後量子密碼學的性能最佳化：開發人員指南

進口 並發期貨 進口 奧克斯 從 打字 進口 列表、元組 進口 時間 班級 平行簽名者: """ 用於批次操作的平行 SPHINCS+ 簽章 在簽署多個獨立訊息時使用。""" 定義 __初始化__（自我，max_workers：int =無）： """ 初始化平行簽署者參數：max_workers：要使用的 CPU 執行緒（預設值：CPU 計數） """ self.max_workers = max_workers or os.cpu_count() 定義 簽名批次( self, messages: List[bytes], Secret_key: bytes ) -> List[bytes]: """ 並行簽署多個訊息 參數： messages：要簽署的訊息清單 Secret_key：SPHINCS+ 金鑰 傳回：與訊息順序相同的簽章清單 """ 定義 標誌_單（訊息：位元組）->位元組：sig = oqs.Signature（“SPHINCS+-SHAKE-128s-簡單”，秘密密鑰） 返回 sig.sign(訊息) 和 並發.futures.ThreadPoolExecutor( max_workers=self.max_workers ) as 執行者：簽章=清單（executor.map（sign_single，訊息）） 返回 簽名 定義 帶鑰匙簽名（自我，項目：列表[元組[字節，位元組]] #（訊息，秘密密鑰） ) -> 列表[位元組]: """使用不同的金鑰並行簽署訊息""" 定義 標誌項（物品： 元組[字節，位元組]) -> 位元組：訊息，sk = item sig = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”, sk） 返回 sig.sign(訊息) 和 並發.futures.ThreadPoolExecutor( max_workers=self.max_workers ) as 執行人： 返回 列表(executor.map(sign_item, items)) # 基準比較 定義 benchmark_parallel_vs_sequential(): # 產生金鑰 sig = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”) sig.generate_keypair() sk = sig.export_secret_key() # 建立測試訊息 訊息 = [f“消息{i}”.encode() 為了 i in 範圍(16)] # 順序 開始= time.perf_counter（）sequential_sigs = [] 為了 味精 in 訊息： s = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”, sk)equential_sigs.append(s.sign(msg)) seq_time = time.perf_counter() - 開始 ＃ 平行線 簽名者= 平行簽名者() start = time.perf_counter() parallel_sigs = signer.sign_batch(messages, sk) par_time = time.perf_counter() - 開始 print(f“順序：{seq_time:.2f}s ({len(messages)/seq_time:.1f} msg/s)”) 列印(f“並行：{par_time:.2f}s ({len(messages)/par_time:.1f} msg/s)”) 列印(f“加速比：{seq_time/par_time:.2f}x”)

班級 平行驗證器: """驗證器的平行簽名驗證""" 定義 __初始化__(self, max_workers: int = None): self.max_workers = max_workers or os.cpu_count() 定義 驗證批次（自我，項目：列表[元組[字節，字節，字節]] #（訊息、訊號、PK） ) -> 列表[布林]: """並行驗證多個簽名返回驗證結果清單""" 定義 驗證單（物品： 元組[字節，字節，位元組]) -> bool: 訊息，簽名，public_key = item 嘗試: sig = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”) 返回 sig.verify(訊息、簽名、公鑰) 除了: 返回 錯誤的 和 並發.futures.ThreadPoolExecutor( max_workers=self.max_workers ) as 執行人： 返回 清單（executor.map（verify_single，項目）） 定義 全部有效（自我，項目：列表[元組[字節，字節，位元組]] ) -> 布林值： """快速檢查所有簽名是否有效""" 結果= self.verify_batch（項目） 返回 全部（結果） # 對於處理區塊的驗證器： 非同步定義 驗證區塊交易（交易：清單）：驗證者 = 平行驗證器（最大工人數=8） # 準備驗證項 items = [ (tx.signing_message, tx.signature, tx.public_key) 為了 tx in 交易] # 並行驗證所有內容 結果 = verifier.verify_batch(items) # 過濾有效交易 valid_txs = [tx 為了 發送，有效 in zip（交易、結果） if 有效的] 返回 有效交易

