Skip to content
KitploitKITPLOIT
ToolsBlog
Submit
ToolsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

··Feeds·Contact·Privacy·© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
openentropy — Open-source entropy harvesting from unconventional hardware sources. Rust + Python SDK. | Kitploit
Tools/GitHubGitHub/amenti-labs/openentropy
Static AnalysisCryptographyHardware SecurityPapers & ResearchLearning & Education
GitHubamenti-labs/openentropy

openentropy

Open-source entropy harvesting from unconventional hardware sources. Rust + Python SDK.

View Repository
28226 months agoReviewed by Kitploit

Most Popular

View all →

Discover the most used tools by our community.

Explore all tools

Browse our collection of tools

View all tools →
Share
openentropy logo

openentropy

Measure and operationalize hardware entropy for research and security.

Crates.io PyPI docs.rs Docs License: MIT CI Platform

Collect entropy from on-device hardware sources, analyze source quality with statistical tests, and deliver raw or conditioned output through CLI, Rust, Python, and HTTP interfaces.

One workflow for entropy research, validation, and cryptographic deployment.

By Amenti Labs

Quick Start

root@kitploit:~
# Install
cargo install openentropy-cli

# Discover entropy sources on your machine
openentropy scan

# Benchmark all fast sources
openentropy bench

# Output 64 random hex bytes
openentropy stream --format hex --bytes 64

# Live TUI dashboard
openentropy monitor

By default, only fast sources (<2s) are used. Pass --all to include slower sources (DNS, TCP, GPU, BLE). The positional alias all is also accepted for compatibility.

External QRNG hardware

Most OpenEntropy sources come from the host machine itself. OpenEntropy also supports external hardware devices when they are attached and discoverable:

  • Crypta Labs QCicada USB QRNG — exposed as the qcicada source. OpenEntropy can read the device's quantum output and benchmark, analyze, record, or compare it alongside on-host sources. The device's own output modes map to raw, sha256, and samples, and OpenEntropy now uses QCicada's fresh-start continuous-mode helper from qcicada 0.2.2, so it discards already-buffered device input once after entering continuous mode instead of serving the first read from stale queued bytes. See the QCicada manual.

Python

root@kitploit:~
pip install openentropy
root@kitploit:~
from openentropy import EntropyPool, detect_available_sources

sources = detect_available_sources()
print(f"{len(sources)} entropy sources available")

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

Build from source (native extension):

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

Two Audiences

Security engineers use OpenEntropy to validate entropy quality and seed CSPRNGs:

root@kitploit:~
openentropy analyze --profile security --output audit.md

Researchers use OpenEntropy to study raw noise characteristics:

root@kitploit:~
openentropy analyze --profile deep --output analysis.json

Security engineers seed CSPRNGs, generate keys, and supplement /dev/urandom with independent hardware entropy. The SHA-256 conditioned output (--conditioning sha256, the default) produces cryptographic-quality random bytes. The security profile enables the NIST test battery, min-entropy breakdown, and SHA-256 conditioning in one flag.

Researchers study the raw noise characteristics of hardware subsystems. Pass --conditioning raw to get unwhitened, unconditioned bytes that preserve the actual noise signal from each source. The deep profile enables 100K samples, cross-correlation, and PEAR-style trial analysis.

Raw mode enables:

  • Hardware characterization — measure min-entropy, autocorrelation, and spectral properties of individual noise sources
  • Silicon validation — compare noise profiles across chip revisions, thermal states, and voltage domains
  • Anomaly detection — monitor entropy source health for signs of hardware degradation or tampering
  • Cross-domain analysis — study correlations between independent entropy domains (thermal vs timing vs IPC)

What Makes This Different

Most random number generators are pseudorandom — deterministic algorithms seeded once. OpenEntropy continuously harvests real physical noise from your hardware:

  • Thermal noise — three independent oscillator beats (CPU crystal vs audio PLL, display PLL, PCIe PHY PLLs)
  • Timing and microarchitecture — clock phase noise, DRAM row buffer conflicts, speculative execution variance, TLB shootdowns, DVFS races, ICC bus contention, prefetcher state, APRR JIT timing, ANE clock domain crossing
  • I/O and IPC — disk and NVMe latency (including IOKit sensor polling, raw device, and Linux passthrough), USB enumeration, Mach port IPC, pipe buffer allocation, kqueue events, fsync journal
  • GPU and compute — GPU warp divergence, IOSurface cross-domain timing, Neural Engine inference timing
  • Scheduling and system — nanosleep drift, GCD dispatch queues, thread lifecycle, P/E-core migration, timer coalescing, kernel counters, process table snapshots
  • Network and sensors — DNS resolution timing, TCP handshake variance, WiFi RSSI, BLE ambient RF, audio ADC noise
  • Deep hardware — dual clock domain beats, SITVA, AES-XTS context switching, SEV broadcast, COMMPAGE seqlock, SMC thermistor, getentropy TRNG reseed

The pool XOR-combines independent streams. No single source failure can compromise the pool.

Conditioning Modes

Conditioning is optional and configurable. Use --conditioning on the CLI or ?conditioning= on the HTTP API:

ModeFlagDescription
SHA-256 (default)--conditioning sha256SHA-256 conditioning. Cryptographic quality output.
Von Neumann--conditioning vonneumannDebiasing only — removes bias while preserving more of the raw signal structure.
Raw--conditioning rawNo processing. Source bytes with zero whitening — preserves the actual hardware noise signal for research.

Raw mode is what makes OpenEntropy useful for research. Most HWRNG APIs run DRBG post-processing that makes every source look like uniform random bytes, destroying the information researchers need. Raw output preserves per-source noise structure: bias, autocorrelation, spectral features, and cross-source correlations. See Conditioning for details.

