image

Acesse bootcamps ilimitados e +650 cursos pra sempre

75
%OFF
Sidney Rezende
Sidney Rezende15/06/2025 10:48
Compartilhe

Título do artigo

    🛡️ Criando um Agente para Detecção de Vulnerabilidades em Arquivos

    A segurança da informação é uma das áreas mais críticas da tecnologia, e uma das primeiras linhas de defesa é a detecção de vulnerabilidades em arquivos enviados ou manipulados por sistemas. Neste artigo, vamos construir um agente simples de detecção de vulnerabilidades em arquivos, com foco em arquivos de código (como .py, .php, .js) e arquivos de configuração (como .env, .json, etc).

    Nosso objetivo será criar uma ferramenta que possa ser integrada em pipelines de CI/CD ou usada localmente para identificar padrões perigosos, como exposições de senhas, comandos maliciosos ou más práticas de codificação.

    📌 O que é um agente de detecção de vulnerabilidades?

    Um agente de detecção é basicamente um script ou aplicação que analisa arquivos em busca de sinais de alerta. Ele pode funcionar como um scanner local, uma API ou um plugin em um fluxo de trabalho DevSecOps.

    🧠 Conceito: O que vamos analisar?

    Vamos procurar por:

    • Chaves de API e senhas hardcoded
    • Comandos potencialmente perigosos (os.system, eval, exec, etc.)
    • Bibliotecas conhecidas por terem brechas de segurança
    • Informações sensíveis em arquivos .env e .json

    🛠️ Mão na massa: Criando o agente em Python

    Vamos usar Python por ser rápido de prototipar e ter ótimas bibliotecas para análise de strings e arquivos.

    1. Estrutura do Projeto

    vuln_scanner/
    ├── scanner.py
    ├── signatures.json
    └── samples/
      ├── test.py
      └── .env
    

    2. Arquivo de assinaturas (signatures.json)

    {
    "patterns": [
      {
        "name": "Uso de eval",
        "regex": "eval\\s*\\(",
        "severity": "alta"
      },
      {
        "name": "Token hardcoded",
        "regex": "(token|senha|password|secret)[\\s:=]+['\\\"]?[A-Za-z0-9\\-_=]{8,}",
        "severity": "média"
      },
      {
        "name": "Comando shell",
        "regex": "os\\.system\\s*\\(",
        "severity": "alta"
      }
    ]
    }
    

    3. O agente (scanner.py)

    import os
    import re
    import json
    
    def carregar_assinaturas(caminho="signatures.json"):
      with open(caminho, 'r') as file:
          return json.load(file)["patterns"]
    
    def escanear_arquivo(arquivo, assinaturas):
      vulnerabilidades = []
      try:
          with open(arquivo, 'r', encoding='utf-8') as f:
              conteudo = f.read()
              for sig in assinaturas:
                  if re.search(sig["regex"], conteudo, re.IGNORECASE):
                      vulnerabilidades.append((sig["name"], sig["severity"]))
      except Exception as e:
          print(f"[!] Erro ao ler {arquivo}: {e}")
      return vulnerabilidades
    
    def escanear_pasta(pasta, assinaturas):
      for root, dirs, files in os.walk(pasta):
          for file in files:
              caminho = os.path.join(root, file)
              vulns = escanear_arquivo(caminho, assinaturas)
              if vulns:
                  print(f"\n[!] Vulnerabilidades encontradas em {caminho}:")
                  for v in vulns:
                      print(f" - {v[0]} (Severidade: {v[1]})")
    
    if __name__ == "__main__":
      print("🔍 Iniciando varredura de vulnerabilidades...")
      sigs = carregar_assinaturas()
      escanear_pasta("samples", sigs)
    

    ✅ Resultado

    Quando você rodar o script, ele irá vasculhar os arquivos da pasta samples e te mostrar possíveis pontos vulneráveis com base nas assinaturas definidas. Exemplo de saída:

    🔍 Iniciando varredura de vulnerabilidades...
    
    [!] Vulnerabilidades encontradas em samples/test.py:
     - Uso de eval (Severidade: alta)
     - Comando shell (Severidade: alta)
    
    [!] Vulnerabilidades encontradas em samples/.env:
     - Token hardcoded (Severidade: média)
    

    🔒 Como melhorar esse agente?

    • ✅ Adicionar suporte a arquivos YAML, INI, XML
    • ✅ Integrar com o GitHub Actions ou GitLab CI
    • ✅ Exportar resultados em formato JSON ou HTML
    • ✅ Adicionar classificação CVSS
    • ✅ Usar machine learning para detectar padrões desconhecidos

    🚀 Conclusão

    Criar um agente de detecção de vulnerabilidades não precisa ser complicado. Mesmo soluções simples, como a que criamos aqui, aumentam muito a segurança do seu projeto. Esse é um ótimo primeiro passo para adotar uma mentalidade DevSecOps e proteger seu código desde o início.

    Se curtiu esse conteúdo, me segue aqui na DIO e compartilha com quem também quer aprender mais sobre segurança da informação na prática! 💻🔐

    Compartilhe
    Recomendados para você
    CI&T - Backend com Java & AWS
    CAIXA - Inteligência Artificial na Prática
    Binance - Blockchain Developer with Solidity 2025
    Comentários (4)
    Sidney Rezende
    Sidney Rezende - 11/10/2025 11:06

    Gustavo Vianna, Com certeza! A mentalidade DevSecOps não só fortalece a segurança, mas também traz ganhos diretos para o negócio — reduzindo riscos, custos com retrabalho e tempo de resposta a incidentes. Além disso, ela promove maior confiança entre as equipes e entregas mais consistentes, o que se traduz em valor real para clientes e stakeholders. 

    Sidney Rezende
    Sidney Rezende - 11/10/2025 11:04

    DIO Community , Muito obrigado pelo reconhecimento e pelo feedback! Fico muito feliz em saber que o artigo contribui para difundir práticas de segurança aplicadas desde as fases iniciais do desenvolvimento.

    Em relação às melhorias, acredito que algumas evoluções interessantes poderiam ser:

    • Ampliação da base de assinaturas dinâmicas: permitir que o agente aprenda novos padrões de vulnerabilidades a partir de repositórios públicos (como CVEs recentes) e mantenha seu banco de regras atualizado automaticamente.
    • Análise contextual: integrar o agente com análise de fluxo de dados e dependências para detectar vulnerabilidades que não são visíveis apenas pelo código estático.
    • Machine Learning: sim, essa é uma direção que considero promissora! Modelos de aprendizado supervisionado poderiam ser treinados com exemplos reais de código vulnerável e seguro, melhorando a capacidade de detecção e reduzindo falsos positivos. Além disso, técnicas de anomaly detection ajudariam a identificar comportamentos suspeitos em padrões de código pouco comuns.
    • Integração contínua (CI/CD): integrar o agente diretamente em pipelines para que a verificação seja parte natural do ciclo DevSecOps.

    Essas melhorias tornariam o agente mais inteligente, adaptável e próximo do conceito de “security as code” — uma mentalidade que acredito ser o futuro da segurança em desenvolvimento.

    DIO Community
    DIO Community - 16/06/2025 16:10

    Sidney, que iniciativa excelente! Seu artigo oferece uma abordagem prática e eficiente para a criação de um agente de detecção de vulnerabilidades, algo essencial para a segurança em desenvolvimento. A estrutura clara e a explicação das ferramentas que você utilizou, como o uso de expressões regulares e assinaturas de padrões, tornam o processo acessível e altamente aplicável para desenvolvedores que buscam implementar segurança de forma proativa. O uso de Python para prototipagem rápida também é uma excelente escolha, considerando a simplicidade e eficiência da linguagem.

    Na DIO, acreditamos no impacto de conteúdos como o seu, que não só capacitam tecnicamente, mas também promovem boas práticas desde o início do desenvolvimento. Seu trabalho ressalta a importância de integrar a segurança de forma contínua e automatizada nas fases de desenvolvimento, algo fundamental na mentalidade DevSecOps.

    Quais melhorias você acredita que seriam as mais impactantes para esse agente de detecção de vulnerabilidades? Já pensou em explorar alguma abordagem de machine learning para tornar a detecção ainda mais precisa e autônoma?

    Gustavo Vianna
    Gustavo Vianna - 15/06/2025 13:39

    Show de bola, Sidney! Lembrando que essa mentalidade DevSecOps é excelente para os negócios.