企业官网建设流程全解析

1. 项目概述：为什么随机数质量是密码学与区块链的基石

在密码学和区块链的世界里，随机数不是锦上添花，而是整个安全大厦的地基。无论是生成一个无法预测的私钥、创建一次性的加密会话，还是在共识机制中公平地选择出块节点，其背后都依赖于一个核心假设：我们使用的随机数是“真”随机，或者说，是足够“随机”的。一个脆弱的随机数生成器，就像一把用面粉做的锁，看似坚固，实则一捅就破。历史上，因为随机数问题导致的安全事件屡见不鲜，从早期SSL/TLS协议的漏洞到某些加密货币钱包的私钥被破解，根源往往都指向了伪随机数生成算法的缺陷或熵源不足。

NIST SP 800-22，这个由美国国家标准与技术研究院发布的文档，正是评估随机数序列质量的“黄金标准”之一。它包含了一套完整的统计测试套件，专门用来检验一个二进制序列是否表现出真正随机序列应有的统计特性。对于开发者，尤其是涉足密码学应用、区块链节点开发、安全协议实现的朋友来说，学会使用这套标准测试自己的RNG，不是一项选修课，而是必修的安全审计环节。它能帮你提前发现“伪随机”中的“伪”，避免将系统性风险埋入产品。

今天，我就以一名开发者的视角，带你用Python实战演练如何对随机数生成器进行NIST SP 800-22测试。我们将不局限于调用现成库，而是深入理解几个关键测试的原理，并亲手实现简化版，最后用完整的测试套件评估几个常见的随机源。目标是让你不仅能跑通测试，更能看懂报告，理解每一个P值背后的含义，从而真正掌控自己系统的随机性安全。

2. 核心需求解析：我们需要测试什么？

在动手之前，我们必须明确目标：NIST测试套件检验的是二进制序列的随机性。它不关心你的随机数是怎么来的（是硬件熵源、算法生成还是混合方案），它只关心最终输出的0/1序列是否“像”一个理想的随机序列。这套测试包含了15种不同的统计测试，每种测试从不同角度“刁难”你的序列。

2.1 测试的核心逻辑与两类错误

所有统计测试都遵循一个基本逻辑：先提出一个“零假设”——假设待测序列是随机的。然后，根据序列计算出一个统计量，并求出这个统计量在“序列是随机的”这个假设下出现的概率（即P值）。如果P值非常低（比如低于0.01），我们就说“在显著性水平α=0.01下，拒绝零假设”，认为序列可能不是随机的。这里存在两类错误：

• 第一类错误（弃真错误）：序列本来是随机的，但测试误判为非随机。概率由显著性水平α控制，通常设α=0.01。
• 第二类错误（取伪错误）：序列本来不随机，但测试误判为随机。这更危险，我们希望其概率β尽可能小。

NIST建议，对于一组测试，通过率需要在一个置信区间内。例如，生成1000个序列，每个序列100万比特，在α=0.01水平下，期望的通过率应在0.99 ± 0.00985范围内。如果某个测试的通过率远低于这个下限，那你的RNG在该测试维度上就失败了。

2.2 测试序列的准备与关键参数

测试对象是一个长的二进制序列（例如1,000,000比特）。在实际操作中，我们通常：

1. 用待测的RNG生成大量随机数（如整数）。
2. 将这些随机数转换为二进制位。最常见的方法是取每个随机数的最低有效位，但更严谨的做法是进行位提取或使用整个字节。
3. 将所有这些位拼接成一个长长的二进制字符串或比特数组。

测试的关键输入参数除了序列本身，就是显著性水平α。NIST默认推荐α=0.01。这意味着，即使是一个完美的随机生成器，也平均有1%的概率会在单次测试中“失败”（第一类错误）。因此，单次测试失败不一定判死刑，需要结合多个序列的通过率综合判断。

3. 环境准备与工具选型

