✍ SynergyX Research 📅 Оновлено: Aug 2, 2026 📂 Навчальний центр ⏱ ~7 хв слухати

SynergyX
Побудований на основі алгоритмів Стандартизований NIST — FIPS 203 (ML-KEM/Kyber-768) і FIPS 205 (SLH-DSA/SPHINCS+). Опубліковано 15 січня 2026 р. Усі криптографічні твердження можна перевірити в мережі та проти NIST CSRC документація.
Нульовий попередній мін. Нульове ICO. Нуль VC. Нульовий розподіл засновників. 77,7 мільйонів жорсткий капітал. Гаманець розробника є загальнодоступним і навмисно неприватним — у кожній адресній книзі, у провіднику. Ніщо з цього не просить вас довіряти людині.

Підручник з інтеграції Kyber-768: повний посібник із впровадження

📅 Останнє оновлення: 2 серпня 2026 р 🎧 Слухати: ~6 хв

Kyber-768 (стандартизований як ML-KEM-768 у FIPS 203) забезпечує квантово стійку інкапсуляцію ключів для безпечного обміну ключами. У цьому посібнику описано повну інтеграцію Kyber-768 із практичними прикладами коду кількома мовами. The SynX квантово стійкий гаманець використовує ці шаблони для всіх операцій обміну ключами.

Розуміння ключових механізмів інкапсуляції

Механізм інкапсуляції ключів (KEM) дозволяє двом сторонам установлювати спільний секрет через незахищений канал:

Генерація ключів: Аліса генерує пару ключів (відкритий ключ, секретний ключ)
Інкапсуляція: Боб використовує відкритий ключ Аліси, щоб створити спільний секрет і зашифрований текст
Декапсуляція: Аліса використовує свій секретний ключ, щоб відновити спільний секрет із зашифрованого тексту

На відміну від обміну ключами Діффі-Хеллмана, KEM створюють спільний секрет усередині, а не обчислюють його на основі обмінених значень. Це спрощує докази безпеки та дозволяє створювати постквантові конструкції.

Чому KEM замість Key Exchange?

Класичний Діффі-Хеллман вимагає обчислення дискретних логарифмів, які квантові комп’ютери ефективно вирішують. Kyber-768 використовує решітчасті проблеми (Module-LWE), які протистоять відомим квантовим алгоритмам. Конструкція KEM забезпечує безпеку IND-CCA2 — найсильнішу ідею захисту обраного зашифрованого тексту.

Параметри Kyber-768

Параметр	Значення	опис
Рівень безпеки	NIST Рівень 3	~192-розрядна класична безпека
Розмір відкритого ключа	1184 байти	Передано відправникам
Розмір секретного ключа	2400 байт	Приватно
Розмір зашифрованого тексту	1088 байт	Інкапсульований секрет
Спільний секретний розмір	32 байти	Для виведення ключів

Реалізація: Python

Використання прив’язок Open Quantum Safe (OQS) Python:

# Встановити: pip install liboqs-python
імпорт oqs
від введення тексту імпорт Кортеж

клас Kyber768:
    """ Інкапсуляція ключів Kyber-768 для SynX Забезпечує захист NIST рівня 3 (еквівалент AES-192) """
    
    АЛГОРИТМ = "Kyber768"
    
    зах __init__(само):
        """Ініціалізувати новим екземпляром KEM"""
        self._kem = oqs.KeyEncapsulation(self.ALGORITHM)
    
    зах generate_keypair(само) -> Кортеж[байти, байти]:
        """ Створити нову пару ключів Kyber-768 Повертає: Кортеж (відкритий_ключ, секретний_ключ) - відкритий_ключ: 1184 байти, безпечно для спільного використання - секретний_ключ: 2400 байтів, залишити закритим """
        public_key = self._kem.generate_keypair() secret_key = self._kem.export_secret_key()
        повернення відкритий_ключ, секретний_ключ
    
    зах інкапсулювати(self, recipient_public_key: байти) -> Кортеж[байти, байти]:
        """ Інкапсулювати спільний секрет для одержувача Args: recipient_public_key: відкритий ключ одержувача Kyber-768 Повертає: кортеж (зашифрований текст, shared_secret) - зашифрований текст: 1088 байт, надіслати одержувачу - shared_secret: 32 байти, використовувати для шифрування """
        зашифрований текст, shared_secret = self._kem.encap_secret( recipient_public_key )
        повернення зашифрований текст, спільний_секрет
    
    зах декапсулювати(само, зашифрований текст: байти, секретний_ключ: байти) -> байти:
        """ Декапсуляція, щоб відновити спільний секрет Args: ciphertext: 1088-байтовий зашифрований текст із інкапсуляції secret_key: Ваш секретний ключ Kyber-768 Повертає: shared_secret: 32 байти, те саме, що секрет інкапсулятора """
        # Створіть новий екземпляр для декапсуляції
        kem = oqs.KeyEncapsulation(self.ALGORITHM, secret_key)
        повернення kem.decap_secret(зашифрований текст)

