Schnorr 簽名在比特幣隱私保護的進階應用：從理論到實際部署

概述與學習目標

比特幣在 2021 年 11 月的 Taproot 升級中正式採用了 Schnorr 簽名，這一密碼學創新不僅提升了交易驗證效率，更為比特幣隱私保護技術開闢了全新的可能性。本指南深入探討 Schnorr 簽名如何應用於比特幣隱私保護的各個層面，從基礎的密碼學特性到複雜的閾值簽名、MuSig2 多簽名聚合、GRIN 隱私協議整合，以及 PTLC（Point Time Locked Contracts）在閃電網路中的隱私應用。

本指南涵蓋的核心主題包括：Schnorr 簽名與 ECDSA 的密碼學差異分析、Schnorr 線性簽名驗證的隱私優勢、MuSig2 協議的多簽名聚合原理與實現、閾值簽名（Threshold Signature）在比特幣隱私錢包中的應用、Schnorr 簽名與 CoinJoin 的結合優化、PTLC 在閃電網路隱私中的角色，以及 Taproot 地址的隱私性深度分析。

第一章：Schnorr 簽名密碼學基礎回顧

1.1 從 ECDSA 到 Schnorr 的技術躍遷

比特幣自 2009 年問世以來，一直使用 ECDSA（橢圓曲線數位簽名演算法）作為其主要的簽名方案。雖然 ECDSA 在安全性方面經過了時間的檢驗，但其固有的數學結構限制了在隱私和效率方面的進一步優化。Schnorr 簽名的引入標誌著比特幣密碼學的一次重大升級。

ECDSA 簽名的局限性

ECDSA 的簽名格式是 (r, s)，其中 r 是橢圓曲線點的 x 座標對曲線階取模的結果，s 是透過特定公式計算得出的標量。這種非線性的簽名結構帶來了幾個固有的限制：

首先，ECDSA 簽名無法直接聚合。當一筆交易包含多個輸入時，每個輸入都需要獨立的 ECDSA 簽名。這些簽名之間沒有任何密碼學關聯，外部觀察者可以清晰地識別出這是一筆多簽名交易，以及各個輸入的數量。

其次，ECDSA 簽名不具有簽名者的可識別性。在多簽名場景中，雖然可以驗證 n 個簽名者中的 m 個同意了交易，但無法確定具體是哪 m 個簽名者參與了簽名過程。這種模糊性在某些場景下是有價值的隱私特性，但 ECDSA 無法原生支持。

第三，ECDSA 的批量驗證效率較低。雖然可以對多個簽名進行批量驗證，但這種批量驗證需要對每個簽名進行獨立的數學運算，效率提升有限。

Schnorr 簽名的突破性特性

Schnorr 簽名採用了完全不同的數學結構，其突破性特性包括：

線性簽名驗證：Schnorr 簽名的驗證等式是 s·G = R + e·P，其中 R 是隨機點，e 是消息和公鑰的哈希，s 是標量。這種線性結構使得多個簽名可以通過簡單的加法運算進行聚合。

密鑰聚合：多個簽名者的私鑰可以聚合成一個虛擬的聚合私鑰，對應的聚合公鑰是各個公鑰的簡單相加。這意味著 n-of-n 多簽名可以用一個 64 位元組的簽名來表示，而不是 n 個獨立的 71-73 位元組 ECDSA 簽名。

批量驗證的線性加速：多個 Schnorr 簽名的驗證可以被並行化處理，理論上可以實現接近 O(1) 的驗證效率提升。

1.2 BIP-340 規範的核心條款

比特幣的 Schnorr 簽名實現遵循 BIP-340 標準，該標準定義了簽名生成、驗證和公鑰格式的具體規範。

公鑰格式

BIP-340 公鑰是 secp256k1 曲線上的一個點的 x 座標，長度固定為 32 位元組。與 ECDSA 的壓縮公鑰格式（33 位元組）相比，BIP-340 公鑰節省了一個位元組。

BIP-340 對公鑰有以下限制：

• 只使用點的 x 座標作為公鑰，y 座標透過曲線方程推導
• 如果推導出的 y 座標是奇數，則對應的公鑰無效
• 這確保了每個公鑰都有唯一的表示方式

這種公鑰格式的選擇是 BIP-340 的重要設計決策。雖然這意味著無法直接從公鑰恢復完整的橢圓曲線點坐標，但這大大簡化了簽名協議的實現。

簽名格式

BIP-340 簽名由兩個部分組成：

• s（32 位元組）：標量值
• R 的 x 座標（32 位元組）：隨機點的 x 座標

總簽名長度為 64 位元組，比大多數 ECDSA 簽名（71-73 位元組）更緊湊。這種緊湊的簽名格式減少了交易資料的大小，降低了區塊空間的消耗。

簽名生成演算法

BIP-340 簽名生成的標準流程如下：