工欲善其事，必先利其器。我们将搭建一个轻量且功能完整的测试环境。

3.1 Python环境与核心库

我推荐使用Python 3.8及以上版本，因为它有良好的类型提示和稳定的库支持。核心库只需要两个：

• NumPy：用于高效的数值计算和数组操作，生成和存储大量的随机数比特。
• SciPy：特别是scipy.special和scipy.stats模块，用于计算互补误差函数erfc、卡方分布等统计函数，这是实现测试公式的关键。

安装非常简单：

pip install numpy scipy

3.2 测试套件实现方案选择

你有三个选择：

1. 使用成熟库：最快捷的是nistrng库，它封装了NIST测试。但对于学习而言，这像个黑盒。
2. 参考官方实现：NIST官网提供了C语言的参考实现。我们可以用Python复现其逻辑，这是最佳的学习路径。
3. 手动实现核心测试：我们将采用这种方式，选择几个有代表性的测试（如频率测试、游程测试、离散傅里叶变换测试）进行深度实现，理解其每一步计算。对于完整的15项测试，我们可以用nistrng来验证和补充。

这里，我们先手动实现，建立直观感受。后续完整评估时，会结合nistrng。

# 如果需要完整套件，可以安装nistrng作为验证工具 pip install nistrng

3.3 待测随机数生成器

我们将测试三种典型的随机源，以便对比：

1. Python内置random模块：这是梅森旋转算法，速度快，周期长，但并非密码学安全。
2. secrets模块：Python 3.6+引入，用于密码学安全的随机数，在类Unix系统上通常使用/dev/urandom。
3. 一个简单的线性同余生成器：自己写一个劣质的LCG，作为“反面教材”，预期它会失败多项测试。

4. 核心测试原理解读与Python实现

让我们深入三个核心测试的内部，看看它们如何“拷问”随机序列。

4.1 单比特频率测试（Frequency (Monobit) Test）

这是最基础、最直观的测试：检查序列中0和1的比例是否大致相等。

4.1.1 原理与计算步骤

1. 将序列中的0替换为-1，1保持不变。设结果为序列S = [s1, s2, ..., sn]，其中si ∈ {-1, 1}。
2. 计算代数和：S_n = Σ si。
3. 计算统计量：S_obs = |S_n| / sqrt(n)。
4. 计算P值：P-value = erfc(S_obs / sqrt(2))。其中erfc是互补误差函数。

为什么？对于真正的随机序列，S_n应近似服从均值为0、方差为n的正态分布。S_obs是这个正态分布变量的绝对值标准化后的形式。P值表示，如果序列是随机的，观察到统计量大于或等于当前S_obs值的概率。P值很小（如<0.01）说明0和1的比例失衡得“离谱”，不像随机序列。

4.1.2 Python实现与注释

import numpy as np from scipy.special import erfc def monobit_test(bit_sequence): """ 执行单比特频率测试。 :param bit_sequence: 一维数组，元素为0或1。 :return: (统计量, P值) """ n = len(bit_sequence) # 步骤1 & 2: 将0->-1，并求和 sn = np.sum(2 * bit_sequence - 1) # 巧妙转换：2*0-1=-1, 2*1-1=1 # 步骤3: 计算观测到的统计量 s_obs = abs(sn) / np.sqrt(n) # 步骤4: 计算P值 p_value = erfc(s_obs / np.sqrt(2)) return s_obs, p_value # 示例：快速测试一个手工序列 test_bits = np.array([1,0,1,1,0,0,1,0,1,0]) s, p = monobit_test(test_bits) print(f"统计量 S_obs: {s:.4f}, P值: {p:.4f}") # 对于这么短的序列，P值仅供参考，无实际意义。

注意：这个测试对序列长度敏感。NIST建议测试序列长度n至少为100。长度太短时，即使理想随机序列也可能通不过测试。

4.2 游程测试（Runs Test）

