kryptools 1.9__tar.gz → 1.9.1__tar.gz

{kryptools-1.9 → kryptools-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.9
+Version: 1.9.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -44,12 +44,12 @@ The tools contained are:
 * 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, Smith normal form, Gram-Schmidt
-* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovaz, BKZ), SIS, ISIS, LWE
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovasz, BKZ), SIS, ISIS, LWE
 * linear codes: Hamming distance, left standard form, parity check matrix
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, solving linear systems, etc.)
 * BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
-* Lattice: a class for lattices (SVP, CPV, LLL, BKZ, HKZ)
+* Lattice: a class for lattices (SVP, CVP, LLL, BKZ, HKZ)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer
 * GF2: a class for Galois fields GF(2^n)

{kryptools-1.9 → kryptools-1.9.1}/README.md

@@ -26,12 +26,12 @@ The tools contained are:
 * 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, Smith normal form, Gram-Schmidt
-* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovaz, BKZ), SIS, ISIS, LWE
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovasz, BKZ), SIS, ISIS, LWE
 * linear codes: Hamming distance, left standard form, parity check matrix
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, solving linear systems, etc.)
 * BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
-* Lattice: a class for lattices (SVP, CPV, LLL, BKZ, HKZ)
+* Lattice: a class for lattices (SVP, CVP, LLL, BKZ, HKZ)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer
 * GF2: a class for Galois fields GF(2^n)

{kryptools-1.9 → kryptools-1.9.1}/kryptools/__init__.py

@@ -5,7 +5,7 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024-2025, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.9"
+__version__ = "1.9.1"
 __email__ = "Gerald.Teschl@univie.ac.at"
 
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, is_carmichael_number, order, crt

{kryptools-1.9 → kryptools-1.9.1}/kryptools/la.py

@@ -1079,7 +1079,7 @@ class BinaryMatrix:
         n = 0
         for bit in b:
             n <<= 1
-            n += bit
+            n += int(bit)
         return n
 
     def bitmatrix(self) -> list[list]:

{kryptools-1.9 → kryptools-1.9.1}/kryptools/poly.py

@@ -142,6 +142,8 @@ class Poly:
             except:  # pylint: disable=W0702
                 pass
             try:
+                if hasattr(s, "ring") and hasattr(s.ring, "sharp") and s.ring.sharp:
+                    s = s.sharp()
                 if plus and s < 0:
                     tmp += " - " + str(-s)
                     if i != 0:
@@ -225,9 +227,11 @@ class Poly:
         return self.__class__(list(map(func, self.coeff)), modulus = self.modulus, cyclic = self.cyclic)
 
     def _check_type(self, other):
+        "Check if self and other can be added/multiplied."
         return isinstance(other, int) or (isinstance(other, Number) and isinstance(self.coeff[0], Number)) or type(other) == type(self.coeff[0])  # pylint: disable=C0123
 
     def _guess_ring(self):
+        "Try to guess from which the ring the coefficients are."
         zero = 0 * self.coeff[0]
         one = zero**0
         if hasattr(zero, "ring"):
@@ -241,6 +245,7 @@ class Poly:
         return zero, one, ring
 
     def _guess_field(self):
