Prevenção de XSS no DOM: Sanitização e Inserção Segura
⚡ Curso de DOM • Web-ZoneWare

Sanitização e Prevenção de XSS ao Inserir Conteúdo no DOM: DOMPurify e Boas Práticas

Lição 10 de 50

Sanitização e Prevenção de XSS ao Inserir Conteúdo no DOM: DOMPurify e Boas Práticas

⚡ Módulo 2 • Aula 10 de 50 • MARCO DE 20%

Compreenda a mecânica dos ataques de Cross-Site Scripting baseado em DOM (DOM-based XSS) e aprenda como blindar suas aplicações web contra injeção maliciosa de código: domine técnicas seguras de inserção, conheça a especificação moderna Trusted Types e aprenda a integrar a biblioteca padrão da indústria DOMPurify para sanitizar marcações HTML ricas sem quebrar a segurança.

1. A Anatomia do DOM-Based Cross-Site Scripting (DOM XSS)

O Cross-Site Scripting baseado em DOM (DOM XSS) é uma das vulnerabilidades de segurança mais críticas e prevalentes em aplicações web ricas (Single Page Applications, dashboards e portais dinâmicos). Ao contrário do XSS tradicional (onde o servidor injeta o script no HTML antes de enviá-lo), o DOM XSS ocorre inteiramente dentro do navegador do usuário.

A falha acontece quando dados não confiáveis controlados pelo usuário (chamados de Fontes / Sources) fluem diretamente para pontos de execução perigosos do navegador (chamados de Destinos / Sinks) sem que haja sanitização rigorosa:

🚨

O Modelo Source → Sink do DOM XSS:

  • Fontes (Sources): Parâmetros de URL (location.search, location.hash), campos de formulário (input.value), dados recebidos via fetch()/APIs externas, e mensagens via window.postMessage().
  • Destinos Perigosos (Sinks): Atribuição direta em element.innerHTML, element.outerHTML, document.write(), e atributos de links com protocolo executável (a.href = "javascript:...").

2. Por Que Filtros Caseiros com Expressões Regulares Falham?

O maior erro cometido por desenvolvedores iniciantes é tentar sanitizar entradas com expressões regulares simplistas, como texto.replace(/<script.*?>.*?</script>/gi, ""). Essa abordagem é uma ilusão de segurança que falha imediatamente.

Um invasor experiente raramente utiliza a tag <script> para explorar DOM XSS. Ele utiliza atributos de eventos embutidos em tags HTML perfeitamente comuns:

  • <img src="invalido" onerror="roubarSessao()"> — Disparado assim que a imagem falha ao carregar.
  • <svg onload="alert(document.cookie)"> — O SVG é um elemento gráfico padrão do HTML5 com suporte a eventos de carga imediatos.
  • <iframe src="javascript:alert('XSS')"></iframe> — Execução de código no contexto da página.
  • <body onpageshow="exfiltrarDados()">

3. A Biblioteca Padrão da Indústria: DOMPurify

Como a especificação do HTML é extremamente tolerante a falhas e rica em particularidades contextuais, a regra da indústria é unânime: nunca crie sua própria sanitização de HTML; utilize o DOMPurify.

Criado pela equipe de segurança da Cure53 e amplamente auditado por gigantes como Google e Mozilla, o DOMPurify faz a higienização parseando a string em uma árvore de DOM viva em segundo plano (via DOMParser), expurgando qualquer tag ou atributo perigoso contra uma lista estrita de elementos permitidos (Allowlist):

JavaScript 13 linhas
// Importação via ESM ou Script CDN:
// <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/purify.min.js"></script>
 
const inputMalicioso = '<strong>Mensagem:</strong> <img src=x onerror="alert('XSS!')">';
 
// 1. Sanitização Profunda e Segura com DOMPurify
const htmlHigienizado = DOMPurify.sanitize(inputMalicioso);
 
console.log(htmlHigienizado);
// Saída: "<strong>Mensagem:</strong> <img src="x">" (O onerror foi cirurgicamente removido!)
 
// 2. Agora sim a inserção é 100% segura:
document.getElementById("painel").innerHTML = htmlHigienizado;

4. Configurações Avançadas de Allowlist

O DOMPurify permite restringir ainda mais as tags autorizadas de acordo com o contexto da sua aplicação:

JavaScript 5 linhas
// Permite apenas tags de formatação básica de texto:
const htmlRestrito = DOMPurify.sanitize(inputUsuario, {
    ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p', 'span'],
    ALLOWED_ATTR: ['class'] // Proíbe estilos inline (style) e links (href)
});

5. A Especificação W3C Trusted Types API

Nos navegadores modernos baseados em Chromium, a especificação Trusted Types atua como um escudo nativo. Através de uma política de Content Security Policy (CSP), o navegador pode bloquear qualquer atribuição direta de strings cruas a sinks perigosos:

CODE 1 linha
Content-Security-Policy: require-trusted-types-for 'script';

Quando ativado, fazer element.innerHTML = "texto" lança um erro imediato no console, obrigando os desenvolvedores a passarem todo o código por um conversor certificado (como o próprio DOMPurify integrado ao Trusted Types).

🛡️

