Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
crypto-scanner — Outil CLI pour analyser les codebases à la recherche de cryptographie vulnérable aux attaques quantiques. | Kitploit
Outils/GitHubGitHub/mbennett-labs/crypto-scanner
Analyse Statique de Code (SAST)Analyse des VulnérabilitésAnalyse de CodeCryptographieDevSecOpsDétection de SecretsSécurité de la Chaîne Logistique
GitHubmbennett-labs/crypto-scanner

crypto-scanner

Outil CLI pour analyser les codebases à la recherche de cryptographie vulnérable aux attaques quantiques.

Voir le dépôt
67il y a 6 moisPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Crypto Scanner

Scannez votre codebase à la recherche de cryptographie vulnérable au quantique avant qu'il ne soit trop tard.

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

Démarrage rapide • Pourquoi être prêt pour le quantique ? • Utilisation • Niveaux de risque • CI/CD • À propos


Aperçu

Crypto Scanner est un outil CLI qui scanne votre codebase à la recherche d'algorithmes cryptographiques et génère des évaluations de risque de vulnérabilité quantique. Il analyse le code source, les fichiers de configuration et les certificats X.509 pour identifier la cryptographie qui sera brisée par les ordinateurs quantiques.

Développé par Quantum Shield Labs — aidant les organisations à se préparer à l'ère post-quantique.


Pourquoi être prêt pour le quantique ?

La menace quantique est réelle

Les ordinateurs quantiques cryptographiquement pertinents (CRQC) capables de briser RSA et ECC devraient émerger d'ici 2033. Ce n'est pas de la science-fiction — c'est un calendrier auquel les grands gouvernements et entreprises se préparent activement.

Récoltez maintenant, déchiffrez plus tard (HNDL)

Les adversaires collectent déjà des données chiffrées aujourd'hui avec l'intention de les déchiffrer une fois que les ordinateurs quantiques seront disponibles. Si vos données ont une valeur à long terme (dossiers médicaux, données financières, secrets commerciaux, communications gouvernementales), elles sont déjà à risque.

Pourquoi vous ne pouvez pas attendre

DéfiRéalité
Complexité de la migration

L'algorithme de Shor : la menace

L'algorithme de Shor, exécuté sur un ordinateur quantique suffisamment puissant, peut factoriser efficacement de grands entiers et calculer des logarithmes discrets. Cela brise :

  • RSA (toutes les tailles de clés)
  • ECDSA/ECC (toutes les courbes)
  • DH/ECDH (échange de clés)
  • DSA (signatures numériques)

La première étape : l'inventaire

Vous ne pouvez pas migrer ce que vous ne savez pas avoir. Crypto Scanner fournit l'inventaire cryptographique qui est la première étape essentielle de tout programme de préparation quantique.

📘 En savoir plus : Lisez le Playbook de Quantum Shield Labs pour des conseils complets de migration.


Démarrage rapide

Obtenez votre première analyse de vulnérabilité quantique en moins de 60 secondes :

root@kitploit:~
# Install from PyPI
pip install crypto-scanner

# Scan your project
crypto-scanner scan .

# Generate an executive HTML report
crypto-scanner scan . --html --output quantum-risk-report.html

C'est tout. Vous avez maintenant un inventaire cryptographique complet de votre codebase.


Installation

Depuis PyPI (Recommandé)

root@kitploit:~
pip install crypto-scanner

Depuis les sources

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

Prérequis

  • Python 3.10 ou supérieur
  • Fonctionne sur Windows, macOS et Linux

Utilisation

Commandes de base

root@kitploit:~
# Scan a directory (JSON output to stdout)
crypto-scanner scan <directory>

# Show supported file types and risk classifications
crypto-scanner info

# Display version
crypto-scanner --version

Options CLI

Exemples

root@kitploit:~
# Scan with verbose output
crypto-scanner scan ./src --verbose

# Save JSON report to file
crypto-scanner scan . --output crypto-audit.json

# Generate branded HTML report for stakeholders
crypto-scanner scan . --html --output quantum-assessment.html

# Exclude specific directories
crypto-scanner scan . --exclude vendor --exclude legacy

# Exclude file patterns
crypto-scanner scan . --exclude "*.test.js" --exclude "*.spec.ts"

# Combine options
crypto-scanner scan ./backend -v --exclude node_modules -o report.json

Exclusions par défaut

Les éléments suivants sont automatiquement exclus pour éviter d'analyser les dépendances :

