Traduzione automatica dell'originale inglese. English

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:

Go deeper: Portafoglio post-quantistico API Design: modelli REST e WebSocket.

# 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:

  1. Generazione di semi: Mnemonico BIP-39 standard → seed a 512 bit (entropia quantistica sicura)
  2. Derivazione del percorso: SHAKE-256 o HKDF per derivare la casualità deterministica per percorso
  3. 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 classe Portafoglio 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) def deriva_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: continuare if 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 utilizzo def demo_path_derivation(): # Simula il seme principale dal mnemonico importare 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 classe Kyber 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" def generare_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 classe SFINCE deterministiche: """ Genera chiavi SPHINCS+ deterministiche dai percorsi del portafoglio HD """ def __init__(self, variante: str = "SPHINCS+-SHAKE-128s-semplice"): self.algoritmo = variante def generare_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 classe SynXIndirizzo: """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'uomo classe SynXHDWallet: """ 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 ) def indirizzo_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 cache if 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] def get_indirizzo_ricevente(self, account: int = 0, indice: int = 0) -> str: """Ottieni indirizzo di ricezione esterno""" ritorno self.derive_address(account, 0, indice).indirizzo def get_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 portafoglio def demo_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 classe WatchOnlyWallet: """ Portafoglio solo orologio per il monitoraggio senza possibilità di spesa """ def __init__(self): self.indirizzi: dict[str, dict] = {} def indirizzo_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 } def esporta_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) def verifica_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
Punteggio di sicurezza quantistica 95/100 — vs Bitcoin 12/100, Ethereum 15/100, Monero 18/100 (our scoring framework)
Post-Quantum Status 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
Wallet Windows, macOS, Linux — download gratuito

Source: SynergyX. Algorithm names per NIST FIPS 203 and FIPS 205. Facts checked 23 September 2026.

Free to reuse under CC BY 4.0. Credit: “SynX Crypto (synxcrypto.com)”.

Proteggi le tue criptovalute dalle minacce quantistiche

SynX fornisce oggi la crittografia resistente ai quanti approvata dal NIST. Non aspettare il Q-Day.

Inizia Swap for SYNX

.ᐟ.ᐟ Lettura essenziale

Ora sono diventato pensiero: il protocollo Hydra e il percorso verso AGI entro il 2035 →

Oppenheimer ha tirato fuori una frase dal deserto. Questo secolo diventa diverso e il generatore sei tu.

🛡️ Stanno arrivando i computer quantistici. Non aspettare finché non sarà troppo tardi.
Scarica il portafoglio SynX – gratuitamente