SparkSome Venture

> PUBLIC_DOCUMENTATION · OPEN_SOURCE

BIG_BANG_ENTROPY

SECTION ABOUT

Quick access Download Statistics Reports
Theme
Language
ACTIVE OPEN SOURCE ACADEMIC

> MISSION_STATEMENT

Open source
high entropy
rooted in physics

Big Bang Entropy is an open-source entropy generation system in which random material comes from a real radio path: microwave sky noise, cosmic radiation, and unavoidable thermal noise in SDR measurement systems.

The project is created by SparkSome Venture and shared free of charge with individuals, developers, and institutions that need high-quality, physically grounded entropy without deploying their own hardware infrastructure.

> ENTROPY_SOURCE

Physical RF noise and microwaves
CMB, thermal noise, ADC, local conditions

> HARDWARE

SDR nodes · multiple receivers
Sky-facing antennas, receiving broad radio noise

> ACCESS

Public API + Open Source
MIT license · GitHub · no registration

> WHERE_RANDOMNESS_COMES_FROM

How random material is formed inside the nodes

Each node acts as an independent measurement chain: antenna, SDR receiver, ADC, and subsequent digital processing. What matters is not the payload of radio transmissions, but the fragment of the received spectrum in which physical noise and background instability can be measured.

Samples therefore contain a mixture of phenomena present within the selected band and channel width: galactic emission, cosmic microwave background, atmospheric noise, thermal noise of analog components, receiver front-end limitations, ADC quantization, and local antenna and installation conditions.

Random material does not come from one ideal source, but from the overlap of many small physical processes measured by independent nodes in different locations. Only later is this material filtered, sampled, and mixed cryptographically.

> ANTENNA_AND_PROJECT_NAME

What the antenna really measures and where the project name comes from

A sky-facing antenna does not receive a single, “clean” signal from space. It records the sum of phenomena present in the radio and microwave background, including galactic emission, a contribution from the cosmic microwave background, and noise introduced by the measurement chain itself.

The CMB is relic radiation from the early Universe: radiation released when matter cooled enough for photons to begin traveling freely through space. In that sense it is one of the most direct physical traces of the era following the Big Bang, and that is exactly why it matters so much to the project's identity.

The name Big Bang Entropy comes from the fact that the radio and microwave background also contains photons that may have started their cosmic journey in that early phase of the Universe. That does not mean every byte can be described as a “pure signal from the Big Bang” — the receiver always sees a mixture of cosmological, galactic, environmental, and instrumental contributions — but the core idea of the entropy source is rooted in a real physical background connected to cosmic history.

> SYSTEM_ARCHITECTURE

From radio sample to public entropy byte

01

RADIO PATH

Receiving signal from the antenna

The receiver collects samples from antennas pointed at the sky. At this stage the data includes both what comes from the environment and cosmos, and the natural noise of the hardware itself.

02

SIGNAL PROCESSING

Selecting the most random bits

From the collected samples, the system selects the parts that best carry the unpredictability of physical noise. The material is then cleaned from part of its bias and correlation to produce fair random bits.

03

CRYPTOGRAPHIC MIXING

Combining data from many nodes

The central generator gathers packets from many sources and mixes them using a SHA-512-based mechanism. This makes the public output safer and keeps the internal state hidden.

04

DELIVERY

Consumable pool and public API

The final output goes into a consumable pool. Every downloaded byte disappears after being served, so the public interface never gives out the same data twice.

> START_IN_30_SECONDS

Run your first test in under a minute

If you only want to evaluate the service, you do not need to install anything. First inspect the pool state, then download raw entropy, and finally try a ready-to-use endpoint.

↗ Documentation / README > Generators

STEP_01

Check service status

Start with healthz to inspect pool size, active sources, and the basic operational parameters of the public endpoint.

curl https://entropy.sparksome.pl/healthz

STEP_02

Download the first chunk

If the pool is ready, download a single binary chunk or a larger stream and use it locally as input material.

curl https://entropy.sparksome.pl/raw --output entropy.bin

