kryptools 1.8.1__tar.gz → 1.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.8.1
+Version: 1.8.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -43,11 +43,11 @@ The tools contained are:
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * 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, Gram-Schmidt
+* 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
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
+* 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)
 * 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

{kryptools-1.8.1 → kryptools-1.8.2}/README.md

@@ -25,11 +25,11 @@ The tools contained are:
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * 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, Gram-Schmidt
+* 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
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
+* 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)
 * 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

{kryptools-1.8.1 → kryptools-1.8.2}/kryptools/Zmod.py

@@ -172,7 +172,7 @@ class ZmodPoint:
         return f"{x} (mod {self.ring.n})"
 
     def __eq__(self, other):
-        if not isinstance(other, self.__class__) or self.ring != other.ring:
+        if not isinstance(other, self.__class__) or self.ring.n != other.ring.n:
             return False
         return self.x == other.x
 

{kryptools-1.8.1 → kryptools-1.8.2}/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.1"
+__version__ = "1.8.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

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

@@ -6,6 +6,7 @@ Linear algebra
 from math import gcd, inf, sqrt
 from numbers import Number
 from fractions import Fraction
+from .nt import egcd
 from .Zmod import Zmod
 
 class Matrix:
@@ -215,19 +216,66 @@ class Matrix:
                     self.matrix[i].append(c)
             self.cols += 1
 
-    def permute_columns(self, permutation) -> None:
+    def swap_columns(self, i: int, j: int) -> None:
+        "Swap two columns."
+        for k in range(self.rows):
+            self.matrix[k][i], self.matrix[k][j] = self.matrix[k][j], self.matrix[k][i]
+
+    def swap_rows(self, i: int, j: int) -> None:
+        "Swap two rows."
+        self.matrix[i], self.matrix[j] = self.matrix[j], self.matrix[i]
+
+    def permute_columns(self, permutation: list) -> None:
         "Permute columns according to a list of new positions."
         if len(permutation) != self.cols:
             raise ValueError(f"The argument must be a list of indices of length {self.cols}.")
         for i in range(self.rows):
             self.matrix[i] = [ self.matrix[i][j] for j in permutation]
 
-    def permute_rows(self, permutation) -> None:
+    def permute_rows(self, permutation: list) -> None:
         "Permute rows according to a list of new positions."
         if len(permutation) != self.rows:
             raise ValueError(f"The argument must be a list of indices of length {self.rows}.")
         self.matrix = [ self.matrix[i] for i in permutation]
 
+    def scale_column(self, i: int, a: Number) -> None:
+        "Scale a column."
+        for k in range(self.rows):
+            self.matrix[k][i] *= a
+
+    def scale_row(self, i: int, a: Number) -> None:
+        "Scale a row."
+        for k in range(self.cols):
+            self.matrix[i][k] *= a
+
+    def addto_column(self, i: int, j: int, a: Number|None = None) -> None:
+        "Add a multiple of the first column to the second."
+        if a is None:
+            for k in range(self.rows):
+                self.matrix[k][i] += self.matrix[k][j]
+        else:
+            for k in range(self.rows):
+                self.matrix[k][i] += a * self.matrix[k][j]
+
+    def addto_row(self, i: int, j: int, a: Number|None = None) -> None:
+        "Add a multiple of the first row to the second."
+        if a is None:
+            for k in range(self.cols):
+                self.matrix[i][k] += self.matrix[j][k]
+        else:
+            for k in range(self.cols):
+                self.matrix[i][k] += a * self.matrix[j][k]
+
+    def maop_row(self, i: int, k: int, a: Number, b: Number, c: Number, d: Number) -> None:
+        "Replaces the i,j and k,j entry by  by using an matrix column operation."
+        for l in range(self.cols):
+            self.matrix[i][l], self.matrix[k][l] = a * self.matrix[i][l] + b * self.matrix[k][l], c * self.matrix[i][l] + d * self.matrix[k][l]
+
+    def maop_column(self, j: int, k: int, a: Number, b: Number, c: Number, d: Number) -> None:
+        "Replaces the i,j and i,k entry by using an matrix column operation."
+        for l in range(self.rows):
+            self.matrix[l][j], self.matrix[l][k] = a * self.matrix[l][j] + b * self.matrix[l][k], c * self.matrix[l][j] + d * self.matrix[l][k]
+
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False
@@ -406,53 +454,46 @@ class Matrix:
         M.map(ring)
         return M
 
