openentropy

Mesurer et opérationnaliser l'entropie matérielle pour la recherche et la sécurité.

Collectez l'entropie des sources matérielles de l'appareil, analysez la qualité des sources avec des tests statistiques, et fournissez une sortie brute ou conditionnée via les interfaces CLI, Rust, Python et HTTP.

Un workflow unique pour la recherche sur l'entropie, la validation et le déploiement cryptographique.

Par Amenti Labs

Démarrage rapide

# Installation
cargo install openentropy-cli

# Découvrir les sources d'entropie sur votre machine
openentropy scan

# Tester toutes les sources rapides
openentropy bench

# Générer 64 octets hexadécimaux aléatoires
openentropy stream --format hex --bytes 64

# Tableau de bord TUI en direct
openentropy monitor

Par défaut, seules les sources rapides (<2s) sont utilisées. Passez --all pour inclure les sources plus lentes (DNS, TCP, GPU, BLE). L'alias positionnel all est également accepté pour la compatibilité.

Matériel QRNG externe

La plupart des sources OpenEntropy proviennent de la machine hôte elle-même. OpenEntropy prend également en charge les périphériques matériels externes lorsqu'ils sont connectés et détectables :

• Crypta Labs QCicada USB QRNG — exposé comme source qcicada. OpenEntropy peut lire la sortie quantique du périphérique et effectuer des tests, des analyses, des enregistrements ou des comparaisons aux côtés des sources de l'hôte. Les modes de sortie du périphérique correspondent à raw, sha256 et samples, et OpenEntropy utilise désormais l'assistant de démarrage à nouveau en mode continu de qcicada 0.2.2, ce qui lui permet de jeter une fois les données déjà mises en mémoire tampon après être entré en mode continu, au lieu de servir la première lecture à partir d'octets obsolètes mis en file d'attente. Consultez le manuel QCicada.

Python

pip install openentropy

from openentropy import EntropyPool, detect_available_sources

sources = detect_available_sources()
print(f"{len(sources)} sources d'entropie disponibles")

pool = EntropyPool.auto()
source = sources[0]["name"]
data = pool.get_source_bytes(source, 256, conditioning="sha256")

Construire à partir des sources (extension native) :

git clone https://github.com/amenti-labs/openentropy.git && cd openentropy
pip install maturin
maturin develop

Deux publics

Les ingénieurs en sécurité utilisent OpenEntropy pour valider la qualité de l'entropie et ensemencer les CSPRNG :

openentropy analyze --profile security --output audit.md

Les chercheurs utilisent OpenEntropy pour étudier les caractéristiques du bruit brut :

openentropy analyze --profile deep --output analysis.json

Les ingénieurs en sécurité ensemencent les CSPRNG, génèrent des clés et complètent /dev/urandom avec une entropie matérielle indépendante. La sortie conditionnée par SHA-256 (--conditioning sha256, par défaut) produit des octets aléatoires de qualité cryptographique. Le profil security active la batterie de tests NIST, la décomposition de l'entropie minimale et le conditionnement SHA-256 en un seul indicateur.

Les chercheurs étudient les caractéristiques du bruit brut des sous-systèmes matériels. Passez --conditioning raw pour obtenir des octets non blanchis et non conditionnés qui préservent le signal de bruit réel de chaque source. Le profil deep active 100 000 échantillons, la corrélation croisée et l'analyse par essais de type PEAR.

Le mode brut permet :

• Caractérisation matérielle — mesurer l'entropie minimale, l'autocorrélation et les propriétés spectrales des sources de bruit individuelles.
• Validation du silicium — comparer les profils de bruit entre les révisions de puce, les états thermiques et les domaines de tension.
• Détection d'anomalies — surveiller la santé de la source d'entropie pour détecter une dégradation matérielle ou une falsification.
• Analyse inter-domaines — étudier les corrélations entre des domaines d'entropie indépendants (thermique vs temporel vs IPC).

Ce qui le rend différent

La plupart des générateurs de nombres aléatoires sont pseudo-aléatoires — des algorithmes déterministes ensemencés une seule fois. OpenEntropy collecte en continu du bruit physique réel à partir de votre matériel :

