DOKUMENTACJA RANDOM.FLAMEIT.IO

Entropia sprzętowa,
wyjaśniona i zweryfikowana.

Opis API, architektura dostarczania i przetestowane procedury OpenSSL do odbierania uwierzytelnionych losowych bitów z usługi Infinite Noise TRNG.

Użyj API Zweryfikuj Ed25519 Poznaj źródło

DOKUMENTACJA API

Endpointy i formaty

Wszystkie odpowiedzi z entropią są wysyłane z Cache-Control: no-store. Endpoint bajtów przyjmuje jeden dodatni parametr dziesiętny bytes do 100 MiB.

/get/?bytes=N

Losowe bajty

Surowe dane application/octet-stream. Dodaj signed=json dla zwartych odpowiedzi uwierzytelnionych albo signed=bundle dla strumieniowych podpisanych pakietów.

/password/

Hasła i tokeny

Generator bezpiecznych haseł, fraz hasłowych, PIN-ów, wartości szesnastkowych i tokenów Base64URL oparty na żądaniach POST.

/dice/

Kości sześcienne

Wyniki JSON dla 1–12 bezstronnych rzutów d6. Użyj /rpg/ dla pul mieszanych i zaawansowanego zapisu.

/img/

Losowy PNG

Jednolity kolor, monochromatyczny obraz 1-bitowy, skala szarości lub niezależne piksele RGB kodowane jako strumieniowy PNG.

/signing-keys/

Klucze weryfikacyjne

Rejestr aktywnych i historycznych kluczy publicznych Ed25519 ze stałymi nazwami pobieranych plików PEM.

/health/

Stan na żywo

Czytelny dla człowieka i maszyny stan serwera Go, źródła sprzętowego, usługi podpisującej oraz buforów RAM/dysk.

PRZELICZENIA

Bajty na bity

Jeden bajt zawiera dokładnie osiem bitów. Jednostki binarne przyjmują 1 KiB = 1024 bajty.

Porównanie skali: szacuje się, że obserwowalny Wszechświat zawiera około 10⁸⁰ atomów — w przybliżeniu 2²⁶⁶.

Rozmiar	Wysłane bajty	Losowe bity
1 B	1	8
8 B	8	64
16 B	16	128
32 B	32	256
64 B	64	512
128 B	128	1,024
256 B	256	2,048
512 B	512	4,096
1 KiB	1,024	8,192
1 MiB	1,048,576	8,388,608
100 MiB	104,857,600	838,860,800

POTOK ENTROPII

Co dzieje się, zanim bajt trafi do endpointu

01Szum termicznyfizyczne źródło analogowe

02Infinite Noise TRNGźródło entropii USB

03Testy + Keccakkontrola i kondycjonowanie

04RAM + rezerwa dyskowabuforowanie jednorazowego użycia

05PHP + HTTPSusługi i strumieniowanie

UWIERZYTELNIONE DOSTARCZANIE TRNG

Podpisy Ed25519 oparte na krzywych eliptycznych

Infinite Noise dostarcza entropię fizyczną; Ed25519 potwierdza pochodzenie i integralność odpowiedzi dostarczonej do Twojego systemu.

Dlaczego zwracane bity są podpisywane

Usługa podpisuje dokładną wiadomość zawierającą losowe bity wraz z liczbą bajtów, znacznikiem czasu, identyfikatorem klucza i opcjonalnym nonce klienta. Poprawny podpis Ed25519 potwierdza, że odpowiedź wystawił random.flameit.io, oraz wykrywa zmianę danych albo podpisanych metadanych przed zaakceptowaniem bitów.

Świeży nonce wiąże zwracane dane z konkretnym żądaniem klienta, chroniąc procedurę przed podmianą lub ponownym użyciem odpowiedzi. Prywatny klucz pozostaje w usłudze podpisującej; do weryfikacji odpowiedzi w OpenSSL użytkownik potrzebuje wyłącznie opublikowanego klucza publicznego.

Dwie drogi publikacji klucza publicznego