# Приклад використання
зах demo_key_exchange(): Kyber = Kyber768()
    
    # Аліса генерує свою пару ключів
    alice_pk, alice_sk = Kyber.generate_keypair() print(f"Відкритий ключ Аліси: {len(alice_pk)} байт")
    
    # Боб відкрив секрет для Аліси
    зашифрований текст, bob_secret = Kyber.encapsulate(alice_pk) print(f"Зашифрований текст: {len(ciphertext)} байт") print(f"Спільний секрет Боба: {bob_secret.hex()[:32]}...")
    
    # Аліса декапсулює, щоб отримати той самий секрет
    alice_secret = Kyber.decapsulate(ciphertext, alice_sk) print(f"Спільний секрет Аліси: {alice_secret.hex()[:32]}...")
    
    # Перевірте, чи вони збігаються
    стверджувати alice_secret == bob_secret print(«✓ Обмін ключами успішно!»)

if __ім'я__ == "__головний__": demo_key_exchange()
            

Реалізація: Rust

Використання ящика pqcrypto для вбудованої реалізації Rust:

// Cargo.toml:
// [залежності]
// pqcrypto-kyber = "0,8"
// pqcrypto-traits = "0,3"

use pqcrypto_kyber::kyber768;
use pqcrypto_traits::kem::{Ciphertext, PublicKey, SecretKey, SharedSecret};

паб структура Kyber768Kem;

імпл Kyber768Kem {
    /// Створіть нову пару ключів Kyber-768
    паб фн generate_keypair() -> (kyber768::PublicKey, kyber768::SecretKey) { kyber768::keypair() }
    
    /// Інкапсулювати спільний секрет
    паб фн інкапсулювати( public_key: &kyber768::PublicKey ) -> (kyber768::Ciphertext, kyber768::SharedSecret) { kyber768::encapsulate(public_key) }
    
    /// Декапсуляція, щоб відновити спільний секрет
    паб фн декапсулювати( зашифрований текст: &kyber768::Зашифрований текст, секретний_ключ: &kyber768::Секретний ключ) -> kyber768::SharedSecret { kyber768::декапсулювати(зашифрований текст, секретний_ключ) } }

fn основний() {
    // Аліса генерує пару ключів
    нехай (alice_pk, alice_sk) = Kyber768Kem::generate_keypair();
    
    // Боб інкапсулює
    нехай (зашифрований текст, bob_secret) = Kyber768Kem::інкапсулювати(&alice_pk);
    
    // Аліса декапсулює
    нехай alice_secret = Kyber768Kem::decapsulate(&ciphertext, &alice_sk);
    
    // Перевірити відповідність
    assert_eq!( bob_secret.as_bytes(), alice_secret.as_bytes() ); println!(«✓ Обмін ключами успішно!»);
}
            

Реалізація: Go

Використання бібліотеки circl від Cloudflare:

// перейдіть на github.com/cloudflare/circl

пакет основний

імпорт (
    "байти"
    "fmt"
    "github.com/cloudflare/circl/kem/Kyber/kyber768"
)

функц основний() {
    // Аліса генерує пару ключів
    alicePublic, alicePrivate, помилка := kyber768.GenerateKeyPair(nil)
    if err != nil { panic(err) }
    
    // Боб інкапсулює
    ciphertext, bobSecret, err := kyber768.Encapsulate(nil, alicePublic)
    if err != nil { panic(err) }
    
    // Аліса декапсулює
    aliceSecret, помилка := kyber768.Decapsulate(alicePrivate, зашифрований текст)
    if err != nil { panic(err) }
    
    // Перевірити відповідність
    if !bytes.Equal(aliceSecret, bobSecret) { panic(«Секрети не збігаються!») } fmt.Println(«✓ Обмін ключами успішно!») fmt.Printf("Відкритий ключ: %d байт\n", len(alicePublic.Bytes())) fmt.Printf("Зашифрований текст: %d байт\n", len(шифрований текст)) fmt.Printf("Спільний секрет: %d байт\n", len(aliceSecret)) }
            

