XSS Cheat Sheet: um guia prático para engenheiros de segurança hardcore

Por que outra folha de consulta xss ainda é importante

Estruturas modernas ≠ Sem XSS. O escape automático no React/Angular/Svelte reduz as falhas de modelagem, mas os sistemas reais ainda enviam o uso indevido da API do DOM, widgets inseguros de terceiros, Markdown/WYSIWYG permissivo, javascript: Manipuladores de URL, SVG/MathML, remanescentes de JSONP e confiança implícita em localização/hash/postMessage.

Os ecossistemas de vetores evoluem. O PortSwigger anota continuamente as cargas úteis por evento / tag / atributo / navegadorreduzindo drasticamente a "memória tribal". Essa curadoria é fundamental quando você precisa de uma ampla cobertura sem reinventar taxonomias de carga útil.

A filtragem por si só não é uma defesa. A OWASP vem repetindo isso há mais de uma década: a correção depende de o contexto de renderização dos dados. Combinação de codificação de saída adequada, sanitização (para HTML de autoria do usuário), política (CSP, tipos confiáveis) e higiene da estrutura não é negociável.

Matriz de superfície de ataque × contexto

Use essa matriz como sua lista de verificação de execução ao criar scripts de validações ou auditorias de código do Playwright/Burp/Nuclei. Cada linha vincula uma renderização contexto a arriscado piascomum entradas, o primeira jogada defensivae como verificar em escala.

Exemplos mínimos reproduzíveis (MREs) que você pode realmente executar

1) Contexto de atributos + gatilho de interação zero

<input autofocus onfocus="fetch('/beacon?xss=1')">

Por que é importante: Os eventos de foco são acionados automaticamente no carregamento em muitos fluxos de UX (campos de pesquisa, prompts rápidos). Substitua por <svg onload=…> ou <img onerror="…"> para testar diferentes semânticas de acionamento.

2) Portador de SVG + peculiaridades no manuseio de URLs

<svg><a xlink:href="javascript:fetch('/beacon?svg')">x</a></svg>

Por que é importante: O SVG é um namespace XML separado com análise de atributos historicamente peculiares. As equipes geralmente se esquecem de higienizar o SVG ou de permiti-lo por meio de renderizadores Markdown.

3) XSS baseado em DOM (fonte → linhagem de sumidouro)

<script>
  const q = new URL(location).hash.slice(1);
  document.getElementById('out').innerHTML = q; // sink
</script>
<div id="out"></div>

Por que é importante: O clássico antipadrão "ler do URL, escrever no DOM". Ele está presente em todos os sites antigos e ferramentas internas. Corrigir com codificação com correção de contexto e nunca escreva diretamente nos sumidouros de HTML.

Linha de base defensiva (engenharia em primeiro lugar, não slogans)

1. Codificação de saída por contexto. Codificar para HTML / Atributo / URL / JS respectivamente. O recurso de escape automático da estrutura não abrange DOM enrolado à mão atualizações.
2. Sanitização da lista de permissões para o HTML do usuário. Quando a lógica comercial exigir conteúdo rico (comentários, biografias, bases de conhecimento), use DOMPurificar (ou equivalente) com configurações reforçadas; evite o "corte de palavras" da lista negra.
3. Política de segurança de conteúdo. Comece com script-src 'self' + bloco em linha por padrão; definir object-src 'none' e base-uri "nenhum. Adotar Tipos confiáveis no Chromium para forçar APIs DOM seguras em tempo de compilação/execução.
4. Auditoria de API perigosa. Proibir ou bloquear eval/new Function/setTimeout(string) e conversões dinâmicas de código JSON→. Aplique as regras do ESLint durante a compilação e falhe na CI quando surgirem violações.
5. Teste e verifique como código. Automatize a reprodução da carga útil. Emparelhe com Relatório de violação do CSP e correlação de gateway/log para separar "pop-ups demonstráveis" de explorável caminhos que importam para a empresa.

Da folha de dicas ao pipeline: automação que envia

O caminho mais curto da "biblioteca de vetores" para a "garantia de grau de produção" é um loop de cinco estágios:

1. Descoberta de contexto. Varreduras estáticas (regras do ESLint, grep semântico) + sondas de tempo de execução que marcam possíveis sumidouros (innerHTML, definidores de atributos, pontos de navegação).
2. Programação de vetores. Mapear cada sink/contexto para um piscina com curadoria de cargas úteis (eventos de atributos, peculiaridades de tags, manipuladores de URL), filtragem por navegador e sinalizadores de recursos.
3. Prova sem cabeça. O Playwright/Chromium é executado por vetor. Captura de console, rede, Violações do CSPe mutações DOM.
4. Correlação de sinais. Junte-se às descobertas sem cabeça com Gateway de API e Registros de aplicativos para classificar "ruído vs. real". Isso elimina os falsos positivos no primeiro dia.
5. Relatórios com base em evidências. Anexe automaticamente capturas de tela, rastreamentos HTTP, diffs de DOM antes/depois e violações de políticas - então confiança na pontuação para que os engenheiros saibam por onde começar.

