Hola a todos, quizas me podáis guiar un poco con todo esto. Mis propósitos son educacionales, si quisiera usar SSLstrip con malas intenciones, no sería necesario crear este tema.

Me gustaría poderlo emular en windows, para ello usaré C#, el comando netsh para pasar los datos al puerto donde escuchará el sslstrip, y me he descargado el winpcap, lo que quiero es redirigir los paquetes a el puerto donde escucha el sslstrip, ¿como puedo hacerlo? También tenia pensado usar py2exe para pasar el programa de Moxie a .exe, y no complicarme la vida intentandolo emular en C#, ¿nadie lo ha intentado antes? ¿alguna idea?

Según me ponga a ello iré subiendo actualizaciones y mis avances.

Si alguien quiere ayudarme a alcanzar este objetivo y poderlo compilar, le invito a comentar en este tema, a ver si entre todos podemos hacer algo, yo cuando me ponga a ello actualizaré mis avances en este tema.

Saludos.

Hola Kub0x, mira he estado probando primero a recibir los paquetes con el programa C#:

Me estoy ayudando con este link: winpcap C#

Utiliza la librería winpcap de /system32/ para extraer las funciones que permiten extraer los paquetes de la red con facilidad, como usa más adelante en el código que está en el link.

Simplemente hay que importarlas así:

const int PCAP_ERRBUF_SIZE = 256;
        const int PCAP_OPENFLAG_PROMISCUOUS = 1;
        const string PCAP_SRC_IF_STRING = "rpcap://";
 
        [DllImport("wpcap.dll")]
        static extern IntPtr pcap_open(string source, int snaplen, int flags, int read_timeout, IntPtr auth, ref IntPtr errbuff);
        [DllImport("wpcap.dll")]
        static extern void pcap_freealldevs(IntPtr alldevs);
        //auth is a managed pointer to a structure of type pcap_rmtauth
        [DllImport("wpcap.dll")]
        static extern int pcap_findalldevs_ex(string source, IntPtr auth, ref IntPtr alldevs, ref IntPtr errbuff);
        [DllImport("wpcap.dll")]
        static extern int pcap_next_ex(IntPtr conn, ref IntPtr header, ref IntPtr packetdata);
        [DllImport("wpcap.dll")]
        static extern void pcap_close(IntPtr conn);

No da error, en caso de que no estaría en ese directorio bastaría con incluirla al proyecto, que no es el caso ya que es la librería estándar "para ver paquetes de red" de windows.

Tras leer y buscar, se recomienda usar esta librería antes que tratar de crear un programa que obtenga los paquetes, básicamente por el filtrado que hacen ya sus funciones de los mismos.

Por lo que creo que es recomendable usarla, al código le faltan algunas funciones que "nos deja como tarea".

Sin embargo, el problema de como conseguir los paquetes de red queda resuelto con la librería wpcap, y en el código ya podemos hacer uso de sus funciones. (queda saberlas llamar con los datos necesarios).

Entonces tendremos acceso a los paquetes de la red, si realizamos un MITM inyectando paquetes dhcp a los usuarios de la red, winpcap nos debería de devolver sus paquetes es allí donde los modificariamos y conectariamos con el servidor (puerta de enlace).

Pasaríamos los paquetes por el sslstrip, pasandolos a su puerto de escucha con la ejecución del comando para windows netsh.

Poco a poco, saludos.

Edito: estaría bien mirar esto ante de usar winpcap.

Os dejo el código que debería mostrarme las interfaces de red, los drivers:

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Drawing;
using System.IO;
using System.ComponentModel;
 
