kryptools 0.9.6__tar.gz → 0.9.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.6
+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.6 → kryptools-0.9.7}/kryptools/factor.py

@@ -107,14 +107,21 @@ def factorint(n: int, verbose: int = 0, trial_bnd: int = 2500) -> dict:
     fermat_steps = 10
 
     for round, parameters in enumerate(ECM_PARAMETERS):
-        if verbose:
-            print(f"Round {round+1}")
         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: "fmt", factor_pm1: "pm1", factor_ecm: "ecm"}  #, factor_qs: "qs"}

{kryptools-0.9.6 → 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.6 → kryptools-0.9.7}/kryptools/factor_ecm.py

@@ -49,15 +49,16 @@ def mult(k, P, 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 = None, D: int|None = None, primes: tuple|None = 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:
@@ -86,14 +87,16 @@ def _ecm_parameters(B1: int, B2: int|None = None, D: int|None = None, primes: tu
     return D, stage_one, stage_two_deltas
 
 
-def factor_ecm(n: int, B1: int|None = None, B2: int|None = None, curves: int = 150, ecm_parameters: tuple|None = None, verbose: int = 0):
+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 = max(2, isqrt(n//200))
+            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)
@@ -159,7 +162,7 @@ def factor_ecm(n: int, B1: int|None = None, B2: int|None = None, curves: int = 1
                     break
             if g == 0:
                 break
-            g =gcd(g,n)
+            g = gcd(g,n)
             if 1 < g:
                 if verbose > 1:
                     print("\nFactor found.")
@@ -171,6 +174,7 @@ def factor_ecm(n: int, B1: int|None = None, B2: int|None = None, curves: int = 1
             if verbose > 1:
                 print("\nFactor found.")
             return g
+
     if verbose > 1:
         print(f"\nNo factor after trying {curves} curves.")
 

{kryptools-0.9.6 → kryptools-0.9.7}/kryptools/factor_pm1.py

@@ -2,10 +2,10 @@
 Integer factorization: Pollard's p-1 method
 """
 
-from math import gcd, log, floor, log10
+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):
+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
@@ -27,24 +27,30 @@ def _pm1_parameters(B1: int, B2: int|None = None, primes: tuple = None):
     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)")
-
+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:
-        stage_one, stage_two_deltas = 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:

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

@@ -24,7 +24,7 @@ def bytetest(a: bytes, i: int) -> bytes:
     return (a[i1] & 2**i0) != 0
 
 
-def factor_qs(n: int, verbose: int = 0) -> 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

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.6 → kryptools-0.9.7}/kryptools.egg-info/PKG-INFO

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

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