kryptools 0.9.5__tar.gz → 0.9.7__tar.gz

{kryptools-0.9.5 → kryptools-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.5
+Version: 0.9.7
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools/factor.py

@@ -4,7 +4,7 @@ Factorization of integers:
     divisors(n) unsorted list of all divisors of the integer n
 """
 
-from math import isqrt, gcd, prod
+from math import isqrt, gcd, prod, floor, log10
 from .primes import sieve_eratosthenes, is_prime
 from .factor_pm1 import _pm1_parameters, factor_pm1
 from .factor_ecm import _ecm_parameters, factor_ecm
@@ -14,8 +14,10 @@ from .factor_ecm import _ecm_parameters, factor_ecm
 # Factoring
 
 
-def _factor_fermat(n: int, steps: int = 10) -> list:
+def _factor_fermat(n: int, maxsteps: int = 10, verbose: int = 0) -> list:
     "Fermat method"
+    if verbose:
+        print(f"Factoring (Fermat, steps={maxsteps}): {n} ({floor(log10(n)) + 1} digits)")
     parameters = {11: (12, 6), 23: (12, 0),
                   5: (6, 3), 17: (6, 3),
                   19: (4, 2), 7: (4, 0),
@@ -23,12 +25,23 @@ def _factor_fermat(n: int, steps: int = 10) -> list:
     start = isqrt(n - 1) + 1
     step, mod = parameters[n % 24]
     start += (mod - start) % step
-    for a in range(start, min(start + steps * step,(n + 9) // 6) + 1, step):
+    if verbose > 1:
+        print("Working ", end= "")
+    maxa = (n + 9) // 6 + 1
+    if maxsteps:
+        maxa = min(maxa, start + maxsteps * step + 1)
+    for a in range(start, maxa, step):
+        if verbose > 1:
+            print(".", end= "")
         b = isqrt(a * a - n)
         if b * b == a * a - n:
+            if verbose > 1:
+                print("")
             return a - b
+    if verbose > 1:
+        print("")
 
-def factorint(n: int, verbose: int = 0) -> dict:
+def factorint(n: int, verbose: int = 0, trial_bnd: int = 2500) -> dict:
     "Factor an ineger `n` into prime factors."
     prime_factors = {}
     if not isinstance(n, int):
@@ -46,7 +59,7 @@ def factorint(n: int, verbose: int = 0) -> dict:
         for m in mm:
             if m in prime_factors:
                 prime_factors[m] += k
-            elif is_prime(m):
+            elif is_prime(m, trialdivision = False):
                 prime_factors[m] = k
             else:
                 if m in remaining_factors:
@@ -56,8 +69,10 @@ def factorint(n: int, verbose: int = 0) -> dict:
                 else:
                     new_factors[m] = k
 
+    if verbose:
+        print(f"Factoring: {n} ({floor(log10(n)) + 1} digits)")
     # trial division
-    B = 2500
+    B = max(3, trial_bnd)
     factorbase = sieve_eratosthenes(B)
     for p in factorbase:
         k = 0
@@ -70,13 +85,14 @@ def factorint(n: int, verbose: int = 0) -> dict:
         return prime_factors
     if verbose:
         print("Trial division found:", list(prime_factors))
-    if is_prime(n):
+    if is_prime(n, trialdivision = False):
         prime_factors[n] = 1
         return prime_factors
     remaining_factors = { n: 1 }
 
     # https://gitlab.inria.fr/zimmerma/ecm/
     ECM_PARAMETERS = [
+        [     5000,         130000,    54],
         [    11000,        1900000,    74],
         [    50000,       13000000,   221],
         [   250000,      130000000,   453],
@@ -88,29 +104,40 @@ def factorint(n: int, verbose: int = 0) -> dict:
         [260000000,  3200000000000, 47173],
         [850000000, 16000000000000, 77666]
     ]
+    fermat_steps = 10
 
-    for parameters in ECM_PARAMETERS:
+    for round, parameters in enumerate(ECM_PARAMETERS):
+        fermat_steps += 10
         B1, B2, num_curves = parameters
+        p_max = isqrt(max(remaining_factors))+1
+        B1 = min(B1, p_max//50)
+        B1 += B1 & 1
+        B2 = min(B2, p_max)
+        B2 += B2 & 1
         num_curves *= 2
         D = isqrt(B2)
+        
+        if verbose:
+            print(f"Round {round+1} (B1={B1})")
+
         primes = sieve_eratosthenes(B1 - 1 + ((B2 - B1 + 1) // (2 * D) + 1) * 2 * D)
-        pm1_parameters = _pm1_parameters(10 * B1, B2, primes = primes)
+        pm1_parameters = tuple([10 * B1, B2] + list(_pm1_parameters(10 * B1, B2, primes = primes)))
         ecm_parameters = tuple([B1, B2, num_curves] + list(_ecm_parameters(B1, B2, D, primes = primes)))
 
-        methods = {_factor_fermat: "fm", factor_pm1: "pm1", factor_ecm: "ecm"}  #, factor_qs: "qs"}
+        methods = {_factor_fermat: "fmt", factor_pm1: "pm1", factor_ecm: "ecm"}  #, factor_qs: "qs"}
         while remaining_factors:
             new_factors = {}
             for method in [ _factor_fermat, factor_pm1, factor_ecm ]:  # , factor_qs ]:
                 factors = list(remaining_factors)
                 for m in factors:
-                    if verbose > 1:
-                        print("Factoring: ",m, "method", methods[method])
-                    if method == factor_pm1:
-                        tmp = factor_pm1(m, pm1_parameters = pm1_parameters)
+                    if method == _factor_fermat:
+                        tmp = _factor_fermat(m, maxsteps = fermat_steps, verbose = max(0, verbose - 1))
+                    elif method == factor_pm1:
+                        tmp = factor_pm1(m, pm1_parameters = pm1_parameters, verbose = max(0, verbose - 1))
                     elif method == factor_ecm:
-                        tmp = factor_ecm(m, ecm_parameters = ecm_parameters)
+                        tmp = factor_ecm(m, ecm_parameters = ecm_parameters, verbose = max(0, verbose - 1))
                     else:
-                        tmp = method(m)
+                        tmp = method(m, verbose = max(0, verbose - 1))
                     if tmp:
                         tmp2 = m // tmp
                         g = gcd(tmp, tmp2)
@@ -125,7 +152,7 @@ def factorint(n: int, verbose: int = 0) -> dict:
                                     tmp3.append(x)
                         else:
                             tmp3 = [tmp, tmp2]
-                        if verbose > 0: print("Factors found (", methods[method] ,"): ", tmp3)
+                        if verbose > 0: print(f"Factors found ({methods[method]}): ", tmp3)
                         add_factors(m, tmp3)
             if not new_factors:
                 break

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools/factor_dix.py

@@ -7,7 +7,7 @@ from .primes import sieve_eratosthenes
 from .nt import legendre_symbol
 from .factor_qs import bytexor, byteset, bytetest
 
-def is_smooth(n: int, factorbase: list, lfb: int) -> bytes or None:
+def is_smooth(n: int, factorbase: list, lfb: int) -> bytes|None:
     """Try to factor n with respect to a given factorbase.
     Upon success a bytestring, whose bits are the exponents with repect to the factorbase mod 2, is returned.
     Otherwise None."""
@@ -26,7 +26,7 @@ def is_smooth(n: int, factorbase: list, lfb: int) -> bytes or None:
         return None  # the number factors if at the end nothing is left
     return factors
 
-def factor_dixon(n: int) -> list:
+def factor_dixon(n: int) -> int|None:
     """Find factors of n using the method of Dixon."""
     # first determine the bound B for the factorbase: Choosing B=p^(1/u) Canfield-Erdös-Pomerance gives us
     # the expected running time |B|^2 u^u = u^(u+2) p^(2/u)/log(n). There is no explicit expression for the optimum, hence

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools/factor_ecm.py

@@ -2,7 +2,7 @@
 Integer factorization: Lentra's ECM
 """
 
-from math import gcd, isqrt, log
+from math import gcd, isqrt, log, floor, log10
 from random import randint, seed
 from .primes import sieve_eratosthenes
 seed(0)
@@ -35,27 +35,30 @@ def mult(k, P, c2, p):
         return dbl(P, c2, p)
     Q = dbl(P, c2, p)
     R = P
-    for i in bin(k)[3:]:
+    for i in bin(k)[3:-1]:
         if i == "1":
             R = add(Q, R, P, p)
             Q = dbl(Q, c2, p)
         else:
             Q = add(R, Q, P, p)
             R = dbl(R, c2, p)
-    return R
+    if k % 2:
+        return add(Q, R, P, p)
+    return dbl(R, c2, p)
 
 # Crandall and Pomerance: Primes (doi=10.1007/0-387-28979-8)
 # Algorithm 7.4.4 (Inversionless ECM)
 
-def _ecm_parameters(B1: int, B2: int = None, D: int = None, primes: tuple = None):
+def _ecm_parameters(B1: int, B2: int|None = None, D: int|None = None, primes: tuple|None = None) -> tuple:
     "Precompute parameters for the ECM method."
 
     # Stage-one/two limits must be even
-    B1 += B1 & 1
+    if B1 % 2:
+        raise ValueError("B1 must be even.")
     if not B2:
         B2 = 100 * B1
-    else:
-        B2 += B2 & 1
+    if B2 % 2:
+        raise ValueError("B2 must be even.")
     if not D:
         D = min(isqrt(B2), B1 // 2 - 1)
     if not primes:
@@ -84,36 +87,61 @@ def _ecm_parameters(B1: int, B2: int = None, D: int = None, primes: tuple = None
     return D, stage_one, stage_two_deltas
 
 
-def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm_parameters: tuple|None = None):
+def factor_ecm(n: int, B1: int|None = None, B2: int|None = None, curves: int = 150, ecm_parameters: tuple|None = None, verbose: int = 0) -> int|None:
     "Factors a number n using Lentsta's ECM method."    
 
     if ecm_parameters:
         B1, B2, curves, D, stage_one, stage_two_deltas = ecm_parameters
     else:
+        if not B1:
+            B1 = min(1000_000, isqrt(n)//200 + 2)
+        # Stage-one/two limits must be even
+        B1 += B1 & 1
+        if not B2:
+            B2 = 100 * B1
         D, stage_one, stage_two_deltas = _ecm_parameters(B1, B2)
 
+    if verbose:
+        print(f"Factoring (ECM, B1={B1}, B2={B2}): {n} ({floor(log10(n)) + 1} digits)")
+    if verbose > 1:
+        print("Working ", end= "")
     for _ in range(curves):
         # find a random curve
+        if verbose > 1:
+            print("C", end= "")  # stage one
         sigma = randint(6, n - 1)
         u = (sigma**2 - 5) % n
         v = (4 * sigma) % n
         try:
             c = (pow(v - u, 3, n) * (3 * u + v) * pow(4 * u**3 * v, -1, n) - 2) % n
         except:
-            m = gcd(4 * u**3 * v, n)
-            return m
-        c2 = c - 2 % n
+            if verbose > 1:
+                print("\nFactor found.")
+            m = gcd(u, n)
+            if m > 1:
+                return m
+            m = gcd(v, n)
+            if m > 1:
+                return m
+            return 2
+        c2 = (c - 2) % n
         # and a point on the curve (or its twist)
         Q = (pow(u, 3, n), pow(v, 3, n))
         # Stage one
+        if verbose > 1:
+            print("1", end= "")
         Q = mult(stage_one, Q, c2, n)
         if Q[1] == 0:
             continue
         g = gcd(Q[1], n)
         if g > 1:
+            if verbose > 1:
+                print("\nFactor found.")
             return g
 
         # Stage two
+        if verbose > 1:
+            print("2", end= "")
         S = [dbl(Q, c2, n)]
         S.append(dbl(S[0], c2, n))
 
@@ -134,11 +162,19 @@ def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm
                     break
             if g == 0:
                 break
-            g =gcd(g,n)
+            g = gcd(g,n)
             if 1 < g:
+                if verbose > 1:
+                    print("\nFactor found.")
                 return g
             R, T = add(R, S[D - 1], T, n), R
 
         g = gcd(g, n)
         if 1 < g < n:
+            if verbose > 1:
+                print("\nFactor found.")
             return g
+
+    if verbose > 1:
+        print(f"\nNo factor after trying {curves} curves.")
+

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools/factor_fmt.py

@@ -2,11 +2,13 @@
 Integer factorization: Fermat's method
 """
 
-from math import isqrt
+from math import isqrt, log10, floor, log10
 
 
-def factor_fermat(n: int) -> list:
+def factor_fermat(n: int, maxsteps: int|None = None, verbose: int = 0) -> list:
     """Find factors of n using the method of Fermat."""
+    if verbose:
+        print(f"Factoring (Fermat): {n} ({floor(log10(n)) + 1} digits)")
     factors = []
     parameters = {11: (12, 6), 23: (12, 0),
                   5: (6, 3), 17: (6, 3),
@@ -20,11 +22,23 @@ def factor_fermat(n: int) -> list:
     start = isqrt(n - 1) + 1
     step, mod = parameters[n % 24]
     start += (mod - start) % step
-    for a in range(start, (n + 9) // 6 + 1, step):
+    if verbose > 1:
+        print("Working ", end= "")
+    maxa = (n + 9) // 6 + 1
+    if maxsteps:
+        maxsteps = max(1, maxsteps)
+        maxa = min(maxa, start + maxsteps * step + 1)
+    for a in range(start, maxa, step):
+        if verbose > 1:
+            print(".", end= "")
         b = isqrt(a * a - n)
         if b * b == a * a - n:
             factors.append(a - b)
             factors.append(a + b)
+            if verbose > 1:
+                print("")
             return factors
     factors.append(n)
+    if verbose > 1:
+        print("")
     return factors

kryptools-0.9.7/kryptools/factor_pm1.py

@@ -0,0 +1,83 @@
+"""
+Integer factorization: Pollard's p-1 method
+"""
+
+from math import gcd, log, isqrt, floor, log10
+from .primes import sieve_eratosthenes
+
+def _pm1_parameters(B1: int, B2: int|None = None, primes: tuple = None) -> tuple:
+    "Precompute parameters for the p-1 method."
+    if not B2:
+        B2 = 100 * B1
+    if not primes:
+        primes = sieve_eratosthenes(B2)
+
+    stage_one = 1
+    stage_two_deltas = []
+    pp = 0
+    for p in primes:
+        if p <= B1:
+            stage_one *= p**int(log(B1, p))
+        elif p <= B2:
+            stage_two_deltas.append(p - pp)  # pylint: disable=W0631
+            pp = p
+        if p > B2:
+            break
+
+    return stage_one, stage_two_deltas
+
+
+def factor_pm1(n: int, B1: int|None = None, B2: int|None = None, x: int = 2, pm1_parameters: tuple = None, verbose: int = 0) -> int|None:
+    "Factors a number n using Pollard's p-1 method."
+    if pm1_parameters:
+        B1, B2, stage_one, stage_two_deltas = pm1_parameters
+    else:
+        if not B1:
+            B1 = min(1000_000, isqrt(n)//50 + 2)
+        stage_one, stage_two_deltas = _pm1_parameters(B1, B2)
+
+    if verbose:
+        print(f"Factoring (Pollard p-1, B1={B1}, B2={B2}): {n} ({floor(log10(n)) + 1} digits)")
+
+    # stage one
+    if verbose > 1:
+        print("Working 1", end= "")
+    x = pow(x, stage_one, n)
+    g = gcd(x - 1, n)
+    if g == n:
+        if verbose > 1:
+            print("")
+        return None
+    if 1 < g:
+        if verbose > 1:
+            print("\nFactor found.")
+        return g
+
+    if verbose > 1:
+        print("2", end= "")
+    saved = {}
+    y = pow(x, stage_two_deltas[0], n)
+    D = (y - 1) % n
+    for k, d in enumerate(stage_two_deltas[1:]):
+        if not d in saved:
+            saved[d] = pow(x, d, n)
+        y = y * saved[d] % n
+        D = D * (y - 1) % n
+        if k % 20 == 0:
+            g = gcd(D, n)
+            if g == n:
+                if verbose > 1:
+                    print("")
+                return None
+            if 1 < g:
+                if verbose > 1:
+                    print("\nFactor found.")
+                return g
+    g = gcd(D, n)
+    if 1 < g < n:
+        if verbose > 1:
+            print("\nFactor found.")
+        return g
+    if verbose > 1:
+        print("")
+    return None

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools/factor_qs.py

@@ -2,7 +2,7 @@
 Integer factorization: Quadratic sieve
 """
 
-from math import isqrt, gcd, sqrt, log, exp, ceil
+from math import isqrt, gcd, sqrt, log, exp, ceil, floor, log10
 from .primes import sieve_eratosthenes
 from .nt import legendre_symbol, sqrt_mod
 
@@ -24,7 +24,7 @@ def bytetest(a: bytes, i: int) -> bytes:
     return (a[i1] & 2**i0) != 0
 
 
-def factor_qs(n: int) -> list:
+def factor_qs(n: int, verbose: int = 0) -> int|None:
     """Find factors of n using the quadratic sieve."""
     # first determine the bound B for the factorbase: Choosing B=p^(1/u) Canfield-Erdös-Pomerance gives us
     # the expected running time |B|^2 u^u = u^(u+2) p^(2/u)/log(n). There is no explicit expression for the optimum, hence
@@ -37,10 +37,16 @@ def factor_qs(n: int) -> list:
     B = int(exp(log(n) / u))
     # B = int(exp(0.5 * sqrt( log(n) * log(log(n)) )*( 1 + 1/log(log(n)) )))
 
+    if verbose:
+        print(f"Factoring (QS, B={B}): {n} ({floor(log10(n)) + 1} digits)")
+    if verbose > 1:
+        print(f"Setting up factorbase: B={B}", end="")
     factorbase = []
     for p in sieve_eratosthenes(B):  # compute the factorbase
         ls = legendre_symbol(n, p)
         if ls == 0:  # we already found a factor;-)
+            if verbose > 1:
+                print("\nFound a small prime factor.")
             if n == p:
                 return n
             return p
@@ -49,6 +55,8 @@ def factor_qs(n: int) -> list:
     lf = len(factorbase)  # length of the factorbase (including -1)
     lfb = ceil((lf+1) / 8)  # the number of bytes we need to store a relation
 
+    if verbose > 1:
+        print(f" len={lf}", end ="")
     factorbase_log = [log(p) for p in factorbase]  # we add these up to test if a number will probably factor
     factorbase_root = [0] * lf # compute the roots of n mod p
     for i, p in enumerate(factorbase):
@@ -66,13 +74,18 @@ def factor_qs(n: int) -> list:
         return m
     m2 = 2 * m
 
+    if verbose > 1:
+        print(" done.")
+
     relation_no = -1
     relations = [None] * (lf + 1)  # here we will store the relations in case we found a B-smooth number
     values = [None] * (lf + 1)  # here we will store the values leading to the B-smooth numbers
 
     # set up the sieve
-    sieve_step = 100
-    sieve_bound = sieve_step
+    expected_trys = int(exp(u*log(u/2)/2))+1 # expected number of trys to find a relation for sieved values
+    sieve_bound = max(100, expected_trys * lf)
+    sieve_step = sieve_bound // 10
+
     # start values for the iterators in the positive/negative direction
     iterator_p = [ [0, 0] for _ in range(lf) ]
     iterator_m = [ [0, 0] for _ in range(lf) ]
@@ -122,10 +135,10 @@ def factor_qs(n: int) -> list:
         # print(f'{j:3}', ' '.join(f'{b:08b}' for b in reversed(relation)))
         if index == lf:  # the new relation is linearly dependent: we have found a linear combination of the 0 vector
             # now we need to determine the factors
-            u = 1  # product over all values m - j such that f(m-j) is B-smooth
-            v = 1  # sqrt of the product over all f(m-j) which are B-smooth
+            u = 1  # product over all values m + j such that f(m+j) is B-smooth
+            v = 1  # sqrt of the product over all f(m+j) which are B-smooth
             w = 1  # save nonsquare terms for the next round
-            for i in range(lf):
+            for i in range(lf + 1):
                 if bytetest(relation, lfb * 8 + i):  # select the relations which sum to the 0 vector
                     ui = m + values[i]
                     u = (u * ui) % n
@@ -137,14 +150,20 @@ def factor_qs(n: int) -> list:
             res = gcd(u - v, n)
             if 1 < res < n:
                 return res
+            if verbose > 1:
+                print("X", end="")
             relation_no -= 1  # this one did not work, try again
         else:
             relations[index] = relation
+            if verbose > 1:
+                print(".", end="")
         return None
 
-    while True:
+    for _ in range(expected_trys * lf * 100):
         factors = {} # store the index of the primes dividing j
 
+        if verbose > 1:
+            print("S", end="")
         do_sieve()
 
         for j in sorted(factors.keys(),key=abs):
@@ -157,7 +176,7 @@ def factor_qs(n: int) -> list:
                     v *= -1
                 for i in primes:
                     p = factorbase[i]
-                    k = 1  # per our sieve we already know that p devides v
+                    k = 1  # per our sieve we already know that p divides v
                     v //= p
                     while v % p == 0:  # divide by p as many times as possible
                         k = (k + 1) % 2  # we only want to know if the exponent is even or odd
@@ -167,8 +186,14 @@ def factor_qs(n: int) -> list:
                 if v == 1:
                     res = process_relation(j, mask)
                     if res:
+                        if verbose:
+                            print(f"\nFactor found after {relation_no} relations.")
                         return res
                 del factors[j]
             else:
                 del factors[j]  # the number is unlikely to factor
         sieve_bound += sieve_step  # increase the sieve and continue
+    if verbose > 1:
+        print("")
+    if verbose:
+        print("QS failed.")

kryptools-0.9.7/kryptools/factor_rho.py

@@ -0,0 +1,58 @@
+"""
+Integer factorization: Pollard's rho method
+"""
+
+from math import gcd, isqrt, floor, log10
+from random import randint
+
+
+def factor_rho(n: int, x: int = 2, maxinit: int = 10, maxiter: int = 1000, brent: bool = True, verbose: int = 0) -> int|None:
+    """Factor n using the Pollard's rho method with start value x."""
+    if not maxiter:
+        maxiter = 10 * isqrt(n)  # stop iterating and try a different start value
+
+    def f(x: int) -> int:
+        return (pow(x, 2, n) + 2) % n
+
+    if verbose:
+        print(f"Factoring (Pollard rho, maxinit={maxinit}, maxiter={maxiter}): {n} ({floor(log10(n)) + 1} digits)")
+
+    if verbose > 1:
+        print("Working ", end= "")
+    for _ in range(maxinit):
+        if verbose > 1:
+            print("X", end= "")
+        if not brent:  # Floyd's cycle detection algorithm
+            i = 1
+            x = f(x)  # x_1=f(x_0)
+            y = f(x)  # y_1=f(f(x_0))
+            while gcd(x - y, n) == 1 and i < maxiter:
+                if verbose > 1 and i % 100 == 0:
+                    print(".", end= "")
+                i += 1
+                x = f(x)  # f(x_j)
+                y = f(y)
+                y = f(y)  # f(f(y_j))
+        else:  # Brent's cycle detection algorithm
+            i = 1  # search for a cycle length k < 2^i
+            k = 1  # cycle length
+            y = f(x)  # f(x_0)
+            while gcd(x - y, n) == 1 and i < maxiter:
+                if verbose > 1 and (i+k) % 100 == 0:
+                    print(".", end= "")
+                if i == k:  # start a new power of 2
+                    x = y
+                    i *= 2
+                    k = 0
+                y = f(y)
+                k += 1
+        # we found a collission (or hit max)
+        tmp = gcd(x - y, n)
+        if 1 < tmp < n:
+            if verbose > 1:
+                print("\nFactor found.")
+            return tmp
+        x = randint(1, n - 1)  # new x_0
+    if verbose > 1:
+        print("")
+

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools/primes.py

@@ -125,12 +125,15 @@ def iroot(k: int, n: int) -> int:
         return n
     if k == 2:
         return isqrt(n)
-    rr = isqrt(n)
+    r = isqrt(n)
+    while r**k >= n:
+        rr = r
+        r = isqrt(r)
     r =rr + 1
     k1 = k-1
     while rr < r:
         r = rr
-        rr = (k1 * r + n // r ** k1) // k # Newton iteration
+        rr = (k1 * rr + n // rr ** k1) // k # Newton iteration
     return r
 
 def perfect_power(n: int) -> tuple|None:
@@ -184,15 +187,16 @@ def lucas_test(n: int) -> bool:
         Qk = pow(Qk, 2, n)
     return False
 
-def is_prime(n: int) -> bool:
+def is_prime(n: int, trialdivision: bool = True) -> bool:
     """Test if an integer `n` if probable prime."""
     # Test small primes
-    for p in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
-              101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
-             211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
-             307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397):
-        if n % p == 0:
-            return n == p
+    if trialdivision:
+        for p in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,
+            101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
+            211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
+            307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397):
+            if n % p == 0:
+                return n == p
     if n < 18446744073709551616:  # https://miller-rabin.appspot.com
         return miller_rabin_test(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022])
     if n < 3317044064679887385961981:

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.5
+Version: 0.9.7
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools

{kryptools-0.9.5 → kryptools-0.9.7}/kryptools.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ kryptools/factor_ecm.py
 kryptools/factor_fmt.py
 kryptools/factor_pm1.py
 kryptools/factor_qs.py
+kryptools/factor_rho.py
 kryptools/la.py
 kryptools/lat.py
 kryptools/nt.py

{kryptools-0.9.5 → kryptools-0.9.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryptools"
-version = "0.9.5"
+version = "0.9.7"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]

kryptools-0.9.5/kryptools/factor_pm1.py

@@ -1,58 +0,0 @@
-"""
-Integer factorization: Pollard's p-1 method
-"""
-
-from math import gcd, log
-from .primes import sieve_eratosthenes
-
-def _pm1_parameters(B1: int, B2: int = None, primes: tuple = None):
-    "Precompute parameters for the P-1 method."
-    if not B2:
-        B2 = 100 * B1
-    if not primes:
-        primes = sieve_eratosthenes(B2)
-
-    stage_one = 1
-    for p in primes:
-        if p > B1:
-            break
-        stage_one *= p**int(log(B1, p))
-
-    stage_two_deltas = []
-    for q in primes:
-        if q <= B1:
-            continue
-        if q > B2:
-            break
-        stage_two_deltas.append(q - p)  # pylint: disable=W0631
-
-    return stage_one, stage_two_deltas
-
-
-def factor_pm1(n: int, B1: int = 11000, B2: int = 1900000, x: int = 2, pm1_parameters: tuple = None):
-    "Factors a number n using Pollard's P-1 method."    
-
-    if pm1_parameters:
-        stage_one, stage_two_deltas = pm1_parameters
-    else:
-        stage_one, stage_two_deltas = _pm1_parameters(B1, B2)
-
-    g = gcd(pow(x, stage_one, n) - 1, n)
-    if 1 < g < n:
-        return g
-    k = 0
-    for d in stage_two_deltas:
-        saved = {}
-        if not d in saved:
-            y = pow(x, d, n)
-            saved[d] = y
-        x = (x * saved[d]) % n
-        k += 1
-        if k % 20 == 0:
-            g = gcd(x-1, n)
-            if 1 < g < n:
-                return g
-    g = gcd(x-1, n)
-    if 1 < g < n:
-        return g
-    return None