Rejestr kluczy HTTPS: https://random.flameit.io/signing-keys/Publikuje identyfikatory aktywnych i historycznych kluczy oraz pliki PEM zgodne z OpenSSL.
DNS TXT: _trng-signing-key.random.flameit.io.Publikuje przez DNS ten sam identyfikator aktywnego klucza i SubjectPublicKeyInfo zakodowane w Base64.

Porównaj obie kopie. Przed przyjęciem losowych danych poniższe skrypty porównują identyfikator klucza i znormalizowane bajty SPKI/DER z HTTPS i DNS. Zgodność obu dróg publikacji potwierdza ten sam aktywny klucz weryfikacyjny oraz ujawnia nieaktualny cache, niepełną rotację lub błąd wdrożenia. Resolver walidujący DNSSEC wzmacnia część sprawdzenia opartą na DNS.

PODPISANY JSON

Małe odpowiedzi uwierzytelnione

signed=json zwraca dokładną podpisaną wiadomość i surowy podpis Ed25519 jako Base64. Ten format jest wygodny dla niewielkich odpowiedzi aplikacyjnych.

PODPISANY PAKIET

Strumieniowe dane uwierzytelnione

signed=bundle zwraca archiwum TAR z random.bin, podpisanym proof.json zawierającym skrót SHA-512 oraz surowym proof.sig.

Pobierz klucz DNS i zapisz zweryfikowane bity

Podstawowa procedura JSON: porównaj oba źródła klucza publicznego, zweryfikuj Ed25519 i nonce, a następnie zapisz zaakceptowane dane jako secure_bits.bin.

set -euo pipefail

dns_name='_trng-signing-key.random.flameit.io'
registry_url='https://random.flameit.io/signing-keys/'
nonce="$(openssl rand -hex 16)"
output='secure_bits.bin'
work_dir="$(mktemp -d)"
trap 'rm -rf "$work_dir"' EXIT

printf '[1/7] Requesting 256 signed TRNG bits...\n'
printf '  Nonce sent: %s\n' "$nonce"
curl -fsS \
  "https://random.flameit.io/get/?bytes=32&signed=json&nonce=${nonce}" \
  -o "$work_dir/response.json"

printf '[2/7] Decoding the signed response...\n'
jq -er '.message_base64' "$work_dir/response.json" | base64 -d > "$work_dir/message.json"
jq -er '.signature_base64' "$work_dir/response.json" | base64 -d > "$work_dir/signature.bin"
signed_nonce="$(jq -er '.client_nonce' "$work_dir/message.json")"
signed_key_id="$(jq -er '.key_id' "$work_dir/message.json")"
printf '  Nonce sent:               %s\n' "$nonce"
printf '  Nonce in signed message:  %s\n' "$signed_nonce"
printf '  Key ID in signed message: %s\n' "$signed_key_id"

printf '[3/7] Fetching the Ed25519 key from DNS...\n'
dns_txt="$(dig +short TXT "$dns_name" | head -n 1 | tr -d '"')"
txt_field() {
  printf '%s\n' "$dns_txt" | tr ';' '\n' | sed -n "s/^[[:space:]]*$1=//p"
}
test "$(txt_field v)" = 'TRNG1'
test "$(txt_field k)" = 'Ed25519'
dns_key_id="$(txt_field kid)"
dns_spki="$(txt_field p)"
test -n "$dns_key_id"
test -n "$dns_spki"
printf '%s\n%s\n%s\n' \
  '-----BEGIN PUBLIC KEY-----' "$dns_spki" '-----END PUBLIC KEY-----' \
  > "$work_dir/dns-signing-key.pub"
openssl pkey -pubin -in "$work_dir/dns-signing-key.pub" \
  -pubout -outform DER -out "$work_dir/dns-signing-key.der"
dns_fingerprint="$(sha256sum "$work_dir/dns-signing-key.der" | awk '{print $1}')"
printf '  DNS TXT: %s\n' "$dns_txt"
printf '  DNS key ID: %s\n' "$dns_key_id"
printf '  DNS public key (PEM):\n'
sed 's/^/    /' "$work_dir/dns-signing-key.pub"
printf '  DNS key SPKI SHA-256: %s\n' "$dns_fingerprint"

