Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
crypto-scanner — Herramienta CLI para escanear bases de código en busca de criptografía vulnerable a la computación cuántica | Kitploit
Herramientas/GitHubGitHub/mbennett-labs/crypto-scanner
Análisis Estático de Código (SAST)Análisis de VulnerabilidadesAnálisis de CódigoCriptografíaDevSecOpsDetección de SecretosSeguridad de Cadena de Suministro
GitHubmbennett-labs/crypto-scanner

crypto-scanner

Herramienta CLI para escanear bases de código en busca de criptografía vulnerable a la computación cuántica

Ver Repositorio
6hace 6 mesesAún no revisado

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

Crypto Scanner

Escanea tu código base en busca de criptografía vulnerable a la computación cuántica antes de que sea demasiado tarde.

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

Inicio Rápido • ¿Por qué Prepararse para la Cuántica? • Uso • Niveles de Riesgo • CI/CD • Acerca de


Resumen

Crypto Scanner es una herramienta CLI que escanea tu código base en busca de algoritmos criptográficos y genera evaluaciones de riesgo de vulnerabilidad cuántica. Analiza código fuente, archivos de configuración y certificados X.509 para identificar criptografía que será quebrada por ordenadores cuánticos.

Desarrollado por Quantum Shield Labs — ayudando a las organizaciones a prepararse para la era post-cuántica.


¿Por qué Prepararse para la Cuántica?

La Amenaza Cuántica es Real

Se proyecta que los Ordenadores Cuánticos Criptográficamente Relevantes (CRQCs, por sus siglas en inglés) capaces de romper RSA y ECC surjan para el 2033. Esto no es ciencia ficción: es un cronograma para el que los principales gobiernos y empresas se están preparando activamente.

Cosecha Ahora, Descifra Después (HNDL)

Los adversarios ya están recopilando datos cifrados hoy con la intención de descifrarlos una vez que los ordenadores cuánticos estén disponibles. Si tus datos tienen valor a largo plazo (registros médicos, datos financieros, secretos comerciales, comunicaciones gubernamentales), ya están en riesgo.

Por Qué No Puedes Esperar

DesafíoRealidad
Complejidad de migración

El Algoritmo de Shor: La Amenaza

El algoritmo de Shor, ejecutándose en un ordenador cuántico suficientemente potente, puede factorizar eficientemente números enteros grandes y calcular logaritmos discretos. Esto rompe:

  • RSA (todos los tamaños de clave)
  • ECDSA/ECC (todas las curvas)
  • DH/ECDH (intercambio de claves)
  • DSA (firmas digitales)

El Primer Paso: Inventario

No puedes migrar lo que no sabes que tienes. Crypto Scanner proporciona el inventario criptográfico que es el primer paso esencial en cualquier programa de preparación cuántica.

📘 Más información: Lee el Manual de Quantum Shield Labs para obtener una guía completa de migración.


Inicio Rápido

Obtén tu primer escaneo de vulnerabilidad cuántica en menos de 60 segundos:

root@kitploit:~
# Instalar desde PyPI
pip install crypto-scanner

# Escanea tu proyecto
crypto-scanner scan .

# Genera un informe HTML ejecutivo
crypto-scanner scan . --html --output quantum-risk-report.html

Eso es todo. Ahora tienes un inventario criptográfico completo de tu código base.


Instalación

Desde PyPI (Recomendado)

root@kitploit:~
pip install crypto-scanner

Desde el Código Fuente

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

Requisitos

  • Python 3.10 o superior
  • Funciona en Windows, macOS y Linux

Uso

Comandos Básicos

root@kitploit:~
# Escanea un directorio (salida JSON a stdout)
crypto-scanner scan <directorio>

# Muestra los tipos de archivo compatibles y las clasificaciones de riesgo
crypto-scanner info

# Muestra la versión
crypto-scanner --version

Opciones de CLI

Ejemplos

root@kitploit:~
# Escanear con salida detallada
crypto-scanner scan ./src --verbose

# Guardar informe JSON en archivo
crypto-scanner scan . --output crypto-audit.json

# Generar informe HTML con marca para partes interesadas
crypto-scanner scan . --html --output quantum-assessment.html

# Excluir directorios específicos
crypto-scanner scan . --exclude vendor --exclude legacy

# Excluir patrones de archivo
crypto-scanner scan . --exclude "*.test.js" --exclude "*.spec.ts"

# Combinar opciones
crypto-scanner scan ./backend -v --exclude node_modules -o report.json

Exclusiones Predeterminadas

Las siguientes están excluidas automáticamente para evitar escanear dependencias:

root@kitploit:~
.git, .svn, .hg          # Control de versiones
node_modules, vendor     # Dependencias de paquetes
__pycache__, .pytest_cache, .mypy_cache
.venv, venv, env         # Entornos virtuales
dist, build, out         # Salidas de compilación
.idea, .vscode           # Directorios de IDE
site-packages, third_party

Clasificación de Riesgo

Crítico — Vulnerable a la Cuántica

Algoritmos que serán completamente quebrados por el algoritmo de Shor:

Alto — Obsoleto o Débil

Algoritmos con vulnerabilidades clásicas conocidas:

Medio — Monitorear

Algoritmos que actualmente son seguros pero deben ser monitoreados:

Bajo — Adecuado o Resistente a la Cuántica

Algoritmos que proporcionan una protección adecuada:


Tipos de Archivo Soportados

Código Fuente

Archivos de Configuración

Certificados

ExtensiónFormato
.pemCodificado PEM
.crt, .cer, .certCertificado
.derCodificado DER

Formatos de Salida

Informe JSON

Formato de salida predeterminado, ideal para automatización y pipelines CI/CD:

root@kitploit:~
{
  "scan_directory": "/ruta/al/proyecto",
  "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": "/ruta/a/auth.py",
      "line_number": 42,
      "algorithm": "RSA",
      "key_size": 2048,
      "risk_level": "critical",
      "description": "Detección de generación de clave RSA",
      "recommendation": "Planificar migración a algoritmos post-cuánticos (ML-KEM, ML-DSA)",
      "context": "key = rsa.generate_private_key(public_exponent=65537, key_size=2048)"
    }
  ]
}

Informe HTML

Informe profesional autocontenido con la marca de Quantum Shield Labs:

  • Resumen ejecutivo con métricas de riesgo de un vistazo
  • Gráfico visual de distribución de riesgo
  • Tabla de hallazgos ordenable con filtros
  • Tema oscuro optimizado para legibilidad
  • Archivo único sin dependencias externas (fácil de compartir)

Generar con:

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

Integración CI/CD

GitHub Actions

root@kitploit:~
name: Escaneo de Vulnerabilidad 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: Ejecutar Escaneo Criptográfico
        run: crypto-scanner scan ./src --output crypto-report.json

      - name: Verificar Hallazgos Críticos
        run: |
          CRITICAL=$(jq '.summary.critical_count' crypto-report.json)
          if [ "$CRITICAL" -gt 0 ]; then
            echo "::error::¡Se encontraron $CRITICAL algoritmos críticos vulnerables a la cuántica!"
            jq '.findings[] | select(.risk_level == "critical")' crypto-report.json
            exit 1
          fi

      - name: Subir Informe
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: informe-vulnerabilidad-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 "¡Se detectó criptografía crítica vulnerable a la cuántica!"
        exit 1
      fi
  artifacts:
    reports:
      dotenv: crypto-report.json
    paths:
      - crypto-report.json
    when: always

Gancho Pre-commit

Añadir a .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 Simple

root@kitploit:~
#!/bin/bash
# crypto-check.sh - Fallar si se encuentran vulnerabilidades críticas

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 "Escaneo completado: $CRITICAL críticos, $HIGH hallazgos de riesgo alto"

if [ "$CRITICAL" -gt 0 ]; then
    echo "FALLÓ: ¡Se detectó criptografía crítica vulnerable a la cuántica!"
    exit 1
fi

Arquitectura

root@kitploit:~
crypto-scanner/
├── src/crypto_scanner/
│   ├── cli.py              # Interfaz CLI Typer
│   ├── scanner.py          # Lógica de orquestación principal
│   ├── models.py           # Modelos de datos Pydantic
│   ├── patterns.py         # 50+ patrones de detección regex
│   ├── analyzers/          # Analizadores de tipos de archivo
│   │   ├── base.py         # Clase base abstracta
│   │   ├── source.py       # Analizador de código fuente (14 lenguajes)
│   │   ├── config.py       # Analizador de archivos de configuración
│   │   └── certificate.py  # Analizador de certificados X.509
│   └── reporters/          # Generadores de salida
│       ├── json_reporter.py
│       └── html_reporter.py
└── tests/                  # Suite de pruebas exhaustiva

Cómo Funciona

  1. Scanner recorre recursivamente el directorio destino, respetando los patrones de exclusión
  2. Analyzers se asignan según la extensión del archivo:
    • SourceCodeAnalyzer — Coincidencia de patrones en 14 lenguajes de programación
    • ConfigAnalyzer — Análisis de YAML/JSON + coincidencia de patrones para archivos de configuración
    • CertificateAnalyzer — Análisis de X.509 para extraer algoritmos y tamaños de clave
  3. Patterns contiene 50+ patrones regex para detección de APIs criptográficas
  4. Reporters agregan hallazgos en formato JSON o HTML

