17、随机数生成器：BBS、ISAAC与Fortuna的深入解析-优快云博客

本文链接：https://blog.youkuaiyun.com/transformer2023/article/details/154327684

随机数生成器：BBS、ISAAC与Fortuna的深入解析

在密码学和计算机科学领域，随机数生成器（PRNG）和密码学安全随机数生成器（CSPRNG）扮演着至关重要的角色。本文将详细介绍BBS、ISAAC和Fortuna这三种随机数生成器，包括它们的原理、代码实现以及性能测试。

1. BBS生成器

BBS（Blum Blum Shub）生成器是一种密码学安全的随机数生成器。它通过循环八次来提取八个值，并从中提取一位。位测试会添加 i%8 ，因为索引将从8的倍数开始。代码中使用 pow(a, b, c) 函数快速计算 a**b % c ，这是生成序列值所必需的。

# 示例代码
from bbs import *
b = BBS(1234)
print([b.next() for i in range(10)])
print([b.next() for i in range(10)])
print([b.idx(i) for i in range(10, 20)])

BBS生成器被认为是安全的，但速度较慢，并且 p 和 q 必须非常大才能获得良好的周期并避免被轻易猜测。不过，它在理论上很有趣，并且在Python中易于实验。

2. ISAAC生成器

ISAAC（Indirection, Shift, Accumulate, Add, and Count）是由Robert Jenkins在1994年引入的确定性CSPRNG。它已进入公共领域，经受住了密码分析，目前被认为是安全的。

2.1 ISAAC的外部状态和代码结构

ISAAC有一个由256个无符号32位整数组成的外部状态，称为种子。它初始化为零，但在设置ISAAC之前可以初始化任何部分。代码分为三个部分：

// 定义外部数组randrsl
uint32_t randrsl[256] = {0};

// 定义mix预处理函数
#define mix(a,b,c,d,e,f,g,h) \
{ \
    a^=b<<11; d+=a; b+=c; \
    b^=c>>2; e+=b; c+=d; \
    c^=d<<8; f+=c; d+=e; \
    d^=e>>16; g+=d; e+=f; \
    e^=f<<10; h+=e; f+=g; \
    f^=g>>4; a+=f; g+=h; \
    g^=h<<8; b+=g; h+=a; \
    h^=a>>9; c+=h; a+=b; \
}

2.2 ISAAC函数

ISAAC函数合并了初始化和执行部分。初始化部分通过混合内部变量和种子值来设置内部状态 mm 。

// ISAAC函数
uint32_t isaac(uint8_t flag) {
    static uint32_t mm[256];
    static uint32_t aa=0, bb=0, cc=0;
    static randcnt=0;
    uint32_t i;

    if (flag) {
        uint32_t a,b,c,d,e,f,g,h;
        aa=bb=cc=0;
        a=b=c=d=e=f=g=h=0x9e3779b9;
        for (i=0; i<4; ++i)
            mix(a,b,c,d,e,f,g,h);
        for (i=0; i<256; i+=8) {
            a+=randrsl[i]; b+=randrsl[i+1];
            c+=randrsl[i+2]; d+=randrsl[i+3];
            e+=randrsl[i+4]; f+=randrsl[i+5];
            g+=randrsl[i+6]; h+=randrsl[i+7];
            mix(a,b,c,d,e,f,g,h);
            mm[i]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;
            mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;
        }
        for (i=0; i<256; i+=8) {
            a+=mm[i]; b+=mm[i+1];
            c+=mm[i+2]; d+=mm[i+3];
            e+=mm[i+4]; f+=mm[i+5];
            g+=mm[i+6]; h+=mm[i+7];
            mix(a,b,c,d,e,f,g,h);
            mm[i]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;
            mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;
        }
        randcnt = 256;
    }

    if (randcnt == 256) {
        uint32_t x,y;
        cc = cc + 1;
        bb = bb + cc;
        for (i=0; i<256; ++i) {
            x = mm[i];
            switch (i%4) {
                case 0: aa = aa^(aa<<13); break;
                case 1: aa = aa^(aa>>6); break;
                case 2: aa = aa^(aa<<2); break;
                case 3: aa = aa^(aa>>16); break;
            }
            aa = mm[(i+128)%256] + aa;
            mm[i] = y = mm[(x>>2)%256] + aa + bb;
            randrsl[i] = bb = mm[(y>>10)%256] + x;
        }
        randcnt = 0;
    }

    return randrsl[randcnt++];
}

2.3 ISAAC性能测试

通过生成5亿个输出文件并使用 ent 和 dieharder 进行测试，ISAAC表现良好。它还通过了TestU01框架的所有SmallCrush、Crush和BigCrush测试。

graph LR
    A[初始化ISAAC] --> B[生成随机数]
    B --> C[测试随机数]
    C --> D{是否通过测试}
    D -- 是 --> E[性能良好]
    D -- 否 --> F[需进一步优化]

此外，测试了ISAAC在不同种子下的性能。当设置 randrsl 的第一个元素为流编号时， dieharder 得分为222（108通过，6个弱，0失败）；当设置 randrsl 的连续元素为1时，得分为220（109通过，4个弱，1失败）。

3. Fortuna生成器

Fortuna是由Schneier和Furguson在2003年开发的，旨在抵抗对其状态的攻击。它由三个主要部分组成：

熵累加器
伪随机数生成器
种子管理系统

3.1 熵累加器

Fortuna使用32个熵池，每个池长32字节。新的熵通过SHA - 256哈希处理后，以循环方式添加到池中。在重新播种生成器时，会使用这些池。

3.2 伪随机数生成器

Fortuna的随机数生成器通常是计数器模式下的流密码，推荐使用AES - 256。它使用128位计数器和当前生成器状态作为密钥，每次输出16字节。

3.3 种子管理系统

种子管理系统允许将状态导出到磁盘文件，并从磁盘文件（或任何其他缓冲区）导入状态。

3.4 Fortuna的实现和测试

使用LibTomCrypt库实现Fortuna。以下是测试代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include "tomcrypt.h"

#define N 1000000

void main(int argc, char *argv[]) {
    prng_state st;
    uint32_t n,i;
    uint8_t *out;
    FILE *g;
    uint8_t ent[32] = {
        12,53,75,63, 4,57, 8,78,89,67, 8,45,62, 3,41, 2,
        4,56,56,67,97,88, 9,78, 5,67,45,23,12,43, 4,76
    };

    n = (uint32_t)atol(argv[1]);
    out = (uint8_t *)malloc(N*sizeof(uint8_t));
    fortuna_start(&st);
    fortuna_add_entropy((void*)ent, sizeof(ent), &st);
    fortuna_ready(&st);
    g = fopen(argv[2],"w");
    for(i=0; i<n; i++) {
        fortuna_read((void*)out, N*sizeof(uint8_t), &st);
        fwrite((void*)out, N*sizeof(uint8_t), 1, g);
    }
    fclose(g);
}

总结

BBS生成器安全但速度慢，适合理论研究；ISAAC生成器安全、快速，适用于一般用途；Fortuna生成器通过熵累加器和种子管理系统抵抗攻击，适合系统级长期使用。在实际应用中，应根据具体需求选择合适的随机数生成器。

4. 三种生成器的对比分析

为了更清晰地了解BBS、ISAAC和Fortuna这三种随机数生成器的特点，下面从多个方面进行对比分析。

4.1 安全性

BBS ：基于数论原理，依赖于大素数 p 和 q 的选择。只要 p 和 q 足够大且满足特定条件，攻击者很难从生成的随机数反推内部状态，安全性较高。但由于其计算复杂度较高，生成速度慢，在实际应用中容易受到时间攻击。
ISAAC ：经过多年的密码分析，目前被认为是安全的。它通过复杂的混合操作和状态更新机制，使得内部状态难以被猜测。不过，虽然有研究指出其内部状态存在一定弱点，但整体安全性未受严重影响。
Fortuna ：专门设计用于抵抗对其状态的攻击。通过熵累加器收集外部随机数据，以及种子管理系统定期更新种子，即使攻击者获取了部分状态信息，也难以预测后续生成的随机数。

生成器	安全性特点	潜在风险
BBS	基于大素数，理论安全	计算慢，易受时间攻击
ISAAC	经受密码分析，状态复杂	内部状态有一定弱点
Fortuna	抵抗状态攻击，熵池和种子管理	依赖外部熵源质量

4.2 性能

BBS ：由于涉及大量的模幂运算，生成随机数的速度非常慢。这使得它在对性能要求较高的场景中不太适用，例如实时系统或大规模随机数生成任务。
ISAAC ：速度较快，在简单测试机器上每秒可生成约2180万个无符号整数。能够满足一般应用对随机数生成速度的需求。
Fortuna ：性能相对适中。虽然在熵收集和种子更新过程中会有一定开销，但由于采用了高效的流密码（如AES - 256）生成随机数，整体性能可以接受。

4.3 易用性

BBS ：在Python中实现相对简单，代码易于理解和实验。但由于其性能问题，在实际项目中使用较少。
ISAAC ：提供了单一的函数接口 isaac ，使用方便。可以通过不同的种子设置来生成不同的随机数序列，适合多种应用场景。
Fortuna ：借助LibTomCrypt库，提供了一系列清晰的接口函数，如 fortuna_start 、 fortuna_add_entropy 等。但需要用户自行管理熵源和种子状态，相对来说使用复杂度稍高。