游程是指连续相同的0或1的最大序列。例如，“1001110001”中，游程有：1,00,111,000,1。游程测试检查序列中游程的总数是否与随机序列的期望相符。太多或太少的游程都意味着序列中存在某种模式或聚类。

4.2.1 原理与计算步骤

1. 计算序列中1的比例：π = (Σ bit_sequence[i]) / n。
2. 检查前置条件：|π - 0.5| < τ，其中τ = 2 / sqrt(n)。如果不满足，测试无效，P值直接返回0。
3. 计算游程总数V_n（包括0游程和1游程）。
4. 计算统计量：P-value = erfc( |V_n - 2nπ(1-π)| / (2 * sqrt(2n) * π * (1-π)) )。

为什么？在随机序列中，游程总数的期望是2nπ(1-π)。统计量衡量了实际游程数与期望值的偏差，标准化后服从渐近正态分布。erfc函数给出了偏差如此之大的概率。

4.2.2 Python实现与注释

def runs_test(bit_sequence): """ 执行游程测试。 :param bit_sequence: 一维数组，元素为0或1。 :return: P值 """ n = len(bit_sequence) # 步骤1: 计算1的比例 pi = np.sum(bit_sequence) / n # 步骤2: 检查前置条件 tau = 2.0 / np.sqrt(n) if abs(pi - 0.5) >= tau: # 根据NIST文档，此时认为测试不适用，返回0 return 0.0 # 步骤3: 计算游程总数 # 一个巧妙的方法：计算相邻位不同的次数，然后+1 v_n = np.sum(bit_sequence[1:] != bit_sequence[:-1]) + 1 # 步骤4: 计算统计量和P值 numerator = abs(v_n - 2 * n * pi * (1 - pi)) denominator = 2 * np.sqrt(2 * n) * pi * (1 - pi) # 避免除零错误（虽然前置条件已保证pi不接近0或1，但数值稳定考虑） if denominator == 0: return 0.0 statistic = numerator / denominator p_value = erfc(statistic) return p_value

实操心得：计算游程总数时，np.diff和比较操作是非常向量化的高效方法。注意序列边界，第一个游程没有被diff捕获，所以总数要加1。这是算法实现中常见的“off-by-one”错误点。

4.3 离散傅里叶变换测试（Spectral Test）

这个测试非常强大，用于检测序列中是否存在周期性的模式。它通过对序列进行傅里叶变换，分析其频域特性。在随机序列中，所有频率分量的幅值应该大致相同。

4.3.1 原理简述

1. 将0/1序列转换为±1序列：X[k] = 2 * ε[k] - 1。
2. 计算离散傅里叶变换：S[f] = |FFT(X)|。
3. 计算归一化的周期图：P[f] = (1/n) * |S[f]|^2。
4. 统计峰值超过阈值T = sqrt(2.995732274 * n)的个数N0。理论期望是95%的峰值应低于此阈值。
5. 计算统计量：d = (N0 - 0.95 * n/2) / sqrt(0.95 * 0.05 * n/2)。
6. P值 = erfc( |d| / sqrt(2) )。

4.3.2 Python实现与注释

def spectral_test(bit_sequence): """ 执行离散傅里叶变换测试（简化版，聚焦核心逻辑）。 :param bit_sequence: 一维数组，元素为0或1。建议长度n为偶数。 :return: P值 """ n = len(bit_sequence) # 步骤1: 转换为±1序列 x = 2 * bit_sequence - 1 # 步骤2 & 3: 计算FFT和周期图 (只取前n/2个点，因为实信号频谱对称) fft_result = np.fft.fft(x) # 取模的平方，并归一化。注意：np.abs是取模 p = (np.abs(fft_result) ** 2) / n # 我们只关心0到奈奎斯特频率之间的点（前n//2个，不包括0频率直流分量） p_half = p[1: n//2 + 1] # 步骤4: 计算阈值T，并统计超过T的峰值数 t = np.sqrt(np.log(1.0 / 0.05) * n) # 近似于 sqrt(2.995732274 * n) n0 = np.sum(p_half > t) # 步骤5: 计算偏差d expected_peaks = 0.95 * (n//2) # 期望低于阈值的峰值数比例是95% d = (n0 - (n//2 - expected_peaks)) / np.sqrt(0.95 * 0.05 * (n//2)) # 步骤6: 计算P值 p_value = erfc(abs(d) / np.sqrt(2)) return p_value

