kryptools 0.8__tar.gz → 0.9__tar.gz

{kryptools-0.8 → kryptools-0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.8
+Version: 0.9
 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
@@ -22,18 +22,21 @@ you are welcome to read (and modify) the source. Any suggestions on how to make
 code more readable or make it better are welcome. However, my main goal is to keep
 it simple and readability will be preferred over small speed improvements.
 
+It does not require any external libraries.
+
 The tools contained are:
 
-* number theory: sqrt modulo primes, crt, continued fractions, etc.
-* primes: Sieve of Erathostenes, primality tests
+* number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
+* primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
+* elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
-* lattices: Babai rounding/nearest plane, lattice reduction
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
 * Poly: a class for polynomials (division, modulo)
 * Zmod: a class for the ring of integers modulo an integer
 
 Documentation can be found in the jupyter notebook
-(currently incomplete: use the force, read the source).
+(mostly done, but might not contain everything: use the force, read the source).

{kryptools-0.8 → kryptools-0.9}/README.md

@@ -7,18 +7,21 @@ you are welcome to read (and modify) the source. Any suggestions on how to make
 code more readable or make it better are welcome. However, my main goal is to keep
 it simple and readability will be preferred over small speed improvements.
 
+It does not require any external libraries.
+
 The tools contained are:
 
-* number theory: sqrt modulo primes, crt, continued fractions, etc.
-* primes: Sieve of Erathostenes, primality tests
+* number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
+* primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
+* elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
-* lattices: Babai rounding/nearest plane, lattice reduction
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
 * Poly: a class for polynomials (division, modulo)
 * Zmod: a class for the ring of integers modulo an integer
 
 Documentation can be found in the jupyter notebook
-(currently incomplete: use the force, read the source).
+(mostly done, but might not contain everything: use the force, read the source).

{kryptools-0.8 → kryptools-0.9}/kryptools/__init__.py

@@ -2,7 +2,7 @@
 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 .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, order, crt
 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

{kryptools-0.8 → kryptools-0.9}/kryptools/dlp.py

@@ -22,7 +22,7 @@ def dlog_naive(a: int, b: int, n: int, m: int = None) -> int|None:
         aa = (aa * a) % n
         if aa == b:
             return i + 1
-    return None  # no solution
+    raise ValueError("DLP not solvable.")
 
 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."""
@@ -44,14 +44,12 @@ def _dlog_ph(a: int, b: int, n: int, q: int, k: int) -> int:
         aj = pow(a, q ** (k - j), n)
         bj = pow(b, q ** (k - j), n)
         yj = _dlog_switch(a1, bj * pow(aj, -xj, n) % n, n, q)  # pylint: disable=E1130
-        if yj is None:
-            return None
         xj = xj + q ** (j - 1) * yj % q**j
     return xj
 
 
 def dlog(a: int, b: int, n: int, m: int|None = None) -> int:
-    """Compute the discrete log_a(b) in Z_n of an element a of order m using Pohlig-Hellman reduction."""
+    """Compute the discrete log_a(b) in Z_n of an element `a` of order `m` using Pohlig-Hellman reduction."""
     a %= n
     b %= n
     assert gcd(a, n) == 1, "a and n must be coprime."
@@ -69,8 +67,6 @@ def dlog(a: int, b: int, n: int, m: int|None = None) -> int:
         aj = pow(a, m // pj**kj, n)
         bj = pow(b, m // pj**kj, n)
         l = _dlog_ph(aj, bj, n, pj, kj)
-        if l is None:
-            return None
         mm += [pj**kj]
         ll += [l]
     return crt(ll, mm)

{kryptools-0.8 → kryptools-0.9}/kryptools/dlp_bsgs.py

@@ -26,4 +26,4 @@ def dlog_bsgs(a: int, b: int, n: int, m: int = None) -> int:
         if giant_step in baby_steps:
             return l * mm + baby_steps[giant_step]
         giant_step = giant_step * giant_stride % n
-    return None  # no solution
+    raise ValueError("DLP not solvable.")

{kryptools-0.8 → kryptools-0.9}/kryptools/dlp_qs.py

@@ -292,6 +292,6 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                     relation[x + j] = 1
                 res = process_relation(relation)
                 if res:
-                    return(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.8 → kryptools-0.9}/kryptools/dlp_rho.py

@@ -55,7 +55,7 @@ def dlog_rho(a: int, b: int, n: int, m: int = None, brent=0) -> int:
             l = (((alpha_x - alpha_y) // d) * pow((beta_y - beta_x) // d, -1, mm)) % mm
             while pow(a, l, n) != b:
                 if l >= m:
-                    return None
+                    raise ValueError("DLP not solvable.")
                 l += mm
             return l
         trys -= 1

{kryptools-0.8 → kryptools-0.9}/kryptools/ec.py

@@ -1,5 +1,6 @@
 """
-Elliptic curves
+Elliptic curves:
+    EC_Weierstrass() constructor for a Weierstrass curve y^2 = x^3 + ax + b mod p
 """
 
 from math import isqrt, floor, sqrt
@@ -11,11 +12,11 @@ from .poly import Poly
 
 class EC_Weierstrass():
     """
-    Elliptic curve in Weierstrass normal form y^2 = x^3 + ax + b mod p.
+    Elliptic curve in Weierstrass normal form `y^2 = x^3 + ax + b mod p`.
     
     Example:
     
-    To define an elliptic curve use
+    To define an elliptic curve y^2 = x^3 + 3x + 1 mod 239 use
     >>> ec = EC_Weierstrass(239, 3, 1)
     
     To declare a point on the elliptic curve use

{kryptools-0.8 → kryptools-0.9}/kryptools/factor.py

@@ -28,9 +28,16 @@ def _factor_fermat(n: int, steps: int = 10) -> list:
         if b * b == a * a - n:
             return a - b
 
-def factorint(n: int, verbose: int = 0) -> list:
-    "Factor a number."
+def factorint(n: int, verbose: int = 0) -> dict:
+    "Factor a the ineger `n`."
     prime_factors = {}
+    if not isinstance(n, int):
+        raise ValueError("Number to be factored must be an integer!")
+    if n == 0:
+        return prime_factors
+    if n < 0:
+        n *= -1
+        prime_factors[-1] = 1
 
     def add_factors(m: int, mm: tuple) -> None:
         k = remaining_factors[m]
@@ -96,7 +103,8 @@ def factorint(n: int, verbose: int = 0) -> list:
             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 verbose > 1:
+                        print("Factoring: ",m, "method", methods[method])
                     if method == factor_pm1:
                         tmp = factor_pm1(m, pm1_parameters = pm1_parameters)
                     elif method == factor_ecm:
@@ -131,5 +139,4 @@ def factorint(n: int, verbose: int = 0) -> list:
         if len(remaining_factors) == 0:
             return prime_factors
 
-    print("Incomplete factorization!")
-    return prime_factors, remaining_factors, new_factors
+    raise ValueError("Incomplete factorization:", prime_factors, remaining_factors, new_factors)

{kryptools-0.8 → kryptools-0.9}/kryptools/la.py

@@ -169,6 +169,9 @@ class Matrix:
     def __neg__(self) -> "Matrix":
         return -1 * self
 
+    def __pos__(self) -> "Matrix":
+        return self
+
     def __mul__(self, other) -> "Matrix":
         if isinstance(other, Matrix):
             return self.multiply(other)

{kryptools-0.8 → kryptools-0.9}/kryptools/lat.py

@@ -173,7 +173,7 @@ def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
     return U
 
 def random_unimodular_matrix(n: int, iterations: int = 50, max_val: int = None) -> Matrix:
-    "Create a random unimodular matrix of dimension n."
+    "Create a pseudorandom unimodular matrix of dimension n."
     W = zeros(n)
     for i in range(n):
         for j in range(i, n):

{kryptools-0.8 → kryptools-0.9}/kryptools/nt.py

@@ -1,13 +1,15 @@
 """
 Number theory tools:
     egcd(a,b) extended Euclidean agorithm
-    crt([a1, a2, ...],[m1, m2, ...]) Chinese Remainder Theorem
     cf(Fraction(m,n)) continued fraction expansions
     convergents() convergents of a continued fraction
     legendre_symbol(a, p) compute the Legendre symbol of a with respect to the prime p
     jacobi_symbol(a, n) compute the Jacobi symbol of a with respect to n
     sqrt_mod(n, p) square root of n modulo a prime p
+    euler_phi(n) Euler phi function of n
+    carmichael_lambda(n) Carmichael lambda function of n
     order(a, n) oder of a in the multiplicative group Z_n^*
+    crt([a1, a2, ...],[m1, m2, ...]) Chinese Remainder Theorem
 """
 from math import gcd, lcm, prod
 from fractions import Fraction
@@ -26,83 +28,8 @@ def egcd(a: int, b: int) -> (int, int, int):
     return r0, x0, y0
 
 
-# Chinese remainder theorem
-
-def crt(a: list[int], m: list[int]) -> int:
-    """Solve given linear congruences x % m[j] == a[j] using the Chinese Remainder Theorem."""
-    l = len(a)
-    assert len(m) == l, "The lists of numbers and modules must have equal length."
-    M = prod(m)
-    Mi = [M // m[i] for i in range(l)]
-    MNi = [Mi[i] * pow(Mi[i], -1, m[i]) % M for i in range(l)]
-    return sum([a[i] * MNi[i] % M for i in range(l)]) % M
-
 # Continued fractions
 
-# class Fraction:
-#     "Rationl number"
-#
-#     def __init__(self, numerator: int, denominator: int = 1):
-#         assert denominator, "Denominator must be nozero."
-#         tmp = gcd(denominator, numerator)
-#         if tmp != 1:
-#             denominator //= tmp
-#             numerator //= tmp
-#         self.numerator = numerator
-#         self.denominator = denominator
-#
-#     def __repr__(self):
-#         if self.denominator == 1:
-#             return str(self.numerator)
-#         else:
-#             return str(self.numerator) + "/" + str(self.denominator)
-#
-#     def __eq__(self, other):
-#         if not isinstance(other, self.__class__):
-#             return False
-#         return self.denominator == other.denominator and self.numerator == other.numerator
-#
-#     def __bool__(self):
-#         return self.numerator != 0
-#
-#     def __add__(self, other: "Fraction") -> "Fraction":
-#         if isinstance(other, self.__class__):
-#             return Rational(self.numerator * other.denominator + other.numerator * self.denominator, self.denominator * other.denominator)
-#         if isinstance(other, int):
-#             return Rational(self.numerator + other * self.denominator, self.denominator)
-#         raise ValueError(f"Cannot add {self} and {other}.")
-#
-#     def __neg__(self) -> "Fraction":
-#         return Rational(- self.numerator, self.denominator)
-#
-#     def __sub__(self, other: "Fraction") -> "Fraction":
-#         if isinstance(other, self.__class__):
-#             return Rational(self.numerator * other.denominator - other.numerator * self.denominator, self.denominator * other.denominator)
-#         if isinstance(other, int):
-#             return Rational(self.numerator - other * self.denominator, self.denominator)
-#         raise ValueError(f"Cannot subtract {self} and {other}.")
-#
-#     def __mul__(self, other: "Fraction") -> "Fraction":
-#         if isinstance(other, self.__class__):
-#             return Rational(self.numerator * other.numerator, self.denominator * other.denominator)
-#         if isinstance(other, int):
-#             return Rational(self.numerator * other, self.denominator)
-#         raise ValueError(f"Cannot multiply {self} and {other}.")
-#
-#     def __rmul__(self, other: int) -> "Fraction":
-#         return Rational(self.denominator * other, self.numerator)
-#
-#     def __truediv__(self, other: "Fraction") -> "Fraction":
-#         if isinstance(other, self.__class__):
-#             return Rational(self.numerator * other.denominator, self.denominator * other.numerator)
-#         if isinstance(other, int):
-#             return Rational(self.numerator, self.denominator * other)
-#         raise ValueError(f"Cannot divide {self} and {other}.")
-#
-#     def __pow__(self, scalar: int) -> "Fraction":
-#         return Rational(self.numerator**scalar, self.denominator**scalar)
-
-
 def fraction_repr(self):
     "Representation of a fraction."
     if self.denominator == 1:
@@ -113,7 +40,7 @@ Fraction.__repr__ = fraction_repr
 
 
 def cf(x: Fraction) -> list[int]:
-    "Compute the continued fraction expansion of the rational number m/n."
+    "Compute the continued fraction expansion of the rational fraction `x`."
     res = []
     m = x.numerator
     n = x.denominator
@@ -144,7 +71,7 @@ def convergents(cont_frac: list[int]) -> float:
 # Legendre symbol
 
 def legendre_symbol(a: int, p: int) -> int:
-    """Compute the Legendre symbol of a with respect to the prime p."""
+    """Compute the Legendre symbol of `a` with respect to the prime `p`."""
     a = a % p
     if a == 0:
         return 0
@@ -153,7 +80,7 @@ def legendre_symbol(a: int, p: int) -> int:
     return -1
 
 def jacobi_symbol(a: int, n: int) -> int:
-    """Compute the Jacobi symbol of a with respect to the integer n."""
+    """Compute the Jacobi symbol of `a` with respect to the integer `n`."""
     # Crandall/Pomerance Algorithm 2.3.5
     a = a % n
     t = 1
@@ -260,3 +187,40 @@ def order(a: int, n: int, factor=False) -> int:
     if factor:
         return order_a, factors_order
     return order_a
+
+# Chinese remainder theorem
+
+def crt(a: list[int], m: list[int], coprime = True) -> int:
+    """Solve given linear congruences `x % m[j] == a[j]` using the Chinese Remainder Theorem."""
+    l = len(m)
+    if l != len(a):
+        raise ValueError("The lists of numbers and modules must have equal length.")
+
+    if not coprime: # make a copy
+        m = [ mi for mi in m ]
+        a = [ ai for ai in a ]
+        for i in range(l):
+            for j in range(i + 1,l):
+                g = gcd(m[i], m[j])
+                if g == 1: # moduli are coprime, nothing to be done
+                    continue
+                if (a[i] - a[j]) % g:
+                     raise ValueError(f"Congruences not solvable!")
+                for p, k in factorint(g).items():
+                    p = p**k #  remove this factor from one of the equations
+                    if gcd(m[i] // p, p) == 1:
+                        m[i] //= p
+                        a[i] %= m[i]
+                    else:
+                        m[j] //= p
+                        a[j] %= m[j]                            
+    for i in reversed(range(l)):
+        if m[i] == 1:
+            del m[i]
+            del a[i]
+    l =len(m)
+
+    M = prod(m)
+    Mi = [M // m[i] for i in range(l)]
+    MNi = [Mi[i] * pow(Mi[i], -1, m[i]) % M for i in range(l)]
+    return sum([a[i] * MNi[i] % M for i in range(l)]) % M

{kryptools-0.8 → kryptools-0.9}/kryptools/primes.py

@@ -3,10 +3,10 @@ Tools for prime numbers:
     sieve_eratosthenes(B) a tuple of all primes up to including B
     is_prime(n) test if n is probably prime
     next_prime(n) find the next prime larger or equal n
-    random_prime(l) find a random prime with bit length at least l
-    random_strongprime(l) find a random strong prime with bit length at least l
+    random_prime(l) find a pseudorandom prime with bit length at least l
+    random_strongprime(l) find a pseudorandom strong prime with bit length at least l
     is_safeprime(n) test if n is a safe prime
-    random_safeprime(n) find a random safe prime with bit length at least l and ord(2)=(p-1)/2
+    random_safeprime(n) find a pseudorandom safe prime with bit length at least l and ord(2)=(p-1)/2
     miller_rabin_test(n, b) Miller-Rabin primality test with base b
 """
 from math import isqrt, gcd
@@ -15,8 +15,8 @@ from .nt import jacobi_symbol
 
 # Erathostenes
 
-def sieve_eratosthenes(B: int) -> list:
-    """ "Returns a list of all primes up to (including) max."""
+def sieve_eratosthenes(B: int) -> tuple:
+    """Returns a tuple of all primes up to (including) `B`."""
     B1 = (isqrt(B) -1)//2
     B = (B - 1)//2
     isprime = [True] * (B + 1)  # to begin with, all numbers are potentially prime
@@ -33,7 +33,7 @@ def sieve_eratosthenes(B: int) -> list:
 
 
 def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
-    """Run a Miller-Rabin test with given bases on n."""
+    """Run a Miller-Rabin test with given bases on `n`."""
     if n < 2:
         return False
     if n % 2 == 0:
@@ -58,7 +58,7 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
     return False
 
 def is_prime(n: int) -> bool:
-    """Test if an integer n if probable prime."""
+    """Test if an integer `n` if probable prime."""
     if n < 18446744073709551616:  # https://miller-rabin.appspot.com
         return miller_rabin_test(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022])
     if n < 3317044064679887385961981:
@@ -66,18 +66,18 @@ def is_prime(n: int) -> bool:
     return miller_rabin_test(n, [2]) and _is_strong_lucas_prp(n)  # Baillie–PSW primality test
 
 def next_prime(n: int) -> int:
-    """Find the next prime larger or equal n."""
+    """Find the next prime larger or equal `n`."""
     n |= 1  # make sure n is odd
     while not is_prime(n):
         n += 2
     return n
 
 def random_prime(l: int) -> int:
-    """Find a random prime with bit length at least l."""
+    """Find a pseudorandom prime with bit length at least `l`."""
     return next_prime(randint(2 ** (l - 1), 2**l - 1))
 
 def random_strongprime(l: int) -> int:
-    """Find a random strong prime with bit length at least l using Gordon's algorithm."""
+    """Find a pseudorandom strong prime with bit length at least `l` using Gordon's algorithm."""
     t = random_prime(l)
     s = random_prime(l)
     u = 2 * t
@@ -96,7 +96,7 @@ def is_safeprime(p: int) -> bool:
     return is_prime(p) and is_prime((p - 1) // 2)
 
 def random_safeprime(l: int) -> int:
-    """Find a random safe prime with bit length at least l and ord(2)=(p-1)/2."""
+    """Find a pseudorandom safe prime with bit length at least `l` and `ord(2)=(p-1)/2`."""
     p = randint(2 ** (l - 1), 2**l - 1)
     p = p - (p % 24) + 23
     while not is_safeprime(p):

{kryptools-0.8 → kryptools-0.9}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.8
+Version: 0.9
 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
@@ -22,18 +22,21 @@ you are welcome to read (and modify) the source. Any suggestions on how to make
 code more readable or make it better are welcome. However, my main goal is to keep
 it simple and readability will be preferred over small speed improvements.
 
+It does not require any external libraries.
+
 The tools contained are:
 
-* number theory: sqrt modulo primes, crt, continued fractions, etc.
-* primes: Sieve of Erathostenes, primality tests
+* number theory: sqrt modulo primes, Jacobi/Legendre symbol, Chinese Remainder Theorem, continued fractions, etc.
+* primes: Sieve of Erathostenes, primality tests, generation of random safe/strong primes
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * integer factorization (Fermat, Pollard p-1, Lenstra's ECM, Dixon, basic quadratic sieve)
+* elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
-* lattices: Babai rounding/nearest plane, lattice reduction
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
 * Poly: a class for polynomials (division, modulo)
 * Zmod: a class for the ring of integers modulo an integer
 
 Documentation can be found in the jupyter notebook
-(currently incomplete: use the force, read the source).
+(mostly done, but might not contain everything: use the force, read the source).

{kryptools-0.8 → kryptools-0.9}/pyproject.toml

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