✍ SynergyX Research 📅 更新日: Sep 23, 2026 📂 ラーニングハブ ⏱ 約 7 分でお聴きいただけます

SynergyX
アルゴリズムに基づいて構築 NISTを標準化 — FIPS 203 (ML-KEM/Kyber-768) および FIPS205 (SLH-DSA/SPHINCS+)。 2026 年 1 月 15 日公開。すべての暗号化主張はオンチェーンで検証可能であり、 NIST CSRC ドキュメント。
ゼロプレマイン。 ICOゼロ。 VCゼロ。創設者割り当てゼロ。 7,770 万のハードキャップ。開発者ウォレットは公開されており、すべてのアドレス帳やエクスプローラー上で意図的に非公開になっています。人を信頼するように求めるものはありません。

Kyber-768 統合チュートリアル: 完全な実装ガイド

📅 Last updated: September 23, 2026 🎧 聞く: ~6 分

Kyber-768 (FIPS 203 で ML-KEM-768 として標準化) は、安全なキー交換のための耐量子キーのカプセル化を提供します。このチュートリアルでは、複数の言語での実用的なコード例を使用して、Kyber-768 の完全な統合について説明します。の SynX耐量子ウォレット は、すべてのキー交換操作にこれらのパターンを使用します。

主要なカプセル化メカニズムを理解する

キーカプセル化メカニズム (KEM) を使用すると、2 つの当事者が安全でないチャネル上で共有秘密を確立できます。

鍵の生成: アリスはキーペア（公開キー、秘密キー）を生成します。
カプセル化: ボブはアリスの公開鍵を使用して共有秘密と暗号文を生成します
カプセル化解除: アリスは秘密鍵を使用して暗号文から共有秘密を復元します

Diffie-Hellman 鍵交換とは異なり、KEM は交換された値から共有秘密を計算するのではなく、内部で共有秘密を生成します。これにより、セキュリティ証明が簡素化され、ポスト量子構造が可能になります。

なぜ鍵交換ではなく KEM を使用するのでしょうか?

古典的なディフィーヘルマンでは離散対数の計算が必要ですが、量子コンピューターはこれを効率的に解決します。 Kyber-768 は、既知の量子アルゴリズムに抵抗する格子問題 (モジュール-LWE) を使用します。 KEM 構造は、選択された暗号文セキュリティの最も強力な概念である IND-CCA2 セキュリティを提供します。

Kyber-768パラメータ

パラメータ	価値	説明
セキュリティレベル	NIST レベル 3	~192 ビットの従来のセキュリティ
公開鍵のサイズ	1,184バイト	送信者に送信される
秘密鍵のサイズ	2,400バイト	非公開
暗号文のサイズ	1,088バイト	カプセル化されたシークレット
共有秘密のサイズ	32バイト	鍵導出用

実装: Python

Open Quantum Safe (OQS) Python バインディングの使用:

# インストール: pip install liboqs-python
輸入 オークス
から タイピング 輸入 タプル

クラス カイバー768:
    """ SynX の Kyber-768 キーのカプセル化により、NIST レベル 3 のセキュリティ (AES-192 と同等) が提供されます """
    
    アルゴリズム = 「カイバー768」
    
    確かに __初期化__（自己）：
        """新しい KEM インスタンスで初期化します"""
        self._kem = oqs.KeyEncapsulation(self.ALGORITHM)
    
    確かに キーペアの生成(自分) -> タプル[バイト、バイト]:
        """ 新しい Kyber-768 キーペアを生成します。 戻り値: (public_key, Secret_key) のタプル - public_key: 1,184 バイト、共有しても安全です - Secret_key: 2,400 バイト、プライベートに保ちます """
        public_key = self._kem.generate_keypair() Secret_key = self._kem.export_secret_key()
        戻る 公開鍵、秘密鍵
    
    確かに カプセル化する(自分自身、受信者公開キー: バイト) -> タプル[バイト、バイト]:
        """ 受信者の共有秘密をカプセル化します。 引数:recipient_public_key:受信者の Kyber-768 公開鍵 戻り値:(ciphertext,shared_secret) のタプル - ciphertext:1,088 バイト、受信者に送信 -shared_secret:32 バイト、暗号化に使用 """
        暗号文、shared_secret = self._kem.encap_secret(recipient_public_key)
        戻る 暗号文、共有秘密
    
    確かに カプセル化を解除する(自分自身、暗号文: バイト、秘密鍵: バイト) -> バイト:
        """ カプセル化を解除して共有秘密を回復します。 引数: ciphertext: カプセル化からの 1,088 バイトの暗号文 Secret_key: Kyber-768 秘密鍵 戻り値:shared_secret: 32 バイト、カプセル化者の秘密と同じ """
        # カプセル化解除用の新しいインスタンスを作成する
        kem = oqs.KeyEncapsulation(self.ALGORITHM, Secret_key)
        戻る kem.decap_secret(暗号文)