printf '[4/7] Comparing the DNS key with the active service key...\n'
curl -fsS "$registry_url" -o "$work_dir/signing-keys.json"
service_key_id="$(jq -er \
  '[.keys[] | select(.status == "active")] | if length == 1 then .[0].key_id else error("expected exactly one active signing key") end' \
  "$work_dir/signing-keys.json")"
if [[ ! "$service_key_id" =~ ^[A-Za-z0-9][A-Za-z0-9._-]{2,63}$ ]]; then
  printf 'ERROR: The service registry returned an invalid active key ID.\n' >&2
  exit 1
fi
curl -fsS "${registry_url}?key=${service_key_id}.pub" \
  -o "$work_dir/service-signing-key.pub"
openssl pkey -pubin -in "$work_dir/service-signing-key.pub" \
  -pubout -outform DER -out "$work_dir/service-signing-key.der"
service_fingerprint="$(sha256sum "$work_dir/service-signing-key.der" | awk '{print $1}')"
printf '  Active service key ID: %s\n' "$service_key_id"
printf '  Active service public key (PEM):\n'
sed 's/^/    /' "$work_dir/service-signing-key.pub"
printf '  Service key SPKI SHA-256: %s\n' "$service_fingerprint"
test "$dns_key_id" = "$service_key_id"
cmp -s "$work_dir/dns-signing-key.der" "$work_dir/service-signing-key.der"
printf '  DNS key vs service key: MATCH\n'

printf '[5/7] Verifying origin, integrity, key ID and request nonce...\n'
openssl pkeyutl -verify \
  -pubin -inkey "$work_dir/dns-signing-key.pub" \
  -rawin -in "$work_dir/message.json" \
  -sigfile "$work_dir/signature.bin" >/dev/null
test "$signed_nonce" = "$nonce"
test "$signed_key_id" = "$dns_key_id"
test "$(jq -er '.algorithm' "$work_dir/message.json")" = 'Ed25519'
printf '  Signature: valid · key ID: MATCH · nonce: MATCH\n'

printf '[6/7] Extracting the verified random bits...\n'
jq -er '.data_base64' "$work_dir/message.json" | base64 -d > "$output"
expected_bytes="$(jq -er '.returned_bytes' "$work_dir/message.json")"
actual_bytes="$(wc -c < "$output" | tr -d '[:space:]')"
test "$actual_bytes" = "$expected_bytes"

printf '[7/7] SUCCESS: %s verified random bits saved as %s\n' \
  "$((actual_bytes * 8))" "$output"
sha256sum "$output"

Pobierz, zweryfikuj i rozpakuj podpisany pakiet

Procedura bundle wykonuje to samo porównanie klucza DNS/HTTPS, a następnie sprawdza proof.json, jego nonce i skrót SHA-512 przed zapisaniem secure_bundle_bits.bin.

set -euo pipefail

dns_name='_trng-signing-key.random.flameit.io'
registry_url='https://random.flameit.io/signing-keys/'
requested_bytes=1048576
nonce="$(openssl rand -hex 16)"
output='secure_bundle_bits.bin'
work_dir="$(mktemp -d)"
trap 'rm -rf "$work_dir"' EXIT

printf '[1/8] Requesting a signed %s-byte TRNG bundle...\n' "$requested_bytes"
printf '  Nonce sent: %s\n' "$nonce"
curl -fsS \
  "https://random.flameit.io/get/?bytes=${requested_bytes}&signed=bundle&nonce=${nonce}" \
  -o "$work_dir/random-signed.tar"

printf '[2/8] Validating and extracting the TAR package...\n'
actual_entries="$(tar -tf "$work_dir/random-signed.tar" | LC_ALL=C sort)"
expected_entries="$(printf '%s\n' proof.json proof.sig random.bin | LC_ALL=C sort)"
test "$actual_entries" = "$expected_entries"
mkdir "$work_dir/bundle"
tar -xf "$work_dir/random-signed.tar" -C "$work_dir/bundle"
test -f "$work_dir/bundle/random.bin"
test -f "$work_dir/bundle/proof.json"
test -f "$work_dir/bundle/proof.sig"

