Question

我正在尝试用Python实现Pollard的P-1分解。请注意，Rho方法有一些答案，但这个p-1是不同的，我能在这里给你的关于p-1的最好的是wiki和Wolfram：

http://en.wikipedia.org/wiki/Pollard“s_p_％E2％88％92_1_algorithm

http://mathworld.wolfram.com/Pollardp-1FactorizationMethod.html

这是n的因素，但始终没有找到p。 np和sp分别来自numpy和scipy。所以sp.uint64的内置函数是unsigned long 64 int（因为预期整数的大小），而np.prod（p）是列表p的累积乘积pi：

def pm1_attack(n,b):
  p = [2,3,5,7,11,13,17]; i=19; a=2
  while i<b:
    if is_prime(i,10): p.append(i)
    i+=2;
  k = sp.uint64(np.prod(p)); q = power2(a,k,n)
  g = euc_al_i((q-1),n)
  print "product pi: ",k
  print "q: ",q
  print "g: ",g
  #return a

print "pollard_pm1_attack(n,b): ",pollard_pm1_attack(n,2000)

输出找不到p：

Python 2.7 (r27:82525, Jul  4 2010, 09:01:59) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>> 
p = 1300199 
q = 2063507 

euler_totient = 2682966374188 

common n = 2682969737893 


public key e = 1588051820871 

secret key d = 2410616084843 

cleartext message = test 

encoded message = 1489995542681 

decoded message = test 

check_rsa = Successful encryption and decrytion. Message is authenticated. 

pollard_pm1_attack(n,b):  product pi:  18446744073460481730
q:  2391570546599
g:  1
None
>>>

我正在学习Python，所以这可能是一个简单的错误。 power2（）函数通过平方使用取幂，对于非常大的整数，它基本上是一个超级充电的pow（）。 euc_al_i（）只是gcd。你可以使用你喜欢的任何gcd（），但是因为我正在学习我想自己制作这些。

我试图找出在这里发生了如此可怕的错误，即使是相对较小的n（小到20位长度）也找不到p。

Answer 1

我不知道 np.prod 和 sp.uint64 做了什么，但我可以告诉你 p - 1算法，这是约翰波拉德于1974年发明的。

Pollard的算法基于费马的小定理 a ^ p == a （mod p ），当 a ！= 0时可以声明 a ^（ p - 1）== 1（mod p ）通过将 a 除以表达式。因此，如果 p - 1除以 m ，则 p 除以gcd（2 ^ m - 1，名词的）。 Pollard的 p - 1算法将 m 计算为小于绑定 b 的整数的最小公倍数，因此如果所有因子都< em> p - 1小于 b ，然后是gcd（2 ^ lcm（1 .. b ） - 1， n ）是 n 的因子。通过将小于 b 的素数乘以小于 b 的多重性来计算最小公倍数：

function pminus1(n, b)
    c := 2
    for p in primes(b)
        pp := p
        while pp < b
            c := powerMod(c, p, n)
            pp := pp * p
    g := gcd(c-1, n)
    if 1 < g < n return g
    error "factorization failed"

可选的第二阶段在 b1 和 b2 之间搜索“大素数”，它与第一阶段的最小公倍数组合以查找因子。第二阶段只需要每个素数的模乘，而不是模幂运算，使其非常快，第二阶段gcds可以分批计算。缓存很小但对功能的效率很重要。

function pminus1(n, b1, b2)
    c := 2
    for p in primes(b1)
        pp := p
        while pp < b
            c := powerMod(c, p, n)
            pp := pp * p
    g := gcd(c-1, n)
    if 1 < g < n return g
    k := 0
    for q in primes(b1, b2)
        d := q - p
        if d is not in cache
            x := powerMod(c, d, n)
            store d, x in cache
        c := (c * x(d)) % n
        p := q
        k := k + 1
        if k % 100 == 0
            g := gcd(c-1, n)
            if 1 < g < n return g
    g := gcd(c-1, n)
    if 1 < g < n return g
    error "factorization failed"

Pollard的 p - 1方法可能无法找到 n 的因子;它取决于 n - 1的因式分解以及您选择的界限。检查的方法是自己计算 n - 1，然后用 b 调用Pollard的方法，该 b 大于 n 的最大因子 - 1.例如，如果你想要 n = 87463 = 149 * 587，请注意 n - 1 = 87462 = 2 * 3 * 3 * 43 * 113，所以用 b = 120调用一阶段算法或用 b1 = 50和 b2 = 120调用两阶段算法，看看你是否找到一个因素。

我在my blog讨论了Pollard的 p - 1分解算法以及其他几种分解算法。我还给出了powerMod和gcd函数的实现，以防你在执行这些函数时遇到问题。我用Python在 http://ideone.com/wdyjxK写了一个简单的单阶段算法实现。

Answer 2

这是在python中实现的两阶段版本。

from math import gcd, log

def pminus1(n, B1, B2):
    log_B1 = log(B1)
    M = 1
    primes = prime_sieve()
    for p in primes:
        if p > B1:
            break
        M *= p**int(log_B1/log(p))
    M = pow(2, M, n)
    g = gcd(M-1, n)
    if 1 < g < n:
        return True
    if g == n:
        return False

    # Start part 2.
    cache = {0:M}
    S = (M*M) % n
    for d in range(2, int(log(B2)**2), 2):
        cache[d] = cache[d-2] * S) % n

    HQ = M
    for k, q in enumerate(primes):
        if q > B2:
            break
        d = q - p
        HQ = (HQ * cache[d]) % n
        M = (M * (HQ-1)) % n
        p = q
        if k % 200 == 0:
            if 1 < gcd(M, n) < n:
                return True
    return 1 < gcd(M, n) < n

Python Pollard P-1分解

2 个答案: