Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
SAFE — Um sistema contextual de auditoria de segurança para artefatos de pesquisa | Kitploit
Ferramentas/GitHubGitHub/nanda-rani/safe
Análise EstáticaAnálise de VulnerabilidadesAnálise de CódigoAprendizado e EducaçãoSegurança de IA
GitHubnanda-rani/safe

SAFE

Um sistema contextual de auditoria de segurança para artefatos de pesquisa

Ver Repositório
há 14 diasAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

SAFE

O SAFE realiza uma avaliação de segurança controlada e ciente do repositório de descobertas do Semgrep e Trivy em artefatos de pesquisa.

Ele suporta duas tarefas de classificação independentes: predição direta binária (SECURITY_RELEVANT ou NON_SECURITY) e a taxonomia contextual detalhada multiclasse (três rótulos — veja Três rótulos). Cada tarefa pode ser executada em modo zero-shot ou agêntico.

Ele espera apenas:

  1. Um CSV de descobertas delimitado por ponto e vírgula.
  2. Um diretório contendo uma pasta de artefato de pesquisa por artifact_id.
  3. Opcionalmente, uma coleção de PDFs/textos de artigos indexada por artifact_id.
  4. Uma chave de API da OpenAI ou acesso a um proxy LiteLLM da organização.

Ele não treina nem ajusta com base em nenhum dado de avaliação rotulado. Os dados rotulados são usados apenas após a inferência, para avaliar as predições, e nunca são vistos pelo classificador. O SAFE nunca executa código de artefato; o texto do repositório é tratado como evidência não confiável, não como instruções.

Esta versão contém o código-fonte completo do safe_audit, CLI e testes, além de um demo/ autocontido com três artefatos de exemplo totalmente sintéticos que você pode executar de ponta a ponta sem nenhum dado externo. Ela exclui o corpus real de artefatos de pesquisa, os rótulos de referência (ground truth) e as descobertas de avaliação usados no artigo.

Baixar ferramenta

Início rápido: após a Instalação, execute a Demo — ela funciona imediatamente sem configuração de dados. O config.example.yaml, abordado mais adiante em Configuração, é um modelo para suas próprias descobertas/artefatos e não será executado até que você o edite.

Instalação

root@kitploit:~
cd path/to/safe-artifact-auditor
python3 -m venv .venv
source .venv/bin/activate
pip install -e .

Defina a chave da API:

root@kitploit:~
export OPENAI_API_KEY="your-key"

Para um proxy LiteLLM da organização, use config.litellm.example.yaml — ele vem comentado inline. As credenciais e os valores de cabeçalho personalizados são lidos de variáveis de ambiente e nunca são armazenados na configuração do SAFE ou nos arquivos de resultado.

Demo

demo/ contém três artefatos de exemplo pequenos e totalmente sintéticos — nenhum derivado ou correspondente a qualquer artefato de pesquisa publicado real — um por rótulo da taxonomia, para que revisores possam exercitar o pipeline completo sem nenhum dado externo:

  • demo-contextual-risk/ — um agregador de checkpoints de aprendizado federado de brinquedo que desserializa um checkpoint baixado de uma URL fornecida pelo chamador com torch.load. Entrada não confiável e originada da rede atinge um sumidouro de desserialização insegura, que o SAFE deve classificar como CONTEXTUAL_RISK.
  • demo-hardening-recommendation/ — um harness de benchmark de brinquedo que executa subprocess.run(..., shell=True) contra linhas de comando que são todas literais Python codificadas, sem entrada controlada pelo chamador. Espera-se que o SAFE classifique isso como HARDENING_RECOMMENDATION: o padrão de shell é real e vale a pena sinalizar, mas nada externo pode alcançá-lo ou influenciá-lo.
  • demo-false-positive/ — um gerador de fixtures de teste fixado em uma versão antiga do Pillow com um aviso hipotético de bomba de descompressão. O código apenas cria novas imagens em memória e nunca abre dados externos, portanto o caminho de código real do aviso nunca é alcançado. Espera-se que o SAFE classifique isso como FALSE_POSITIVE.

demo/findings.csv contém uma descoberta por artefato, e demo/demo-zero-shot.yaml / demo/demo-agentic.yaml são configurações prontas para execução (artifact_root: . resolve relativo ao arquivo de configuração, então execute de dentro de demo/):