-    def hrnf(self, start = 0, drop_zero_rows: bool = False) -> "Matrix":
+
+    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):
             raise ValueError("Hermite normal form requires integer entries!")
-        H = [ self.matrix[i][:] for i in range(m) ]
-        pivotcols = []
-        nonpivotcols = []
+        H = self[:,:]
+        H.pivotcols = []
+        H.nonpivotcols = []
         i = 0
         if start >= n:
             raise ValueError("Start value cannot be beyond the last column.")
         for j in range(start, n):
             i0 = i
-            minimum = abs(H[i][j])  # search for the pivot in the present column
+            minimum = abs(H.matrix[i][j])  # search for the pivot in the present column
             for ii in range(i + 1, m):
-                tmp = abs(H[ii][j])
+                tmp = abs(H.matrix[ii][j])
                 if tmp > 0 and (tmp < minimum or minimum == 0):
                     minimum = tmp
                     i0 = ii
             if minimum == 0:
-                nonpivotcols.append(j)
+                H.nonpivotcols.append(j)
                 continue  # all entrjes are zero
-            pivotcols.append(j)
+            H.pivotcols.append(j)
             if i0 > i:
-                H[i], H[i0] = H[i0], H[i]  # swap rows, to move the pivot jn place
-            if H[i][j] < 0:
-                for k in range(n):
-                    H[i][k] *= -1  # make the pivot positive
-            ii = i + 1
-            while ii < m:  # make the column entries below to the pivot zero
-                tmp = H[ii][j] // H[i][j]
-                for k in range(n):
-                    H[ii][k] -= tmp * H[i][k]
-                if H[ii][j]:
-                    H[i], H[ii] = H[ii], H[i]  # swap rows
-                else:
-                    ii += 1
+                H.swap_rows(i, i0)  # swap rows, to move the pivot in place
+            if H.matrix[i][j] < 0:
+                H.scale_row(i, -1)  # make the pivot positive
+            for ii in range(i + 1, m):  # make the column entries below to the pivot zero
+                if H.matrix[ii][j]:
+                    g, x, y = egcd(H.matrix[i][j], H.matrix[ii][j], minimal = True)
+                    xx = H.matrix[i][j] // g
+                    yy = - H.matrix[ii][j] // g
+                    H.maop_row(i, ii, x, y, yy, xx)
             for ii in range(i):  # reduce the column entries above to the pivot