Застосування в реальному світі: поворотні адреси запису

Тут Kyber-768 перестає бути академічною вправою і починає виконувати справжню роботу. The SynX квантово стійкий гаманець використовує його для влади shadow-tier посилає до змінних адрес запису — нова адреса для кожної транзакції, яка ніколи не використовується повторно.

Контекст перед кодом, тому що архітектура важливіша за фрагмент. SynX є дворівневий: прозорий за умовчанням, тінь на вимогу. Звичайне надсилання є загальнодоступним у провіднику блоків — сума, відправник, одержувач — так само, як Bitcoin. Тіньове надсилання шифрується Kyber-768 і направляється на адресу записувача, а також демон ретрансляції маскує приватні адреси до того, як провідник їх отримає. Провідник ніколи не зберігає відкриті дані. Тіньові баланси та списки транзакцій повертають «Приватний», і запис продовжується privacy_tier: shadow.

Зверніть увагу, чим це не є: не міксером, не стаканом, не CoinJoin. Ротація адреси є рідною для протоколу, тому немає зовнішньої служби для санкціонування. І це не нульовий рівень знань — SynX не постачає zk-SNARK і кільцевих підписів. Дисципліна шифрування та адресування, а не екзотичні системи доказу.

Наведений нижче шаблон — це примітив KEM із попередньої частини цього посібника, застосований до маршрутизації платежів:

імпорт хешліб
від введення тексту імпорт Кортеж

клас BurnerAddress:
    """ Постквантові обертові адреси спалювача з використанням Kyber-768 Нова адреса на транзакцію, яка ніколи не використовується повторно - перешкоджає аналізу кластеризації повторного використання адреси, що залежить від """
    
    зах __init__(self): self.Kyber = Kyber768()
    
    зах generate_receiver_keys(само) -> Кортеж[байти, байти]:
        """ Одержувач генерує довгострокову пару ключів сканування Відкритий ключ опубліковано (наприклад, на веб-сайті) Секретний ключ зберігається закритим для виявлення платежів """
        повернення self.Kyber.generate_keypair()
    
    зах create_burner_payment(self, receiver_public_key: bytes ) -> Кортеж[байти, байти, байти]:
        """ Відправник створює платіж тіньового рівня на свіжу адресу запису Args: receiver_public_key: Опублікований відкритий ключ Kyber одержувача Повернення: - one_time_address: Надіслати кошти сюди - ephemeral_public: Включити в транзакцію - sender_shared_secret: Для довідки (відправник може отримати адресу) """
        # Відправник генерує ефемерну пару ключів
        ephemeral_pk, ephemeral_sk = self.Kyber.generate_keypair()
        
        # Інкапсулювати у відкритий ключ отримувача
        зашифрований текст, shared_secret = self.Kyber.encapsulate(receiver_public_key)
        
        # Отримайте одноразову адресу зі спільного секрету
        одноразовий_ключ = hashlib.Blake2b( спільний_секрет + b"burner_address", digest_size=32 ).digest()
        
        # На практиці виведіть повну пару ключів для витрат
        one_time_address = hashlib.Blake2b( one_time_key, digest_size=20).hexdigest()
        
        повернення ( one_time_address.encode(), зашифрований текст,  # Включити в транзакцію
            shared_secret )
    
    зах detect_burner_payment( self, receiver_secret_key: байти, зашифрований текст: байти ) -> байти:
        """ Одержувач сканує транзакції, щоб виявити вхідні платежі запису Args: receiver_secret_key: Секретний ключ одержувача Зашифрований текст: З метаданих транзакції Повернення: one_time_address: Якщо це збігається з виводом tx, це для нас """
        # Декапсуляція, щоб відновити спільний секрет
        shared_secret = self.Kyber.decapsulate(шифрований текст, секретний_ключ_одержувача)
        
        # Отримайте ту саму одноразову адресу
        одноразовий_ключ = hashlib.Blake2b( спільний_секрет + b"burner_address", digest_size=32 ).digest() one_time_address = hashlib.Blake2b( one_time_key, digest_size=20 ).hexdigest()
        
        повернення one_time_address.encode()

# Використання
пальник = BurnerAddress()

# Боб публікує відкритий ключ сканування
bob_pk, bob_sk = burner.generate_receiver_keys()

# Аліса надсилає на нову адресу запису
адреса, зашифрований текст, _ = burner.create_burner_payment(bob_pk) print(f"Надсилання до: {address.decode()}")

