User Tools

Site Tools


hack:testing_for_http_splitting_smuggling

testing_guide

Résumé

Dans ce chapitre, nous allons illustrer des exemples d'attaques que tirent profit de fonctionnalités spécifiques du protocole HTTP, que ce soit en exploitant les faiblesses de l'application Web ou des particularités dans la manière dont les agents interprètent les messages HTTP

Description

Nous allons analyser deux attaques différentes qui ciblent spécifiquement les en-têtes HTTP: HTTP splitting et HTTP smuggling.

  • La première attaque exploite un manque de désinfection de l'entrée qui permet d'insérer un CR / LF dans l'en-tête de la réponse provoquant un «split» de celle-ci en deux différents messages HTTP. L'objectif de l'attaque peut varier d'un empoisonnement du cache à du Cross Site Scripting.
  • Dans la seconde attaque, l'attaquant exploite le fait que certains messages HTTP spécialement conçus peuvent être analysées et interprétés de différentes manières en fonction de l'agent qui les reçoit. Cela exige un certain niveau de connaissances sur les différents agents qui manipulent les messages HTTP (serveur web, proxy, pare-feu) et par conséquent ne seront inclus que dans la section des tests boîte grise

Test Boîte Noire

HTTP Splitting

Certaines applications Web utilisent une partie de l'entrée de l'utilisateur pour générer les valeurs de certaines en-têtes de leurs réponses. L'exemple le plus simple est fourni par les redirections dans laquelle l'URL cible dépend de quelques valeurs soumisent par les utilisateurs. Disons par exemple que l'utilisateur est invité à choisir si il / elle préfère une interface Web standard ou avancé. Le choix sera passé comme un paramètre qui sera utilisé dans l'en-tête de réponse pour déclencher la redirection vers la page correspondante. Plus précisément, si le paramètre «interface» a la valeur «advanced» l'application répondra à ce qui suit:

HTTP/1.1 302 Moved Temporarily
Date: Sun, 03 Dec 2005 16:22:19 GMT
Location: http://victim.com/main.jsp?interface=advanced
<snip>

Lors de la réception de ce message, le navigateur va amener l'utilisateur à la page indiquée dans l'en-tête. Toutefois, si l'application ne filtre pas la saisie de l'utilisateur, il sera possible d'insérer dans le paramètre «interface» la séquence,%0d%0a ce qui représente la séquence CRLF qui est utilisée pour séparer les différentes lignes. À ce stade, nous serons en mesure de déclencher une réponse qui sera interprétée comme deux réponses différentes par toute agent qui arrive à l'analyser, par exemple un cache Web entre nous et l'application. Cela peut être exploité par un attaquant pour empoisonner le cache web afin qu'il fournisse du faux contenu dans toutes les demandes ultérieures. Disons que dans notre exemple précédent, le testeur transmet les données suivantes en tant que paramètre d'interface:

advanced%0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-
Type:%20text/html%0d%0aContent-Length:%2035%0d%0a%0d%0a<html>Sorry,%20System%20Down</html>

La réponse résultant de l'application vulnérable sera donc la suivante:

HTTP/1.1 302 Moved Temporarily
Date: Sun, 03 Dec 2005 16:22:19 GMT
Location: http://victim.com/main.jsp?interface=advanced
Content-Length: 0
...
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 35
*
<html>Sorry,%20System%20Down</html>
 <other data>

Le cache Web verra deux réponses différentes, donc si l'attaquant envoie, immédiatement après la première demande, une deuxième demande pour /index.html, le cache Web fera correspondre à cette demande la deuxième réponse et mettra en cache le contenu, de sorte que toutes les demandes ultérieures visant victim.com/index.html passant par la cache Web recevra le message“system down”. De cette manière, l'attaquant devrait être en mesure d'effectivement polluer le site pour que tous les utilisateurs qui utilisent ce cache web (tout Internet, si le cache Web est un reverse proxy de l'application Web). Alternativement, l'attaquant pourrait retourner à ces utilisateurs un extrait de code JavaScript qui provoquera une attaque de scriptage intersite, par exemple, pour voler les cookies. Notez que bien que la vulnérabilité se trouve dans l'application, l'objectif ici est ses utilisateurs.

Par conséquent, afin de rechercher cette vulnérabilité, le testeur doit identifier toutes les informations de l'utilisateur qui influent sur un ou plusieurs en-têtes de réponse, et vérifier si il/elle peut y injecter une séquence CR + LF. Les en-têtes qui sont les candidats les plus probables pour cette attaque sont les suivantes:

  • location
  • set-cookie

Il faut noter qu'une exploitation réussie de cette vulnérabilité dans un scénario réel peut être assez complexe, car plusieurs facteurs doivent être pris en compte:

Le testeur doit correctement définir les en-têtes dans la réponse falsifiée pour qu'elle soit correctement mise en cache (par exemple, un en-tête Last-Modified avec une date fixée dans l'avenir). Il/elle peut également détruire les versions précédemment mises en cache des pages cibles, par l'émission d'une demande préliminaire avec “Pragma: no-cache” dans les en-têtes de requête L'application, sans filtrage de la séquence CR + LF, peut filtrer d'autres caractères qui sont nécessaires pour une attaque réussie (par exemple, “<” et “

>"). Dans ce cas, le testeur peut essayer d'utiliser d'autres codages (par exemple, UTF-7)

C

ertaines cibles (par exemple, ASP) -encodent au format URL la partie du path de l'en-tête location (par exemple, www.victim.com/redirect.asp), ce qui rend inutile une séquence CRLF. Cependant, elles ne parviennent pas à coder la section requête (par exemple,?Interface =advanced), ce qui signifie qu'un point d'interrogation principal est suffisant pour contourner ce filtrage Pour une analyse plus détaillée de cette attaque et d'autres informations sur les scénarios et d'applications possibles, consulter les articles référencés à la fin de cette section.

Test boîte grise

HTTP splitting

L'exploitation réussie du splitting HTTP est grandement facilitée par la connaissance des détails de l'application Web et de la cible de l'attaque. Par exemple, des cibles différentes peuvent utiliser différentes méthodes pour décider du moment où le premier message HTTP se termine et quand le seconde commence. Certaines utiliseront les limites de message, comme dans l'exemple précédent. D'autres cibles supposeront que différents messages seront toujours dans différents paquets. D'autres alloueront pour chaque message un certain nombre de morceaux de longueur prédéterminée: dans ce cas, le deuxième message devra commencer exactement au début d'un morceau, ce qui nécessitera que le testeur utilise un padding les deux messages. Cela peut causer des problèmes lorsque le paramètre vulnérable doit être envoyé dans l'URL, car une URL très longue est susceptible d'être tronquée ou filtrée. Un test boîte grise peut aider l'attaquant à trouver une solution de contournement: des serveurs d'application, par exemple, permettront que la requête soit envoyée via POST au lieu de GET.

HTTP Smuggling

Comme mentionné dans l'introduction, la smuggling HTTP s'appuie sur les différentes façons dont un message HTTP peut être analysé et interprété par différents agents (navigateurs, caches web, pare-feu d'application). Ce type relativement nouveau d'attaque a été découvert par Chaim Linhart, Amit Klein, Ronen Heled et Steve Orrin en 2005. Il y a plusieurs applications possibles et nous analyserons l'une des plus spectaculaire: la voie de contournement d'un pare-feu applicatif. Reportez-vous au livre blanc d'origine (lien au bas de cette page) pour des informations plus détaillées et d'autres scénarios.

Contournement d'un pare-feu applicatif

Il y a plusieurs produits qui permettent à une administration système de détecter et bloquer une requête Web hostile en fonction de certaines configurations malveillantes connues qui sont incorporées dans la requête. Par exemple, considérons la tristement célèbre, vieille attaque Unicode directory traversal contre un serveur IIS (http://www.securityfocus.com/bid/1806), dans laquelle un attaquant pourrait casser la racine www par l'émission d'une requête de type:

http://target/scripts/..%c1%1c../winnt/system32/cmd.exe?/c+<command_to_execute>

Bien sûr, il est assez facile de repérer et de filtrer cette attaque par la présence de chaînes telles que ”..“ et “cmd.exe” dans l'URL. Cependant, IIS 5.0 est assez pointilleux sur les requêtes POST dont le corps est au maximum de 48K octets et tronque tout le contenu qui est au-delà de cette limite lorsque l'en-tête Content-Type est différente de application /x-www-form-urlencoded. Le testeur peut tirer parti de cela en créant une demande très importante, structurée comme suit:

POST /target.asp HTTP/1.1        <-- **Request #1**
Host: target
Connection: Keep-Alive
Content-Length: 49225 
<CRLF>
<49152 bytes of garbage> 
POST /target.asp HTTP/1.0        <-- **Request #2**
Connection: Keep-Alive
Content-Length: 33
<CRLF>
POST /target.asp HTTP/1.0        <-- **Request #3**
xxxx: POST /scripts/..%c1%1c../winnt/system32/cmd.exe?/c+dir HTTP/1.0   <-- **Request #4**
Connection: Keep-Alive
<CRLF>

La requête n° 1 est composée de 49223 octets, ce qui comprend aussi les lignes de requête n ° 2. Par conséquent, un pare-feu (ou de tout autre agent à côté de IIS 5.0) verra la requête n ° 1, mais ne parviendra pas à voir la requête n° 2 (ses données seront tout simplement partie de la requête n° 1), verra la requête n°3 et ignorera la requête n° 4 (parce que lee message sera tout simplement partie de l'en-tête xxxx faux). Maintenant, qu'est-ce qui se passe dans le serveur IIS 5.0? Il s'arrêtera l'analyse de la requête n° 1 juste après les 49152 octets (car elle aura atteint la limite de 48K = 49152 octets) et le déchet ne sera donc analyser La requête n° 2 sera considérée comme une nouvelle demande distincte. La requête n° 2 affirme que son contenu est de 33 octets, ce qui inclut tout jusqu'à ce que “xxxx”, ce qui fait qu'IIS va manquer la requête n° 3 (interprétée dans le cadre de la requête n° 2), mais placera la requête n° 4, car son POST commence juste après le 33ème octet de la requête n° 2. C'est un peu compliqué, mais le fait est que l'URL d'attaque ne sera pas détectée par le pare-feu (elle sera interprété comme la requête précédente), mais sera correctement analysée (et exécutée) par IIS.

Alors que dans le cas précité, la technique exploite le bug d'un serveur web, il existe d'autres scénarios dans lesquels nous pouvons miser sur les différentes façons dont les différents appareils compatibles HTTP analysent les messages qui ne sont pas conformes à la RFC 1005. Par exemple, le protocole HTTP permet un seul Content-Length par en-tête, mais ne précise pas la façon de traiter un message qui a deux occurrences de cet en-tête. Certaines implémentations utiliseront le premier tandis que d'autres préfèront le second, laissant la voie à des attaques de smuggling HTTP. Un autre exemple est l'utilisation de l'en-tête Content-Length dans un message GET.

Notez que le smuggling HTTP « n'exploite pas » une vulnérabilité dans l'application Web cible. Par conséquent, il pourrait être un peu délicat, dans un test, de convaincre le client qu'une contre-mesure devrait être quand même examinée.

Références

Livres blancs

hack/testing_for_http_splitting_smuggling.txt · Last modified: 2019/02/13 13:10 by 127.0.0.1