def schnorr_sign(message: bytes, private_key: int, aux_randomness: bytes) -> tuple:
    """
    BIP-340 Schnorr 簽名生成
    
    參數:
        message: 要簽署的消息（32位元組哈希）
        private_key: 私鑰（32位元組整數）
        aux_randomness: 輔助隨機數（32位元組）
    
    返回:
        (signature, recov_id): 簽名和恢復ID
    """
    # 步驟 1：從私鑰推導公鑰
    P = private_key * G
    
    # 步驟 2：生成隨機標量 k
    # 使用 RFC 6979 確定性生成
    k = generate_k(private_key, message, aux_randomness)
    
    # 步驟 3：計算隨機點 R = k*G
    R = k * G
    
    # 步驟 4：如果 R 的 y 座標是奇數，取反 k
    if R.y % 2 != 0:
        k = curve_order - k
        R = -R
    
    # 步驟 5：計算挑战 e = Hash(R.x || P.x || message)
    e = int_from_bytes(hash_function(
        R.x.to_bytes(32, 'big') +
        P.x.to_bytes(32, 'big') +
        message
    )) % curve_order
    
    # 步驟 6：計算回覆 s = k + e*d mod n
    s = (k + e * private_key) % curve_order
    
    # 構建簽名：(R.x, s)
    signature = R.x.to_bytes(32, 'big') + s.to_bytes(32, 'big')
    
    return signature

簽名驗證演算法

BIP-340 簽名驗證的標準流程如下：

def schnorr_verify(message: bytes, public_key: bytes, signature: bytes) -> bool:
    """
    BIP-340 Schnorr 簽名驗證
    
    參數:
        message: 消息哈希（32位元組）
        public_key: 公鑰（32位元組）
        signature: 簽名（64位元組）
    
    返回:
        bool: 驗證是否成功
    """
    # 解析簽名
    sig_Rx = int_from_bytes(signature[0:32])
    s = int_from_bytes(signature[32:64])
    
    # 解析公鑰
    Px = int_from_bytes(public_key)
    
    # 範圍檢查
    if sig_Rx >= curve_prime or s >= curve_order:
        return False
    
    # 推導 R 點
    # R.y 可以從曲線方程 y² = x³ + 7 推導
    Ry_squared = (sig_Rx**3 + 7) % curve_prime
    Ry = mod_sqrt(Ry_squared, curve_prime)
    
    # 選擇正確的 y（使 R.y 為偶數）
    if Ry % 2 != 0:
        Ry = curve_prime - Ry
    
    R = Point(sig_Rx, Ry)
    
    # 計算挑战 e
    e = int_from_bytes(hash_function(
        sig_Rx.to_bytes(32, 'big') +
        Px.to_bytes(32, 'big') +
        message
    )) % curve_order
    
    # 驗證：s*G == R + e*P
    lhs = s * G
    rhs = R + e * P
    
    return lhs == rhs

1.3 Schnorr 簽名的數學安全性

Schnorr 簽名的安全性基於以下幾個計算假設：

離散對數假設（Discrete Logarithm Assumption）

給定橢圓曲線點 G 和公鑰 P = d·G，求解私鑰 d 在計算上不可行。secp256k1 曲線的這個問題預計需要約 2^128 次運算才能解決，即使使用 Pollard's rho 算法。

隨機預言機模型（Random Oracle Model）

BIP-340 簽名中的哈希函數被建模為隨機預言機，這意味著哈希輸出在計算上與隨機位元串不可區分。這允許將離散對數問題的安全性轉化為簽名方案的安全性證明。

Forking Lemma 分析

Schnorr 簽名的安全性可以通過分叉引理（Forking Lemma）進行形式化分析。粗略地說，如果存在一個攻擊者可以偽造 Schnorr 簽名，則可以通過「分叉」該攻擊者的執行來解決離散對數問題。

在隨機預言機模型下，Schnorr 簽名的安全性可以歸約為離散對數問題的困難性。具體來說，伪造 Schnorr 簽名的成功概率與解決 ECDLP 的效率成正比。

第二章：MuSig2 多簽名聚合協議

2.1 MuSig2 協議概述

MuSig2 是由 Blockstream 開發的 Schnorr 多簽名聚合協議，允許 n 個簽名者共同創建一個可以由單個聚合公鑰驗證的簽名。與比特幣傳統的 P2SH 多簽名相比，MuSig2 提供了顯著的隱私和效率提升。

傳統多簽名的問題

比特幣的傳統多簽名（2-of-3、3-of-5 等）使用 P2SH 或 P2WSH 地址格式。這種地址格式將多簽名腳本哈希到區塊鏈上，外部觀察者可以清楚地識別這是一個多簽名地址。

例如，一個 2-of-3 P2SH 地址的格式為：

OP_2 <pubkey1> <pubkey2> <pubkey3> OP_3 OP_CHECKMULTISIG

外部觀察者可以從區塊鏈上讀取這個腳本，得知這是一個 2-of-3 的多簽名設置。這種透明度可能暴露以下信息：

• 這是一個需要多方同意才能花費的共享錢包
• 具體的門檻設置（多少-of-多少）
• 各個簽名者的公鑰

MuSig2 的解決方案

MuSig2 採用密碼學聚合的方式，將多個簽名者的貢獻合併成一個簽名。從區塊鏈外觀看，聚合簽名與普通的單簽名完全無法區分。

聚合公鑰的生成過程：

import hashlib