As Duas Diretrizes Sagradas de Defesa:

  1. Se for apenas texto: Utilize SEMPRE element.textContent = entrada. Nunca use innerHTML para exibir dados que não exigem tags de formatação.
  2. Se for criar elementos: Prefira a API programática document.createElement(), atribuindo valores textuais com textContent e atributos limpos com setAttribute.

JavaScript Moderno (ES6+)
sanitizacao-e-prevencao-xss.js
JavaScript 72 linhas
// =====================================================================
// LAB: PREVENÇÃO DE XSS BASEADO EM DOM E SANITIZAÇÃO SEGURA
// =====================================================================
 
console.log("=== LABORATÓRIO DE SEGURANÇA E PREVENÇÃO DE DOM XSS ===");
 
// 1. Simulação de um Sanitizador Nativo Baseado em DOMParser e Allowlist
// (Mecanismo conceitual que demonstra como bibliotecas como DOMPurify operam)
class SanitizadorNativo {
    private static tagsPermitidas = new Set(["B", "I", "STRONG", "EM", "P", "SPAN", "UL", "LI"]);
    private static atributosPermitidos = new Set(["class", "title"]);
 
    public static sanitizar(htmlBruto) {
        const parser = new DOMParser();
        const doc = parser.parseFromString(htmlBruto, "text/html");
        
        function purificarNo(no) {
            // Se for nó de elemento, verifica se está na Allowlist
            if (no.nodeType === Node.ELEMENT_NODE) {
                if (!SanitizadorNativo.tagsPermitidas.has(no.nodeName)) {
                    // Tag proibida: substitui o elemento por seu texto interno
                    const textoSubstituto = document.createTextNode(no.textContent);
                    no.parentNode?.replaceChild(textoSubstituto, no);
                    return;
                }
 
                // Remove atributos suspeitos (especialmente on* e javascript:)
                const atributos = Array.from(no.attributes);
                for (const attr of atributos) {
                    const nomeAttr = attr.name.toLowerCase();
                    const valorAttr = attr.value.toLowerCase();
 
                    // Bloqueia qualquer evento (onclick, onerror, onload) ou links javascript:
                    if (nomeAttr.startsWith("on") || valorAttr.includes("javascript:")) {
                        no.removeAttribute(attr.name);
                        console.warn(`[DEFESA] Atributo malicioso neutralizado: ${attr.name}="${attr.value}"`);
                    } else if (!SanitizadorNativo.atributosPermitidos.has(nomeAttr)) {
                        no.removeAttribute(attr.name);
                    }
                }
            }
 
            // Percorre os nós filhos recursivamente
            Array.from(no.childNodes).forEach(filho => purificarNo(filho));
        }
 
        Array.from(doc.body.childNodes).forEach(no => purificarNo(no));
        return doc.body.innerHTML;
    }
}
 
// 2. Testando com Payloads Reais de Ataque XSS
const payload1 = 'Olá <strong>Visitante</strong>! <img src="imagem-inexistente.jpg" onerror="alert('XSS Executado!')"></p>';
const payload2 = 'Clique para ver fotos';
 
console.log("--- TESTANDO SANITIZAÇÃO DE PAYLOAD 1 ---");
console.log("Original:", payload1);
const limpo1 = SanitizadorNativo.sanitizar(payload1);
console.log("Higienizado:", limpo1);
 
console.log("n--- TESTANDO SANITIZAÇÃO DE PAYLOAD 2 ---");
console.log("Original:", payload2);
const limpo2 = SanitizadorNativo.sanitizar(payload2);
console.log("Higienizado:", limpo2);
 
// 3. Aplicação Segura no DOM
const containerSeguro = document.createElement("div");
containerSeguro.id = "area-comentarios";
containerSeguro.innerHTML = limpo1;
document.body.appendChild(containerSeguro);
 
console.log("n✅ Conteúdo inserido no DOM com segurança total e zero execução maliciosa!");
🛠️ Laboratório Prático & Prática Imediata

Aplique o que você aprendeu nesta lição

Utilize nossas ferramentas online gratuitas para experimentar os conceitos ou teste o código ao vivo no Playground IDE.

💻 Desenvolvedor & Código

Editor de Códigos Web Online

Ambiente com destaque de sintaxe para você testar tags, tabelas e scripts na hora.

Abrir Ferramenta Online
⚡ Live Code Studio

Playground Web Online

Escreva seu código HTML, CSS ou JavaScript e veja o resultado renderizado ao vivo no navegador com zero configuração.

⚡ Codificar no Playground IDE
Foto de Web-Zoneware
✓ Verificado
🎓 Tutor & Coordenador da Web Academy

Web-Zoneware

Tutor Técnico & Desenvolvedor Full-Stack

Desenvolvedor web e instrutor focado na formação prática de novos programadores. Defensor ferrenho de código semântico, arquitetura limpa e acessibilidade W3C/WCAG, dedicando-se a construir cursos estruturados em metodologia passo a passo com execução ao vivo no Playground IDE.

Especialidades: HTML5 Semântico CSS3 & Flexbox/Grid JavaScript Moderno Acessibilidade WCAG 2.2 Didática Prática
Rolar para cima