注意事项：这个测试计算量较大，对于超长序列（如1亿比特），FFT会成为瓶颈。在实际应用中，NIST的完整实现还有更复杂的细节，比如忽略前5%的峰值等。我们的简化版用于理解核心思想。另外，序列长度n最好选择2的幂次，这样FFT效率最高。

5. 完整测试流程与结果分析实战

现在，我们将三个测试整合，并对我们准备的三个随机源进行系统的评估。

5.1 构建测试框架与生成测试序列

首先，我们编写一个函数，用于生成指定长度的二进制序列，并运行我们的测试套件。

import random import secrets def generate_bits_from_source(source_func, num_bits): """使用指定的随机源生成二进制位序列。""" bits = [] # 假设随机源函数每次调用返回一个整数 # 为了效率，我们一次生成多个字节再转换为位 num_bytes = (num_bits + 7) // 8 for _ in range(num_bytes): # 调用随机源获取一个0-255的整数 byte_val = source_func(256) # 将该字节的8个位依次加入列表 for j in range(8): if len(bits) >= num_bits: break bits.append((byte_val >> j) & 1) return np.array(bits[:num_bits]) # 定义三个随机源 def source_random(): return random.randint(0, 255) # Python内置random def source_secrets(): return secrets.randbelow(256) # 密码学安全随机 # 一个劣质的线性同余生成器 (LCG) lcg_state = 12345 def source_bad_lcg(): global lcg_state a, c, m = 1103515245, 12345, 2**31 lcg_state = (a * lcg_state + c) % m return lcg_state & 0xFF # 取低8位 def run_test_suite(bit_sequence, alpha=0.01): """运行我们的简化测试套件并返回结果字典。""" results = {} # 1. 单比特频率测试 _, p1 = monobit_test(bit_sequence) results['频率测试'] = {'P值': p1, '通过': p1 >= alpha} # 2. 游程测试 p2 = runs_test(bit_sequence) results['游程测试'] = {'P值': p2, '通过': p2 >= alpha} # 3. 频谱测试 p3 = spectral_test(bit_sequence) results['频谱测试'] = {'P值': p3, '通过': p3 >= alpha} return results # 生成并测试一个序列 n_bits = 10000 # 测试序列长度 print("测试序列长度:", n_bits) print("="*50) sources = [('Python random', source_random), ('Python secrets', source_secrets), ('Bad LCG', source_bad_lcg)] for name, func in sources: print(f"\n随机源: {name}") bits = generate_bits_from_source(func, n_bits) res = run_test_suite(bits) for test_name, test_res in res.items(): status = "通过" if test_res['通过'] else "失败" print(f" {test_name}: P值={test_res['P值']:.6f} [{status}]")

5.2 结果解读与通过率分析

单次测试结果可能有偶然性。按照NIST指南，我们需要生成大量（如1000个）序列，统计每个测试的通过率。