def aggregate_pubkeys(pubkeys: list) -> bytes:
    """
    生成 MuSig2 聚合公鑰
    
    參數:
        pubkeys: 各簽名者的公鑰列表
    
    返回:
        bytes: 聚合公鑰（32位元組）
    """
    # 計算各公鑰的係數
    coefficients = []
    for i, pk in enumerate(pubkeys):
        # 系數 = Hash(聚合公鑰 || 索引)
        prefix = b'musig-aggressive-nonce-gen' + bytes([i])
        coeff_hash = hashlib.sha256(prefix + pk)
        coefficient = int_from_bytes(coeff_hash) % curve_order
        coefficients.append(coefficient)
    
    # 聚合公鑰 = 係數1*P1 + 係數2*P2 + ...
    Q = Point.infinity()
    for pk_int, coeff in zip(pubkeys, coefficients):
        P = lift_x(pk_int)
        Q = Q + coeff * P
    
    return Q.x.to_bytes(32, 'big')

2.2 MuSig2 簽名流程

MuSig2 的簽名流程分為兩個主要階段：準備階段和簽名階段。

準備階段（Nonce Generation）

每個簽名者需要生成一個隨機的「nonce」（一次性隨機數），並與其他簽名者分享。這些 nonce 用於後續的簽名生成。

def generate_nonces(private_key: int, session_id: bytes, round: int) -> tuple:
    """
    生成 MuSig2 nonce
    
    參數:
        private_key: 簽名者私鑰
        session_id: 唯一的會話ID
        round: 輪次（1或2）
    
    返回:
        (R_i, R_i_commitment): Nonce 和其承諾
    """
    # 生成基礎 nonce
    nonce_seed = hashlib.sha256(
        private_key.to_bytes(32, 'big') + session_id + bytes([round])
    ).digest()
    
    # 使用 RFC 6979 從 seed 生成確定性 nonce
    k = int_from_bytes(nonce_seed) % curve_order
    
    # 計算 R_i = k*G
    R = k * G
    
    # 生成 commitment（用於第二輪之前的承諾）
    commitment = hashlib.sha256(R.x.to_bytes(32, 'big'))
    
    return (R.x.to_bytes(32, 'big'), k, commitment)

第一輪：收集 Nonce 承諾

1. 每個簽名者計算自己的 nonce commitment
2. 所有簽名者相互交換 nonce commitments
3. 這一輪確保了簽名的不可偽造性

第二輪：收集 Nonce 並生成部分簽名

1. 每個簽名者揭示自己的 actual nonce
2. 所有簽名者計算聚合 nonce R_agg
3. 每個簽名者計算自己的部分簽名

def musig_partial_sign(
    private_key: int,
    message: bytes,
    aggregate_pubkey: bytes,
    nonce: int,
    other_nonces: list,
    pubkeys: list,
    my_index: int
) -> int:
    """
    生成 MuSig2 部分簽名
    
    參數:
        private_key: 簽名者私鑰
        message: 消息哈希
        aggregate_pubkey: 聚合公鑰
        nonce: 該簽名者的 nonce（k值）
        other_nonces: 其他簽名者的 nonce 列表
        pubkeys: 所有簽名者的公鑰列表
        my_index: 該簽名者的索引
    
    返回:
        int: 部分簽名 s_i
    """
    # 計算所有 nonce
    all_nonces = other_nonces.copy()
    all_nonces.insert(my_index, nonce)
    
    # 計算聚合 nonce R_agg
    R_agg = Point.infinity()
    for nonce_val in all_nonces:
        R_agg = R_agg + nonce_val * G
    
    # 選擇正確的 R_agg（使 y 座標為偶數）
    if R_agg.y % 2 != 0:
        R_agg = -R_agg
    
    # 計算 challenge e
    e = int_from_bytes(hashlib.sha256(
        R_agg.x.to_bytes(32, 'big') +
        aggregate_pubkey +
        message
    )) % curve_order
    
    # 計算係數 a_i
    a_i = int_from_bytes(hashlib.sha256(
        aggregate_pubkey + pubkeys[my_index]
    )) % curve_order
    
    # 計算部分簽名 s_i
    s_i = (nonce + e * a_i * private_key) % curve_order
    
    return s_i

第三輪：聚合部分簽名

所有簽名者將自己的部分簽名發送給一個聚合者（可以是任意方），聚合者計算最終簽名：

def aggregate_signatures(partial_signatures: list, R_agg: Point) -> tuple:
    """
    聚合所有部分簽名
    
    參數:
        partial_signatures: 所有部分簽名列表
        R_agg: 聚合 nonce 點
    
    返回:
        tuple: 最終 Schnorr 簽名 (R.x, s)
    """
    # s = sum(s_i) mod n
    s = sum(partial_signatures) % curve_order
    
    # 最終簽名
    signature = R_agg.x.to_bytes(32, 'big') + s.to_bytes(32, 'big')
    
    return signature

2.3 MuSig2 與比特幣 Taproot 的整合

MuSig2 與 Taproot 的結合為比特幣多簽名錢包帶來了革命性的隱私提升。

Taproot 的 Schnorr 聚合能力

Taproot 地址格式支持將多個花費條件（包括多簽名門檻）合併到一個 Merkle 樹結構中。在正常情況下（滿足某個門檻條件），花費者只需要提供聚合簽名即可。

例如，一個 2-of-3 的 MuSig2 + Taproot 設置：