printf '[3/8] Reading signed bundle metadata...\n'
signed_nonce="$(jq -er '.client_nonce' "$work_dir/bundle/proof.json")"
signed_key_id="$(jq -er '.key_id' "$work_dir/bundle/proof.json")"
printf '  Nonce sent:              %s\n' "$nonce"
printf '  Nonce in signed proof:   %s\n' "$signed_nonce"
printf '  Key ID in signed proof:  %s\n' "$signed_key_id"

printf '[4/8] Fetching the Ed25519 key from DNS...\n'
dns_txt="$(dig +short TXT "$dns_name" | head -n 1 | tr -d '"')"
txt_field() {
  printf '%s\n' "$dns_txt" | tr ';' '\n' | sed -n "s/^[[:space:]]*$1=//p"
}
test "$(txt_field v)" = 'TRNG1'
test "$(txt_field k)" = 'Ed25519'
dns_key_id="$(txt_field kid)"
dns_spki="$(txt_field p)"
test -n "$dns_key_id"
test -n "$dns_spki"
printf '%s\n%s\n%s\n' \
  '-----BEGIN PUBLIC KEY-----' "$dns_spki" '-----END PUBLIC KEY-----' \
  > "$work_dir/dns-signing-key.pub"
openssl pkey -pubin -in "$work_dir/dns-signing-key.pub" \
  -pubout -outform DER -out "$work_dir/dns-signing-key.der"
dns_fingerprint="$(sha256sum "$work_dir/dns-signing-key.der" | awk '{print $1}')"
printf '  DNS key ID: %s\n' "$dns_key_id"
printf '  DNS key SPKI SHA-256: %s\n' "$dns_fingerprint"

printf '[5/8] Comparing the DNS key with the active service key...\n'
curl -fsS "$registry_url" -o "$work_dir/signing-keys.json"
service_key_id="$(jq -er \
  '[.keys[] | select(.status == "active")] | if length == 1 then .[0].key_id else error("expected exactly one active signing key") end' \
  "$work_dir/signing-keys.json")"
if [[ ! "$service_key_id" =~ ^[A-Za-z0-9][A-Za-z0-9._-]{2,63}$ ]]; then
  printf 'ERROR: The service registry returned an invalid active key ID.\n' >&2
  exit 1
fi
curl -fsS "${registry_url}?key=${service_key_id}.pub" \
  -o "$work_dir/service-signing-key.pub"
openssl pkey -pubin -in "$work_dir/service-signing-key.pub" \
  -pubout -outform DER -out "$work_dir/service-signing-key.der"
service_fingerprint="$(sha256sum "$work_dir/service-signing-key.der" | awk '{print $1}')"
printf '  Active service key ID: %s\n' "$service_key_id"
printf '  Service key SPKI SHA-256: %s\n' "$service_fingerprint"
test "$dns_key_id" = "$service_key_id"
cmp -s "$work_dir/dns-signing-key.der" "$work_dir/service-signing-key.der"
printf '  DNS key vs service key: MATCH\n'

printf '[6/8] Verifying Ed25519, key ID and request nonce...\n'
openssl pkeyutl -verify \
  -pubin -inkey "$work_dir/dns-signing-key.pub" \
  -rawin -in "$work_dir/bundle/proof.json" \
  -sigfile "$work_dir/bundle/proof.sig" >/dev/null
test "$signed_nonce" = "$nonce"
test "$signed_key_id" = "$dns_key_id"
test "$(jq -er '.algorithm' "$work_dir/bundle/proof.json")" = 'Ed25519'
test "$(jq -er '.payload_file' "$work_dir/bundle/proof.json")" = 'random.bin'
test "$(jq -er '.returned_bytes' "$work_dir/bundle/proof.json")" = "$requested_bytes"
printf '  Signature: valid · key ID: MATCH · nonce: MATCH\n'

printf '[7/8] Verifying the payload SHA-512 and byte count...\n'
(
  cd "$work_dir/bundle"
  jq -er '"\(.payload_sha512)  \(.payload_file)"' proof.json | sha512sum -c -
)
actual_bytes="$(wc -c < "$work_dir/bundle/random.bin" | tr -d '[:space:]')"
test "$actual_bytes" = "$requested_bytes"

printf '[8/8] Saving the verified random bits...\n'
install -m 600 "$work_dir/bundle/random.bin" "$output"
printf 'SUCCESS: %s verified random bits saved as %s\n' \
  "$((actual_bytes * 8))" "$output"