STEP_03

Try the ready-made API

You can immediately test utility endpoints backed by the same entropy pool, for example the password generator.

curl "https://entropy.sparksome.pl/api/password?length=24&count=3"

> HOW_TO_USE

How to use the service

Big Bang Entropy exposes raw entropy over HTTP and TCP, plus a few diagnostic endpoints. Below are the simplest ways to use the service from a terminal.

HTTP_RAW

Fetching entropy over HTTP

The /raw endpoint returns a single binary chunk, /raw/stream streams the requested number of bytes, and /download/entropy prepares the response as a downloadable file.

curl https://entropy.sparksome.pl/raw --output entropy.bin

TCP_RAW

Fetching entropy over TCP

Port 1420 returns one chunk of raw bytes and then closes the connection. This is the simplest option for clients that want material without the HTTP layer.

nc entropy.sparksome.pl 1420 > entropy.bin

SERVICE_STATUS

Service and source status

The healthz, sources, and waterfalls endpoints let you inspect pool size, active SDR nodes, and available waterfall frames without consuming entropy itself.

curl https://entropy.sparksome.pl/healthz
curl https://entropy.sparksome.pl/sources
curl https://entropy.sparksome.pl/waterfalls

READY_TO_USE

Example commands

The examples below show typical usage through the public HTTPS address and the public TCP endpoint on port 1420.

curl "https://entropy.sparksome.pl/raw/stream?bytes=1048576" --output 1mb.bin
curl -OJ "https://entropy.sparksome.pl/download/entropy?bytes=65536"
nc entropy.sparksome.pl 1420 | hexdump -C | head

LIMITS_AND_BEHAVIOR

User limits and service behavior

HTTP traffic is rate-limited by Nginx. Diagnostic endpoints and generators run under the general limit, while endpoints that deliver raw entropy use a stricter request budget.

The service also limits concurrent connections, request budgets, and default chunk sizes. When the pool is too small, the /raw endpoint and some generators may return 503 Warming up..., while streaming endpoints return as much data as is currently available.

The built-in generators also enforce parameter limits: passwords can be up to 1024 characters long, and generator request counts are capped at 1000 results per call.

HTTP general: 10 req/s, burst 10
HTTP heavy (/raw, /raw/stream, /download/entropy): 2 req/s, burst 2-3
HTTP concurrent connections per IP: 20
TCP concurrent connections per IP: 3
/raw chunk: 65536 bytes
/raw/stream default: 1048576 bytes
TCP session default: 65536 bytes

> ACCESS_MODELS

Three ways to use Big Bang Entropy

The project simultaneously acts as a free public API, an open stack for self-hosting, and a starting point for dedicated deployments with higher requirements.

PUBLIC_API

Public API

The fastest way to start, with no account and no API key. Good for tests, experiments, prototypes, and lightweight integrations. Public limits and a best-effort model apply.

SELF_HOST

Open source / self-host

If you want full infrastructure control, run your own generator and SDR nodes. The architecture, Docker setup, and deployment documentation are public in the main project README.

DEDICATED_DEPLOYMENT

Dedicated deployment

For production systems with higher requirements, SparkSome Venture can provide agreed throughput, private infrastructure, integration help, and deployment support.

> AUDIT_REPORTS

Audit reports

> /REPORTS/

PUBLIC_REPORTS

How to read the reports

The audit container runs recurring quality checks against the generator and stores the results in the shared /reports/ directory. This is the public place where you can review the current statistical test outcome and the history of previous runs.

Every audit publishes an HTML report for quick reading, a full JSON report for automation, SHA-256 checksum files, and an append-only integrity-chain entry in chain.jsonl. In addition, index.html lists all runs and latest.json points to the newest available report.

This makes it possible to review the test result, compare consecutive audits, and verify that the reporting history remains consistent over time.

> SECURITY_AND_INTENDED_USE

Important: intended use and the boundaries of the public service

Big Bang Entropy is a public, free engineering and research service as well as an open-source project. Public endpoints operate in a best effort model and are not a replacement for the local system CSPRNG or a formally certified HSM/TRNG.

