kryptools 1.2__tar.gz → 1.3__tar.gz

{kryptools-1.2 → kryptools-1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.2
+Version: 1.3
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -39,11 +39,13 @@ The tools contained are:
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * 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.)
 * Poly: a class for polynomials (division, modulo)
 * 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
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.2 → kryptools-1.3}/README.md

@@ -21,11 +21,13 @@ The tools contained are:
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * 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.)
 * Poly: a class for polynomials (division, modulo)
 * 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
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.2 → kryptools-1.3}/kryptools/Zmod.py

@@ -17,7 +17,7 @@ class Zmod:
     To define a finite Galois field modulo the prime 5 use
     >>> Z_5=Zmod(5)
 
-    To declare 3 as an element of our Galois filed use
+    To declare 3 as an element of our Galois field use
     >>> Z_5(3)
     3
 
@@ -210,6 +210,10 @@ class ZmodPoint:
     def __abs__(self) -> int:
         return abs(self.sharp())
 
+    def bits(self) -> list:
+        "Convert to a list of bits."
+        return [int(d) for d in str(format(self.x, "0" + str(int.bit_length(self.ring.n - 1)) + "b"))]
+
     def sharp(self):
         "Returns a symmetric (w.r.t. 0) representative."
         tmp = (self.ring.n - 1) // 2

{kryptools-1.2 → kryptools-1.3}/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.2"
+__version__ = "1.3"
 __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,6 +19,7 @@ from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round
 from .poly import Poly
 from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash
+from .code import left_standard_form, gen2pchk, hamming_dist, Goppa
 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.3/kryptools/code.py

@@ -0,0 +1,124 @@
+"""
+Linear codes
+"""
+
+from .Zmod import Zmod
+from .GF2 import GF2
+from .poly import Poly
+from .la import Matrix, eye, zeros
+
+
+def poly2bits(x: Poly) -> list:
+    "Convert a polynomial in GF(2^n)[x] to a list of binary digits."
+    out = []
+    for c in x.coeff:
+        out += c.bits()
+    return out
+
+def left_standard_form(M: Matrix) -> (Matrix, Matrix):
+    "Compute the left standard form of a generator matrix. Return the standard form and the pertmutation matrix."
+    M = M.rref()
+    for i in range(M.rows-1,-1,-1):
+        if not M[i,:]:
+            M.delete_rows(i)  # remove zero rows
+    last = min(M.rows, M.cols)
+    P = eye(M.cols)
+    for i in range(last):
+        if not M[i,i]:
+            j = i + 1
+            while j <= last and not M[i, j]:
+                j += 1
+            if j <= last:
+                P[:,i], P[:,j] = P[:,j], P[:,i]
+                M[:,i], M[:,j] = M[:,j], M[:,i]
+    return M, P
+
+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
+    assert d > 0
+    zero = 0 * G[0]
+    H = zeros(d, G.cols, zero = zero)
+    for i in range(d):
+        H[i,G.rows+i] = zero**0
+    tmp = - G[:,-d:].transpose()
+    for i in range(G.cols - d):
+        H[:, i] = tmp[:, i]
+    return H * P.transpose()
+
+def hamming_dist(a: iter, b: iter):
+    "Hamming distance of two iterables."
+    if len(a) != len(b):
+        raise ValueError("Both iteralbles must have equal length.")
+    return sum(aa != bb for aa, bb in zip(a, b))
+
+class Goppa():
+    """
+    Binary Goppa code.
+
+    Example:
+
+    >>> gf = GF2(4) # base field GF(2^n)
+    >>> g = Poly([2, 0, 0, 1], ring = gf) # Polynomial for the code
+    >>> alpha = list(gf) # list of points from the base field (must not contain zeros of g)
+    >>> goppa = Goppa(gf, g, alpha)
+    
+    To encode a list of bits (the length must be equal to the dimension k of the code)
+    >>> goppa.encode([1, 0, 1, 1])
+    [0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1]
+
+    Decoding still works if there are atmost deg(g) errors:
+    >>> goppa.decode([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0])
+    [1, 0, 1, 1]
+    
+    """
+
+    def __init__(self, gf: GF2, g: Poly, alpha: list["GF2Point"]):
+        assert all(map(g, alpha))
+        self.gf = gf
+        self.g = g
+        self.alpha = alpha
+        # Compute the control matrix
+        self.Z_2 = Zmod(2)
+
+        tmp =[]
+        for x in alpha:
+            tmp.append(Poly([-x, 1], ring = gf, modulus = g).inv().bits())
+        self.H = Matrix(tmp, ring=self.Z_2).transpose()
+        # Compute the generator matrix
+        self.G = gen2pchk(self.H)
+
+    def encode(self, x: list[int]):
+        "Encode a given list of bits."
+        x = Matrix(x, ring = self.Z_2)
+        y = self.G.transpose() * x
+        y.map(int)
+        return list(y)
+
+    def decode(self, y: list[int]):
+        "Decode a given list of bits."
+        y = Matrix(y, ring = self.Z_2)
+        if self.H * y: # no code word
+            s = self.gf(0) # syndrom polynomial
+            for i, x in enumerate(self.alpha):
+                s += int(y[i]) * Poly([-x, 1], ring = self.gf, modulus = self.g).inv()
+            v = (s.inv() - Poly([0, 1], ring = self.gf, modulus = self.g))**(self.gf.order ** self.g.degree() // 2)
+            # determine error locator polynomial sigma(x) = a(x^2) + b(x^2) * x
+            # find a and b by running EEA until b has the desired degree
+            v.modulus = None
+            r0, r1 = self.g, v
+            y0, y1 = Poly([self.gf(0)]), Poly([self.gf(1)])
+            while r1 and 2* r1.degree() > self.g.degree():
+                q, r = r0.divmod(r1)
+                r0, r1 = r1, r
+                y0, y1 = y1, y0 - q * y1
+            a, b = r1, y1
+            sigma = a**2 + b**2 * Poly([0,1], ring = self.gf)
+            # correct the error
+            for x in self.gf:
+                if not sigma(x):
+                    y[int(x)] += 1
+        x = self.G.transpose().solve(y)
+        x.map(int)
+        return list(x)

{kryptools-1.2 → kryptools-1.3}/kryptools/la.py

@@ -374,7 +374,7 @@ class Matrix:
         A[:, 0:self.cols] = self
         A[:, self.cols] = b
         A = A.rref()
-        solution = self.zeros(self.rows, 1)
+        solution = self.zeros(self.cols, 1)
         for i in range(A.rows-1, -1, -1):
             if not any(A.matrix[i][:-1]):
                 if A.matrix[i][-1]:

{kryptools-1.2 → kryptools-1.3}/kryptools/lat.py

@@ -109,7 +109,8 @@ def babai_plane_bnd(U: Matrix, p=2) -> float:
 
 def lagrange_lr(V: Matrix) -> Matrix:
     "Lagrange lattice reduction."
-    assert (V.rows, V.cols) == (2, 2)
+    if (V.rows, V.cols) != (2, 2):
+        raise ValueError("Lagrange lattice reduction requires dimension two.")
     v1, v2 = V[:, 0], V[:, 1]
     if norm2(v1) > norm2(v2):
         v1, v2 = v2, v1

{kryptools-1.2 → kryptools-1.3}/kryptools/poly.py

@@ -231,6 +231,16 @@ class Poly:
             tmp *= tmp
         return res
 
+    def bits(self) -> list[int]:
+        "List of bits of all coefficients."
+        ring = self.coeff[0].__class__
+        if not (hasattr(ring, 'bits') and callable(ring.bits)):
+            raise NotImplementedError("Coefficients cannot be converted to bits.")
+        out = []
+        for c in self.coeff:
+            out += c.bits()
+        return out
+
     def max(self) -> int:
         "Maximum of the absolute value of all coefficients."
         return max(abs(c) for c in self.coeff)

{kryptools-1.2 → kryptools-1.3}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.2
+Version: 1.3
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -39,11 +39,13 @@ The tools contained are:
 * elliptic curves (Weierstrass form), group operations, order, discrete logarithms
 * linear algebra: Hermite normal form, Gram-Schmidt
 * 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.)
 * Poly: a class for polynomials (division, modulo)
 * 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
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.2 → kryptools-1.3}/kryptools.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ kryptools/Zmod.py
 kryptools/__init__.py
 kryptools/aes.py
 kryptools/blockcipher.py
