kryptools 1.8.2__tar.gz → 1.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.8.2
+Version: 1.9
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -44,11 +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 (Lenstra-Lenstra-Lovaz), SIS, ISIS, LWE
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovaz, 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)
 * 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.8.2 → kryptools-1.9}/README.md

@@ -26,11 +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 (Lenstra-Lenstra-Lovaz), SIS, ISIS, LWE
+* lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Hermite, Lenstra-Lenstra-Lovaz, 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)
 * 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.8.2 → kryptools-1.9}/kryptools/Zmod.py

@@ -63,8 +63,8 @@ class Zmod:
     def random(self, num: int = 0) -> "ZmodPoint":
         "Return a single random point or a list of random points."
         if num:
-            return([self(randint(0,self.n-1)) for _ in range(num)])
-        return self(randint(0,self.n-1))
+            return([self(randint(0, self.n-1)) for _ in range(num)])
+        return self(randint(0, self.n-1))
 
     def order(self) -> int:
         "Compute the order of the group Z_n^*."
@@ -91,6 +91,12 @@ class Zmod:
             self.group_order *= p**k
         return self.group_order
 
+    def factor_n(self) -> bool:
+        "Returns the factorization of n and stores it."
+        if not self.n_factors:
+            self.n_factors = factorint(self.n)
+        return self.n_factors
+
     def is_cyclic(self) -> bool:
         "Test if the group Z_n^* is cyclic."
         n = self.n
@@ -260,6 +266,7 @@ class ZmodPoint:
         return self.x - self.ring.n
 
     mods = sharp
+    lift_centered = sharp
 
     def order(self) -> int:
         "Compute the order of the point in the group Z_n^*."

{kryptools-1.8.2 → kryptools-1.9}/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.8.2"
+__version__ = "1.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, is_carmichael_number, order, crt
@@ -15,8 +15,8 @@ from .factor import factorint, divisors
 from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye, circulant, BinaryMatrix
-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, q_ary_lattice
-from .lat import svp_lll, cvp_lll, sis_lll, isis_lll, svp_search, cvp_search, sis_search, isis_search
+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 .poly import Poly, PolyBinMult, lagrange_interpolation
 from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash

{kryptools-1.8.2 → kryptools-1.9}/kryptools/code.py

@@ -414,7 +414,7 @@ class CyclicCode():
     >>> cc = CyclicCode(n, g)
     
     To encode a list of letters (the length must be equal to the dimension k of the code):
-    >>> cc.encode([0,1,0])
+    >>> cc.encode([0, 1, 0])
     [0, 1, 1, 0]
 
     Decoding is only implemented for code words:

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

@@ -25,22 +25,26 @@ class Matrix:
     print_post = " ]"
     print_sep = ", "
 
-    def __init__(self, matrix: list|tuple, ring = None):
+    def __init__(self, matrix: list, ring = None):
         if isinstance(matrix, BinaryMatrix):
             matrix = matrix.bitmatrix()
             ring = Zmod(2)
-        elif not (isinstance(matrix, list|tuple) and matrix):
-            raise ValueError("The given `matrix` must be a nonempty list.")
-        elif not isinstance(matrix[0], list|tuple):
+        elif not isinstance(matrix, list):
+            try:
+                matrix = list(matrix)
+            except Exception as exc:
+                raise ValueError("The given `matrix` cannot be converted to a list.") from exc
+        if not isinstance(matrix[0], list):
             matrix = [[x] for x in matrix]
         self.matrix = matrix  # the matrix as a list (rows) of lists (column entries)
         self.cols = len(matrix[0])  # number of columns
         self.rows = len(matrix)  # number of rows
+        if not self.cols or not self.cols:
+            raise ValueError("Both the number of rows and the number of columns must be nonzero.")
+        if any( len(row) != self.cols for row in self.matrix ):
+            raise ValueError("All matrix rows must have equal length!")
         self.nonpivotcols = None  # set during rref
         self.pivotcols = None  # set during rref
-        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)
 
@@ -281,10 +285,10 @@ class Matrix:
             return False
         if self.rows != other.rows or self.cols != other.cols:
             return False
-        return all(self[i] == other[i] for i in range(self.rows * self.cols))
+        return all(self.matrix[i][j] == other.matrix[i][j] for i in range(self.rows) for j in range(self.cols))
 
     def __bool__(self):
-        return any(bool(self[i]) for i in range(self.rows * self.cols))
+        return any( bool(x) for row in self.matrix for x in row)
 
     def map(self, func) -> None:
         "Apply a function to all elements in place."
@@ -293,9 +297,7 @@ class Matrix:
 
     def applyfunc(self, func) -> "Matrix":
         "Apply a function to all elements."
-        tmp = self[:, :]
-        tmp.map(func)
-        return tmp
+        return self.__class__([ list(map(func, row)) for row in self.matrix ])
 
     def _guess_zero(self):
         "Guess zero and one in the ring of the coefficients."
@@ -303,6 +305,22 @@ class Matrix:
         one = zero**0
         return zero, one
 
