kryptools 0.9.7__tar.gz → 0.9.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.7
+Version: 0.9.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
@@ -9,7 +9,7 @@ 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
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -29,7 +29,7 @@ The tools contained are:
 * 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)
+* integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

{kryptools-0.9.7 → kryptools-0.9.9}/README.md

@@ -14,7 +14,7 @@ The tools contained are:
 * 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)
+* integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/Zmod.py

@@ -30,7 +30,11 @@ class Zmod:
         self.group_order = 0
         self.factors = {} # factoring of the group order
 
-    def __call__(self, x: int):
+    def __call__(self, x: int|list|tuple):
+        if isinstance(x, list):
+            return [ZmodPoint(xx, self) for xx in x]
+        elif isinstance(x, tuple):
+            return (ZmodPoint(xx, self) for xx in x)
         return ZmodPoint(x, self)
 
     def __eq__(self, other):
@@ -76,7 +80,7 @@ class Zmod:
 
     def star(self) -> int:
         """Return a list of all elements of the group Z_n^*."""
-        elements = [ 1 ]
+        elements = [ self(1) ]
         for a in range(2, self.n):
             if gcd(a, self.n) > 1:
                 continue
@@ -119,9 +123,7 @@ class ZmodPoint:
         return NotImplemented
 
     def __radd__(self, scalar: int) -> "ZmodPoint":
-        if isinstance(scalar, int):
-            return self.__class__(scalar + self.x, self.ring)
-        return NotImplemented
+        return self + scalar
 
     def __neg__(self) -> "ZmodPoint":
         return self.__class__(-self.x, self.ring)
@@ -139,9 +141,7 @@ class ZmodPoint:
         return NotImplemented
 
     def __rsub__(self, scalar: int) -> "ZmodPoint":
-        if isinstance(scalar, int):
-            return self.__class__(scalar - self.x, self.ring)
-        return NotImplemented
+        return (- self) + scalar
 
     def __mul__(self, other: "ZmodPoint") -> "ZmodPoint":
         if isinstance(other, self.__class__):
@@ -153,9 +153,7 @@ class ZmodPoint:
         return NotImplemented
 
     def __rmul__(self, scalar: int) -> "ZmodPoint":
-        if isinstance(scalar, int):
-            return self.__class__(scalar * self.x, self.ring)
-        return NotImplemented
+        return self * scalar
 
     def __truediv__(self, other: "ZmodPoint") -> "ZmodPoint":
         if isinstance(other, self.__class__):

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/__init__.py

@@ -2,6 +2,12 @@
 Implemenation of same basic algorithms used in cryptography.
 """
 
+__author__ = "Gerald Teschl"
+__copyright__ = "Copyright 2024, Gerald Teschl"
+__license__ = "MIT License"
+__version__ = "0.9.9"
+__email__ = "Gerald.Teschl@univie.ac.at"
+
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, order, crt
 from .primes import sieve_eratosthenes, prime_pi, is_prime, next_prime, previous_prime, random_prime, random_strongprime, is_safeprime, random_safeprime, is_blumprime, random_blumprime, miller_rabin_test, lucas_test
 from .factor import factorint, divisors

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/ec.py

@@ -71,6 +71,10 @@ class EC_Weierstrass():
         return False
 
     def __contains__(self, P: "ECPoint") -> bool:
+        if not isinstance(P, ECPoint) or P.curve != self:
+            return False
+        if P.x is None and P.y is None:
+            return True
         return P.y**2 == P.x**3 + self.a * P.x + self.b
 
     def info(self):
@@ -268,7 +272,7 @@ class ECPoint:
                 else:
                     y = (curve.p - y1) % curve.p
             self.y = curve.gf(y)
-            if not self in curve:
+            if self not in curve:
                 raise ValueError("Point not on curve!")
 
     def __repr__(self):

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/factor.py

@@ -116,7 +116,7 @@ def factorint(n: int, verbose: int = 0, trial_bnd: int = 2500) -> dict:
         B2 += B2 & 1
         num_curves *= 2
         D = isqrt(B2)
-        
+
         if verbose:
             print(f"Round {round+1} (B1={B1})")
 

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/factor_ecm.py

@@ -177,4 +177,3 @@ def factor_ecm(n: int, B1: int|None = None, B2: int|None = None, curves: int = 1
 
     if verbose > 1:
         print(f"\nNo factor after trying {curves} curves.")
-

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/factor_fmt.py

@@ -2,7 +2,7 @@
 Integer factorization: Fermat's method
 """
 
