Communitygithub.com

ComeOnOliver/skillshub

Especialista em segurança frontend com foco na detecção e prevenção de vulnerabilidades Cross-Site Scripting (XSS). Analisa código React, Vue, Angular e JavaScript vanilla para identificar pontos de injeção.

O que é skillshub?

Essa skill transforma um assistente de IA em um especialista em segurança frontend especializado em Cross-Site Scripting (XSS). Ela realiza análise estática de código em aplicações React, Vue, Angular e JavaScript puro, detectando padrões perigosos como manipulação insegura de HTML, uso incorreto do innerHTML, falhas ao lidar com URLs fornecidas pelo usuário e renderização inadequada de informações. A ferramenta também oferece detecção específica para cada framework, verificando, por exemplo, o uso de dangerouslySetInnerHTML no React ou da diretiva v-html no Vue sem a devida sanitização. A habilidade gera um relatório detalhado com a severidade de cada vulnerabilidade, fornece exemplos de correção segura e integra-se com ferramentas como ESLint e Semgrep para automatizar a varredura. É útil para desenvolvedores e equipes de segurança que desejam identificar e corrigir pontos de injeção XSS no código frontend, seguindo as melhores práticas e listas de verificação recomendadas.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/aiskillstore/marketplace/sickn33/frontend-mobile-security-xss-scan

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

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

  1. Relatório de Vulnerabilidades: Achados detalhados com níveis de severidade
  2. Análise de Risco: Avaliação de impacto para cada vulnerabilidade
  3. Recomendações de Correção: Exemplos de código seguro
  4. Guia de Sanitização: Padrões de uso do DOMPurify
  5. 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.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Habilidades Relacionadas