-                tmp = H[ii][j] // H[i][j]
-                for k in range(n):
-                    H[ii][k] -= tmp * H[i][k]
+                H.addto_row(ii, i, -(H.matrix[ii][j] // H.matrix[i][j]))
             i += 1
             if i >= m:
                 break
-        H = Matrix(H)
-        H.pivotcols = pivotcols
-        H.nonpivotcols = nonpivotcols + list(range(j+1, H.cols))
+        H.nonpivotcols += list(range(j+1, H.cols))
         # purge zero rows
         if drop_zero_rows:
             l = len(H.pivotcols)
@@ -462,6 +503,141 @@ class Matrix:
             H.rows = l
         return H
 
+    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):
+            raise ValueError("Hermite normal form requires integer entries!")
+        H = self[:,:]
+        j = n - 1
+        for i in range(m-1,-1,-1):
+            j0 = j
+            minimum = abs(H.matrix[i][j])  # search for the pivot in the present row
+            for jj in range(j):
+                tmp = abs(H.matrix[i][jj])
+                if tmp > 0 and (tmp < minimum or minimum == 0):
+                    minimum = tmp
+                    j0 = jj
+            if minimum == 0:
+                continue  # all entries are zero
+            if j0 < j:
+                H.swap_columns(j, j0)  # swap columns, to move the pivot in place
+            if H.matrix[i][j] < 0:
+                H.scale_column(j, -1)  # make the pivot positive
+            for jj in range(j):  # make the row left to the pivot zero
+                if H.matrix[i][jj]:
+                    g, x, y = egcd(H.matrix[i][j], H.matrix[i][jj], minimal = True)
+                    xx = H.matrix[i][j] // g
+                    yy = - H.matrix[i][jj] // g
+                    H.maop_column(j, jj, x, y, yy, xx)
+            for jj in range(j + 1, n):  # reduce the row entries right to the pivot
+                H.addto_column(jj, j, -(H.matrix[i][jj] // H.matrix[i][j]))
+            j -= 1
+            if j < 0:
+                break
+        if drop_zero_columns:
+            while H.cols > 1 and all(not H.matrix[i][0] for i in range(m)):  # remove zero columns
+                H = H[:, 1:]
+        return H
+
+    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):
+            raise ValueError("Smith normal form requires integer entries!")
+        m, n = self.rows, self.cols
+        A = self[:,:]
+        if include_T:
+            T = A.eye(n)
+        if include_S:
+            S = A.eye(m)
+        for i in range(min(n,m)):
+            minimum = abs(A.matrix[i][i])  # search for the pivot
+            i0, j0 = i, i
+            for ii in range(i, m):
+                for jj in range(i, n):
+                    tmp = abs(A.matrix[ii][jj])
+                    if tmp > 0 and (tmp < minimum or minimum == 0):
+                        minimum = tmp
+                        i0, j0 = ii, jj
+            if not minimum:
+                break
+            if j0 != i:  # swap columns, to move the pivot in place
+                if include_T:
+                    T.swap_columns(i, j0)
+                A.swap_columns(i, j0)
+            if i0 != i:  # swap rows, to move the pivot in place
+                if include_S:
+                    S.swap_rows(i, i0)
+                A.swap_rows(i, i0)
+            if A[i, i] < 0:  # make the pivot positive
+                if include_S:
+                    S.scale_row(i, -1)
+                A.scale_row(i, -1)
+            done = False
+            while not done:
+                for jj in range(i+1, n):
+                    if A.matrix[i][jj] == 0:
+                        continue
+                    g, x, y = egcd(A.matrix[i][i], A.matrix[i][jj], minimal = True)
+                    xx = A.matrix[i][i] // g
+                    yy = A.matrix[i][jj] // g
+                    if include_T:
+                        T.maop_column(i, jj, x, y, -yy, xx)
+                    A.maop_column(i, jj, x, y, -yy, xx)
+                for ii in range(i+1, m):
+                    if A.matrix[ii][i] == 0:
+                        continue
+                    g, x, y = egcd(A.matrix[i][i], A.matrix[ii][i], minimal = True)
+                    xx = A.matrix[i][i] // g
+                    yy = -A.matrix[ii][i] // g
+                    if include_S:
+                        S.maop_row(i, ii, x, y, yy, xx)
+                    A.maop_row(i, ii, x, y, yy, xx)
+                done = True
+                for jj in range(i+1, n):
+                    if A[i,jj] != 0:
+                        done = False
+                        break
+        for l in range(min(n,m)-1, 0, -1):
+            for i in range(l):
+                if A.matrix[i][i] and A.matrix[i+1][i+1] % A.matrix[i][i]:
+                    g, x, y = egcd(A.matrix[i][i], A.matrix[i+1][i+1], minimal = True)
+                    aa= A.matrix[i][i] //g
+                    bb = -A.matrix[i+1][i+1]//g
+                    by = bb * y
+                    if include_T:
+                        T.addto_column(i, i+1)
+                        T.addto_column(i+1, i, by)
+                    A.addto_column(i, i+1)
+                    A.addto_column(i+1, i, by)
+                    if include_S:
+                        S.maop_row(i, i+1, x, y, bb, aa)
+                    A.maop_row(i, i+1, x, y, bb, aa)
+        if drop_zero_rows or drop_zero_columns:
+            for i in range(min(n,m)):
+                if A[i,i] == 0:
+                    break
+            else:
+                i += 1
+            i = max(i, 1)
+        if drop_zero_rows:
+            if i < m:
+                del A[i:, :]
+                if include_S:
+                    del S[i:, :]
+        if drop_zero_columns:
+            if i < n:
+                del A[:, i:]
+                if include_T:
+                    del T[:, i:]
+        if include_S and include_T:
+            return A, S, T
+        if include_S:
+            return A, S
+        if include_T:
+            return A, T
+        return A
+
     def left_standard_form(self) -> "Matrix":
         "Compute the left standard form."
         # reduced row echelon form
@@ -474,7 +650,24 @@ class Matrix:
     def kernel(self) -> "Matrix":
         "Compute a basis for the kernel."
         if hasattr(self.matrix[0][0], "ring") and not self.matrix[0][0].ring.is_field():
-            raise NotImplementedError("The matrix must be over a field, not a ring.")
+            ring = self.matrix[0][0].ring
+            M = self.applyfunc(int)
+            D, T = M.snf(include_S=False, drop_zero_rows=True)
+            D.map(ring)
+            T.map(ring)
+            K = D.eye(D.cols)
+            shift = 0
+            for i in range(D.rows):
+                g = gcd(int(D.matrix[i][i]), ring.n)
+                if g == 1:
+                    if shift == D.cols - 1:
+                        K.matrix[i][i - shift] = ring(0)
+                        break
+                    K.delete_columns(i - shift)
+                    shift += 1
+                elif g < ring.n:
+                    K.matrix[i][i-shift] = ring(ring.n // g)
+            return T * K
         _, one = self._guess_zero()
         M = self.rref(drop_zero_rows = True)
         K = M.zeros(M.cols, max(1,len(M.nonpivotcols)))
@@ -562,52 +755,30 @@ class Matrix:
             b = self.__class__(b)
         if self.rows != b.rows or b.cols != 1:
             raise ValueError("Matrix dimensions do not match.")
-        A = self[:,:]
-        A.append_column(b)
-        A = A.rref(drop_zero_rows = True)
-        if not any(A.matrix[-1][:-1]) and A.matrix[-1][-1]:
-            return None  # Not solvable
         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
-            # compute column normal form (TODO implement full Smith normal form)
-            b = A[:,-1]
-
-            A = A[:,:-1].transpose()
-            A.map(int)
-            A.append_column(A.eye(A.rows))
-            A = A.hrnf().transpose()
-            R = A[b.rows:,:b.rows]
-            A = A[:b.rows,:b.rows]
-            A.map(ring)
-
-            solution_nr = [ 0 ] * A.rows
-            solutions_left = True
-            next_solution = False  # start with the first solution
-            while solutions_left:
-                solution = solution = [ None ] * A.rows
-                solutions_left = False
-                for i in range(A.rows):
-                    bi = b[i]
-                    for k in range(i):
-                        bi -= A.matrix[i][k] * solution[k]
-                    c = A.matrix[i][i].solve(bi, all_solutions = True)
-                    if c is None:
-                        solution = None
-                        break
-                    if next_solution and solution_nr[i] < len(c) - 1:
-                        solution_nr[i] += 1
-                        next_solution = False
-                    if solution_nr[i] < len(c) -1:
-                        solutions_left = True
-                    solution[i] = c[solution_nr[i]]
-                if next_solution: # no more solutions left
+            A = self.applyfunc(int)
+            D, S, T = A.snf()
+            D.map(ring)
+            S.map(ring)
+            T.map(ring)
+            b = S * b
+            for i in range(min(A.rows, A.cols), A.rows):
+                if b[i]:
+                    return None
+            y = [ ring(0) ] * A.cols
+            for i in range(min(A.rows, A.cols)):
+                y[i] = D[i,i].solve(b[i])
+                if y[i] is None:
                     return None
-                if solution is not None:
-                    return R * Matrix(solution)
-                next_solution = True
-            return None
+            return T * Matrix(y)
         # the matrix is over a field
+        A = self[:,:]
+        A.append_column(b)
+        A = A.rref(drop_zero_rows = True)
+        if not any(A.matrix[-1][:-1]) and A.matrix[-1][-1]:
+            return None  # Not solvable
         solution = self.zeros(self.cols, 1)
         for i, j in enumerate(A.pivotcols):
             solution[j] = A.matrix[i][-1]
@@ -911,7 +1082,18 @@ class BinaryMatrix:
         self.rows += 1
         self.matrix.append(row)
 
-    def permute_columns(self, permutation) -> None:
+    def swap_columns(self, i: int, j: int) -> None:
+        "Swap two columns."
+        for k in range(self.rows):
+            b = self.matrix[k]
+            x = ((b >> i) ^ (b >> j)) & 1
+            self.matrix[k] ^= ((x << i) | (x << j))
+
+    def swap_rows(self, i: int, j: int) -> None:
+        "Swap two rows."
+        self.matrix[i], self.matrix[j] = self.matrix[j], self.matrix[i]
+
+    def permute_columns(self, permutation: list) -> None:
         "Permute columns according to a list of new positions."
         if len(permutation) != self.cols:
             raise ValueError(f"The argument must be a list of indices of length {self.cols}.")
@@ -920,7 +1102,7 @@ class BinaryMatrix:
             bits = [ bits[j] for j in permutation]
             self.matrix[i] = self.from_bits(bits)
 
-    def permute_rows(self, permutation) -> None:
+    def permute_rows(self, permutation: list) -> None:
         "Permute rows according to a list of new positions."
         if len(permutation) != self.rows:
             raise ValueError(f"The argument must be a list of indices of length {self.rows}.")

{kryptools-1.8.1 → kryptools-1.8.2}/kryptools/lat.py

@@ -11,40 +11,7 @@ from .la import Matrix, eye, zeros
 
 def hermite_nf(M: Matrix) -> Matrix:
     "Compute the Hermite normal form of a matrix M."
-    n, m = M.cols, M.rows
-    H = M[:, :]
-    j = n - 1
-    for i in range(m-1,-1,-1):
-        j0 = j
-        minimum = abs(H[i, j])  # search for the pivot in the present row
-        for jj in range(j):
-            tmp = abs(H[i, jj])
-            if tmp > 0 and (tmp < minimum or minimum == 0):
-                minimum = tmp
-                j0 = jj
-        if minimum == 0:
-            continue  # all entries are zero
-        if j0 < j:
-            H[:, j], H[:, j0] = H[:, j0], H[:, j]  # swap columns, to move the pivot in place
-        if H[i, j] < 0:
-            H[:, j] *= -1  # make the pivot positive
-        jj = j - 1
-        while jj >= 0:  # make the row entries left to the pivot zero
-            tmp = H[i, jj] // H[i, j]
-            H[:, jj] -= tmp * H[:, j]
-            if H[i, jj]:
-                H[:, j], H[:, jj] = H[:, jj], H[:, j]  # swap columns
-            else:
-                jj -= 1
-        for jj in range(j + 1, n):  # reduce the row entries right to the pivot
-            tmp = H[i, jj] // H[i, j]
-            H[:, jj] -= tmp * H[:, j]
-        j -= 1
-        if j < 0:
-            break
-    while H.cols > 1 and all(not H[i, 0] for i in range(m)):  # remove zero columns
-        H = H[:, 1:]
-    return H
+    return M.hnf()
 
 
 def norm2(v: Matrix) -> float:
@@ -56,9 +23,8 @@ 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)
     Us = U.zeros()
-    Us[:, 0] = U[:, 0]
     jj = 0 # offset taking removed vectors into account
-    for j in range(1, U.cols):
+    for j in range(0, U.cols):
         tmp = U[:, j]
         for i in range(j - jj):
             M[i, j - jj] = U[:, j].dot(Us[:, i]) / Us[:, i].norm2()
@@ -69,6 +35,8 @@ def gram_schmidt(U: Matrix, drop_dependent: bool = True) -> (Matrix, Matrix):
             jj += 1
         else:
             Us[:, j - jj] = tmp
+    if jj == U.cols:
+        raise ValueError("The matrix must be nonzero.")
     if jj:
         Us = Us[:,:-jj]
         M = M[:-jj,:-jj]
@@ -114,6 +82,30 @@ def babai_plane_bnd(U: Matrix, p=2) -> float:
     return float(0.5 * min(Us[:, i].norm(p) for i in range(Us.rows)))
 
 
+def kannan_cvp(x: Matrix, U: Matrix, m: int = 1) -> Matrix:
+    "Kannan's embedding algorithm for approximately solving the CVP."
+    V = U[:,:]
+    V.append_column(x)
+    V.append_row(V.zeros(1,V.cols))
+    V[-1,-1]= m
+    V = lll(V)
+    e = None
+    for i in range(V.cols):
+        mm = V.matrix[-1][i]
+        if mm == m:
+            e = V[:-1,i]
+            break
+        if mm == -m:
+            e = -V[:-1,i]
+            break
+    if e is None:
+        return None
+    V = U.applyfunc(Fraction)
+    x = V.solve(x-e)
+    x.map(int)
+    return U * x
+
+
 def lagrange_lr(V: Matrix) -> Matrix:
     "Lagrange lattice reduction."
     if V.cols != 2:
@@ -220,26 +212,32 @@ def q_ary_lattice(U: Matrix, lll: bool = False) -> Matrix:  # pylint: disable=W0
         raise ValueError("The matrix does not seem to be over Zmod.")
     V = eye(U.rows, one = q)
     V.append_column(U, ring = int)
-    V = hermite_nf(V)
+    V = V.hnf()
     if lll:
         return globals()['lll'](V)
     return V
 
 def svp_lll(U: Matrix) -> Matrix:
     "Solve the shortest vector problem in a q-ary lattice associated with a matrix over a finite ring Z_q."
-    gf = U[0].ring
-    V = q_ary_lattice(U, lll = True)
+    ring = U[0].ring
+    V = lll(q_ary_lattice(U, lll = True))
     x = V[:, 0]
-    x.map(gf)
+    x.map(ring)
     return x
 
-def cvp_lll(U: Matrix, x: Matrix) -> Matrix:
+def cvp_lll(U: Matrix, x: Matrix, babai_plane: bool = True, kannan: bool = True) -> Matrix:
     "Solve the closest vector problem in a q-ary lattice associated with a matrix over a finite ring Z_q (LWE)."
-    gf = U[0].ring
-    V = q_ary_lattice(U, lll = True)
+    ring = U[0].ring
+    V = lll(q_ary_lattice(U, lll = True))
     x.map(int)
-    y = babai_plane_cvp(x, V)
-    x.map(gf)
+    y = None
+    if babai_plane:
+        y = babai_plane_cvp(x, V)
+    if kannan:
+        y2 = kannan_cvp(x, V)
+        if y is not None and y2 is not None and y2.norm2() < y.norm2():
+            y = y2
+    x.map(ring)
     return y
 
 def sis_lll(A: Matrix) -> Matrix:
@@ -249,48 +247,47 @@ def sis_lll(A: Matrix) -> Matrix:
 def isis_lll(A: Matrix, b: Matrix) -> Matrix:
     "Solve the inhomogenous short integer problem over a finite ring Z_q (ISIS)."
     y = A.solve(b)
+    if y is None:
+        return None
     return y - cvp_lll(A.kernel(), y)
 
 def svp_search(U: Matrix, m: int = 0, p: int = 2) -> Matrix:
     "Solve the shortest vector problem in a q-ary lattice associated with a matrix over a finite ring Z_q."
-    gf = U[0].ring
+    ring = U[0].ring
     if m:
         ml, mu = -m, m + 1
     else:
-        ml, mu = -((gf.n-1)//2), gf.n//2 + 1
-    U.map(int)
+        ml, mu = -((ring.n-1)//2), ring.n//2 + 1
+    U = U.applyfunc(int)
     norm_min = inf
     c_min = None
     for j in range(U.cols):
         for c in product(range(ml, mu), repeat = U.cols-j-1):
             for cc in range(1, mu):
                 cc = U * Matrix([ 0 ] * j + [ cc ] + list(c))
-                cc.map(gf)
+                cc.map(ring)
                 norm = cc.norm(p)
-                if norm < norm_min:
+                if norm and norm < norm_min:
                     norm_min = norm
                     c_min = cc
-    U.map(gf)
     return c_min
 
 def cvp_search(U: Matrix, b: Matrix, p: int = 2) -> Matrix:
     "Solve the closest vector problem in a q-ary lattice associated with a matrix over a finite ring Z_q (LWE)."
-    gf = U[0].ring
-    U.map(int)
-    b.map(int)
+    ring = U[0].ring
+    U = U.applyfunc(int)
+    b = b.applyfunc(int)
     norm_min = inf
     c_min = None
-    for c in product(range(-((gf.n-1)//2), gf.n//2 + 1), repeat = U.cols):
+    for c in product(range(-((ring.n-1)//2), ring.n//2 + 1), repeat = U.cols):
         c = U * Matrix(c)
         d = c - b
-        d.map(gf)
+        d.map(ring)
         norm = d.norm(p)
         if norm < norm_min:
             norm_min = norm
-            c.map(gf)
+            c.map(ring)
             c_min = c
-    U.map(gf)
-    b.map(gf)
     return c_min
 
 def sis_search(A: Matrix, p: int = 2) -> Matrix:

{kryptools-1.8.1 → kryptools-1.8.2}/kryptools/nt.py

@@ -19,12 +19,16 @@ from fractions import Fraction
 # extended Euclid
 
 
-def egcd(a: int, b: int) -> (int, int, int):
+def egcd(a: int, b: int, minimal = False) -> (int, int, int):
     """Perform the extended Euclidean agorithm. Returns `gcd`, `x`, `y` such that `a x + b y = gcd`."""
     if a == 0:
         if b < 0:
             return -b, 0, -1
         return b, 0, 1
+    if b == 0:
+        if a < 0:
+            return -a, -1, 0
+        return a, 1, 0
     if a < 0:
         r0, r1 = -a, b
         x0, x1, y0, y1 = -1, 0, 0, 1
@@ -39,6 +43,19 @@ def egcd(a: int, b: int) -> (int, int, int):
         r0, r1 = r1, r
         x0, x1 = x1, x0 - q * x1
         y0, y1 = y1, y0 - q * y1
+    if minimal:
+        bb = abs(b) // r0
+        if a < 0:
+            x0 *= -1
+        k, x0 = divmod(x0, bb)
+        if x0 == 0:
+            x0 = bb
+            k -= 1
+        if a < 0:
+            x0 *= -1
+        if b < 0:
+            k *= -1
+        y0 += k * abs(a) // r0
     return r0, x0, y0
 
 

{kryptools-1.8.1 → kryptools-1.8.2}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.8.1
+Version: 1.8.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -43,11 +43,11 @@ The tools contained are:
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
 * 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, Gram-Schmidt
+* 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
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
+* 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)
 * 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

{kryptools-1.8.1 → kryptools-1.8.2}/pyproject.toml

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

{kryptools-1.8.1 → kryptools-1.8.2}/tests/test_la.py

@@ -3,6 +3,7 @@ import pytest  # pylint: disable=W0611
 from math import gcd  # pylint: disable=C0411
 from random import randint, seed  # pylint: disable=C0411
 from fractions import Fraction  # pylint: disable=C0411
+from itertools import product  # pylint: disable=C0411
 from kryptools import Matrix, Zmod, GF2, eye, circulant, BinaryMatrix
 
 
@@ -65,11 +66,53 @@ def test_Matrix2():
                 x = A.solve(b)
                 assert A * x == b
 
+def test_hnf():
+    num_tests = 5
+    seed(0)
+    for m,n in ((3, 5), (5, 3), (3, 3)):
+        for _ in range(num_tests):
+            A = Matrix([[randint(-10,10) for _ in range(m)] for _ in range(n)])
+            H = A.transpose()
+            H.permute_columns(range(H.cols-1,-1,-1))
+            H = H.hrnf(drop_zero_rows = True)
+            H.permute_columns(range(H.cols-1,-1,-1))
+            H = H.transpose()
+            H.permute_columns(range(H.cols-1,-1,-1))
+            assert H == A.hnf()
+
+def test_solve():
+    seed(0)
+    for gf in Zmod(2), Zmod(7), GF2(1), GF2(8):
+        for m,n in ((3, 5), (5, 3), (3, 3)):
+            for _ in range(25):
+                A = Matrix([[gf.random() for _ in range(n)] for _ in range(m)])
+                b = Matrix([gf.random() for _ in range(m)])
+                x = A.solve(b)
+                if x is not None:
+                    assert A *x == b
+                else:
+                    AA = A[:, :]
+                    AA.append_column(b)
+                    assert AA.rank() > A.rank()
+    for ring in Zmod(4), Zmod(6):
+        for m,n in ((3, 4), (4, 3), (3, 3)):
+            for _ in range(25):
+                A = Matrix([[ring.random() for _ in range(n)] for _ in range(m)])
+                b = Matrix([ring.random() for _ in range(m)])
+                x = A.solve(b)
+                if x is not None:
+                    assert A *x == b
+                else:
+                    for x in product(ring, repeat = A.cols):
+                        x = Matrix(x)
+                        assert A * x != b
+
 def test_kernel():
+    seed(0)
     for gf in Zmod(2), Zmod(7), GF2(1), GF2(8):
         for m,n in ((3, 5), (5, 3), (3, 3)):
             for _ in range(25):
-                A = Matrix([[gf.random() for _ in range(m)] for _ in range(n)])
+                A = Matrix([[gf.random() for _ in range(n)] for _ in range(m)])
                 K = A.kernel()
                 assert not A * K
                 assert K.rows == A.cols
@@ -77,6 +120,29 @@ def test_kernel():
                     assert K.cols == A.nullity()
                 else:
                     assert K.cols == 1
+    for ring in Zmod(4), Zmod(6):
+        for m,n in ((3, 4), (4, 3), (3, 3)):
+            for _ in range(25):
+                A = Matrix([[ring.random() for _ in range(n)] for _ in range(m)])
+                K = A.kernel()
+                assert not A * K
+                kernel = []
+                for a in product(ring, repeat = K.cols):
+                    a = K * Matrix(a)
+                    a.map(int)
+                    a = list(a)
+                    if a not in kernel:
+                        kernel.append(a)
+                kernel.sort()
+                kernel2 = []
+                for a in product(ring, repeat = A.cols):
+                    a = Matrix(a)
+                    if not A * a:
+                        a.map(int)
+                        a = list(a)
+                        kernel2.append(a)
+                kernel2.sort()
+                assert kernel2 == kernel
 
 def test_BinaryMatrix():
     num_tests = 100
@@ -95,6 +161,12 @@ def test_BinaryMatrix():
         assert BinaryMatrix(Mat1 + Mat2) == mat1 + mat2
         assert BinaryMatrix(Mat1 - Mat2) == mat1 + mat2
         assert BinaryMatrix(Mat1 * Mat3) == mat1 * mat3
+        Mat1.swap_columns(0,n-1)
+        mat1.swap_columns(0,n-1)
+        assert BinaryMatrix(Mat1) == mat1
+        Mat1.swap_rows(0,m-1)
+        mat1.swap_rows(0,m-1)
+        assert BinaryMatrix(Mat1) == mat1
 
     for _ in range(num_tests):
         m = randint(n-1,n+1)

kryptools-1.8.2/tests/test_lat.py

@@ -0,0 +1,49 @@
+# pragma pylint: disable=C0114,C0116
+import pytest  # pylint: disable=W0611
+from random import seed, randint  # pylint: disable=C0411
+from fractions import Fraction  # pylint: disable=C0411
+from kryptools import Matrix, gram_schmidt, random_unimodular_matrix
+from kryptools import Zmod, sis_search, sis_lll, isis_search, isis_lll
+
+
+def test_gram_schmidt():
+    seed(0)
+    for n in range(2, 5):
+        for _ in range(10):
+            found = False
+            while not found:
+                V = Matrix([[ randint(-10,10) for _ in range(n)] for _ in range(n) ], ring=Fraction)
+                found = bool(V.rank() == n)
+            Vs, M = gram_schmidt(V)
+            assert V == Vs * M
+            D = V.eye()
+            for i in range(Vs.cols):
+                assert Vs[:,i].dot(Vs[:,i]) == Vs[:,i].norm2()
+                D[i,i] = Vs[:,i].dot(Vs[:,i])
+            assert Vs.transpose() * Vs == D
+
+def test_random_unimodular_matrix():
+    for i in range(2, 5):
+        U = random_unimodular_matrix(i)
+        U.map(Fraction)
+        assert U.det() in (-1, 1)
+
+def test_sis():
+    seed(0)
+    for ring in Zmod(3), Zmod(4), Zmod(5), Zmod(6):
+        for _ in range(25):
+            A = Matrix([[ring.random() for _ in range(6)] for _ in range(3)])
+            xs = sis_search(A)
+            assert not A * xs
+            x = sis_lll(A)
+            assert not A * x
+            assert x.norm() == xs.norm()
+            b = Matrix([[ring.random()] for _ in range(3)])
+            xs = isis_search(A, b)
+            if xs is not None:
+                assert A * xs == b
+            x = isis_lll(A, b)
+            if x is not None:
+                assert A * x == b
+            if xs is not None:
+                assert xs.norm() <= x.norm() <= 1.5 * xs.norm()

{kryptools-1.8.1 → kryptools-1.8.2}/tests/test_nt.py

@@ -9,12 +9,21 @@ seed(0)
 
 
 def test_egcd():
+    def sign(x: int) -> int:
+        return (1, -1)[x<0]
     maxsize = 100
     for a in range(-maxsize, maxsize):
         for b in range(-maxsize, maxsize):
             g, x, y = egcd(a, b)
             assert g == gcd(a, b)
             assert x * a + y * b == g
+            if a and b:
+                g, x, y = egcd(a, b, minimal = True)
+                assert g == gcd(a, b)
+                assert x * a + y * b == g
+                assert -abs(a) // g < y * sign(b) <= 0
+                assert 1 <= x * sign(a) <= abs(b)//g
+
 
 
 def test_crt():

kryptools-1.8.1/tests/test_lat.py

@@ -1,17 +0,0 @@
-# pragma pylint: disable=C0114,C0116
-import pytest  # pylint: disable=W0611
-from fractions import Fraction  # pylint: disable=C0411
-from kryptools import Matrix, gram_schmidt, random_unimodular_matrix
-
-
-def test_gram_schmidt():
-    V = Matrix([[5, 8], [0, 1]], ring=Fraction)
-    Vs, M = gram_schmidt(V)
-    assert V == Vs * M
-
-
-def test_random_unimodular_matrix():
-    for i in range(2, 5):
-        U = random_unimodular_matrix(i)
-        U.map(Fraction)
-        assert U.det() in (-1, 1)