kryptools 0.9.4__tar.gz → 0.9.6__tar.gz

{kryptools-0.9.4 → kryptools-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.4
+Version: 0.9.6
 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.4 → kryptools-0.9.6}/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,8 +104,12 @@ 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):
+        if verbose:
+            print(f"Round {round+1}")
+        fermat_steps += 10
         B1, B2, num_curves = parameters
         num_curves *= 2
         D = isqrt(B2)
@@ -97,20 +117,20 @@ def factorint(n: int, verbose: int = 0) -> dict:
         pm1_parameters = _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 +145,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.4 → kryptools-0.9.6}/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,19 +35,21 @@ 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):
     "Precompute parameters for the ECM method."
 
     # Stage-one/two limits must be even
@@ -84,36 +86,59 @@ 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):
     "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 = max(2, isqrt(n//200))
+        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))
 
@@ -136,9 +161,16 @@ def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm
                 break
             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.4 → kryptools-0.9.6}/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.6/kryptools/factor_pm1.py

@@ -0,0 +1,77 @@
+"""
+Integer factorization: Pollard's p-1 method
+"""
+
+from math import gcd, log, floor, log10
+from .primes import sieve_eratosthenes
+
+def _pm1_parameters(B1: int, B2: int|None = 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
+    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 = 10000, B2: int|None = None, x: int = 2, pm1_parameters: tuple = None, verbose: int = 0):
+    "Factors a number n using Pollard's p-1 method."    
+    if verbose:
+        print(f"Factoring (Pollard p-1, B1={B1}, B2={B2}): {n} ({floor(log10(n)) + 1} digits)")
+
+    if pm1_parameters:
+        stage_one, stage_two_deltas = pm1_parameters
+    else:
+        stage_one, stage_two_deltas = _pm1_parameters(B1, B2)
+
+    # stage one
+    if verbose > 1:
+        print("Working 1", end= "")
+    x = pow(x, stage_one, n)
+    g = gcd(x - 1, n)
+    if g == n:
+        return None
+    if 1 < g:
+        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.4 → kryptools-0.9.6}/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) -> list:
     """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.4 → kryptools-0.9.6}/kryptools/poly.py

@@ -4,6 +4,14 @@ Polynomials
 
 from numbers import Number
 
+display_reversed = True
+
+def poly_style_reversed(value: bool = True) -> None:
+    "Change the order of the coefficients when displaying polynomials."
+    global display_reversed
+    display_reversed = value
+
+
 class Poly:
     """
     Represents a polynomial as a list of coefficients.
@@ -40,7 +48,7 @@ class Poly:
         return len(self.coeff)
 
     def __repr__(self):
-        def prx(i: int):
+        def prx(i: int) -> str:
             if i == 0:
                 return ""
             if i == 1:
@@ -51,7 +59,10 @@ class Poly:
             return str(self.coeff[0])
         plus = ""
         tmp = ""
-        for i in reversed(range(len(self.coeff))):
+        coef_range = range(len(self.coeff))
+        if display_reversed:
+            coef_range = reversed(coef_range)
+        for i in coef_range:
             s = self.coeff[i]
             if not s:
                 continue
@@ -70,11 +81,15 @@ class Poly:
                 pass
             try:
                 if plus and s < 0:
-                    tmp += " - " + str(-s) + " " + prx(i)
+                    tmp += " - " + str(-s)
+                    if i != 0:
+                        tmp += " " + prx(i)
                     continue
             except:
                 pass
-            tmp += plus + str(s) + " " + prx(i)
+            tmp += plus + str(s)
+            if i != 0:
+                tmp += " " + prx(i)
             plus = " + "
         return tmp.strip()
 

{kryptools-0.9.4 → kryptools-0.9.6}/kryptools/primes.py

@@ -13,6 +13,9 @@ Tools for prime numbers:
     random_blumprime(l) find a pseudorandom Blum prime with bit length at least l
     miller_rabin_test(n, b) Miller-Rabin primality test with base b
     lucas_test(n) strong Lucas test
+    perfect_square(n) test if a number is a perfect square
+    perfect_power(n) test if a number is a perfect power
+    iroot(k, n) integer k'th root of n
 """
 from math import isqrt, gcd, floor, ceil
 from random import randint
@@ -51,26 +54,37 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
     """Run a Miller-Rabin test with given bases on `n`."""
     if n < 2:
         return False
-    if n % 2 == 0:
+    if n % 2 == 0:  # make sure n is odd
         return n == 2
+
+    # write n = m 2^k + 1
     m = (n - 1) // 2
     k = 1
     while m % 2 == 0:
         m //= 2
         k += 1
+
     if isinstance(bases, int):
         bases = [bases]
+
     for a in bases:
+        a %= n
+        if a == 0:
+            continue
         b = pow(a, m, n)
         if b == 1 or b == n - 1:
-            return True
+            continue
         for _ in range(1, k):
             b = pow(b, 2, n)
-            if b == 1:
+            if b == 0:  # n and a are not coprime
+                return False
+            if b == 1:  # 1 before -1
                 return False
             if b == n - 1:
-                return True
-    return False
+                break
+        else: # no -1 found
+            return False
+    return True
 
 def _lucas_sequence(n, D, k):
     """Evaluate a Lucas sequence."""
@@ -97,16 +111,59 @@ def _lucas_sequence(n, D, k):
     return U % n, V % n, Qk
 
 
+def perfect_square(n: int) -> int|None:
+    """Returns the root if `n` is a perfect square and None else."""
+    s = isqrt(n)
+    if s*s == n:
+        return s
+
+def iroot(k: int, n: int) -> int:
+    """Compute the integer k'th root of n."""
+    if not isinstance(k, int) or n < 1:
+        raise ValueError(f"{k} is not a positive integer")
+    if k == 1:
+        return n
+    if k == 2:
+        return 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 * rr + n // rr ** k1) // k # Newton iteration
+    return r
+
+def perfect_power(n: int) -> tuple|None:
+    """Returns integers `(m, p)` with `m**p == n` if `n` is a perfect power and None else."""
+    for p in sieve_eratosthenes(n.bit_length() - 1):
+        m = iroot(p, n)
+        if pow(m, p) == n:
+            return (m, p)
+
+
+# https://en.wikipedia.org/wiki/Lucas_pseudoprime#Implementing_a_Lucas_probable_prime_test
+
 def lucas_test(n: int) -> bool:
     """Run a strong Lucas primality test on `n`."""
-
-    # remove powers of 2 from n+1 (= k * 2**s)
+    if n < 2:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    if perfect_square(n) is not None:  # the search for D will not succeed in this case
+        return False
+    
+    # write n = k 2^s - 1
     k = (n + 1) // 2
     s = 1
     while k % 2 == 0:
         k //= 2
         s += 1
-    # gernerate parameters
+
+    # Selfridge method for choosing D
+    
     D = 5
     while True:
         g = gcd(abs(D), n)
@@ -119,9 +176,6 @@ def lucas_test(n: int) -> bool:
         else:
             D = -D + 2
 
-    if D == 0:
-        return False
-
     U, V, Qk = _lucas_sequence(n, D, k)
 
     if U == 0 or V == 0:
@@ -133,8 +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
+    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.4 → kryptools-0.9.6}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.4
+Version: 0.9.6
 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.4 → kryptools-0.9.6}/pyproject.toml

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

kryptools-0.9.4/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