def evaluate_rng(source_func, num_sequences=1000, bits_per_sequence=10000, alpha=0.01): """评估一个随机源，生成多个序列并统计通过率。""" pass_counts = {'频率测试': 0, '游程测试': 0, '频谱测试': 0} for i in range(num_sequences): if i % 100 == 0: print(f"正在处理第 {i} 个序列...") bits = generate_bits_from_source(source_func, bits_per_sequence) res = run_test_suite(bits, alpha) for test_name in pass_counts.keys(): if res[test_name]['通过']: pass_counts[test_name] += 1 print(f"\n评估完成，共 {num_sequences} 个序列，每个 {bits_per_sequence} 比特。") print("各测试通过率：") for test_name, count in pass_counts.items(): pass_rate = count / num_sequences # 计算99%置信区间 (对于α=0.01) # 通过率期望 p = 1 - α = 0.99 p = 1 - alpha margin = 3 * np.sqrt(p * (1-p) / num_sequences) # 近似3-sigma区间 lower_bound = p - margin upper_bound = p + margin in_interval = lower_bound <= pass_rate <= upper_bound interval_status = "在区间内" if in_interval else "**异常**" print(f" {test_name}: {pass_rate:.4f} (期望 ~0.99) [{interval_status}]") return pass_counts # 由于完整运行1000*10000比特的频谱测试计算量很大，这里我们用更少的序列演示 print("\n开始对'Bad LCG'进行多序列通过率评估（演示用，序列数较少）...") evaluate_rng(source_bad_lcg, num_sequences=100, bits_per_sequence=10000)

运行上述代码，你可能会发现：

• Python random和secrets：在大多数测试中通过率会落在置信区间内，表现良好。secrets作为密码学安全源，理论上应更稳健。
• Bad LCG：在频率测试上可能勉强通过（因为LCG在均匀分布上可能还行），但在游程测试和频谱测试上很可能严重失败。游程测试会检测到其序列模式过于规则（游程数可能偏离期望），频谱测试则会清晰地暴露其周期性（在频域会出现显著的尖峰）。

5.3 使用nistrng进行完整15项测试验证

为了进行更全面、权威的评估，我们可以使用nistrng包。它能一次性执行所有15项测试，并生成格式化的报告。

import nistrng import numpy as np def full_nist_suite_test(source_func, num_bits=1000000): """使用nistrng包执行完整的NIST SP 800-22测试套件。""" # 生成比特序列 print(f"生成 {num_bits} 比特的测试序列...") bits = generate_bits_from_source(source_func, num_bits) # nistrng要求序列为np.array，元素类型为np.int8 eligible_bits = np.array(bits, dtype=np.int8) # 检查序列长度是否满足各项测试的最小要求 eligible_tests = nistrng.check_eligibility_all_battery(eligible_bits, nistrng.SP800_22R1A_BATTERY) print(f"可执行的测试数量: {len(eligible_tests)}") # 执行所有符合条件的测试 results = nistrng.run_all_battery(eligible_bits, eligible_tests, False) # 汇总结果 print("\n===== NIST SP 800-22 测试结果汇总 =====") for result, test_name in zip(results, eligible_tests): # result是一个元组 (test_name, subtest_id, score, p_value, assessment) assessment = "通过" if result[4] else "失败" print(f"{result[0]} [{result[1]}]: P值 = {result[3]:.6f} -> {assessment}") # 计算总体通过率 pass_count = sum(1 for r in results if r[4]) total_count = len(results) print(f"\n总体通过率: {pass_count}/{total_count} ({pass_count/total_count:.2%})") return results # 示例：对secrets模块运行完整测试（耗时较长，建议在性能好的机器上运行） # full_nist_suite_test(source_secrets, num_bits=1000000)

重要提示：完整运行15项测试需要至少1,000,000比特的数据，且某些测试（如线性复杂度测试、通用统计测试）计算量巨大，可能需要数分钟甚至更长时间。建议在评估生产环境RNG时进行，学习阶段用我们实现的简化版或减少序列长度即可。

6. 常见问题、陷阱与排查技巧实录

在实际操作中，你会遇到各种预料之外的问题。以下是我踩过的一些坑和总结的经验。

6.1 测试结果解读的陷阱

