kryptools 0.9.15__tar.gz → 1.0__tar.gz

{kryptools-0.9.15 → kryptools-1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: kryptools
-Version: 0.9.15
+Version: 1.0
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

{kryptools-0.9.15 → kryptools-1.0}/kryptools/factor_pm1.py

@@ -6,10 +6,8 @@ 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:
+def _pm1_parameters(B1: int, B2: int, primes: tuple = None) -> tuple:
     "Precompute parameters for the p-1 method."
-    if not B2:
-        B2 = 100 * B1
     if not primes:
         primes = sieve_eratosthenes(B2)
 
@@ -34,28 +32,31 @@ def factor_pm1(n: int, B1: int | None = None, B2: int | None = None, x: int = 2,
         B1, B2, stage_one, stage_two_deltas = pm1_parameters
     else:
         if not B1:
-            B1 = min(1000_000, isqrt(n)//50 + 2)
+            B1 = min(1000_000, isqrt(isqrt(n)) + 2)
+        if not B2 or B2 < B1:
+            B2 = 100 * B1
         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)")
+        print(f"Factoring (Pollard p-1, B1={B1}, B2={B2}): {n} ({floor(log10(n)) + 1} digits)", end ="")
 
     # stage one
     if verbose > 1:
-        print("Working 1", end="")
+        print("\nWorking 1", end="")
     x = pow(x, stage_one, n)
     g = gcd(x - 1, n)
-    if g == n:
-        if verbose > 1:
-            print("")
+    if g == n:  # we hit a multiple of n
+        if verbose:
+             print("\nFailed after stage one.")
         return None
     if 1 < g:
         if verbose > 1:
-            print("\nFactor found.")
+            print("\nFactor found in stage one.")
         return g
 
+    # stage two
     if verbose > 1:
-        print("2", end="")
+        print(",2", end="")
     saved = {}
     y = pow(x, stage_two_deltas[0], n)
     D = (y - 1) % n
@@ -68,17 +69,17 @@ def factor_pm1(n: int, B1: int | None = None, B2: int | None = None, x: int = 2,
             g = gcd(D, n)
             if g == n:
                 if verbose > 1:
-                    print("")
+                    print("\nFailed during stage two.")
                 return None
             if 1 < g:
                 if verbose > 1:
-                    print("\nFactor found.")
+                    print("\nFactor found in stage two.")
                 return g
     g = gcd(D, n)
     if 1 < g < n:
         if verbose > 1:
-            print("\nFactor found.")
+            print("\nFactor found in stage two.")
         return g
-    if verbose > 1:
-        print("")
+    if verbose:
+        print("\nFailed after stage two.")
     return None

{kryptools-0.9.15 → kryptools-1.0}/kryptools/factor_qs.py

@@ -29,7 +29,7 @@ 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
-    # we use Newton
+    # we use Newton's method
     u = 2 * sqrt(log(n) / log(log(n)))  # asymptotic value
     for _ in range(3):
         u = (2 * log(n) + u * u * (2 + log(u))) / (
@@ -47,11 +47,9 @@ def factor_qs(n: int, verbose: int = 0) -> int | None:
         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
+                print("\nFactor base contains a factor.")
             return p
-        if ls == 1:  # we only take primes such that n is quadratic residue
+        if ls == 1:  # we only take primes such that n is a quadratic residue
             factorbase.append(p)
     lf = len(factorbase)  # length of the factorbase (including -1)
     lfb = ceil((lf+1) / 8)  # the number of bytes we need to store a relation
@@ -67,11 +65,13 @@ def factor_qs(n: int, verbose: int = 0) -> int | None:
         if r1 == r2:
             factorbase_root[i] = [r1]
         else:
-            factorbase_root[i] = [r1, -r1 % p]  # pylint: disable=E1130
+            factorbase_root[i] = [r1, r2]
 
     m = isqrt(n - 1) + 1
     d = m**2 - n
-    if d == 0:  # Our number is a square
+    if d == 0:  # our number is a square
+        if verbose > 1:
+            print("\nThe number is a complete square.")
         return m
     m2 = 2 * m
 

{kryptools-0.9.15 → kryptools-1.0}/kryptools/factor_rho.py

@@ -15,10 +15,10 @@ def factor_rho(n: int, x: int = 2, maxinit: int = 10, maxiter: int = 1000, brent
         return (pow(x, 2, n) + 2) % n
 
     if verbose:
-        print(f"Factoring (Pollard rho, maxinit={maxinit}, maxiter={maxiter}): {n} ({floor(log10(n)) + 1} digits)")
+        print(f"Factoring (Pollard rho, maxinit={maxinit}, maxiter={maxiter}): {n} ({floor(log10(n)) + 1} digits)", end="")
 
     if verbose > 1:
-        print("Working ", end="")
+        print("\nWorking ", end="")
     for _ in range(maxinit):
         if verbose > 1:
             print("X", end="")
@@ -54,4 +54,4 @@ def factor_rho(n: int, x: int = 2, maxinit: int = 10, maxiter: int = 1000, brent
             return tmp
         x = randint(1, n - 1)  # new x_0
     if verbose > 1:
-        print("")
+        print("\nFailed.")

{kryptools-0.9.15 → kryptools-1.0}/kryptools/nt.py

@@ -21,8 +21,19 @@ from fractions import Fraction
 
 def egcd(a: int, b: int) -> (int, int, int):
     """Perform the extended Euclidean agorithm. Returns `gcd`, `x`, `y` such that `a x + b y = gcd`."""
-    r0, r1 = a, b
-    x0, x1, y0, y1 = 1, 0, 0, 1
+    if a == 0:
+        if b < 0:
+            return -b, 0, -1
+        return b, 0, 1
+    if a < 0:    
+        r0, r1 = -a, b
+        x0, x1, y0, y1 = -1, 0, 0, 1
+    else:
+        r0, r1 = a, b
+        x0, x1, y0, y1 = 1, 0, 0, 1
+    if b < 0:
+        r1 *= -1
+        y1 = -1
     while r1 != 0:
         q, r = divmod(r0, r1)
         r0, r1 = r1, r

{kryptools-0.9.15 → kryptools-1.0}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: kryptools
-Version: 0.9.15
+Version: 1.0
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

{kryptools-0.9.15 → kryptools-1.0}/kryptools.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ tests/test_dlog.py
 tests/test_ec.py
 tests/test_factor.py
 tests/test_factor_fmt.py
+tests/test_factor_pm1.py
 tests/test_factor_qs.py
 tests/test_intfuncs.py
 tests/test_la.py

{kryptools-0.9.15 → kryptools-1.0}/pyproject.toml

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

kryptools-1.0/tests/test_factor_pm1.py

@@ -0,0 +1,8 @@
+import pytest
+from kryptools.factor_pm1 import factor_pm1
+
+
+def test_pm1():
+    for n in [5421331, 10361963, 406525876951, 558847218052163]:
+        m = factor_pm1(n)
+        assert n % m == 0 and 1 < m < n

{kryptools-0.9.15 → kryptools-1.0}/tests/test_factor_qs.py

@@ -1,5 +1,4 @@
 import pytest
-from kryptools import is_prime
 from kryptools.factor_qs import factor_qs
 
 

{kryptools-0.9.15 → kryptools-1.0}/tests/test_nt.py

@@ -1,6 +1,6 @@
 import pytest
 from random import randint, seed
-from math import prod, lcm
+from math import gcd, prod, lcm
 from fractions import Fraction
 from kryptools import sieve_eratosthenes, is_prime
 from kryptools import egcd, crt, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, carmichael_lambda, euler_phi, moebius_mu, is_carmichael_number
@@ -9,9 +9,10 @@ seed(0)
 
 def test_egcd():
     maxsize = 100
-    for a in range(maxsize):
-        for b in range(maxsize):
+    for a in range(-maxsize, maxsize):
+        for b in range(-maxsize, maxsize):
             g, x, y = egcd(a, b)
+            assert g == gcd(a, b)
             assert x * a + y * b == g