了解Blum-Blum-Shub算法。（Python实现）

请帮助我理解BBS算法。我执行了以下操作：

class EmptySequenseError(Exception):                                  
    pass                                                              


class BlumBlumShub(object):                                           
    def __init__(self, length):                                       
        self.length = length                                          
        self.primes = e(1000)  # Primes obtained by my own Sieve of Eratosthenes implementation.                                                                            

    def get_primes(self):                                             
        out_primes = []                                               
        while len(out_primes) < 2:                                    
            curr_prime = self.primes.pop()          
            if curr_prime % 4 == 3:                                   
                out_primes.append(curr_prime)                         
        return out_primes                                             

    def set_random_sequence(self):                                    
        p, q = self.get_primes()                                      
        m = p * q                                                     
        self.random_sequence = [((x+1)**2)%m for x in range(self.length)]

    def get_random_sequence(self):                                    
        if self.random_sequence:                                      
           return self.random_sequence                               
        raise EmptySequenseError("Set random sequence before get it!")

类清空顺序错误（异常）：
通过
类BlumBlumShub（对象）：
定义初始值（自身，长度）：
self.length=长度
self.primes=e（1000）#通过我自己的Eratosthenes实现筛选得到的primes。
def获取_素数（自）：
out_primes=[]
而len（out_primes）<2：
curr_prime=self.primes.pop（）
如果当前素数%4==3：
out\u primes.append（curr\u prime）
返回素数
def设置随机序列（自）：
p、 q=自我获取素数（）
m=p*q
self.random_序列=[（x+1）**2）%m，用于范围内的x（self.length）]
def get_随机_序列（自）：
如果self.random_序列：
返回self.random_序列
引发EmptySequenceError（“在获取之前设置随机序列！”）

我有几个问题。起初我不想使用

random

库，它太幼稚了。我的序列在增加，它不是绝对随机的如何防止返回序列增加？我不理解算法描述的这一部分：

在算法的每一步中，从xn+1导出一些输出；输出通常是xn+1的位奇偶校验或xn+1的一个或多个最低有效位

请向我解释一下这是什么意思？

编辑摘要：

• 对算法进行了修正
• 引文替换为en.wikipedia引文

仅为范围内的x生成

[（x**2）%m（自身长度）]

，大致为xn+1=n2 mod m

算法应该是：xn+1=xn2 mod M

你看到你的版本有什么不同吗

---

至于报价-你没有说它来自哪里，但有：

在算法的每一步中，从xn+1导出一些输出；输出通常是xn+1的位奇偶校验或xn+1的一个或多个最低有效位

---

这意味着xn+1是下一次迭代的种子，而不是返回的伪随机数。相反，返回值是通过计算其位奇偶校验（每次迭代产生0或1）或只取一些高位来从xn+1导出的。

Blum Blum Shub在《应用密码学手册》第5.5.2节中进行了描述。在那一章中有很多关于随机数生成的有用内容。

我宁愿将我的理解形式化作为一个答案

class BlumBlumShub(object):                                             
    def __init__(self, length):                                         
        self.length = length                                            
        self.primes = e(1000)                                           

    def gen_primes(self):                                               
        out_primes = []                                                 
        while len(out_primes) < 2:                                      
            curr_prime = self.primes[random.randrange(len(self.primes))]
            if curr_prime % 4 == 3:                                     
                out_primes.append(curr_prime)                           
        return out_primes                                               

    def random_generator(self):                                         
        x = random.randrange(1000000)                                   
        while self.length:                                              
            x += 1                                                      
            p, q = self.gen_primes()                                    
            m = p * q                                                   
            z = (x**2) % m                                              
            self.length -= 1                                            
            yield str(bin(z).count('1') % 2)                            

    def get_random_bits(self):                                          
        return ''.join(self.random_generator())                         

class BlumBlumShub（对象）：
定义初始值（自身，长度）：
self.length=长度
self.primes=e（1000）
def gen_底漆（自）：
out_primes=[]
而len（out_primes）<2：
curr_prime=self.primes[random.randrange（len（self.primes））]
如果当前素数%4==3：
out\u primes.append（curr\u prime）
返回素数
def随机_发生器（自身）：
x=random.randrange（1000000）
而self.length：
x+=1
p、 q=自我生成素数（）
m=p*q
z=（x**2）%m
自我长度-=1
收益率str（bin（z）.计数（'1'）%2）
def get_随机_位（自身）：
返回“”。加入（self.random\u生成器（））

• BBS是伪随机位生成器，它必须返回随机位，而不是整数
• 返回值只是结果xn+12%m操作的奇偶校验位

---

如果我理解错误，请解释我的错误。

我仍然无法理解，我应该返回什么？奇偶校验位意味着什么？我应该返回

（（x+1）**2）%m

还是其他什么？或者按位操作应该做什么？位奇偶校验位字符串中1个数的奇偶性。在python中，这基本上是：

parity\u of_x=bin（x）.count（1）%2

class BlumBlumShub(object):                                             
    def __init__(self, length):                                         
        self.length = length                                            
        self.primes = e(1000)                                           

    def gen_primes(self):                                               
        out_primes = []                                                 
        while len(out_primes) < 2:                                      
            curr_prime = self.primes[random.randrange(len(self.primes))]
            if curr_prime % 4 == 3:                                     
                out_primes.append(curr_prime)                           
        return out_primes                                               

    def random_generator(self):                                         
        x = random.randrange(1000000)                                   
        while self.length:                                              
            x += 1                                                      
            p, q = self.gen_primes()                                    
            m = p * q                                                   
            z = (x**2) % m                                              
            self.length -= 1                                            
            yield str(bin(z).count('1') % 2)                            

    def get_random_bits(self):                                          
        return ''.join(self.random_generator())