kryptools 1.5.2__tar.gz → 1.6__tar.gz

{kryptools-1.5.2 → kryptools-1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.5.2
+Version: 1.6
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -47,13 +47,14 @@ The tools contained are:
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
+* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
 * 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)
 * Goppa: a class for encoding and decoding Goppa codes
 * CyclicCode: a class for encoding and decoding cyclic codes
 * ReedSolomonCode: a class for encoding and decoding Reed-Solomon codes
+* BCHCode: a class for encoding and decoding primitive narrow sense BCH codes
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.5.2 → kryptools-1.6}/README.md

@@ -29,13 +29,14 @@ The tools contained are:
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
+* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
 * 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)
 * Goppa: a class for encoding and decoding Goppa codes
 * CyclicCode: a class for encoding and decoding cyclic codes
 * ReedSolomonCode: a class for encoding and decoding Reed-Solomon codes
+* BCHCode: a class for encoding and decoding primitive narrow sense BCH codes
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.5.2 → kryptools-1.6}/kryptools/GF2.py

@@ -61,8 +61,12 @@ class GF2:
 
     def __call__(self, x: int | list | tuple | range | map):
         if isinstance(x, list|tuple|range|map):
-            return [GF2nPoint(xx, self) for xx in x]
-        return GF2nPoint(x, self)
+            if isinstance(x, bytes | bytearray):
+                return [ GF2nPoint(int.from_bytes(x, byteorder=self.byteorder), self) for xx in x]
+            return [GF2nPoint(int(xx) % self.order, self) for xx in x]
+        if isinstance(x, bytes | bytearray):
+            return GF2nPoint(int.from_bytes(x, byteorder=self.byteorder), self)
+        return GF2nPoint(int(x) % self.order, self)
 
     def __len__(self):
         return self.order
@@ -80,26 +84,26 @@ class GF2:
         return isinstance(other, GF2nPoint) and self == other.field
 
     def _factors(self) -> dict:
-        "Return the factroization order of the group order of GF(2^n)^*."
+        "Return the factroization of the group order of GF(2^n)^*."
         if not self.factors:
             self.factors = factorint(self.mult_order)
         return self.factors
 
     def zero(self) -> bool:
         "Return zero."
-        return self(0)
+        return GF2nPoint(0, self)
 
     def one(self) -> bool:
         "Return one."
         if self.bitreversed:
-            return self(self.order - 1)
-        return self(1)
+            return GF2nPoint(self.order >> 1, self)
+        return GF2nPoint(1, self)
 
     def random(self, num: int = 0) -> "GF2nPoint":
         "Return a single random point or a list of random points."
         if num:
-            return([self(randint(0,self.order-1)) for _ in range(num)])
-        return self(randint(0,self.order-1))
+            return([GF2nPoint(randint(0,self.order-1), self) for _ in range(num)])
+        return GF2nPoint(randint(0,self.order-1), self)
 
     def is_cyclic(self) -> bool:
         "GF(2^n)^* is cyclic."
@@ -112,9 +116,9 @@ class GF2:
     def generator(self) -> int | None:
         "Return a generator of the group GF(2^n)^*."
         if self.degree == 1:
-            return self(1)
+            return self.one()
         for a in range(2, self.order):
-            a = self(a)
+            a = GF2nPoint(a, self)
             if a.is_generator():
                 return a
 
@@ -129,16 +133,21 @@ class GF2:
     def star(self) -> list:
         "Return a generator for all elements of the group GF(2^n)n^*."
         for x in range(1, self.order):
-            yield self(x)
+            yield GF2nPoint(x, self)
 
+    def poly(self) -> Poly:
+        "Return the associated irreducible polynomial."
+        coeff = [int(d) for d in str(
+            format(self.modulus, "b"))]
+        if self.bitreversed:
+            return Poly(coeff + [1])
+        return Poly(list(reversed(coeff)))
 
 class GF2nPoint:
     "Represents a point in the Galois field GF(2^n)."
 
     def __init__(self, x: int, field: "GF2"):
-        if isinstance(x, bytes | bytearray):
-            x = int.from_bytes(x, byteorder=field.byteorder)
-        self.x = int(x) % field.order
+        self.x = x
         self.field = field
 
     def __repr__(self):
@@ -162,13 +171,11 @@ class GF2nPoint:
 
     def bits(self) -> list:
         "Convert to a list of bits."
+        coeff = [int(d) for d in str(
+            format(self.x, "0" + str(self.field.degree) + "b"))]
         if self.field.bitreversed:
-            coeff = [int(d) for d in str(
-                format(self.x, "0" + str(self.field.degree) + "b"))]
-        else:
-            coeff = reversed([int(d) for d in str(
-                format(self.x, "0" + str(self.field.degree) + "b"))])
-        return list(coeff)
+            return coeff
+        return list(reversed(coeff))
 
     def poly(self) -> "Poly":
         "Convert to a polynomial."
@@ -193,26 +200,20 @@ class GF2nPoint:
             return NotImplemented
         if self.field != other.field:
             raise NotImplementedError("Cannot add elements from different fields.")
-        return self.field(self.x ^ other.x)
+        return self.__class__(self.x ^ other.x, self.field)
 
-    def __neg__(self) -> "GF2nPoint":
-        return self
+    __sub__ = __add__
 
     def __pos__(self) -> "GF2nPoint":
         return self
 
-    def __sub__(self, other: "GF2nPoint") -> "GF2nPoint":
-        if not isinstance(other, self.__class__):
-            return NotImplemented
-        if self.field != other.field:
-            raise NotImplementedError("Cannot add elements from different fields.")
-        return self.field(self.x ^ other.x)
+    __neg__ = __pos__
 
     def __mul__(self, other: "GF2nPoint") -> "GF2nPoint":
         if isinstance(other, int):
             if other % 2:
                 return self
-            return self.field(0)
+            return self.__class__(0, self.field)
         if not isinstance(other, self.__class__):
             return NotImplemented
         if self.field != other.field:
@@ -238,13 +239,13 @@ class GF2nPoint:
                 y <<= 1
                 if y & bitmap1:
                     y ^= self.field.modulus
-        return self.field(z)
+        return self.__class__(z, self.field)
 
     def __rmul__(self, scalar: int) -> "GF2nPoint":
         if isinstance(scalar, int):
             if scalar % 2:
                 return self
-            return self.field(0)
+            return self.__class__(0, self.field)
         return NotImplemented
 
     def __truediv__(self, other: "GF2nPoint") -> "GF2nPoint":
@@ -261,14 +262,16 @@ class GF2nPoint:
             return NotImplemented
         if not (self.x) and j < 0:
             raise ValueError("Division by zero.")
+        j %= self.field.order - 1
         if self.field.order == 2:
+            if j == 0:
+                return self.field.one()
             return self
         if self.field.bitreversed:
-            res = self.field(self.field.order >> 1)
+            res = self.__class__(self.field.order >> 1, self.field)
         else:
-            res = self.field(1)
-        x = self.field(self.x)
-        j %= self.field.order - 1
+            res = self.__class__(1, self.field)
+        x = self.__class__(self.x, self.field)
         while j > 0:
             # If j is odd, multiply with x
             if j & 1:
