kryptools 1.2__tar.gz → 1.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.2
+Version: 1.3.1
 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.1}/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.1}/kryptools/GF2.py

@@ -62,6 +62,9 @@ class GF2:
             return [GF2nPoint(xx, self) for xx in x]
         return GF2nPoint(x, self)
 
+    def __len__(self):
+        return self.order
+
     def __iter__(self):
         for x in range(self.order):
             yield GF2nPoint(x, self)

{kryptools-1.2 → kryptools-1.3.1}/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.1}/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.1"
 __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.1/kryptools/code.py

@@ -0,0 +1,140 @@
+"""
+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."
+    # 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
+
+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()
+
+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 irreducible Goppa code.
+
+    Example:
+
+    >>> gf = GF2(4) # base field GF(2^n)
+    >>> g = Poly([2, 0, 0, 1], ring = gf) # irreducible 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 at most 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"]):
+        if not all(map(lambda x: x in gf, alpha)):
+            raise ValueError(f"{x}: alpha must be a list of elements from the Galois field!")
+        if not g.rabin_test():
+            raise ValueError(f"The polynomial g must be irreducible!")
+        self.gf = gf  # underlying Galois field
+        self.g = g  # polynomial
+        self.alpha = alpha # list of elements from gf
+        # 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 __repr__(self):
+        return f"Binary irreducible Goppa code over GF(2^{self.gf.power}) with polynomial g(x) = {self.g}."
+
+    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 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.alpha:
+                if not sigma(x):
+                    y[int(x)] += 1
+            if self.H * y:
+                raise ValueError("Decoding failed!")
+        x = self.G.transpose().solve(y)
+        x.map(int)
+        return list(x)

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

@@ -191,7 +191,7 @@ class Matrix:
             return False
         if self.rows != other.rows or self.cols != other.cols:
             return False
-        return any(self[i] == other[i] for i in range(self.rows * self.cols))
+        return all(self[i] == other[i] for i in range(self.rows * self.cols))
 
     def __bool__(self):
         return any(bool(self[i]) for i in range(self.rows * self.cols))
@@ -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.1}/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.1}/kryptools/poly.py

@@ -4,7 +4,7 @@ Polynomials
 
 from numbers import Number
 from .primes import is_prime
-from .factor import factorint
+#from .factor import factorint
 
 class Poly:
     """
@@ -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)
@@ -377,11 +387,23 @@ class Poly:
             isfield = True
         if not isfield:
             raise ValueError("The polynomial does not seem to be over a finite field.")
-        n = self.degree()
-        x = self.__class__([0, 1], ring=ring, modulus = self.coeff)  # x
-        for p in factorint(n).keys():
-            g = self.gcd(x**(q**(n//p)) - x)  # gcd with x^{q/n} - x
+        #n = self.degree()
+        #x = self.__class__([0, 1], ring=ring, modulus = self.coeff)  # x
+        #for p in factorint(n).keys():
+        #    g = self.gcd(x**(q**(n//p)) - x)  # gcd with x^{q/n} - x
+        #    if g.degree():
+        #        return False
+        #g = x**(q**n) - x
+        #return not(g)
+        x = Poly([0, 1], ring = ring)  # x
+        xq = Poly(q * [0] + [1], ring = ring, modulus = self.coeff)  # x^q modulo self to keep the polynomials small
+        for k in range(1, self.degree() // 2 + 1):
+            if k == 1:
+                b = xq
+            else:
+                b **= q  # we compute x^{q^k} mod a recursively
+            g = self.gcd(b - x)  # gcd with x^{q^k} - x
             if g.degree():
                 return False
-        g = x**(q**n) - x
-        return not(g)
+        return True
+

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

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

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

{kryptools-1.2 → kryptools-1.3.1}/tests/test_GF2.py

@@ -8,6 +8,11 @@ num_tests = 50
 def test_GF2_ops():
     for n, modulus in [(4, None), (8, None), (8, 0b100011011), (12, None), (128, 0b11100001 << 120)]:
         gf = GF2(n, modulus=modulus)
+        assert gf(1)
+        assert not gf(0)
+        assert gf(1) == gf(1)
+        assert not gf(1) == gf(0)
+        assert not gf(0) == 0
         if gf.power < 17:
             assert len(list(gf)) == gf.order
             assert len(list(gf.star())) == gf.order - 1

{kryptools-1.2 → kryptools-1.3.1}/tests/test_Zmod.py

@@ -42,6 +42,11 @@ def test_Zmod_methods():
     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 not Z_5(0)
+    assert Z_5(1)
+    assert Z_5(2) == Z_5(2)
+    assert Z_5(2) != Z_5(3)
+    assert Z_5(2) != 2
     assert str(Z_5(3)) == "3"
     Z_5.short = False
     assert str(Z_5(6)) == "1 (mod 5)"
@@ -57,6 +62,10 @@ 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 Z_6(1)
+    assert Z_6(2) == Z_6(2)
+    assert Z_6(2) != Z_6(3)
+    assert Z_5(2) != Z_6(2)
     assert str(Z_6(3)) == "3"
 
 

kryptools-1.3.1/tests/test_code.py

@@ -0,0 +1,41 @@
+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)
+
+def Hamming2(h: int) -> Matrix:
+    "Parity check matrix for the binary Hamming code."
+    out = []
+    for i in range(1,2**h):
+        out.append([int(d) for d in str(format(i, "0" + str(h) + "b"))])
+    return Matrix(out, ring = Z_2).transpose()
+
+
+def test_gen2pchk():
+    for h in range(2,6):
+        H = Hamming2(h)
+        G = gen2pchk(H)
+        assert not H * G.transpose()
+
+num_tests = 10
+
+def test_Goppa():
+    for gf, t in [ [GF2(4), 3],  [GF2(6), 4]]:
+        found = False
+        while not found:
+            c = [randint(0,gf.order-1) for _ in range(t)] + [1]
+            g = Poly(c, ring = gf)
+            found = g.rabin_test()
+        alpha = list(gf)
+
+        goppa = Goppa(gf, g, alpha)
+        for _ in range(num_tests):
+            x = [ randint(0,1) for _ in range(goppa.G.rows) ]
+            y = goppa.encode(x)
+            for _ in range(t):
+                i = randint(0, goppa.G.cols-1)
+                y[i] = 1- y[i]
+            assert goppa.decode(y) == x

{kryptools-1.2 → kryptools-1.3.1}/tests/test_la.py

@@ -5,6 +5,13 @@ from kryptools import Matrix, Zmod
 
 def test_Matrix():
     M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]])
