✍ SynergyX Research 📅 更新于: Sep 23, 2026 📂 学习中心 ⏱ ~7 分钟听

SynergyX
基于算法 NIST标准化 — FIPS 203 (ML-KEM/Kyber-768) 和 FIPS 205 （SLH-DSA/SPHINCS+）。发布于 2026 年 1 月 15 日。所有加密声明均可在链上验证 NIST 中国证监会文档。
零预开采。零 ICO。零风险投资。零创始人分配。 7770 万硬顶。开发者钱包是公开的，并且刻意是非私密的——在每个地址簿中，在浏览器上。这些都不需要你信任一个人。

Kyber-768 集成教程：完整实施指南

📅 Last updated: September 23, 2026 🎧 听：~6 分钟

Kyber-768（在 FIPS 203 中标准化为 ML-KEM-768）为安全密钥交换提供抗量子密钥封装。本教程通过多种语言的实际代码示例介绍完整的 Kyber-768 集成。这 SynX抗量子钱包 将这些模式用于所有密钥交换操作。

了解关键封装机制

密钥封装机制 (KEM) 使两方能够通过不安全的通道建立共享秘密：

密钥生成： Alice 生成密钥对（公钥、私钥）
封装： 鲍勃使用爱丽丝的公钥生成共享秘密和密文
解封装： 爱丽丝使用她的密钥从密文中恢复共享秘密

与 Diffie-Hellman 密钥交换不同，KEM 在内部生成共享秘密，而不是根据交换值进行计算。这简化了安全证明并实现了后量子结构。

为什么选择 KEM 而不是密钥交换？

经典的 Diffie-Hellman 需要计算离散对数，而量子计算机可以有效地解决这个问题。 Kyber-768 使用抵抗已知量子算法的晶格问题 (Module-LWE)。 KEM 构造提供 IND-CCA2 安全性——选择密文安全性的最强概念。

Kyber-768参数

范围	价值	描述
安全等级	NIST 3 级	~192 位经典安全性
公钥大小	1,184 字节	传送给发件人
密钥大小	2,400 字节	保密
密文大小	1,088 字节	封装的秘密
共享秘密尺寸	32字节	用于密钥派生

实现：Python

使用开放量子安全 (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：字节）-> 元组[字节，字节]：
        """ 为接收者封装共享密钥 参数：recipient_public_key：接收者的 Kyber-768 公钥 返回：(ciphertext, shared_secret) 元组 - ciphertext：1,088 字节，发送给接收者 - shared_secret：32 字节，用于加密 """
        密文，shared_secret = self._kem.encap_secret(recipient_public_key)
        返回 密文、共享秘密
    
    定义 解封（自身，密文：字节，secret_key：字节）->字节：
        """ 解封装以恢复共享密钥 参数： ciphertext：封装后的 1,088 字节密文 Secret_key：您的 Kyber-768 密钥 返回：shared_secret：32 字节，与封装者的密钥相同 """
        # 创建新实例用于解封装
        kem = oqs.KeyEncapsulation（self.ALGORITHM，secret_key）
        返回 kem.decap_secret(密文)

# 用法示例
定义 演示密钥交换(): Kyber = 凯伯768()
    
    # Alice 生成她的密钥对
    alice_pk, alice_sk = Kyber.generate_keypair() print(f“Alice 公钥：{len(alice_pk)} 字节”)
    
    # Bob 为 Alice 封装了一个秘密
    密文， bob_secret = Kyber.encapsulate(alice_pk) print(f“密文：{len(密文)}字节”) 打印(f“鲍勃的共享秘密：{bob_secret.hex()[:32]}...”)
    
    # Alice 解封装得到相同的秘密
    alice_secret = Kyber.decapsulate(密文, alice_sk) print(f“爱丽丝的共享秘密：{alice_secret.hex()[:32]}...”)
    
    # 验证它们是否匹配
    断言 alice_secret == bob_secret 打印（“✓ 密钥交换成功！”)

if __名字__ == “__主要的__”: demo_key_exchange()
            

实现：Rust

使用 pqcrypto 箱进行本机 Rust 实现：

