Esperas saber programar un boombang desde 0 sin saber nisiquiera como funciona un bucle?  .
Tu problema principal es que solo lees una vez lo que el cliente te envía y que estas reinventando la rueda.

Tienes que crear un proxy entre cliente y servidor.
El proxy escucha lo que envia el cliente y lo que envia el servidor y haces de intermediario entre ambos, de esa forma puedes leer todos los paquetes que se envían.

Perdoan por no responder antes..
A ver, se me ha ocurrido que una forma de detectar malware es escanear todos los procesos abiertos buscando ciertos patrones que siguen, por ejemplo un string.
He encontrado una base de datos que tiene todos estos datos, patrones en memoria, hash de virus, etc y me gustaría hacer un programa que buscase estos strings/patrones en la memoria de todos los programas.
Pero no hace falta que sean exactamente todos, los programas x64 bits pueden ser saltados.
La cosa es que el codigo que he proporcionado siempre me devuelve 0 o se queda atascado  
Basicamente lo que quiero hacer es un loop en la memoria de cada proceso y mirar si contiene alguno de los strings que yo tengo en la base de datos, y si así fuese, el proceso seria clasificado como malware.

Hola, estoy programando un programa que detecta malware según ciertos patrones que tenga.
La verdad es que soy novato con lo relacionado con memoria y no estoy seguro de cómo hacerlo, estoy interesado en escanear cadenas/strings que son estáticas en la memoria pero no he encontrado ninguna forma eficaz de hacerlo.

He encontrado esto en un foro, pero siempre devuelve 0

            public static List<MEMORY_BASIC_INFORMATION> MemReg { get; set; }
 
            public static void MemInfo(IntPtr pHandle)
            {
                IntPtr Addy = new IntPtr();
                while (true)
                {
                    MEMORY_BASIC_INFORMATION MemInfo = new MEMORY_BASIC_INFORMATION();
                    int MemDump = VirtualQueryEx(pHandle, Addy, out MemInfo, Marshal.SizeOf(MemInfo));
                    if (MemDump == 0) break;
                    if ((MemInfo.State & 0x1000) != 0 && (MemInfo.Protect & 0x100) == 0)
                        MemReg.Add(MemInfo);
                    Addy = new IntPtr(MemInfo.BaseAddress.ToInt32() + MemInfo.RegionSize);
                }
            }
            public static IntPtr _Scan(byte[] sIn, byte[] sFor)
            {
                int[] sBytes = new int[256]; int Pool = 0;
                int End = sFor.Length - 1;
                for (int i = 0; i < 256; i++)
                    sBytes[i] = sFor.Length;
                for (int i = 0; i < End; i++)
                    sBytes[sFor[i]] = End - i;
                while (Pool <= sIn.Length - sFor.Length)
                {
                    for (int i = End; sIn[Pool + i] == sFor[i]; i--)
                        if (i == 0) return new IntPtr(Pool);
                    Pool += sBytes[sIn[Pool + End]];
                }
                return IntPtr.Zero;
            }
            public static IntPtr AobScan(string ProcessName, byte[] Pattern)
            {
                Process[] P = Process.GetProcessesByName(ProcessName);
                if (P.Length == 0) return IntPtr.Zero;
                MemReg = new List<MEMORY_BASIC_INFORMATION>();
                MemInfo(P[0].Handle);
                for (int i = 0; i < MemReg.Count; i++)
                {
                    byte[] buff = new byte[MemReg[i].RegionSize];
                    ReadProcessMemory(P[0].Handle, MemReg[i].BaseAddress, buff, MemReg[i].RegionSize, 0);
 
                    IntPtr Result = _Scan(buff, Pattern);
                    if (Result != IntPtr.Zero)
                        return new IntPtr(MemReg[i].BaseAddress.ToInt32() + Result.ToInt32());
                }
                return IntPtr.Zero;
            }