+kryptools/code.py
 kryptools/conway_polynomials.py
 kryptools/des.py
 kryptools/dlp.py
@@ -36,6 +37,7 @@ kryptools.egg-info/top_level.txt
 tests/test_GF2.py
 tests/test_Zmod.py
 tests/test_aes.py
+tests/test_code.py
 tests/test_des.py
 tests/test_dlog.py
 tests/test_ec.py

{kryptools-1.2 → kryptools-1.3}/pyproject.toml

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

kryptools-1.3/tests/test_code.py

@@ -0,0 +1,32 @@
+import pytest
+from random import randint, seed
+from kryptools import Zmod, GF2, Poly, Matrix
+from kryptools import gen2pchk, Goppa
+
+seed(0)
+Z_2 = Zmod(2)
+G_Hamming = Matrix([
+[1, 0, 0, 0, 1, 1, 0],
+[0, 1, 0, 0, 1, 0, 1],
+[0, 0, 1, 0, 0, 1, 1],
+[0, 0, 0, 1, 1, 1, 1]
+], ring = Z_2)
+
+
+def test_gen2pchk():
+    H = gen2pchk(G_Hamming)
+    assert not H * G_Hamming.transpose()
+
+def test_Goppa():
+    gf = GF2(4)
+    g = Poly([2, 0, 0, 1], ring = gf)
+    alpha = list(gf)
+
+    goppa = Goppa(gf, g, alpha)
+    for _ in range(10):
+        x = [ randint(0,1) for _ in range(goppa.G.rows) ]
+        y = goppa.encode(x)
+        for _ in range(3):
+            i = randint(0, goppa.G.cols-1)
+            y[i] = 1- y[i]
+    assert goppa.decode(y) == x