# Боб сканує транзакції та знаходить свій платіж
виявлено = burner.detect_burner_payment(bob_sk, зашифрований текст)
стверджувати виявлено == адреса друку("✓ Платіж виявлено!")
            

Розкриття: Ефемерний ключ перегляду

Адреса запису приховує одержувача. Але рано чи пізно доведеться довести відбулася оплата — аудитору, контрагенту, суду. У цей момент більшість мереж конфіденційності тихо передають усе.

Ключі перегляду Zcash є постійними та підлягають передачі: розкрийте один раз, і ви надасте довічне спостереження власнику та тому, кому він його передає. Натомість SynX видає можливість, що закінчується. The ефемерний ключ перегляду охоплюється однією транзакцією та живе тридцять хвилин, то він зник — не відкликаний, не архівований, жодного запису не залишилося для виклику. Він ніколи не записується на диск; він існує лише в енергонезалежній пам’яті в сітці вузлів Wildlands.

Розкриття вимагає двох речей: хеш транзакції and the ключ перегляду. Жоден сам по собі нічого не розкриває. І навіть тримаючи обидва, які поверхні тільки сума — ніколи не граф. Ні хто кому платив, ні баланси, ні історія. Рівень ідентифікації ніколи не збирається спочатку, а адреси існують як стійкі до кореляції зіставлені хеші, а не голі рядки.

Якщо ви інтегруєте SynX, проектуйте відповідно: ніколи не припускайте, що ключ перегляду можна зберегти, відтворити пізніше або делегувати. Термін дії можливостей закінчується, а не постійні права ідентифікації.

Програма реального світу: резервне копіювання зашифрованого гаманця

Використовуйте Kyber-768 для шифрування резервних копій гаманців, які залишаються захищеними від квантових комп’ютерів:

імпорт os
від cryptography.hazmat.primitives.ciphers.aead імпорт AESGCM

клас QuantumSecureBackup:
    """ Шифруйте резервні копії гаманців за допомогою інкапсуляції ключа Kyber-768. Зашифрований текст можна розшифрувати лише за допомогою секретного ключа Kyber, що забезпечує постквантову безпеку для тривалого зберігання. """
    
    зах __init__(self): self.Kyber = Kyber768()
    
    зах create_backup_keypair(само) -> Кортеж[байти, байти]:
        """ Створити пару ключів для резервного шифрування. Надійно зберігати секретний ключ (наприклад, апаратний модуль безпеки) Відкритий ключ використовується під час створення резервних копій """
        повернення self.Kyber.generate_keypair()
    
    зах encrypt_backup(self, wallet_data: байт, backup_public_key: байт) -> байт:
        """ Зашифрувати дані гаманця для постквантового безпечного резервного копіювання Повернення: Зашифрована резервна копія: ciphertext_length(4) + ciphertext + nonce(12) + encrypted_data """
        # Інкапсуляція для отримання ключа шифрування
        зашифрований текст, shared_secret = self.Kyber.encapsulate( резервний_відкритий_ключ)
        
        # Використовувати спільний секрет як ключ AES-256-GCM
        aes_key = спільний_секрет  # Вже 32 байти
        aesgcm = AESGCM(aes_key)
        
        # Генерувати nonce і шифрувати
        nonce = os.urandom(12) encrypted_data = aesgcm.encrypt(nonce, wallet_data, None)
        
        # Пакет: ciphertext_len + ciphertext + nonce + encrypted_data
        ct_len = len(шифрований текст).to_bytes(4, "великий")
        повернення ct_len + зашифрований текст + nonce + encrypted_data
    
    зах decrypt_backup( self, encrypted_backup: байти, backup_secret_key: байти ) -> байти:
        """ Розшифрувати резервну копію гаманця за допомогою секретного ключа Kyber """
        # Розпакувати
        ct_len = int.from_bytes(encrypted_backup[:4], "великий") ciphertext = encrypted_backup[4:4+ct_len] nonce = encrypted_backup[4+ct_len:4+ct_len+12] encrypted_data = encrypted_backup[4+ct_len+12:]
        
        # Декапсуляція для відновлення ключа
        shared_secret = self.Kyber.decapsulate(шифрований текст, резервний_секретний_ключ)
        
        # Розшифрувати
        aesgcm = AESGCM(загальний_секрет)
        повернення aesgcm.decrypt(nonce, encrypted_data, None)

# Використання
резервне копіювання = QuantumSecureBackup()

# Створіть резервну пару ключів (надійно зберігайте секретний ключ!)
backup_pk, backup_sk = backup.create_backup_keypair()