[StructLayout(LayoutKind.Sequential)]
        struct pcap_if
        {
            public IntPtr next;
            public string name; //name of device
            public string description; //description of device
            public pcap_addr addresses;
            public int flags;
        }
 
        [StructLayout(LayoutKind.Sequential)]
        struct pcap_addr
        {
            public IntPtr next;
            public IntPtr addr;
            public IntPtr netmask;
            public IntPtr broadaddr;
            public IntPtr dstaddr;
        }
 
        [StructLayout(LayoutKind.Sequential)]
        struct sockaddr
        {
            public Int16 sa_family;
            public string sa_data;
        }
 
        [StructLayout(LayoutKind.Sequential)]
        struct pcap_pkthdr
        {
            public timeval ts;
            public int caplen; //captured length
            public int len; //packet length
        }
 
        [StructLayout(LayoutKind.Sequential)]
        struct timeval
        {
            public int tv_sec;
            public int tv_usec;
        }
 
        //some credentials if we want to capture packets remotely
        //CAN BE VERY USEFUL!!
        [StructLayout(LayoutKind.Sequential)]
        struct pcap_rmtauth
        {
            public int type;
            public string username; 
            public string password;
        };
 
 
 
        static class Program
        {
            const int PCAP_ERRBUF_SIZE = 256;
            const int PCAP_OPENFLAG_PROMISCUOUS = 1;
            const string PCAP_SRC_IF_STRING = "rpcap://";
 
            [DllImport("wpcap.dll")]
            static extern IntPtr pcap_open(string source, int snaplen, int flags, int read_timeout, IntPtr auth, ref IntPtr errbuff);
            [DllImport("wpcap.dll")]
            static extern void pcap_freealldevs(IntPtr alldevs);
            //auth is a managed pointer to a structure of type pcap_rmtauth
            [DllImport("wpcap.dll")]
            static extern int pcap_findalldevs_ex(string source, IntPtr auth, ref IntPtr alldevs, ref IntPtr errbuff);
            [DllImport("wpcap.dll")]
            static extern int pcap_next_ex(IntPtr conn, ref IntPtr header, ref IntPtr packetdata);
            [DllImport("wpcap.dll")]
            static extern void pcap_close(IntPtr conn);
            static void Main()
            {
                MessageBox.Show("hola");
                pcap_if d;
                IntPtr alldevs=IntPtr.Zero;
                //IntPtr d;
                int i=0;
                //char errbuf[PCAP_ERRBUF_SIZE];
                IntPtr errbuf = IntPtr.Zero;
 
                /* Retrieve the device list from the local machine */
                if (pcap_findalldevs_ex(PCAP_SRC_IF_STRING, IntPtr.Zero /* IntPtr.Zero auth is not needed */, ref alldevs, ref errbuf) == -1)
                {
                    Console.WriteLine("Error in pcap_findalldevs_ex: {0}\n", errbuf);
                    Application.Exit();
                }
                /* Print the list */
 
                while(alldevs!=IntPtr.Zero)
                {
                    d=(pcap_if)Marshal.PtrToStructure(alldevs, typeof(pcap_if));
                    MessageBox.Show(d.name + d.description);
                    Console.WriteLine("%d. %s", ++i, d.name);
                    if (d.description!="")
                        Console.WriteLine(" (%s)\n", d.description);
                    else
                        Console.WriteLine(" (No description available)\n");
                    alldevs=d.next;
                }
 
                if (i == 0)
                {
                    MessageBox.Show("\nNo interfaces found! Make sure WinPcap is installed.\n");
                    return;
                }
 
                /* We don't need any more the device list. Free it */
                //pcap_freealldevs(alldevs);
            }
        }

Sin embargo no sale nada, ¿alguien sabe porque? Me dice que no encuentra ninguna interfaz que me asegure de que tengo winpcap instalado??, vamos a ver yo uso wpcap.dll de windows para cargar esas funciones, porque necesitaria el winpacap? y no viene intalado?, raro.

Edito:Olvidad lo anterior, FUNCIONA!!!! necesitaba permisos de admin claro!!!!

Ya he listado los "devices", ahora a seguir con lo demás, aunque despues de esto haré un descanso, no estuvo mal por hoy.

---

Hola de nuevo, he conseguido listar las interfaces de red en mi caso son 4, una es la de realtek (la del wifi), es en ella donde quiero escuchar y obtener el trafico.

Pero no obtengo los paquetes con éxito, ¿qué puede fallar? Lo corrí como admin y tampoco funcionaba.

public IntPtr openDevice(pcap_if dev)
        {
            IntPtr fp = IntPtr.Zero;
            IntPtr referrbuff = IntPtr.Zero;
            fp = pcap_open(dev.name, 65536, PCAP_OPENFLAG_PROMISCUOUS, 1000, IntPtr.Zero, ref referrbuff);
            if (fp == IntPtr.Zero)
            {
                return IntPtr.Zero;
            }
            return fp;
        }
 
        public void startCapture(IntPtr fp, AsyncOperation async)
        {
            try
            {
                IntPtr hdr = IntPtr.Zero;
                IntPtr data = IntPtr.Zero;
                int res;
                pcap_pkthdr header = new pcap_pkthdr();
                while ((res = pcap_next_ex(fp, ref hdr, ref data)) >= 0)
                {
                    if (res == 0)
                        continue;
                    header = (pcap_pkthdr)Marshal.PtrToStructure(hdr, typeof(pcap_pkthdr));
                    Console.WriteLine(data.ToString());
                    //asynchronously calls the function OnPacketCaptured with the arguments: data (the captured data) and header.caplen (the length of the data).
                    async.Post(
                        delegate(object e)
                        {
                            object[] inputdata = (object[])e;
                            //OnPacketCapturedEvent((int)inputdata[0], PtrToString((IntPtr)inputdata[1], (int)inputdata[0]));
                        },
                        (object)(new object[] { header.caplen, data }
                    ));
                    hdr = IntPtr.Zero;
                    data = IntPtr.Zero;
                }
            }
            catch (Exception ex)
            {
                pcap_close(fp);
            }
        }