Contribuciones

¡Las contribuciones son bienvenidas! Aquí te explicamos cómo empezar:

Configuración de Desarrollo

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

Ejecutar Pruebas

root@kitploit:~
# Ejecutar todas las pruebas
pytest tests/ -v

# Ejecutar con cobertura
pytest tests/ -v --cov=crypto_scanner --cov-report=html

Añadir Nuevos Patrones

Los patrones criptográficos se definen en src/crypto_scanner/patterns.py. Cada patrón incluye:

  • Expresión regular para detección
  • Nombre del algoritmo
  • Nivel de riesgo (CRITICAL, HIGH, MEDIUM, LOW)
  • Descripción y recomendación

Directrices para Pull Requests

  1. Haz un fork del repositorio
  2. Crea una rama de funcionalidad (git checkout -b feature/nuevo-patron)
  3. Añade pruebas para la nueva funcionalidad
  4. Asegúrate de que todas las pruebas pasen (pytest tests/ -v)
  5. Envía un pull request con una descripción clara

Licencia

Licencia MIT — consulta LICENSE para más detalles.


Acerca de Quantum Shield Labs

Quantum Shield Labs

Quantum Shield Labs ayuda a las organizaciones a prepararse para la era post-cuántica con:

  • Evaluaciones de Riesgo Cuántico — Inventario criptográfico completo y análisis de riesgos
  • Planificación de Migración a PQC — Hojas de ruta para la transición a algoritmos resistentes a la cuántica
  • Briefings Ejecutivos — Presentaciones a nivel de junta directiva sobre el riesgo cuántico
  • Capacitación para Desarrolladores — Talleres prácticos para equipos de ingeniería

Recursos

  • Manual de Preparación Cuántica
  • Blog
  • Contáctenos

Construido con cuidado por Quantum Shield Labs

Descargar herramienta
Los códigos base grandes tardan de 3 a 5+ años en migrar
Profundidad en la cadena de suministroTus dependencias contienen criptografía vulnerable que no ves
Mandatos de cumplimientoLos estándares PQC del NIST (ML-KEM, ML-DSA) ya están finalizados
Plazo CNSA 2.0La NSA exige algoritmos resistentes a la cuántica para 2033
OpciónCortaDescripción
--htmlGenerar informe HTML en lugar de JSON
--output-oGuardar informe en archivo (en lugar de stdout)
--verbose-vMostrar progreso detallado del escaneo
--exclude-ePatrones de exclusión adicionales (repetible)
--version-VMostrar versión y salir
AlgoritmoTamaños de ClaveImpacto CuánticoAcción Recomendada
RSATodos (1024-4096+)Completamente rotoMigrar a ML-KEM + ML-DSA
ECDSA/ECCTodas las curvasCompletamente rotoMigrar a ML-DSA
DH/ECDHTodosIntercambio de claves rotoMigrar a ML-KEM
DSATodosCompletamente rotoMigrar a ML-DSA
AlgoritmoProblemaAcción Recomendada
MD5Ataques de colisión, completamente rotoReemplazar por SHA-3 o SHA-256
SHA-1Ataques de colisión demostradosReemplazar por SHA-256+
DESClave de 56 bits, trivialmente rotoReemplazar por AES-256
3DESAtaques meet-in-the-middleReemplazar por AES-256
AES-128El algoritmo de Grover reduce la seguridadActualizar a AES-256
AlgoritmoEstadoAcción Recomendada
SHA-256Seguro, Grover reduce a 128 bitsPlanificar migración a SHA-3
SHA-384SeguroMonitorear desarrollos
SHA-512Buena resistencia cuánticaMonitorear desarrollos
TLS 1.2Seguro pero envejeciendoPreferir TLS 1.3
AlgoritmoEstadoNotas
AES-256Resistente a la cuánticaSeguridad post-cuántica de 128 bits
ChaCha20Moderno, seguroBuena alternativa a AES
SHA-3Último estándar del NISTRecomendado para nuevos proyectos
ML-KEMPost-cuántico (Kyber)Estandarizado por el NIST en 2024
ML-DSAPost-cuántico (Dilithium)Estandarizado por el NIST en 2024
ExtensiónLenguaje
.py, .pywPython
.js, .mjs, .cjsJavaScript
.ts, .tsxTypeScript
.javaJava
.goGo
.rsRust
.c, .h, .cpp, .hppC/C++
.csC#
.rbRuby
.phpPHP
.swiftSwift
.kt, .ktsKotlin
.scalaScala
ExtensiónFormato
.yaml, .ymlYAML
.jsonJSON
.tomlTOML
.ini, .cfg, .conf, .configINI/Config
.envVariables de entorno