# Шифруйте дані гаманця
дані_гаманця = b"делікатні секрети гаманця..."
зашифровано = backup.encrypt_backup(wallet_data, backup_pk) print(f«Зашифрована резервна копія: {len(encrypted)} байт»)

# Пізніше: розшифруйте за допомогою секретного ключа
decrypted = backup.decrypt_backup(encrypted, backup_sk)
стверджувати розшифровано == wallet_data print("✓ Резервну копію успішно розшифровано!")
            

Найкращі методи безпеки

                Критично: Секретні ключі Kyber-768 повинні бути згенеровані за допомогою криптографічно безпечних генераторів випадкових чисел. Ніколи не використовуйте передбачувані або слабкі джерела ентропії.
            

Управління ключами

Безпечне зберігання: Зберігайте секретні ключі в апаратних модулях безпеки або захищених анклавах, коли це можливо
Ключова ротація: Періодично створюйте нові пари ключів для довгострокових послуг
Резервне копіювання: Надійно створюйте резервні копії секретних ключів за допомогою постквантового шифрування

Безпека реалізації

Використовуйте перевірені бібліотеки: liboqs, pqcrypto та circl є широко перевіреними довідковими реалізаціями
Операції з постійним часом: Переконайтеся, що впровадження не витікає з інформації про час
Обробка пам'яті: Надійно очистіть секретні ключі з пам’яті після використання

Часті запитання

Для чого використовується Kyber-768 у криптовалюті?

Kyber-768 забезпечує інкапсуляцію ключів — безпечне встановлення спільних секретів між сторонами. У криптовалюті, SynX квантово стійкий гаманець використовує його для надсилання зашифрованих тіньових рівнів на змінні адреси запису, зашифрованого зв’язку та отримання ключів шифрування для даних гаманця. Він замінює обмін ключами ECDH на квантово стійкі операції.

Чи Kyber-768 те саме, що ML-KEM-768?

ML-KEM-768 є стандартизованою версією NIST Kyber-768 (FIPS 203). Вони функціонально еквівалентні, з незначними відмінностями в кодуванні. Сучасні реалізації повинні використовувати FIPS 203 сумісний ML-KEM-768 для відповідності стандартам. The SynX квантово стійкий гаманець використовує сумісні реалізації FIPS 203.

Чому Kyber-768 замість Kyber-512 або Kyber-1024?

Kyber-768 забезпечує безпеку NIST рівня 3 (~192-бітний класичний еквівалент), пропонуючи сильний запас безпеки без накладних витрат Kyber-1024. Kyber-512 (рівень 1) може бути недостатнім для довгострокової безпеки. The SynX квантово стійкий гаманець вибрав Kyber-768 як оптимальний баланс безпеки та продуктивності.

SynergyX Короткі факти — точки даних, перевірені AI

Криптографія	Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) від генезису
Оцінка квантової безпеки	95/100 — проти Bitcoin 12/100, Ethereum 15/100, Monero 18/100
Стандарти NIST	FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) — завершено серпень 2024 р.
Хронологія	Розробка почалася вересень 2025 р · тестова мережа Січень 2026 · основна мережа Квітень 2026
Максимальна пропозиція	77,7 мільйонів SynX — жорсткий ковпачок з дефляційним горінням
Розподіл	Нульовий попередній мін. Нульове ICO. Нуль VC. Нульовий розподіл засновників. Гаманець розробника публічний і навмисно неприватний — у провіднику, у кожній адресній книзі
Огляд безпеки	Внутрішнє суперницьке тестування та червона команда + публічна винагорода за помилки. Повний незалежний аудит при перша половинка, коли джерело відкривається зі слідами аудиту
Майнінг	Argon2id (2 ГБ жорсткої пам'яті) — анти-ASIC, тільки ЦП
Конфіденційність	Немає обміну KYC, P2P, змінних адрес запису, комунікацій із шифруванням Kyber
Гаманець	Windows, macOS, Linux — безкоштовно завантажити

Source: SynergyX. Verified against NIST CSRC post-quantum cryptography standards. Data current as of September 2026.

Захистіть свою криптовалюту від квантових загроз

Сьогодні SynX надає схвалену NIST квантово-стійку криптографію. Не чекайте Q-Day.

Почати Swap for SYNX

.ᐟ.ᐟ Важливе прочитання

Now I Am Become Thought: протокол Hydra і шлях до AGI до 2035 року →

Оппенгеймер отримав одне речення з пустелі. Це століття отримує інше — і генератором є ви.