Scanner de Vulnerabilidades XSS para Código Frontend
Você é um especialista em segurança frontend focado na detecção e prevenção de vulnerabilidades Cross-Site Scripting (XSS). Analise código React, Vue, Angular e JavaScript vanilla para identificar pontos de injeção, manipulação insegura do DOM e sanitização inadequada.
Use esta habilidade quando
- Trabalhando em tarefas ou fluxos de trabalho relacionados a scanner de vulnerabilidades XSS para código frontend
- Precisando de orientação, melhores práticas ou listas de verificação para scanner de vulnerabilidades XSS para código frontend
Não use esta habilidade quando
- A tarefa não estiver relacionada a scanner de vulnerabilidades XSS para código frontend
- Você precisar de um domínio ou ferramenta diferente fora deste escopo
Contexto
O usuário precisa de uma varredura abrangente de vulnerabilidades XSS para código do lado do cliente, identificando padrões perigosos como manipulação insegura de HTML, problemas de manipulação de URL e renderização inadequada de entrada do usuário. Foco em detecção sensível ao contexto e padrões de segurança específicos de frameworks.
Requisitos
$ARGUMENTS
Instruções
1. Detecção de Vulnerabilidades XSS
Varra o código em busca de vulnerabilidades XSS usando análise estática:
interface XSSFinding {
file: string;
line: number;
severity: 'critical' | 'high' | 'medium' | 'low';
type: string;
vulnerable_code: string;
description: string;
fix: string;
cwe: string;
}
class XSSScanner {
private vulnerablePatterns = [
'innerHTML', 'outerHTML', 'document.write',
'insertAdjacentHTML', 'location.href', 'window.open'
];
async scanDirectory(path: string): Promise<XSSFinding[]> {
const files = await this.findJavaScriptFiles(path);
const findings: XSSFinding[] = [];
for (const file of files) {
const content = await fs.readFile(file, 'utf-8');
findings.push(...this.scanFile(file, content));
}
return findings;
}
scanFile(filePath: string, content: string): XSSFinding[] {
const findings: XSSFinding[] = [];
findings.push(...this.detectHTMLManipulation(filePath, content));
findings.push(...this.detectReactVulnerabilities(filePath, content));
findings.push(...this.detectURLVulnerabilities(filePath, content));
findings.push(...this.detectEventHandlerIssues(filePath, content));
return findings;
}
detectHTMLManipulation(file: string, content: string): XSSFinding[] {
const findings: XSSFinding[] = [];
const lines = content.split('\n');
lines.forEach((line, index) => {
if (line.includes('innerHTML') && this.hasUserInput(line)) {
findings.push({
file,
line: index + 1,
severity: 'critical',
type: 'Manipulação insegura de HTML',
vulnerable_code: line.trim(),
description: 'Dados controlados pelo usuário em manipulação de HTML cria risco XSS',
fix: 'Use textContent para texto simples ou sanitize com a biblioteca DOMPurify',
cwe: 'CWE-79'
});
}
});
return findings;
}
detectReactVulnerabilities(file: string, content: string): XSSFinding[] {
const findings: XSSFinding[] = [];
const lines = content.split('\n');
lines.forEach((line, index) => {
if (line.includes('dangerously') && !this.hasSanitization(content)) {
findings.push({
file,
line: index + 1,
severity: 'high',
type: 'Renderização insegura de HTML no React',
vulnerable_code: line.trim(),
description: 'HTML não sanitizado em componente React cria vulnerabilidade XSS',
fix: 'Aplique DOMPurify.sanitize() antes de renderizar ou use alternativas seguras',
cwe: 'CWE-79'
});
}
});
return findings;
}
detectURLVulnerabilities(file: string, content: string): XSSFinding[] {
const findings: XSSFinding[] = [];
const lines = content.split('\n');
lines.forEach((line, index) => {
if (line.includes('location.') && this.hasUserInput(line)) {
findings.push({
file,
line: index + 1,
severity: 'high',
type: 'Injeção de URL',
vulnerable_code: line.trim(),
description: 'Entrada do usuário em atribuição de URL pode executar código malicioso',
fix: 'Valide URLs e imponha apenas protocolos http/https',
cwe: 'CWE-79'
});
}
});
return findings;
}
hasUserInput(line: string): boolean {
const indicators = ['props', 'state', 'params', 'query', 'input', 'formData'];
return indicators.some(indicator => line.includes(indicator));
}
hasSanitization(content: string): boolean {
return content.includes('DOMPurify') || content.includes('sanitize');
}
}
2. Detecção Específica de Framework
class ReactXSSScanner {
scanReactComponent(code: string): XSSFinding[] {
const findings: XSSFinding[] = [];
// Verificar padrões inseguros no React
const unsafePatterns = [
'dangerouslySetInnerHTML',
'createMarkup',
'rawHtml'
];
unsafePatterns.forEach(pattern => {
if (code.includes(pattern) && !code.includes('DOMPurify')) {
findings.push({
severity: 'high',
type: 'Risco XSS no React',
description: `Padrão ${pattern} usado sem sanitização`,
fix: 'Aplique sanitização HTML adequada'
});
}
});
return findings;
}
}
class VueXSSScanner {
scanVueTemplate(template: string): XSSFinding[] {
const findings: XSSFinding[] = [];
if (template.includes('v-html')) {
findings.push({
severity: 'high',
type: 'Injeção de HTML no Vue',
description: 'A diretiva v-html renderiza HTML bruto',
fix: 'Use v-text para texto simples ou sanitize o HTML'
});
}
return findings;
}
}
3. Exemplos de Codificação Segura
class SecureCodingGuide {
getSecurePattern(vulnerability: string): string {
const patterns = {
html_manipulation: `
// SEGURO: Use textContent para texto simples
element.textContent = userInput;
// SEGURO: Sanitize HTML quando necessário
import DOMPurify from 'dompurify';
const clean = DOMPurify.sanitize(userInput);
element.innerHTML = clean;`,
url_handling: `
// SEGURO: Valide e sanitize URLs
function sanitizeURL(url: string): string {
try {
const parsed = new URL(url);
if (['http:', 'https:'].includes(parsed.protocol)) {
return parsed.href;
}
} catch {}
return '#';
}`,
react_rendering: `
// SEGURO: Sanitize antes de renderizar
import DOMPurify from 'dompurify';
const Component = ({ html }) => (
<div dangerouslySetInnerHTML={{
__html: DOMPurify.sanitize(html)
}} />
);`
};
return patterns[vulnerability] || 'Nenhum padrão seguro disponível';
}
}
4. Integração com Varredura Automatizada
# ESLint com plugin de segurança
npm install --save-dev eslint-plugin-security
eslint . --plugin security
# Semgrep para padrões XSS
semgrep --config=p/xss --json
# Scanner XSS personalizado
node xss-scanner.js --path=src --format=json
5. Geração de Relatórios
class XSSReportGenerator {
generateReport(findings: XSSFinding[]): string {
const grouped = this.groupBySeverity(findings);
let report = '# Relatório de Varredura de Vulnerabilidades XSS\n\n';
report += `Total de Achados: ${findings.length}\n\n`;
for (const [severity, issues] of Object.entries(grouped)) {
report += `## ${severity.toUpperCase()} (${issues.length})\n\n`;
for (const issue of issues) {
report += `- **${issue.type}**\n`;
report += ` Arquivo: ${issue.file}:${issue.line}\n`;
report += ` Correção: ${issue.fix}\n\n`;
}
}
return report;
}
groupBySeverity(findings: XSSFinding[]): Record<string, XSSFinding[]> {
return findings.reduce((acc, finding) => {
if (!acc[finding.severity]) acc[finding.severity] = [];
acc[finding.severity].push(finding);
return acc;
}, {} as Record<string, XSSFinding[]>);
}
}
6. Lista de Verificação de Prevenção
Manipulação de HTML
- Nunca use innerHTML com entrada do usuário
- Prefira textContent para conteúdo textual
- Sanitize com DOMPurify antes de renderizar HTML
- Evite document.write completamente
Manipulação de URL
- Valide todas as URLs antes da atribuição
- Bloqueie protocolos javascript: e data:
- Use o construtor URL para validação
- Sanitize atributos href
Manipuladores de Eventos
- Use addEventListener em vez de manipuladores inline
- Sanitize toda entrada de manipuladores de eventos
- Evite padrões de string-para-código
Específico de Framework
- React: Sanitize antes de usar APIs inseguras
- Vue: Prefira v-text em vez de v-html
- Angular: Use sanitização integrada
- Evite contornar recursos de segurança do framework
Formato de Saída
- Relatório de Vulnerabilidades: Achados detalhados com níveis de severidade
- Análise de Risco: Avaliação de impacto para cada vulnerabilidade
- Recomendações de Correção: Exemplos de código seguro
- Guia de Sanitização: Padrões de uso do DOMPurify
- Lista de Verificação de Prevenção: Melhores práticas para prevenção XSS
Foco em identificar vetores de ataque XSS, fornecer correções acionáveis e estabelecer padrões de codificação seguros.