kryptools 0.4__tar.gz → 0.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.4
+Version: 0.5
 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.5}/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.5}/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.5}/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.5}/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.5}/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.5}/kryptools/la.py

@@ -3,6 +3,8 @@ Linear algebra
 """
 
 from math import inf, sqrt, prod
+from numbers import Number
+
 
 class Matrix:
     """
@@ -149,12 +151,16 @@ class Matrix:
         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 +170,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."

{kryptools-0.4 → kryptools-0.5}/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.5}/kryptools/poly.py

@@ -2,6 +2,8 @@
 Polynomials
 """
 
+from numbers import Number
+
 class Poly:
     """
     Represents a polynomial as a list of coefficients.
@@ -94,12 +96,11 @@ class Poly:
 
     def __add__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
-                tmp = self.coeff[:]
+            tmp = self.coeff[:]
+            if isinstance(other, int) or type(other) == type(tmp[0]):
                 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 +117,10 @@ class Poly:
 
     def __radd__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if isinstance(other, Number) or type(other) == type(self.coeff[0]):
                 tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                pass
         return NotImplemented
 
     def __neg__(self) -> "Poly":
@@ -129,12 +128,11 @@ class Poly:
 
     def __sub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if isinstance(other, int) or type(other) == type(self.coeff[0]):
                 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 +145,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 isinstance(other, int) or type(other) == type(self.coeff[0]):
                 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 isinstance(other, int) or type(other) == type(self.coeff[0]):
+                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 +172,36 @@ 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: int) -> "Poly":
-        return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
+        if isinstance(other, int) or type(other) == type(self.coeff[0]):
+            return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
+        return NotImplemented
 
     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 +269,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 +280,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.5}/kryptools.egg-info/PKG-INFO

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

@@ -1,12 +1,12 @@
 [project]
 name = "kryptools"
-version = "0.4"
+version = "0.5"
 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",