Documentation

  • Docs site: https://amenti-labs.github.io/openentropy/
  • PyPI package: https://pypi.org/project/openentropy/
DocDescription
Source CatalogSource catalog with physics explanations and platform notes
CLI ReferenceFull command reference and examples
ConditioningRaw vs VonNeumann vs SHA-256 conditioning modes
Trial Analysis MethodologyPEAR-style 200-bit trials, calibration gate, and references
Telemetry ModelExperimental telemetry_v1 context model and integration points
Rust API ReferenceCore Rust API surface
ArchitectureCrate structure and design decisions
Python SDKPyO3 bindings and Python API reference
ExamplesRust and Python code examples
TroubleshootingCommon issues and fixes
SecurityThreat model and responsible disclosure

Acknowledgments

The expanded statistical analysis roadmap and method inventory were informed by:

  • vikingdude81/qrng-analysis-toolkit

We appreciate the open-source work that helped shape this comparative QRNG/PRNG analysis surface.

Entropy Sources

The current source registry spans 13 mechanism-based categories; actual availability varies by platform:

CategoryCount
Thermal4
Timing7
Scheduling6
IO6
IPC4
Microarchitecture16
GPU3
Network3
System6
Signal3
Sensor4
Quantum1

For full per-source descriptions, platform availability, and physics notes, see Source Catalog.

Currently supported external hardware:

  • qcicada — Crypta Labs QCicada USB QRNG (manual)

CLI Reference

For the full command reference and examples, see CLI Reference.

Most-used workflows:

root@kitploit:~
openentropy scan
openentropy bench
openentropy stream --format hex --bytes 64
openentropy analyze --profile security         # NIST battery + entropy + sha256
openentropy analyze --profile deep             # 100K + forensic + cross-corr + trials
openentropy record clock_jitter --duration 30s
openentropy sessions sessions/<id> --profile deep
openentropy compare sessions/<id-a> sessions/<id-b> --profile deep

On sessions, profile presets apply only when a specific session path is provided. openentropy sessions with no path always stays in list mode.

PEAR-style trial methodology references (200-bit trials, terminal Z, weighted Stouffer composition, calibration gating) are documented in Trial Analysis Methodology.

Rust API

root@kitploit:~
[dependencies]
openentropy-core = "0.12"
root@kitploit:~
use openentropy_core::{ConditioningMode, EntropyPool, detect_available_sources};

let sources = detect_available_sources();
println!("{} sources available", 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();

Analyze and compare entropy data programmatically:

root@kitploit:~
use openentropy_core::{full_analysis, compare, trial_analysis};

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

// Per-source statistical analysis
let analysis = full_analysis(&source, &data);
println!("Shannon entropy: {:.4} bits/byte", analysis.shannon_entropy);

// Differential comparison of two streams
let other = pool.get_source_raw_bytes(&source, 5000).unwrap();
let diff = compare("stream_a", &data, "stream_b", &other);

// PEAR-style trial analysis
let trials = trial_analysis(&data, &Default::default());
println!("Terminal Z: {:.4}, p = {:.4}", trials.terminal_z, trials.terminal_p_value);

Chaos theory analysis (distinguish true randomness from deterministic chaos):

root@kitploit:~
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

Cargo workspace with 6 crates:

CrateDescription
openentropy-coreCore library — sources, pool, conditioning
openentropy-cliCLI binary with TUI dashboard
openentropy-serverAxum HTTP entropy server
openentropy-testsNIST SP 800-22 inspired test battery
openentropy-pythonPython bindings via PyO3/maturin
openentropy-wasmWebAssembly/browser entropy crate
root@kitploit:~
flowchart TD
    Sources[Sources 63] --> Raw[raw samples]
    Raw --> Pool[Entropy Pool XOR combine]
    Pool --> Modes{Conditioning mode}
    Modes -->|default| Sha[sha256]
    Modes --> Vn[vonneumann]
    Modes -->|passthrough| RawMode[raw]
    Sha --> Output[Output surfaces]
    Vn --> Output
    RawMode --> Output
    Output --> Rust[Rust API]
    Output --> CLI[CLI and TUI]
    Output --> Http[HTTP Server]
    Output --> Pipe[Named Pipe]
    Output --> Py[Python SDK]

Platform Support

PlatformSourcesNotes
MacBook (M-series)63/63Full suite — WiFi, BLE, camera, mic
Mac Mini / Studio / Pro50–55No built-in camera, mic on some models
Intel Mac~20Some silicon/microarch sources are ARM-specific
Linux12–15Timing, network, disk, process sources + NVMe passthrough

The library detects available hardware at runtime and only activates working sources.

Building from Source

Requires Rust 1.85+ and macOS or Linux.

root@kitploit:~
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

Python package

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

Contributing

See CONTRIBUTING.md. Ideas:

  • New entropy sources (especially Linux-specific)
  • Performance improvements
  • Additional NIST test implementations
  • Windows platform support

References

  • NIST SP 800-22: A Statistical Test Suite for Random and Pseudorandom Number Generators
  • Bone, A. (2026): QRNG Analysis Toolkit — chaos theory analysis methods (Hurst exponent, Lyapunov exponent, correlation dimension, BiEntropy, Epiplexity) were reimplemented in Rust from mathematical definitions, inspired by this Python toolkit
  • Croll, G.J. (2013): BiEntropy — The Approximate Entropy of a Finite Binary String
  • Hurst, H.E. (1951): Long-term storage capacity of reservoirs
  • 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

License

MIT — Copyright © 2026 Amenti Labs

Download Tool