pcap_next_ex(fp, ref hdr, ref data)) siempre devuelve 0, porque no recojo paquetes?

SI FUNCIONA!!!!!! TENGO LOS PAQUETES! ERA OTRA INTERFAZ!!

---

Hola de nuevo, ya tengo los paquetes, abri wireshark y vi que el wifi correspondia al primer servicio de windows y no al de realtek como pensaba (donde no pasaban paquetes).

Este es la funcion que muestra los paquetes:

public void startCapture(IntPtr fp, AsyncOperation async)
        {
            try
            {
                String paquete;
                IntPtr hdr = IntPtr.Zero;
                IntPtr data = IntPtr.Zero;
                int res;
                pcap_pkthdr header = new pcap_pkthdr();
                pcap_addr datos = new pcap_addr();
                while ((res = pcap_next_ex(fp, ref hdr, ref data)) >= 0)
                {
                    paquete = "";
                    if (res == 0)
                        continue;
                    header = (pcap_pkthdr)Marshal.PtrToStructure(hdr, typeof(pcap_pkthdr));
                    paquete += "tamaño paquete teorico: " + header.len + Environment.NewLine;
                    paquete += "tamaño paquete practico: " + header.caplen + Environment.NewLine;
                    paquete += "tiempo recojer paquete (s): " + header.ts.tv_sec + Environment.NewLine;
                    paquete += "tiempo recojer paquete (us): " + header.ts.tv_usec + Environment.NewLine;
                    string merda = (string)Marshal.PtrToStringAnsi(data, header.caplen);
                    paquete += "datos del paquete: " + merda + Environment.NewLine + Environment.NewLine;
                    Console.WriteLine(paquete);
                    hdr = IntPtr.Zero;
                    data = IntPtr.Zero;
                }
            }
            catch { }
            /*try
            {
                IntPtr hdr = IntPtr.Zero;
                IntPtr data = IntPtr.Zero;
                int res;
                pcap_pkthdr header = new pcap_pkthdr();
                pcap_addr datos = new pcap_addr();
                while ((res = pcap_next_ex(fp, ref hdr, ref data)) >= 0)
                {
                    if (res == 0)
                        continue;
 
                    header = (pcap_pkthdr)Marshal.PtrToStructure(hdr, typeof(pcap_pkthdr));
                    datos = (pcap_addr)Marshal.PtrToStructure(data, typeof(pcap_addr));
                    Console.WriteLine(datos.addr.ToString());
                    Console.WriteLine(datos.broadaddr.ToString());
                    Console.WriteLine(datos.netmask.ToString());
                    //asynchronously calls the function OnPacketCaptured with the arguments: data (the captured data) and header.caplen (the length of the data).
                    async.Post(
                        delegate(object e)
                        {
                            object[] inputdata = (object[])e;
                            //OnPacketCapturedEvent((int)inputdata[0], PtrToString((IntPtr)inputdata[1], (int)inputdata[0]));
                        },
                        (object)(new object[] { header.caplen, data }
                    ));
                    hdr = IntPtr.Zero;
                    data = IntPtr.Zero;
                }
            }
            catch (Exception ex)
            {
                pcap_close(fp);
            }*/
        }

Ahora debería de filtrarlos ... el programa parece mostrarme todos los paquetes de la interfaz, alguien sabe como obtener solo los de un puerto?? de todas formas voy progresando gracias a los tutoriales de winpcap y un poco de google (para pasar de c++ a c#).

Esto es un ejemplo de los paquetes que recojo, como estos aparecen decenas diría por segundo si produzco el trafico:


 

Ahora a ver si alguien me ayuda me gustaría filtrarlos, luego quiero hacer ARP POISONING para obtener los paquetes de los demas ordenadores de la red, tengo que saber cuales filtrar y cuales enciar al sslstrip y hacer la inet.

Poco a poco, pero con mas ayuda y codigo sería mas facil (aunque bien que aprendo asi..) no hay mal que por bien no venga, compartir es vivir!!

Saludos!!

De todas maneras creo que no vas a poder editarlos, solo verlos, corregirme si me equivoco, pero  con winpcap solo podrás recibir, "si no estoy equivocado"

Ceo que winpcap solo permite ver el paquete, no interceptarlo y esperar una respuesta

De todas maneras me gusta la idea de crear un sniffer que altere los paquetes en Windows, mediante plugins en c#, quizá deberías crear un proyecto en GitHub