Reprodutor do Minimal Playwright (snippet drop-in)

importar { chromium } de 'playwright';

const vectors = [
  '#\"&gt;<img src="x" onerror="fetch(\">',
  '#<svg onload="fetch(\">'
];

(async () =&gt; {
  const browser = await chromium.launch();
  const page = await browser.newPage();
  page.on('console', m =&gt; console.log('console:', m.text()));
  page.on('pageerror', e =&gt; console.error('pageerror:', e));
  for (const v of vectors) {
    await page.goto('https://target.example/' + v);
    await page.screenshot({ path: `evidence_${encodeURIComponent(v)}.png` });
  }
  await browser.close();
})();

Produza-o: adicione rótulos de linhagem de fonte→sumidouro a cada execução, ative Somente relatório do CSP para coletar violações e armazenar Diferenças de DOM para tornar as regressões óbvias nos PRs.

Realidades da estrutura para as quais você deve projetar

• React/JSX. O escape automático ajuda, mas dangerouslySetInnerHTML e crua ref.current.innerHTML = ... reabrir a pia. Trate-os como odores de código; proteja-se com um desinfetante e uma política de Tipos Confiáveis.
• Angular. O desinfetante é bom, mas bypassSecurityTrustHtml e APIs semelhantes podem fazer furos, documentar cada desvio e restringir a fontes controladas.
• Próximo/seguinte/SSR. As páginas geradas pelo servidor devem ecoar apenas codificado conteúdo. Nunca confie nas estruturas do cliente para "limpar" os erros do servidor.
• Markdown/MDX/WYSIWYG. Trate-os como Ingestão de HTML Problemas. Proteja seu renderizador, coloque widgets não confiáveis em uma área restrita e elimine atributos de eventos/manipuladores de URL.
• SVG/MathML. Se você precisar permiti-los, limite o conjunto de recursos e execute um sanitizador que entenda os namespaces XML. Se não for crítico, converta para rasterização segura no servidor.

Famílias práticas de carga útil de que você realmente precisará

• Acionador automático no evento: autofoco, carregar, onerror, onanimationstart, em foco, Intercâmbio de informações. Excelente para comprovar a capacidade de exploração sem cliques do usuário.
• Manipuladores de URL: javascript:, dados:e, ocasionalmente vbscript: (legado). Aplicar listas de permissões.
• Colisões de modelos: Truques de divisão/concatração que passam por filtros ingênuos (por exemplo, sair de contextos de atributos e entrar novamente no HTML).
• Dobradinha do DOM: Substitua IDs/nomes para redirecionar caminhos de código e aterrar um sumidouro.
• Tempo de mutação-observador: Acionadores que exploram atualizações dinâmicas em vez de carga inicial.

CSP e tipos confiáveis: de "bom ter" a proteção

