kryptools 0.4__tar.gz → 0.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.4
+Version: 0.6
 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.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 

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

@@ -90,48 +90,66 @@ class ZmodPoint:
         return hash(self.x)
 
     def __add__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if isinstance(other, self.__class__) and self.ring == other.ring:
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot add elements from different rings.")
             return self.__class__(self.x + other.x, self.ring)
         if isinstance(other, int):
             return self.__class__(self.x + other, self.ring)
         return NotImplemented
 
     def __radd__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar + self.x, self.ring)
+        if isinstance(scalar, int):
+            return self.__class__(scalar + self.x, self.ring)
+        return NotImplemented
 
     def __neg__(self) -> "ZmodPoint":
         return self.__class__(-self.x, self.ring)
 
     def __sub__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if isinstance(other, self.__class__) and self.ring == other.ring:
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot subtract elements from different rings.")
             return self.__class__(self.x - other.x, self.ring)
         if isinstance(other, int):
             return self.__class__(self.x - other, self.ring)
         return NotImplemented
 
     def __rsub__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar - self.x, self.ring)
+        if isinstance(scalar, int):
+            return self.__class__(scalar - self.x, self.ring)
+        return NotImplemented
 
     def __mul__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if isinstance(other, self.__class__) and self.ring == other.ring:
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot multiply elements from different rings.")
             return self.__class__(self.x * other.x, self.ring)
         if isinstance(other, int):
             return self.__class__(self.x * other, self.ring)
         return NotImplemented
 
     def __rmul__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar * self.x, self.ring)
+        if isinstance(scalar, int):
+            return self.__class__(scalar * self.x, self.ring)
+        return NotImplemented
 
     def __truediv__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if not isinstance(other, self.__class__) or self.ring != other.ring:
-            return NotImplemented
-        return self.__class__(self.x * pow(other.x, -1, self.ring.n), self.ring)
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot divide elements from different rings.")
+            return self.__class__(self.x * pow(other.x, -1, self.ring.n), self.ring)
+        return NotImplemented
 
     def __rtruediv__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar * pow(self.x, -1, self.ring.n), self.ring)
+        if isinstance(scalar, int):
+            return self.__class__(scalar * pow(self.x, -1, self.ring.n), self.ring)
+        return NotImplemented
 
     def __pow__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)
+        if isinstance(scalar, int):
+            return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)
+        return NotImplemented
 
     def sharp(self):
         "Returns a symmetric (w.r.t. 0) representative."

{kryptools-0.4 → kryptools-0.6}/kryptools/__init__.py

@@ -8,6 +8,6 @@ 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 .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_round_bnd, babai_plane_cvp, babai_plane_bnd, lagrange_lr, lll, random_unimodular_matrix
 from .poly import Poly
 from .Zmod import Zmod

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

@@ -11,7 +11,7 @@ from .dlp_qs import dlog_qs
 from .factor import factorint
 
 
-def dlog_naive(a: int, b: int, n: int, m: int = None) -> int:
+def dlog_naive(a: int, b: int, n: int, m: int = None) -> int|None:
     """Compute the discrete log_a(b) in Z_n of an element a of order m by exhaustive search."""
     a %= n
     b %= n
@@ -43,14 +43,14 @@ def _dlog_ph(a: int, b: int, n: int, q: int, k: int) -> int:
     for j in range(2, k + 1):
         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)
+        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) -> int:
+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."""
     a %= n
     b %= n
@@ -60,7 +60,8 @@ def dlog(a: int, b: int, n: int, m: int = None) -> int:
         mf = factorint(m)
     else:
         m, mf = order(a, n, True)
-    assert pow(b, m, n) == 1, "DLP not solvable."
+    if pow(b, m, n) != 1:
+        raise ValueError("DLP not solvable.")
     # We first use Pohlig-Hellman to split m into powers of prime factors
     mm = []
     ll = []

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

@@ -227,7 +227,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                 if r == 0:
                     roots = [ -(inv2 * aa) % p ]  # one root
                 else:
-                    roots = [ (inv2 * (r - aa)) % p, (inv2 * (-r - aa)) % p ]  # two roots
+                    roots = [ (inv2 * (r - aa)) % p, (inv2 * (-r - aa)) % p ]  # two roots  pylint: disable=E1130
             for r in roots:
                 x = r  # start value for x
                 while x < max_j:
@@ -255,10 +255,10 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
         relation = find_relation(include_b)
         res = process_relation(relation)
         if res:
-            return(res)
+            return res
 
     #
-    # find the B-smooth numbers and add them to the system 
+    # find the B-smooth numbers and add them to the system
     #
 
     for s in range(sieve_bound):

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

@@ -320,7 +320,7 @@ class ECPoint:
     def __neg__(self) -> "ECPoint":
         if self.x is None or not self.y:
             return self
-        return ECPoint(self.x, -self.y, self.curve)
+        return ECPoint(self.x, -self.y, self.curve)  # pylint: disable=E1130
 
     def order(self) -> int:
         """Compute the order of an element."""

{kryptools-0.4 → kryptools-0.6}/kryptools/factor_ecm.py

@@ -84,7 +84,7 @@ def _ecm_parameters(B1: int, B2: int = None, D: int = None, primes: tuple = None
     return D, stage_one, stage_two_deltas
 
 
-def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm_parameters: tuple = None):
+def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm_parameters: tuple|None = None):
     "Factors a number n using Lentsta's ECM method."    
 
     if ecm_parameters:

{kryptools-0.4 → kryptools-0.6}/kryptools/la.py

@@ -3,6 +3,8 @@ Linear algebra
 """
 
 from math import inf, sqrt, prod
