BBS伪随机数生成器

Blum Blum Shub（BBS），由Lenore Blum、Manuel Blum和Michael Shub于1986年提出。BBS伪随机数生成器以其可证明的安全性而闻名，其安全性基于大整数分解问题的困难性

BBS生成器的数学基础

1. Blum整数

BBS生成器的核心是Blum整数，定义为两个特殊素数的乘积：

N = p × q

其中p和q必须满足：

• p和q都是大素数
• p ≡ 3 (mod 4)
• q ≡ 3 (mod 4)

2. Blum素数生成

class BlumInteger:
    @staticmethod
    def generate_blum_prime(bit_length: int) -> int:
        """生成Blum素数（p ≡ 3 mod 4）"""
        while True:
            # 生成候选奇数
            candidate = random.getrandbits(bit_length)
            candidate |= (1 << (bit_length - 1))  # 确保指定位数
            candidate |= 1  # 确保是奇数
            
            # 检查是否 ≡ 3 mod 4
            if candidate % 4 != 3:
                continue
            
            # Miller-Rabin素性测试
            if MillerRabin.is_prime(candidate):
                return candidate

3. Miller-Rabin素性测试

class MillerRabin:
    @staticmethod
    def is_prime(n: int, k: int = 40) -> bool:
        """Miller-Rabin素性测试"""
        if n <= 1:
            return False
        elif n <= 3:
            return True
        elif n % 2 == 0:
            return False
        
        # 将n-1分解为 d * 2^s
        d = n - 1
        s = 0
        while d % 2 == 0:
            d //= 2
            s += 1
        
        # 进行k轮测试
        for _ in range(k):
            a = random.randrange(2, n - 1)
            x = pow(a, d, n)
            
            if x == 1 or x == n - 1:
                continue
            
            for __ in range(s - 1):
                x = pow(x, 2, n)
                if x == n - 1:
                    break
            else:
                return False
        
        return True

BBS生成器核心算法

1. 基本原理

BBS生成器使用简单的二次剩余迭代：

\[x_{n+1} = x_n² mod N \]

其中：

• N是Blum整数
• \(x_0\)是与N互质的种子
• 输出为\(x_n\)的最低有效位（LSB）

2. 核心实现

class BBSGenerator:
    def __init__(self, N: int, seed: Optional[int] = None):
        """初始化BBS生成器"""
        self.N = N
        self.state = seed if seed is not None else self._generate_seed()
        
        # 验证种子
        if not self._validate_seed():
            raise ValueError("种子必须与N互质且不能为0或1")
    
    def next_bit(self) -> int:
        """生成下一个随机比特"""
        # BBS核心算法: x_{n+1} = x_n^2 mod N
        self.state = pow(self.state, 2, self.N)
        
        # 输出最低有效位（LSB）
        bit = self.state & 1
        return bit

3. 种子验证

def _validate_seed(self) -> bool:
    """验证种子有效性"""
    return (self.state > 1 and 
            self.state < self.N - 1 and 
            math.gcd(self.state, self.N) == 1)

多种输出格式

1. 比特序列生成

def next_bits(self, num_bits: int) -> str:
    """生成指定数量的随机比特"""
    bits = []
    for _ in range(num_bits):
        bits.append(str(self.next_bit()))
    return ''.join(bits)

2. 字节生成

def next_byte(self) -> int:
    """生成下一个随机字节"""
    byte = 0
    for i in range(8):
        byte |= (self.next_bit() << i)
    return byte

3. 浮点数生成

def next_float(self) -> float:
    """生成[0, 1)范围内的随机浮点数"""
    # 使用52位精度（IEEE 754双精度尾数）
    bits = self.next_bits(52)
    mantissa = int(bits, 2)
    return mantissa / (2**52)

统计测试套件

1. 频率测试

def frequency_test(bits: str, significance: float = 0.01) -> Tuple[bool, float]:
    """频率测试（单比特测试）"""
    n = len(bits)
    ones = bits.count('1')
    
    # 计算测试统计量
    s_obs = abs(ones - n/2) / math.sqrt(n/4)
    
    # 计算p值
    p_value = 2 * (1 - BBSTestSuite._normal_cdf(abs(s_obs)))
    
    return p_value >= significance, p_value

2. 游程测试

def runs_test(bits: str, significance: float = 0.01) -> Tuple[bool, float]:
    """游程测试"""
    n = len(bits)
    ones = bits.count('1')
    zeros = n - ones
    
    # 计算游程数
    runs = 1
    for i in range(1, n):
        if bits[i] != bits[i-1]:
            runs += 1
    
    # 计算期望和方差
    expected_runs = (2 * ones * zeros) / n + 1
    variance_runs = (2 * ones * zeros * (2 * ones * zeros - n)) / (n**2 * (n - 1))
    
    # 计算测试统计量
    z_obs = (runs - expected_runs) / math.sqrt(variance_runs)
    
    # 计算p值
    p_value = 2 * (1 - BBSTestSuite._normal_cdf(abs(z_obs)))
    
    return p_value >= significance, p_value

自相关测试

def autocorrelation_test(bits: str, lag: int = 1, significance: float = 0.01) -> Tuple[bool, float]:
        """
        自相关测试
        检查比特序列与其延迟版本的相关性
        """
        n = len(bits)
        if lag >= n:
            return False, 0.0
        
        # 计算自相关
        correlation = 0
        for i in range(n - lag):
            if bits[i] == bits[i + lag]:
                correlation += 1
            else:
                correlation -= 1
        
        # 计算测试统计量
        z_obs = correlation / math.sqrt(n - lag)
        
        # 计算p值
        p_value = 2 * (1 - BBSTestSuite._normal_cdf(abs(z_obs)))
        
        return p_value >= significance, p_value

BBS的安全性分析

1. 周期性

BBS生成器的周期至少是λ(p)和λ(q)的最小公倍数，其中λ是卡迈克尔函数：

def carmichael_blum(p):
    return (p - 1) // 2
lambda_p = carmichael_blum(p)
lambda_q = carmichael_blum(q)
period = math.lcm(lambda_p, lambda_q)

2. 安全性基础

BBS的安全性基于以下数学难题：

1. 大整数分解问题：已知N，难以找到p和q
2. 二次剩余问题：给定x和N，难以判断x是否为二次剩余
3. 预测困难性：预测BBS输出等价于分解N

性能特点

1. 优势

• 可证明安全性：基于数学难题
• 长周期：周期长度可达\(2^{|N|}\)
• 可重现性：相同种子产生相同序列

2. 劣势

• 速度较慢：每次迭代需要大数模运算
• 初始化复杂：需要生成大素数

使用示例

# 生成Blum整数
p, q, N = BlumInteger.generate_blum_integer(256, 256)
# 创建BBS生成器
bbs = BBSGenerator(N)
# 生成随机数
bits = bbs.next_bits(128)          # 128位随机数
bytes_data = bbs.next_bytes(16)    # 16字节随机数
random_int = bbs.next_int(1, 100)  # 1-100随机整数
random_float = bbs.next_float()    #[0,1)随机浮点数