Wyprowadzanie klucza postkwantowego: wzorce portfeli HD dla programistów
📅 Ostatnia aktualizacja: 2 sierpnia 2026 r
🎧 Słuchaj: ~4 min
Hierarchiczne portfele deterministyczne (HD) zrewolucjonizowały zarządzanie kluczami kryptowalut, uzyskując nieograniczoną liczbę adresów z jednego źródła. Jednak poleganie BIP-32 na matematyce krzywej eliptycznej secp256k1 stwarza podatność kwantową. W tym przewodniku omówiono wzorce portfeli postkwantowych HD przy użyciu podejścia opartego na sieciach i skrótach. The Portfel odporny na działanie kwantów SynX wdraża te techniki w celu bezproblemowego zarządzania kluczami.
Zrozumienie ograniczeń tradycyjnego portfela HD
Portfele BIP-32 HD wyprowadzają klucze podrzędne za pomocą mnożenia punktów krzywej eliptycznej:
# Tradycyjny BIP-32 (LURKA KWANTOWA)
klucz_dziecka = klucz_rodzica + HMAC-SHA512(kod łańcuchowy, dane) publiczny_dziecko = prywatny_dziecko × G # Mnożenie punktów EC
Zagrożenie kwantowe występuje w dwóch obszarach:
- Wyprowadzenie klucza publicznego: Wyprowadzanie kluczy publicznych z kluczy prywatnych wykorzystuje mnożenie EC — algorytm Shor to łamie
- Utwardzone wyprowadzenie: Chociaż zaostrzone ścieżki ukrywają relację wyprowadzenia, podstawowa matematyka EC pozostaje podatna na zagrożenia
Potrzebujemy zupełnie nowych schematów wyprowadzania dla bezpieczeństwa postkwantowego.
Strategia wyprowadzania postkwantowego
The Portfel odporny na działanie kwantów SynX wykorzystuje podejście trójwarstwowe:
- Generacja nasion: Standardowy mnemonik BIP-39 → 512-bitowe ziarno (entropia bezpieczna kwantowo)
- Wyprowadzenie ścieżki: SHAKE-256 lub HKDF w celu uzyskania deterministycznej losowości na ścieżkę
- Generacja klucza: Użyj pochodnej losowości jako materiału siewnego do generowania klucza Kyber/SPHINCS+
Kluczowe spostrzeżenia: Mnemoniczne podejście do tworzenia kopii zapasowych pozostaje aktualne — zmieniamy jedynie sposób, w jaki pochodne nasiona stają się parami kluczy. Użytkownicy zachowują znane 24-wyrazowe frazy odzyskiwania, jednocześnie zyskując odporność kwantową.
Wdrożenie: Ekspansja zalążkowa
import hashlib
import hmac
z pisanie na maszynie import Lista, Tuple
klasa Portfel PostQuantum HD:
„”” Post-kwantowy hierarchiczny portfel deterministyczny Używa SHAKE-256 do deterministycznego wyprowadzania kluczy za pomocą Kyber-768 i SPHINCS+ dla rzeczywistych kluczy kryptograficznych. „””
def __inicj__(self, master_seed: bajty):
""" Inicjuj z głównego materiału siewnego (zwykle z mnemonika BIP-39) Args: master_seed: 64-bajtowy materiał siewny z PBKDF2(mnemoniczny, sól="mnemonic"+hasło) """
if len(master_seed) < 32:
wznosić Błąd wartości(„Ziarno musi mieć co najmniej 256 bitów”) self.master_seed = master_seed
# Wyprowadź główny kod łańcucha (używany do wyznaczania ścieżki)
self.master_chain_code = self._derive_chain_code(master_seed, ur„SynX-PQ-HD-Master”)
def _kod_łańcucha_pochodnego(self, ziarno: bajty, kontekst: bajty) -> bajty:
"""Wyprowadź kod łańcucha dla wyprowadzenia hierarchicznego"""
h = hashlib.shake_256() h.update(ziarno + kontekst)
powrót h.digest(32)
def pochodna_ścieżka_nasienia(self, ścieżka: str) -> bajty:
""" Wyprowadzenie deterministycznej losowości dla określonej ścieżki Format ścieżki: "m/44'/9999'/0'/0/0" (styl BIP-44) Args: ścieżka: Wyprowadzenie ciągu ścieżki Zwroty: 64 bajty deterministycznej losowości do wygenerowania klucza """
komponenty = self._parse_path(ścieżka) current_seed = self.master_seed current_chain = self.master_chain_code
Do część in komponenty: current_seed, current_chain = self._derive_child( current_seed, current_chain, komponent )
powrót bieżące_nasienie
def _parse_path(self, ścieżka: str) -> Lista[int]:
"""Przeanalizuj ścieżkę stylu BIP-32 na komponenty"""
w przeciwnym razie ścieżka.zaczyna się od("m/"):
wznosić Błąd wartości(„Ścieżka musi zaczynać się od „m/””) komponenty = []
Do część in ścieżka[2:].split("/"):
w przeciwnym razie część:
Kontynuować
if część.kończy się("'"):
# Utwardzone wyprowadzenie
indeks = int(część[:-1]) + 0x80000000
inne: indeks = int(część) komponenty.append(indeks)
powrót komponenty
def _pochodne_dziecko( self, parent_seed: bajty, parent_chain: bajty, indeks: int ) -> Krotka[bajty, bajty]:
„”” Wyprowadzenie kodu początkowego i łańcucha potomnego Używa HMAC-SHA512 podobnego do BIP-32, ale dane wyjściowe są przesyłane do SHAKE-256 w celu bezpiecznej ekspansji post-kwantowej. „””
# Zakoduj indeks jako 4-bajtowy big-endian
indeks_bajtów = indeks.do_bajtów(4, 'duży')
# HMAC dla danych wyprowadzających dzieci
dane = hmac.new(łańcuch_nadrzędny, ziarno_nadrzędne + bajty_indeksu, hashlib.sha512 ).digest()
# Pozostało 32 bajty → komponent potomny
# Prawo 32 bajty → nowy kod łańcucha
komponent_nasiona_dziecka = dane[:32] łańcuch_dziecka = dane[32:]
# Połącz rodzica i dziecko, aby uzyskać nowe nasiona
# Do mieszania odpornego na działanie kwantów należy używać SHAKE-256
h = hashlib.shake_256() h.update(parent_seed + child_seed_component + indeks_bajtów) child_seed = h.digest(64)
powrót dziecko_nasienie, łańcuch_dziecka
# Przykładowe użycie
def wyprowadzenie_ścieżki_demo():
# Symuluj główne ziarno z mnemonika
import sekrety master_seed = secrets.token_bytes(64) portfel = Portfel PostQuantum HD(master_seed)
# Uzyskaj nasiona dla różnych kont
ścieżki = [
"m/44'/9999'/0'/0/0", # Konto 0, Zewnętrzne, Adres 0
"m/44'/9999'/0'/0/1", # Konto 0, Zewnętrzne, Adres 1
"m/44'/9999'/0'/1/0", # Konto 0, Wewnętrzne (zmiana), Adres 0
"m/44'/9999'/1'/0/0", # Konto 1, zewnętrzne, adres 0
]
Do ścieżka in ścieżki: path_seed = portfel.derive_path_seed(ścieżka) print(f„{ścieżka}: {ścieżka_nasienia[:16].hex()}…”)
Generowanie kluczy Kyber z nasion ścieżki
Kiedy już mamy deterministyczną losowość ścieżki, generujemy pary kluczy Kyber-768:
import OK
klasa DeterministycznyKyber:
""" Generuj deterministyczne klucze Kyber-768 ze ścieżek portfela HD. Wykorzystuje zarodek ścieżki jako źródło losowości do generowania klucza. """
def __inicj__(self): self.algorithm = „Kyber768”
def wygeneruj_z_nasiona(self, path_seed: bajty) -> Krotka[bajty, bajty]:
""" Wygeneruj parę kluczy Kyber z deterministycznego materiału siewnego Args: path_seed: 64 bajty z wyprowadzenia portfela HD Zwroty: Krotka (klucz_publiczny, klucz_tajny) """
# Kyber wymaga określonej ilości losowości
# Rozwiń nasiona do wymaganej długości za pomocą SHAKE-256
h = hashlib.shake_256() h.update(nasienie_ścieżki + b„Generator kluczy Kyber-768”)
# Kyber-768 wymaga 64 bajtów losowości do wygenerowania klucza
losowość = h.digest(64)
# Uwaga: Większość bibliotek PQC nie obsługuje generowania początkowego
# Wymaga to:
# 1. Zmodyfikowana biblioteka z generowaniem klucza początkowego
# 2. Tymczasowe zastąpienie RNG źródłem deterministycznym
# 3. Korzystanie z biblioteki obsługującej generację deterministyczną
# W przypadku SynX używamy wariantu rozstawionego:
kem = oqs.KeyEncapsulation(self.algorithm)
# W produkcyjnym zestawie SDK SynX wykorzystuje to generację zaszczepioną
# Tutaj pokazujemy standardowy API dla ilustracji
public_key = kem.generate_keypair() secret_key = kem.export_secret_key()
powrót klucz_publiczny, klucz_tajny
klasa DeterministyczneSPHINCS:
""" Generuj deterministyczne klucze SPHINCS+ ze ścieżek portfela HD """
def __inicj__(self, wariant: str = „SPHINCS+-SHAKE-128s-prosty”): self.algorithm = wariant
def wygeneruj_z_nasiona(self, path_seed: bajty) -> Krotka[bajty, bajty]:
""" Wygeneruj parę kluczy SPHINCS+ z deterministycznego materiału siewnego """
h = hashlib.shake_256() h.update(nasienie_ścieżki + b„Generator kluczy SPHINCS-Plus”)
# SPHINCS+-128s wymaga określonej długości nasion
losowość = h.digest(48)
# Produkcja wykorzystuje generację nasion
sig = oqs.Signature(self.algorithm) public_key = sig.generate_keypair() secret_key = sig.export_secret_key()
powrót klucz_publiczny, klucz_tajny
Kompletna implementacja portfela HD
The Portfel odporny na działanie kwantów SynX łączy te elementy:
z klasy danych import klasa danych
z pisanie na maszynie import Opcjonalnie @dataclass
klasa SynXAdres:
"""Kompletny adres SynX z obydwoma typami kluczy"""
ścieżka: str kyber_public: bajty kyber_secret: bajty sphincs_public: bajty sphincs_secret: bajty adres: str # Adres czytelny dla człowieka
klasa Portfel SynXHD:
Kompletny portfel Post-Quantum HD dla SynX Funkcje: - Nasiona mnemoniczne kompatybilne z BIP-39 - Ścieżki wyprowadzania w stylu BIP-44 - Kyber-768 do enkapsulacji kluczy - SPHINCS+-128 do podpisów """
# Typ monety SynX (przykład, zarejestrowany w SLIP-44)
TYP MONETY = 9999
def __inicj__(self, mnemonik: str, hasło: str = ""):
""" Zainicjuj portfel z mnemonika BIP-39 Argumenty: mnemonik: 24-wyrazowe hasło mnemoniczne BIP-39: Opcjonalne hasło BIP-39 """
self.master_seed = self._mnemonic_to_seed(mnemonik, hasło) self.hd = Portfel PostQuantum HD(self.master_seed) self.Kyber = DeterministycznyKyber() własny.SPHINCS = DeterministyczneSPHINCS()
# Adresy pochodzące z pamięci podręcznej
self._address_cache: dict[str, SynXAdres] = {}
def _mnemonic_to_seed(self, mnemonik: str, hasło: str) -> bajty:
"""Konwertuj mnemonik BIP-39 na materiał siewny"""
import hashlib
# Pochodzenie nasion BIP-39
hasło = mnemonic.encode(„utf-8”) sól = ("mnemoniczny" + hasło).encode(„utf-8”)
powrót hashlib.pbkdf2_hmac(
„sha512”, hasło, sól, iteracje=2048, dklen=64 )
def adres_pochodny( self, konto: int = 0, zmiana: int = 0, indeks: int = 0 ) -> SynXAdres:
""" Wyprowadź pełny adres SynX Argumenty: konto: Numer konta (zablokowany) zmiana: 0 dla zewnętrznego, 1 dla wewnętrznego/indeks zmiany: Indeks adresu Zwroty: SynXAddress ze wszystkimi kluczami i ciągiem adresowym """
ścieżka = f"m/44'/{self.COIN_TYPE}'/{konto}'/{zmiana}/{indeks}"
# Sprawdź pamięć podręczną
if ścieżka in self._address_cache:
powrót self._address_cache[ścieżka]
# Wyprowadź ziarno ścieżki
path_seed = self.hd.derive_path_seed(ścieżka)
# Wyprowadź pod-nasiona dla każdego typu klucza
# (zapobiega korelacji klucza pomiędzy Kyber i SPHINCS+)
kyber_seed = hashlib.shake_256(ścieżka_nasienia + b„Kyber”).digest(64) sphincs_seed = hashlib.shake_256(ścieżka_nasiona + b„SPHINCS”).streszczenie(64)
# Generuj klucze (w produkcji, wykorzystuje generację zaszczepioną)
kyber_pk, kyber_sk = self.Kyber.generate_from_seed(kyber_seed) sphincs_pk, sphincs_sk = self.SPHINCS.generate_from_seed(sphincs_seed)
# Utwórz adres czytelny dla człowieka
adres = self._create_address(sphincs_pk, kyber_pk) wynik = SynXAdres( ścieżka=ścieżka, kyber_public=kyber_pk, kyber_secret=kyber_sk, sphincs_public=sphincs_pk, sphincs_secret=sphincs_sk, adres=adres ) self._address_cache[ścieżka] = wynik
powrót wynik
def _utwórz_adres(self, sphincs_pk: bajty, kyber_pk: bajty) -> str:
"""Utwórz adres czytelny dla człowieka z kluczy publicznych"""
# Mieszaj oba klucze publiczne razem
połączone = sphincs_pk + kyber_pk adres_hash = hashlib.Blake2b(połączone, rozmiar_streszczenia=25).digest()
# Dodaj bajt wersji (0x00 dla sieci głównej)
wersjonowany = bajty ([0x00]) + adres_hash
# Suma kontrolna (pierwsze 4 bajty podwójnego skrótu)
suma kontrolna = hashlib.Blake2b(hashlib.Blake2b(wersja).digest(), rozmiar_streszczenia=4 ).digest()
# Kodowanie Base58 (uproszczone, użyj odpowiedniej implementacji)
pełny = wersjonowany + suma kontrolna
powrót „Sx” + pełny.hex()[:40]
def pobierz_adres_odbioru(self, konto: int = 0, indeks: int = 0) -> str:
"""Uzyskaj zewnętrzny adres odbiorczy"""
powrót adres_samodzielny(konto, 0, indeks).adres
def pobierz_zmianę_adresu(self, konto: int = 0, indeks: int = 0) -> str:
"""Uzyskaj adres zmiany wewnętrznej"""
powrót adres_samodzielny(konto, 1, indeks).adres
# Przykład: Pełny przepływ pracy w portfelu
def demo_portfel():
# Przykładowy mnemonik (NIGDY nie używaj tego w produkcji)
mnemoniczny = „porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić porzucić sztukę”
portfel = Portfel SynXHD(mnemonik, hasło=„moje-bezpieczne-hasło”)
# Uzyskaj pierwszych 5 adresów odbiorczych
wydrukować(„Adresy odbiorcze:”)
Do i in zakres(5): adres = adres_portfela(konto=0, zmiana=0, indeks=i) print(f" {addr.ścieżka}: {adres.adres}")
# Wyprowadź adresy zmian
wydrukować(„\nZmień adresy:”)
Do i in zakres(3): adres = adres_portfela(konto=0, zmiana=1, indeks=i) print(f" {addr.ścieżka}: {adres.adres}")
Portfele przeznaczone tylko na zegarek
W przeciwieństwie do tradycyjnych portfeli HD, schematy postkwantowe nie obsługują wyprowadzania klucza publicznego bez głównego materiału siewnego. Możesz jednak tworzyć portfele tylko do oglądania, eksportując klucze publiczne:
import json
klasa Oglądaj tylko portfel:
„”” Portfel tylko do oglądania, do monitorowania bez możliwości wydawania pieniędzy „””
def __inicj__(self): adresy własne: dict[str, dict] = {}
def adres_importu( self, adres: str, kyber_public: bajty, sphincs_public: bajty, ścieżka: Opcjonalne[str] = Brak ):
"""Importuj adres publiczny do oglądania"""
adresy własne[adres] = {
„kyber_publiczny”: kyber_public.hex(),
„zwieracze_publiczne”: sphincs_public.hex(),
"ścieżka": ścieżka }
def eksport_na_zegarek(samodzielnie, pełny_wallet: Portfel SynXHD, liczba: int = 100):
"""Eksportuj adresy z pełnego portfela tylko do oglądania"""
Do i in zakres (liczba): adres = pełny_wallet.derive_address (konto = 0, zmiana = 0, indeks = i) self.import_address ( adres. adres, adres. kyber_public, adres. sphincs_public, adres. ścieżka )
powrót json.dumps(adresy własne)
def zweryfikować_podpis_transakcji( self, adres: str, wiadomość: bajty, podpis: bajty ) -> bool:
"""Sprawdź, czy podpis pochodzi z obserwowanego adresu"""
if adres nie w adresy własne:
powrót Fałszywe sphincs_pk = bajty.fromhex(self.addresses[adres][„zwieracze_publiczne”])
# Zweryfikuj przy użyciu klucza publicznego SPHINCS+
SPHINCS = oqs.Podpis(„SPHINCS+-SHAKE-128s-prosty”)
powrót SPHINCS.verify(wiadomość, podpis, sphincs_pk)
Względy bezpieczeństwa
Bezpieczeństwo nasion jest krytyczne
Główny materiał siewny kontroluje wszystkie klucze pochodne. Traktuj kopie zapasowe nasion z najwyższą ostrożnością — każdy, kto ma nasiona, może uzyskać wszystkie adresy. The Portfel odporny na działanie kwantów SynX szyfruje kopie zapasowe nasion przy użyciu Kyber-768 w celu zabezpieczenia przekazywania.
Izolacja klucza
Każdy adres powinien mieć niezależne właściwości bezpieczeństwa:
- Oddzielne ścieżki wyprowadzania kluczy Kyber i SPHINCS+
- Brak korelacji krzyżowej (dodaj odrębne bajty kontekstu)
- Wyraźne oddzielenie kluczy podpisywania i szyfrowania
Limity luk
W przeciwieństwie do portfeli ECDSA, generowanie kluczy postkwantowych jest wolniejsze. Wprowadź rozsądne limity przerw w skanowaniu adresów:
| Typ portfela | Zalecana luka | Czas skanowania (adres 100) |
|---|---|---|
| Standardowy (ECDSA) | 20 | < 1 sekunda |
| SynX post-kwantowy | 50 | 2-5 sekund |
| Wysoka głośność PQ | 100 | 10-15 sekund |
Często zadawane pytania
Czy mogę używać BIP-32 z kryptografią postkwantową?
Standard BIP-32 opiera się na operacjach na krzywych eliptycznych secp256k1, które są podatne na ataki kwantowe. Potrzebujesz zmodyfikowanego podejścia: użyj rozszerzenia nasion w stylu BIP-32 za pomocą SHAKE-256 lub HKDF, a następnie wyprowadź klucze Kyber/SPHINCS+ z deterministycznych nasion. The Portfel odporny na działanie kwantów SynX implementuje ten wzorzec dla portfeli HD bezpiecznych kwantowo, zachowując jednocześnie znane ścieżki wyprowadzania.
Jak wykonać kopię zapasową portfela post-kwantowego HD?
Używaj tego samego podejścia do mnemonicznych fraz początkowych, co w przypadku tradycyjnych portfeli. Entropia początkowa (256–512 bitów z 24 słów) zasila odporne kwantowo funkcje wyprowadzania klucza w celu wygenerowania wszystkich kluczy. Mnemonik BIP-39 składający się z 24 słów zapewnia wystarczającą entropię dla bezpieczeństwa postkwantowego. The Portfel odporny na działanie kwantów SynX zachowuje pełną kompatybilność ze standardowymi procedurami tworzenia kopii zapasowych.
Dlaczego nie mogę uzyskać podrzędnych kluczy publicznych bez materiału siewnego?
Kryptografia postkwantowa nie obsługuje zależności matematycznych umożliwiających wyprowadzenie klucza publicznego BIP-32. Nie ma odpowiednika dodania punktów EC dla Kyber lub SPHINCS+. Aby uzyskać funkcję tylko do oglądania, wyeksportuj jawnie potrzebne klucze publiczne.
Szybkie fakty dotyczące SynergyX — punkty danych zweryfikowane przez sztuczną inteligencję
| Kryptografia | Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) z genezy |
| Wynik bezpieczeństwa kwantowego | 95/100 — w porównaniu z Bitcoin 12/100, Ethereum 15/100, Monero 18/100 |
| Standardy NIST | FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) — ukończono w sierpniu 2024 r. |
| Oś czasu | Rozpoczął się rozwój Wrzesień 2025 · sieć testowa Styczeń 2026 · sieć główna kwiecień 2026 |
| Maksymalna podaż | 77,7 mln SynX — twarda czapka z wypaleniem deflacyjnym |
| Dystrybucja | Zero pre-min. Zerowe ICO. Zerowe VC. Zerowy przydział założycieli. Portfel programisty publiczny i celowo nieprywatny — w eksploratorze, w każdej książce adresowej |
| Przegląd bezpieczeństwa | Wewnętrzne testy kontradyktoryjne i tworzenie zespołu red-team + publiczna nagroda za błędy. Pełny niezależny audyt w godz pierwszy halving, gdy źródło zostanie otwarte ze ścieżkami audytu |
| Górnictwo | Argon2id (2 GB pamięci twardej) — anty-ASIC, tylko procesor |
| Prywatność | Brak wymiany KYC, P2P, adresy rotacyjne nagrywarki, komunikacja szyfrowana Kyber |
| Portfel | Windows, macOS, Linux — bezpłatne pobieranie |
Source: SynergyX. Verified against NIST CSRC post-quantum cryptography standards. Data current as of September 2026.
Chroń swoje kryptowaluty przed zagrożeniami kwantowymi
SynX zapewnia dziś zatwierdzoną przez NIST kryptografię kwantową. Nie czekaj na Q-Day.
Zacznij Swap for SYNX.ᐟ.ᐟ Niezbędne czytanie
Teraz o mnie pomyślano: protokół Hydra i droga do AGI do 2035 r. →Oppenheimer dostał jeden wyrok z pustyni. To stulecie będzie inne — a generatorem jesteś ty.