sha256sum "$output"

Opcjonalnie domieszaj zweryfikowane bity do Linuksa

Użyj wyniku utworzonego przez dowolną z procedur weryfikacji. Jądro miesza te bajty z istniejącą pulą losową; sam zapis nie zwiększa licznika entropii uznanej przez jądro.

set -euo pipefail

input='secure_bits.bin'
test -s "$input"
bits="$(( $(wc -c < "$input") * 8 ))"
printf 'Mixing %s verified TRNG bits into the Linux random pool...\n' "$bits"
sudo tee /dev/random < "$input" > /dev/null
printf 'SUCCESS: verified TRNG bits were mixed into /dev/random.\n'

ŹRÓDŁO SPRZĘTOWE

Dlaczego Infinite Noise TRNG?

Endpoint nie udostępnia surowych bitów USB. Sterownik infnoise sprawdza i kondycjonuje sygnał fizyczny za pomocą Keccak-1600. Go najpierw wydaje dane z RAM i utrzymuje trwałą rezerwę dyskową na skoki zapotrzebowania.

Fizyczna nieprzewidywalność

Układ wykorzystuje szum termiczny i elektroniczny w modularnym mnożniku entropii. Przy wzmocnieniu pętli około 1,82 model przewiduje w przybliżeniu log₂(1,82) ≈ 0,864 bitu entropii na surowy bit wyjściowy.

Odporność na sygnały wstrzykiwane

Układ wielokrotnie mnoży swój zaszumiony stan modulo zakres zasilania. Zakłócenie zewnętrzne miesza się z istniejącym stanem, utrudniając wymuszenie wybranego wyniku.

Ciągłe testy stanu

Sterownik open source szacuje entropię surowego strumienia. Gdy odbiega ona od oczekiwanego modelu lub pojawiają się podejrzane serie identycznych wartości, wyjście zostaje zatrzymane zamiast po cichu wydawać wątpliwe dane.

Kondycjonowanie kryptograficzne

Skorelowane sąsiednie surowe bity nigdy nie są wydawane bezpośrednio. Po sprawdzeniu szacowanej entropii funkcja gąbkowa Keccak-1600 wybiela strumień.

Konserwatywny stosunek wyjścia

Usługa używa infnoise --multiplier 1: 512 sprawdzonych bitów wejściowych, szacowanych na co najmniej około 433 bity entropii, jest kondycjonowanych do 256 bitów wyjściowych. Go nie rozszerza strumienia za pomocą PRNG.

Najpierw RAM, dysk w rezerwie

Go bezpośrednio uzupełnia wolne miejsce w RAM i najpierw wydaje dane z RAM. Dopiero pełny bufor RAM uzupełnia dysk; rezerwa jest odczytywana wyłącznie po opróżnieniu RAM. Bajty pozostają jednorazowe także przy wielu równoczesnych klientach.

Uwaga eksploatacyjna

Jest to mocne dodatkowe źródło entropii. Dane wyjściowe pochodzą ze sprzętu i są kondycjonowane kryptograficznie, a nie stanowią nieprzetworzonego strumienia analogowego. Bezpieczeństwo zależy również od sprzętu i sterownika TRNG, hosta Go/PHP, ochrony buforów i uwierzytelnionego transportu HTTPS.

Źródła techniczneSprzęt i teoria Infinite Noise ↗infnoise — dokumentacja sterownika ↗Stan lokalnej usługi Go ↗

ZAREJESTROWANA PRÓBKA

Statystyki wyjścia

Wyniki dla próbki 8 GB. Testy statystyczne wspierają ciągłe monitorowanie jakości wyjścia; potwierdzenie fizycznego pochodzenia wynika z udokumentowanej architektury sprzętu, testów stanu i procesu kondycjonowania.

Otwórz pełny raport z testu ↗

Entropia: 8.000000 bitów/bajt
Średnia: 127.5019 ideał 127,5
Korelacja szeregowa: −0.000007 ideał 0,0
Monte Carlo π: 3.141638830 błąd 0,00%

Entropia sprzętowa,wyjaśniona i zweryfikowana.