+from numbers import Number
+from fractions import Fraction
 
 class Matrix:
     """
@@ -146,15 +148,21 @@ class Matrix:
             for j in range(other.cols):
                 for k in range(other.rows):
                     result.matrix[i][j] += self.matrix[i][k] * other.matrix[k][j]
+        if self.rows == 1 and other.cols == 1:
+            return result.matrix[0][0]
         return result
 
     def __add__(self, other) -> "Matrix":
-        if isinstance(other, Matrix) and other.cols == self.cols and other.rows == self.rows:
+        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 NotImplemented
 
     def __sub__(self, other) -> "Matrix":
-        if isinstance(other, Matrix) and other.cols == self.cols and other.rows == self.rows:
+        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 NotImplemented
 
@@ -164,12 +172,14 @@ class Matrix:
     def __mul__(self, other) -> "Matrix":
         if isinstance(other, Matrix):
             return self.multiply(other)
-        return Matrix([ [item * other for item in row] for row in self.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 ])
+        return NotImplemented
 
     def __rmul__(self, other) -> "Matrix":
-        if isinstance(other, Matrix):
-            return self.multiply(other)
-        return Matrix([ [item * other for item in row] for row in self.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 ])
+        return NotImplemented
 
     def rref(self) -> "Matrix":
         "Compute the reduced echelon form of a matrix M."
@@ -238,6 +248,16 @@ class Matrix:
             raise ValueError("Matrix is not invertible!")
         return MM[:,n:]
 
+    def is_unimodular(self) -> bool:
+        "Test if the matrix is unimodular."
+        if self.rows != self.rows:
+            return False
+        def is_integer(i):
+            if isinstance(i, int) or (isinstance(i, Fraction) and i.denominator == 1):
+                return True
+            return False
+        return all([is_integer(i) for i in self]) and self.det()**2 == 1
+
     def zeros(self, m: int = None, n: int = None):
         "Returns a zero matrix of the same dimension"
         if not m and not n:

{kryptools-0.4 → kryptools-0.6}/kryptools/lat.py

@@ -2,7 +2,7 @@
 Lattice tools
 """
 
-from math import prod
+from math import prod, floor
 from fractions import Fraction
 from random import choice, sample
 from .la import Matrix, zeros
@@ -73,19 +73,28 @@ def hadamard_ratio(M: Matrix) -> float:
     return (gram_det(M) / prod([M[:, i].norm() for i in range(m)])) ** (1 / m)
 
 def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
-    "Babai's rounding algorithm for solving the CVP."
+    "Babai's rounding algorithm for approximately solving the CVP."
     s = U.inv() * x
     k = s.applyfunc(round)
     return U * k
 
+def babai_round_bnd(U: Matrix) -> float:
+    "Bound for Babai's rounding algorithm for solving the CVP."
+    return floor(1 / (2 * max([ U.inv()[i,:].norm(1) for i in range(U.rows)])))
+
 def babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
-    "Babai's closest plane algorithm for solving the CVP."
+    "Babai's closest plane algorithm for approximately solving the CVP."
     Us = gram_schmidt(U)[0]
     y = x
     for k in range(U.cols - 1, -1, -1):
         y = y - round(y.dot(Us[:, k]) / norm2(Us[:, k])) * U[:, k]
     return (x - y).applyfunc(round)
 
+def babai_plane_bnd(U: Matrix, p = 2) -> float:
+    "Bound for Babai's closest plane algorithm for solving the CVP."
+    Us = gram_schmidt(U)[0]
+    return float(0.5 * min([Us[:, i].norm(p) for i in range(Us.rows)]))
+
 def lagrange_lr(V: Matrix) -> Matrix:
     "Lagrange lattice reduction."
     assert (V.rows, V.cols) == (2, 2)
@@ -99,7 +108,7 @@ def lagrange_lr(V: Matrix) -> Matrix:
     return Matrix([list(v1), list(v3)]).transpose()
 
 def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
-    "lll algorithm for lattice reduction"
+    "LLL algorithm for lattice reduction."
 
     assert 0 < delta <= 1, f"LLL reqires 0 < delta={delta} <= 1"
     j = 1

{kryptools-0.4 → kryptools-0.6}/kryptools/nt.py

@@ -104,6 +104,7 @@ def crt(a: list[int], m: list[int]) -> int:
 
 
 def fraction_repr(self):
