kryptools 0.2__tar.gz → 0.4__tar.gz

{kryptools-0.2 → kryptools-0.4}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.2
+Version: 0.4
 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
 Project-URL: Issues, https://github.com/teschlg/kryptools/issues
-Project-URL: Docs, https://github.com/teschlg/kryptools/doc
+Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -27,7 +27,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.2 → kryptools-0.4}/README.md

@@ -12,7 +12,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.2 → kryptools-0.4}/kryptools/Zmod.py

@@ -2,6 +2,10 @@
 Ring of intergers modulo `n`.
 """
 
+from math import gcd
+from .factor import factorint
+
+
 class Zmod:
     """
     Ring of intergers modulo `n`.
@@ -20,9 +24,11 @@ class Zmod:
     0 (mod 5)
     """
 
-    def __init__(self, n: int, short: bool = False):
+    def __init__(self, n: int, short: bool = True):
         self.n = n
         self.short = short
+        self.group_order = 0
+        self.factors = {} # factoring of the group order
 
     def __call__(self, x: int):
         return ZmodPoint(x, self)
@@ -35,15 +41,33 @@ class Zmod:
     def __contains__(self, other: "ZmodPoint") -> bool:
         return isinstance(other, ZmodPoint) and self.n == other.ring.n
 
+    def order(self) -> int:
+        """Compute the order of the group Z_n^*."""
+        if self.group_order:
+            return self.group_order
+        # We compute euler_phi(n) and its factorization in one pass
+        for p, k in factorint(self.n).items():  # first factorize n
+            for pm, km in factorint(p - 1).items():  # factor p-1 and add the factors
+                if pm in self.factors:
+                    self.factors[pm] += km
+                else:
+                    self.factors[pm] = km
+            if k > 1:  # if the multiplicity of of p is >1, then we need to add p**(k-1)
+                if p in self.factors:
+                    self.factors[p] += k - 1
+                else:
+                    self.factors[p] = k - 1
+        self.group_order = 1
+        for p, k in self.factors.items():
+            self.group_order *= p**k
+        return self.group_order
+
 
 class ZmodPoint:
     "Represents a point in the ring Zmod."
 
     def __init__(self, x: int, ring: "Zmod"):
-        if isinstance(x, self.__class__) and x.ring.n == ring.n:
-            self.x = int(x)
-        else:
-            self.x = int(x) % ring.n
+        self.x = int(x) % ring.n
         self.ring = ring
 
     def __repr__(self):
@@ -62,11 +86,6 @@ class ZmodPoint:
     def __int__(self):
         return self.x
 
-    def sharp(self):
-        "Returns a symmetric (w.r.t. 0) representative."
-        tmp = (self.ring.n - 1) // 2
-        return (self.x + tmp) % self.ring.n - tmp
-
     def __hash__(self):
         return hash(self.x)
 
@@ -113,3 +132,26 @@ class ZmodPoint:
 
     def __pow__(self, scalar: int) -> "ZmodPoint":
         return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)
+
+    def sharp(self):
+        "Returns a symmetric (w.r.t. 0) representative."
+        tmp = (self.ring.n - 1) // 2
+        return (self.x + tmp) % self.ring.n - tmp
+
+    def order(self) -> int:
+        """Compute the order of the point in the group Z_n^*."""
+        if self.x == 0 or gcd(self.x, self.ring.n) != 1:
+            raise ValueError(f"{self.x} and {self.ring.n} are not coprime!")
+        order = self.ring.order()  # use euler_phi(n) as our current guess
+        for p, k in self.ring.factors.items():
+            for _ in range(k):
+                order_try = order // p
+                if pow(self.x, order_try, self.ring.n) == 1:
+                    order = order_try
+                else:
+                    break
+        return order
+
+    def is_generator(self):
+        """Test if the point is a generator of the group Z_n^*."""
+        return self.ring.order() == self.order()

kryptools-0.4/kryptools/__init__.py

@@ -0,0 +1,13 @@
+"""
+Implemenation of same basic algorithms used in cryptography.
+"""
+
+from .nt import egcd, crt, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, order, carmichael_lambda
+from .primes import sieve_eratosthenes, is_prime, next_prime, random_prime, random_strongprime, is_safeprime, random_safeprime
+from .factor import factorint
+from .dlp import dlog
+from .ec import EC_Weierstrass
+from .la import Matrix, zeros, eye
+from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, lagrange_lr, lll, random_unimodular_matrix
+from .poly import Poly
+from .Zmod import Zmod

{kryptools-0.2 → kryptools-0.4}/kryptools/dlp.py

@@ -28,10 +28,9 @@ def _dlog_switch(a: int, b: int, n: int, m: int) -> int:
     """Compute the discrete log_a(b) in Z_n of an element a of order m choosing an appropriate method."""
     if m < 1000:
         return dlog_naive(a, b, n, m)
-    elif log(m) - 6 < 2 * sqrt(log(n) * log(log(n))):  # compare the theoreticaly expected running times ob bsgs and ic; the constant 6 is determined experimentally
+    if log(m) - 6 < 2 * sqrt(log(n) * log(log(n))):  # compare the theoreticaly expected running times ob bsgs and ic; the constant 6 is determined experimentally
         return dlog_bsgs(a, b, n, m)
-    else:
-        return dlog_qs(a, b, n, m)
+    return dlog_qs(a, b, n, m)
 
 def _dlog_ph(a: int, b: int, n: int, q: int, k: int) -> int:
     """Compute the discrete log_a(b) in Z_n of an element a of order q^k using Pohlig-Hellman reduction."""

{kryptools-0.2 → kryptools-0.4}/kryptools/dlp_ic.py

@@ -69,7 +69,7 @@ def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int =
             rinv = pow(ri, -1, m)
             relation[i] = 1
             for j in range(i+1, len_relations + 1):
-                    relation[j] = rinv * relation[j] % m
+                relation[j] = rinv * relation[j] % m
             relations[i] = relation
             if verbose > 2:
                 print(n_relations, f"rel found (index={i}) :", relation)

{kryptools-0.2 → kryptools-0.4}/kryptools/dlp_qs.py

@@ -50,18 +50,18 @@ def is_smooth(n: int, factorbase: list, factorbase_len: int, smallprimes_len: in
         while n % p == 0:  # divide by p as many times as possible
             factors[i] += 1
             n = n // p
-    if pollard_k: 
+    if pollard_k:
         if gcd(pow(2, pollard_k, n)-1, n) == 1: # Pollard p-1 test
             return None  # most likely not smooth, give up
         for i in range(smallprimes_len, factorbase_len):
             p = factorbase[i]
             while n % p == 0:  # divide by p as many times as possible
                 factors[i] += 1
-                n = n // p    
+                n = n // p
     if n != 1:
         return None  # the number factors if at the end nothing is left
     return factors
-    
+
 def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor: float = None, verbose: int = 0) -> int:
     """
     Compute the discrete log_a(b) in Z_p of an element a of prime order m using Index Calculus with a quadratic sieve.
