🔥 Spalone ścieżki: 0
📐 0ᵢ (zero urojone): —
Niech M będzie przestrzenią wiadomości o długości n, gdzie M = {0,1}n.
Πs : M → M jest permutacją bez powtórzeń, gdzie s = H(PESEL2 ∥ counter). Dla każdego s, Πs jest bijekcją, a Πs-1 istnieje wtedy i tylko wtedy, gdy s jest znane.
B(m, t) = (Πs(m), σ(m, t)) — gdzie σ(m, t) to sygnatura zniszczenia. Po wykonaniu B, ścieżka pośrednia Πs jest nieodwracalnie usuwana z pamięci.
0ᵢ = XOR(ścieżka, ścieżka) po spaleniu. 0ᵢ ≠ 0 w klasycznym sensie. 0ᵢ zawiera metadane o czasie spalenia i identyfikatorze ścieżki.
Niech AQ będzie kwantowym algorytmem atakującym. Adv(AQ) = negl(λ). Dowód (szkic): AQ stosuje superpozycję na przestrzeni ścieżek. Ale ścieżki nie istnieją po spaleniu — nie ma stanu kwantowego reprezentującego nieistniejącą informację. Superpozycja kolapsuje na stan pusty. ▮
Burning Encryption osiąga bezpieczeństwo doskonałe w sensie Shannona: I(m; c | s) = 0 — ciphertext c nie zawiera informacji o plaintext m bez znajomości s.
| Kryterium | BURNING | Kyber | Dilithium | McEliece |
|---|---|---|---|---|
| Typ | Burn-based | Lattice | Lattice | Code |
| Klucz publiczny | JAWNY (unikatowe) | 800 B | 1 312 B | 261 120 B |
| Klucz prywatny | SEED 160b (nigdy nie transmitowany) | 1 632 B | 2 528 B | 6 452 B |
| Quantum-safe | ✅ Z ZASADY | ✅ | ✅ | ✅ |
| Odporność na Shor | ✅ Nie ma co faktoryzować | ✅ | ✅ | ✅ |
| Odporność na Grover | ✅ Brak klucza do przeszukania | ⚠️ ½ | ⚠️ ½ | ⚠️ ½ |
| Wiązanie z tożsamością | ✅ PESEL2 | ❌ | ❌ | ❌ |
| Jednorazowość | ✅ Fundamentalna | ❌ | ❌ | ❌ |
| Formalna weryfikacja | W trakcie | ✅ NIST | ✅ NIST | ✅ NIST |
🔥 Zero-Key Attack Surface: klucz jest jawny → nie ma co kraść
🔥 Naturalna jednorazowość: każda transmisja konsumuje ścieżkę
🔥 Tożsamość wbudowana: PESEL2 jako root of trust
🔥 Brak key exchange: nie trzeba wymieniać kluczy
import hashlib, hmac, time, secrets
from typing import Tuple
SIGMA = 2.414213562373095 # σ = 1 + √2
PHI = 1.618033988749895 # φ = (1 + √5)/2
PUBLIC_KEY = f"CODEX-BURN-σ{SIGMA:.6f}-φ{PHI:.6f}"
CONSTANT = hashlib.sha3_256(PUBLIC_KEY.encode()).digest()
def derive_pesel2(pesel: str) -> bytes:
salt = hashlib.sha256(CONSTANT).digest()[:16]
return hashlib.pbkdf2_hmac('sha3_256', pesel.encode(), salt,
iterations=int(SIGMA * 100000), dklen=20)
def generate_burn_seed(pesel2: bytes, counter: int) -> int:
h = hashlib.sha3_256(pesel2 + counter.to_bytes(8,'big')).digest()
return int.from_bytes(h[:16], 'big')
def permute(data: bytes, seed: int) -> bytes:
n = len(data); indices = list(range(n)); state = seed
for i in range(n-1, 0, -1):
state = (state * 6364136223846793005 + 1) & 0xFFFFFFFFFFFFFFFF
j = state % (i + 1)
indices[i], indices[j] = indices[j], indices[i]
return bytes(data[indices[i]] for i in range(n))
def unpermute(data: bytes, seed: int) -> bytes:
n = len(data); indices = list(range(n)); state = seed; swaps = []
for i in range(n-1, 0, -1):
state = (state * 6364136223846793005 + 1) & 0xFFFFFFFFFFFFFFFF
j = state % (i + 1); swaps.append((i, j))
for i, j in reversed(swaps):
indices[i], indices[j] = indices[j], indices[i]
result = bytearray(n)
for i in range(n): result[indices[i]] = data[i]
return bytes(result)
def burn_encrypt(plaintext, pesel2, counter):
seed = generate_burn_seed(pesel2, counter)
ts = time.time()
permuted = permute(plaintext, seed)
mask = hashlib.sha3_256(
seed.to_bytes(16,'big') + str(ts).encode()
).digest()[:len(permuted)]
ct = bytes(a^b for a,b in zip(permuted, mask))
iz = hashlib.sha3_256(permuted + mask).hexdigest()[:16]
return ct, counter, ts, iz
def burn_decrypt(ct, pesel2, counter, ts):
seed = generate_burn_seed(pesel2, counter)
mask = hashlib.sha3_256(
seed.to_bytes(16,'big') + str(ts).encode()
).digest()[:len(ct)]
permuted = bytes(a^b for a,b in zip(ct, mask))
return unpermute(permuted, seed)Pełna implementacja: codex.sex.pl/burning_encryption.py