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
crypto-scanner — Ferramenta CLI para verificar bases de código em busca de criptografia vulnerável a quantum. | Kitploit
Ferramentas/GitHubGitHub/mbennett-labs/crypto-scanner
Análise Estática de Código (SAST)Análise de VulnerabilidadesAnálise de CódigoCriptografiaDevSecOpsDetecção de SegredosSegurança da Cadeia de Suprimentos
GitHubmbennett-labs/crypto-scanner

crypto-scanner

Ferramenta CLI para verificar bases de código em busca de criptografia vulnerável a quantum.

Ver Repositório
67há 6 mesesAinda 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

Crypto Scanner

Escaneie sua base de código em busca de criptografia vulnerável a computadores quânticos antes que seja tarde demais.

PyPI Version PyPI Downloads Python 3.10+ License: MIT Build Status

Início Rápido • Por que estar preparado para o quantum? • Uso • Níveis de Risco • CI/CD • Sobre


Visão Geral

Crypto Scanner é uma ferramenta de linha de comando que escaneia sua base de código em busca de algoritmos criptográficos e gera avaliações de risco de vulnerabilidade quântica. Ele analisa código-fonte, arquivos de configuração e certificados X.509 para identificar criptografia que será quebrada por computadores quânticos.

Desenvolvido por Quantum Shield Labs — ajudando organizações a se prepararem para a era pós-quântica.


Por que estar preparado para o quantum?

A Ameaça Quântica é Real

Computadores Quânticos Criptograficamente Relevantes (CRQCs) capazes de quebrar RSA e ECC têm previsão de surgir até 2033. Isso não é ficção científica — é um cronograma para o qual governos e empresas de grande porte estão se preparando ativamente.

Colha Agora, Descriptografe Depois (HNDL)

Adversários já estão coletando dados criptografados hoje com a intenção de descriptografá-los quando computadores quânticos estiverem disponíveis. Se seus dados têm valor de longo prazo (registros de saúde, dados financeiros, segredos comerciais, comunicações governamentais), eles já estão em risco.

Por que você não pode esperar

DesafioRealidade
Complexidade da migração

Algoritmo de Shor: A Ameaça

O algoritmo de Shor, executado em um computador quântico suficientemente poderoso, pode fatorar grandes inteiros e calcular logaritmos discretos de forma eficiente. Isso quebra:

  • RSA (todos os tamanhos de chave)
  • ECDSA/ECC (todas as curvas)
  • DH/ECDH (troca de chaves)
  • DSA (assinaturas digitais)

O Primeiro Passo: Inventário

Você não pode migrar o que não sabe que possui. O Crypto Scanner fornece o inventário criptográfico que é o primeiro passo essencial em qualquer programa de prontidão quântica.

📘 Saiba mais: Leia o Playbook do Quantum Shield Labs para obter orientação abrangente de migração.


Início Rápido

Obtenha sua primeira varredura de vulnerabilidade quântica em menos de 60 segundos:

root@kitploit:~
# Instalar a partir do PyPI
pip install crypto-scanner

# Escanear seu projeto
crypto-scanner scan .

# Gerar um relatório HTML executivo
crypto-scanner scan . --html --output quantum-risk-report.html

Pronto. Agora você tem um inventário criptográfico completo da sua base de código.


Instalação

Via PyPI (Recomendado)

root@kitploit:~
pip install crypto-scanner

A partir do código fonte

root@kitploit:~
git clone https://github.com/mbennett-labs/crypto-scanner.git
cd crypto-scanner
pip install -e .

Requisitos

  • Python 3.10 ou superior
  • Funciona em Windows, macOS e Linux

Uso

Comandos Básicos

root@kitploit:~
# Escanear um diretório (saída JSON para stdout)
crypto-scanner scan <diretório>

# Mostrar tipos de arquivo suportados e classificações de risco
crypto-scanner info

# Exibir versão
crypto-scanner --version

Opções de CLI

Exemplos

