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

Question

请帮我理解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!")

我有几个问题。起初我不想使用random库，这太天真了。我的序列越来越多，它不是绝对随机的。 如何防止返回序列增加？我不明白这部分算法描述：

  

在算法的每一步，一些输出都来自 x _{n + 1} ;输出通常是 x _{n + 1} 的位奇偶校验或 x _{n + 1}

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

编辑摘要：

• 算法已更正。
• 引用已替换为en.wikipedia引用。

Answer 1

    for x in range(self.length):                                  
        self.random_sequence.append((x ** 2) % m) 

只需生成[(x ** 2) % m for x in range(self.length)]，大致为x _{n + 1} = n ² mod M.

算法假设为：x _{n + 1} = x _n ² mod M

你看到你的版本与众不同吗？

---

至于引用 - 你没有说出来自哪里，但Wikipedia有：

  

在算法的每一步，一些输出都来自 x _{n + 1} ;输出通常是 x _{n + 1} 的位奇偶校验或 x _{n + 1}

这意味着 x _{n + 1} 是下一次迭代的种子，但不伪 - 返回随机数。相反，返回值来自 x _{n + 1} ，通过计算其位奇偶校验（每次迭代产生0或1），或者只取一些数量的顶部位。

Answer 2

Blum Blum Shub在“应用密码学手册”第5.5.2节的Chapter Five中有所描述。关于随机数生成有很多有用的东西。

Answer 3

我宁愿将我的理解正式化为答案。

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())                         

• BBS是伪随机位生成器，它必须返回随机位，而不是整数。
• 返回值只是结果x _{n + 1} ² ％m操作的奇偶校验位。

如果我错误地理解了某些内容，请解释我的错误。