情況 1（正常）：Alice 和 Bob 共同簽署
- 使用 MuSig2 聚合簽名
- 區塊鏈上只看到一個普通的單簽名交易
- 無法識別這是一個多簽名錢包

情況 2（緊急）：使用預設的腳本路徑
- 花費者提供葉片腳本和相關見證
- 區塊鏈上看到使用了「腳本路徑」
- 但無法得知其他可能的腳本條件

安全性考量

MuSig2 的安全性依賴於nonce生成的正確性。以下是關鍵的安全要求：

1. Nonce 不能重用：相同的 nonce 只能用於一次簽名，否則會導致私鑰泄露
2. Nonce 必須隨機：nonce 的選擇必須在計算上與攻擊者的預測隔離
3. Session 隔離：不同的簽名會話必須使用不同的 session ID

MuSig2 採用了兩輪通訊的設計來提高 nonce 生成的靈活性，即使在高風險的離線環境中也能安全使用。

第三章：閾值簽名的隱私應用

3.1 閾值簽名的基本概念

閾值簽名（Threshold Signature）是一種密碼學技術，允許 n 個參與者中的任意 t 個共同產生一個有效的簽名，而不需要所有 n 個參與者都在線或同意簽名。

與 MuSig2 的區別

應用場景

門限簽名特別適合以下場景：

家庭遺產錢包：父母和孩子各持有一把私鑰分片，需要 2-of-3 的門限設置。孩子無法單獨盜取資金，但父母去世後，孩子可以與其他家屬一起恢復錢包。

企業財務管理：企業的比特幣儲備由多個高管共同管理，需要 3-of-5 的門限設置。任何單一高管無法挪用資金，但多數高管可以進行大額轉帳。

交易所冷錢包：交易所的比特幣冷錢包採用 2-of-3 門限簽名，分別存放在離線電腦、保險箱和外部審計機構。

3.2 Pedersen 門限方案的原理

比特幣門限簽名的一個主要方案是基於 Pedersen 承諾和 Feldman 可驗證秘密分享（VSS）的組合。

秘密分享基礎

Shamir 秘密分享（SSS）是一種將秘密分片給多個參與者的密碼學技術。一個 (t, n) Shamir 秘密分享將秘密 s 分成 n 個分片，使得：

• 任意 t 個分片可以恢復秘密 s
• 少於 t 個分片無法獲得任何關於 s 的信息

def shamir_split(secret: int, t: int, n: int) -> list:
    """
    Shamir 秘密分享分片
    
    參數:
        secret: 要分享的秘密
        t: 門限值
        n: 總分片數
    
    返回:
        list: n 個分片
    """
    # 生成 t-1 個隨機係數
    coefficients = [secret] + [random.randint(1, curve_order - 1) for _ in range(t - 1)]
    
    # 在有限域上構建多項式 f(x)
    shares = []
    for x in range(1, n + 1):
        # f(x) = secret + a1*x + a2*x² + ... + a_{t-1}*x^{t-1}
        y = 0
        for i, coeff in enumerate(coefficients):
            y = (y + coeff * (x ** i)) % curve_order
        shares.append((x, y))
    
    return shares

def shamir_reconstruct(shares: list) -> int:
    """
    使用 Lagrange 插值重建秘密
    
    參數:
        shares: 至少 t 個分片
    
    返回:
        int: 恢復的秘密
    """
    secret = 0
    t = len(shares)
    
    for i in range(t):
        xi, yi = shares[i]
        
        # 計算 Lagrange 係數
        numerator = 1
        denominator = 1
        for j in range(t):
            if i != j:
                xj, _ = shares[j]
                numerator = (numerator * (-xj)) % curve_order
                denominator = (denominator * (xi - xj)) % curve_order
        
        lagrange_coeff = numerator * mod_inverse(denominator, curve_order) % curve_order
        
        # 重建秘密
        secret = (secret + yi * lagrange_coeff) % curve_order
    
    return secret

Feldman VSS 擴展

基本的 Shamir 秘密分享的一個問題是，每個分片持有者可以謊報自己的分片來干擾秘密恢復過程。Feldman 的可驗證秘密分享（VSS）通過讓分片者公開承諾來解決這個問題。

def feldman_vss_commit(coefficients: list) -> list:
    """
    為 Shamir 係數生成 Feldman 承諾
    
    參數:
        coefficients: Shamir 多項式係數列表
    
    返回:
        list: 承諾列表
    """
    commitments = []
    for coeff in coefficients:
        # C_i = coeff_i * G
        commitment = coeff * G
        commitments.append(commitment)
    
    return commitments

def verify_shares(shares: list, commitments: list) -> bool:
    """
    驗證分片的正確性
    
    參數:
        shares: 分片列表
        commitments: Feldman 承諾列表
    
    返回:
        bool: 驗證是否成功
    """
    for x, y in shares:
        # 驗證 f(x) == sum(coeff_i * x^i)
        left = y * G
        right = Point.infinity()
        
        for i, commitment in enumerate(commitments):
            right = right + commitment * (x ** i)
        
        if left != right:
            return False
    
    return True

3.3 門限 Schnorr 簽名的實現

將門限機制應用於 Schnorr 簽名需要特殊的密碼學協議。一個常用的方案是基於 Pedersen 承諾的離線門限簽名。

門限簽名生成流程