root@kitploit:~
# Escanear com saída detalhada
crypto-scanner scan ./src --verbose

# Salvar relatório JSON em arquivo
crypto-scanner scan . --output crypto-audit.json

# Gerar relatório HTML personalizado para as partes interessadas
crypto-scanner scan . --html --output quantum-assessment.html

# Excluir diretórios específicos
crypto-scanner scan . --exclude vendor --exclude legacy

# Excluir padrões de arquivo
crypto-scanner scan . --exclude "*.test.js" --exclude "*.spec.ts"

# Combinar opções
crypto-scanner scan ./backend -v --exclude node_modules -o report.json

Exclusões Padrão

Os seguintes são excluídos automaticamente para evitar escanear dependências:

root@kitploit:~
.git, .svn, .hg          # Controle de versão
node_modules, vendor     # Dependências de pacotes
__pycache__, .pytest_cache, .mypy_cache
.venv, venv, env         # Ambientes virtuais
dist, build, out         # Saídas de build
.idea, .vscode           # Diretórios de IDE
site-packages, third_party

Classificação de Risco

Crítico — Vulnerável a Quantum

Algoritmos que serão completamente quebrados pelo algoritmo de Shor:

Alto — Obsoleto ou Fraco

Algoritmos com vulnerabilidades clássicas conhecidas:

Médio — Monitorar

Algoritmos atualmente seguros, mas que devem ser monitorados:

Baixo — Adequado ou Resistente a Quantum

Algoritmos que fornecem proteção adequada:


Tipos de Arquivo Suportados

Código Fonte

Arquivos de Configuração

Certificados

ExtensãoFormato
.pemCodificado PEM
.crt, .cer, .certCertificado
.derCodificado DER

Formatos de Saída

Relatório JSON

Formato de saída padrão, ideal para automação e pipelines CI/CD:

root@kitploit:~
{
  "scan_directory": "/caminho/para/projeto",
  "scan_timestamp": "2026-02-06T10:30:00",
  "scanner_version": "0.1.0",
  "summary": {
    "total_files_scanned": 150,
    "total_findings": 23,
    "critical_count": 5,
    "high_count": 8,
    "medium_count": 7,
    "low_count": 3
  },
  "excluded_patterns": [".git", "node_modules", "..."],
  "findings": [
    {
      "file_path": "/caminho/para/auth.py",
      "line_number": 42,
      "algorithm": "RSA",
      "key_size": 2048,
      "risk_level": "critical",
      "description": "Geração de chave RSA detectada",
      "recommendation": "Planeje a migração para algoritmos pós-quânticos (ML-KEM, ML-DSA)",
      "context": "key = rsa.generate_private_key(public_exponent=65537, key_size=2048)"
    }
  ]
}

Relatório HTML

Relatório profissional e autônomo com a marca do Quantum Shield Labs:

  • Resumo executivo com métricas de risco em um relance
  • Gráfico visual de distribuição de risco
  • Tabela de descobertas ordenável com filtragem
  • Tema escuro otimizado para legibilidade
  • Arquivo único sem dependências externas (fácil de compartilhar)

Gerar com:

root@kitploit:~
crypto-scanner scan . --html --output report.html

Integração CI/CD

GitHub Actions

root@kitploit:~
name: Varredura de Vulnerabilidade Criptográfica

on: [push, pull_request]

jobs:
  crypto-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Configurar Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

      - name: Instalar Crypto Scanner
        run: pip install crypto-scanner

      - name: Executar Varredura Criptográfica
        run: crypto-scanner scan ./src --output crypto-report.json

      - name: Verificar Descobertas Críticas
        run: |
          CRITICAL=$(jq '.summary.critical_count' crypto-report.json)
          if [ "$CRITICAL" -gt 0 ]; then
            echo "::error::Encontrados $CRITICAL algoritmos críticos vulneráveis a quantum!"
            jq '.findings[] | select(.risk_level == "critical")' crypto-report.json
            exit 1
          fi

      - name: Enviar Relatório
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: relatorio-vulnerabilidade-criptografica
          path: crypto-report.json