-from math import isqrt, log10, floor, log10
+from math import isqrt, floor, log10
 
 
 def factor_fermat(n: int, maxsteps: int|None = None, verbose: int = 0) -> list:

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

@@ -59,7 +59,7 @@ def factor_pm1(n: int, B1: int|None = None, B2: int|None = None, x: int = 2, pm1
     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:
+        if d not in saved:
             saved[d] = pow(x, d, n)
         y = y * saved[d] % n
         D = D * (y - 1) % n

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/factor_rho.py

@@ -55,4 +55,3 @@ def factor_rho(n: int, x: int = 2, maxinit: int = 10, maxiter: int = 1000, brent
         x = randint(1, n - 1)  # new x_0
     if verbose > 1:
         print("")
-

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/la.py

@@ -23,6 +23,9 @@ class Matrix:
         self.matrix = matrix
         self.cols = len(matrix[0])
         self.rows = len(matrix)
+        for i in range(1, self.rows):
+            if len(matrix[i]) != self.cols:
+                raise ValueError("All matrix rows must have equal length!")
         if ring:
             self.map(ring)
 
@@ -62,11 +65,11 @@ class Matrix:
                 cols = i
             else:
                 cols = range(self.cols)[j]
-            return Matrix([[self.matrix[i][j] for j in cols] for i in rows])
+            return self.__class__([[self.matrix[i][j] for j in cols] for i in rows])
         if isinstance(item, int):
             i, j = divmod(item, self.cols)
             return self.matrix[i][j]
-        return Matrix([self.matrix[k // self.cols][k % self.cols] for k in range(self.cols * self.rows)[item]])
+        return self.__class__([self.matrix[k // self.cols][k % self.cols] for k in range(self.cols * self.rows)[item]])
 
     def __setitem__(self, item, value):
         if isinstance(item, tuple):
@@ -89,15 +92,24 @@ class Matrix:
             for i, ii in zip(cols,range(len(cols))):
                 for j, jj in zip(rows,range(len(rows))):
                     self.matrix[j][i] = value[jj,ii]
-            return
-        i, j = divmod(item, self.cols)
-        self.matrix[i][j] = value
+        elif isinstance(item, int):
+            i, j = divmod(item, self.cols)
+            self.matrix[i][j] = value
+        else:
+            for k in range(self.cols * self.rows)[item]:
+                i, j = divmod(k, self.cols)
+                self.matrix[i][j] = value[k]
 
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
-        return self.matrix == other.matrix
+        if self.rows != other.rows or self.cols != other.cols:
+            return False
+        return any([ self[i] == other[i] for i in range(self.rows * self.cols) ])
 
+    def __bool__(self):
+        return any([ bool(self[i]) for i in range(self.rows * self.cols) ])
+    
     def map(self, func):
         "Apply a function to all elements in place."
         for row in self.matrix:
@@ -156,14 +168,14 @@ class Matrix:
         if isinstance(other, Matrix):
             if other.cols != self.cols or other.rows != self.rows:
                 raise NotImplementedError("Matrix dimensions do not match!")
-            return Matrix([ [ x1 + y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
+            return self.__class__([ [ x1 + y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
         return NotImplemented
 
     def __sub__(self, other) -> "Matrix":
         if isinstance(other, Matrix):
             if other.cols != self.cols or other.rows != self.rows:
                 raise NotImplementedError("Matrix dimensions do not match!")
-            return Matrix([ [ x1 - y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
+            return self.__class__([ [ x1 - y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
         return NotImplemented
 
     def __neg__(self) -> "Matrix":
@@ -175,13 +187,13 @@ class Matrix:
     def __mul__(self, other) -> "Matrix":
         if isinstance(other, Matrix):
             return self.multiply(other)
-        if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
-            return Matrix([ [item * other for item in row] for row in self.matrix ])
+        if isinstance(other, Number) or type(other) is type(self.matrix[0][0]):
+            return self.__class__([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def __rmul__(self, other) -> "Matrix":
-        if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
-            return Matrix([ [item * other for item in row] for row in self.matrix ])
+        if isinstance(other, Number) or type(other) is type(self.matrix[0][0]):
+            return self.__class__([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def rref(self) -> "Matrix":
@@ -242,7 +254,7 @@ class Matrix:
         if self.rows != self.cols:
             raise ValueError("Matrix must be square!")
         n = self.cols
-        MM = Matrix([[0 for _ in range(2*n)] for _ in range(n)])
+        MM = self.__class__([[0 for _ in range(2*n)] for _ in range(n)])
         for i in range(n):
             MM[i,n+i] = 1
         MM[:,0:n] = self
@@ -271,7 +283,7 @@ class Matrix:
             zero = 0 * self[0]
         except:
             zero = 0
-        return Matrix([[ zero for j in range(n) ] for i in range(m) ])
+        return self.__class__([[ zero for j in range(n) ] for i in range(m) ])
 
     def eye(self, m: int = None, n: int = None):
         "Returns an identity matrix of the same dimension."
@@ -287,8 +299,11 @@ class Matrix:
             zero = 0 * self[0]
         except:
             zero = 0
-        one = 1 + zero
-        return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])
+        try:
+            one = zero**0
+        except:
+            one = 1
+        return self.__class__([[ delta(i, j) for j in range(n) ] for i in range(m) ])
 
 
 def zeros(m: int, n: int = None, zero = 0) -> "Matrix":

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/nt.py

@@ -143,6 +143,8 @@ def carmichael_lambda(n: int) -> int:
     """Carmichael's lambda function of `n`."""
     if not isinstance(n, int) or n < 1:
         raise ValueError(f"{n} is not a positive integer")
+    if n == 1:
+        return 1
     k = factorint(n)
     lam_all = []  # values corresponding to the prime factors
     for p in k:
@@ -224,7 +226,7 @@ def crt(a: list[int], m: list[int], coprime = True) -> int:
                 if g == 1: # moduli are coprime, nothing to be done
                     continue
                 if (a[i] - a[j]) % g:
-                     raise ValueError(f"Congruences not solvable!")
+                    raise ValueError("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:

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/poly.py

@@ -55,8 +55,9 @@ class Poly:
                 return "x"
             return "x^" + str(i)
 
-        if len(self.coeff) == 1:
+        if not self:
             return str(self.coeff[0])
+        one = self.coeff[0]**0
         plus = ""
         tmp = ""
         coef_range = range(len(self.coeff))
@@ -66,12 +67,12 @@ class Poly:
             s = self.coeff[i]
             if not s:
                 continue
-            if not s - 1 and i != 0:
+            if not s - one and i != 0:
                 tmp += plus + prx(i)
                 plus = " + "
                 continue
             try:
-                if s == -1 and i != 0:
+                if not s + one and i != 0:
                     if plus:
                         plus = " "
                     tmp += plus + "- " + prx(i)
@@ -96,7 +97,7 @@ class Poly:
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
-        return self.coeff == other.coeff
+        return not bool(self - other)
 
     def __bool__(self):
         return bool(self.degree()) or bool(self.coeff[0])
@@ -116,7 +117,18 @@ class Poly:
     def _check_type(self, other):
         return isinstance(other, int) or (isinstance(other, Number) and isinstance(self.coeff[0], Number)) or type(other) == type(self.coeff[0])
 
+    def _guess_ring(self):
+        zero = 0 * self.coeff[0]
+        try:
+            ring = type(zero)
+            one = ring(1)
+        except:
+            ring = None
+            one = zero**0  # zero + 1
+        return zero, one, ring
+
     def __add__(self, other: "Poly") -> "Poly":
+        zero = 0 * self.coeff[0]
         if not isinstance(other, self.__class__):
             if self._check_type(other):
                 tmp = self.coeff[:]
@@ -125,11 +137,11 @@ class Poly:
             return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
-            scoeff = self.coeff + (lo - ls) * [0]
+            scoeff = self.coeff + (lo - ls) * [zero]
         else:
             scoeff = self.coeff
         if ls > lo:
-            ocoeff = other.coeff + (ls - lo) * [0]
+            ocoeff = other.coeff + (ls - lo) * [zero]
         else:
             ocoeff = other.coeff
         modulus = self.modulus
@@ -138,12 +150,7 @@ class Poly:
         return self.__class__([s + o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
 
     def __radd__(self, other: "Poly") -> "Poly":
-        if not isinstance(other, self.__class__):
-            if self._check_type(other):
-                tmp = self.coeff[:]
-                tmp[0] += other
-                return self.__class__(tmp, modulus=self.modulus)
-        return NotImplemented
+        return self + other
 
     def __neg__(self) -> "Poly":
         return Poly([-s for s in self.coeff], modulus=self.modulus)
@@ -152,57 +159,33 @@ class Poly:
         return self
 
     def __sub__(self, other: "Poly") -> "Poly":
-        if not isinstance(other, self.__class__):
-            if self._check_type(other):
-                tmp = self.coeff[:]
-                tmp[0] -= other
-                return self.__class__(tmp, modulus=self.modulus)
-            return NotImplemented
-        ls, lo = len(self.coeff), len(other.coeff)
-        if ls < lo:
-            scoeff = self.coeff + (lo - ls) * [0]
-        else:
-            scoeff = self.coeff
-        if ls > lo:
-            ocoeff = other.coeff + (ls - lo) * [0]
-        else:
-            ocoeff = other.coeff
-        modulus = self.modulus
-        if not modulus and other.modulus:
-            modulus = other.modulus
-        return self.__class__([s - o for s, o in zip(scoeff, ocoeff)], modulus = modulus)
+        return self + (- other)
 
     def __rsub__(self, other: "Poly") -> "Poly":
-        if not isinstance(other, self.__class__):
-            if self._check_type(other):
-                tmp = self.coeff[:]
-                tmp[0] -= other
-                return self.__class__(tmp, modulus=self.modulus)
-        return NotImplemented
+        return (- self) + other
 
     def __mul__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
             if self._check_type(other):
                 return Poly([other * s for s in self.coeff], modulus = self.modulus)
             return NotImplemented
+        zero = 0 * self.coeff[0]
         ls, lo = len(self.coeff), len(other.coeff)
-        coeff = [0] * (ls + lo - 1)
+        coeff = [None] * (ls + lo - 1)
         for k in range(ls + lo - 1):
             coeff[k] = sum(
                 [
                     self.coeff[j] * other.coeff[k - j]
                     for j in range(max(0, k - lo + 1), min(ls, k + 1))
                 ]
-            )
+            , start = zero)
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
         return self.__class__(coeff, modulus = modulus)
 
     def __rmul__(self, other) -> "Poly":
-        if self._check_type(other):
-            return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
-        return NotImplemented
+        return self * other
 
     def __truediv__(self, other) -> "Poly":
         if self._check_type(other):
@@ -221,8 +204,7 @@ class Poly:
     def __pow__(self, j: int) -> "Poly":
         if not isinstance(j, int):
             return NotImplemented
-        zero = 0 * self.coeff[0]
-        one = zero + 1
+        one = self.coeff[0]**0
         res = self.__class__([one], modulus=self.modulus)
         if j < 0:
             if not self.modulus:
@@ -256,39 +238,39 @@ class Poly:
 
     def divmod(self, other: "Poly") -> ("Poly", "Poly"):
         "Polynom division with remainder."
+        zero, one, ring = self._guess_ring()
         if isinstance(other, list):
-            other = self.__class__(other)
+            other = self.__class__(other , ring = ring)
         elif not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot divide {self} and {other}.")
         if not other:
             raise ValueError(f"{other} must be nonzero.")
         sd, od = self.degree(), other.degree()
         if sd < od:
-            return self.__class__([0]), self
-        div = [0] * (sd - od + 1)
+            return self.__class__([zero]), self
+        div = [zero] * (sd - od + 1)
         lco = other.coeff[-1]
-        if bool(lco - 1):
-            tmp = 1 / lco
+        if bool(lco - one):
+            tmp = one / lco
             oth = [c * tmp for c in other.coeff]
             rem = [c * tmp for c in self.coeff]
         else:
             oth = other.coeff
-            rem = [c for c in self.coeff]
+            rem = [c * one for c in self.coeff] # "* 1" is here to make sure we get a copy
         for i in range(sd - od + 1):
-            tmp = rem[sd - i]
+            tmp = rem[sd - i] * one # "* 1" is here to make sure we get a copy
             div[sd - od - i] = tmp
             for j in range(od + 1):
                 rem[sd - i - j] -= tmp * oth[od - j]
-        if bool(lco - 1):
+        if bool(lco - one):
             rem = [c * lco for c in rem]
-        return self.__class__(div, modulus=self.modulus), self.__class__(
-            rem, modulus=self.modulus
-        )
+        return self.__class__(div, modulus=self.modulus), self.__class__(rem, modulus=self.modulus)
 
     def mod(self, other: "Poly") -> None:
         "Reduce with respect to a given polynomial."
+        one, ring = self._guess_ring()[1:]
         if isinstance(other, list):
-            other = self.__class__(other)
+            other = self.__class__(other , ring = ring)
         elif not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot divide {self} and {other}.")
         if not other:
@@ -297,13 +279,13 @@ class Poly:
         if sd < od:
             return self
         lco = other.coeff[-1]
-        if bool(lco - 1):
-            tmp = 1 / lco
+        if bool(lco - one):
+            tmp = one / lco
             oth = [c * tmp for c in other.coeff]
         else:
             oth = other.coeff
         for i in range(sd - od + 1):
-            tmp = self.coeff[sd - i]
+            tmp = self.coeff[sd - i] * one # "* 1" is here to make sure we get a copy
             for j in range(od + 1):
                 self.coeff[sd - i - j] -= tmp * oth[od - j]
         for i in range(len(self.coeff) - 1, 0, -1):
@@ -315,14 +297,13 @@ class Poly:
         "Inverse modulo a given polynomial."
         if not other:
             other = self.modulus
+        zero, one, ring = self._guess_ring()
         if isinstance(other, list):
-            other = self.__class__(other)
+            other = self.__class__(other , ring = ring)
         elif not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot invert {self} modulo {other}.")
         if not other:
             raise NotImplementedError(f"{other} must be nonzero.")
-        zero = 0 * self.coeff[0]
-        one = zero +1
         r0, r1 = other, self
         y0, y1 = self.__class__([zero], modulus=self.modulus), self.__class__([one], modulus=self.modulus)
         while r1:
@@ -331,7 +312,7 @@ class Poly:
             y0, y1 = y1, y0 - q * y1
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
-        tmp = 1 / r0[0]
+        tmp = one / r0[0]
         for i in range(len(y0)):
             y0.coeff[i] *= tmp
         return y0

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools/primes.py

@@ -72,7 +72,7 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
         if a == 0:
             continue
         b = pow(a, m, n)
-        if b == 1 or b == n - 1:
+        if b in (1, n - 1):
             continue
         for _ in range(1, k):
             b = pow(b, 2, n)
@@ -154,7 +154,7 @@ def lucas_test(n: int) -> bool:
         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
@@ -163,7 +163,7 @@ def lucas_test(n: int) -> bool:
         s += 1
 
     # Selfridge method for choosing D
-    
+
     D = 5
     while True:
         g = gcd(abs(D), n)

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.7
+Version: 0.9.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
@@ -9,7 +9,7 @@ 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
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -29,7 +29,7 @@ The tools contained are:
 * 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)
+* integer factorization (Fermat, Pollard p-1, Pollard rho, Lenstra's ECM, Dixon, basic quadratic sieve)
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)

{kryptools-0.9.7 → kryptools-0.9.9}/kryptools.egg-info/SOURCES.txt

@@ -24,4 +24,13 @@ kryptools/primes.py
 kryptools.egg-info/PKG-INFO
 kryptools.egg-info/SOURCES.txt
 kryptools.egg-info/dependency_links.txt
-kryptools.egg-info/top_level.txt
+kryptools.egg-info/top_level.txt
+tests/test_Zmod.py
+tests/test_dlog.py
+tests/test_ec.py
+tests/test_factor.py
+tests/test_la.py
+tests/test_lat.py
+tests/test_nt.py
+tests/test_poly.py
+tests/test_primes.py

{kryptools-0.9.7 → kryptools-0.9.9}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "kryptools"
-version = "0.9.7"
+version = "0.9.9"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]
 description = "Implemenation of same basic algorithms used in cryptography."
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

kryptools-0.9.9/tests/test_Zmod.py

@@ -0,0 +1,51 @@
+import pytest
+from math import gcd
+from kryptools import Zmod
+
+def test_Zmod():
+	for n in [5, 6]:
+		Z_n = Zmod(n)
+		for a in range(n):
+			aa = Z_n(a)
+			bool(aa) == bool(a)
+			for i in range(4):
+				assert aa ** i == Z_n(pow(a, i, n))
+				if i == 0 or gcd(a, n) == 1:
+					assert aa ** -i == Z_n(pow(a, -i, n))
+				else:
+					with pytest.raises(ValueError):
+						aa ** -i
+			if gcd(a, n) == 1:
+				assert aa ** aa.order() == Z_n(1)
+			else:
+				with pytest.raises(ValueError):
+					aa.order()
+			for b in range(n):
+				bb = Z_n(b)
+				assert aa + bb == Z_n(a + b)
+				assert aa - bb == Z_n(a - b)
+				assert aa * bb == Z_n(a * b)
+				if gcd(b, n) == 1:
+					assert aa / bb == Z_n( a * pow(b, -1, n) )
+
+	Z_5 = Zmod(5)
+	assert Z_5(3).order() == 4
+	assert Z_5(1).is_generator() == False
+	assert Z_5(3).is_generator() == True
+	assert Z_5.generator(all = True) == Z_5([2, 3])
+	assert Z_5.star() == Z_5([1, 2, 3, 4])
+	assert [Z_5(i).sharp() for i in range(Z_5.n)] == [0, 1, 2, -2, -1]
+	assert [abs(Z_5(i)) for i in range(Z_5.n)] == [0, 1, 2, 2, 1]
+	assert str(Z_5(3)) == "3"
+	Z_5.short = False
+	assert str(Z_5(6)) == "1 (mod 5)"
+
+	Z_6 = Zmod(6)
+	assert Z_6(5).order() == 2
+	with pytest.raises(ValueError):
+		Z_6(3).order()
+	assert Z_6(1).is_generator() == False
+	assert Z_6(5).is_generator() == True
+	assert Z_6.generator(all = True) == Z_6([5])
+	assert Z_6.star() == Z_6([1, 5])
+	assert str(Z_6(3)) == "3"

kryptools-0.9.9/tests/test_dlog.py

@@ -0,0 +1,18 @@
+import pytest
+from random import randint, seed
+from kryptools import dlog
+
+seed(0)
+
+with pytest.raises(ValueError):
+	dlog(1, 3, 10)
+
+def test_dlogt():
+	for data in (
+			[557639, 278819, 2],
+			[24570203447, 12285101723, 2],
+			[28031135240181527, 14015567620090763, 2] ):
+		p, m, a = data  # m is the order of a in Z_p
+		x = randint(2, m - 1)
+		b = pow(a, x, p)
+		assert dlog(a, b, p) == x

kryptools-0.9.9/tests/test_ec.py

@@ -0,0 +1,25 @@
+import pytest
+from random import randint, seed
+from kryptools import EC_Weierstrass
+seed(0)
+
+
+def test_EC():
+	ec = EC_Weierstrass(239, 3, 1)
+	O = ec(None, None)  # point at infinity
+	assert O in ec
+	P = ec.random()
+	assert P in ec
+	Q = ec.random()
+	assert Q in ec
+	assert P + O == P
+	assert O + P == P
+	R = O
+	for i in range(5):
+		assert i * P == R
+		R += P
+	assert P + Q == Q + P
+	assert Q.order() * Q == O
+	k = randint(1, ec.order())
+	R = k * Q
+	assert R.dlog(Q) == k

kryptools-0.9.9/tests/test_factor.py

@@ -0,0 +1,18 @@
+import pytest
+from kryptools import factorint, is_prime
+
+def myprod(factors: dict) -> int:
+	n = 1
+	for p in factors:
+		assert is_prime(p)
+		n *= p**factors[p]
+	return n
+
+
+def test_factorint():
+	assert factorint(0) == {0: 1}
+	assert factorint(1) == {}
+	for n in ( 1489576198567193874913874619387459183543154617315437135656,
+				2**128 - 1,
+				4521089809**7 ):
+		assert n == myprod(factorint(n))

kryptools-0.9.9/tests/test_la.py

@@ -0,0 +1,15 @@
+import pytest
+from fractions import Fraction
+from kryptools import Matrix, Zmod
+
+
+def test_Matrix():
+	M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]])
+	M.map(Fraction)
+	Mi = M.inv()
+	assert M * Mi == M.eye()
+
+	Z_11 = Zmod(11)
+	M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]], ring=Z_11)
+	Mi = M.inv()
+	assert M * Mi == M.eye()

kryptools-0.9.9/tests/test_lat.py

@@ -0,0 +1,9 @@
+import pytest
+from fractions import Fraction
+from kryptools import Matrix, gram_schmidt
+
+
+def test_gram_schmidt():
+	V = Matrix([[5, 8], [0, 1]], ring=Fraction)
+	Vs, M = gram_schmidt(V)
+	assert V == Vs * M

kryptools-0.9.9/tests/test_nt.py

@@ -0,0 +1,38 @@
+import pytest
+from kryptools import carmichael_lambda, euler_phi, moebius_mu
+
+#https://oeis.org/A000010
+OEIS_A000010 = [
+		1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8, 12, 10, 22, 8, 20,
+		12, 18, 12, 28, 8, 30, 16, 20, 16, 24, 12, 36, 18, 24, 16, 40, 12, 42, 20, 24, 22,
+		46, 16, 42, 20, 32, 24, 52, 18, 40, 24, 36, 28, 58, 16, 60, 30, 36, 32, 48, 20,
+		66, 32, 44 ]
+
+def test_euler_phi():
+	for n in range(1, len(OEIS_A000010)+1):
+		assert euler_phi(n) == OEIS_A000010[n - 1]
+
+#https://oeis.org/A002322
+OEIS_A002322 = [
+		1, 1, 2, 2, 4, 2, 6, 2, 6, 4, 10, 2, 12, 6, 4, 4, 16, 6, 18, 4, 6, 10, 22, 2, 20,
+		12, 18, 6, 28, 4, 30, 8, 10, 16, 12, 6, 36, 18, 12, 4, 40, 6, 42, 10, 12, 22, 46,
+		4, 42, 20, 16, 12, 52, 18, 20, 6, 18, 28, 58, 4, 60, 30, 6, 16, 12, 10, 66, 16,
+		22, 12, 70, 6, 72, 36, 20, 18, 30, 12, 78, 4, 54 ]
+
+def test_carmichael_lambda():
+	for n in range(1, len(OEIS_A002322)+1):
+		assert carmichael_lambda(n) == OEIS_A002322[n - 1]
+
+#https://oeis.org/A008683
+OEIS_A008683 = [
+		1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, 0, 1, 1, -1, 0,
+		0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, 1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0,
+		0, 1, 0, -1, 0, 1, 0, 1, 1, -1, 0, -1, 1, 0, 0, 1, -1, -1, 0, 1, -1, -1, 0, -1, 1,
+		0, 0, 1, -1 ]
+
+def test_moebius_mu():
+	for n in range(1, len(OEIS_A008683)+1):
+		assert moebius_mu(n) == OEIS_A008683[n - 1]
+
+
+

kryptools-0.9.9/tests/test_poly.py

@@ -0,0 +1,15 @@
+import pytest
+from kryptools import Poly, Zmod
+
+
+def test_Poly():
+	p = Poly([2, 0, 2])
+	q = Poly([1, 2, 3, 4])
+	d, m = q.divmod(p)
+	assert d * p + m == q
+	
+	Z_5 = Zmod(5)
+	p.map(Z_5)
+	q.map(Z_5)
+	d, m = q.divmod(p)
+	assert d * p + m == q

kryptools-0.9.9/tests/test_primes.py

@@ -0,0 +1,27 @@
+import pytest
+from kryptools import sieve_eratosthenes, prime_pi, next_prime, previous_prime
+
+
+#https://oeis.org/A000040
+OEIS_A000010 = [ 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 ]
+
+def test_sieve_eratosthenes():
+	for i, p in enumerate(sieve_eratosthenes(OEIS_A000010[-1])):
+		assert p == OEIS_A000010[i]
+		if i > 0:
+			assert previous_prime(p-1) == OEIS_A000010[i-1]
+		if i < len(OEIS_A000010) - 1:
+			assert next_prime(p+1) == OEIS_A000010[i+1]
+
+#https://oeis.org/A000040
+OEIS_A000720 = [ 0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+	9, 9, 9, 9, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 14, 14, 14, 14,
+	15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 17, 17, 18, 18, 18, 18, 18, 18, 19,
+	19, 19, 19, 20, 20, 21, 21, 21, 21, 21, 21 ]
+
+def test_prime_pi():
+	for n in range(1, len(OEIS_A000720)+1):
+		assert prime_pi(n) == OEIS_A000720[n - 1]