• Bruit thermique — trois battements d'oscillateurs indépendants (cristal CPU vs PLL audio, PLL d'affichage, PLL PHY PCIe).
• Temporisation et microarchitecture — bruit de phase d'horloge, conflits de tampon de ligne DRAM, variance d'exécution spéculative, TLB shootdowns, courses DVFS, contention de bus ICC, état du préfetch, temporisation JIT APRR, croisement de domaine d'horloge ANE.
• E/S et IPC — latence disque et NVMe (y compris scrutation du capteur IOKit, périphérique brut et passage Linux), énumération USB, IPC Mach port, allocation de tampon de tube, événements kqueue, journal fsync.
• GPU et calcul — divergence de warp GPU, temporisation inter-domaine IOSurface, temporisation d'inférence Neural Engine.
• Ordonnancement et système — dérive nanosleep, files d'attente GCD dispatch, cycle de vie des threads, migration P/E-core, coalescence de temporisateurs, compteurs du noyau, instantanés de table de processus.
• Réseau et capteurs — temporisation de résolution DNS, variance d'établissement de liaison TCP, RSSI WiFi, RF ambiante BLE, bruit ADC audio.
• Matériel profond — battements de deux domaines d'horloge, SITVA, changement de contexte AES-XTS, diffusion SEV, seqlock COMMPAGE, thermistance SMC, réensemencement TRNG getentropy.

Le pool combine par XOR des flux indépendants. Aucune défaillance d'une seule source ne peut compromettre le pool.

Modes de conditionnement

Le conditionnement est optionnel et configurable. Utilisez --conditioning sur la CLI ou ?conditioning= sur l'API HTTP :

Le mode brut est ce qui rend OpenEntropy utile pour la recherche. La plupart des API HWRNG appliquent un post-traitement DRBG qui donne l'impression que chaque source produit des octets aléatoires uniformes, détruisant ainsi les informations dont les chercheurs ont besoin. La sortie brute préserve la structure de bruit par source : biais, autocorrélation, caractéristiques spectrales et corrélations entre sources. Voir Conditionnement pour plus de détails.

Documentation

• Site de documentation : https://amenti-labs.github.io/openentropy/
• Paquet PyPI : https://pypi.org/project/openentropy/

Remerciements

La feuille de route élargie de l'analyse statistique et l'inventaire des méthodes ont été influencés par :

• vikingdude81/qrng-analysis-toolkit

Nous apprécions le travail open source qui a contribué à façonner cette surface d'analyse comparative QRNG/PRNG.

Sources d'entropie

Le registre actuel des sources couvre 13 catégories basées sur les mécanismes ; la disponibilité réelle varie selon la plateforme :

Pour des descriptions complètes par source, la disponibilité sur les plateformes et des notes physiques, consultez le Catalogue des sources.

Matériel externe actuellement pris en charge :

• qcicada — Crypta Labs QCicada USB QRNG (manuel)

Référence CLI

Pour la référence complète des commandes et des exemples, consultez la Référence CLI.

Workflows les plus courants :

openentropy scan
openentropy bench
openentropy stream --format hex --bytes 64
openentropy analyze --profile security         # Batterie NIST + entropie + sha256
openentropy analyze --profile deep             # 100K + forensique + corrélation croisée + essais
openentropy record clock_jitter --duration 30s
openentropy sessions sessions/<id> --profile deep
openentropy compare sessions/<id-a> sessions/<id-b> --profile deep

Sur sessions, les préréglages de profil ne s'appliquent que lorsqu'un chemin de session spécifique est fourni. openentropy sessions sans chemin reste toujours en mode liste.

Les références à la méthodologie d'essais de type PEAR (essais à 200 bits, Z terminal, composition de Stouffer pondérée, porte d'étalonnage) sont documentées dans Méthodologie d'analyse par essais.

API Rust

[dependencies]
openentropy-core = "0.12"

use openentropy_core::{ConditioningMode, EntropyPool, detect_available_sources};