def threshold_schnorr_sign(
    secret_shares: list,
    public_key_shares: list,
    x_coords: list,
    message: bytes,
    threshold: int
) -> tuple:
    """
    門限 Schnorr 簽名生成
    
    參數:
        secret_shares: 該簽名者的秘密分片
        public_key_shares: 所有參與者的公鑰分片
        x_coords: 各參與者的 x 座標
        message: 消息哈希
        threshold: 門限值 t
    
    返回:
        tuple: 門限簽名 (R.x, s)
    """
    # 第一階段：分發隨機數承諾
    k_shares = []
    R_commitments = []
    
    for i, (_, d_i) in enumerate(secret_shares):
        # 生成 nonce 分片
        k_i = random.randint(1, curve_order - 1)
        R_i = k_i * G
        
        k_shares.append(k_i)
        R_commitments.append(R_i.x.to_bytes(32, 'big'))
    
    # 廣播 R_commitments 並接收其他人的承諾
    
    # 第二階段：收集所有 R 值
    all_R_points = []
    for i in range(len(secret_shares)):
        R_i = lift_x(int_from_bytes(R_commitments[i]))
        all_R_points.append(R_i)
    
    # 計算聚合 R
    R_agg = sum(all_R_points[1:], all_R_points[0])
    
    # 選擇正確的 R（y 座標為偶數）
    if R_agg.y % 2 != 0:
        R_agg = -R_agg
    
    # 計算 challenge e
    P_agg_x = calculate_aggregate_pubkey_x(public_key_shares)
    e = int_from_bytes(hashlib.sha256(
        R_agg.x.to_bytes(32, 'big') +
        P_agg_x +
        message
    )) % curve_order
    
    # 第三階段：計算部分簽名
    # 每個參與者計算 s_i = k_i + e * d_i * Lagrange_i
    partial_sigs = []
    
    for i in range(len(secret_shares)):
        _, d_i = secret_shares[i]
        
        # 計算 Lagrange 係數
        lagrange_i = calculate_lagrange_coefficient(x_coords[i], x_coords)
        
        # s_i = k_i + e * d_i * λ_i
        s_i = (k_shares[i] + e * d_i * lagrange_i) % curve_order
        partial_sigs.append(s_i)
    
    # 第四階段：聚合部分簽名
    s = sum(partial_sigs) % curve_order
    
    return (R_agg.x.to_bytes(32, 'big'), s.to_bytes(32, 'big'))

門限簽名驗證

門限簽名的驗證與普通 Schnorr 簽名驗證完全相同。驗證者只需要聚合公鑰和簽名，不需要知道門限設置的細節。

def verify_threshold_signature(
    message: bytes,
    aggregate_pubkey: bytes,
    signature: tuple
) -> bool:
    """
    驗證門限簽名（與普通 Schnorr 驗證相同）
    """
    R_x, s = signature
    
    # 推導 R 點
    R = lift_x(int_from_bytes(R_x))
    if R is None:
        return False
    
    # 計算 challenge
    e = int_from_bytes(hashlib.sha256(
        R_x +
        aggregate_pubkey +
        message
    )) % curve_order
    
    # 驗證
    P = lift_x(int_from_bytes(aggregate_pubkey))
    lhs = s * G
    rhs = R + e * P
    
    return lhs == rhs

3.4 門限簽名在隱私錢包中的應用

門限簽名錢包為比特幣隱私和安全性提供了獨特的優勢：

資產隔離的不可識別性

使用門限簽名的錢包從區塊鏈外觀看，與普通單簽名錢包完全無法區分。這提供了：

• 資金控制結構的隱藏
• 簽名者數量的隱藏
• 門限設置的隱藏

攻擊者即使知道這是一個門限錢包，也無法確定具體的門限設置是 2-of-3、3-of-5 還是其他配置。

防止單點故障

與傳統多簽名相比，門限簽名不需要在區塊鏈上存儲多個公鑰，這減少了：

• 鏈上資料量
• 錢包恢復的複雜度
• 遷移到新地址時的風險

地理分佈的靈活性

門限簽名分片可以存放在不同地理位置，無需任何方知道完整的私鑰。這種設置對於：

• 家族遺產規劃
• 企業財務管理
• 機構托管服務

第四章：Schnorr 簽名與 CoinJoin 的結合

4.1 CoinJoin 隱私的密碼學瓶頸

CoinJoin 是比特幣隱私保護的核心技術之一，但其傳統實現存在一些密碼學限制。當使用 ECDSA 簽名時，CoinJoin 交易的每個參與者都需要提供獨立的簽名，這些簽名的數量和格式暴露了參與者的數量和身份結構。

ECDSA CoinJoin 的可識別性

一個有 n 個參與者的 CoinJoin 交易包含 n 個獨立的 ECDSA 簽名。雖然無法直接識別每個簽名屬於哪個輸入，但以下信息仍然可能泄露：

• 簽名數量與參與者數量的對應關係
• 簽名格式的一致性或差異性
• 某些錢包軟體的簽名特徵

傳統 CoinJoin 的改進空間

傳統改進方法包括：

• 使用更復雜的 CoinJoin 輪次設計
• 增加參與者數量
• 混合不同金額的 UTXO

但這些方法都有局限性，無法從根本上解決密碼學層面的信息泄露。