• P值恰好等于1或0：这通常意味着计算过程中出现了数值下溢或上溢，或者你的序列极端到让统计量超出了函数有效范围。检查你的序列生成逻辑和测试代码。对于真正的随机序列，P值均匀分布在[0,1]区间，极端值非常罕见。
• 单次测试失败：不要慌张！记住显著性水平α=0.01的含义。即使是一个完美的RNG，生成100个序列，也平均有1个序列会在某项测试上“失败”。关键看通过率。如果1000个序列的通过率在0.99附近（比如0.983-0.997），那很可能是正常的统计波动。如果通过率低至0.95或更低，那你的RNG很可能有问题。
• 所有测试都“完美通过”：这有时更值得警惕。在极少数情况下，一个设计不良的测试或错误的实现，可能导致对任何输入都返回高P值。用已知的非随机序列（如全0、全1、010101...）验证你的测试代码。它们应该以极高的概率失败。

6.2 序列生成与预处理中的坑

• 比特提取方法：不要只取随机数的最低有效位。对于某些劣质RNG，低位的随机性可能很差。NIST建议测试整个输出块。更安全的方法是使用哈希函数（如SHA-256）对RNG的输出进行“蒸馏”，或者使用标准化的DRBG（确定性随机比特生成器）。
• 序列长度不足：每个测试都有最小长度要求。例如，离散傅里叶变换测试建议至少1000比特。使用过短的序列会导致测试功效不足（第二类错误概率高），即无法检测出非随机性。务必遵守NIST文档中对每种测试的最小n建议。
• 测试的独立性：如果你用同一个RNG生成多个测试序列，确保它们是由不同的种子或内部状态生成的。如果测试序列之间有重叠或强相关性，测试结果就无效了。

6.3 性能优化与实用技巧

• 向量化操作：在Python中，使用NumPy的向量化操作（如np.sum,np.diff,np.fft.fft）比用for循环快几个数量级。我们的示例代码都采用了向量化实现。
• 分块处理海量数据：如果需要测试数十亿比特的数据，无法一次性读入内存。可以流式处理：将数据分块，对每个块执行可以增量计算的测试（如频率测试可以累加和），或者分别测试每个块再综合结果。对于FFT这类需要全局数据的测试，则需要单独处理每个足够大的块。
• 并行化：生成和测试多个独立序列是“令人尴尬的并行”任务。可以使用Python的multiprocessing或concurrent.futures模块，将序列分配到多个CPU核心上同时测试，大幅缩短总时间。
• 记录原始数据与状态：始终记录下测试时使用的RNG种子（如果可设置）、生成的序列样本（前几百比特即可）、以及完整的测试结果（P值）。这便于结果复现和问题排查。

6.4 针对区块链与密码学场景的特殊考量

• 私钥生成：用于生成椭圆曲线私钥或RSA私钥的RNG，必须通过所有15项NIST测试，并且最好是密码学安全的（CSPRNG）。/dev/urandom（Linux）、CryptGenRandom（Windows）或secrets模块是更好的起点，而不是random。
• 共识随机数：在权益证明（PoS）等共识机制中，随机数用于出块者选择。这里的RNG不仅需要统计随机，还需要具备可验证随机函数或承诺-揭示等密码学属性，以防止操纵。NIST测试是基础，但远不够。
• 智能合约中的随机数：链上环境是确定性的，极难获得安全随机数。常见的方案是使用链下预言机、区块哈希（未来区块，但需注意矿工影响）或VRF。在这些方案中，最终输入给合约的“随机源”在链下生成时，也应经过NIST测试等评估。

7. 从测试到实践：构建更健壮的随机数方案

通过了NIST测试只是一个开始，对于密码学应用，我们还需要从系统层面保障随机性。

7.1 熵源混合与健康监测

一个健壮的CSPRNG通常有多个熵源（如硬件噪声、系统事件计时、用户输入等）。这些熵源需要被充分混合和池化。在Linux中，/dev/random和/dev/urandom维护了一个熵池。对于关键应用，可以考虑：