@@ -104,7 +104,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
             relation += [ 0, x ]
         relation = [0] * sieve_bound + relation # sieve values + primes + b + x
         return relation
-    
+
    # this functions does the linear algebra
     def process_relation(relation: list) -> None or int:
         """Add a new relation to the linear system and keep the system in echelon form."""
@@ -122,10 +122,10 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                     relation[j] = (relation[j] - ri * relations[i][j]) % m
                 continue
             # normalize the first nonzero entry
-            rinv = pow(ri, -1, m)  
+            rinv = pow(ri, -1, m)
             relation[i] = 1
             for j in range(i+1, len_relations + 1):
-                    relation[j] = rinv * relation[j] % m
+                relation[j] = rinv * relation[j] % m
             relations[i] = relation
             if verbose > 2:
                 print(n_relations, f"rel found (index={i}) :", relation)
@@ -143,8 +143,8 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
         #        if ri > 0:
         #            relations[i][index] = 0
         #            for j in range(index+1, len_relations + 1):
-        #                relations[i][j] = (relations[i][j] - ri * relation[j]) % m           
-        #print(n_relations, f"i={i}={index} ({len_relations})", relations)       
+        #                relations[i][j] = (relations[i][j] - ri * relation[j]) % m
+        #print(n_relations, f"i={i}={index} ({len_relations})", relations)
         if index == len_relations - 1:  # we found the solution
             if verbose:
                 print(f"Success after {n_relations} relations out of {len_relations}.")
@@ -160,7 +160,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     # Determine the parameters
     #
 
-    B, expected_trys, expected_trys2 = determine_factorbound(n) 
+    B, expected_trys, expected_trys2 = determine_factorbound(n)
     max_trys = 10 * expected_trys
     factorbase = []
     factorbase = tuple(p for p in sieve_eratosthenes(B) if gcd(p,n) == 1)  # compute the factorbse