4.2 Schnorr 聚合 CoinJoin 的實現

Schnorr 簽名的線性特性允許創建真正聚合的 CoinJoin 交易，其中所有參與者的簽名被合併成一個區塊鏈上無法區分的簽名。

MuSig-CoinJoin 協議設計

def musig_coinjoin(
    participants: list,
    input_amounts: list,
    output_addresses: list,
    fee: int
) -> tuple:
    """
    MuSig CoinJoin 交易構造
    
    參數:
        participants: 參與者公鑰列表
        input_amounts: 各參與者的輸入金額
        output_addresses: 輸出地址列表
        fee: 礦工費用
    
    返回:
        tuple: (交易, 聚合公鑰)
    """
    # 步驟 1：計算聚合公鑰
    Q_agg = aggregate_pubkeys(participants)
    
    # 步驟 2：構造 CoinJoin 交易
    # 計算每個參與者的輸出金額
    total_input = sum(input_amounts)
    per_person_output = (total_input - fee) // len(participants)
    
    # 創建交易輸出
    tx_outputs = []
    for addr in output_addresses:
        tx_outputs.append(create_tx_output(addr, per_person_output))
    
    # 步驟 3：生成 MuSig Nonce
    all_R_commitments = []
    all_R_values = []
    
    for i, pk in enumerate(participants):
        R_commit, R_val = generate_nonces(pk, session_id=f'coinjoin-{tx_id}', round=i)
        all_R_commitments.append(R_commit)
        all_R_values.append(R_val)
    
    # 交換並驗證 commitments
    
    # 步驟 4：計算聚合 R
    R_agg = sum(all_R_values) * G
    if R_agg.y % 2 != 0:
        R_agg = -R_agg
    
    # 步驟 5：計算 challenge
    tx_message = serialize_transaction(tx_inputs, tx_outputs)
    e = int_from_bytes(hashlib.sha256(
        R_agg.x.to_bytes(32, 'big') +
        Q_agg +
        tx_message
    )) % curve_order
    
    # 步驟 6：各參與者計算部分簽名
    partial_signatures = []
    
    for i, (pk, sk) in enumerate(participants):
        a_i = int_from_bytes(hashlib.sha256(Q_agg + pk)) % curve_order
        s_i = (all_R_values[i] + e * a_i * sk) % curve_order
        partial_signatures.append(s_i)
    
    # 步驟 7：聚合簽名
    s = sum(partial_signatures) % curve_order
    
    signature = R_agg.x.to_bytes(32, 'big') + s.to_bytes(32, 'big')
    
    # 返回完整交易
    transaction = build_transaction(tx_inputs, tx_outputs, signature, Q_agg)
    
    return (transaction, Q_agg)

4.3 批量 CoinJoin 的優化

Schnorr 簽名的另一個優勢是支持批量驗證，這對於高吞吐量的 CoinJoin 服務提供商具有重要意義。

批量驗證原理

多個 Schnorr 簽名的驗證可以透過以下方式加速：

def batch_verify_schnorr(
    messages: list,
    pubkeys: list,
    signatures: list
) -> bool:
    """
    批量驗證多個 Schnorr 簽名
    
    時間複雜度: O(n) 橢圓曲線加法 + O(1) 標量乘法
    相比逐個驗證的 O(n) 標量乘法有顯著提升
    """
    # 選擇隨機權重
    weights = [random.randint(1, 2**32) for _ in range(len(messages))]
    
    # 計算加權和
    total_pubkey_sum = Point.infinity()
    total_R_sum = Point.infinity()
    total_message_hash = b''
    
    for i, (msg, pk, (Rx, s)) in enumerate(zip(messages, pubkeys, signatures)):
        P = lift_x(int_from_bytes(pk))
        R = lift_x(int_from_bytes(Rx))
        
        total_pubkey_sum = total_pubkey_sum + P * weights[i]
        total_R_sum = total_R_sum + R * weights[i]
        total_message_hash = hashlib.sha256(total_message_hash + msg)
    
    # 驗證加權等式
    e_total = int_from_bytes(total_message_hash) % curve_order
    
    lhs = sum([s_i * w_i for s_i, w_i in zip(
        [int_from_bytes(sig[32:64]) for sig in signatures],
        weights
    )]) % curve_order * G
    
    rhs = total_R_sum + e_total * total_pubkey_sum
    
    return lhs == rhs

第五章：PTLC 與閃電網路隱私

5.1 PTLC 的概念與優勢

PTLC（Point Time Locked Contracts，點時間鎖定合約）是閃電網路中即將引入的一項重大升級，用於替代現有的 HTLC（哈希時間鎖定合約）。PTLC 使用 Schnorr 簽名的密碼學特性來提供更好的隱私和效率。

HTLC 的局限性

閃電網路當前使用的 HTLC 具有以下特點：

• 支付透過哈希鎖定
• 路由節點可以看到哈希原像
• 所有 HTLC 具有相同的「指紋」（哈希值）

這使得區塊鏈分析師可以：

• 識別某些閃電網路支付
• 追蹤支付流向
• 分析路由網路的結構

PTLC 的解決方案

PTLC 使用基於 Schnorr 簽名的「適配器簽名」（Adaptor Signature）技術：