GitLab CI

root@kitploit:~
crypto-scan:
  stage: security
  image: python:3.12
  script:
    - pip install crypto-scanner
    - crypto-scanner scan . --output crypto-report.json
    - |
      CRITICAL=$(jq '.summary.critical_count' crypto-report.json)
      if [ "$CRITICAL" -gt 0 ]; then
        echo "Criptografia crítica vulnerável a quantum detectada!"
        exit 1
      fi
  artifacts:
    reports:
      dotenv: crypto-report.json
    paths:
      - crypto-report.json
    when: always

Hook Pre-commit

Adicionar ao .pre-commit-config.yaml:

root@kitploit:~
repos:
  - repo: local
    hooks:
      - id: crypto-scanner
        name: Crypto Scanner
        entry: bash -c 'crypto-scanner scan . --output /tmp/crypto-scan.json && CRITICAL=$(jq ".summary.critical_count" /tmp/crypto-scan.json) && [ "$CRITICAL" -eq 0 ]'
        language: system
        pass_filenames: false
        always_run: true

Script Shell Simples

root@kitploit:~
#!/bin/bash
# crypto-check.sh - Falhar se vulnerabilidades críticas forem encontradas

set -e

crypto-scanner scan . --output /tmp/crypto-report.json

CRITICAL=$(jq '.summary.critical_count' /tmp/crypto-report.json)
HIGH=$(jq '.summary.high_count' /tmp/crypto-report.json)

echo "Varredura concluída: $CRITICAL críticas, $HIGH descobertas de alto risco"

if [ "$CRITICAL" -gt 0 ]; then
    echo "FALHOU: Criptografia crítica vulnerável a quantum detectada!"
    exit 1
fi

Arquitetura

root@kitploit:~
crypto-scanner/
├── src/crypto_scanner/
│   ├── cli.py              # Interface CLI Typer
│   ├── scanner.py          # Lógica de orquestração principal
│   ├── models.py           # Modelos de dados Pydantic
│   ├── patterns.py         # 50+ padrões de detecção regex
│   ├── analyzers/          # Analisadores de tipo de arquivo
│   │   ├── base.py         # Classe base abstrata
│   │   ├── source.py       # Analisador de código fonte (14 linguagens)
│   │   ├── config.py       # Analisador de arquivo de configuração
│   │   └── certificate.py  # Analisador de certificado X.509
│   └── reporters/          # Geradores de saída
│       ├── json_reporter.py
│       └── html_reporter.py
└── tests/                  # Suíte de testes abrangente

Como Funciona

  1. Scanner percorre recursivamente o diretório alvo, respeitando os padrões de exclusão
  2. Analyzers são despachados com base na extensão do arquivo:
    • SourceCodeAnalyzer — Correspondência de padrões em 14 linguagens de programação
    • ConfigAnalyzer — Análise YAML/JSON + correspondência de padrões para arquivos de configuração
    • CertificateAnalyzer — Análise X.509 para extrair algoritmos e tamanhos de chave
  3. Patterns módulo contém 50+ padrões regex para detecção de API criptográfica
  4. Reporters agregam descobertas em formato JSON ou HTML

Contribuindo

Contribuições são bem-vindas! Veja como começar:

Configuração de Desenvolvimento

root@kitploit:~
git clone https://github.com/mbennett-labs/crypto-scanner.git
cd crypto-scanner
pip install -e ".[dev]"

Executando Testes

root@kitploit:~
# Executar todos os testes
pytest tests/ -v

# Executar com cobertura
pytest tests/ -v --cov=crypto_scanner --cov-report=html

Adicionando Novos Padrões

Os padrões criptográficos estão definidos em src/crypto_scanner/patterns.py. Cada padrão inclui:

  • Padrão regex para detecção
  • Nome do algoritmo
  • Nível de risco (CRÍTICO, ALTO, MÉDIO, BAIXO)
  • Descrição e recomendação