root@kitploit:~
.git, .svn, .hg          # Contrôle de version
node_modules, vendor     # Dépendances de paquets
__pycache__, .pytest_cache, .mypy_cache
.venv, venv, env         # Environnements virtuels
dist, build, out         # Sorties de construction
.idea, .vscode           # Répertoires IDE
site-packages, third_party

Classification des risques

Critique — Vulnérable au quantique

Algorithmes qui seront complètement brisés par l'algorithme de Shor :

Élevé — Déprécié ou faible

Algorithmes avec des vulnérabilités classiques connues :

Moyen — Surveiller

Algorithmes actuellement sécurisés mais à surveiller :

Faible — Adéquat ou résistant au quantique

Algorithmes offrant une protection adéquate :


Types de fichiers pris en charge

Code source

Fichiers de configuration

Certificats

ExtensionFormat
.pemEncodé PEM
.crt, .cer, .certCertificat
.derEncodé DER

Formats de sortie

Rapport JSON

Format de sortie par défaut, idéal pour l'automatisation et les pipelines CI/CD :

root@kitploit:~
{
  "scan_directory": "/path/to/project",
  "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": "/path/to/auth.py",
      "line_number": 42,
      "algorithm": "RSA",
      "key_size": 2048,
      "risk_level": "critical",
      "description": "RSA key generation detected",
      "recommendation": "Plan migration to post-quantum algorithms (ML-KEM, ML-DSA)",
      "context": "key = rsa.generate_private_key(public_exponent=65537, key_size=2048)"
    }
  ]
}

Rapport HTML

Rapport professionnel autonome avec la marque Quantum Shield Labs :

  • Résumé exécutif avec métriques de risque en un coup d'œil
  • Graphique visuel de distribution des risques
  • Tableau de résultats triable avec filtrage
  • Thème sombre optimisé pour la lisibilité
  • Fichier unique sans dépendances externes (facile à partager)

Générer avec :

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

Intégration CI/CD

GitHub Actions

root@kitploit:~
name: Crypto Vulnerability Scan

on: [push, pull_request]

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

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

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

      - name: Run Crypto Scan
        run: crypto-scanner scan ./src --output crypto-report.json

      - name: Check for Critical Findings
        run: |
          CRITICAL=$(jq '.summary.critical_count' crypto-report.json)
          if [ "$CRITICAL" -gt 0 ]; then
            echo "::error::Found $CRITICAL critical quantum-vulnerable algorithms!"
            jq '.findings[] | select(.risk_level == "critical")' crypto-report.json
            exit 1
          fi

      - name: Upload Report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: crypto-vulnerability-report
          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 "Critical quantum-vulnerable cryptography detected!"
        exit 1
      fi
  artifacts:
    reports:
      dotenv: crypto-report.json
    paths:
      - crypto-report.json
    when: always

Pre-commit Hook

Add to .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 - Fail if critical vulnerabilities found

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 "Scan complete: $CRITICAL critical, $HIGH high risk findings"

if [ "$CRITICAL" -gt 0 ]; then
    echo "FAILED: Critical quantum-vulnerable cryptography detected!"
    exit 1
fi

Architecture

root@kitploit:~
crypto-scanner/
├── src/crypto_scanner/
│   ├── cli.py              # Interface CLI Typer
│   ├── scanner.py          # Logique d'orchestration centrale
│   ├── models.py           # Modèles de données Pydantic
│   ├── patterns.py         # 50+ motifs de détection regex
│   ├── analyzers/          # Analyseurs par type de fichier
│   │   ├── base.py         # Classe de base abstraite
│   │   ├── source.py       # Analyseur de code source (14 langages)
│   │   ├── config.py       # Analyseur de fichiers de configuration
│   │   └── certificate.py  # Analyseur de certificats X.509
│   └── reporters/          # Générateurs de sortie
│       ├── json_reporter.py
│       └── html_reporter.py
└── tests/                  # Suite de tests complète

Comment ça fonctionne

  1. Scanner parcourt récursivement le répertoire cible, en respectant les motifs d'exclusion
  2. Analyzers sont dispatchés en fonction de l'extension du fichier :
    • SourceCodeAnalyzer — Correspondance de motifs dans 14 langages de programmation
    • ConfigAnalyzer — Analyse YAML/JSON + correspondance de motifs pour les fichiers de config
    • CertificateAnalyzer — Analyse X.509 pour extraire les algorithmes et tailles de clés
  3. Patterns module contient 50+ motifs regex pour la détection d'API cryptographiques
  4. Reporters agrègent les résultats au format JSON ou HTML

Contribution

