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. En almindelig afsendelse er offentlig i blokudforskeren - mængde, afsender, modtager - præcis som Bitcoin. En skyggesend er Kyber-768-krypteret og dirigeret til en brænderadresse, og den relay daemon maskerer de private adresser, før opdagelsesrejsende nogensinde modtager dem. Udforskeren har aldrig de nøgne data. Skyggebalancer og transaktionslister returnerer "Privat", og posten bærer privacy_tier: shadow.
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, så er det væk - ikke tilbagekaldt, ikke arkiveret, ingen optegnelse tilbage til stævning. Det er aldrig skrevet til disk; den eksisterer kun i flygtig hukommelse på tværs af Wildlands-knudenettet.
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 — aldrig grafen. Ikke hvem betalte hvem, ikke saldi, ikke historie. Identitetslaget samles aldrig i første omgang, og adresser eksisterer som korrelationsresistente matchede hashes snarere end nøgne strenge.
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 er den NIST standardiserede version af Kyber-768 (FIPS 203). De er funktionelt ækvivalente med mindre forskelle i kodning. Moderne implementeringer bør bruge FIPS 203-kompatibel ML-KEM-768 til standardoverholdelse. De 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.
Ældre tegnebøger (Bitcoin, Ethereum, Monero) bruger kryptografi, som kvantecomputere kan bryde. Over $250 billion i udsatte Bitcoin-adresser er allerede i fare.