Pular para o conteúdo
Skillpedia
Segurança35 mil · #5956

implementing-semgrep-for-custom-sast-rules

Faz seu agente escrever regras personalizadas com Semgrep para encontrar vulnerabilidades específicas de aplicações.

O que ela faz

Esta ferramenta ajuda a encontrar problemas em seu código, como erros de segurança ou padrões de codificação que não seguem as regras. Você pode criar suas próprias regras para procurar coisas específicas no seu código.

Quando usar

  • ✓Quando você quer encontrar falhas de segurança específicas no seu código.
  • ✓Quando você quer garantir que seu código segue um padrão definido.
  • ✓Quando você quer automatizar a verificação de código em projetos grandes.

Exemplo do que pedir para a IA

“Procure por senhas que foram escritas diretamente no código.”

Quer saber mais? Abra as seções abaixo.

Como usar

O jeito mais fácil: copie a mensagem abaixo e cole no Claude, ChatGPT, Cursor ou outra IA. Ela lê a skill e segue as instruções.

Link da skill

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/implementing-semgrep-for-custom-sast-rules/SKILL.md

Mensagem pronta para colar

Use esta skill para me ajudar: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/implementing-semgrep-for-custom-sast-rules/SKILL.md Leia o arquivo SKILL.md desse link e siga as instruções dele na minha tarefa.
Como funciona

Você escreve regras em um formato especial (YAML) que descreve o que procurar no código. A ferramenta lê essas regras e verifica seu código para encontrar correspondências.

Instalação

Jeito mais fácil: copie o link da skill e cole no Claude, ChatGPT ou Cursor pedindo para seguir as instruções.

No terminal (Claude Code, Codex, Cursor), na pasta do projeto:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill implementing-semgrep-for-custom-sast-rules

Ou baixe só o arquivo:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/implementing-semgrep-for-custom-sast-rules/SKILL.md -o SKILL.md
Conteúdo técnico (SKILL.md)

Tradução do texto original do autor no GitHub. Os comandos e códigos estão como no original.

Implementando Semgrep para Regras SAST Personalizadas

Visão Geral

Semgrep é uma ferramenta de análise estática de código aberto que usa correspondência de padrões para encontrar bugs, impor padrões de código e detectar vulnerabilidades de segurança. Regras personalizadas são escritas em YAML usando a sintaxe de padrões do Semgrep, tornando-o acessível sem a necessidade de conhecimento de compilador. Ele suporta mais de 30 linguagens, incluindo Python, JavaScript, Go, Java e C.

Quando Usar

  • Ao implantar ou configurar a implementação de regras SAST personalizadas do Semgrep em seu ambiente
  • Ao estabelecer controles de segurança alinhados aos requisitos de conformidade
  • Ao construir ou melhorar a arquitetura de segurança para este domínio
  • Ao realizar avaliações de segurança que exigem esta implementação

Pré-requisitos

  • Python 3.8+ ou Docker
  • Semgrep CLI instalado
  • Base de código alvo em uma linguagem suportada

Instalação

# Install via pip
pip install semgrep

# Install via Homebrew
brew install semgrep

# Run via Docker
docker run -v "${PWD}:/src" returntocorp/semgrep semgrep --config auto /src

# Verify
semgrep --version

Executando Semgrep

# Auto-detect rules for your code
semgrep --config auto .

# Use Semgrep registry rules
semgrep --config r/python.lang.security

# Use custom rule file
semgrep --config my-rules.yaml .

# Use multiple configs
semgrep --config auto --config ./custom-rules/ .

# JSON output
semgrep --config auto --json . > results.json

# SARIF output for GitHub
semgrep --config auto --sarif . > results.sarif

# Filter by severity
semgrep --config auto --severity ERROR .

Escrevendo Regras Personalizadas

Correspondência de Padrões Básica

# rules/sql-injection.yaml
rules:
  - id: sql-injection-string-format
    languages: [python]
    severity: ERROR
    message: |
      Potential SQL injection via string formatting.
      Use parameterized queries instead.
    pattern: |
      cursor.execute(f"..." % ...)
    metadata:
      cwe: ["CWE-89"]
      owasp: ["A03:2021"]
      category: security
    fix: |
      cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))

Operadores de Padrão

rules:
  - id: hardcoded-secret-in-code
    languages: [python, javascript, typescript]
    severity: ERROR
    message: Hardcoded secret detected in source code
    patterns:
      - pattern-either:
          - pattern: $VAR = "..."
          - pattern: $VAR = '...'
      - metavariable-regex:
          metavariable: $VAR
          regex: (?i)(password|secret|api_key|token|aws_secret)
      - pattern-not: $VAR = ""
      - pattern-not: $VAR = "changeme"
      - pattern-not: $VAR = "PLACEHOLDER"
    metadata:
      cwe: ["CWE-798"]
      category: security

Análise de Taint

rules:
  - id: xss-taint-tracking
    languages: [python]
    severity: ERROR
    message: User input flows to HTML response without sanitization
    mode: taint
    pattern-sources:
      - pattern: request.args.get(...)
      - pattern: request.form.get(...)
      - pattern: request.form[...]
    pattern-sinks:
      - pattern: return render_template_string(...)
      - pattern: Markup(...)
    pattern-sanitizers:
      - pattern: bleach.clean(...)
      - pattern: escape(...)
    metadata:
      cwe: ["CWE-79"]
      owasp: ["A03:2021"]

Regra para Múltiplas Linguagens

rules:
  - id: insecure-random
    languages: [python, javascript, go, java]
    severity: WARNING
    message: |
      Using insecure random number generator. Use cryptographically
      secure alternatives for security-sensitive operations.
    pattern-either:
      # Python
      - pattern: random.random()
      - pattern: random.randint(...)
      # JavaScript
      - pattern: Math.random()
      # Go
      - pattern: math/rand.Intn(...)
      # Java
      - pattern: new java.util.Random()
    metadata:
      cwe: ["CWE-330"]

Impor Padrões de Codificação

rules:
  - id: require-error-handling
    languages: [go]
    severity: WARNING
    message: Error return value not checked
    pattern: |
      $VAR, _ := $FUNC(...)
    fix: |
      $VAR, err := $FUNC(...)
      if err != nil {
        return fmt.Errorf("$FUNC failed: %w", err)
      }

  - id: no-console-log-in-production
    languages: [javascript, typescript]
    severity: WARNING
    message: Remove console.log before merging to production
    pattern: console.log(...)
    paths:
      exclude:
        - "tests/*"
        - "*.test.*"

Regras de Segurança JWT

rules:
  - id: jwt-none-algorithm

…
Perguntas frequentes

Preciso saber como o computador compila o código para usar?

Não, você não precisa entender como o código é compilado. As regras usam um sistema de 'padrões' que é mais fácil de aprender.

Quais linguagens de programação funcionam?

Funciona com muitas linguagens populares como Python, JavaScript, Go, Java e C.

Posso usar regras prontas ou só criar as minhas?

Você pode usar regras prontas da comunidade ou criar suas próprias regras personalizadas para necessidades específicas.

Detalhes

Descrição original do autor

Write custom Semgrep SAST rules in YAML to detect application-specific vulnerabilities, enforce coding standards, and integrate into CI/CD pipelines.

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularidade

Estrelas no GitHub
35 mil
Posição no ranking
#5956
Licença
Apache-2.0
Atualizada em
31/08/2026

Essa skill é útil?

0

Entre para votar.

Comentários

  • …

Mais skills deste repositório

Skills parecidas