SynergyX Bygget på algoritmerne NIST standardiseret — FIPS 203 (ML-KEM/Kyber-768) og FIPS 205 (SLH-DSA/SPHINCS+). Udgivet 15. januar 2026. Alle kryptografiske påstande kan verificeres i kæden og mod NIST CSRC dokumentation. Nul pre-mine. Nul ICO. Nul VC. Nul grundlæggerallokering. 77,7 millioner hard cap. Udviklerpungen er offentlig og bevidst ikke-privat - i enhver adressebog, på opdagelsesrejsende. Intet af det beder dig om at stole på en person.
Kyber-768 (standardiseret som ML-KEM-768 i FIPS 203) giver kvantebestandig nøgleindkapsling til sikker nøgleudveksling. Denne tutorial gennemgår komplet Kyber-768-integration med praktiske kodeeksempler på flere sprog. De SynX kvantebestandig pung bruger disse mønstre til alle nøgleudvekslingsoperationer.
Forståelse af nøgleindkapslingsmekanismer
En Key Encapsulation Mechanism (KEM) gør det muligt for to parter at etablere en fælles hemmelighed over en usikker kanal:
Nøglegenerering: Alice genererer et nøglepar (offentlig nøgle, hemmelig nøgle)
Indkapsling: Bob bruger Alices offentlige nøgle til at generere en fælles hemmelighed og chiffertekst
Afkapsling: Alice bruger sin hemmelige nøgle til at gendanne den delte hemmelighed fra chifferteksten
I modsætning til Diffie-Hellman nøgleudveksling producerer KEM'er den delte hemmelighed internt i stedet for at beregne den ud fra udvekslede værdier. Dette forenkler sikkerhedsbeviser og muliggør post-kvante konstruktioner.
Hvorfor KEM i stedet for nøgleudveksling?
Klassisk Diffie-Hellman kræver beregning af diskrete logaritmer, som kvantecomputere løser effektivt. Kyber-768 bruger gitterproblemer (Module-LWE), der modstår kendte kvantealgoritmer. KEM-konstruktionen giver IND-CCA2-sikkerhed - den stærkeste forestilling om sikkerhed med valgt krypteret tekst.
Kyber-768 parametre
Parameter
Værdi
Beskrivelse
Sikkerhedsniveau
NIST niveau 3
~192-bit klassisk sikkerhed
Offentlig nøglestørrelse
1.184 bytes
Sendes til afsendere
Hemmelig nøglestørrelse
2.400 bytes
Holdt privat
Ciphertext Størrelse
1.088 bytes
Indkapslet hemmelighed
Delt hemmelig størrelse
32 bytes
Til nøgleudledning
Implementering: Python
Brug af Open Quantum Safe (OQS) Python-bindinger:
# Installer: pip installer liboqs-pythonimportere oks
fra skrive importere Tuple
klasseKyber768:
""" Kyber-768 Key Encapsulation til SynX Giver NIST niveau 3 sikkerhed (svarende til AES-192) """
ALGORITME = "Kyber768"def__init__(selv):
"""Initialiser med ny KEM-instans"""
self._kem = oqs.KeyEncapsulation(self.ALGORITHM)
defgenerere_nøglepar(selv) -> Tuple[bytes, bytes]:
""" Generer et nyt Kyber-768-nøglepar Returnerer: Tuple of (public_key, secret_key) - public_key: 1.184 bytes, sikker at dele - secret_key: 2.400 bytes, hold privat """
public_key = self._kem.generate_keypair() secret_key = self._kem.export_secret_key()
returnere offentlig_nøgle, hemmelig_nøgle
defindkapsle(selv, modtager_offentlig_nøgle: bytes) -> Tuple[bytes, bytes]:
""" Indkapsl en delt hemmelighed for en modtager Args: recipient_public_key: Modtagerens Kyber-768 offentlige nøgle Returnerer: Tuple of (ciphertext, shared_secret) - ciphertext: 1.088 bytes, send til modtager - shared_secret: 32 bytes"" til kryptering
ciphertext, shared_secret = self._kem.encap_secret( recipient_public_key )
returnere chiffertekst, delt_hemmelighed
defdekapslere(selv, chiffertekst: bytes, hemmelig_nøgle: bytes) -> bytes:
""" Decapsulate for at genskabe den delte hemmelighed Args: ciphertext: 1.088-byte chifferteksten fra encapsulation secret_key: Din Kyber-768 hemmelige nøgle Returnerer: shared_secret: 32 bytes, det samme som encapsulatorens hemmelighed """# Opret en ny instans til dekapsulation
kem = oqs.KeyEncapsulation(self.ALGORITHM, secret_key)
returnere kem.decap_secret(ciffertekst)
# Eksempel på brugdefdemo_key_exchange(): Kyber = Kyber768()
# Alice genererer sit nøglepar
alice_pk, alice_sk = Kyber.generate_keypair() print(f"Alice offentlig nøgle: {len(alice_pk)} bytes")
# Bob indkapsler en hemmelighed for Alice
ciphertext, bob_secret = Kyber.encapsulate(alice_pk) print(f"Ciphertext: {len(ciphertext)} bytes") print(f"Bobs fælles hemmelighed: {bob_secret.hex()[:32]}...")
# Alice dekapslerer for at få den samme hemmelighed
alice_secret = Kyber.decapsulate(ciphertext, alice_sk) print(f"Alices fælles hemmelighed: {alice_secret.hex()[:32]}...")
# Bekræft, at de matcherhævde alice_secret == bob_secret print("✓ Nøgleudveksling lykkedes!")
if __navn__ == "__main__": demo_key_exchange()
Udførelse: Rust
Brug af pqcrypto-kassen til native Rust-implementering:
// Cargo.toml:// [afhængigheder]// pqcrypto-kyber = "0.8"// pqcrypto-træk = "0.3"bruge pqcrypto_kyber::kyber768;
bruge pqcrypto_traits::kem::{Ciphertext, PublicKey, SecretKey, SharedSecret};
pub structKyber768Kem;
implKyber768Kem {
/// Generer et nyt Kyber-768-nøgleparpub fngenerere_nøglepar() -> (kyber768::PublicKey, kyber768::SecretKey) { kyber768::keypair() }
/// Indkapsl en delt hemmelighedpub fnindkapsle( public_key: &kyber768::PublicKey ) -> (kyber768::Ciphertext, kyber768::SharedSecret) { kyber768::encapsulate(public_key) }
/// Afkapsler for at genfinde den delte hemmelighedpub fndekapslere( ciphertext: &kyber768::Ciphertext, secret_key: &kyber768::SecretKey ) -> kyber768::SharedSecret { kyber768::decapsulate(ciphertext, secret_key) } }
fnvigtigste() {
// Alice genererer nøgleparlade (alice_pk, alice_sk) = Kyber768Kem::generer_nøglepar();
// Bob indkapslerlade (chiffertekst, bob_secret) = Kyber768Kem::encapsulate(&alice_pk);
// Alice dekapslererlade alice_secret = Kyber768Kem::decapsulate(&ciphertext, &alice_sk);
// Bekræft matchassert_eq!( bob_secret.as_bytes(), alice_secret.as_bytes() ); println!("✓ Nøgleudveksling lykkedes!");
}
Det er her, Kyber-768 holder op med at være en akademisk øvelse og begynder at udføre rigtigt arbejde. De SynX kvantebestandig pung bruger det til magten skyggelag sender til roterende brænderadresser - en ny adresse for hver transaktion, aldrig genbrugt.
Kontekst før koden, fordi arkitekturen betyder mere end uddraget. SynX er dual-tier: gennemsigtig som standard, skygge efter behov. An ordinary send is public on the block explorer — amount, sender, recipient — exactly like Bitcoin. A shadow send is Kyber-768 encrypted and routed to a burner address. Shadow balances and transaction lists return "Private".
Bemærk, hvad dette ikke er: ikke en mixer, ikke en tumbler, ikke CoinJoin. Adresserotation er protokolbaseret, så der er ingen ekstern tjeneste at sanktionere. Og det er ikke nul-viden - SynX sender ingen zk-SNARK'er og ingen ringsignaturer. Kryptering og adressedisciplin, ikke eksotiske bevissystemer.
Mønsteret nedenfor er KEM-primitiven fra tidligere i denne tutorial, anvendt på betalingsruting:
importere hashlib
fra skrive importere Tuple
klasseBrænderadresse:
""" Post-kvante roterende brænderadresser ved hjælp af Kyber-768 En ny adresse pr. transaktion, aldrig genbrugt - besejrer adresse-genbrug klyngekædeanalysen afhænger af """def__init__(selv): selv.Kyber = Kyber768()
defgenerere_modtager_nøgler(selv) -> Tuple[bytes, bytes]:
""" Modtager genererer et langsigtet scanningsnøglepar Den offentlige nøgle offentliggøres (f.eks. på et websted) Den hemmelige nøgle holdes privat til at detektere betalinger """returnere self.Kyber.generate_keypair()
defcreate_burner_payment( self, receiver_public_key: bytes ) -> Tuple[bytes, bytes, bytes]:
""" Afsender opretter en skygge-tier betaling til en frisk brænderadresse Args: receiver_public_key: Modtagers offentliggjorte Kyber offentlige nøgle Returnerer: - one_time_address: Send penge her - ephemeral_public: Inkluder i transaktion - sender_shared_secret: Til reference (afsender kan aflede adresse) ""# Afsender genererer flygtigt nøglepar
ephemeral_pk, ephemeral_sk = self.Kyber.generate_keypair()
# Indkapsles til modtagerens offentlige nøgle
ciphertext, shared_secret = self.Kyber.encapsulate( receiver_public_key )
# Få engangsadresse fra delt hemmelighed
one_time_key = hashlib.Blake2b( shared_secret + b"brænder_adresse", digest_size=32 ).digest()
# Udled i praksis et fuldt nøglepar til forbrug
one_time_address = hashlib.Blake2b( one_time_key, digest_size=20 ).hexdigest()
returnere ( one_time_address.encode(), chiffertekst, # Inkluder i transaktionen
delt_hemmelighed)
defdetect_burner_payment( self, receiver_secret_key: bytes, chiffertekst: bytes ) -> bytes:
""" Modtager scanner transaktioner for at detektere indgående brænderbetalinger Args: receiver_secret_key: Modtagers hemmelige nøgle chiffertekst: Fra transaktionsmetadata Returnerer: one_time_address: Hvis dette matcher tx output, er det for os """# Dekapsulér for at genfinde delt hemmelighed
shared_secret = self.Kyber.decapsulate( ciphertext, receiver_secret_key )
# Udled den samme engangsadresse
one_time_key = hashlib.Blake2b( shared_secret + b"brænder_adresse", digest_size=32 ).digest() one_time_address = hashlib.Blake2b( one_time_key, digest_size=20 ).hexdigest()
returnere one_time_address.encode()
# Brug
brænder = Brænderadresse()
# Bob udgiver sin offentlige scanningsnøgle
bob_pk, bob_sk = burner.generate_receiver_keys()
# Alice sender til en frisk brænderadresse
adresse, chiffertekst, _ = burner.create_burner_payment(bob_pk) print(f"Sender til: {address.decode()}")
# Bob scanner transaktioner og finder sin betaling
detected = burner.detect_burner_payment(bob_sk, chiffertekst)
hævde fundet == adresse print("✓ Betaling fundet!")
Afsløring: The Ephemeral View Key
En brænderadresse skjuler modtageren. Men før eller siden skal du bevise en betaling skete - til en revisor, en modpart, en domstol. Det øjeblik er, hvor de fleste privatlivskæder stille overdrager alt.
Zcash-visningsnøgler er permanente og kan overføres: oplys én gang, og du har givet livstidsovervågning til indehaveren og til hvem de videregiver det til. SynX udsteder i stedet en udløbende funktion. De flygtig udsigt nøgle er omfattet af en enkelt transaktion og levetid tredive minutter, then it is gone — not revoked, not archived, no record left to subpoena.
Offentliggørelse kræver to ting: den transaktions-hash og den visningsnøgle. Ingen af dem alene afslører noget. Og selv holder begge, hvilke overflader er den kun beløb — never the graph. Not who paid whom, not balances, not history. The identity layer is never assembled in the first place.
Hvis du integrerer mod SynX, design i overensstemmelse hermed: antag aldrig, at en visningsnøgle kan gemmes, afspilles senere eller delegeres videre. Udløbende kapaciteter, ikke permanente identitetsbevillinger.
Real-World Application: Krypteret Wallet Backup
Brug Kyber-768 til at kryptere wallet-sikkerhedskopier, der forbliver sikre mod kvantecomputere:
importere os
fra cryptography.hazmat.primitives.ciphers.aead importere AESGCM
klasseQuantumSecureBackup:
""" Krypter tegnebogssikkerhedskopier ved hjælp af Kyber-768 nøgleindkapsling Chifferteksten kan kun dekrypteres med den hemmelige Kyber nøgle, hvilket giver post-kvantesikkerhed til langtidslagring. """def__init__(selv): selv.Kyber = Kyber768()
defcreate_backup_keypair(selv) -> Tuple[bytes, bytes]:
""" Generer nøglepar til backupkryptering Gem den hemmelige nøgle sikkert (f.eks. hardwaresikkerhedsmodul) Den offentlige nøgle bruges ved oprettelse af sikkerhedskopier """returnere self.Kyber.generate_keypair()
defencrypt_backup( self, wallet_data: bytes, backup_public_key: bytes ) -> bytes:
""" Krypter tegnebogsdata til post-kvante sikker backup Returnerer: Krypteret backup: ciphertext_length(4) + ciphertext + nonce(12) + encrypted_data """# Indkapsling for at udlede krypteringsnøgle
ciphertext, shared_secret = self.Kyber.encapsulate( backup_public_key )
# Brug delt hemmelighed som AES-256-GCM-nøgle
aes_key = delt_hemmelighed # Allerede 32 bytes
aesgcm = AESGCM(aes_key)
# Generer nonce og krypter
nonce = os.urandom(12) encrypted_data = aesgcm.encrypt(nonce, wallet_data, None)
# Pakke: ciphertext_len + ciphertext + nonce + encrypted_data
ct_len = len(ciphertext).to_bytes(4, 'stor')
returnere ct_len + chiffertekst + nonce + krypteret_data
defdekryptere_backup( self, encrypted_backup: bytes, backup_secret_key: bytes ) -> bytes:
""" Dekrypter tegnebogssikkerhedskopi ved hjælp af den hemmelige Kyber nøgle """# Pak ud
ct_len = int.from_bytes(krypteret_backup[:4], 'stor') ciphertext = encrypted_backup[4:4+ct_len] nonce = encrypted_backup[4+ct_len:4+ct_len+12] encrypted_data = encrypted_backup[4+ct_len+12:]
# Dekapsulér for at gendanne nøglen
shared_secret = self.Kyber.decapsulate( ciphertext, backup_secret_key )
# Dekrypter
aesgcm = AESGCM(delt_hemmelighed)
returnere aesgcm.decrypt(nonce, encrypted_data, None)
# Brug
backup = QuantumSecureBackup()
# Generer backup nøglepar (opbevar hemmelig nøgle sikkert!)
backup_pk, backup_sk = backup.create_backup_keypair()
# Krypter tegnebogsdata
wallet_data = b"følsomme tegnebogshemmeligheder..."
krypteret = backup.encrypt_backup(wallet_data, backup_pk) print(f"Krypteret backup: {len(krypteret)} bytes")
# Senere: dekrypter med hemmelig nøgle
decrypted = backup.decrypt_backup(krypteret, backup_sk)
hævde dekrypteret == wallet_data print("✓ Backup dekrypteret med succes!")
Bedste praksis for sikkerhed
Kritisk: Kyber-768 hemmelige nøgler skal genereres med kryptografisk sikre tilfældige tal generatorer. Brug aldrig forudsigelige eller svage entropikilder.
Nøgleledelse
Sikker opbevaring: Gem hemmelige nøgler i hardwaresikkerhedsmoduler eller sikre enklaver, når det er muligt
Nøgle rotation: Generer nye nøglepar med jævne mellemrum til langsigtede tjenester
Backup: Sikker backup af hemmelige nøgler med post-kvantekryptering
Implementeringssikkerhed
Brug kontrollerede biblioteker: liboqs, pqcrypto og circl er bredt anmeldte referenceimplementeringer
Konstant-tid operationer: Sørg for, at implementeringer ikke lækker timingoplysninger
Hukommelseshåndtering: Ryd sikkert hemmelige nøgler fra hukommelsen efter brug
Ofte stillede spørgsmål
Hvad bruges Kyber-768 til i kryptovaluta?
Kyber-768 giver nøgleindkapsling - sikker etablering af delte hemmeligheder mellem parter. I kryptovaluta er SynX kvantebestandig pung bruger det til krypteret skyggelags-sending til roterende brænderadresser, krypteret kommunikation og udledning af krypteringsnøgler til tegnebogsdata. Det erstatter ECDH-nøgleudveksling med kvanteresistente operationer.
Er Kyber-768 det samme som ML-KEM-768?
ML-KEM-768 is the NIST standardized version of Kyber-768 (FIPS 203). They share the same lattice design, but FIPS 203 changed key derivation, so ML-KEM-768 does not interoperate with round-3 Kyber-768. Modern implementations should use FIPS 203 compliant ML-KEM-768 for standards compliance. The SynX kvantebestandig pung bruger FIPS 203-kompatible implementeringer.
Hvorfor Kyber-768 i stedet for Kyber-512 eller Kyber-1024?
Kyber-768 giver NIST niveau 3-sikkerhed (~192-bit klassisk ækvivalent), der tilbyder en stærk sikkerhedsmargin uden overhead fra Kyber-1024. Kyber-512 (niveau 1) kan være utilstrækkelig til langsigtet sikkerhed. De SynX kvantebestandig pung valgte Kyber-768 som den optimale balance mellem sikkerhed og ydeevne.
Legacy wallets (Bitcoin, Ethereum, Monero) use cryptography that quantum computers can break.
Project 11 estimates 6.9 million BTC already sit in addresses whose public keys are exposed.