def create_ptlc(
    sender_key: int,
    receiver_key: int,
    amount: int,
    payment_hash: bytes
) -> tuple:
    """
    創建 PTLC 合約
    
    參數:
        sender_key: 發送方私鑰
        receiver_key: 接收方公鑰
        amount: 支付金額（satoshi）
        payment_hash: 支付哈希
    
    返回:
        tuple: (PTLC 承諾, 適配器承諾)
    """
    # 生成一次性隨機數
    t = random.randint(1, curve_order - 1)
    T = t * G
    
    # 計算 receiver 的部分公鑰
    R_receiver = receiver_key * G
    
    # 創建 PTLC 承諾
    # PTLC 的花費條件是知道 t
    PTLC_script = create_ptlc_script(T, payment_hash, time_lock=144)
    
    # 適配器承諾：用於原子化交換
    adaptor = t * R_receiver
    
    return (PTLC_script, adaptor, T)

5.2 適配器簽名在 PTLC 中的應用

適配器簽名是 Schnorr 簽名的一個擴展，它允許在不透露秘密的情況下「預示」簽名。

適配器簽名原理

def create_adaptor_signature(
    private_key: int,
    message: bytes,
    adaptor_point: bytes
) -> tuple:
    """
    創建 Schnorr 適配器簽名
    
    適配器簽名的特點：
    - 可以被任何人驗證為「幾乎完整」的簽名
    - 只有知道 adaptor 對應私鑰的人才能完成簽名
    
    參數:
        private_key: 簽名者私鑰
        message: 消息哈希
        adaptor_point: 適配器點 T = t*G
    
    返回:
        tuple: (部分簽名 s_tilde, R')
    """
    # 生成 nonce
    k = random.randint(1, curve_order - 1)
    R = k * G
    
    # 將 adaptor 加入 R
    T = lift_x(int_from_bytes(adaptor_point))
    R_prime = R + T
    
    # 確保 y 座標為偶數
    if R_prime.y % 2 != 0:
        R_prime = -R_prime
        k = curve_order - k
    
    # 計算 challenge
    e = int_from_bytes(hashlib.sha256(
        R_prime.x.to_bytes(32, 'big') +
        private_key * G +
        message
    )) % curve_order
    
    # 計算部分簽名
    s_tilde = (k + e * private_key) % curve_order
    
    return (s_tilde, R_prime.x.to_bytes(32, 'big'))

適配器簽名的原子化特性

適配器簽名可用於創建原子化交換，例如在閃電網路中的 HTLC 替換：

def verify_adaptor_signature(
    signature: tuple,
    adaptor_signature: tuple,
    private_key: bytes,
    message: bytes,
    adaptor_point: bytes
) -> bool:
    """
    驗證並完成適配器簽名
    
    參數:
        signature: 普通 Schnorr 簽名
        adaptor_signature: 適配器簽名
        private_key: 簽名者私鑰
        message: 消息哈希
        adaptor_point: 適配器點
    
    返回:
        tuple: (驗證結果, 恢復的秘密 t)
    """
    s_tilde, Rx_prime = adaptor_signature
    s, Rx = signature
    
    # 恢復秘密 t
    # s = k + e*d
    # s_tilde = k + e*d + t
    # 所以 t = s_tilde - s
    t = (s_tilde - s) % curve_order
    
    # 驗證 t
    T_expected = t * G
    T_actual = lift_x(int_from_bytes(adaptor_point))
    
    if T_expected != T_actual:
        return (False, None)
    
    # 驗證原始簽名
    if schnorr_verify(message, private_key, signature):
        return (True, t)
    
    return (False, None)

5.3 PTLC 帶來的隱私提升

PTLC 為閃電網路隱私帶來了多個層面的提升：

路由混淆

• 每個 PTLC 使用不同的點，沒有統一的「指紋」
• 路由節點無法通過哈希識別相同的支付
• 支付路徑的追蹤變得更加困難

支付的不可關聯性

• ECDSA 適配器簽名的限制：每個適配器簽名與原簽名的 R 值相同
• Schnorr 適配器簽名可以選擇不同的 R 值
• 這使得不同支付之間無法通過 R 值關聯

Schnorr 批量驗證的效率提升

• 閃電網路通道的關閉交易可以批量驗證
• 區塊鏈節點的驗證負擔降低
• 網路的整體效率和隱私都得到提升

第六章：Taproot 地址的隱私性深度分析

6.1 Taproot 地址格式與隱私特性

Taproot（BIP-341/342）是比特幣 2021 年升級的核心內容，它重新定義了比特幣地址的格式和使用方式，帶來了前所未有的隱私提升。

P2TR 地址結構

Taproot 地址使用 Pay-to-Taproot（P2TR）格式，其核心是一個 Schnorr 公鑰。地址的生成過程：