從 功能工具 進口 lru_緩存 進口 哈希庫 班級 密鑰緩存: """ 快取派生金鑰以避免重複派生 對於頻繁存取相同路徑的 HD 錢包很有用。""" 定義 __初始化__(self, max_size: int = 1000): self.max_size = max_size self._cache: dict = {} 定義 獲取或派生（自我，master_seed：字節，路徑：str，derive_func）-> 元組[字節，位元組]： """ 取得快取金鑰或衍生並快取參數： master_seed：錢包主種子路徑：派生路徑derive_func：快取未命中時呼叫的函數回傳：(public_key，secret_key) 元組 """ # 建立快取鍵（不要在鍵中儲存實際種子） cache_key = hashlib.Blake2b(master_seed + path.encode()).hexdigest()[:32] if 快取鍵 in self._cache： 返回 self._cache[cache_key] # 派生金鑰 pk, sk =derive_func(master_seed, 路徑) # 快取與驅逐 if len(self._cache) >= self.max_size: # 簡單的 FIFO 驅逐（在生產中使用 OrderedDict） 最舊的=下一個（iter（self._cache）） 德爾 self._cache[最舊] self._cache[cache_key] = (pk, sk) 返回 PK、SK 定義 清除（自己）： """清除所有快取的金鑰（呼叫錢包鎖）""" # 安全擦除 為了 鑰匙 in 列表(self._cache.keys()): pk, sk = self._cache[key] # 刪除前覆蓋 self._cache[key] = (b'\x00' * len(pk), b'\x00' * 長度（sk）） 德爾 self._cache[鍵] # 錢包中的使用 班級 優化錢包: 定義 __初始化__(self, master_seed: 位元組): self.master_seed = master_seed self.key_cache = 密鑰緩存（最大大小=500） 定義 取得地址密鑰（自我，路徑：str）-> 元組[字節，位元組]： 返回 self.key_cache.get_or_derive( self.master_seed, 路徑, self._derive_keys ) 定義 _derive_keys（自身，種子：位元組，路徑：str）： # 實際推導邏輯 ...

班級 簽名緩存: """快取簽章驗證結果供驗證者避免重新驗證已看到的交易。""" 定義 __初始化__(self, max_size: int = 10000): self.max_size = max_size self._verified: dict[str, bool] = {} 定義 _signature_id( self, 訊息: 位元組, 簽章: 位元組, public_key: 位元組 ) -> str: """建立唯一 ID 用於簽章驗證""" 返回 hashlib.Blake2b( 訊息 + 簽章[:64] + public_key, # sig 的前 64 位元組足夠了 摘要_大小 = 16 ).hexdigest() 定義 檢查或驗證( self, 訊息: 位元組, 簽章: 位元組, public_key: 位元組 ) -> bool: """檢查快取或驗證並快取結果""" sig_id = self._signature_id(訊息、簽章、公鑰) if sig_id in 自我驗證： 返回 self._verified[sig_id] ＃ 核實 sig = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”) is_valid = sig.verify(message, 簽章, 公鑰) # 快取（有驅逐） if len(self._verified) >= self.max_size: # 刪除 ~10% 最舊的條目 to_remove = list(self._verified.keys())[:self.max_size // 10] 為了 鑰匙 in 刪除： 德爾 self._verified[key] self._verified[sig_id] = is_valid 返回 有效

進口 gc 班級 記憶體效率簽署者: """嵌入式/行動裝置的記憶體高效簽章""" 定義 簽署並釋放（自我，訊息：字節，secret_key：字節）->位元組： """ 簽署訊息並立即釋放金鑰記憶體 用於金鑰不應持續存在的一次性簽章。""" sig_obj = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”, Secret_key) 簽章 = sig_obj.sign(訊息) # 釋放OQS對象 德爾 sig_obj # 覆蓋密鑰 if isinstance(secret_key, bytearray): 為了 i in 範圍（len（secret_key））：secret_key [i] = 0 # 強制垃圾回收 GC.collect() 返回 簽名 定義 串流媒體符號( self, message_chunks: Iterator[bytes], Secret_key: bytes ) -> bytes: """ 對流訊息進行簽名，而不將所有訊息載入到記憶體中 對訊息進行分塊預哈希，然後對哈希進行簽名。 """ # 雜湊訊息區塊 哈希器 = hashlib.Blake2b(digest_size=32) 為了 區塊 in message_chunks: hasher.update(chunk) message_hash = hasher.digest() # 對哈希進行簽名 sig = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”，秘密密鑰） 返回 sig.sign(message_hash)

