-[ 0x04 ]--------------------------------------------------------------------
-[ HIJACKING ]---------------------------------------------------------------
-[ by ~AtilA~ ]-------------------------------------------------------SET-13-

HIJACKING 
 
Espero que el articulo os sirva para entender un poco mejor los beneficios
que el IP-Spoofing tiene con respecto a otros metodos de sniffing. He sacado 
informacion de varios articulos sober el tema, y he puesto lo que me parece 
mas util, pero si quieres aprender mas sobre IP-Spoofing te recomiendo que te 
leas la Phrack, en el #48 hay un articulo muy bueno. Tambien es aconsejable
que sepas algo sobre el protocolo TCP/IP, puesto que es la base de internet
y te servira de mucho. Bueno,  dejando a un lado los consejos que os habran
dado mil veces, y me dedico a explicar lo que es el HIJACKING.
 
INTRODUCCION 
Hija... que?. HIJACKING. Es un metodo por el cual podemos "robar" una
conexion generada por un aplicacion de red iniciada por un cliente,
generalmente, la aplicacion de red que mas nos interesa para estos fines es
el TELNET., y lo que vamos ha hacer es hacernos pasar por el cliente
que ha iniciado esa aplicacion, sustituyendolo y tomando los mandos de la
aplicacion, haciendo con ella lo que nos plazca. 
Para hacer hijacking, podemos hacerlo de dos maneras, la primera y la mas 
aconsejable es usar un programa que hayas conseguido en la red, y la otra es 
hacerlo manualmente aunque hay que saber bien lo que se esta haciendo, puesto 
que la rapidez es imprescindible.  
  
Para explicar esto mejor, pondre un ejemplo ficticio de este metodo,  
vamos a suponer que la maquina cliente tiene la direccion IP 195.1.1.1, el 
servidor tiene la direccion IP 194.1.1.1 (el servidor es la maquina a la cual 
el cliente se conecta para hacerle un telnet), y la maquina Hijacker tiene la 
direccion 195.1.1.3.  
 
EMPEZAMOS EL ESPIONAJE 
El cliente, tras enviar una peticion de conexion al puerto 23 y haber
iniciado la sesion con el servidor, (no voy a explicar paso a paso el trafico
y la manipulacion de estos paquetes por que es irrelevante para lo que
queremos hacer) comienza escribiendo un simple "finger", para saber quien
esta conectado al servidor. 
Lo primero que envia el cliente es el caracter "f", y para ello se genera un 
paquete TCP con la siguiente estructura : (he omitido algunos campos, porque 
no son importantes para entender la explicacion) 
 
1er PASO (Sentido: {Cliente -------> Servidor}) 
 
TCP paquet ID ->IP-Cliente.puerto:195.1.1.1.1025->IP-Server.puerto:194.1.1.1.23 
*SEQ ------------------> 3DF454DA 
**ACK -----------------> F454FDF5 
Flag ------------------> -AP---  
Paquet ID ----->IP-Cliente.puerto:195.1.1.1.1025->IP-Server.puerto:194.1.1.1.23 
DATA ------------------> AE 00 ) 33 GF (bla ,bla, bla) 
 
* SEQ: Los datos de este campo son usados para definir la secuencia de los 
paquetes enviados. Esta en hexadecimal y el server los que hara con estos 
datos es ponerlos en el campo ACK del paquete que envie al cliente.
El hijacking es basicamente predecir los datos de este y del campo ACK para
enviar paquetes falsos que seran aceptados por el servidor sin que note nada
anormal.
** ACK: Este campo de datos contiene una cifre hexadecimal que se usa por el 
cliente y el servidor para autentificar (mas o menos) los paquetes enviados. 
 
Este paquete es enviado por el ***modulo IP de la maquina cliente , hacia la 
red, con el destinatario de la maquina servidor. El paquete viajara por la
red y los modulos IP de los ordenadores conectados a la red compararan la
direccion de destino del paquete con la suya, de tal manera que si coinciden
quiere decir que el paquete ha llegado a su destino (al Servidor) y si no
coinciden lo rechazan. 
Pues llegados a este punto os preguntareis... como coño consigo la informacion
del paquete enviado por el cliente?. Facil, con un sniffer. Cualquier sniffer
decentillo te da toda la informacion necesaria para llevar a cabo nuestros 
planes. El sniffer intercepta el paquete y guarda su informacion, pero no lo 
modifica, gracias a esa informacion podemos darnos cuenta que el Cliente esta 
usando el Telnet. 
 