+        "Try to guess from which field the coefficients are."
         zero, one, field = self._guess_ring()
         if not field:
             raise ValueError(
@@ -251,7 +256,7 @@ class Poly:
             if not field.is_field():
                 raise ValueError(
                     "The polynomial does not seem to be over a finite field.")
-        else:  # G2 or galois
+        else:  # GF2 or galois
             p = field.characteristic
             q = field.order
         return field, zero, one, q, p
@@ -293,13 +298,13 @@ class Poly:
         return (- self) + other
 
     def __mul__(self, other: "Poly") -> "Poly":
+        zero = 0 * self.coeff[0]
         if not isinstance(other, self.__class__):
             if self._check_type(other):
                 if not other:
-                    return self.__class__([other], modulus = self.modulus, cyclic = self.cyclic, check = False)
+                    return self.__class__([zero], modulus = self.modulus, cyclic = self.cyclic, check = False)
                 return self.__class__([other * s for s in self.coeff], modulus = self.modulus, cyclic = self.cyclic, check = False)
             return NotImplemented
-        zero = 0 * self.coeff[0]
         ls, lo = len(self.coeff), len(other.coeff)
         if self.cyclic or other.cyclic:
             if self.cyclic:
@@ -319,8 +324,8 @@ class Poly:
             if cyclic > 0:
                 coeff = [ sum( (selfc[j] * otherc[(k-j) % n] for j in range(ls)), start = zero) for k in range(n)]
             else:
-                coeff = [ sum( (selfc[j] * otherc[(k-j) % n] for j in range(min(k,ls))), start = zero) -
-                          sum( (selfc[j] * otherc[(k-j) % n] for j in range(k,ls)), start = zero) for k in range(n)]
+                coeff = [ sum( (selfc[j] * otherc[k - j] for j in range(min(k+1,ls))), start = zero) -
+                          sum( (selfc[j] * otherc[n + k - j] for j in range(k+1,ls)), start = zero) for k in range(n)]
             ret = self.__class__(coeff, modulus = modulus, cyclic = cyclic, check = False)
             ret.strip()
             return ret
@@ -521,6 +526,7 @@ class Poly:
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
         y0.modulus = self.modulus
+        y0.cyclic = self.cyclic
         if r0.coeff[0] == one:
             return y0
         return y0 / r0.coeff[0]

{kryptools-1.9 → kryptools-1.9.1}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.9
+Version: 1.9.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -44,12 +44,12 @@ The tools contained are:
 * 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, Smith normal form, Gram-Schmidt
-* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovaz, BKZ), SIS, ISIS, LWE
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovasz, BKZ), SIS, ISIS, LWE
 * linear codes: Hamming distance, left standard form, parity check matrix
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, solving linear systems, etc.)
 * BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
-* Lattice: a class for lattices (SVP, CPV, LLL, BKZ, HKZ)
+* Lattice: a class for lattices (SVP, CVP, LLL, BKZ, HKZ)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer
 * GF2: a class for Galois fields GF(2^n)

{kryptools-1.9 → kryptools-1.9.1}/pyproject.toml

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

{kryptools-1.9 → kryptools-1.9.1}/tests/test_poly.py

@@ -21,17 +21,24 @@ def test_Poly():
     assert q * p == p.gcd(q) * p.lcm(q)
     assert d * p + m == q
     for _ in range(num_tests):
-        p = Poly([randint(0,100) for _ in range(10)])
-        q = Poly([randint(0,100) for _ in range(12)])
-        x = randint(0,100)
+        p = Poly([randint(-100,100) for _ in range(10)])
+        q = Poly([randint(-100,100) for _ in range(12)])
+        x = randint(-100,100)
         assert p(x) == sum((c * x**j for j, c in enumerate(p.coeff)), start=0)
         assert (p + q)(x) == p(x) + q(x)
         assert (p - q)(x) == p(x) - q(x)
         assert (p*q)(x) == p(x) * q(x)
-    modulus = [-1] + 7 * [0] + [1]
-    p = [ randint(0,9) for _ in range(8) ]
-    q = [ randint(0,9) for _ in range(8) ]
-    assert list(circulant(p) * Matrix(q)) == (Poly(p, modulus = modulus) * Poly(q, modulus = modulus)).coeff
+    n = 8
+    modulus = [-1] + (n-1) * [0] + [1]
+    for _ in range(num_tests):
+        p = [ randint(-9,9) for _ in range(n) ]
+        q = [ randint(-9,9) for _ in range(n) ]
+        assert list(circulant(p) * Matrix(q)) == (Poly(p, modulus = modulus) * Poly(q, modulus = modulus)).coeff
+    modulus = [1] + (n-1) * [0] + [1]
+    for _ in range(num_tests):
+        p = [ randint(-9,9) for _ in range(n) ]
+        q = [ randint(-9,9) for _ in range(n) ]
+        assert Poly(p) * Poly(q) % Poly(modulus) == (Poly(p, modulus = modulus) * Poly(q, modulus = modulus))
     gf = Zmod(5)
     p = Poly([2, 0, 2], ring = gf)
     q = Poly([1, 2, 3, 4], ring = gf)