kryptools 1.9__tar.gz → 1.9.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.9
+Version: 1.9.2
 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.2}/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.2}/kryptools/__init__.py

@@ -3,9 +3,9 @@ Implemenation of same basic algorithms used in cryptography.
 """
 
 __author__ = "Gerald Teschl"
-__copyright__ = "Copyright 2024-2025, Gerald Teschl"
+__copyright__ = "Copyright 2024-2026, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.9"
+__version__ = "1.9.2"
 __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
@@ -16,7 +16,7 @@ from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye, circulant, BinaryMatrix
 from .lat import Lattice, random_unimodular_matrix
-from .lat2 import q_ary_lattice, gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_round_bnd, babai_plane_cvp, babai_plane_bnd, lll, svp, cvp, sis, isis, sis_search, isis_search
+from .lat2 import q_ary_lattice, gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, babai_plane_bnd, lll, svp, cvp, sis, isis, sis_search, isis_search
 from .poly import Poly, PolyBinMult, lagrange_interpolation
 from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash

{kryptools-1.9 → kryptools-1.9.2}/kryptools/factor.py

@@ -209,8 +209,7 @@ def divisors(n:int, proper:bool = False) -> int:
             i = 0
         d = prod(primes[i] ** exponents[i] for i in range(nprimes))
         if d == n:
-            if proper:
-                return divisor_list
-            divisor_list.append(n)
+            if not proper:
+                divisor_list.append(n)
             return divisor_list
         divisor_list.append(d)

{kryptools-1.9 → kryptools-1.9.2}/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.2}/kryptools/lat.py

@@ -205,7 +205,7 @@ class Lattice():
             print(f"Total number of steps: {steps}")
 
     def hnf(self) -> None:
-        "Transform the basis into Hermite normal form.."
+        "Transform the basis into Hermite normal form."
         if self.Uhnf is None:
             self.Uhnf = self.basis().hnf().matrix
             self.Us = None
@@ -237,7 +237,7 @@ class Lattice():
                 self.N[j] = Fraction(self.N[j])
         self.Us_end = end + 1
 
-    def size_reduce(self, j: int) -> bool:
+    def size_reduce_one(self, j: int) -> bool:
         "Size reduction at index `j`."
         self.gsd(j)
         reduced = False
@@ -251,6 +251,14 @@ class Lattice():
                     self.M[j][k] -= r * self.M[i][k]
         return reduced
 
+    def size_reduce(self) -> bool:
+        "Size reduction at all indices."
+        reduced = False
+        for j in range(self.len):
+            if self.size_reduce_one(j):
+                reduced = True
+        return reduced
+
     def swap(self, j:int, newN1 = None) -> None:
         "Swap columns j and j-1 and update the Gram-Schmidt decomposition."
         self.U[j - 1], self.U[j] = self.U[j], self.U[j - 1]
@@ -296,7 +304,7 @@ class Lattice():
         steps = 0
         while j < self.len:
             steps += 1
-            if self.size_reduce(j) and verbose:
+            if self.size_reduce_one(j) and verbose:
                 print(f"Reduced basis vector {j}")
             if all(self.U[j][l] == 0 for l in range(self.dim)):
                 if verbose:
@@ -372,7 +380,7 @@ class Lattice():
             c = lat.svp_enum(coordinates = True, reduce = False)
             uu = lat.basis() * c
             if uu.norm2() == lat.norm2(lat.U[0]):
-                if self.size_reduce(start):
+                if self.size_reduce_one(start):
                     changed = True
                 continue
             # the new vector is shorter

{kryptools-1.9 → kryptools-1.9.2}/kryptools/lat2.py

@@ -2,7 +2,7 @@
 Lattice tools 2
 """
 
-from math import prod, floor, inf
+from math import prod, inf
 from itertools import product
 from .la import Matrix, eye
 from .lat import Lattice
@@ -12,7 +12,6 @@ def hermite_nf(M: Matrix) -> Matrix:
     "Compute the Hermite normal form of a matrix M."
     return M.hnf()
 
-
 def gram_schmidt(U: Matrix, drop_dependent: bool = True) -> (Matrix, Matrix):
     "Compute the Gram-Schmidt orthogonalization of the column vectors of a matrix M."
     M = U.eye(U.cols)
@@ -36,30 +35,22 @@ def gram_schmidt(U: Matrix, drop_dependent: bool = True) -> (Matrix, Matrix):
         M = M[:-jj,:-jj]
     return Us, M
 
-
 def gram_det(U: Matrix) -> float:
     "Compute the Gram determinant of a matrix."
     Us = gram_schmidt(U, drop_dependent = False)[0]
     return prod([Us[:, i].norm() for i in range(U.rows)])
 
-
 def hadamard_ratio(M: Matrix) -> float:
     "Compute the Hadamard ratio of a matrix."
     m = M.rows
     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 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 CVPwith respect to the sup norm."
-    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 approximately solving the CVP."
     Us = gram_schmidt(U)[0]
@@ -68,7 +59,6 @@ def babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
         y = y - round(y.dot(Us[:, k]) / Us[:, k].norm2()) * 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 with respect to the Euclidean norm (p=2) or sup norm (p=inf)."
     Us = gram_schmidt(U)[0]

{kryptools-1.9 → kryptools-1.9.2}/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.2}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.9
+Version: 1.9.2
 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.2}/pyproject.toml

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

{kryptools-1.9 → kryptools-1.9.2}/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)