Código de C/Visual C - ESNIFFER MODIFICADO

/*

*********ESNIFER********
EJECUTAR BAJO ROOT
*******************************************
Hilario Iglesias Martínez.
-------------------------------------

snifo-paquetes.c
------------------------------------
COMPILACIÓN BAJO CONSOLA DE LINUX:
-----------------------------------
$ gcc esnifo-paquetes.c -lpcap -o esnifo-paquetes
----------------------------------------
Para el funcionamiento de este programa, deberán estar
instaladas las librerías pcap.
Forma de instalarlas bajo Linux:
sudo apt-get update
sudo apt-get install libpcap-dev

Para saber las tarjetas presentes en el ordenador
bajo linux se puede utilizar el comando ifconfig.
Debe estar instalado el paquete net-tools.
Puede instalarse en Linux Ubuntu con este comando:
sudo apt install net-tools.
El programa al inicio hace una llamada a dicho
comando, indicando las caracteristicas, y parámetros
de red.
Se puede snifar y probar con cualquier tarjeta,
incluida la ethernet, LOOPBACK. wifi...
El programa obtiene una tarjeta de red por defecto.
El comado habitual seŕia.
sudo ./snifo-paquetes [-tu tarjeta de red, IP OBJETIVO, página web, etc-]
Ejeemplos:
$ sudo ./esnifo-paquetes [Sin atributos]
$ sudo ./esnifo-paquetes enxd03745c56b84
$ sudo ./esnifo-paquetes 192.168.0.0
$ sudo ./esnifo-paquetes www.paginacualquiera.com
En caso de esnifar una página web, para que el esnifer
sea efectivo se deberá acceder a dicha página,
con el programa activado, pidiendo el
endenamiento de algún enlace, con el fin de
que haya tráfico de red más intenso.

************************************************
El programa fue realizado en plataforma
LINUX Ubuntu 20.04.4 LTS.
Bajo el standard ANSI C.-C-11
+++++++++++++++++++++++++++++++++++++++++

Dependiendo de la platafaorma pueden
existir algunos errores de compilación tipo warning,
que no son importantes.
---------------------------------------------------
****************************************************
EJEMPLO DE ESNIFADO - (El dispositivo de red loopback).
$ sudo ./esnifo-paquetes lo
---------------------------------
Si se quieren guardar los esnifados en un fichero de
texto, se puede utilizar este comando.
$ sudo ./esnifo-paquetes > mifichero.txt
Se deberá crear el fichero vacio mifichero.txt.
El programa esnifa por defecto 80 paquetes,
esa cantidad se puede modificar según preferencias,
y recompilar el programa.
Para salir de consola con Control C.

++++++++++++++++++++++++++++++++++++++++++++++
SALIDA EJEMPLO POR CONSOLA LINUX
-----------------------------------------
Tarjeta de red wifi: wlp1s0
Dirección IP: 192.168.0.0
Mascara de Red: 255.255.255.0
***********************************************
*****ESPERA,ESTOY ESNIFANDO PAQUETES
****************************************************
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:0 DE: 78 BYTES******
****************************************************************
45 00 00 4e 51 49 40 00 32 06 39 32 8c 52 71 19 | [email protected].
c0 a8 00 1b 01 bb bd 78 92 1a 73 e1 4f c5 1d 01 | .......x..s.O...
80 18 00 46 40 68 00 00 01 01 08 0a 7f 91 4d 56 | [email protected]
cb a9 16 b6 17 03 03 00 15 c1 51 f9 e2 7d ba 7a | ..........Q..}.z
7b b7 85 cf 31 d7 5d 1f 6f cc b0 1c c7 63 | {...1.].o....c
****************************************************************
****ESNIFAMOS DE LA TARJETA: wlp1s0 -> EL PAQUETE N°:1 DE: 52 BYTES******
****************************************************************
45 00 00 34 51 4a 40 00 32 06 39 4b 8c 52 71 19 | [email protected].
c0 a8 00 1b 01 bb bd 78 92 1a 73 fb 4f c5 1d 1f | .......x..s.O...
80 10 00 46 ec 07 00 00 01 01 08 0a 7f 91 4d c0 | ...F..........M.
cb aa 01 16 | ....
-----------------------------------------------------------
**********************************************************************
*Esnifer Tarjeta-red: enxd03745c56b84 -> Paquete N°:77 de: 339 Bytes*
**********************************************************************
45 00 01 53 22 FC 40 00 3A 06 A5 0D 17 3A 9F 9E | E..S".@.:....:..
C0 A8 00 1B 01 BB D0 B8 A2 62 1F D6 E3 BB 31 41 | .........b....1A
80 18 01 F9 E0 41 00 00 01 01 08 0A 2D AD 14 68 | .....A......-..h
6D DC C8 8A 17 03 03 01 1A E7 65 88 00 40 73 DD | m.........e..@s.
E2 69 B7 58 33 41 05 F3 ED 31 C5 E3 81 A5 02 25 | .i.X3A...1.....%
2B B1 66 DD EF 1A 05 7C A3 A1 34 08 E5 60 51 66 | +.f....|..4..`Qf
68 4D 18 B5 49 A4 F9 5C AA 9C 0D 3F 15 97 F6 35 | hM..I..\...?...5
D6 2C 5F 1D 46 09 A8 BB FF 24 95 11 2D E0 99 42 | .,_.F....$..-..B
7A AF B5 9A 7F 1A CA C0 9C D6 BC 53 C9 4F E9 E0 | z..........S.O..
0B EA D2 F4 00 9D 3B EA 95 53 E1 AF 7B E5 E0 CA | ......;..S..{...
D9 32 DE 7E C4 96 77 03 B3 C4 3B 80 EF 1F 46 B5 | .2.~..w...;...F.
EB EE 77 80 2A A7 F2 5C 23 BC 04 DF A5 AA D6 66 | ..w.*..\#......f
3B C3 9E A2 56 66 D9 EE BB F7 16 05 DE 8C 0E 01 | ;...Vf..........
E5 FA C9 62 2E F8 4D DA 39 B7 CC FF 8E 77 20 7E | ...b..M.9....w ~
33 48 AA 73 23 4D AC 52 42 F6 D4 09 D2 E6 21 E5 | 3H.s#M.RB.....!.
F1 A4 8A 6F A4 00 25 8A F4 8A 74 EE 13 6C 0E E0 | ...o..%...t..l..
DA CC 56 5D 1C 7E B9 00 96 BB 4E AB DC 11 5C 61 | ..V].~....N...\a
30 1C 79 62 61 90 63 63 FF C3 76 7B 98 BF C9 C1 | 0.yba.cc..v{....
D2 51 7B FF 49 DE 24 D3 21 61 F2 DE 0F F7 28 E3 | .Q{.I.$.!a....(.
B1 19 FD 69 58 C6 1F 5C B2 32 DD 69 54 C9 86 2F | ...iX..\.2.iT../
53 5B 35 68 53 D0 07 A2 AE 97 59 95 C8 E7 5C 8E | S[5hS.....Y...\.
26 CE 1C
-----------------------------------------------------------------
****************************************************************

-----------------------------------------------------

//---------------------

/* esnifo-paquetes.c*/