Diretrizes para Pull Requests

  1. Faça um fork do repositório
  2. Crie um branch de funcionalidade (git checkout -b feature/novo-padrao)
  3. Adicione testes para a nova funcionalidade
  4. Certifique-se de que todos os testes passam (pytest tests/ -v)
  5. Envie um pull request com uma descrição clara

Licença

Licença MIT — consulte LICENSE para detalhes.


Sobre o Quantum Shield Labs

Quantum Shield Labs

Quantum Shield Labs ajuda organizações a se prepararem para a era pós-quântica com:

  • Avaliações de Risco Quântico — Inventário criptográfico abrangente e análise de risco
  • Planejamento de Migração PQC — Roteiros para transição para algoritmos resistentes a quantum
  • Briefings Executivos — Apresentações para o conselho sobre risco quântico
  • Treinamento para Desenvolvedores — Workshops práticos para equipes de engenharia

Recursos

  • Playbook de Prontidão Quântica
  • Blog
  • Contato

Construído com carinho por Quantum Shield Labs

Baixar ferramenta
Grandes bases de código levam de 3 a 5+ anos para transitar
Profundidade da cadeia de suprimentosSuas dependências contêm criptografia vulnerável que você não vê
Obrigações de conformidadePadrões PQC do NIST (ML-KEM, ML-DSA) agora estão finalizados
Prazo CNSA 2.0NSA exige algoritmos resistentes a quantum até 2033
OpçãoAbreviaçãoDescrição
--htmlGerar relatório HTML em vez de JSON
--output-oSalvar relatório em arquivo (em vez de stdout)
--verbose-vMostrar progresso detalhado da varredura
--exclude-ePadrões de exclusão adicionais (repetível)
--version-VMostrar versão e sair
AlgoritmoTamanhos de ChaveImpacto QuânticoAção Recomendada
RSATodos (1024-4096+)Completamente quebradoMigrar para ML-KEM + ML-DSA
ECDSA/ECCTodas as curvasCompletamente quebradoMigrar para ML-DSA
DH/ECDHTodosTroca de chaves quebradaMigrar para ML-KEM
DSATodosCompletamente quebradoMigrar para ML-DSA
AlgoritmoProblemaAção Recomendada
MD5Ataques de colisão, completamente quebradoSubstituir por SHA-3 ou SHA-256
SHA-1Ataques de colisão demonstradosSubstituir por SHA-256+
DESChave de 56 bits, trivialmente quebradoSubstituir por AES-256
3DESAtaques meet-in-the-middleSubstituir por AES-256
AES-128Algoritmo de Grover reduz a segurançaAtualizar para AES-256
AlgoritmoStatusAção Recomendada
SHA-256Seguro, Grover reduz a 128 bitsPlanejar migração para SHA-3
SHA-384SeguroMonitorar desenvolvimentos
SHA-512Boa resistência quânticaMonitorar desenvolvimentos
TLS 1.2Seguro, mas envelhecendoPreferir TLS 1.3
AlgoritmoStatusObservações
AES-256Resistente a quantumSegurança pós-quântica de 128 bits
ChaCha20Moderno, seguroBoa alternativa ao AES
SHA-3Padrão NIST mais recenteRecomendado para novos projetos
ML-KEMPós-quântico (Kyber)Padronizado pelo NIST em 2024
ML-DSAPós-quântico (Dilithium)Padronizado pelo NIST em 2024
ExtensãoLinguagem
.py, .pywPython
.js, .mjs, .cjsJavaScript
.ts, .tsxTypeScript
.javaJava
.goGo
.rsRust
.c, .h, .cpp, .hppC/C++
.csC#
.rbRuby
.phpPHP
.swiftSwift
.kt, .ktsKotlin
.scalaScala
ExtensãoFormato
.yaml, .ymlYAML
.jsonJSON
.tomlTOML
.ini, .cfg, .conf, .configINI/Config
.envVariáveis de ambiente