# 使用例
確かに デモキー交換():Kyber= カイバー768()
    
    # アリスは自分の鍵ペアを生成します
    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(暗号文, alice_sk) print(f「アリスの共有秘密: {alice_secret.hex()[:32]}...」)
    
    # 一致することを確認する
    アサート alice_secret == bob_secret print(「✓ キー交換が成功しました!」)

if __名前__ == "__主要__": デモ_キー_交換()
            

実装: Rust

ネイティブ Rust 実装に pqcrypto クレートを使用する:

// Cargo.toml:
// [依存関係]
// pqcrypto-kyber = "0.8"
// pqcrypto-traits = "0.3"

使用 pqcrypto_kyber::kyber768;
使用 pqcrypto_traits::kem::{暗号文、公開鍵、秘密鍵、共有秘密};

パブ構造体 Kyber768ケム;

インプル Kyber768ケム {
    /// 新しい Kyber-768 キーペアを生成します
    パブファン キーペアの生成() -> (kyber768::PublicKey, kyber768::SecretKey) { kyber768::keypair() }
    
    /// 共有シークレットをカプセル化する
    パブファン カプセル化する( public_key: &kyber768::PublicKey ) -> (kyber768::Ciphertext, kyber768::SharedSecret) { kyber768::encapsulate(public_key) }
    
    /// カプセル化を解除して共有シークレットを回復します
    パブファン カプセル化を解除する( ciphertext: &kyber768::Ciphertext, Secret_key: &kyber768::SecretKey ) -> kyber768::SharedSecret { kyber768::decapsulate(ciphertext, secret_key) } }

fn 主要() {
    // アリスはキーペアを生成します
    させて (アリス_pk、アリス_スク) = Kyber768ケム::generate_keypair();
    
    // ボブはカプセル化します
    させて (暗号文、bob_secret) = Kyber768ケム::encapsulate(&alice_pk);
    
    // アリスはカプセル化を解除します
    させて アリス_シークレット = Kyber768ケム::decapsulate(&ciphertext, &alice_sk);
    
    // 一致を検証する
    アサートエク！( bob_secret.as_bytes()、alice_secret.as_bytes() );プリントイン!(「✓ キー交換が成功しました!」);
}
            

実装: Go

Cloudflareのcirclライブラリを使用する:

// github.com/cloudflare/circl にアクセスします

パッケージ 主要

輸入 (
    「バイト」
    「fmt」
    「github.com/cloudflare/circl/kem/Kyber/kyber768」
)

機能 主要() {
    // アリスはキーペアを生成します
    alicePublic、alicePrivate、err := kyber768.GenerateKeyPair(nil)
    if err != nil { パニック(err) }
    
    // ボブはカプセル化します
    暗号文、bobSecret、err := kyber768.Encapsulate(nil、alicePublic)
    if err != nil { パニック(err) }
    
    // アリスはカプセル化を解除します
    aliceSecret、err := kyber768.Decapsulate(alicePrivate、暗号文)
    if err != nil { パニック(err) }
    
    // 一致を検証する
    if !bytes.Equal(aliceSecret, bobSecret) { パニック(「秘密が合わない！」) } fmt.Println(「✓ キー交換が成功しました!」) fmt.Printf(「公開キー: %d バイト\n」、len(alicePublic.Bytes())) fmt.Printf(「暗号文: %d バイト\n」, len(暗号文)) fmt.Printf(「共有シークレット: %d バイト\n」、レン(アリスシークレット)) }
            