+    Z = M.zeros()
+    assert M
+    assert M == M
+    assert not Z
+    Z[0] = 1
+    assert Z
+    assert Z != Z.zeros()
     assert len(M) == 3 * 3
     assert M[0] == 1
     assert M[:] == [1, 2, 3, 4, 5, 6, 7, 8, 12]

kryptools-1.3.1/tests/test_poly.py

@@ -0,0 +1,36 @@
+import pytest
+from kryptools import Poly, Zmod, GF2
+from kryptools import divisors, moebius_mu
+
+
+def test_Poly():
+    p = Poly([2, 0, 2])
+    q = Poly([1, 2, 3, 4])
+    d, m = q.divmod(p)
+    assert d * p + m == q
+
+    Z_5 = Zmod(5)
+    p.map(Z_5)
+    q.map(Z_5)
+    d, m = q.divmod(p)
+    assert d * p + m == q
+
+    gf = GF2(8, modulus=0b100011011)
+    p = Poly([2, 1, 1, 3], modulus=[1, 0, 0, 0, 1], ring=gf)
+    q = p.inv()
+    assert p * q == Poly([1], modulus=[1, 0, 0, 0, 1], ring=gf)
+
+def test_rabin():
+    for gf,t in [ [Zmod(7), 4], [GF2(4), 3]]:
+        order = len(list(gf))
+        count = 0
+        for i in range(order**t):
+            c = []
+            while i:
+                i, m = divmod(i, order)
+                c.append(m)
+            c += [0] * (t- len(c)) + [1]
+            a = Poly(c, ring=gf)
+            if a.rabin_test():
+                count += 1
+        assert count == sum([moebius_mu(d) * order ** (t // d) for d in divisors(t)]) // t

kryptools-1.2/tests/test_poly.py

@@ -1,20 +0,0 @@
-import pytest
-from kryptools import Poly, Zmod, GF2
-
-
-def test_Poly():
-    p = Poly([2, 0, 2])
-    q = Poly([1, 2, 3, 4])
-    d, m = q.divmod(p)
-    assert d * p + m == q
-
-    Z_5 = Zmod(5)
-    p.map(Z_5)
-    q.map(Z_5)
-    d, m = q.divmod(p)
-    assert d * p + m == q
-
-    gf = GF2(8, modulus=0b100011011)
-    p = Poly([2, 1, 1, 3], modulus=[1, 0, 0, 0, 1], ring=gf)
-    q = p.inv()
-    assert p * q == Poly([1], modulus=[1, 0, 0, 0, 1], ring=gf)