// 货物.toml:
// [依赖项]
// pqcrypto-kyber =“0.8”
// pqcrypto-traits = "0.3"

使用 pqcrypto_kyber::kyber768；
使用 pqcrypto_traits::kem::{密文、PublicKey、SecretKey、SharedSecret}；

酒吧结构 Kyber768Kem;

暗示 Kyber768Kem {
    /// 生成新的 Kyber-768 密钥对
    酒吧 fn 生成密钥对() -> (kyber768::PublicKey, kyber768::SecretKey) { kyber768::keypair() }
    
    /// 封装共享秘密
    酒吧 fn 封装( public_key: &kyber768::PublicKey ) -> (kyber768::密文, kyber768::SharedSecret) { kyber768::encapsulate(public_key) }
    
    /// 解封装以恢复共享秘密
    酒吧 fn 解封( 密文: &kyber768::Ciphertext, Secret_key: &kyber768::SecretKey ) -> kyber768::SharedSecret { kyber768::decapsulate(ciphertext, Secret_key) } }

fn 主要的() {
    // Alice 生成密钥对
    让 (alice_pk, alice_sk) = Kyber768Kem::generate_keypair();
    
    // Bob 封装
    让 （密文，bob_secret）= Kyber768Kem::封装(&alice_pk);
    
    // Alice 解封装
    让 爱丽丝秘密= Kyber768Kem::decapsulate(&ciphertext, &alice_sk);
    
    // 验证匹配
    断言_eq！( bob_secret.as_bytes(), alice_secret.as_bytes() );打印！（“✓ 密钥交换成功！”);
}
            

实施：去

使用 Cloudflare 中的circl 库：

// 获取 github.com/cloudflare/circl

包裹 主要的

进口 (
    “字节”
    “FMMT”
    “github.com/cloudflare/circl/kem/Kyber/kyber768”
)

功能 主要的() {
    // Alice 生成密钥对
    alicePublic，alicePrivate，err := kyber768.GenerateKeyPair(nil)
    if err != nil { 恐慌(err) }
    
    // Bob 封装
    密文，bobSecret，err := kyber768.Encapsulate(nil，alicePublic)
    if err != nil { 恐慌(err) }
    
    // Alice 解封装
    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”, len(aliceSecret)) }
            

实际应用：旋转燃烧器地址