root@kitploit:~
cd demo
safe-audit run --config demo-zero-shot.yaml
safe-audit run --config demo-agentic.yaml

Os resultados vão para demo/runs/demo-zero-shot/ e demo/runs/demo-agentic/ respectivamente (veja Saída).

Três rótulos

  • CONTEXTUAL_RISK
  • HARDENING_RECOMMENDATION
  • FALSE_POSITIVE

Nenhuma categoria adicional e nenhuma regra determinística de alteração de rótulo é usada. Um mecanismo de pesquisa/segurança documentado e isolado no próprio código de um artefato é classificado como HARDENING_RECOMMENDATION, pois a prática subjacente ainda é real mesmo quando o isolamento limita a explorabilidade realista.

Classes binárias

  • SECURITY_RELEVANT: um risco contextual válido ou uma preocupação de endurecimento, incluindo comportamento intencional e isolado de pesquisa em segurança.
  • NON_SECURITY: uma descoberta falsa, incompatível, não aplicável, ausente ou de recurso afetado comprovadamente não utilizado.

O avaliador também deriva uma visão binária das predições multiclasse: FALSE_POSITIVE torna-se NON_SECURITY; todos os outros rótulos multiclasse tornam-se SECURITY_RELEVANT. Os resultados binários diretos e derivados permanecem explicitamente separados.

Estrutura de entrada

root@kitploit:~
project/
├── config.yaml
├── data/
│   └── findings.csv
└── artifacts/
    ├── artifact_001/
    ├── artifact_002/
    └── artifact_003/

O mapeamento é exato: artifact_id = artifact_001 resolve para artifacts/artifact_001/.

Colunas CSV obrigatórias:

root@kitploit:~
artifact_id;tool;finding_id

Colunas opcionais:

root@kitploit:~
artifact_id;tool;finding_id;category;severity_raw;file;line;message;package;version;cwe;cvss;scanner_applicable

Uma coluna de índice inicial sem nome é ignorada. Colunas adicionais são preservadas pelo modelo de entrada.

Exemplo:

root@kitploit:~
artifact_id;tool;finding_id;category;severity_raw;file;line;message;package;version;cwe;cvss;scanner_applicable
artifact_001;semgrep;python.lang.security.audit.subprocess-shell-true;code;HIGH;src/probe.py;42;Shell command uses shell=True;;;;CWE-78;;yes
artifact_002;trivy;DEMO-CVE-0001;dependency;HIGH;;;Affected package (illustrative, not a real CVE);example-lib;1.2.0;CWE-502;8.1;yes

Gerar descobertas a partir de um novo código-base

scripts/run_scanners.py e scripts/build_findings_csv.py produzem o findings.csv e o layout de artefatos descritos acima diretamente do seu próprio código, usando Semgrep e Trivy.

Instale o Semgrep (funciona da mesma forma em qualquer SO, incluindo Linux):

root@kitploit:~
pip install semgrep

Instale o Trivy no Linux — ou o repositório apt (Debian/Ubuntu):

root@kitploit:~
sudo apt-get install wget gnupg
wget -qO - https://aquasecurity.github.io/trivy-repo/deb/public.key | gpg --dearmor | sudo tee /usr/share/keyrings/trivy.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/trivy.gpg] https://aquasecurity.github.io/trivy-repo/deb generic main" | sudo tee -a /etc/apt/sources.list.d/trivy.list
sudo apt-get update
sudo apt-get install trivy

ou o script de instalação oficial, que funciona em qualquer distribuição Linux e instala um binário de lançamento em /usr/local/bin (sem pacotes de root além de sudo para esse diretório):

root@kitploit:~
curl -sfL https://raw.githubusercontent.com/aquasecurity/trivy/main/contrib/install.sh | sudo sh -s -- -b /usr/local/bin

Verifique se ambos estão no PATH antes de continuar:

root@kitploit:~
semgrep --version
trivy --version

Em seguida, organize um diretório por artefato sob um artifact_root/ e execute:

root@kitploit:~
python scripts/run_scanners.py artifact_root --output scan-output
python scripts/build_findings_csv.py scan-output --output data/findings.csv