def create_p2tr_address(
    internal_key: bytes,
    script_tree: ScriptTree = None
) -> str:
    """
    創建 Taproot 地址
    
    參數:
        internal_key: 內部公鑰（32位元組）
        script_tree: 可選的腳本樹（Merkle 樹）
    
    返回:
        str: Base58 或 Bech32m 格式的 Taproot 地址
    """
    # 如果有腳本樹，計算 Merkle 根
    if script_tree is not None:
        t = hash_tap_tree(script_tree)
    else:
        t = b'\x00' * 32
    
    # 計算調試係數
    # 這是 Taproot 的關鍵創新
    x = int_from_bytes(internal_key)
    
    # 最終公鑰 Q = internal_key + t*G
    Q = lift_x(x) + int_from_bytes(t) * G
    
    # 確保 y 座標為偶數
    if Q.y % 2 != 0:
        Q = -Q
        x = curve_order - x
    
    # 編碼為 Bech32m
    address = bech32_encode('bc', 1, x.to_bytes(32, 'big'))
    
    return address

6.2 Taproot 隱私的三個層次

第一層：所有交易的統一外觀

在 Taproot 升級前，比特幣交易根據其花費條件呈現出不同的「指紋」：

• P2PKH 交易有特定的腳本結構
• P2SH 交易的腳本哈希可被識別
• P2WSH 交易的見證結構暴露腳本類型
• 多簽名交易與單簽名交易明顯不同

Taproot 的創新在於：所有複雜的腳本邏輯——無論是 1-of-1、2-of-3 還是 15-of-15 的多簽名——都可以被表示為一個普通的 Schnorr 公鑰。

普通單簽名使用金鑰路徑花費：
區塊鏈上只看到：Q = internal_key + t*G
無法識別任何腳本條件

MuSig 2-of-3 使用金鑰路徑花費：
區塊鏈上只看到：Q_agg（聚合公鑰）
無法識別這是多簽名，無法識別門限設置

有緊急預案的個人錢包使用金鑰路徑：
區塊鏈上只看到：Q
無法識別緊急預案的存在

第二層：腳本路徑的 Merkle 保護

即使需要使用腳本路徑（Merkle 樹中的某個葉片腳本），Taproot 仍然提供了顯著的隱私保護：

def spend_taproot_script_path(
    internal_key: bytes,
    script: bytes,
    script_path: list,
    witness: list
) -> bytes:
    """
    通過腳本路徑花費 Taproot 輸出
    
    參數:
        internal_key: 內部公鑰
        script: 要執行的腳本
        script_path: Merkle 路徑
        witness: 見證數據
    
    返回:
        bytes: 完整的見證
    """
    # 計算葉片腳本哈希
    leaf_version = 0xc0
    script_hash = hash_tap_leaf(script, leaf_version)
    
    # 計算 Merkle 證明
    merkle_proof = compute_merkle_proof(script_hash, script_path)
    
    # 構造完整見證
    witness = [script] + witness + [leaf_version] + merkle_proof
    
    return witness

Merkle 樹結構的特點是：

• 攻擊者只看到使用了「腳本路徑」
• 無法得知其他可能的腳本條件
• 無法識別 Merkle 樹的深度或葉片數量

第三層：見證數據的簡化

Taproot 的另一個隱私優勢是見證數據的結構優化：

升級前（P2WSH 多簽名）：
witness: [sig1, sig2, ..., script]

升級後（P2TR MuSig）：
witness: [aggregated_sig]

這種結構的簡化減少了區塊鏈上的數據量，同時也減少了可識別的信息。

6.3 Taproot 隱私的局限性

儘管 Taproot 提供了顯著的隱私提升，但以下因素仍可能泄露信息：

區塊鏈分析的持續改進

即使 Taproot 隱藏了腳本結構，區塊鏈分析師仍可能通過以下方式獲得信息：

• 網路層分析：追蹤交易的廣播來源
• 時間分析：交易的廣播時間模式
• 金額分析：某些特殊金額可能成為指紋

錢包實現的一致性

當大多數錢包還未採用 Taproot 時，已採用 Taproot 的錢包可能成為識別目標。比特幣隱私的最佳實踐是「混入人群」，當 Taproot 採用率提高時，其隱私效果將顯著增強。

用戶行為的洩露

即使使用 Taproot，以下行為仍可能洩露信息：

• 總是使用金鑰路徑（暗示沒有使用腳本路徑）
• 使用特殊的腳本條件（容易被識別）
• 與已知地址的交互

結論

Schnorr 簽名的引入為比特幣隱私保護技術帶來了革命性的變化。從密碼學層面來看，Schnorr 簽名的線性特性使得多簽名聚合、門限簽名和適配器簽名成為可能，這些技術從根本上改變了比特幣交易的隱私特性。

MuSig2 協議允許真正的密碼學意義上的多簽名聚合，使得 n-of-n 多簽名錢包與普通單簽名錢包在外觀上完全無法區分。門限簽名技術進一步擴展了這一能力，允許 t-of-n 的門限設置，同時保持區塊鏈上的不可識別性。

PTLC 和閃電網路的結合預示著比特幣支付隱私的下一個重大飛躍。適配器簽名技術的應用將使閃電網路支付擺脫哈希指紋的限制，實現真正的不可追蹤性。

Taproot 地址的採用將使比特幣網路上的所有交易——無論其複雜程度——呈現出統一的外觀。這種「人群混雜」效應隨著採用率的提高將變得越來越強大。

展望未來，隨著比特幣社區繼續探索 Schnorr 簽名和 Taproot 的應用場景，我們可以期待更多創新的隱私保護技術問世。比特幣的隱私保護將從單純的「混幣」操作，進化為密碼學原生的、不可識別的隱私架構。