//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
			HACKING METHODE : LE SPOOFING DE CONNECTION
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

 Le but de cet article est de vous expliquer une methode fatal de hacking : 
le spoofing !
 Noter que je n'ai aucunement la pretention d' apprendre quoi que ce soit a 
toute personne qui s'interesse depuis un certain temps au hacking et qui 
(comme tout bon hacker) en maitrise l'utilisation et le codage. Cet article 
s'addresse donc principalement aux newbies et a tout ceux desireux d'apprendre
l'efficacite d'une telle methode.

Preliminaire :
 Le spoofing consiste a voler l'addresse IP d'une machine c'est a dire a se 
faire passer aux yeux d'une machine B pour une machine A.
 Pour mettre en oeuvre une telle pratique , il nous faut d'abord nous 
interesser à l'etablissement d'une connection TCP/IP :
UNE CONNECTION TCP/IP SE FAIT EN TROIS ETAPES :
1 La machine A ( qui veut etablir une connection avec B) envoie un paquet ,avec 
le bit SYN placé, à B ainsi que son ISN ( qu'on note ISNa )

		A ---------SYN + ISNa-------->  B

2 La machine B repond par un paquet, avec les bits SYN et ACK placés , muni de 
son ISN ( qu'on note ISNb ) ainsi que de l'ISNa pour ainsi "prevenir A" 
qu'elle connait bien son ISN.

		A <--SYN + ACK + ISNb + ISNa--  B

3 La machine renvoie finalement un paquet avec le bit ACK place et l'ISNb pour 
prevenir B qu'elle a bien recu son ISN.

		B ---------ACK + ISNb-------->  A

Voila si vous voulez plus de precision, allez voir l'article de Scientist.

LeT's spOOf !

Machine A : 192.156.0.23
Machine B : 191.142.23.15

Mettons que la machine A ait des droits rlogin sur la machine B.
Notre but est simple : nous faire passer pour A aux yeux de B et d'ainsi etablir
une connection, d'obtenir un shell (par spoof) puis un ptit roOt.  

Ok alors comment faire ? D'abord envoyer un paquet SYN avec notre ISN et
l'addresse IP de la machine A , c pas si simple !

En effet si on envoie un tel paquet a B , celle ci va repondre à la machine A
(la vraie) par un packet SYN/ACK avec son ISN et le notre l'ISNh.

si on note H la machine du hacker , tout se passe suivant le schema suivant :

1		H --------SYN + ISNh-------> B
				avec 
			addresse IP de A

2		B --SYN/ACK + ISNh + ISNb--> A



La machine A qui n'a pas envoye de paquet SYN repond a B par un datagramme erreur :
B coupe alors la connection : bye bye shell !
CONCLUSION : La premiere etape du spoofing consiste à deconnecter la machine A ;-))
pour se faire utiliser une DOS classique (cf par exemple article smurf de SLy)

Une fois que la machine A est hors service , on construit un paquet SYN ( la prog c
est classique toutefois n oublier pas de remplir la structure iphdr avec les infos
de A ! )
C alors qu'intervient le probleme majeur du BLIND SPOOFING : 
reflechissons : B va repondre à la machine A (qui est alors hors service) en lui 
envoyant l'ISNh et l'ISNb et va attendre le paquet ACK final CONTENANT L'ISNb :
la on a un probleme ! voyons tout ceci en schema :

1 ETAPE 1 : on met A HORS SERVICE  

 		H -----------DOS-----------> A

2 ETAPE 2 : on envoie un paquet SYN à B en nous faisant passer pour A

		H -----SYN + ISNh----------> B
		        IP de A

3 ETAPE 3 : B est alors persuade que A veut etablir une connection, elle renvoie 
donc un SYN/ACK à A ( qui ne repondra jamais car Out of Service)

		B --SYN/ACK + ISNh + ISNb--> A (OOS)

4 ETAPE 4 : B attend alors un paquet ACK de la part de A pour etablir une 
connection. En theorie il faut donc que H lui envoie ce paquet au nom de A:

		H -------ACK + ISNb--------> B

Le probleme est que , dans ce dernier paquet, il nous faut renvoyer l'ISNb que nous
ne connaissons pas ! (rappelez vous l'ISNb a été renvoyé à A)
On distingue alors deux cas :
	- on est sur un reseau local : un simple sniffer nous permet alors d'obtenir 
l'ISNb : on parle de Non-BLIND SPOOFING.
	- on est sur internet : il nous faut deviner l'ISNb : on parle de 
BLIND SPOOFING.

Comment deviner l'ISNb ?

on pourrait croire (et je dois dire asez logiquement) que l'ISNb est toujours nul.
Ceci poserait cependant certains problemes: imaginer un serveur qui accepte 
plusieurs connections à la fois , les paquets pourraient etre melanges !
L'ISN n'est pas non plus tirer au hasard : en effet on verrait alors apparaitre 
le meme probleme que precedemment.
En realite, l'ISN obeit EN GENERAL à un algorithme simple :
il augmente de 128 000/secondes et de 64 000 a chaque connection

Finalement pour obtenir l'ISNb il suffit de taper plusieurs connections avec B, 
noter l'ISNb et essayer de deviner le prochain.
Au final voila comment on spoof B :


		1		H -----Connection pour-----> B
					obtenir le prochain
						ISNb


		2 		H -----------DOS-----------> A


		3		H -----SYN + ISNh----------> B
				        IP de A


		4		B --SYN/ACK + ISNh + ISNb--> A (OOS)


		5		H -------ACK + ISNb--------> B


B ouvre alors une connection avec A.
Si maintenant on a spoofe le port rlogin et que A avait des droits r* sur B
il nous suffit d'envoyer de zolis paquets AU NOM DE A qui ecrivent notre IP
dans son $HOME/.rhost (finger A@machine B pour obtenir le home directory) et 
voila :
- on ferme la connection avec B.
- puis : 

Par4noID$ rlogin -l userA IP_de_B
Machine_B$  
Un ptit buff overflow pour la forme et:
Machine_B#