@@ -282,13 +285,13 @@ class GF2nPoint:
         "Cyclic rotation to the left."
         x = self.x << j
         x = (x % self.field.order) + (x // self.field.order)
-        return self.field(x)
+        return self.__class__(self.x, self.field)
 
     def __rshift__(self, j: int) -> "GF2nPoint":
         "Cyclic rotation to the right."
         x = self.x >> j
         x += (self.field.order >> j) * (self.x % 2**j)
-        return self.field(x)
+        return self.__class__(self.x, self.field)
 
     def sqrt(self) -> "GF2nPoint":
         "Compute the square root."
@@ -314,6 +317,17 @@ class GF2nPoint:
         "Test if the point is a generator of the group GF(2^n)^*."
         return self.field.mult_order == self.order()
 
+    def minpoly(self) -> Poly:
+        "Return the minimal polynomial of an element."
+        aj = self
+        mpoly = Poly([aj, self.field.one()])
+        for _ in range(1, self.field.degree):
+            aj = aj**2  # Frobenius
+            if aj == self:
+                break
+            mpoly *= Poly([aj, self.field.one()])
+        return mpoly
+
     def sbox(self, inv: bool = False) -> "GF2nPoint":
         "Apply the AES sbox."
         if self.field.degree == 8 and self.field.modulus == 0b100011011: # AES

{kryptools-1.5.2 → kryptools-1.6}/kryptools/Zmod.py

@@ -43,8 +43,8 @@ class Zmod:
 
     def __call__(self, x: int | list | tuple | range | map):
         if isinstance(x, list|tuple|range|map):
-            return [ZmodPoint(xx, self) for xx in x]
-        return ZmodPoint(x, self)
+            return [ZmodPoint(int(xx), self) for xx in x]
+        return ZmodPoint(int(x), self)
 
     def __iter__(self):
         for x in range(self.n):
@@ -157,7 +157,7 @@ class ZmodPoint:
     "Represents a point in the ring Zmod."
 
     def __init__(self, x: int, ring: "Zmod"):
-        self.x = int(x) % ring.n
+        self.x = x % ring.n
         self.ring = ring
 
     def __repr__(self):
@@ -247,8 +247,11 @@ class ZmodPoint:
 
     def sharp(self):
         "Returns a symmetric (w.r.t. 0) representative."
-        tmp = (self.ring.n - 1) // 2
-        return (self.x + tmp) % self.ring.n - tmp
+        if self.x <= self.ring.n // 2:
+            return self.x
+        return self.x - self.ring.n
+
+    mods = sharp
 
     def order(self) -> int:
         "Compute the order of the point in the group Z_n^*."

{kryptools-1.5.2 → kryptools-1.6}/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.5.1"
+__version__ = "1.6"
 __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
@@ -19,7 +19,7 @@ from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round
 from .poly import Poly, lagrange_interpolation
 from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash
-from .code import left_standard_form, gen2pchk, hamming_dist, Goppa, CyclicCode, ReedSolomonCode
+from .code import gen2pchk, hamming_dist, Goppa, CyclicCode, ReedSolomonCode, BCHCode
 from .blockcipher import BlockCipher, bytexor
 from .aes import AESKeySchedule, AESCipher, AESBlockCipher
 from .des import list2int, int2list, permute, invert_permutation, rotate_left, SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, DESBlockCipher

{kryptools-1.5.2 → kryptools-1.6}/kryptools/code.py

@@ -5,8 +5,8 @@ Linear codes
 from math import prod
 from .Zmod import Zmod
 from .GF2 import GF2
-from .poly import Poly, lagrange_interpolation
-from .la import Matrix, eye, zeros
+from .poly import Poly
+from .la import Matrix
 
 
 def poly2bits(x: Poly) -> list:
@@ -16,45 +16,13 @@ def poly2bits(x: Poly) -> list:
         out += c.bits()
     return out
 
-def left_standard_form(M: Matrix) -> (Matrix, Matrix):
+def left_standard_form(G: Matrix) -> (Matrix, Matrix):
     "Compute the left standard form of a generator matrix. Return the standard form and the pertmutation matrix."
-    # reduced row echelon form
-    M = M.rref()
-    # purge zero rows
-    for i in range(M.rows-1,-1,-1):
-        if not M[i,:]:
-            M.delete_rows(i)
-    # permute columns to get the identity on the left
-    last = min(M.rows, M.cols)
-    P = eye(M.cols)
-    for i in range(last):
-        if not M[i,i]: # the diagonal entry vanishes
-            # find the index of the pivot and permute
-            j = i + 1
-            while j <= M.cols and not M[i, j]:
-                j += 1
-            P[:,i], P[:,j] = P[:,j], P[:,i]
-            M[:,i], M[:,j] = M[:,j], M[:,i]
-    return M, P
+    return G.left_standard_form()
 
 def gen2pchk(G: Matrix) -> Matrix:
     "Compute the parity check matrix from a given generator matrix (and vice versa)."
-    G, P = left_standard_form(G)
-    d = G.cols - G.rows
-    if d <= 0:
-        raise ValueError("A generator matrix must have more columns than rows!")
-    zero = 0 * G[0]
-    one = zero**0
-    # we start with a zero matrix
-    H = zeros(d, G.cols, zero = zero)
-    # create the identity on the right
-    for i in range(d):
-        H[i,G.rows+i] = one
-    # add minus the transpose of the right part of G as the left part
-    tmp = - G[:,-d:].transpose()
-    for i in range(G.cols - d):
-        H[:, i] = tmp[:, i]
-    return H * P.transpose()
+    return G.kernel().transpose()
 
 def hamming_dist(a: iter, b: iter):
     "Hamming distance of two iterables."
@@ -102,7 +70,7 @@ class Goppa():
         self.G = gen2pchk(self.H)
 
     def __repr__(self):
-        return f"Binary irreducible Goppa code over GF(2^{self.gf.power}) with polynomial g(x) = {self.g}."
+        return f"Binary irreducible Goppa [{self.G.cols}, {self.G.rows}] code over GF(2^{self.gf.degree}) with polynomial g(x) = {self.g}."
 
     def encode(self, x: list[int]):
         "Encode a given list of bits."
@@ -217,13 +185,18 @@ class CyclicCode():
             raise ValueError(f"Degree can be at most {self.n-1}.")
         x, r = y.divmod(self.g)
         if r:
-            raise NotImplementedError("Word is no code word! Cannot decode.")
+            y = self.correct(y)
+            x, r = y.divmod(self.g)
         if systematic_form:
             x.coeff = y.coeff[self.g.degree():]
         if as_list:
             return x.coeff + [zero] * (self.k - len(x.coeff))
         return x
 
+    def correct(self, y: Poly):
+        "Correct a given polynomial."
+        raise NotImplementedError("Error correction not implemented.")
+
     def generator_matrix(self):
         "Return the generator matrix of the code."
         zero = 0 * self.g[0]
@@ -246,12 +219,12 @@ class ReedSolomonCode(CyclicCode):
     >>> rsc = ReedSolomonCode(k, gf)
     
     To encode a list of letters (the length must be equal to the dimension k of the code; conversion to the Galois field is done automatically):
-    >>> cc.encode([1, 2, 3])
-    [0, 1, 1, 0]
+    >>> rsc.encode([1, 2, 3])
+    [6, 4, 5, 1, 8, 4, 2, 9, 2, 8, 9, 6]
 
-    Decoding is only implemnted for code words:
-    >>> cc.decode([0, 1, 1, 0], ring = Zmod(2))
-    [0, 1, 0]
+    To decode use:
+    >>> rsc.decode([1, 4, 4, 0, 8, 4, 2, 9, 2, 0, 9, 6])
+    [1, 2, 3]
     
     """
     def __init__(self, k:int, gf, alpha = None):  # pylint: disable=W0231
@@ -265,7 +238,9 @@ class ReedSolomonCode(CyclicCode):
         self.order = n + 1  # order of the base field
         self.n = n  # lenght
         self.k = k  # dimension
-        self.d = n - k - 1  # minimal distance
+        if k >= n:
+            raise ValueError(f"Code dimension k = {k} must be smaller than the code lenght n = {self.n}.")
+        self.d = n - k + 1  # minimal distance
         self.modulus = Poly([-one] + [zero] * (n-1) + [one])
         if alpha is None:
             if hasattr(gf, "primitive_element"):
@@ -279,9 +254,9 @@ class ReedSolomonCode(CyclicCode):
         assert self.g * self.h == self.modulus
 
     def __repr__(self):
-        return f"Reed-Solomon-Code [{self.n}, {self.k}, {self.d}] over GF({self.n+1})."
+        return f"Reed-Solomon [{self.n}, {self.k}, {self.d}] code over GF({self.n+1})."
 
-    def encode(self, x: list|Poly):  # pylint: disable=W0221
+    def encode(self, x: list|Poly) -> list|Poly:  # pylint: disable=W0221
         "Encode a given list or polynomial."
         as_list = False
         zero = 0 * self.g[0]
@@ -295,7 +270,7 @@ class ReedSolomonCode(CyclicCode):
             return y + [zero] * (self.n - len(y))
         return Poly(y)
 
-    def decode(self, y: list|Poly):  # pylint: disable=W0221
+    def decode(self, y: list|Poly) -> list|Poly:  # pylint: disable=W0221
         "Decode a given list or polynomial."
         as_list = False
         zero = 0 * self.g[0]
@@ -309,19 +284,76 @@ class ReedSolomonCode(CyclicCode):
         x = Poly(xx)
         if x.degree() >= self.k: # No codewort
             t = (self.n - self.k) // 2
+            if not t:
+                raise ValueError("This code cannot correct any errors.")
             A = Matrix([[ xx[j - l % self.n] for l in range(1, t+1) ] for j in range(self.k+t, self.k+2*t) ])
             b = [ -xx[self.k + t + l ] for l in range(t) ]
             lam = Poly([one] + list(A.solve(b)))
-            x_coordinates = []
-            y_coordinates = []
-            for j in range(self.n):
-                if len(x_coordinates) == self.k:
-                    break
-                alphaj = self.alpha**j
-                if lam(alphaj):
-                    x_coordinates.append(alphaj)
-                    y_coordinates.append(y[j])
-            x = lagrange_interpolation(x_coordinates, y_coordinates)
+            lamp = lam.derivative()
+            s = Poly([x[self.k + j] for j in range(self.n - self.k)])
+            omega = s * lam
+            omega = Poly(omega.coeff[:self.n - self.k])  # mod x^(n-k)
+            # Chien search
+            lam = lam.coeff
+            alphai = [ self.alpha**i for i in range(len(lam)) ]
+            for i in range(self.n):
+                if not sum(lam, start = zero):
+                    # Fornay
+                    ali = self.alpha**i
+                    y[i] -= ali**(self.k-1) * omega(ali) / lamp(ali)
+                for j in range(len(lam)):  # pylint: disable=C0200
+                    lam[j] *= alphai[j]
+            x = Poly([ -y(self.alpha**(-j)) for j in range(self.n) ])
         if as_list:
             return x.coeff + [zero] * (self.k - len(x.coeff))
         return x
+
+    def correct(self, y: Poly):
+        "Correct a given polynomial."
+        x = self.decode(y)
+        return self.encode(x)
+
+class BCHCode(CyclicCode):
+    """
+    Binary narrow sense primitive BCH code.
+
+    Example:
+
+    >>> n = 7 # lenght of the code
+    >>> D = 2 # desired distance
+    >>> bch = BCHCode(k, D)
+    
+    To encode a list of letters (the length must be equal to the dimension k of the code; conversion to the Galois field is done automatically):
+    >>> bch.encode([0, 1, 0, 1])
+    [0, 1, 1, 1, 0, 0, 1]
+
+    To decode use:
+    >>> bch.decode([0, 1, 1, 1, 0, 0, 1])
+    [0, 1, 0, 1]
+    
+    """
+    def __init__(self, n:int, D: int):
+        m = n.bit_length()
+        if 2**m - 1 != n:
+            raise ValueError(f"The codelenght n={n} plus one must be a power of 2.")
+        self.rsc = ReedSolomonCode(n - D + 1, GF2(m))
+        # Compute the generator polynomial
+        aj = self.rsc.alpha
+        g = aj.minpoly()
+        for _ in range(2,D):
+            aj *= self.rsc.alpha
+            mj = aj.minpoly()
+            g = g.lcm(mj)
+        g.map(GF2(1))
+        super().__init__(n, g)
+
+    def __repr__(self):
+        return f"BCH [{self.n}, {self.k}] code over GF({self.order}) with generator polynomial g(x) = {self.g}."
+
+    def correct(self, y: Poly):
+        "Correct a given polynomial."
+        y.map(self.rsc.gf)
+        x = self.rsc.decode(y)
+        y = self.rsc.encode(x)
+        y.map(GF2(1))
+        return y

{kryptools-1.5.2 → kryptools-1.6}/kryptools/factor_qs.py

@@ -13,13 +13,13 @@ def bytexor(a: bytearray, b: bytes) -> bytes:
         a[i] ^= b[i]
 
 
-def byteset(a: bytearray, i: int) -> bytes:
+def byteset(a: bytearray, i: int) -> None:
     """Set the i'th bit in the bytearray `a` to 1."""
     i1, i0 = divmod(i, 8)
     a[i1] |= 2**i0
 
 
-def bytetest(a: bytes, i: int) -> bytes:
+def bytetest(a: bytes, i: int) -> bool:
     """Test if the i'th bit in the bytestring `a` is 1."""
     i1, i0 = divmod(i, 8)
     return (a[i1] & 2**i0) != 0

{kryptools-1.5.2 → kryptools-1.6}/kryptools/la.py

@@ -169,7 +169,9 @@ class Matrix:
 
     def append_row(self, row: list|tuple, ring = None) -> None:
         "Append a row."
-        if not isinstance(row, list|tuple) or len(row) != self.cols:
+        if not isinstance(row, list|tuple):
+            row = list(row)
+        if len(row) != self.cols:
             raise ValueError("Length does not match the number of columns.")
         if ring:
             row =list(map(ring, row))
@@ -178,7 +180,9 @@ class Matrix:
 
     def append_column(self, col: list|tuple, ring = None) -> None:
         "Append a column."
-        if not isinstance(col, list|tuple) or len(col) != self.rows:
+        if not isinstance(col, list|tuple):
+            col = list(col)
+        if len(col) != self.rows:
             raise ValueError("Length does not match the number of rows.")
         if ring:
             col =list(map(ring, col))
@@ -312,6 +316,50 @@ class Matrix:
                 break
         return R
 
+    def left_standard_form(self) -> ("Matrix", "Matrix"):
+        "Compute the left standard form of a matrix. Return the standard form and the pertmutation matrix."
+        # reduced row echelon form
+        M = self.rref()
+        # purge zero rows
+        for i in range(M.rows-1,-1,-1):
+            if not M[i,:]:
+                M.delete_rows(i)
+        # permute columns to get the identity on the left
+        last = min(M.rows, M.cols)
+        P = M.eye(M.cols)
+        for i in range(last):
+            if not M[i,i]: # the diagonal entry vanishes
+                # find the index of the pivot and permute
+                j = i + 1
+                while j <= M.cols and not M[i, j]:
+                    j += 1
+                P[:,i], P[:,j] = P[:,j], P[:,i]
+                M[:,i], M[:,j] = M[:,j], M[:,i]
+        return M, P
+
+    def kernel(self) -> "Matrix":
+        "Compute a basis for the kernel of a matrix."
+        _, one = self._guess_zero()
+        M = self.rref()
+        pivotcols = []
+        nonpivotcols = []
+        j = 0
+        for i in range(0, M.rows):
+            while j < M.cols and not M[i,j]:
+                nonpivotcols.append(j)
+                j += 1
+            if j == M.cols:
+                break
+            pivotcols.append(j)
+            j += 1
+        nonpivotcols += list(range(j, M.cols))
+        K = M.zeros(M.cols, max(1,len(nonpivotcols)))
+        for k, j in enumerate(nonpivotcols):
+            K[j, k] = one
+            for l, i in enumerate(pivotcols):
+                K[i, k] = - M[l, j]
+        return K
+
     def det(self) -> int:
         "Compute the determinant of a matrix M."
         zero, one = self._guess_zero()
@@ -349,6 +397,10 @@ class Matrix:
                 return i+1
         return 0
 
+    def nullity(self) -> int:
+        "Compute the nillity of a matrix M."
+        return self.cols - self.rank()
+
     def inv(self) -> "Matrix":
         "Compute the inverse of a square matrix M."
         if self.rows != self.cols:

{kryptools-1.5.2 → kryptools-1.6}/kryptools/poly.py

@@ -18,6 +18,7 @@ class Poly:
     """
 
     print_reversed = True  # print the terms in reversed order
+    print_latex = False  # print in latex format
     print_x = "x"  # variable for printing
     print_pow = "^"  # you can change this to "**" if you want it python style
 
@@ -63,16 +64,20 @@ class Poly:
     def __hash__(self):
         return hash(tuple(self.coeff))
 
-    def __repr__(self, latex=False):
+    def __repr__(self, latex=None):
         def prx(i: int) -> str:
             if i == 0:
                 return ""
             if i == 1:
                 return self.__class__.print_x
             if latex:
+                if i < 10:
+                    return self.__class__.print_x + "^" + str(i)
                 return self.__class__.print_x + "^{" + str(i) + "}"
             return self.__class__.print_x + self.__class__.print_pow + str(i)
 
+        if latex is None:
+            latex = self.__class__.print_latex
         if not self:
             return str(self.coeff[0])
         one = self.coeff[0]**0
@@ -130,6 +135,10 @@ class Poly:
         "Return the degree."
         return len(self.coeff) - 1
 
+    def weight(self) -> int:
+        "Return the number of nonzero coefficients."
+        return sum(map(bool,self.coeff))
+
     def map(self, func):
         "Apply a given function to all coefficients in place."
         self.coeff = list(map(func, self.coeff))
@@ -294,7 +303,7 @@ class Poly:
             return self.__class__([zero]), self
         div = [zero] * (sd - od + 1)
         lco = other.coeff[-1]
-        if bool(lco - one):
+        if lco != one:
             tmp = one / lco
             oth = [c * tmp for c in other.coeff]
             rem = [c * tmp for c in self.coeff]
@@ -306,7 +315,7 @@ class Poly:
             div[sd - od - i] = tmp
             for j in range(od + 1):
                 rem[sd - i - j] -= tmp * oth[od - j]
-        if bool(lco - one):
+        if lco != one:
             rem = [c * lco for c in rem]
         return self.__class__(div, modulus=self.modulus), self.__class__(rem, modulus=self.modulus)
 
@@ -323,7 +332,7 @@ class Poly:
         if sd < od:
             return self
         lco = other.coeff[-1]
-        if bool(lco - one):
+        if lco != one:
             tmp = one / lco
             oth = [c * tmp for c in other.coeff]
         else:
@@ -359,12 +368,15 @@ class Poly:
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
         y0.modulus = self.modulus
+        if r0.coeff[0] == one:
+            return y0
         return y0 / r0.coeff[0]
 
     def gcd(self, other: "Poly") -> "Poly":
         "Greates common divisor with a given polynomial."
         if not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot compute gcd: {other} must be a polynomial.")
+        _, one, _ = self._guess_ring()
         if not self:
             if not other:
                 return Poly([self.coeff[0]])
@@ -375,8 +387,14 @@ class Poly:
         while r1:
             r0, r1 = r1, r0.divmod(r1)[1]
         r0.modulus = None
+        if r0.coeff[-1] == one:
+            return r0
         return r0 / r0.coeff[-1]
 
+    def lcm(self, other: "Poly") -> "Poly":
+        "Least common multiple with a given polynomial."
+        return self * other // self.gcd(other)
+
     def egcd(self, other: "Poly") -> ("Poly", "Poly", "Poly"):
         """Perform the extended Euclidean agorithm for polynomials. Returns gcd, x, y such that other * x + self * y = gcd."""
         zero, one, _ = self._guess_ring()
@@ -385,6 +403,8 @@ class Poly:
         if not self:
             if not other:
                 return Poly([zero]), Poly([zero]), Poly([zero])
+            if other.coeff[-1] == one:
+                return other, Poly([zero]), one
             return other / other.coeff[-1], Poly([zero]), one / other.coeff[-1]
         r0, r1 = other, self
         x0, x1 = self.__class__([one]), self.__class__([zero])
@@ -395,6 +415,8 @@ class Poly:
             x0, x1 = x1, x0 - x1 * q
             y0, y1 = y1, y0 - y1 * q
         lcr0 = r0.coeff[-1]
+        if lcr0 == one:
+            return r0, x0, y0
         return r0 / lcr0, x0 / lcr0, y0 / lcr0
 
     def derivative(self) -> "Poly":

{kryptools-1.5.2 → kryptools-1.6}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.5.2
+Version: 1.6
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -47,13 +47,14 @@ The tools contained are:
 * lattices: Hadamard ratio, Babai rounding/nearest plane algorithm, lattice reduction (Lenstra-Lenstra-Lovaz)
 * linear codes: Hamming distance, left standard form, parity check matrix
 
-* Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
+* Matrix: a class for Matrices (inverse, det, reduced echelon form, kernel, etc.)
 * 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)
 * Goppa: a class for encoding and decoding Goppa codes
 * CyclicCode: a class for encoding and decoding cyclic codes
 * ReedSolomonCode: a class for encoding and decoding Reed-Solomon codes
+* BCHCode: a class for encoding and decoding primitive narrow sense BCH codes
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.5.2 → kryptools-1.6}/pyproject.toml

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

{kryptools-1.5.2 → kryptools-1.6}/tests/test_GF2.py

@@ -4,7 +4,7 @@ from random import randint, seed  # pylint: disable=C0411
 from kryptools import GF2, euler_phi
 seed(0)
 
-num_tests = 50
+num_tests = 25
 
 def test_GF2_ops():
     for n, modulus in [(4, None), (8, None), (8, 0b100011011), (12, None), (128, 0b11100001 << 120)]:
@@ -14,6 +14,10 @@ def test_GF2_ops():
         assert gf(1) == gf(1)
         assert gf(1) != gf(0)
         assert gf(0) != 0
+        assert 0 * gf.one() == gf.zero()
+        assert 1 * gf.one() == gf.one()
+        assert 2 * gf.one() == gf.zero()
+        assert gf.zero()**0 == gf.one()
         if gf.degree < 17:
             assert len(list(gf)) == gf.order
             assert len(list(gf.star())) == gf.order - 1
@@ -21,9 +25,16 @@ def test_GF2_ops():
         for _ in range(num_tests):
             a = gf(randint(0, gf.order-1))
             b = gf(randint(0, gf.order-1))
+            assert a * gf.one() == a
+            assert gf.one() * a == a
+            assert a**0 == gf.one()
+            assert a**1 == a
+            assert a**2 == a * a
+            assert a * b == b * a
             assert (a + b).poly() == a.poly() + b.poly()
             assert (a - b).poly() == a.poly() - b.poly()
             assert (a * b).poly() == a.poly() * b.poly()
+            assert (a**2).poly() == a.poly()**2
             if a:
                 assert (a**-1).poly() == a.poly().inv()
             if b:

{kryptools-1.5.2 → kryptools-1.6}/tests/test_Zmod.py

@@ -41,8 +41,8 @@ def test_Zmod_methods():
     assert Z_5(3).is_generator() is True
     assert list(Z_5.generators()) == Z_5([2, 3])
     assert list(Z_5.star()) == Z_5([1, 2, 3, 4])
-    assert [Z_5(i).sharp() for i in range(Z_5.n)] == [0, 1, 2, -2, -1]
-    assert [abs(Z_5(i)) for i in range(Z_5.n)] == [0, 1, 2, 2, 1]
+    assert [i.sharp() for i in Z_5] == [0, 1, 2, -2, -1]
+    assert [abs(i) for i in Z_5] == [0, 1, 2, 2, 1]
     assert not Z_5(0)
     assert Z_5(1)
     assert Z_5(2) == Z_5(2)
@@ -63,6 +63,9 @@ def test_Zmod_methods():
     assert Z_6(5).is_generator() is True
     assert list(Z_6.generators()) == Z_6([5])
     assert list(Z_6.star()) == Z_6([1, 5])
+    assert [i.sharp() for i in Z_6] == [0, 1, 2, 3, -2, -1]
+    assert [abs(i) for i in Z_6] == [0, 1, 2, 3, 2, 1]
+    assert not Z_6(0)
     assert Z_6(1)
     assert Z_6(2) == Z_6(2)
     assert Z_6(2) != Z_6(3)

{kryptools-1.5.2 → kryptools-1.6}/tests/test_code.py

@@ -2,7 +2,7 @@
 import pytest  # pylint: disable=W0611
 from random import randint, seed  # pylint: disable=C0411
 from kryptools import Zmod, GF2, Poly, Matrix
-from kryptools import gen2pchk, Goppa, CyclicCode, ReedSolomonCode
+from kryptools import gen2pchk, Goppa, CyclicCode, ReedSolomonCode, BCHCode
 
 seed(0)
 Z_2 = Zmod(2)
@@ -33,6 +33,7 @@ def test_Goppa():
         alpha = list(gf)
 
         goppa = Goppa(gf, g, alpha)
+        assert not goppa.H * goppa.G.transpose()
         for _ in range(num_tests):
             x = [ randint(0,1) for _ in range(goppa.G.rows) ]
             y = goppa.encode(x)
@@ -45,6 +46,12 @@ def test_Cyclic():
     for gf, n, g in [ [Zmod(2), 4, [1, 1]],  [Zmod(3), 4, [-1, 1]], [Zmod(11), 5, [4, 6, 1]] ]:
         g = Poly(g, ring = gf)
         cc = CyclicCode(n, g)
+        G = cc.generator_matrix()
+        H = cc.check_matrix()
+        assert not H * G.transpose()
+        H2 = gen2pchk(G)
+        assert H2.rows == H.rows
+        assert not H2 * G.transpose()
         for _ in range(num_tests):
             x = [ gf(randint(0, cc.order-1)) for _ in range(cc.k) ]
             y = cc.encode(x)
@@ -53,6 +60,12 @@ def test_Cyclic():
 def test_ReedSolomon():
     for gf, k in [ [Zmod(13), 3],  [GF2(6), 4]]:
         rsc = ReedSolomonCode(k, gf)
+        G = rsc.generator_matrix()
+        H = rsc.check_matrix()
+        assert not H * G.transpose()
+        H2 = gen2pchk(G)
+        assert H2.rows == H.rows
+        assert not H2 * G.transpose()
         t = (rsc.n - rsc.k) // 2
         for _ in range(num_tests):
             x = [ gf(randint(0, rsc.n)) for _ in range(rsc.k) ]
@@ -61,3 +74,22 @@ def test_ReedSolomon():
                 i = randint(0, rsc.n-1)
                 y[i] += gf(1)
             assert rsc.decode(y) == x
+
+def test_BCH():
+    gf = GF2(1)
+    for n, D in [ [7, 3],  [15, 5]]:
+        bch = BCHCode(n, D)
+        G = bch.generator_matrix()
+        H = bch.check_matrix()
+        assert not H * G.transpose()
+        H2 = gen2pchk(G)
+        assert H2.rows == H.rows
+        assert not H2 * G.transpose()
+        t = (D - 1) // 2
+        for _ in range(num_tests):
+            x = [ gf(randint(0, 1)) for _ in range(bch.k) ]
+            y = bch.encode(x)
+            for _ in range(t):
+                i = randint(0, bch.n-1)
+                y[i] += gf(1)
+            assert bch.decode(y) == x

{kryptools-1.5.2 → kryptools-1.6}/tests/test_la.py

@@ -1,7 +1,7 @@
 # pragma pylint: disable=C0114,C0116
 import pytest  # pylint: disable=W0611
 from fractions import Fraction  # pylint: disable=C0411
-from kryptools import Matrix, Zmod
+from kryptools import Matrix, Zmod, GF2
 
 
 def test_Matrix():
@@ -26,3 +26,16 @@ def test_Matrix():
     M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]], ring=Z_11)
     Mi = M.inv()
     assert M * Mi == M.eye()
+
+def test_kernel():
+    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)], ring = gf)
+                K = A.kernel()
+                assert not A * K
+                assert K.rows == A.cols
+                if K:
+                    assert K.cols == A.nullity()
+                else:
+                    assert K.cols == 1

{kryptools-1.5.2 → kryptools-1.6}/tests/test_poly.py

@@ -8,9 +8,17 @@ seed(0)
 num_tests = 10
 
 def test_Poly():
+    assert  Poly([0]).weight() == 0
+    assert  Poly([1]).weight() == 1
+    assert  Poly([1]).degree() == 0
     p = Poly([2, 0, 2])
     q = Poly([1, 2, 3, 4])
+    assert p.degree() == 2
+    assert p.weight() == 2
+    assert q.degree() == 3
+    assert q.weight() == 4
     d, m = q.divmod(p)
+    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)])
@@ -26,6 +34,7 @@ def test_Poly():
     q = Poly([1, 2, 3, 4], ring = gf)
     d, m = q.divmod(p)
     assert d * p + m == q
+    assert q * p == p.gcd(q) * p.lcm(q)
     for _ in range(num_tests):
         p = Poly(gf.random(10))
         q = Poly(gf.random(12))