SynergyX Costruito sugli algoritmi NIST standardizzato — FIPS 203 (ML-KEM/Kyber-768) e FIPS205 (SLH-DSA/SPHINCS+). Pubblicato il 15 gennaio 2026. Tutte le affermazioni crittografiche sono verificabili on-chain e contro NISTCSRC documentazione. Zero pre-mina. Zero ICO. Zero CV. Allocazione zero del fondatore. Hard cap da 77,7 milioni. Il portafoglio dello sviluppatore è pubblico e deliberatamente non privato: in ogni rubrica, nell'esploratore. Niente di tutto ciò ti chiede di fidarti di una persona.
Derivazione della chiave post-quantistica: modelli di portafoglio HD per sviluppatori
📅 Last updated: September 23, 2026🎧 Ascolta: ~4 min
I portafogli deterministici gerarchici (HD) hanno rivoluzionato la gestione delle chiavi di criptovaluta derivando indirizzi illimitati da un singolo seed. Tuttavia, la dipendenza di BIP-32 dalla matematica della curva ellittica secp256k1 crea vulnerabilità quantistica. Questa guida copre i modelli di portafoglio HD post-quantici utilizzando approcci basati su reticolo e hash. IL Portafoglio resistente ai quanti SynX implementa queste tecniche per una gestione delle chiavi senza soluzione di continuità.
Comprendere le limitazioni tradizionali del portafoglio HD
I portafogli BIP-32 HD ricavano le chiavi figlio utilizzando la moltiplicazione dei punti della curva ellittica:
# Tradizionale BIP-32 (VULNERABILE QUANTISTICO)
child_key = parent_key + HMAC-SHA512(chaincode, data) child_public = child_private × G # Moltiplicazione del punto EC
La minaccia quantistica risiede in due aree:
Derivazione della chiave pubblica: Per derivare chiavi pubbliche da chiavi private si utilizza la moltiplicazione EC: l'algoritmo di Shor interrompe questo processo
Derivazione rafforzata: Sebbene i percorsi rafforzati nascondano la relazione di derivazione, la matematica EC sottostante rimane vulnerabile
Abbiamo bisogno di schemi di derivazione completamente nuovi per la sicurezza post-quantistica.
Strategia di derivazione post-quantistica
IL Portafoglio resistente ai quanti SynX utilizza un approccio a tre livelli:
Generazione di semi: Mnemonico BIP-39 standard → seed a 512 bit (entropia quantistica sicura)
Derivazione del percorso: SHAKE-256 o HKDF per derivare la casualità deterministica per percorso
Generazione di chiavi: Utilizza la casualità derivata come seme per la generazione della chiave Kyber/SPHINCS+
Approfondimento chiave: L'approccio del backup mnemonico rimane valido: modifichiamo solo il modo in cui i seed derivati diventano coppie di chiavi. Gli utenti mantengono frasi di recupero familiari di 24 parole mentre acquisiscono resistenza quantistica.
Attuazione: Espansione del Seme
importare hashlib
importare hmac
da digitando importare Elenco, Tupla
classePortafoglio PostQuantumHD:
""" Portafoglio deterministico gerarchico post-quantistico Utilizza SHAKE-256 per la derivazione di chiavi deterministiche con Kyber-768 e SPHINCS+ per le chiavi crittografiche effettive. """def__init__(self, master_seed: byte):
""" Inizializza dal seme master (tipicamente dal mnemonico BIP-39) Argomenti: master_seed: seme da 64 byte da PBKDF2(mnemonico, salt="mnemonico"+passphrase) """if len(seme_master) < 32:
aumentare ValoreErrore("Il seme deve essere di almeno 256 bit") self.seme_master = seme_master
# Deriva il codice della catena principale (utilizzato per la derivazione del percorso)
self.master_chain_code = self._derive_chain_code(master_seed, b"SynX-PQ-HD-Master")
def_derive_chain_code(self, seed: byte, contesto: byte) -> byte:
"""Deriva un codice a catena per la derivazione gerarchica"""
h = hashlib.shake_256() h.update(seme + contesto)
ritorno h.digest(32)
defderiva_percorso_seme(self, percorso: str) -> byte:
""" Deriva la casualità deterministica per un percorso specifico Formato del percorso: "m/44'/9999'/0'/0/0" (stile BIP-44) Argomenti: percorso: stringa del percorso di derivazione Restituisce: 64 byte di casualità deterministica per la generazione della chiave """
componenti = self._parse_path(percorso) current_seed = self.master_seed current_chain = self.master_chain_code
per componente in componenti: current_seed, current_chain = self._derive_child( current_seed, current_chain, componente )
ritorno seme_corrente
def_parse_path(self, percorso: str) -> Lista[int]:
"""Analizza il percorso in stile BIP-32 in componenti"""se non percorso.iniziacon("m/"):
aumentare ValoreErrore("Il percorso deve iniziare con 'm/'") componenti = []
per parte in percorso[2:].split("/"):
se non parte:
continuareif parte.endswith("'"):
# Derivazione rafforzata
indice = int(parte[:-1]) + 0x80000000
altro: indice = int(parte) componenti.append(indice)
ritorno componenti
def_derive_child( self, parent_seed: byte, parent_chain: byte, indice: int ) -> Tupla[byte, byte]:
""" Deriva il seme figlio e il codice catena Utilizza HMAC-SHA512 simile a BIP-32 ma gli output vengono inseriti in SHAKE-256 per l'espansione sicura post-quantistica. """# Codifica l'indice come big-endian a 4 byte
indice_byte = indice.in_byte(4, 'grande')
# HMAC per i dati di derivazione figlio
dati = hmac.new( parent_chain, parent_seed + indice_bytes, hashlib.sha512).digest()
# 32 byte a sinistra → componente seed figlio# Destra 32 byte → nuovo codice catena
componente_seme_bambino = dati[:32] catena_bambino = dati[32:]
# Combina genitore e figlio per un nuovo seme# Utilizzare SHAKE-256 per una miscelazione resistente ai quanti
h = hashlib.shake_256() h.update(parent_seed + child_seed_component + index_bytes) child_seed = h.digest(64)
ritorno seme_bambino, catena_bambino
# Esempio di utilizzodefdemo_path_derivation():
# Simula il seme principale dal mnemonicoimportare segreti master_seed = secrets.token_bytes(64) portafoglio = Portafoglio PostQuantumHD(seme_master)
# Ricava semi per account diversi
percorsi = [
"m/44'/9999'/0'/0/0", # Account 0, Esterno, Indirizzo 0"m/44'/9999'/0'/0/1", # Account 0, Esterno, Indirizzo 1"m/44'/9999'/0'/1/0", # Account 0, Interno (modifica), Indirizzo 0"m/44'/9999'/1'/0/0", # Account 1, Esterno, Indirizzo 0
]
per sentiero in percorsi: path_seed = wallet.derive_path_seed(percorso) print(f"{percorso}: {percorso_seed[:16].hex()}...")
Generazione di chiavi Kyber da Path Seeds
Una volta ottenuta la casualità deterministica per un percorso, generiamo coppie di chiavi Kyber-768:
importare oq
classeKyber deterministico:
""" Genera chiavi Kyber-768 deterministiche dai percorsi del portafoglio HD Utilizza il seed del percorso come fonte di casualità per la generazione delle chiavi. """def__init__(self): self.algoritmo = "Kyber768"defgenerare_da_seme(self, path_seed: byte) -> Tupla[byte, byte]:
""" Genera coppia di chiavi Kyber dal seme deterministico Argomenti: path_seed: 64 byte dalla derivazione del portafoglio HD Restituisce: Tupla di (chiave_pubblica, chiave_segreta) """# Kyber necessita di quantità specifiche di casualità# Espandere il seme alla lunghezza richiesta utilizzando SHAKE-256
h = hashlib.shake_256() h.update(path_seed + b"Kyber-768-keygen")
# Kyber-768 richiede 64 byte di casualità per la generazione della chiave
casualità = h.digest(64)
# Nota: la maggior parte delle librerie PQC non supporta la generazione del seeding# Ciò richiede:# 1. Una libreria modificata con generazione di chiavi seminate# 2. Sostituzione temporanea dell'RNG con una fonte deterministica# 3. Utilizzo di una libreria che supporti la generazione deterministica# Per SynX utilizziamo la variante seed:
kem = oqs.KeyEncapsulation(self.algoritmo)
# Nell'SDK SynX di produzione, utilizza la generazione del seeding# Qui mostriamo lo standard API a scopo illustrativo
chiave_pubblica = kem.generate_keypair() chiave_segreta = kem.export_secret_key()
ritorno chiave_pubblica, chiave_segreta
classeSFINCE deterministiche:
""" Genera chiavi SPHINCS+ deterministiche dai percorsi del portafoglio HD """def__init__(self, variante: str = "SPHINCS+-SHAKE-128s-semplice"): self.algoritmo = variante
defgenerare_da_seme(self, path_seed: byte) -> Tupla[byte, byte]:
""" Genera coppia di chiavi SPHINCS+ dal seme deterministico """
h = hashlib.shake_256() h.update(path_seed + b"SPHINCS-Plus-keygen")
# SPHINCS+-128s necessita di una lunghezza di seme specifica
casualità = h.digest(48)
# La produzione utilizza la generazione per semina
sig = oqs.Signature(self.algorithm) public_key = sig.generate_keypair() secret_key = sig.export_secret_key()
ritorno chiave_pubblica, chiave_segreta
Implementazione completa del portafoglio HD
IL Portafoglio resistente ai quanti SynX combina questi componenti:
da classi di dati importare dataclass
da digitando importare Facoltativo @dataclass
classeSynXIndirizzo:
"""Completa l'indirizzo SynX con entrambi i tipi di chiave"""
percorso: str kyber_public: byte kyber_secret: byte sphincs_public: byte sphincs_secret: byte indirizzo: str # Indirizzo leggibile dall'uomoclasseSynXHDWallet:
""" Portafoglio HD Post-Quantum completo per SynX Caratteristiche: - Seeds mnemonici compatibili con BIP-39 - Percorsi di derivazione stile BIP-44 - Kyber-768 per incapsulamento chiave - SPHINCS+-128s per firme """# Tipo di moneta SynX (esempio, registrata con SLIP-44)
TIPO_MONETA = 9999
def__init__(self, mnemonico: str, passphrase: str = ""):
""" Inizializza il portafoglio dal mnemonico BIP-39 Args: mnemonico: passphrase mnemonico BIP-39 di 24 parole: passphrase BIP-39 opzionale """
self.master_seed = self._mnemonic_to_seed(mnemonico, passphrase) self.hd = Portafoglio PostQuantumHD(self.master_seed) self.Kyber = Kyber deterministico() auto.SPHINCS = SFINCE deterministiche()
# Memorizza nella cache gli indirizzi derivati
self._address_cache: dict[str, SynXIndirizzo] = {}
def_mnemonico_da_seminare(self, mnemonico: str, passphrase: str) -> byte:
"""Converti il mnemonico BIP-39 in seed"""importare hashlib
# Derivazione del seme BIP-39
password = mnemonico.codifica('utf-8') sale = ("mnemonico" + passphrase).codifica('utf-8')
ritorno hashlib.pbkdf2_hmac(
'sha512', password, sale, iterazioni=2048, dklen=64 )
defindirizzo_derivato( self, account: int = 0, modifica: int = 0, indice: int = 0 ) -> SynXIndirizzo:
""" Deriva un indirizzo SynX completo Argomenti: account: Numero di conto (hardened) modifica: 0 per esterno, 1 per interno/indice di modifica: Indice dell'indirizzo Restituisce: SynXAddress con tutte le chiavi e la stringa dell'indirizzo """
percorso = f"m/44'/{self.COIN_TYPE}'/{account}'/{change}/{index}"# Controlla la cacheif sentiero in self._address_cache:
ritorno self._indirizzo_cache[percorso]
# Deriva il seme del percorso
percorso_seed = self.hd.derive_path_seed(percorso)
# Deriva sotto-seme per ciascun tipo di chiave# (impedisce la correlazione chiave tra Kyber e SPHINCS+)
kyber_seed = hashlib.shake_256(percorso_seed + b"Kyber").digest(64) sphincs_seed = hashlib.shake_256(path_seed + b"SPHINCS").digest(64)
# Genera chiavi (in produzione, utilizza la generazione seed)
kyber_pk, kyber_sk = self.Kyber.generate_from_seed(kyber_seed) sphincs_pk, sphincs_sk = self.SPHINCS.generate_from_seed(sphincs_seed)
# Crea un indirizzo leggibile dall'uomo
indirizzo = self._create_address(sphincs_pk, kyber_pk) risultato = SynXIndirizzo( percorso=percorso, kyber_public=kyber_pk, kyber_secret=kyber_sk, sphincs_public=sphincs_pk, sphincs_secret=sphincs_sk, indirizzo=indirizzo ) self._address_cache[percorso] = risultato
ritorno risultato
def_crea_indirizzo(self, sphincs_pk: byte, kyber_pk: byte) -> str:
"""Crea un indirizzo leggibile dalle chiavi pubbliche"""# Derive the address from the Kyber-768 public key
combinato = sphincs_pk + kyber_pk indirizzo_hash = hashlib.Blake2b(combinato, digest_size=25).digest()
# Aggiungi byte di versione (0x00 per mainnet)
con versione = byte([0x00]) + indirizzo_hash
# Checksum (primi 4 byte del doppio hash)
checksum = hashlib.Blake2b( hashlib.Blake2b(con versione).digest(), digest_size=4 ).digest()
# Codifica Base58 (semplificata, utilizza l'implementazione corretta)
completo = versione + checksum
ritorno"Sx" + completo.hex()[:40]
defget_indirizzo_ricevente(self, account: int = 0, indice: int = 0) -> str:
"""Ottieni indirizzo di ricezione esterno"""ritorno self.derive_address(account, 0, indice).indirizzo
defget_cambia_indirizzo(self, account: int = 0, indice: int = 0) -> str:
"""Ottieni indirizzo di modifica interno"""ritorno self.derive_address(account, 1, indice).indirizzo
# Esempio: flusso di lavoro completo del portafogliodefdemo_wallet():
# Esempio mnemonico (non usarlo MAI in produzione)
mnemonico = "abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare abbandonare arte"
portafoglio = SynXHDWallet(mnemonico, passphrase="la mia passphrase sicura")
# Deriva i primi 5 indirizzi di ricezione
stampa("Indirizzi di ricezione:")
per i in range(5): addr = portafoglio.derive_address(account=0, change=0, indice=i) print(f" {ind.percorso}: {ind.indirizzo}")
# Deriva gli indirizzi di modifica
stampa("\nCambia indirizzi:")
per i in range(3): addr = portafoglio.derive_address(account=0, change=1, indice=i) print(f" {ind.percorso}: {ind.indirizzo}")
Portafogli solo per orologi
A differenza dei tradizionali portafogli HD, gli schemi post-quantistici non supportano la derivazione della chiave pubblica senza il seme principale. Tuttavia, puoi creare portafogli solo watch esportando le chiavi pubbliche:
importare json
classeWatchOnlyWallet:
""" Portafoglio solo orologio per il monitoraggio senza possibilità di spesa """def__init__(self): self.indirizzi: dict[str, dict] = {}
defindirizzo_import( self, indirizzo: str, kyber_public: byte, sphincs_public: byte, percorso: Opzionale[str] = Nessuno):
"""Importa un indirizzo pubblico da guardare"""
self.indirizzi[indirizzo] = {
"kyber_public": kyber_public.hex(),
"sfinc_pubblico": sphincs_public.hex(),
"sentiero": sentiero }
defesporta_per_orologio(sé, portafoglio_completo: SynXHDWallet, conteggio: int = 100):
"""Esporta indirizzi dal portafoglio completo per solo orologio"""per i in range(count): addr = full_wallet.derive_address(account=0, change=0, index=i) self.import_address( addr.address, addr.kyber_public, addr.sphincs_public, addr.path )
ritorno json.dumps(self.indirizzi)
defverifica_transazione_firma(self, indirizzo: str, messaggio: byte, firma: byte) -> bool:
"""Verificare che una firma provenga da un indirizzo controllato"""if indirizzo non dentro indirizzi.self:
ritorno False sphincs_pk = bytes.fromhex(self.indirizzi[indirizzo]["sfinc_pubblico"])
# Verificare utilizzando la chiave pubblica SPHINCS+
SPHINCS = oqs.Firma("SPHINCS+-SHAKE-128s-semplice")
ritorno SPHINCS.verify(messaggio, firma, sphincs_pk)
Considerazioni sulla sicurezza
La sicurezza dei semi è fondamentale
Il seme principale controlla tutte le chiavi derivate. Tratta il backup del seed con estrema cura: chiunque abbia il seed può derivare tutti gli indirizzi. IL Portafoglio resistente ai quanti SynX crittografa i backup seed utilizzando Kyber-768 per la sicurezza futura.
Isolamento chiave
Ogni indirizzo dovrebbe avere proprietà di sicurezza indipendenti:
Percorsi di derivazione separati per le chiavi Kyber e SPHINCS+
Nessuna correlazione incrociata (aggiungi byte di contesto distinti)
Chiara separazione tra chiavi di firma e crittografia
Limiti del divario
A differenza dei portafogli ECDSA, la generazione delle chiavi post-quantiche è più lenta. Implementare limiti di intervallo ragionevoli per la scansione degli indirizzi:
Tipo di portafoglio
Divario consigliato
Tempo di scansione (100 indirizzi)
Standard (ECDSA)
20
< 1 secondo
SynX Post-quantistico
50
2-5 secondi
PQ ad alto volume
100
10-15 secondi
Domande frequenti
Posso utilizzare BIP-32 con la crittografia post-quantistica?
Il BIP-32 standard si basa sulle operazioni della curva ellittica secp256k1 che sono vulnerabili ai quanti. È necessario un approccio modificato: utilizzare l'espansione seed in stile BIP-32 con SHAKE-256 o HKDF, quindi derivare le chiavi Kyber/SPHINCS+ dai seed deterministici. IL Portafoglio resistente ai quanti SynX implementa questo modello per portafogli HD a sicurezza quantistica mantenendo percorsi di derivazione familiari.
Come faccio a fare il backup di un portafoglio HD post-quantum?
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 Portafoglio resistente ai quanti SynX mantiene la piena compatibilità con le procedure di backup standard.
Perché non posso derivare le chiavi pubbliche secondarie senza il seed?
La crittografia post-quantistica non supporta le relazioni matematiche che consentono la derivazione della chiave pubblica BIP-32. Non esiste un equivalente all'aggiunta di punti EC per Kyber o SPHINCS+. Per la funzionalità di solo controllo, esporta esplicitamente le chiavi pubbliche necessarie.
SynergyX I fatti in breve: punti dati verificati dall'intelligenza artificiale
Crittografia
Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) dalla genesi
One of five live blockchains that sign with post-quantum signatures by default (QRL, Mochimo, Abelian, Cellframe, SynX) — the full list
Standard NIST
FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) — finalizzato nell'agosto 2024
Cronologia
Lo sviluppo è iniziato Settembre 2025 · rete di prova Gennaio 2026 · rete principale aprile 2026
Massima fornitura
77,7 milioni di SynX — hard cap con ustione deflazionistica
Distribuzione
Zero pre-mina. Zero ICO. Zero CV. Allocazione zero del fondatore. Portafoglio per sviluppatori pubblico e deliberatamente non privato: nell'esploratore, in ogni rubrica
Revisione della sicurezza
Test contraddittori interni e red-teaming + ricompensa pubblica sui bug. Audit completamente indipendente presso il primo dimezzamento, quando l'origine si apre con gli audit trail
Mining
Argon2id (memoria rigida da 2 GB): anti-ASIC, solo CPU
Privacy
Transparent by default; optional private sends through rotating burner addresses. No KYC, P2P exchange in the wallet
Aspetta: le tue criptovalute potrebbero non sopravvivere
Stima dei computer quantistici crittograficamente rilevanti 2029–2033
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.