+    "Representation of a fraction."
     if self.denominator == 1:
         return str(self.numerator)
     return str(self.numerator) + "/" + str(self.denominator)
@@ -228,7 +229,7 @@ def order(a: int, n: int, factor=False) -> int:
     """Compute the order of `a` in the group Z_n^*."""
     a %= n
     assert a != 0 and gcd(a, n) == 1, f"{a} and {n} are not coprime!"
-    factors = dict()  # We compute euler_phi(n) and its factorization in one pass
+    factors = {}  # We compute euler_phi(n) and its factorization in one pass
     for p, k in factorint(n).items():  # first factorize n
         for pm, km in factorint(p - 1).items():  # factor p-1 and add the factors
             if pm in factors:
@@ -255,7 +256,7 @@ def order(a: int, n: int, factor=False) -> int:
             else:
                 break
         if factor and i < k:
-            factors_order[p] = k - i
+            factors_order[p] = k - i  # pylint: disable=E0606
     if factor:
         return order_a, factors_order
     return order_a

{kryptools-0.4 → kryptools-0.6}/kryptools/poly.py

@@ -2,6 +2,8 @@
 Polynomials
 """
 
+from numbers import Number
+
 class Poly:
     """
     Represents a polynomial as a list of coefficients.
@@ -92,14 +94,16 @@ class Poly:
         "Apply a given function to all coefficients."
         self.coeff = list(map(func, self.coeff))
 
+    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 __add__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                return NotImplemented
+            return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
             scoeff = self.coeff + (lo - ls) * [0]
@@ -116,12 +120,10 @@ class Poly:
 
     def __radd__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                pass
         return NotImplemented
 
     def __neg__(self) -> "Poly":
@@ -129,12 +131,11 @@ class Poly:
 
     def __sub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] -= other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                return NotImplemented
+            return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
             scoeff = self.coeff + (lo - ls) * [0]
@@ -147,24 +148,21 @@ class Poly:
         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.__class__([s - o for s, o in zip(scoeff, ocoeff)], modulus = modulus)
 
     def __rsub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] -= other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                pass
         return NotImplemented
 
     def __mul__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
-                return Poly([other * s for s in self.coeff])
-            except:
-                return NotImplemented
+            if self._check_type(other):
+                return Poly([other * s for s in self.coeff], modulus = self.modulus)
+            return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         coeff = [0] * (ls + lo - 1)
         for k in range(ls + lo - 1):
@@ -177,23 +175,50 @@ class Poly:
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
-        return self.__class__(coeff, modulus=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
 
-    def __rmul__(self, other: int) -> "Poly":
-        return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
+    def __truediv__(self, other) -> "Poly":
+        if self._check_type(other):
+            return self.__class__([s / other for s in self.coeff], modulus=self.modulus)
+        if isinstance(other, self.__class__):
+            if not other.modulus:
+                raise NotImplementedError("Cannot invert polynomials without modulus.")
+            return self * other.inv()
+        return NotImplemented
+
+    def __rtruediv__(self, other) -> "Poly":
+        if not self.modulus:
+            raise NotImplementedError("Cannot invert polynomials without modulus.")
+        return other * self.inv()
 
     def __pow__(self, i: int) -> "Poly":
-        res = self.__class__([1], modulus=self.modulus)
+        if not isinstance(i, int):
+            return NotImplemented
+        zero = 0 * self.coeff[0]
+        one = zero + 1
+        res = self.__class__([one], modulus=self.modulus)
         if i < 0:
             if not self.modulus:
-                raise NotImplementedError("Cannot divide.")
+                raise NotImplementedError("Cannot divide polynomials without modulus.")
             tmp = self.inv()
+            i *= -1
         else:
             tmp = self
         for _ in range(i):
             res *= tmp
         return res
 
+    def __floordiv__(self, other: "Poly") -> "Poly":
+        return self.divmod(other)[0]
+
+    def __mod__(self, other: "Poly") -> "Poly":
+        return self.divmod(other)[1]
+
     def divmod(self, other: "Poly") -> ("Poly", "Poly"):
         "Polynom division with remainder."
         if isinstance(other, list):
@@ -261,10 +286,10 @@ class Poly:
             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__([0], modulus=self.modulus), self.__class__(
-            [1], modulus=self.modulus
-        )
+        y0, y1 = self.__class__([zero], modulus=self.modulus), self.__class__([one], modulus=self.modulus)
         while r1:
             q, r = r0.divmod(r1)
             r0, r1 = r1, r
@@ -272,6 +297,6 @@ class Poly:
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
         tmp = 1 / r0[0]
-        for i in range(y0.degree()):
+        for i in range(len(y0)):
             y0.coeff[i] *= tmp
         return y0

{kryptools-0.4 → kryptools-0.6}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.4
+Version: 0.6
 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.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 

{kryptools-0.4 → kryptools-0.6}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "kryptools"
-version = "0.4"
+version = "0.6"
 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.8"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",