# blind xpath injection

{{INLINETOC}}

## Description


**XPath** est un type de langage de requêtes qui décrit comment trouver des éléments spécifiques (en incluant des attributs, en traitant des instructions, etc.) dans un document XML. Puisque c'est un langage de requêtes, **XPath** est un peu semblable à **S**tructured **Q**uery **L**anguage (**SQL**). Pourtant, **XPath** peut être utilisé pour se référer à presque n'importe quelle partie de n'importe quel document XML sans restrictions de contrôle d'accès, alors qu'avec **SQL**, 'un utilisateur' (qui est un terme non défini dans le contexte XPath/XML) peut être restreint à certaines tables, colonnes ou requêtes.

Plus d'informations peuvent être trouvées dans l'article dédié à l'injection **XPATH**. En utilisant une attaque d'injection **XPATH**, l'attaquant est en mesure de se connecter au système sans avoir à entrer de login et et mot-de-passe valide à l'ouverture de session. S'il veut avoir des informations sur d'autres utilisateurs, il doit faire un pas supplémentaire. En accomplissant une attaque d'injection **XPath** aveugle, l'attaquant n'a aucune connaissance de la structure du document XML.
Pourtant sa situation est meilleure avec l'injection SQL Aveugle, car il y a des fonctions qui autorisent l'exécution de tests (XML Crawling) et, à la fin, de connaître la structure de document.


## Exemples

L'attaquant peut réussir en utilisant deux méthodes : Boolenization et XML Crawling. En ajoutant à la syntaxe XPath, l'attaquant utilise des expressions supplémentaires (remplaçant ce que l'attaquant avait entré dans l'ouverture de session par une expression spécialement faite à la main).


### Boolenization

Utilisant la méthode de " Boolenization ", l'attaquant peut découvrir si l'expression XPath donnée est Vraie ou Fausse. Supposons que le but de l'attaquant est de se connecter au compte. Une connection réalisée avec succès rendrait l'expression Vraie et si elle était ratée rendrait Fausse. Seule une certaine portion de l'information est analysée comme " caractère " ou nombre. Quand l'attaquant se concentre sur le //string// , il peut le révéler dans son ensemble en vérifiant chaque caractère simple dans le fait de classer/varier les caractères auxquels ce //string// appartient.

En utilisant une fonction //string-length(S)//, où S est un //string//, l'attaquant peut découvrir la longueur de ce //string//. Avec le nombre approprié d'itérations de la fonction //substring(S,N,1)//, où S est le string auparavant mentionné, N est un caractère, et "1" est un caractère s'incrémentant et suivant le caractère N, l'attaquant est en mesure de découvrir entièrement le //string// : 

Code : 
  <nowiki>< ?xml version="1.0" encoding="UTF-8"?></nowiki>Fonction : 
  string.stringlength(//user[position()=1]/child::node()[position()=2]) retourne la longueur du second string du premier user (8), 
  substring((//user[position()=1]/child::node()[position()=2),1,1) retourne le premier caractère de cet user ('r'). 


### XML Crawling

Pour connaître la structure du document XML l'attaquant peut utiliser : 
  * count(expression) 
  count(//user/child::node()
Cela retournera le nombre de noeuds (dans ce cas-là 2).
  * stringlength(string) 
  string-length(//user[position()=1]/child::node()[position()=2])=6
Utilisant cette requête, l'attaquant découvrira si le second string (mot-de-passe) du premier noeud (utilisateur 'admin') se compose de 6 caractères.
  * substring(string, number, number) 
  substring((//user[position()=1]/child::node()[position()=2]),1,1)="a"
Cette requête confirmera (Vraie) ou refutera (Fausse) que le premier caractère du mot-de-passe de   l'utilisateur ('admin') est un caractère " a ".

Si la log est de la forme : 
  C#: 
  String FindUser;
  FindUser = "//user[login/text()='" + Request("Username") + "' And
       password/text()='" + Request("Password") + "']";
alors l'attaquant pourrait injecter le code suivant :
  Username: ' or substring((//user[position()=1]/child::node()[position()=2]),1,1)="a" or //='//
La syntaxe XPath peut rappeler des attaques d'injection SQL communes mais l'attaquant doit estimer que ce langage refuse de remarquer le reste de l'expresssion. Pour omettre cette restriction l'attaquant devrait utiliser l'expression  OR pour vider toutes les expressions, ce qui pourrait désorganiser l'attaque.


## References

  * http://www.modsecurity.org/archive/amit/blind-xpath-injection.pdf - by Amit Klein (much more detailes, in my opinion the best source about Blind XPath Injection).
  * http://www.ibm.com/developerworks/xml/library/x-xpathinjection.html