@@ -172,7 +172,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     if pollard:  # should we speed up trial division with Pollard p-1
         smallprimes_len, pollard_k = determine_trialdivison_bounds(B // 150, factorbase)
     no_sieve_bound = 1  # We do not sieve for primes smaller than this bound (not worth the effort)
-    no_sieve_primes = [ ]  
+    no_sieve_primes = [ ]
     for i in range(factorbase_len):
         if factorbase[i] > no_sieve_bound:
             break
@@ -195,7 +195,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     #
     # Do the sieving
     #
-    
+
     sn = isqrt(n - 1) + 1 # ceil(sqrt(n))
     d = sn**2 - n
     sn2 = 2 * sn
@@ -203,7 +203,6 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     for j in range(sieve_bound):
         # we sieve with respect to the quadratic polynomial f_j(x) = (x+sn)*(x+j+sn) - n = x^2 + (2*sn+j)*x + (d+j*sn)
         snj = sn2 + j
-        snj2 = snj**2
         dj = d + j * sn
         max_j = sieve_bound - j
         for i in range(factorbase_len):
@@ -294,5 +293,5 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                 res = process_relation(relation)
                 if res:
                     return(res)
- 
+
     raise Exception(f"Sorry, Quadratic sieve could not find enough relations! ({n_relations} - {n_relations_redundant} = {n_relations - n_relations_redundant} out of {len_relations}). Try to increase sieve_factor={sieve_factor}")

{kryptools-0.2 → kryptools-0.4}/kryptools/ec.py

@@ -7,6 +7,7 @@ from random import randint
 from .factor import factorint
 from .nt import legendre_symbol, sqrt_mod, crt
 from .Zmod import Zmod
+from .poly import Poly
 
 class EC_Weierstrass():
     """
@@ -26,27 +27,29 @@ class EC_Weierstrass():
     >>> P + Q
     (195, 41)
     """
+    # pylint: disable=too-many-instance-attributes
 
     def __init__(self, p: int, a: int, b: int, order: int = None):
         if p < 3:
             raise ValueError(f"{p} must be a prime larger than 2.")
         if (4 * pow(a, 3, p) + 27 * pow(b, 2, p) ) % p == 0:
-            raise ValueError(f"Curve is singular!")
+            raise ValueError("Curve is singular!")
         self.p = p
         self.gf = Zmod(p, short = True)
         self.a = self.gf(a % p)
         self.b = self.gf(b % p)
         self.group_order = order
         self.group_order_factors = None
+        self.psi_list = [ Poly([ 0 ], ring = self.gf ) ] # division polynomials
         self.short = False  # display points in short format
         self.hex = False  # display points as hex values in compressed format
 
     def __call__(self, x: int | str | None = None, y: int | None = None, short: bool = False):
         if isinstance(x, str):
             x = x.replace(" ", "")
-            type = x[:2]
+            coordinate_type = x[:2]
             x = x[2:]
-            if type == '02' or type == '03':
+            if coordinate_type in ('02', '03'):
                 short = 1
                 x = int(x, 16)
                 if type == '02':
@@ -70,15 +73,17 @@ class EC_Weierstrass():
         return P.y**2 == P.x**3 + self.a * P.x + self.b
 
     def info(self):
-        format = "Weierstrass curve y^2 = x^3"
+        "Display some basic info on the curve"
+        out = "Weierstrass curve y^2 = x^3"
         if int(self.a):
-            format += f" + {self.a} x"
+            out += f" + {self.a} x"
         if int(self.b):
-            format += f" + {self.b}"
-        format += f" over Z_{self.p}."
-        print(format)
+            out += f" + {self.b}"
+        out += f" over Z_{self.p}."
+        print(out)
 
     def add(self, x1, y1, x2, y2):
+        "Point addition"
         if x1 is None:
             return x2, y2
         if x2 is None:
@@ -93,6 +98,7 @@ class EC_Weierstrass():
         return x3, y3
 
     def dbl(self, x, y):
+        "Point doubling"
         if x is None or not y:
             return None, None
         s = (3 * x**2 + self.a) / (2 * y)
@@ -101,6 +107,7 @@ class EC_Weierstrass():
         return x3, y3
 
     def mult(self, j: int, x, y):  # Addition-subtraction ladder
+        "Point multiplication"
         if j == 0:
             return None, None
         if j < 0:
@@ -126,6 +133,7 @@ class EC_Weierstrass():
         return xx, yy
 
     def random(self):
+        "Return a random point."
         j = -1
         while j == -1:
             x = self.gf(randint(0, self.p - 1))
@@ -133,7 +141,30 @@ class EC_Weierstrass():
             j = legendre_symbol(y2, self.p)
         return ECPoint(x, randint(0, 1), self, short = True)
 
+    def psi(self, n: int):
+        """The x-part of the n'th division polynomial."""
+
+        if len(self.psi_list) < 5:
+            self.psi_list = [ Poly([i], ring = self.gf) for i in range(3)]
+            self.psi_list += [ Poly([-self.a * self.a, 12 * self.b, 6 * self.a, 0, 3], ring = self.gf) ]
+            self.psi_list += [ Poly([-4 * self.a**3 - 32 * self.b * self.b, -16 * self.a * self.b, -20 * self.a * self.a, 80 * self.b, 20 * self.a, 0, 4], ring = self.gf) ]
+        if len(self.psi_list) < n + 1:
+            y2 = Poly([self.b, self.a, 0, 1], ring = self.gf)**2
+            ti = 1 / self.gf(2)
+            for m in range(len(self.psi_list), n + 1):
+                if m % 2:  # odd
+                    m = (m - 1) // 2
+                    if m % 2:
+                        self.psi_list += [ self.psi_list[m + 2] * self.psi_list[m]**3 - y2 * self.psi_list[m - 1] * self.psi_list[m + 1]**3]
+                    else:
+                        self.psi_list += [ y2 * self.psi_list[m + 2] * self.psi_list[m]**3 - self.psi_list[m - 1] * self.psi_list[m + 1]**3]
+                else:  # even
+                    m = m // 2
+                    self.psi_list += [ ti * self.psi_list[m] * (self.psi_list[m + 2] * self.psi_list[m - 1]**2 - self.psi_list[m - 2] * self.psi_list[m + 1]**2) ]
+        return self.psi_list[n]
+
     def order(self, order: int = None) -> int:
+        "Return the group order."
         if order:
             self.group_order = order
         elif not self.group_order:
@@ -144,6 +175,7 @@ class EC_Weierstrass():
         return self.group_order
 
     def factor_order(self) -> dict:
+        "Factor the group order."
         if self.group_order_factors:
             return self.group_order_factors
         if not self.group_order:
@@ -152,6 +184,7 @@ class EC_Weierstrass():
         return self.group_order_factors
 
     def order_naive(self) -> int:
+        "Return the order of the group by adding the Legendre symbols."
         a1 = (int(self.a) + 1) % self.p
         y = int(self.b)
         order = self.p + 1 + legendre_symbol(y, self.p)
@@ -161,6 +194,7 @@ class EC_Weierstrass():
         return order
 
     def order_shanks_mestre(self) -> int:
+        "Return the order of the group using the Shanks-Mestre algorithm."
         if self.p < 230:
             return self.order_naive()
         j = 1
@@ -215,7 +249,7 @@ class EC_Weierstrass():
 
 class ECPoint:
     "Point on an elliptic curve"
-    def __init__(self, x: int, y: int, curve: EC_Weierstrass, short:bool = False):
+    def __init__(self, x: int|None, y: int|None, curve: EC_Weierstrass, short:bool = False):
         self.curve = curve
         if x is None:
             self.x = None
@@ -301,17 +335,23 @@ class ECPoint:
                     break
         return order
 
-    def dlog(Q, P: "ECPoint") -> int:
+    def psi(self, n: int):
+        """Value of the n'th division polynomial."""
+        if n % 2:
+            return self.curve.psi(n)(self.x)
+        return self.y * self.curve.psi(n)(self.x)
+
+    def dlog(self, other: "ECPoint") -> int:
         """Compute the discrete log_P(Q) in EC."""
-        m = P.order()
+        m = other.order()
         mf = factorint(m)
-        assert m * Q == P.curve(None, None), "DLP not solvable."
+        assert m * self == other.curve(None, None), "DLP not solvable."
         # We first use Pohlig-Hellman to split m into powers of prime factors
         mm = []
         ll = []
         for pj, kj in mf.items():
-            Pj = (m // pj**kj) * P
-            Qj = (m // pj**kj) * Q
+            Pj = (m // pj**kj) * other
+            Qj = (m // pj**kj) * self
             l = Qj.dlog_ph(Pj, pj, kj)
             if l is None:
                 return None
@@ -319,60 +359,60 @@ class ECPoint:
             ll += [l]
         return crt(ll, mm)
 
-    def dlog_ph(Q, P: "ECPoint", q: int, k: int) -> int:
+    def dlog_ph(self, other: "ECPoint", q: int, k: int) -> int:
         """Compute the discrete log_P(Q) in EC if P has order q^k using Pohlig-Hellman reduction."""
         if k == 1 or q**k < 10000:
-            return Q.dlog_switch(P, q**k)
-        Pj = q**(k - 1) * P
+            return self.dlog_switch(other, q**k)
+        Pj = q**(k - 1) * self
         P1 = Pj
-        Qj = q**(k - 1) * Q
+        Qj = q**(k - 1) * other
         xj = Qj.dlog_switch(P1, q)
         for j in range(2, k + 1):
-            Pj = q**(k - j) * P
-            Qj = q**(k - j) * Q - xj * Pj
+            Pj = q**(k - j) * self
+            Qj = q**(k - j) * other - xj * Pj
             yj = Qj.dlog_switch(P1, q)
             xj = xj + q ** (j - 1) * yj % q**j
         return xj
 
-    def dlog_switch(Q, P: "ECPoint", m: int) -> int:
+    def dlog_switch(self, other: "ECPoint", m: int) -> int:
         """Compute the discrete log_P(Q) in EC if P has order m choosing an appropriate method."""
         if m < 100:
-            return Q.dlog_naive(P, m)
-        return Q.dlog_bsgs(P, m)
+            return self.dlog_naive(other, m)
+        return self.dlog_bsgs(other, m)
 
-    def dlog_naive(Q, P: "ECPoint", m: int) -> int:
+    def dlog_naive(self, other: "ECPoint", m: int) -> int:
         """Compute the discrete log_P(Q) in EC using an exhaustive search."""
-        if not Q.curve == P.curve and not isinstance(Q, P.__class__):
-            raise ValueError(f"Points must be on the same curve!")
+        if not self.curve == other.curve and not isinstance(self, other.__class__):
+            raise ValueError("Points must be on the same curve!")
         j = 0
         xx, yy = None, None
-        while xx != Q.x:
+        while xx != self.x:
             j += 1
-            xx, yy = P.curve.add(xx, yy, P.x, P.y)
+            xx, yy = self.curve.add(xx, yy, other.x, other.y)
             if xx is None:
                 raise ValueError("DLP not solvabel!")
-        if  yy == Q.y:
+        if  yy == self.y:
             return j
         return m - j
 
-    def dlog_bsgs(Q, P: "ECPoint", m: int) -> int:
+    def dlog_bsgs(self, other: "ECPoint", m: int) -> int:
         """Compute the discrete log_P(Q) in EC if P has order m using Shanks' baby-step-giant-step algorithm."""
-        if not Q.curve == P.curve and not isinstance(P, Q.__class__):
-            raise ValueError(f"Points must be on the same curve!")
+        if not self.curve == other.curve and not isinstance(other, self.__class__):
+            raise ValueError("Points must be on the same curve!")
         mm = 1 + isqrt(m - 1)
         m2 = mm//2 + mm % 1  # we use the group symmetry to halve the number of steps
         # initialize baby_steps table
         baby_steps = {}
-        baby_step = P
+        baby_step = other
         for j in range(1,m2+1):
             baby_steps[int(baby_step.x)] = j, int(baby_step.y)
-            baby_step += P
+            baby_step += other
 
         # now take the giant steps
-        giant_stride = -mm * P
-        giant_step = Q
+        giant_stride = -mm * other
+        giant_step = self
         for l in range(mm+1):
-            if giant_step.x == None:
+            if giant_step.x is None:
                 return l * mm
             if int(giant_step.x) in baby_steps:
                 j = baby_steps[int(giant_step.x)][0]

{kryptools-0.2 → kryptools-0.4}/kryptools/factor.py

@@ -4,7 +4,10 @@ Factorization of integers:
 """
 
 from math import isqrt, gcd
-from .primes import sieve_eratosthenes, isprime
+from .primes import sieve_eratosthenes, is_prime
+from .factor_pm1 import _pm1_parameters, factor_pm1
+from .factor_ecm import _ecm_parameters, factor_ecm
+#from .factor_qs import factor_qs
 
 
 # Factoring
@@ -12,24 +15,18 @@ from .primes import sieve_eratosthenes, isprime
 
 
 def _factor_fermat(n: int, steps: int = 10) -> list:
-    a = isqrt(n - 1) + 1
-    step =2
-    if n % 3 == 2:  # if n % 3 = 2, then a must be a multiple of 3
-        a += 2 - ((a - 1) % 3)
-        step = 3
-    elif (n % 4 == 1) ^ (a & 1):  # if n % 4 = 1,3 then a must be odd, even, respectively
-        a += 1
-    for _ in range(steps):
-        #if a > (n + 9) // 6:
-        #     return
+    "Fermat method"
+    parameters = {11: (12, 6), 23: (12, 0),
+                  5: (6, 3), 17: (6, 3),
+                  19: (4, 2), 7: (4, 0),
+                  1: (2, 1), 13: (2, 1)}
+    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):
         b = isqrt(a * a - n)
         if b * b == a * a - n:
             return a - b
-        a += step
-
-from .factor_pm1 import _pm1_parameters, factor_pm1
-from .factor_ecm import _ecm_parameters, factor_ecm
-#from .factor_qs import factor_qs
 
 def factorint(n: int, verbose: int = 0) -> list:
     "Factor a number."
@@ -42,7 +39,7 @@ def factorint(n: int, verbose: int = 0) -> list:
         for m in mm:
             if m in prime_factors:
                 prime_factors[m] += k
-            elif isprime(m):
+            elif is_prime(m):
                 prime_factors[m] = k
             else:
                 if m in remaining_factors:
@@ -66,7 +63,7 @@ def factorint(n: int, verbose: int = 0) -> list:
         return prime_factors
     if verbose:
         print("Trial division found:", list(prime_factors))
-    if isprime(n):
+    if is_prime(n):
         prime_factors[n] = 1
         return prime_factors
     remaining_factors = { n: 1 }
@@ -130,7 +127,7 @@ def factorint(n: int, verbose: int = 0) -> list:
                 else:
                     remaining_factors[m] = new_factors[m]
             if verbose > 1: print("Remaining: ", remaining_factors)
-   
+
         if len(remaining_factors) == 0:
             return prime_factors
 

{kryptools-0.2 → kryptools-0.4}/kryptools/factor_dix.py

@@ -4,9 +4,27 @@ Integer factorization: Dixon's method
 
 from math import isqrt, gcd, sqrt, log, exp, ceil
 from .primes import sieve_eratosthenes
-from .nt import legendre_symbol, sqrt_mod
+from .nt import legendre_symbol
 from .factor_qs import bytexor, byteset, bytetest
 
+def is_smooth(n: int, factorbase: list, lfb: int) -> bytes or 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."""
+    factors = bytearray(b"\x00") * lfb  # we store the exponents mod 2 as bits
+    if n < 0:
+        byteset(factors, 0)
+        n *= -1
+    for i, p in enumerate(factorbase):
+        k = 0
+        while n % p == 0:  # divide by p as many times as possible
+            k = (k + 1) % 2  # we only need the exponents mod 2
+            n = n // p
+        if k:
+            byteset(factors, i + 1)
+    if n != 1:
+        return None  # the number factors if at the end nothing is left
+    return factors
 
 def factor_dixon(n: int) -> list:
     """Find factors of n using the method of Dixon."""
@@ -19,7 +37,7 @@ def factor_dixon(n: int) -> list:
             2 + 3 * u + 2 * u * log(u)
         )  # Newton iteration
     B = int(exp(log(n) / u))
-    
+
     # B = int(exp(0.5 * sqrt( log(n) * log(log(n)) )*( 1 + 1/log(log(n)) )))
     factorbase = []
     for p in sieve_eratosthenes(B):  # compute the factorbase
@@ -44,7 +62,7 @@ def factor_dixon(n: int) -> list:
         index = lf # this will be the index of the first nonzero entry
         # print(f'{j:3}', ' '.join(f'{b:08b}' for b in reversed(relation)))
         for i in range(lf):
-            if bytetest(relation, i) and relations[i] != None:  # make this entry zero if we can (Gauss elimination)
+            if bytetest(relation, i) and relations[i] is not None:  # make this entry zero if we can (Gauss elimination)
                 bytexor(relation, relations[i])
             if bytetest(relation, i) and index == lf:  # is this the index of the first nonzero entry?
                 index = i
@@ -85,6 +103,5 @@ def factor_dixon(n: int) -> list:
             continue
         res = process_relation(j, relation)
         if res:
-            return(res)
+            return res
     return n
-