//--------------------

#include<pcap.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<sys/socket.h>

#include<netinet/in.h>

#include<arpa/inet.h>

#include<arpa/inet.h>

#include<string.h>

#include<unistd.h>

#define ROJO "\x1b[31m"

#define AMARILLO  "\x1b[33m"

#define CYAN    "\x1b[36m"

#define VERDE        "\x1b[32m"

/*Llamada a mensajes*/

void los_mensajes(char *mensaje)

 {

   char error_mensaje[100];

   strcpy(error_mensaje, "Se ha cometido un error: ");

   strncat(error_mensaje, mensaje, 83);

   perror(error_mensaje);

   exit(-1);

}

/* Error chequeado por la función  malloc(), en la

asignación dinámica de memoria, definidas en stdlib.h

*/

void *ec_malloc(unsigned int size) {

   void *ptr;

   ptr = malloc(size);

   if(ptr == NULL)

      los_mensajes("utilizamos ec_malloc() para la asignación de memoria");

   return ptr;

}

int main(void)

{

char *tarjeta_red;

int  salida;    /* Salida del comando */

char comando[60];

    char ip[13]; /*Reserva espacio ip*/

    char subnet_mask[13];/* Reservamos espacio en memoria para mascara de red*/

    bpf_u_int32 ip_raw;  /* Nuestra IP */

    bpf_u_int32 subnet_mask_raw; /* La máscara de red de nuestro dispositivo rastreador */

    int lookup_return_code;/*número codigo de error*/

    char error_buffer[PCAP_ERRBUF_SIZE];

    /* definido en pcap.h

    cadena de errores */

    struct in_addr address; /* Estructura usada por cada ip y subnet */

    /* Este tramo de código está anulado por

    conflictos con la función pcap_lookupdev(error_buffer),

    ya que da error tipo warning: ‘pcap_lookupdev’

    de compilación. Se sugieren ideas.

    **************************************

    tarjeta_red = pcap_lookupdev(error_buffer);

    if (tarjeta_red == NULL) {

        printf("%s\n", error_buffer);

        return 1;

    }

    ****************************************

    */

 printf(CYAN"***********CARACTERISTICAS DE LA RED**********\n" );

 sprintf (comando, "ifconfig");

 salida = system (comando);

    /* Obtener información del dispositivo */

    lookup_return_code = pcap_lookupnet(

        tarjeta_red,

        &ip_raw,

        &subnet_mask_raw,

        error_buffer

    );//Detectamos errores

    if (lookup_return_code == -1) {

        printf("%s\n", error_buffer);

        return 1;

    }

    address.s_addr = ip_raw;

    strcpy(ip, inet_ntoa(address));

    if (ip == NULL) {

        perror("inet_ntoa"); /* Imprimimos si hubiera algún error */

        return 1;

    }

    /* Ahora vamos a optener la máscara de subred en formato

     legible  */

    address.s_addr = subnet_mask_raw;

    strcpy(subnet_mask, inet_ntoa(address));

    if (subnet_mask == NULL) {

        perror("inet_ntoa");

        return 1;

    }

//Imprimimos la tarjeta de red, la ip, y la máscara de red

    printf("Tarjeta de red: %s\n", tarjeta_red);

    {

    printf("**********************************************************************\n");

    printf(ROJO"----------------------------------------------.\n**");

    printf("****¡EN 8 SG. SE VA A INICIAR EL ESNIFADO. MIRA TU CONFIG DE RED!.****\n");

    printf("**********************************************************************\n");

    printf(VERDE" " );

    sleep(8); //Pausa de 10 segundos

/*

Declaramos constante i de contador, la reserva

de buffer de 10000 bytes

para almacenar los paquetes, y el descriptor para BSD */

int i, recv_length, descriptor;

u_char buffer[10000];/*dimensión de buffersuficiente

para que no se produzca "stack smashing detected"*/

if ((descriptor = socket(PF_INET, SOCK_RAW, IPPROTO_TCP)) == -1)

los_mensajes("EJECUTAR COMO ROOT");

for(i=0; i < 80; i++) { /*En principio establezco la salida para 20 paquetes.

    para salir de consola pulsar control C*/

recv_length = recv(descriptor, buffer, 8000, 0);

printf("\n**********************************************************************");

printf("\n*Esnifer Tarjeta-red: %s -> Paquete N°:%i de: %d Bytes*",tarjeta_red,i, recv_length);

printf("\n**********************************************************************\n");

/*

Este trozo de código a continuación,

vuelca la memoria sin procesar en bytes hexadecimales

y formato dividido imprimible.

En ella se programan, entre otros, los criterios de

impresión para que puedan ser legible,

de los volcados esnifados a la red.

unsigned char buffer:almacenar datos binarios arbitrarios

unsigned int length:Indicamos longitud

*/

unsigned char byte;

unsigned int i;

char Codigo_ascii[17];

Codigo_ascii[16] = '\0';

for (i = 0; i < recv_length; ++i) {

    byte = buffer[i];

        printf("%02X ", ((unsigned char*)buffer)[i]);

        if (((unsigned char*)buffer)[i] >= ' ' && ((unsigned char*)buffer)[i] <= '~')

         {

            Codigo_ascii[i % 16] = ((unsigned char*)buffer)[i];

        } else {

            Codigo_ascii[i % 16] = '.';

        }

        if ((i+1) % 8 == 0 || i+1==recv_length) {

            printf(" ");

            if ((i+1) % 16 == 0) {

                printf(" |  %s \n", Codigo_ascii);

            }

            }

            }

            printf("\n" );

}

}

}