O primeiro comando executa o Semgrep e o Trivy (varredura de vulnerabilidades e segredos) contra cada diretório de artefato e salva o JSON bruto do scanner. O segundo analisa esse JSON em um findings.csv compatível com o SAFE (as colunas correspondem à Estrutura de entrada; file é relatado relativo a cada diretório de artefato). Passe --skip-semgrep/--skip-trivy a qualquer um dos scripts para executar apenas uma ferramenta. O --config no run_scanners.py fixa um conjunto de regras específico do Semgrep em vez do auto padrão, que é conveniente, mas não fixado de forma reproduzível.

Configuração

Esta seção é para executar o SAFE contra seu próprio CSV de descobertas e pastas de artefatos (veja Estrutura de entrada acima). Se você apenas quiser ver o SAFE em execução, use a Demo — o config.example.yaml abaixo é um modelo e não será executado como está.

Copie o config.example.yaml:

root@kitploit:~
cp config.example.yaml config.yaml

Em seguida, edite input_csv e artifact_root (e opcionalmente paper_root) para apontar para seus próprios dados antes de executar.

Configurações principais:

  • model / provider: identificador exato do modelo OpenAI (ou alias LiteLLM), e openai ou litellm com URL do proxy e nome da variável de ambiente da credencial.
  • analysis_mode: zero_shot ou agentic.
  • classification_task: binary ou multiclass; independente de analysis_mode.
  • max_agent_steps: necessário apenas em uma configuração agêntica.
  • max_workers / max_output_tokens / max_schema_retries: concorrência, teto de saída por resposta e orçamento de novas tentativas de chamada de modelo para respostas inválidas de esquema.
  • resume / resume_policy: incomplete tenta novamente falhas, artefatos ausentes e descobertas não tentadas; failed_only tenta novamente apenas falhas, mantendo os sucessos registrados.
  • cost: contabilidade de custo opcional em tempo real e término por max_run_cost_usd.

O modelo padrão é gpt-5.6-sol. Altere-o explicitamente se os requisitos de disponibilidade, custo ou latência forem diferentes.

Executar análise

root@kitploit:~
safe-audit run --config config.yaml

Ou sem instalar o comando de console:

root@kitploit:~
PYTHONPATH=src python -m safe_audit.cli run --config config.yaml

Para uma comparação executável e correspondente com os dados sintéticos incluídos, veja Demo (demo/demo-zero-shot.yaml e demo/demo-agentic.yaml). Eles diferem apenas em analysis_mode e run_name. O zero-shot faz uma chamada de modelo sobre a evidência base. O modo agêntico começa com a mesma evidência e pode chamar ferramentas de repositório somente leitura limitadas antes de retornar o mesmo resultado estruturado.

Saída

root@kitploit:~
runs/<run_name>/
├── config.resolved.yaml
├── run_metadata.json
├── summary.json
├── results.jsonl
├── results.csv
├── profiles/
├── evidence/
├── raw/<finding_uid>/
│   ├── 0001-request.json
│   ├── 0001-response.json (ou 0001-error.json)
│   └── final-output.txt
└── logs/
    ├── events.jsonl
    ├── result_attempts.jsonl
    └── run_sessions.jsonl

O results.csv destina-se à análise. O results.jsonl preserva os registros estruturados completos. Evidências e saídas brutas do modelo apoiam auditoria e análise de erros. Ambos são canônicos: contêm apenas o registro mais recente de cada descoberta, enquanto logs/result_attempts.jsonl é somente de acréscimo e preserva todos os resultados históricos.

Ao retomar, o SAFE primeiro re-analisa as respostas brutas salvas de cada descoberta com falha usando o parser estrito atual; uma classificação exclusivamente válida é recuperada sem uma chamada de API. Apenas falhas irrecuperáveis são agendadas para inferência de modelo. Para uma continuação somente de falhas de uma execução parcialmente concluída, mantenha o mesmo output_root e run_name e defina:

root@kitploit:~
resume: true
resume_policy: failed_only

Para avaliar predições contra um CSV dourado rotulado (com uma coluna security_label ou security_class):

root@kitploit:~
safe-audit evaluate --results runs/<run_name>/results.jsonl --gold GOLD.csv --output runs/<run_name>/evaluation.json

Testes

root@kitploit:~
PYTHONPATH=src python -m unittest discover -s tests -v

A suíte de testes usa um provedor falso e, portanto, não requer uma chave de API.