• 使用硬件RNG：现代CPU（如Intel的RDRAND、RDSEED指令）提供了硬件随机数生成器，熵质量很高。
• 熵估计与健康检查：持续监测熵池的熵估计值，过低时发出警告。在Linux上，可以通过cat /proc/sys/kernel/random/entropy_avail查看。
• 定期自检：系统可以定期从自己的RNG中采样，离线运行NIST测试套件，作为健康检查的一部分。

7.2 在Python项目中的集成建议

1. 默认选择secrets：对于任何与安全相关的随机操作（令牌、密钥、盐值），无条件使用secrets模块。random模块仅用于模拟、游戏等非安全场景。
2. 系统随机数的封装：如果你需要更底层的控制或跨平台一致性，可以使用os.urandom()来获取系统提供的密码学安全随机字节。
3. 第三方库验证：如果你使用了第三方密码学库（如cryptography），确保你了解它底层使用的RNG，并信任其实现。通常这些库会封装好系统的最佳实践。

# 安全示例 import secrets import os # 生成一个安全的随机令牌 token = secrets.token_urlsafe(32) print(f"安全令牌: {token}") # 生成一个256位的随机整数（用于私钥） private_key_int = secrets.randbits(256) print(f"私钥整数 (十六进制): {private_key_int:064x}") # 直接获取系统随机字节 system_random_bytes = os.urandom(32) print(f"系统随机字节: {system_random_bytes.hex()}")

7.3 一个简单的RNG健康检查脚本蓝图

你可以将今天的知识整合成一个定期运行的脚本，监控你的服务器或应用的随机数质量。

#!/usr/bin/env python3 """ 简易RNG健康检查脚本。 定期采样系统随机源，运行简化版NIST测试，记录通过率，并在通过率异常时告警。 """ import numpy as np import os import time import logging from datetime import datetime # 导入我们之前实现的测试函数 (monobit_test, runs_test, spectral_test) logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') def sample_and_test(sample_size_bits=100000, num_samples=100): """采集并测试多个样本。""" pass_rates = {'频率': [], '游程': [], '频谱': []} for i in range(num_samples): # 从系统随机源采样 num_bytes = (sample_size_bits + 7) // 8 random_bytes = os.urandom(num_bytes) # 转换为比特数组 (更高效的位操作) bits = np.unpackbits(np.frombuffer(random_bytes, dtype=np.uint8)) bits = bits[:sample_size_bits] # 精确截取所需比特数 # 运行测试 _, p1 = monobit_test(bits) p2 = runs_test(bits) p3 = spectral_test(bits) # 注意：对于定期检查，频谱测试可能太重，可酌情移除或减少频率 # 记录通过情况 (α=0.01) pass_rates['频率'].append(p1 >= 0.01) pass_rates['游程'].append(p2 >= 0.01) pass_rates['频谱'].append(p3 >= 0.01) time.sleep(0.01) # 避免采样太快 # 计算通过率 final_rates = {k: np.mean(v) for k, v in pass_rates.items()} return final_rates def main(): logging.info("开始RNG健康检查...") rates = sample_and_test(sample_size_bits=10000, num_samples=50) # 参数可配置 logging.info(f"测试通过率: {rates}") # 检查通过率是否在合理范围内 (例如，低于0.95告警) threshold = 0.95 for test_name, rate in rates.items(): if rate < threshold: logging.warning(f"警告: {test_name}测试通过率({rate:.2%})低于阈值({threshold:.0%})！") logging.info("健康检查完成。") if __name__ == "__main__": main()

这个脚本可以放入cron job中定期运行，将日志输出到文件或监控系统，帮助你建立对系统随机数质量的长期监控。记住，随机性是安全的基石，值得你投入精力去理解和验证。通过今天从理论到实战的梳理，希望你已经掌握了用NIST SP 800-22这把尺子，去丈量你手中随机数生成器可靠性的基本方法。在密码学和区块链的开发道路上，多一分严谨，就少一分风险。