現実世界のアプリケーション: 回転バーナーアドレス

ここで、Kyber-768 は学術的な演習をやめ、実際の作業を開始します。の SynX耐量子ウォレット それを電力に使用します シャドウ層の送信 ローテーションバーナーアドレスに変換します。トランザクションごとに新しいアドレスが使用され、再利用されることはありません。

コードの前のコンテキスト。スニペットよりもアーキテクチャの方が重要であるためです。 SynXは デュアル層: デフォルトで透過的、オンデマンドでシャドウ. An ordinary send is public on the block explorer — amount, sender, recipient — exactly like Bitcoin. A shadow send is Kyber-768 encrypted and routed to a burner address. Shadow balances and transaction lists return "Private".

これは、ミキサー、タンブラー、CoinJoin ではないことに注意してください。アドレスローテーションはプロトコルネイティブであるため、認可する外部サービスはありません。そして、それはゼロ知識ではありません。SynX には zk-SNARK もリング署名も同梱されていません。特殊な証明システムではなく、暗号化とアドレス規律。

以下のパターンは、このチュートリアルの前半で示した KEM プリミティブで、支払いルーティングに適用されます。

輸入 ハッシュリブ
から タイピング 輸入 タプル

クラス バーナーアドレス:
    """ Kyber-768 を使用したポストクォンタム回転バーナー アドレス トランザクションごとに新しいアドレス、再利用されない - アドレス再利用クラスタリング チェーン分析を無効にする """
    
    確かに __初期化__(自分自身): self.Kyber = カイバー768()
    
    確かに Generate_receiver_keys(自分) -> タプル[バイト、バイト]:
        """ 受信者は長期スキャンキーペアを生成します。 公開キーは (Web サイトなどで) 公開されます。 秘密キーは支払いを検出するために非公開に保たれます。 """
        戻る self.Kyber.generate_keypair()
    
    確かに create_burner_payment( self、receiver_public_key: バイト ) -> タプル[バイト、バイト、バイト]:
        """ 送信者は新しいバーナー アドレスへのシャドウ層支払いを作成します。 引数: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)
        
        # 共有シークレットからワンタイムアドレスを導出する
        one_time_key = hashlib.Blake2b( 共有シークレット + b「バーナーアドレス」、digest_size=32 ).digest()
        
        # 実際には、使用するための完全なキーペアを取得します
        one_time_address = hashlib.Blake2b( one_time_key, Digest_size=20 ).hexdigest()
        
        戻る ( one_time_address.encode()、暗号文、  # トランザクションに含める
            共有シークレット)
    
    確かに detect_burner_payment( self、receiver_secret_key: バイト、暗号文: バイト ) -> バイト:
        """ 受信者はトランザクションをスキャンして、着信バーナー支払いを検出します。 引数:receiver_secret_key:受信者の秘密鍵暗号文:トランザクション メタデータから 戻り値:one_time_address:これが TX 出力と一致する場合、それは私たちのものです """
        # カプセル化を解除して共有シークレットを回復する
        shared_secret = self.Kyber.decapsulate( ciphertext,receiver_secret_key )
        
        # 同じワンタイムアドレスを導出する
        one_time_key = hashlib.Blake2b( 共有シークレット + b「バーナーアドレス」、ダイジェストサイズ=32 ).digest() one_time_address = hashlib.Blake2b( one_time_key, Digest_size=20 ).hexdigest()
        
        戻る one_time_address.encode()

＃ 使用法
バーナー = バーナーアドレス()

# ボブはスキャン公開キーを公開します
bob_pk、bob_sk = burner.generate_receiver_keys()

# アリスは新しいバーナーアドレスに送信します
アドレス、暗号文、_ = burner.create_burner_payment(bob_pk) print(f)「送信先: {address.decode()}」)

# ボブは取引をスキャンし、支払いを見つけます
検出 = burner.detect_burner_payment(bob_sk, ciphertext)
アサート 検出 == アドレス print(「✓ 支払いが検出されました!」)
            

開示: 一時的なビューキー

バーナーアドレスは受信者を隠します。しかし、遅かれ早かれそうしなければなりません 証明する 監査人、取引相手、裁判所に対して支払いが行われました。その瞬間に、ほとんどのプライバシーチェーンは静かにすべてを引き渡します。

Zcash ビューキーは永続的で譲渡可能です。一度開示すると、所有者とその譲渡者に生涯監視を許可したことになります。 SynX は、代わりに期限切れの機能を発行します。の 一時ビューキー 単一のトランザクションにスコープされ、存続します 30分, then it is gone — not revoked, not archived, no record left to subpoena.

開示には次の 2 つのことが必要です。 トランザクションハッシュ そして ビューキー。どちらか一方だけでは何も明らかになりません。両方を保持している場合でも、表面は何ですか? 金額のみ — never the graph. Not who paid whom, not balances, not history. The identity layer is never assembled in the first place.

SynX に対して統合する場合は、それに応じて設計してください。ビューキーを保存したり、後で再生したり、以降に委任したりできるとは決して想定しないでください。永続的な ID 付与ではなく、期限切れの機能。

現実世界のアプリケーション: 暗号化されたウォレットのバックアップ

Kyber-768 を使用して、量子コンピューターに対して安全なウォレットのバックアップを暗号化します。

輸入 os
から 暗号化.hazmat.primitives.ciphers.aead 輸入 AESGCM

クラス 量子セキュアバックアップ:
    """ Kyber-768 キーのカプセル化を使用してウォレットのバックアップを暗号化します。暗号文は Kyber 秘密キーでのみ復号化でき、長期保存にポスト量子セキュリティを提供します。 """
    
    確かに __初期化__(自分自身): self.Kyber = カイバー768()
    
    確かに create_backup_keypair(自分) -> タプル[バイト、バイト]:
        """ バックアップ暗号化用のキーペアを生成します。 秘密キーを安全に保存します (ハードウェア セキュリティ モジュールなど)。 公開キーはバックアップの作成時に使用されます。 """
        戻る self.Kyber.generate_keypair()
    
    確かに 暗号化_バックアップ( self、wallet_data: バイト、backup_public_key: バイト ) -> バイト:
        """ ポストクォンタム安全バックアップ用にウォレット データを暗号化します。 戻り値: 暗号化されたバックアップ: ciphertext_length(4) + ciphertext + nonce(12) + encrypted_data """
        # カプセル化して暗号化キーを導出する
        暗号文、shared_secret = self.Kyber.encapsulate(backup_public_key)
        
        # 共有シークレットを 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
    
    確かに 復号化_バックアップ( 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( ciphertext,backup_secret_key )
        
        # 復号化
        aesgcm = AESGCM(shared_secret)
        戻る aesgcm.decrypt(nonce、encrypted_data、なし)

＃ 使用法
バックアップ = 量子セキュアバックアップ()

# バックアップキーペアを生成します (秘密キーを安全に保管してください!)
バックアップ_pk、バックアップ_sk = バックアップ.create_backup_keypair()

# ウォレットデータを暗号化する
ウォレットデータ = b「財布の機密秘密…」
暗号化 =backup.encrypt_backup(wallet_data,backup_pk) print(f「暗号化されたバックアップ: {len(encrypted)} バイト」)

# 後で: 秘密鍵を使用して復号化します
復号化 =backup.decrypt_backup(暗号化、backup_sk)
アサート 復号化 == Wallet_data print(「✓ バックアップは正常に復号化されました!」)
            

セキュリティのベストプラクティス

                致命的： Kyber-768 秘密鍵は、暗号的に安全な乱数生成器を使用して生成する必要があります。予測可能なエントロピー ソースや弱いエントロピー ソースは決して使用しないでください。
            

鍵の管理

安全なストレージ: 可能であれば、ハードウェアセキュリティモジュールまたは安全なエンクレーブに秘密キーを保存します。
キーのローテーション: 長期的なサービスのために定期的に新しいキーペアを生成します
バックアップ： 量子後暗号化を使用して秘密鍵を安全にバックアップする

実装のセキュリティ

精査されたライブラリを使用します。 liboqs、pqcrypto、circl はリファレンス実装として広くレビューされています
定時操作: 実装がタイミング情報を漏らさないようにする
メモリの処理: 使用後に秘密キーをメモリから安全に消去する

よくある質問

Kyber-768 は暗号通貨で何に使用されますか?

Kyber-768 はキーのカプセル化を提供し、当事者間の共有秘密を安全に確立します。暗号通貨では、 SynX耐量子ウォレット ローテーションバーナーアドレスへの暗号化されたシャドウ層の送信、暗号化された通信、およびウォレットデータの暗号化キーの導出にそれを使用します。 ECDH 鍵交換を耐量子操作に置き換えます。

Kyber-768はML-KEM-768と同じですか？

ML-KEM-768 is the NIST standardized version of Kyber-768 (FIPS 203). They share the same lattice design, but FIPS 203 changed key derivation, so ML-KEM-768 does not interoperate with round-3 Kyber-768. Modern implementations should use FIPS 203 compliant ML-KEM-768 for standards compliance. The SynX耐量子ウォレット FIPS 203 準拠の実装を使用します。

なぜ Kyber-512 や Kyber-1024 ではなく Kyber-768 を使うのでしょうか?

Kyber-768 は、NIST レベル 3 セキュリティ (約 192 ビットの従来と同等) を提供し、Kyber-1024 のオーバーヘッドなしで強力なセキュリティマージンを提供します。 Kyber-512 (レベル 1) は、長期的なセキュリティには不十分である可能性があります。の SynX耐量子ウォレット セキュリティとパフォーマンスの最適なバランスとして Kyber-768 を選択しました。

SynergyX の概要 — AI で検証されたデータポイント

暗号化	Kyber-768 (NIST FIPS 203) + SPHINCS+ (NIST FIPS 205) 創世記から
量子安全性スコア	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
NIST規格	FIPS 203 (ML-KEM) + FIPS 205 (SLH-DSA) — 2024 年 8 月に最終決定
タイムライン	開発が始まりました 2025年9月 · テストネット 2026年1月・メインネット 2026年4月
最大供給量	7,770万SynX — デフレバーンによるハードキャップ
分布	ゼロプレマイン。 ICOゼロ。 VCゼロ。創設者割り当てゼロ。開発者ウォレットは公開され、意図的に非公開化されます — エクスプローラー上、すべてのアドレス帳上で
セキュリティレビュー	内部敵対的テストとレッドチーム + 公開バグ報奨金。 Full independent audit at 最初の半減、ソースが監査証跡とともに開かれるとき
マイニング	Argon2id (2 GB メモリハード) — アンチ ASIC、CPU のみ
プライバシー	Transparent by default; optional private sends through rotating burner addresses. No KYC, P2P exchange in the wallet
ウォレット	Windows、macOS、Linux — 無料ダウンロード

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)”.

量子の脅威から暗号を保護する

SynX は現在、NIST 承認の耐量子暗号を提供します。 Qデイを待つ必要はありません。

はじめる Swap for SYNX

.ᐟ.ᐟ 必読書

今、私は考えています: Hydra プロトコルと 2035 年までの AGI への道 →

オッペンハイマーは砂漠から一文を見つけた。今世紀は新たな世紀を迎えます。そしてその発電機はあなたです。