这就是 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 的后量子旋转燃烧器地址 每笔交易都有一个新地址，从未重用 - 击败地址重用聚类链分析取决于 """
    
    定义 __初始化__（自我）：自我.Kyber = 凯伯768()
    
    定义 生成接收者密钥（自我）-> 元组[字节，字节]：
        """ 接收方生成长期扫描密钥对 公开密钥已公开（例如，在网站上） 秘密密钥保密以检测支付情况 """
        返回 self.Kyber.generate_keypair()
    
    定义 创建燃烧器付款（自我，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(), 密文,  # 包含在交易中
            共享秘密）
    
    定义 检测燃烧器付款（ self，receiver_secret_key：字节，密文：字节）->字节：
        """ 接收方扫描交易以检测传入的刻录机付款 参数：receiver_secret_key：接收方的密钥 密文：来自交易元数据 返回：one_time_address：如果这与 tx 输出匹配，则它是给我们的 """
        # 解封装以恢复共享秘密
        Shared_secret = self.Kyber.decapsulate(密文,receiver_secret_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()

＃ 用法
燃烧器= 燃烧器地址()

# Bob 发布他的扫描公钥
bob_pk, bob_sk = burner.generate_receiver_keys()

# Alice 发送到一个新的燃烧器地址
地址，密文，_ = burner.create_burner_ payment(bob_pk) print(f“发送至：{address.decode()}”)

# Bob 扫描交易并找到他的付款
检测到=burner.detect_burner_ payment（bob_sk，密文）
断言 检测到==地址打印(“✓ 检测到付款！”)
            

披露：短暂的视图密钥

刻录机地址隐藏了收件人。但迟早你必须证明发生了一笔付款——支付给审计师、交易对手、法院。那一刻是大多数隐私链悄悄交出一切的时刻。

Zcash 查看密钥是永久且可转让的：披露一次，您就授予持有者及其将其传递给任何人终身监视权。 SynX 会发出过期的能力。这 临时视图键 范围仅限于单个事务并存在 三十分钟, then it is gone — not revoked, not archived, no record left to subpoena.

披露需要满足两件事： 交易哈希 和 查看键。两者都没有透露任何信息。即使同时握住两者，表面的还是 仅金额 — never the graph. Not who paid whom, not balances, not history. The identity layer is never assembled in the first place.

如果您要针对 SynX 进行集成，请进行相应的设计：永远不要假设视图密钥可以存储、稍后重播或向前委派。过期的能力，而不是永久的身份授予。

实际应用：加密钱包备份

使用 Kyber-768 加密钱包备份，以抵御量子计算机的攻击：

进口 os
从 密码学.hazmat.primitives.ciphers.aead 进口 AESGCM

班级 量子安全备份:
    """使用Kyber-768密钥封装加密钱包备份密文只能使用Kyber密钥解密，为长期存储提供后量子安全性。"""
    
    定义 __初始化__（自我）：自我.Kyber = 凯伯768()
    
    定义 创建备份密钥对（自我）-> 元组[字节，字节]：
        """ 生成用于备份加密的密钥对 安全地存储密钥（例如，硬件安全模块） 创建备份时使用公钥 """
        返回 self.Kyber.generate_keypair()
    
    定义 加密备份( self, wallet_data: 字节, backup_public_key: 字节 ) -> 字节:
        """ 加密钱包数据进行后量子安全备份返回：加密备份：ciphertext_length(4) + ciphertext + nonce(12) + crypto_data """
        # 封装导出加密密钥
        密文，shared_secret = self.Kyber.encapsulate( backup_public_key )
        
        # 使用共享密钥作为 AES-256-GCM 密钥
        aes_key = 共享秘密  # 已经是32字节了
        aesgcm = AESGCM(aes_key)
        
        # 生成随机数并加密
        nonce = os.urandom(12) crypto_data = aesgcm.encrypt(nonce, wallet_data, None)
        
        # 打包：ciphertext_len + ciphertext + nonce + crypto_data
        ct_len = len(密文).to_bytes(4, '大的')
        返回 ct_len + 密文 + 随机数 + 加密数据
    
    定义 解密备份( self, crypto_backup: bytes, backup_secret_key: bytes ) -> 字节:
        """ 使用 Kyber 密钥解密钱包备份 """
        # 解压
        ct_len = int.from_bytes(加密_备份[:4], '大的') 密文 = 加密_备份[4:4+ct_len] 随机数 = 加密_备份[4+ct_len:4+ct_len+12] 加密数据 = 加密_备份[4+ct_len+12:]
        
        # 解封装恢复密钥
        Shared_secret = self.Kyber.decapsulate( 密文, backup_secret_key )
        
        # 解密
        aesgcm = AESGCM(shared_secret)
        返回 aesgcm.decrypt（随机数，加密数据，无）

＃ 用法
备份= 量子安全备份()

# 生成备份密钥对（安全存储密钥！）
backup_pk, backup_sk = backup.create_backup_keypair()

# 加密钱包数据
钱包数据 = b“敏感的钱包秘密……”
加密 = backup.encrypt_backup(wallet_data, backup_pk) print(f“加密备份：{len(加密)} 字节”)

# 稍后：用密钥解密
解密 = 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-768 而不是 Kyber-512 或 Kyber-1024？

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 月
最大供应量	7770 万 SynX — 带有通货紧缩烧伤的硬顶
分配	零预开采。零 ICO。零风险投资。零创始人分配。开发者钱包公开且刻意非私有——在浏览器上，在每个地址簿中
安全审查	内部对抗性测试和红队+公共错误赏金。全面独立审计第一次减半，当源打开并带有审计跟踪时
矿业	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-Day。

开始使用 Swap for SYNX

.ᐟ.ᐟ 必读

现在我正在思考：Hydra 协议和 2035 年通往 AGI 的道路 →

奥本海默从沙漠中得到了一句话。这个世纪将迎来一个不同的世纪——而发电机就是你。