• CSP oferece uma linguagem de política para restringir as fontes de script e a execução em linha. Comece com restrições e, em seguida, amplie-as apenas para casos aprovados. Emparelhe com relatório-uri/reportar para e colheita relatórios de violação em sua telemetria.
• Tipos confiáveis forçar os desenvolvedores a aprovar criado por política em APIs DOM que, de outra forma, aceitariam strings brutas (innerHTML, outerHTML, insertAdjacentHTML, Range#createContextualFragment). Isso remove classes inteiras de DOM XSS por construção.
• Dica de lançamento: executar o CSP em somente relatório por dois sprints; corrija as violações; depois aplique. Introduzir um único Política de tipos confiáveis em todo o aplicativo e somente emitir HTML "abençoado" por meio de construtores aprovados.

Como provar a capacidade de exploração aos engenheiros

1. Scripts de reprodução: Forneça um one-liner (URL ou curl) e uma ramificação do Playwright para reproduzir.
2. Diferença de DOM: Mostra o nó exato que foi alterado e o caminho (#app > .profile > .bio).
3. Pilhas de chamadas: Para os sumidouros de JS, inclua os rastreamentos de pilha de seu eval/Função ganchos.
4. Evidências do CSP: Anexar JSON de violação para violações de inline/script src.
5. Narrativa de negócios: "Isso pode exfiltrar tokens de sessão de /conta por meio de uma injeção de <img> beacon" é sempre melhor que "alert popped".

Executando esta folha de consulta xss dentro do Penligent

Se você já estiver usando Penligente como uma plataforma de pentest automatizada, você pode empacotar os itens acima em um único modelo executável:

• Modelo de tarefa: "Reconhecimento XSS + Validação". O agente realiza o reconhecimento (subdomínio/porta/impressão digital), programa vetores por contexto detectado, executa a reprodução sem cabeça e correlaciona sinais com troncos/portas para reduzir o ruído.
• Exportação com base em evidências. As descobertas são enviadas com escores de confiançaO sistema de gerenciamento de dados da Microsoft é composto por etapas reproduzíveis, capturas de tela, registros de violação de CSP e diferenças de DOM em que seus engenheiros podem confiar.
• Onde é mais útil. Grandes escopos com pilhas mistas de legado + SPA, ou equipes migrando para CSP/Tipos confiáveis e precisando de triagem orientada por provas em vez de curiosidades sobre a carga útil.

Armadilhas comuns que continuam prejudicando as equipes experientes

• Sanitizar a entrada, não a saída. Se você precisar aceitar HTML, higienize e ainda codificam na saída com base no contexto de destino; os dois não são intercambiáveis.
• Permitir javascript: para "flexibilidade". Elimine-o completamente; coloque na lista de permissões apenas protocolos específicos (https, mailtoTalvez tel).
• Tratamento do Markdown como "texto seguro". É um renderizador - seus plug-ins decidem a segurança. Audite as tags/atributos permitidos; considere a rasterização no lado do servidor para SVG não confiável.
• Ignorar contextos não HTML. A concatenação de URL e as avaliações JSON→JS são reincidentes. Fortaleça a política de "não usar strings para codificar".
• Confiar em um ambiente. O XSS que falha no headless ainda pode ser bem-sucedido no Chromium móvel ou em compilações de desktop mais antigas. Mantenha um matriz do navegador para aplicativos de alto valor.

Lista de verificação de produção, fixe-a ao lado do seu crachá de CI

• Consciente do contexto codificação Utilitários com testes de unidade para HTML/Attr/URL/JS
• DOMPurificar (ou equivalente) bloqueado em uma configuração reforçada para caminhos de conteúdo avançado
• CSP com script-src 'self' (sem linha insegura), object-src 'none', base-uri "nenhumColeta de violações conectada à telemetria
• Tipos confiáveis política + regras de lint no tempo de compilação para bloquear os sumidouros de strings brutas
• Regras de banimento da ESLint eval/new Function/setTimeout(string) (imposto pela CI)
• Dramaturgo suíte de replay semeado com vetores no estilo PortSwigger; capturas de tela por vetor + diferenças de DOM
• Automatizado correlação de sinais com logs de aplicativos/eventos de gateway de API
• Relatórios que priorizam as evidências com escores de confiança e notas sobre o impacto nos negócios
• Linhas de modelo de RP: "Introduz novos sumidouros de HTML?" "Ignora o desinfetante?" "Política de TT atualizada?"
• Revisão regular das configurações de widgets de terceiros/WYSIWYG/Markdown

PERGUNTAS FREQUENTES

P: Se já usamos React/Angular, ainda precisamos disso?
R: Sim. As estruturas não policiam todas as gravações DOM, widgets de terceiros ou Markdown/SVG. Você ainda precisa de sanitizador + CSP + TT, e deve evitar gravar dados não confiáveis em coletores DOM brutos.

P: Devemos bloquear todos os scripts em linha com o CSP?
R: Sim, por padrão. Use nonces ou hashes somente quando for absolutamente necessário e documente a exceção. O objetivo a longo prazo é evitar completamente os scripts em linha.

P: A higienização é suficiente?
R: Não. A sanitização reduz a superfície de ataque para Ingestão de HTMLmas você ainda precisa corrigir codificação de saída e proteções políticas. Problemas diferentes, ferramentas diferentes.

P: Quais navegadores são testados?
R: No mínimo, os dois principais mecanismos para desktop + dispositivos móveis da sua base de usuários. Mantenha uma matriz pequena; alguns vetores são específicos de navegadores ou de bandeiras de recursos.

Leitura adicional (autorizada)

• PortSwigger - Folha de dicas sobre XSS (Cross-Site Scripting) - um catálogo vivo de vetores, PoCs e notas do navegador.
• OWASP - Folha de dicas de prevenção de XSS - estratégias de codificação rigorosas e específicas do contexto e tabelas de "fazer/não fazer".
• OWASP - Folha de dicas para prevenção de XSS baseado em DOM - padrões de fonte→sumidouro e atenuações no navegador.
• PortSwigger - O que é XSS? - tutoriais estruturados e laboratórios práticos para treinamento de novas contratações.

Apêndice: referência rápida de saneamento e codificação

• Nós de texto HTML → escape & " ' /
• Valores de atributos → Codificação de atributos HTML + não permitir atributos de eventos de dados não confiáveis
• URLs → codificar componentesprotocolos da lista de permissões; nunca escreva em formato bruto javascript: / dados:
• Cadeias de caracteres JS → serializar com segurança; nunca passe dados do usuário para APIs de interpretação de código

Nota de encerramento: Uma útil Folha de consulta xss é uma que você pode em seu pipeline-não um pôster de cargas úteis inteligentes. Comece com a descoberta de contexto, programe vetores por contexto, reproduza sem cabeça, correlacione com registros e envie evidências com pontuações de confiança. Independentemente de você adotar a Penligent ou desenvolver seu próprio sistema, conduza o processo com evidências e deixar que a política imponha os limites.