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.
Post-kvantenøgleafledning: HD Wallet Patterns for Developers
📅 Last updated: September 23, 2026🎧 Lyt: ~4 min
Hierarkisk deterministiske (HD) tegnebøger revolutionerede styring af kryptovalutanøgler ved at udlede ubegrænsede adresser fra et enkelt frø. Men BIP-32's afhængighed af secp256k1 elliptisk kurve-matematik skaber kvantesårbarhed. Denne vejledning dækker post-quantum HD tegnebogsmønstre ved hjælp af gitterbaserede og hash-baserede tilgange. De SynX kvantebestandig pung implementerer disse teknikker til problemfri nøglestyring.
Forståelse af traditionelle HD Wallet-begrænsninger
BIP-32 HD tegnebøger udleder børnenøgler ved hjælp af elliptisk kurvepunktmultiplikation:
# Traditionel BIP-32 (KVANTESÅRBAR)
child_key = parent_key + HMAC-SHA512(chaincode, data) child_public = child_private × G # EC point multiplikation
Kvantetruslen ligger på to områder:
Offentlig nøgleafledning: At udlede offentlige nøgler fra private nøgler bruger EC-multiplikation - Shor's algoritme bryder dette
Hærdet afledning: Mens hærdede stier skjuler afledningsforholdet, forbliver den underliggende EC-matematik sårbar
Vi har brug for helt nye afledningsordninger til postkvantesikkerhed.
Post-kvante afledningsstrategi
De SynX kvantebestandig pung bruger en tre-lags tilgang:
Frøgenerering: Standard BIP-39 mnemonisk → 512-bit frø (kvantesikker entropi)
Stiafledning: SHAKE-256 eller HKDF for at udlede deterministisk tilfældighed pr. sti
Nøglegenerering: Brug afledt tilfældighed som basis for Kyber/SPHINCS+ nøglegenerering
Nøgleindsigt: Den mnemoniske backup-tilgang forbliver gyldig - vi ændrer kun, hvordan afledte frø bliver til nøglepar. Brugere beholder velkendte 24-ords gendannelsessætninger, mens de opnår kvantemodstand.
Implementering: Frøudvidelse
importere hashlib
importere hmac
fra skrive importere Liste, Tuple
klassePostQuantumHDWallet:
""" Post-Quantum Hierarchical Deterministic Wallet bruger SHAKE-256 til deterministisk nøgleafledning med Kyber-768 og SPHINCS+ til faktiske kryptografiske nøgler. """def__init__(selv, master_seed: bytes):
""" Initialiser fra master-seed (typisk fra BIP-39 mnemonic) Args: master_seed: 64-byte-seed fra PBKDF2(mnemonic, salt="mnemonic"+passphrase) """if len(master_seed) < 32:
hæve ValueError("Seed skal være mindst 256 bit") self.master_seed = master_seed
# Udled masterkædekode (bruges til stiafledning)
self.master_chain_code = self._derive_chain_code(master_seed, b"SynX-PQ-HD-Master")
def_derive_chain_code(selv, frø: bytes, kontekst: bytes) -> bytes:
"""Udled en kædekode til hierarkisk udledning"""
h = hashlib.shake_256() h.update(seed + kontekst)
returnere h.digest(32)
defderive_path_seed(selv, sti: str) -> bytes:
""" Udled deterministisk tilfældighed for en specifik sti Stiformat: "m/44'/9999'/0'/0/0" (BIP-44-stil) Args: sti: Afledningsstistreng Returnerer: 64 bytes deterministisk tilfældighed for nøglegenerering """
komponenter = self._parse_path(path) current_seed = self.master_seed current_chain = self.master_chain_code
for komponent in komponenter: current_seed, current_chain = self._derive_child( current_seed, current_chain, component )
returnere nuværende_frø
def_parse_sti(selv, sti: str) -> Liste[int]:
"""Parsér BIP-32 stilsti til komponenter"""hvis ikke sti.starter med("m/"):
hæve ValueError("Stien skal starte med 'm/'") komponenter = []
for del in sti[2:].split("/"):
hvis ikke del:
fortsætteif part.endswith("'"):
# Hærdet afledning
indeks = int(del[:-1]) + 0x80000000
andet: indeks = int(del) komponenter.append(indeks)
returnere komponenter
def_aflede_barn( self, parent_seed: bytes, parent_chain: bytes, index: int ) -> Tuple[bytes, bytes]:
""" Udleder børnefrø og kædekode Bruger HMAC-SHA512 svarende til BIP-32, men udgange føres ind i SHAKE-256 for post-kvantesikker ekspansion. """# Indkode indeks som 4 bytes big-endian
index_bytes = index.to_bytes(4, 'stor')
# HMAC til underordnede afledningsdata
data = hmac.new( parent_chain, parent_seed + index_bytes, hashlib.sha512 ).digest()
# Venstre 32 bytes → underordnet frø-komponent# Højre 32 bytes → ny kædekode
child_seed_component = data[:32] child_chain = data[32:]
# Kombiner forælder og barn for nyt frø# Brug SHAKE-256 til kvantebestandig blanding
h = hashlib.shake_256() h.update(parent_seed + child_seed_component + index_bytes) child_seed = h.digest(64)
returnere barnefrø, barnekæde
# Eksempel på brugdefdemo_path_derivation():
# Simuler master frø fra mnemonicimportere hemmeligheder master_seed = secrets.token_bytes(64) tegnebog = PostQuantumHDWallet(master_seed)
# Udled frø til forskellige konti
stier = [
"m/44'/9999'/0'/0/0", # Konto 0, Ekstern, Adresse 0"m/44'/9999'/0'/0/1", # Konto 0, Ekstern, Adresse 1"m/44'/9999'/0'/1/0", # Konto 0, intern (ændring), adresse 0"m/44'/9999'/1'/0/0", # Konto 1, Ekstern, Adresse 0
]
for sti in stier: path_seed = wallet.derive_path_seed(path) print(f"{sti}: {sti_frø[:16].hex()}...")
Generering af Kyber-nøgler fra Path Seeds
Når vi har deterministisk tilfældighed for en sti, genererer vi Kyber-768-nøglepar:
importere oks
klasseDeterministisk Kyber:
""" Generer deterministiske Kyber-768-nøgler fra HD wallet-stier Bruger sti-seed som tilfældighedskilde til nøglegenerering. """def__init__(selv): selv.algoritme = "Kyber768"defgenerere_fra_frø(selv, path_seed: bytes) -> Tuple[bytes, bytes]:
""" Generer Kyber-nøglepar fra deterministisk seed Args: path_seed: 64 bytes fra HD wallet-afledning Returnerer: Tuple of (public_key, secret_key) """# Kyber har brug for specifikke mængder af tilfældighed# Udvid frøet til den ønskede længde med SHAKE-256
h = hashlib.shake_256() h.update(path_seed + b"Kyber-768-keygen")
# Kyber-768 kræver 64 bytes tilfældighed til nøglegenerering
tilfældighed = h.digest(64)
# Bemærk: De fleste PQC-biblioteker understøtter ikke seeded generation# Dette kræver enten:# 1. Et modificeret bibliotek med seeded nøglegenerering# 2. Udskiftning af RNG midlertidigt med deterministisk kilde# 3. Brug af et bibliotek, der understøtter deterministisk generering# Til SynX bruger vi den seedede variant:
kem = oqs.KeyEncapsulation(self.algorithm)
# I produktionen SynX SDK bruger denne seeded generation# Her viser vi standarden API til illustration
public_key = kem.generate_keypair() secret_key = kem.export_secret_key()
returnere offentlig_nøgle, hemmelig_nøgle
klasseDeterministiske SPHINCS:
""" Generer deterministiske SPHINCS+ nøgler fra HD tegnebogsstier """def__init__(selv, variant: str = "SPHINCS+-SHAKE-128s-simpelt"): self.algorithm = variant
defgenerere_fra_frø(selv, path_seed: bytes) -> Tuple[bytes, bytes]:
""" Generer SPHINCS+ nøglepar fra deterministisk frø """
h = hashlib.shake_256() h.update(path_seed + b"SPHINCS-Plus-keygen")
# SPHINCS+-128s har brug for specifik frølængde
tilfældighed = h.digest(48)
# Produktionen bruger seeded generation
sig = oqs.Signature(self.algorithm) public_key = sig.generate_keypair() secret_key = sig.export_secret_key()
returnere offentlig_nøgle, hemmelig_nøgle
Komplet implementering af HD Wallet
De SynX kvantebestandig pung kombinerer disse komponenter:
fra dataklasser importere dataklasse
fra skrive importere Valgfri @dataclass
klasseSynXAddress:
"""Fuldfør SynX-adresse med begge nøgletyper"""
sti: str kyber_public: bytes kyber_secret: bytes sphincs_public: bytes sphincs_secret: bytes adresse: str # Menneskelæselig adresseklasseSynXHDWallet:
""" Komplet Post-Quantum HD Wallet til SynX Funktioner: - BIP-39 kompatible mnemoniske frø - BIP-44 stil afledningsstier - Kyber-768 til nøgleindkapsling - SPHINCS+-128s til signaturer """# SynX mønttype (eksempel, registreret med SLIP-44)
COIN_TYPE = 9999
def__init__(selv, mnemonisk: str, adgangssætning: str = ""):
""" Initialiser tegnebogen fra BIP-39 mnemonic Args: mnemonic: 24-ords BIP-39 mnemonisk adgangskode: Valgfri BIP-39-adgangssætning """
self.master_seed = self._mnemonic_to_seed(mnemonic, passphrase) self.hd = PostQuantumHDWallet(self.master_seed) self.Kyber = Deterministisk Kyber() selv.SPHINCS = Deterministiske SPHINCS()
# Cache-afledte adresser
self._address_cache: dict[str, SynXAddress] = {}
def_mnemonisk_til_frø(selv, mnemonisk: str, adgangssætning: str) -> bytes:
"""Konverter BIP-39 mnemonic til frø"""importere hashlib
# BIP-39 frøafledning
password = mnemonic.encode('utf-8') salt = ("mnemonisk" + adgangssætning).encode('utf-8')
returnere hashlib.pbkdf2_hmac(
'sha512', adgangskode, salt, iterations=2048, dklen=64 )
defaflede_adresse( selv, konto: int = 0, ændring: int = 0, indeks: int = 0 ) -> SynXAddress:
""" Udled en komplet SynX adresse Args: konto: Kontonummer (hærdet) ændring: 0 for eksternt, 1 for internt/ændre indeks: Adresseindeks Returnerer: SynXAddress med alle nøgler og adressestreng """
sti = f"m/44'/{self.COIN_TYPE}'/{account}'/{change}/{index}"# Tjek cacheif sti in self._address_cache:
returnere self._address_cache[sti]
# Udled stifrø
path_seed = self.hd.derive_path_seed(sti)
# Udled sub-seeds for hver nøgletype# (forhindrer nøglekorrelation mellem Kyber og SPHINCS+)
kyber_seed = hashlib.shake_256(path_seed + b"Kyber").digest(64) sphincs_seed = hashlib.shake_256(path_seed + b"SPHINCS").digest(64)
# Generer nøgler (i produktion, bruger seeded generation)
kyber_pk, kyber_sk = self.Kyber.generate_from_seed(kyber_seed) sphincs_pk, sphincs_sk = self.SPHINCS.generate_from_seed(sfincs_seed)
# Opret adresse, der kan læses af mennesker
adresse = self._create_address(sphincs_pk, kyber_pk) resultat = SynXAddress( path=path, kyber_public=kyber_pk, kyber_secret=kyber_sk, sphincs_public=sphincs_pk, sphincs_secret=sphincs_sk, address=address ) self._address_cache[path] = resultat
returnere resultat
def_opret_adresse(selv, sphincs_pk: bytes, kyber_pk: bytes) -> str:
"""Opret menneskelæselig adresse fra offentlige nøgler"""# Derive the address from the Kyber-768 public key
combined = sphincs_pk + kyber_pk address_hash = hashlib.Blake2b(combined, digest_size=25).digest()
# Tilføj versionsbyte (0x00 for mainnet)
versioned = bytes([0x00]) + address_hash
# Kontrolsum (første 4 bytes dobbelthash)
checksum = hashlib.Blake2b( hashlib.Blake2b(versioned).digest(), digest_size=4 ).digest()
# Base58 encode (forenklet, brug korrekt implementering)
fuld = versioneret + kontrolsum
returnere"Sx" + full.hex()[:40]
defget_receiving_address(selv, konto: int = 0, indeks: int = 0) -> str:
"""Få ekstern modtageadresse"""returnere self.derive_address(konto, 0, indeks).adresse
defget_change_address(selv, konto: int = 0, indeks: int = 0) -> str:
"""Få intern ændringsadresse"""returnere self.derive_address(konto, 1, indeks).adresse
# Eksempel: Fuld tegnebogsarbejdsgangdefdemo_wallet():
# Eksempel på mnemonic (brug ALDRIG dette i produktionen)
mnemonisk = "opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive opgive kunst"
tegnebog = SynXHDWallet(mnemonic, passphrase="min-sikre-adgangssætning")
# Udled de første 5 modtageradresser
trykke("Modtager adresser:")
for i in range(5): addr = wallet.derive_address(account=0, change=0, index=i) print(f" {addr.path}: {addr.address}")
# Udled ændringsadresser
trykke("\nSkift adresser:")
for i in range(3): addr = wallet.derive_address(account=0, change=1, index=i) print(f" {addr.path}: {addr.address}")
Watch-Only Wallets
I modsætning til traditionelle HD-punge understøtter post-kvanteskemaer ikke udledning af offentlig nøgle uden master-seedet. Du kan dog oprette ur-beskyttede tegnebøger ved at eksportere offentlige nøgler:
importere json
klasseWatchOnlyWallet:
""" Se-kun tegnebog til overvågning uden forbrugskapacitet """def__init__(selv): self.addresses: dict[str, dict] = {}
defimport_adresse( selv, adresse: str, kyber_public: bytes, sphincs_public: bytes, sti: Valgfri[str] = Ingen ):
"""Importer en offentlig adresse til visning"""
self.addresses[adresse] = {
"kyber_public": kyber_public.hex(),
"sphincs_public": sphincs_public.hex(),
"sti": sti }
defeksport_til_ur(selv, fuld_pung: SynXHDWallet, antal: int = 100):
"""Eksportér adresser fra fuld tegnebog til kun at se"""for i in range(count): addr = full_wallet.derive_address(account=0, change=0, index=i) self.import_address(adr.address, addr.kyber_public, addr.sphincs_public, addr.path )
returnere json.dumps(selv.adresser)
defverify_transaction_signature( selv, adresse: str, besked: bytes, signatur: bytes ) -> bool:
"""Bekræft, at en signatur kom fra en overvåget adresse"""if adresse ikke i selv.adresser:
returnere False sphincs_pk = bytes.fromhex(selv.adresser[adresse]["sphincs_public"])
# Bekræft med den offentlige nøgle SPHINCS+
SPHINCS = oqs.Signatur("SPHINCS+-SHAKE-128s-simpelt")
returnere SPHINCS.verify(meddelelse, signatur, sphincs_pk)
Sikkerhedshensyn
Frøsikkerhedskritisk
Hovedfrøet styrer alle afledte nøgler. Behandl frøbackup med ekstrem forsigtighed - alle med frøet kan udlede alle adresser. De SynX kvantebestandig pung krypterer frø-backups ved hjælp af Kyber-768 for fremadrettet sikkerhed.
Nøgle isolering
Hver adresse skal have uafhængige sikkerhedsegenskaber:
Separate afledningsstier for Kyber vs SPHINCS+ nøgler
Ingen krydsnøglekorrelation (tilføj forskellige kontekstbytes)
Tydelig adskillelse mellem signerings- og krypteringsnøgler
Gab grænser
I modsætning til ECDSA tegnebøger er post-kvante nøglegenerering langsommere. Implementer rimelige gap-grænser for adressescanning:
Tegnebogstype
Anbefalet Gap
Scanningstid (100 adresser)
Standard (ECDSA)
20
< 1 sekund
SynX Post-Quantum
50
2-5 sekunder
Høj-volumen PQ
100
10-15 sekunder
Ofte stillede spørgsmål
Kan jeg bruge BIP-32 med post-kvantekryptografi?
Standard BIP-32 er afhængig af secp256k1 elliptiske kurveoperationer, som er kvantesårbare. Du har brug for en modificeret tilgang: brug BIP-32-stil frøudvidelse med SHAKE-256 eller HKDF, og afled derefter Kyber/SPHINCS+-nøgler fra deterministiske frø. De SynX kvantebestandig pung implementerer dette mønster for kvantesikre HD-tegnebøger, mens de bevarer velkendte afledningsstier.
Hvordan sikkerhedskopierer jeg en post-quantum HD-pung?
Use the same mnemonic seed phrase approach as traditional wallets. The seed entropy (256 bits from 24 words, stretched by PBKDF2 into a 512-bit seed) feeds into quantum-resistant key derivation functions to generate all keys. A 24-word BIP-39 mnemonic provides sufficient entropy for post-quantum security. The SynX kvantebestandig pung bevarer fuld kompatibilitet med standard sikkerhedskopieringsprocedurer.
Hvorfor kan jeg ikke udlede underordnede offentlige nøgler uden frøet?
Postkvantekryptografi understøtter ikke de matematiske relationer, der muliggør BIP-32 offentlig nøgleafledning. Der er ingen ækvivalent til EC-pointtillæg for Kyber eller SPHINCS+. Eksportér de nødvendige offentlige nøgler eksplicit for visningsfunktionalitet.
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.