SynergyX Gebouwd op de algoritmen NIST gestandaardiseerd — FIPS 203 (ML-KEM/Kyber-768) en FIPS 205 (SLH-DSA/SPHINCS+). Gepubliceerd op 15 januari 2026. Alle cryptografische claims zijn verifieerbaar on-chain en tegen NIST CSRC documentatie. Nul voormijn. Nul ICO. Nul VC. Nul toewijzing van oprichters. 77,7 miljoen harde cap. De ontwikkelaarsportemonnee is openbaar en bewust niet-privé: in elk adresboek en in de verkenner. Niets ervan vraagt je om iemand te vertrouwen.
Post-Quantum Key Afleiding: HD Wallet-patronen voor ontwikkelaars
📅 Last updated: September 23, 2026🎧 Luister: ~4 min
Hiërarchisch deterministische (HD) portemonnees brachten een revolutie teweeg in het beheer van cryptocurrency-sleutels door onbeperkte adressen uit één enkel zaadje af te leiden. De afhankelijkheid van BIP-32 van secp256k1-elliptische curve-wiskunde creëert echter kwantumkwetsbaarheid. Deze gids behandelt post-kwantum HD-portemonneepatronen met behulp van op roosters gebaseerde en hash-gebaseerde benaderingen. De SynX kwantumbestendige portemonnee implementeert deze technieken voor naadloos sleutelbeheer.
Traditionele HD Wallet-beperkingen begrijpen
BIP-32 HD-portefeuilles leiden onderliggende sleutels af met behulp van elliptische curve-puntvermenigvuldiging:
Afleiding van de publieke sleutel: Het afleiden van publieke sleutels uit private sleutels maakt gebruik van EC-vermenigvuldiging; het algoritme van Shor doorbreekt dit
Geharde afleiding: Terwijl verharde paden de afleidingsrelatie verbergen, blijft de onderliggende EC-wiskunde kwetsbaar
We hebben geheel nieuwe afleidingsschema's nodig voor post-kwantumveiligheid.
Post-kwantumafleidingsstrategie
De SynX kwantumbestendige portemonnee hanteert een drielaagse aanpak:
Padafleiding: SHAKE-256 of HKDF om deterministische willekeur per pad af te leiden
Sleutelgeneratie: Gebruik afgeleide willekeur als startpunt voor het genereren van Kyber/SPHINCS+-sleutels
Belangrijkste inzicht: De geheugensteunbenadering blijft geldig: we veranderen alleen de manier waarop afgeleide zaden sleutelparen worden. Gebruikers behouden vertrouwde herstelzinnen van 24 woorden terwijl ze kwantumweerstand verwerven.
Implementatie: Seed Expansion
importeren hasjlib
importeren hmac
van typen importeren Lijst, Tupel
klasPostQuantumHDWallet:
""" Post-Quantum hiërarchische deterministische portemonnee Gebruikt SHAKE-256 voor deterministische sleutelafleiding met Kyber-768 en SPHINCS+ voor daadwerkelijke cryptografische sleutels. """zeker__init__(zelf, master_seed: bytes):
""" Initialiseren vanuit master-seed (meestal vanuit BIP-39-ezelsbruggetje) Args: master_seed: 64-byte Seed uit PBKDF2 (ezelsbruggetje, salt = "ezelsbruggetje"+wachtwoordzin) """if len(master_seed) < 32:
salarisverhoging WaardeFout("Seed moet minimaal 256 bits zijn") zelf.master_seed = master_seed
# Leid hoofdketencode af (gebruikt voor padafleiding)
self.master_chain_code = self._derive_chain_code(master_seed, b"SynX-PQ-HD-Master")
zeker_afleiden_keten_code(zelf, zaad: bytes, context: bytes) -> bytes:
"""Leid een ketencode af voor hiërarchische afleiding"""
h = hashlib.shake_256() h.update(seed + context)
opbrengst h.digest(32)
zekerontleen_pad_zaad(zelf, pad: str) -> bytes:
""" Leid deterministische willekeur af voor een specifiek pad Padformaat: "m/44'/9999'/0'/0/0" (BIP-44-stijl) Args: pad: Afleidingspadstring Resultaat: 64 bytes deterministische willekeur voor het genereren van sleutels """
componenten = self._parse_path(path) current_seed = self.master_seed current_chain = self.master_chain_code
voor bestanddeel in componenten: current_seed, current_chain = self._derive_child( current_seed, current_chain, component )
opbrengst huidig_zaad
zeker_parse_pad(zelf, pad: str) -> Lijst[int]:
"""Parse BIP-32-stijl pad in componenten"""zo niet pad.begintmet("m/"):
salarisverhoging WaardeFout("Pad moet beginnen met 'm/'") componenten = []
voor deel in pad[2:].split("/"):
zo niet deel:
doorgaanif deel.eindigtmet("'"):
# Geharde afleiding
index = int(deel[:-1]) + 0x80000000
anders: index = int(deel) componenten.append(index)
opbrengst componenten
zeker_afleiden_kind(self, parent_seed: bytes, parent_chain: bytes, index: int ) -> Tupel[bytes, bytes]:
""" Leid onderliggende zaad- en ketencode af Gebruikt HMAC-SHA512 vergelijkbaar met BIP-32, maar voert feed uit naar SHAKE-256 voor post-kwantumveilige uitbreiding. """# Codeer de index als 4 bytes big-endian
index_bytes = index.to_bytes(4, 'groot')
# HMAC voor gegevens over onderliggende afleiding
data = hmac.new( parent_chain, parent_seed + index_bytes, hashlib.sha512).digest()
# Links 32 bytes → onderliggende zaadcomponent# Rechts 32 bytes → nieuwe ketencode
child_seed_component = gegevens[:32] child_chain = gegevens[32:]
# Combineer ouder en kind voor nieuw zaad# Gebruik SHAKE-256 voor kwantumbestendig mixen
h = hashlib.shake_256() h.update(parent_seed + child_seed_component + index_bytes) child_seed = h.digest(64)
opbrengst kind_zaad, kind_keten
# Voorbeeldgebruikzekerdemo_pad_afleiding():
# Simuleer hoofdzaad van geheugensteuntjeimporteren geheimen master_seed = geheimen.token_bytes(64) portemonnee = PostQuantumHDWallet(master_seed)
# Leid zaden af voor verschillende accounts
paden = [
"m/44'/9999'/0'/0/0", # Account 0, Extern, Adres 0"m/44'/9999'/0'/0/1", # Account 0, Extern, Adres 1"m/44'/9999'/0'/1/0", # Account 0, Intern (wijzigen), Adres 0"m/44'/9999'/1'/0/0", # Account 1, Extern, Adres 0
]
voor pad in paden: path_seed = wallet.derive_path_seed(pad) print(f"{pad}: {path_seed[:16].hex()}...")
Kyber-sleutels genereren uit Path Seeds
Zodra we deterministische willekeur voor een pad hebben, genereren we Kyber-768-sleutelparen:
importeren oké
klasDeterministischeKyber:
""" Genereer deterministische Kyber-768-sleutels uit HD-portemonneepaden. Gebruikt padzaad als willekeurbron voor het genereren van sleutels. """zeker__init__(zelf): zelf.algoritme = "Kyber768"zekergenereer_uit_zaad(zelf, pad_zaad: bytes) -> Tupel[bytes, bytes]:
""" Genereer Kyber-sleutelpaar uit deterministisch zaad Args: path_seed: 64 bytes uit HD-portemonnee-afleiding Resultaat: Tuple van (openbare_sleutel, geheime_sleutel) """# Kyber heeft specifieke hoeveelheden willekeur nodig# Zaad tot gewenste lengte uitbreiden met SHAKE-256
h = hashlib.shake_256() h.update(path_seed + b"Kyber-768-keygen")
# Kyber-768 vereist 64 bytes willekeur voor het genereren van sleutels
willekeur = h.digest(64)
# Opmerking: de meeste PQC-bibliotheken ondersteunen geen geplaatste generatie# Dit vereist ofwel:# 1. Een aangepaste bibliotheek met gezaaide sleutelgeneratie# 2. De RNG tijdelijk vervangen door deterministische bron# 3. Een bibliotheek gebruiken die deterministische generatie ondersteunt# Voor SynX gebruiken we de geplaatste variant:
kem = oqs.KeyEncapsulation(self.algoritme)
# In productie SynX SDK wordt hierbij gebruik gemaakt van gezaaide generatie# Hier laten we ter illustratie de standaard API zien
public_key = kem.generate_keypair() geheime_sleutel = kem.export_secret_key()
opbrengst openbare_sleutel, geheime_sleutel
klasDeterministischeSPHINCS:
""" Genereer deterministische SPHINCS+-sleutels uit HD-portemonneepaden """zeker__init__(zelf, variant: str = "SPHINCS+-SHAKE-128s-eenvoudig"): zelf.algoritme = variant
zekergenereer_uit_zaad(zelf, pad_zaad: bytes) -> Tupel[bytes, bytes]:
""" Genereer SPHINCS+-sleutelpaar uit deterministisch zaad """
h = hashlib.shake_256() h.update(path_seed + b"SPHINCS-Plus-keygen")
# SPHINCS+-128s heeft een specifieke zaadlengte nodig
willekeur = h.digest(48)
# Bij de productie wordt gebruik gemaakt van gezaaide generatie
sig = oqs.Signature(self.algorithm) public_key = sig.generate_keypair() secret_key = sig.export_secret_key()
opbrengst openbare_sleutel, geheime_sleutel
Volledige implementatie van HD Wallet
De SynX kwantumbestendige portemonnee combineert deze componenten:
van dataklassen importeren dataklasse
van typen importeren Optioneel @dataclass
klasSynXAdres:
"""Volledig SynX-adres met beide sleuteltypen"""
pad: str kyber_public: bytes kyber_secret: bytes sphincs_public: bytes sphincs_secret: bytes adres: str # Voor mensen leesbaar adresklasSynXHDWallet:
""" Complete Post-Quantum HD-portemonnee voor SynX-functies: - BIP-39-compatibele geheugensteuntjes - Afleidingspaden in BIP-44-stijl - Kyber-768 voor sleutelinkapseling - SPHINCS+-128s voor handtekeningen """# SynX-munttype (bijvoorbeeld geregistreerd met SLIP-44)
MUNT_TYPE = 9999
zeker__init__(zelf, geheugensteuntje: str, wachtwoordzin: str = ""):
""" Portefeuille initialiseren vanuit BIP-39 geheugensteuntje Args: geheugensteuntje: 24-woorden BIP-39 geheugensteuntje: Optioneel BIP-39 wachtwoordzin """
self.master_seed = self._mnemonic_to_seed(ezelsbruggetje, wachtwoordzin) self.hd = PostQuantumHDWallet(self.master_seed) zelf.Kyber = DeterministischeKyber() zelf.SPHINCS = DeterministischeSPHINCS()
# Cache-afgeleide adressen
self._address_cache: dict[str, SynXAdres] = {}
zeker_ezelsbruggetje_naar_zaad(zelf, geheugensteuntje: str, wachtwoordzin: str) -> bytes:
"""BIP-39-ezelsbruggetje omzetten naar zaad"""importeren hasjlib
# BIP-39 zaadafleiding
wachtwoord = geheugensteuntje.encode('utf-8') zout = ("ezelsbruggetje" + wachtwoordzin).encode('utf-8')
opbrengst hashlib.pbkdf2_hmac(
'sha512', wachtwoord, salt, iteraties=2048, dklen=64 )
zekerafleiden_adres( zelf, account: int = 0, verandering: int = 0, index: int = 0 ) -> SynXAdres:
""" Leid een volledig SynX-adres af Args: account: Accountnummer (gehard) wijzigen: 0 voor extern, 1 voor intern/wijzig index: Adresindex Returns: SynXAddress met alle sleutels en adresreeks """
pad = f"m/44'/{self.COIN_TYPE}'/{account}'/{change}/{index}"# Controleer cacheif pad in zelf._adres_cache:
opbrengst zelf._adres_cache[pad]
# Leid padzaad af
path_seed = self.hd.derive_path_seed(pad)
# Leid subzaden af voor elk sleuteltype# (voorkomt belangrijke correlatie tussen Kyber en SPHINCS+)
kyber_seed = hashlib.shake_256(pad_seed + b"Kyber").digest(64) sfincs_seed = hashlib.shake_256(path_seed + b"SPHINCS").digest(64)
# Genereer sleutels (in productie, maakt gebruik van geplaatste generatie)
kyber_pk, kyber_sk = zelf.Kyber.generate_from_seed(kyber_seed) sfincs_pk, sfincs_sk = zelf.SPHINCS.generate_from_seed(sphincs_seed)
# Creëer een voor mensen leesbaar adres
adres = zelf._create_address(sphincs_pk, kyber_pk) resultaat = SynXAdres( pad=pad, kyber_public=kyber_pk, kyber_secret=kyber_sk, sphincs_public=sphincs_pk, sphincs_secret=sphincs_sk, adres=adres ) self._address_cache[pad] = resultaat
opbrengst resultaat
zeker_create_adres(zelf, sfincs_pk: bytes, kyber_pk: bytes) -> str:
"""Maak een voor mensen leesbaar adres op basis van openbare sleutels"""# Derive the address from the Kyber-768 public key
gecombineerd = sfincs_pk + kyber_pk adres_hash = hashlib.Blake2b(gecombineerd, digest_size=25).digest()
# Versiebyte toevoegen (0x00 voor mainnet)
versiebeheer = bytes([0x00]) + adres_hash
# Checksum (eerste 4 bytes van dubbele hash)
checksum = hashlib.Blake2b( hashlib.Blake2b(versie).digest(), digest_size=4).digest()
# Base58-codering (vereenvoudigd, gebruik de juiste implementatie)
volledig = versiebeheer + controlesom
opbrengst"Sx" + volledig.hex()[:40]
zekerget_ontvangend_adres(zelf, account: int = 0, index: int = 0) -> str:
"""Extern ontvangstadres ophalen"""opbrengst self.derive_address(account, 0, index).adres
zekerget_change_address(zelf, account: int = 0, index: int = 0) -> str:
"""Intern wijzigingsadres ophalen"""opbrengst self.derive_address(account, 1, index).adres
# Voorbeeld: Volledige portemonnee-workflowzekerdemo_portemonnee():
# Voorbeeld geheugensteuntje (gebruik dit NOOIT in de productie)
geheugensteuntje = "verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten verlaten kunst"
portemonnee = SynXHDWallet(ezelsbruggetje, wachtwoordzin="mijn-beveiligde-wachtwoordzin")
# Leid de eerste 5 ontvangstadressen af
afdrukken("Adres ontvangen:")
voor i in bereik(5): addr = portemonnee.derive_address(account=0, wijziging=0, index=i) print(f" {adres.pad}: {adres.adres}")
# Wijzigingsadressen afleiden
afdrukken("\nAdres wijzigen:")
voor i in bereik(3): addr = portemonnee.derive_address(account=0, wijziging=1, index=i) print(f" {adres.pad}: {adres.adres}")
Watch-Only-portemonnees
In tegenstelling tot traditionele HD-portefeuilles ondersteunen post-kwantumschema's geen afleiding van openbare sleutels zonder de masterseed. U kunt echter alleen-watch-portemonnees maken door openbare sleutels te exporteren:
importeren json
klasBekijkOnlyWallet:
""" Watch-only portemonnee voor monitoring zonder bestedingsmogelijkheid """zeker__init__(zelf): zelf.adressen: dict[str, dict] = {}
zekerimport_adres(self, adres: str, kyber_public: bytes, sphincs_public: bytes, pad: Optioneel[str] = Geen ):
"""Importeer een openbaar adres om te kijken"""
zelf.adressen[adres] = {
"kyber_public": kyber_public.hex(),
"sfincs_public": sfincs_public.hex(),
"pad": pad }
zekerexport_voor_horloge(zelf, volledige_portemonnee: SynXHDWallet, telling: int = 100):
"""Exporteer adressen uit volledige portemonnee voor alleen kijken"""voor i in bereik(aantal): addr = full_wallet.derive_address(account=0, change=0, index=i) self.import_address(adr.address, addr.kyber_public, addr.sphincs_public, addr.path )
opbrengst json.dumps(self.adressen)
zekerverifieer_transactie_handtekening( zelf, adres: str, bericht: bytes, handtekening: bytes ) -> bool:
""Verifieer dat een handtekening afkomstig is van een bewaakt adres"""if adres niet binnen zelf.adressen:
opbrengst Valse sphincs_pk = bytes.fromhex(self.addresses[adres]["sfincs_public"])
# Verifieer met de openbare sleutel SPHINCS+
SPHINCS = oqs.Handtekening("SPHINCS+-SHAKE-128s-eenvoudig")
opbrengst SPHINCS.verify(bericht, handtekening, sfincs_pk)
Beveiligingsoverwegingen
Zaadbeveiliging is cruciaal
Het masterzaad bestuurt alle afgeleide sleutels. Ga uiterst voorzichtig om met Seed-back-ups: iedereen met de Seed kan alle adressen afleiden. De SynX kwantumbestendige portemonnee versleutelt zaadback-ups met Kyber-768 voor voorwaartse beveiliging.
Sleutel isolatie
Elk adres moet onafhankelijke beveiligingseigenschappen hebben:
Afzonderlijke afleidingspaden voor Kyber versus SPHINCS+-sleutels
Geen cross-key correlatie (voeg afzonderlijke contextbytes toe)
Duidelijke scheiding tussen ondertekenings- en coderingssleutels
Tussenruimtelimieten
In tegenstelling tot ECDSA-portefeuilles is het genereren van post-kwantumsleutels langzamer. Implementeer redelijke afstandslimieten voor het scannen van adressen:
Portemonneetype
Aanbevolen kloof
Scantijd (100 adres)
Standaard (ECDSA)
20
< 1 seconde
SynX Post-Quantum
50
2-5 seconden
PQ met hoog volume
100
10-15 seconden
Veelgestelde vragen
Kan ik BIP-32 gebruiken met post-kwantumcryptografie?
Standaard BIP-32 vertrouwt op secp256k1 elliptische curve-operaties die kwantumkwetsbaar zijn. Je hebt een aangepaste aanpak nodig: gebruik zaaduitbreiding in BIP-32-stijl met SHAKE-256 of HKDF, en leid vervolgens Kyber/SPHINCS+-sleutels af van deterministische zaden. De SynX kwantumbestendige portemonnee implementeert dit patroon voor kwantumveilige HD-portefeuilles met behoud van bekende afleidingspaden.
Hoe maak ik een back-up van een post-quantum HD-portemonnee?
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 kwantumbestendige portemonnee behoudt volledige compatibiliteit met standaard back-upprocedures.
Waarom kan ik geen onderliggende openbare sleutels afleiden zonder het zaad?
Post-kwantumcryptografie biedt geen ondersteuning voor de wiskundige relaties die het afleiden van openbare BIP-32-sleutels mogelijk maken. Er bestaat geen equivalent voor het optellen van EC-punten voor Kyber of SPHINCS+. Voor alleen-kijken-functionaliteit exporteert u de benodigde openbare sleutels expliciet.
One of five live blockchains that sign with post-quantum signatures by default (QRL, Mochimo, Abelian, Cellframe, SynX) — the full list
NIST-normen
FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) - afgerond in augustus 2024
Tijdlijn
De ontwikkeling begon September 2025 · testnet Januari 2026 · hoofdnet april 2026
Maximaal aanbod
77,7 miljoen SynX — harde dop met deflatoire verbranding
Verdeling
Nul voormijn. Nul ICO. Nul VC. Nul toewijzing van oprichters. Ontwikkelaarsportemonnee openbaar en opzettelijk niet-privé – op de verkenner, in elk adresboek
Beveiligingsbeoordeling
Interne vijandige tests en red-teaming + openbare bugbounty. Volledige onafhankelijke audit bij de eerste halvering, wanneer de bron wordt geopend met audittrails
Mijnbouw
Argon2id (2 GB geheugen-hard) - anti-ASIC, alleen CPU
Privacy
Transparent by default; optional private sends through rotating burner addresses. No KYC, P2P exchange in the wallet
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.