***modulo IP: Es el encargado de comprobar el destinatario y el remitente del 
paquete, entre otras cosas. Es el modulo central de la escalera de protcolos.   
 
2º PASO (Servidor -------> Cliente) 
 
El servidor, traduce el contenido del paquete, y lo ejecuta, escribiendo la
"f" en la shell, y envia otro paquete al cliente, que en realidad es un
"echo"  del recibido por el cliente para que el cliente se cerciore de que
el paquete ha llegado y ha sido ejecutado.  
 
TCP paquet ID->IP-Server.puerto:194.1.1.1.23->IP-Cliente.puerto:195.1.1.1.1025  
SEQ -------------------> F454FDF5 
ACK -------------------> 3DF454E4 
Flags -----------------> -AP--- 
Paquet ID ---->IP-Server.puerto:194.1.1.1.23->IP-Cliente.puerto:195.1.1.1.1025  
DATA ------------------> AE 00 ) 33 GF (bla ,bla, bla) 
 
3er PASO (Cliente -----> Servidor) 
 
El cliente enviara un paquete ACK, como respuesta al paquete que acaba de
enviar el servidor, este paquete no contendra DATA. Solo sirve para confirmar
que ha llegado el paquete del servidor. 
 
TCP paquet ID->IP-Cliente.puerto:195.1.1.1.1025->IP-Server.puerto:194.1.1.1.23 
SEQ -------------------> 3DF454E4 
ACK -------------------> F454FDFF 
Flag ------------------> -A----  
Paquet ID ---->IP-Cliente.puerto:195.1.1.1.1025->IP-Server.puerto:194.1.1.1.23 
DATA ------------------> (2 bytes de data, que no tienen valor) 
 
4º PASO (Hijacker ------> Servidor) 
 
Ahora es cuando debemos enviar nuevos datos al servidor haciendonos pasar por
el Cliente.
Para lograrlo debemos calcular la secuencia del paquete "spoofed" que
enviaremos de los numeros SEQ y ACK, basandonos en el primer paquete que
hemos interceptado (¿sniffado? :-?). Debemos enviar datos al servidor para
que no se ejecute el comando que el cliente estaba introduciondo (que por
ahora solo habia enviado la "f" del "finger", con lo cual sea mas facil),
para que esto ocurra enviamos retornos de carro, o lo que nos plazca. El
paquete tendra este aspecto: 
 
TCP paquet ID->IP-Cliente.puerto:195.1.1.1.1025->IP-Server.puerto:194.1.1.1.23 
SEQ -------------------> 3DF454E4 
****ACK ---------------> F454FE09 
Flag ------------------> -AP---  
Paquet ID ---->IP-Cliente.puerto:195.1.1.1.1025->IP-Server.puerto:194.1.1.1.23 
DATA ------------------> AE 00 ) 33 GF (bla ,bla, bla) 
 
**** ACK ---------> F454FE09 = F454FDFF + 0A. Esto quiere decir que podemos 
enviar cuantos paquetes queramos puesto que, sabemos como falsearlos. Por 
cierto la cantidad que se le suma al numero que hemos recibido (SEQ), para 
meterlo en le campo del ACK es el tamaño de los datos, del paquete que vamos a
enviar (un poco lioso, ya lo se pero leelo bien y medita). Como ejemplo vamos 
a imaginar que somos el Hijacker, y que hemos interceptado el paquete que el 
servidor le envio al cliente el segundo paso, de todo lo que le envio lo que 
mas nos interesa es el numero del campo  SEQ , F454FDF5, despues el Cliente 
envio  un paquete ACK, con el numero F454FDFF, que es el F454FDF5 + el tamaño
de los datos que en hexadecimal es 0A, y por ultimo el Hijacker (nosotros), 
enviamos un paquete con el ACK F454FDFF + el tamaño de los datos, que tambien 
es 0A.  
 
Una vez logramos predecir la secuencia de numeros del SEQ/ACK podemos enviar
los comandos que queramos sin preocupacion, y lo gracioso es que el Cliente
no recibira nada y se creera que se le ha colgado la conexion, como suele
pasar a veces sin necesidad de ningun hacker de por medio. 
 
Hasta aqui hemos llegado, si algo no ha quedado bien explicado, o si se me ha 
olvidado algo en el tintero, lo siento mucho, porque como os pillen, jejeje. 
 
 
 
                                ~AtilA~