+    def is_integer(self, convert: bool = False):
+        "Test if all coefficients are integers and convert integer valued fractions if requested."
+        if all( isinstance(x, int) or (isinstance(x, Fraction) and x.denominator == 1) for row in self.matrix for x in row):
+            if convert:
+                self.map(int)
+            return True
+        return False
+
+    def is_rational(self, convert: bool = False):
+        "Test if all coefficients are rational and convert to fractions if requested."
+        if all( isinstance(x, (Fraction, int)) for row in self.matrix for x in row):
+            if convert:
+                self.map(Fraction)
+            return True
+        return False
+
     def norm2(self) -> float:
         "Squared Frobenius/Euclidean norm."
         return sum(sum(abs(x)**2 for x in row) for row in self.matrix)
@@ -318,7 +336,7 @@ class Matrix:
         tmp = sum(sum(abs(x)**p for x in row) for row in self.matrix)
         return tmp**(1/p)
 
-    def dot(self, other) -> int:
+    def dot(self, other) -> Number:
         "Dot product of two vectors."
         if self.rows == 1 and other.rows == 1 and self.cols == other.cols:
             return sum(x * y for x, y in zip(self.matrix[0], other.matrix[0]))
@@ -382,9 +400,12 @@ class Matrix:
         if hasattr(self.matrix[0][0], "ring") and not self.matrix[0][0].ring.is_field():
             # the matrix is over a ring (not a field)
             return self._rref_ring(start = start, drop_zero_rows = drop_zero_rows)
-        one = self._guess_zero()[1]
         n, m = self.cols, self.rows
-        R = [ self.matrix[i][:] for i in range(m) ]
+        if self.is_rational():
+            R = [ list(map(Fraction, row)) for row in self.matrix ]
+        else:
+            R = [ row[:] for row in self.matrix ]
+        one = self._guess_zero()[1]
         pivotcols = []
         nonpivotcols = []
         i = 0
@@ -428,15 +449,15 @@ class Matrix:
     def _rref_ring(self, start: int = 0, drop_zero_rows: bool = False) -> "Matrix":
         "Compute the reduced echelon form if the base ring is Z_n and no field."
         ring = self.matrix[0][0].ring
-        M = self.applyfunc(int)
+        R = self.applyfunc(int)
         done = start
-        while done < M.cols:
-            M = M.hrnf(start = start, drop_zero_rows = drop_zero_rows)
-            done = M.cols
-            for i, j in enumerate(M.pivotcols):
+        while done < R.cols:
+            R = R.hrnf(start = start, drop_zero_rows = drop_zero_rows)
+            done = R.cols
+            for i, j in enumerate(R.pivotcols):
                 if j < start:
                     continue
-                pivot = M.matrix[i][j]
+                pivot = R.matrix[i][j]
                 if pivot >= ring.n:
                     done = min(j, done)
                     pivot %= ring.n
@@ -448,17 +469,17 @@ class Matrix:
                 if pivot > 1:  # we can make the pivot smaller
                     done = min(j, done)
                     tmp = pow(pivot, -1, ring.n)
-                    for k in range(j, M.cols):
-                        M.matrix[i][k] *= tmp
-            M.map(lambda x: x % ring.n)
-        M.map(ring)
-        return M
+                    for k in range(j, R.cols):
+                        R.matrix[i][k] *= tmp
+            R.map(lambda x: x % ring.n)
+        R.map(ring)
+        return R
 
 
     def hrnf(self, start = 0, drop_zero_rows: bool = True) -> "Matrix":
         "Compute the Hermite row normal form."
         n, m = self.cols, self.rows
-        if not isinstance(self.matrix[0][0], int):
+        if not self.is_integer(convert = True):
             raise ValueError("Hermite normal form requires integer entries!")
         H = self[:,:]
         H.pivotcols = []
@@ -506,7 +527,7 @@ class Matrix:
     def hnf(self, drop_zero_columns: bool = True) -> "Matrix":
         "Compute the Hermite normal form."
         n, m = self.cols, self.rows
-        if not isinstance(self.matrix[0][0], int):
+        if not self.is_integer(convert = True):
             raise ValueError("Hermite normal form requires integer entries!")
         H = self[:,:]
         j = n - 1
@@ -542,7 +563,7 @@ class Matrix:
 
     def snf(self, drop_zero_rows: bool = False, drop_zero_columns: bool = False, include_S: bool = True, include_T: bool = True) -> "Matrix":
         "Computes the Smith normal form D of a matrix A with integer coefficients together with invertible matrices S and T such that D = S * A * T."
-        if not isinstance(self.matrix[0][0], int):
+        if not self.is_integer(convert = True):
             raise ValueError("Smith normal form requires integer entries!")
         m, n = self.rows, self.cols
         A = self[:,:]
@@ -685,11 +706,15 @@ class Matrix:
         if hasattr(self.matrix[0][0], "ring") and not self.matrix[0][0].ring.is_field():
             # the matrix is over a ring (not a field)
             ring = self.matrix[0][0].ring
-            R = [ list(map(lambda x: Fraction(int(x)), self.matrix[i])) for i in range(m) ]
+            R = [ list(map(lambda x: Fraction(int(x)), row)) for row in self.matrix ]
             zero, one = ring(0), 1
+        elif self.is_integer():
+            ring = None
+            R = [ list(map(Fraction, row)) for row in self.matrix ]
+            zero, one = 0, 1
         else:
             ring = None
-            R = [ self.matrix[i][:] for i in range(m) ]
+            R = [ row[:] for row in self.matrix ]
             zero, one = self._guess_zero()
         D = one
         i = 0