# 檢查 CPU 特徵以選擇最佳演算法 進口 子流程 定義 取得CPU功能() -> 設定： """偵測可用的 CPU SIMD 功能""" 嘗試: # Linux 和 打開（“/proc/cpuinfo”) as f: cpuinfo = f.read() 功能 = set() if “avx2” in cpuinfo: 功能.add(“avx2”) if “avx512” in cpuinfo: 功能.add(“avx512”) if “aes” in cpuinfo: 功能.add(“埃斯尼”) 返回 特徵 除了: 返回 放（） 定義 選擇最優變體() -> 字串： """為此 CPU 選擇最佳的 SPHINCS+ 變體""" 功能 = get_cpu_features() if “avx512” in 特徵： # AVX-512 提供約 20-30% 的加速 列印(《使用AVX-512優化實作》) 返回 “SPHINCS+-SHAKE-128s-簡單” # liboqs 自動選擇 埃利夫 “avx2” in 特點：列印（《使用AVX2優化實現》) 返回 “SPHINCS+-SHAKE-128s-簡單” 別的: 列印(“使用參考實作”) 返回 “SPHINCS+-SHAKE-128s-簡單” # 使用最佳標誌編譯 liboqs # cmake -DOQS_USE_AVX2_INSTRUCTIONS=ON -DOQS_USE_AVX512_INSTRUCTIONS=ON ..

進口 統計數據 進口 時間 班級 加密基準測試: """全面的 PQC 基準測試""" 定義 __初始化__（自我，迭代：int = 100）：self.iterations =迭代 定義 基準操作（自我，名稱：str，操作，設定=沒有任何 ) -> 字典： """對單一操作進行基準測試""" 次數 = [] 為了 _ in 範圍（自我迭代）： if 設定： ctx = setup() 開始 = time.perf_counter() if 設定：操作（ctx） 別的：操作（）已過去=（time.perf_counter（）-開始）* 1000 ＃ 多發性硬化症 times.append(已過去) 返回 { “姓名”： 姓名， “意思是”: 統計.平均值(次), “中位數”: 統計.中位數(次), “標準開發”：統計數據.stdev（次）， “分鐘”：分鐘（次）， “最大限度”：最大（次）， “每秒操作數”: 1000 / 統計.平均值(次) } 定義 運行完整基準（自我）-> 字典： """運行完整的 PQC 基準測試套件""" 結果={} # Kyber 基準測試 結果[“kyber_keygen”] = self.benchmark_operation( “Kyber-768 金鑰產生器”, 拉姆達: oqs.KeyEncapsulation(“凱伯768”).generate_keypair() ) # 封裝/解蓋設置 kem = oqs.KeyEncapsulation(“凱伯768”) pk = kem.generate_keypair() sk = kem.export_secret_key() 結果[“kyber_encap”] = self.benchmark_operation( “Kyber-768 封裝”, 拉姆達: kem.encap_secret(pk) ) ct, _ = kem.encap_secret(pk) kem_dec = oqs.KeyEncapsulation(“凱伯768”, sk) 結果[“kyber_decap”] = self.benchmark_operation( “Kyber-768 開蓋”, 拉姆達: kem_dec.decap_secret(ct) ) # SPHINCS+ 基準測試 結果[“sphincs_keygen”] = self.benchmark_operation( “SPHINCS+-SHAKE-128s 金鑰產生器”, 拉姆達: oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”).generate_keypair() ) sig = oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”) sig.generate_keypair() spx_sk = sig.export_secret_key() msg​​ = b"x" * 256 個結果[“sphincs_sign”] = self.benchmark_operation( “SPHINCS+-SHAKE-128s 標誌”, 拉姆達: oqs.Signature(“SPHINCS+-SHAKE-128s-簡單”, spx_sk).sign(msg), 迭代=20 # 由於速度較慢而減少 ) 返回 結果 定義 列印結果（自我，結果：字典）： """漂亮的列印基準測試結果""" 列印("\n=== PQC 性能基準 ===) 列印(f“迭代次數：{self.iterations}\n”) 為了 密鑰、數據 in 結果.items(): 列印(f“{數據['名稱']}：”) 列印(f“平均值：{數據['平均值']：.3f}毫秒”) 列印(f“中位數：{數據['中位數']：.3f}毫秒”) 列印(f“每秒操作次數：{data['ops_per_sec']:.1f}”) 列印() # 運行基準測試 if __名字__ == “__主要的__”: 板凳 = 加密基準測試(迭代=50) 結果 = bench.run_full_benchmark() bench.print_results(結果)