For higher-criticality production use, treat this service as an additional external entropy source, an audit layer, or an input for controlled mixing with local randomness. You should evaluate fit against your own security, regulatory, and performance requirements.

If you need your own infrastructure, predictable throughput, isolation from public traffic, or an individual support model, choose self-hosting or contact us about a dedicated deployment.

> PURPOSE_AND_USE_CASES

Who uses Big Bang Entropy and why

{ }

Developers and engineers

Applications that require true randomness: cryptographic key generation, session tokens, password salting, and nonces in cryptographic protocols.

API · HTTP · JSON
∿

Researchers and academics

Experiments that need uncorrelated random samples: Monte Carlo simulations, statistical tests, cryptographic studies, and physical entropy analysis.

RESEARCH · ACADEMIC
▣

Institutions and organizations

Systems that need an external, independent entropy source to complement the local CSPRNG pool without deploying their own SDR hardware.

ENTERPRISE · INFRA
⌁

SDR and RF enthusiasts

The project is fully open - from SDR node configuration and DSP pipeline to the cryptographic layer. Full method documentation and the ability to run your own node.

SDR · DIY · SELF-HOST

> ALGORITHM_CORE

Physical extractor + cryptographic mixer

The SDR layer acts as an entropy extractor from the physical signal. It utilizes an advanced DSP pipeline that aggregates noisy ADC bits (via multi-bit XOR-folding), providing high throughput and drastically reducing hardware bias without relying on aggressive decimation.

The generator layer does not ‘create’ entropy from nothing. Its task is to securely bind material from many nodes into one stream, add cryptographic resilience, and separate the public output from the raw internal system state.

> OPEN_IMPLEMENTATION

Full access to the source code

The entire pipeline - from SDR driver and DSP extractor to the generator and API server - is published on GitHub. You can run your own node, connect your own antenna, and join the entropy collection network.

The project includes Dockerfiles, docker-compose.yml, and full deployment documentation. A new node can be started on a mini PC with a compatible SDR receiver within a few hours.

SDR nodes use a compact naming convention, for example pl-lub-sdr-ad9363-omni01, in the format country-city-technology-hardware-antennaID.

↗ GitHub repository ↗ README documentation

> FOR_AUDITORS_AND_ENGINEERS

TRNG Technical Details and Conditioning

Entropy Throughput

The system extracts randomness from the least significant bits (LSB) of the ADC converter using multi-bit XOR-folding. This ensures high information density: every sample after the conditioning process contributes significantly to the entropy pool, guaranteeing full stream unpredictability.

Statistical Tests

The external audit container takes the output stream and continuously evaluates it using rigorous test suites, including NIST SP 800-22 (e.g., Frequency, Runs, Approximate Entropy), ENT, and Dieharder.

Health Checks (FIPS)

A module in each node implements continuous hardware health checks in the style of FIPS 140-3 for TRNG devices: Repetition Count Test (RCT) and Adaptive Proportion Test (APT). ADC failure or strong hardware bias results in packet rejection.

DRBG Reseeding

The generator layer operates as a DRBG (Deterministic Random Bit Generator). Its internal state is reseeded asynchronously and continuously from a high-frequency physical source, protecting against attacks on the internal state of the machine.

Backtracking Resistance

The stream is conditioned using the SHA-512 cryptographic hash function. The architecture maintains separation between the public buffer and the internal mixing state. In practice, compromising the current buffer should not allow straightforward reconstruction of previously issued entropy, because issued bytes are removed from the pool while mixing remains tied to the generator's internal state.

> PROJECT_PUBLISHER

SparkSome Venture

An IT integrator specializing in complex systems engineering, critical infrastructure, and advanced technical challenges. We focus on technical education and knowledge sharing in an open model.

⬡ Engineering and complex systems
⬡ Technical education and knowledge transfer
⬡ Community open-source projects
⬡ IT infrastructure and applied cryptography

> COMMUNITY_MODEL