let sources = detect_available_sources();
println!("{} sources disponibles", sources.len());

let pool = EntropyPool::auto();
let source = pool.source_names()[0].clone();
let bytes = pool
    .get_source_bytes(&source, 256, ConditioningMode::Sha256)
    .unwrap();
let health = pool.health_report();

Analyser et comparer des données d'entropie par programmation :

use openentropy_core::{full_analysis, compare, trial_analysis};

let data = pool.get_source_raw_bytes(&source, 5000).unwrap();

// Analyse statistique par source
let analysis = full_analysis(&source, &data);
println!("Entropie de Shannon : {:.4} bits/octet", analysis.shannon_entropy);

// Comparaison différentielle de deux flux
let other = pool.get_source_raw_bytes(&source, 5000).unwrap();
let diff = compare("flux_a", &data, "flux_b", &other);

// Analyse par essais de type PEAR
let trials = trial_analysis(&data, &Default::default());
println!("Z terminal : {:.4}, p = {:.4}", trials.terminal_z, trials.terminal_p_value);

Analyse de la théorie du chaos (distinguer le véritable hasard du chaos déterministe) :

use openentropy_core::chaos::chaos_analysis;

let result = chaos_analysis(&data);
println!("Hurst H={:.4}, Lyapunov λ={:.4}, D₂={:.4}",
    result.hurst.hurst_exponent,
    result.lyapunov.lyapunov_exponent,
    result.correlation_dimension.dimension);

Architecture

Espace de travail Cargo avec 6 crates :

flowchart TD
    Sources[Sources 63] --> Raw[échantillons bruts]
    Raw --> Pool[Pool d'entropie XOR combine]
    Pool --> Modes{Mode de conditionnement}
    Modes -->|par défaut| Sha[sha256]
    Modes --> Vn[vonneumann]
    Modes -->|passage direct| RawMode[brut]
    Sha --> Output[Surfaces de sortie]
    Vn --> Output
    RawMode --> Output
    Output --> Rust[API Rust]
    Output --> CLI[CLI et TUI]
    Output --> Http[Serveur HTTP]
    Output --> Pipe[Tuyau nommé]
    Output --> Py[SDK Python]

Prise en charge des plateformes

La bibliothèque détecte le matériel disponible à l'exécution et n'active que les sources fonctionnelles.

Construction à partir des sources

Nécessite Rust 1.85+ et macOS ou Linux.

git clone https://github.com/amenti-labs/openentropy.git
cd openentropy
cargo build --release --workspace --exclude openentropy-python
cargo test --workspace --exclude openentropy-python
cargo install --path crates/openentropy-cli

Paquet Python

pip install maturin
maturin develop --release
python3 -c "from openentropy import EntropyPool; print(EntropyPool.auto().get_random_bytes(16).hex())"

Contribuer

Consultez CONTRIBUTING.md. Idées :

• Nouvelles sources d'entropie (en particulier spécifiques à Linux)
• Améliorations de performances
• Implémentations supplémentaires de tests NIST
• Prise en charge de la plateforme Windows

Références

• NIST SP 800-22 : A Statistical Test Suite for Random and Pseudorandom Number Generators
• Bone, A. (2026) : QRNG Analysis Toolkit — les méthodes d'analyse de la théorie du chaos (exposant de Hurst, exposant de Lyapunov, dimension de corrélation, BiEntropie, Épiplexité) ont été réimplémentées en Rust à partir de définitions mathématiques, inspirées de cette boîte à outils Python.
• Croll, G.J. (2013) : BiEntropy — The Approximate Entropy of a Finite Binary String
• Hurst, H.E. (1951) : Capacité de stockage à long terme des réservoirs
• Rosenstein, M.T., Collins, J.J. & De Luca, C.J. (1993) : A practical method for calculating largest Lyapunov exponents from small data sets
• Grassberger, P. & Procaccia, I. (1983) : Measuring the strangeness of strange attractors
• Shannon, C.E. (1948) : A Mathematical Theory of Communication

Licence

MIT — Copyright © 2026 Amenti Labs