Les contributions sont les bienvenues ! Voici comment commencer :

Configuration de développement

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

Exécution des tests

root@kitploit:~
# Run all tests
pytest tests/ -v

# Run with coverage
pytest tests/ -v --cov=crypto_scanner --cov-report=html

Ajout de nouveaux motifs

Les motifs de cryptographie sont définis dans src/crypto_scanner/patterns.py. Chaque motif comprend :

  • Motif regex pour la détection
  • Nom de l'algorithme
  • Niveau de risque (CRITICAL, HIGH, MEDIUM, LOW)
  • Description et recommandation

Directives pour les pull requests

  1. Forkez le dépôt
  2. Créez une branche de fonctionnalité (git checkout -b feature/nouveau-motif)
  3. Ajoutez des tests pour la nouvelle fonctionnalité
  4. Assurez-vous que tous les tests passent (pytest tests/ -v)
  5. Soumettez une pull request avec une description claire

Licence

Licence MIT — voir LICENSE pour les détails.


À propos de Quantum Shield Labs

Quantum Shield Labs

Quantum Shield Labs aide les organisations à se préparer à l'ère post-quantique avec :

  • Évaluations des risques quantiques — Inventaire cryptographique complet et analyse des risques
  • Planification de la migration PQC — Feuilles de route pour la transition vers des algorithmes résistants au quantique
  • Briefings exécutifs — Présentations au niveau du conseil d'administration sur le risque quantique
  • Formation des développeurs — Ateliers pratiques pour les équipes d'ingénierie

Ressources

  • Playbook de préparation quantique
  • Blog
  • Contactez-nous

Construit avec soin par Quantum Shield Labs

Télécharger l’outil
Les grandes codebases prennent 3 à 5 ans ou plus à transitionner
Profondeur de la chaîne d'approvisionnementVos dépendances contiennent de la crypto vulnérable que vous ne voyez pas
Obligations de conformitéLes normes NIST PQC (ML-KEM, ML-DSA) sont désormais finalisées
Échéance CNSA 2.0La NSA exige des algorithmes résistants au quantique d'ici 2033
OptionCourtDescription
--htmlGénérer un rapport HTML au lieu de JSON
--output-oEnregistrer le rapport dans un fichier (au lieu de stdout)
--verbose-vAfficher la progression détaillée de l'analyse
--exclude-eMotifs d'exclusion supplémentaires (répétable)
--version-VAfficher la version et quitter
AlgorithmKey SizesQuantum ImpactRecommended Action
RSAToutes (1024-4096+)Complètement briséMigrer vers ML-KEM + ML-DSA
ECDSA/ECCToutes les courbesComplètement briséMigrer vers ML-DSA
DH/ECDHTousÉchange de clés briséMigrer vers ML-KEM
DSATousComplètement briséMigrer vers ML-DSA
AlgorithmIssueRecommended Action
MD5Attaques de collision, complètement briséRemplacer par SHA-3 ou SHA-256
SHA-1Attaques de collision démontréesRemplacer par SHA-256+
DESClé de 56 bits, trivialement briséRemplacer par AES-256
3DESAttaques meet-in-the-middleRemplacer par AES-256
AES-128L'algorithme de Grover réduit la sécuritéMettre à niveau vers AES-256
AlgorithmStatusRecommended Action
SHA-256Sécurisé, Grover réduit à 128 bitsPlanifier la migration vers SHA-3
SHA-384SécuriséSurveiller les développements
SHA-512Bonne résistance quantiqueSurveiller les développements
TLS 1.2Sécurisé mais vieillissantPréférer TLS 1.3
AlgorithmStatusNotes
AES-256Résistant au quantiqueSécurité post-quantique de 128 bits
ChaCha20Moderne, sécuriséBonne alternative à AES
SHA-3Dernière norme NISTRecommandé pour les nouveaux projets
ML-KEMPost-quantique (Kyber)Normalisé par le NIST en 2024
ML-DSAPost-quantique (Dilithium)Normalisé par le NIST en 2024
ExtensionLangage
.py, .pywPython
.js, .mjs, .cjsJavaScript
.ts, .tsxTypeScript
.javaJava
.goGo
.rsRust
.c, .h, .cpp, .hppC/C++
.csC#
.rbRuby
.phpPHP
.swiftSwift
.kt, .ktsKotlin
.scalaScala
ExtensionFormat
.yaml, .ymlYAML
.jsonJSON
.tomlTOML
.ini, .cfg, .conf, .configINI/Config
.envVariables d'environnement