Code published for the community

The entire source code of the project is publicly available and developed in an open model. We publish it as free software and invite researchers, engineers, and radio enthusiasts to collaborate.

> EDUCATION

Educational and research project

The project documents the methodology from radio signal to cryptographic byte stream. Code, comments, and architecture are also meant to serve as learning material on SDR, entropy extraction, and randomness security.

> OPEN_DATA

No access gates

The public endpoint requires no registration or API key. Every downloaded byte is unique and consumable; the system deliberately never serves the same data twice.

> LICENSE

MIT license

The project is released under the MIT license. You can run it locally, fork it, modify it, and integrate it into your own systems without fees or asking for permission.

> CONTACT_AND_COLLABORATION

Let's talk about deployment, integration, or collaboration

If you want to use Big Bang Entropy in a production, research, or educational system, contact SparkSome Venture. We can help with integration, throughput planning, deployments, and technical collaboration.

> CONTACT_DETAILS

> FAQ

Frequently asked questions

Does the generator contain only cosmic radiation?

No. In practice the input stream contains thermal noise from the system's own components, front-end electronics noise, ADC quantum effects, and local radio conditions. The project intentionally uses the whole physical noise landscape rather than only an ideally isolated cosmic component.

Is device self-noise a flaw?

No. From the perspective of an entropy generator it is still valuable physical material, as long as it is extracted correctly and strengthened cryptographically. The goal is to measure unpredictability in a real RF path - not to build a lab detector for a single phenomenon.

Why use SHA-512 on top of that?

The physical layer delivers entropic material, but a public service also needs cryptographic resilience. SHA-512 binds data from many nodes, hides internal state, and makes future bytes harder to predict - even if part of the input is weaker than assumed.

Why generate physical entropy if the computer already has its own random number generator (RNG)?

A local system random number generator is usually very good and much faster, but it still depends on the machine's internal entropy pool and on trust in that specific machine, hypervisor, and operating system. External physical entropy from the SDR path is not meant to beat it on throughput; it provides an independent, auditable outside source of randomness that can seed or cross-check a local cryptographically secure pseudo-random number generator (CSPRNG) in higher-assurance use cases.

Is every downloaded byte unique?

Yes. Entropy enters a consumable pool and is removed after download. Each recipient gets the next available data, never a copy of data already given to another user.

Can I run my own node?

Yes - that is one of the project's main goals. The repository contains full deployment instructions for an SDR node, Docker configuration, and the central server communication protocol. New nodes increase both independence and throughput.

Does the system scale from 1 node to hundreds or thousands?

Yes - the architecture is designed for that. Each additional node contributes more input material to the central pool, and the SHA-512-based mixing layer processes that stream very quickly. In practice, more nodes mainly mean faster pool growth and more diversity in the physical input sources.

Is there a real difference between 1 node and 1000 nodes?

Yes. A single node can still provide valuable entropy, but many nodes bring higher throughput, more source independence, and less sensitivity to local conditions of any one installation. That does not automatically mean "magically stronger encryption," but it does mean richer input material and faster pool replenishment.

What do I need to set up a small node?

In practice, a small Linux computer, a compatible SDR receiver, internet access, and the software configuration are enough. The system is meant to work with different receivers as long as they provide a meaningful sample stream for further processing.

Can Raspberry Pi handle a node?

Yes - Raspberry Pi is a reasonable candidate for a lightweight node, as long as it has stable power, networking, and a supported SDR. Large compute power is not the main requirement for collecting and forwarding samples, so this is more about hardware compatibility and deployment convenience than about running a big server.

Does the node have to be outdoors and pointed at the sky?

No. An antenna pointed at the sky fits the project's original vision, but it is not a strict requirement for useful randomness. The system can use broadly understood physical noise: radio background, ambient thermal noise, and self-noise of the electronics, so a node can also operate indoors.

Can it be used commercially?

Yes. The MIT license imposes no restrictions on commercial use. The public API is free. If you are designing a production system that needs dedicated throughput or support, contact SparkSome Venture.