kryptools 1.1__tar.gz → 1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.1
+Version: 1.3
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -39,20 +39,20 @@ 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
 * DESCipher: individual DES operations
 
-* SHA1
-* Keccak individual sponge operations
-* SHA3
-* SHAKE
+* SHA1: custom initial state, padding function
+* Keccak: individual sponge operations, SHA3, SHAKE
 
 Documentation can be found in the jupyter notebook
 (mostly done, but might not contain everything: use the force, read the source).

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

@@ -21,20 +21,20 @@ 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
 * DESCipher: individual DES operations
 
-* SHA1
-* Keccak individual sponge operations
-* SHA3
-* SHAKE
+* SHA1: custom initial state, padding function
+* Keccak: individual sponge operations, SHA3, SHAKE
 
 Documentation can be found in the jupyter notebook
 (mostly done, but might not contain everything: use the force, read the source).

kryptools-1.3/kryptools/GF2.py

@@ -0,0 +1,351 @@
+"""
+Galois field GF(2^n).
+"""
+
+from math import gcd
+from .poly import Poly
+from .Zmod import Zmod
+from .factor import factorint
+from .conway_polynomials import conway_polynomials2
+
+
+class GF2:
+    """
+    Create a Galois field GF(2^n).
+
+    Elements of a Galois filed are specified by integers from 0 to 2**n-1, which are
+    identified with polynomials whose coefficients are the binary digits of the integer.
+    Multiplication is polynomial multiplication modulo a given irreducible polynomial.
+    If the polynomial has the n'th bit set, the lowest bit corresponds to the constant coefficient
+    (like in AES). Otherwise, the bit order is reversed (like for Ghash). The default modulus is
+    choosen from a list of Conway polynomials.
+
+    Example:
+
+    To define the Galois field GF(2^8) use
+    >>> gf=GF2(8)
+
+    To declare 3 as an element of our Galois field use (elements are displayed as hex numbers)
+    >>> gf(3)
+    03
+
+    The usual arithmetic operations are supported.
+    >>> gf(2) * gf(123)
+    f6
+
+    """
+    def __init__(self, n: int, modulus: int | None = None):
+        if not isinstance(n, int) or n < 1:
+            raise ValueError(f"{n} is not a positive integer.")
+        if not modulus:
+            if n in conway_polynomials2:
+                modulus = conway_polynomials2[n]
+            else:
+                raise ValueError("Unknown power. Please specify a modulus.")
+        self.modulus = modulus  # integer whose biniary digits are the coefficients of the irreducible modulus polynomial
+        if modulus & 2**n == 2**n:
+            self.bitreversed = False
+        else:
+            self.bitreversed = True
+        self.power = n  # n
+        self.order = 2**n  # 2**n
+        self.print_hex: bool = True
+        self.byteorder: str = "big"  # big|little
+        self.mult_order = self.order -1
+        self.factors = {}  # factoring of the group order
+
+    def __repr__(self):
+        return f"GF(2^{self.power})"
+
+    def __call__(self, x: int | list | tuple):
+        if isinstance(x, list|tuple):
+            return [GF2nPoint(xx, self) for xx in x]
+        return GF2nPoint(x, self)
+
+    def __iter__(self):
+        for x in range(self.order):
+            yield GF2nPoint(x, self)
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.order == other.order and self.modulus == other.modulus
+        return False
+
+    def __contains__(self, other: "ZmodPoint") -> bool:
+        return isinstance(other, GF2nPoint) and self == other.field
+
+    def _factors(self) -> dict:
+        "Return the factroization order of the group order of GF(2^n)^*."
+        if not self.factors:
+            self.factors = factorint(self.mult_order)
+        return self.factors
+
+    def one(self) -> bool:
+        "Return one."
+        if self.bitreversed:
+            return self(self.order - 1)
+        return self(1)
+
+    def is_cyclic(self) -> bool:
+        "GF(2^n)^* is cyclic."
+        return True
+
+    def is_field(self) -> bool:
+        "GF(2^n) is a field."
+        return True
+
+    def generator(self) -> int | None:
+        "Return a generator of the group GF(2^n)^*."
+        for a in range(2, self.order):
+            a = self(a)
+            if a.is_generator():
+                return a
+
+    def generators(self) -> list | None:
+        "Return a generator for all generators of the group GF(2^n)^*."
+        a = self.generator()
+        if a is not None:
+            for j in range(1, self.mult_order):
+                if gcd(j, self.mult_order) == 1:
+                    yield a**j
+
+    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)
+
+
+class GF2nPoint:
+    "Represents a point in the Galois field GF(2^n)."
+
+    def __init__(self, x: int, field: "GF2n"):
+        if isinstance(x, bytes | bytearray):
+            x = int.from_bytes(x, byteorder=field.byteorder)
+        self.x = int(x) % field.order
+        self.field = field
+
+    def __repr__(self):
+        if self.field.print_hex:
+            return format(self.x, "0"+str(self.field.power // 4)+"x")
+        return self.x
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__) or self.field != other.field:
+            return False
+        return self.x == other.x
+
+    def __bool__(self):
+        return bool(self.x)
+
+    def __int__(self):
+        return self.x
+
+    def __bytes__(self):
+        return self.x.to_bytes(self.field.power // 8, byteorder=self.field.byteorder)
+
+    def bits(self) -> list:
+        "Convert to a list of bits."
+        if self.field.bitreversed:
+            coeff = [int(d) for d in str(
+                format(self.x, "0" + str(self.field.power) + "b"))]
+        else:
+            coeff = reversed([int(d) for d in str(
+                format(self.x, "0" + str(self.field.power) + "b"))])
+        return list(coeff)
+
+    def poly(self) -> "Poly":
+        "Convert to a polynomial."
+        Z_2 = Zmod(2)
+        if self.field.bitreversed:
+            coeff = [Z_2(int(d)) for d in str(
+                format(self.x, "0" + str(self.field.power) + "b"))]
+            coeff_modulus = [Z_2(int(d)) for d in str(
+                format((self.field.modulus << 1) + 1, "0" + str(self.field.power) + "b"))]
+        else:
+            coeff = reversed([Z_2(int(d)) for d in str(
+                format(self.x, "0" + str(self.field.power) + "b"))])
+            coeff_modulus = reversed([Z_2(int(d)) for d in str(
+                format(self.field.modulus, "0" + str(self.field.power) + "b"))])
+        return Poly(list(coeff), modulus=list(coeff_modulus))
+
+    def __hash__(self):
+        return hash(self.x)
+
+    def __add__(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)
+
+    def __neg__(self) -> "GF2nPoint":
+        return self
+
+    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)
+
+    def __mul__(self, other: "GF2nPoint") -> "GF2nPoint":
+        if isinstance(other, int):
+            if other % 2:
+                return self
+            return self.field(0)
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        if self.field != other.field:
+            raise NotImplementedError("Cannot add elements from different fields.")
+        z = 0
+        y = other.x
+        if self.field.bitreversed:
+            for d in bin(self.x)[2:].zfill(self.field.power):
+                if int(d):
+                    z ^= y
+                if y % 2:
+                    y >>= 1
+                    y ^= self.field.modulus
+                else:
+                    y >>= 1
+        else:
+            bitmap1 = self.field.order
+            bitmap2 = 1
+            for _ in range(self.field.power):
+                if self.x & bitmap2:
+                    z ^= y
+                bitmap2 <<= 1
+                y <<= 1
+                if y & bitmap1:
+                    y ^= self.field.modulus
+        return self.field(z)
+
+    def __rmul__(self, scalar: int) -> "GF2nPoint":
+        if isinstance(scalar, int):
+            if scalar % 2:
+                return self
+            return self.field(0)
+        return NotImplemented
+
+    def __truediv__(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.")
+        if not other.x:
+            raise ValueError("Division by zero.")
+        return self * other**(self.field.order - 2)
+
+    def __pow__(self, j: int) -> "GF2nPoint":
+        if not isinstance(j, int):
+            return NotImplemented
+        if not (self.x) and j < 0:
+            raise ValueError("Division by zero.")
+        if self.field.bitreversed:
+            res = self.field(self.field.order >> 1)
+        else:
+            res = self.field(1)
+        x = self.field(self.x)
+        j %= self.field.order - 1
+        while j > 0:
+            # If j is odd, multiply with x
+            if j & 1:
+                res *= x
+            # Now square
+            j = j >> 1  # j= j/2
+            x *= x
+        return res
+
+    def __lshift__(self, i: int) -> "GF2nPoint":
+        "Cyclic rotation to the left."
+        x = self.x << i
+        x = (x % self.field.order) + (x // self.field.order)
+        return self.field(x)
+
+    def __rshift__(self, i: int) -> "GF2nPoint":
+        "Cyclic rotation to the right."
+        x = self.x >> i
+        x += (self.field.order >> i) * (self.x % 2**i)
+        return self.field(x)
+
+    def sqrt(self) -> "GF2nPoint":
+        "Compute the square root."
+        return self**(self.field.order//2)
+
+    def order(self) -> int:
+        "Compute the order of the point in the group GF(2^n)^*."
+        self.field._factors()
+        order = self.field.mult_order  # our current guess
+        one = self.field.one()
+        for p, k in self.field.factors.items():
+            for _ in range(k):
+                order_try = order // p
+                if self ** order_try == one:
+                    order = order_try
+                else:
+                    break
+        return order
+
+    def is_generator(self):
+        "Test if the point is a generator of the group GF(2^n)^*."
+        return self.field.mult_order == self.order()
+
+    def sbox(self, inv: bool = False) -> "GF2nPoint":
+        "Apply the AES sbox."
+        if self.field.power == 8 and self.field.modulus == 0b100011011: # AES
+            if inv:
+                return aes_sbox_inv[self.x]
+            return aes_sbox[self.x]
+        elif self.field.power == 4 and self.field.modulus == 0b10011: # MiniAES
+            if inv:
+                return miniaes_sbox_inv[self.x]
+            return miniaes_sbox[self.x]
+        raise ValueError("sbox is only availaible for AES/MiniAES field.")
+
+# sbox for AES
+GF2_aes = GF2(8, 0b100011011)  # x^8 + x^4 + x^3 + x + 1 = AES
+
+aes_sbox = [99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118,
+ 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
+ 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21,
+ 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9,
+ 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83,
+ 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208,
+ 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81,
+ 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205,
+ 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96,
+ 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224,
+ 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231,
+ 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186,
+ 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112,
+ 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225,
+ 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140,
+ 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22]
+
+# inverse sbox for AES
+aes_sbox_inv = [ 0 for i in range(256) ]
+for i in range(256):
+    aes_sbox_inv[aes_sbox[i]] = i
+aes_sbox = list(map(GF2_aes, aes_sbox))
+aes_sbox_inv = list(map(GF2_aes, aes_sbox_inv))
+
+    
+# sbox for Mini-AES
+GF2_miniaes = GF2(4, 0b10011)  # x^4 + x + 1 = Mini-AES
+
+miniaes_sbox = [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7]
+
+# inverse sbox for MiniAES
+miniaes_sbox_inv = [ 0 for i in range(16) ]
+for i in range(16):
+    miniaes_sbox_inv[miniaes_sbox[i]] = i
+
+miniaes_sbox = list(map(GF2_miniaes, miniaes_sbox))
+miniaes_sbox_inv = list(map(GF2_miniaes, miniaes_sbox_inv))
+
+#Ghash
+
+GF2_ghash = GF2(128, 0b11100001 << 120)  # 1 + x + x^2 + x^7 (+ x^128) = Ghash

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

@@ -4,6 +4,7 @@ Ring of intergers modulo `n`.
 
 from math import gcd
 from .factor import factorint
+from .primes import is_prime
 from .intfuncs import prime_power
 
 
@@ -16,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
 
@@ -33,11 +34,12 @@ class Zmod:
         self.group_order = 0
         self.factors = {}  # factoring of the group order
 
+    def __repr__(self):
+        return f"Z_{self.n})"
+
     def __call__(self, x: int | list | tuple):
-        if isinstance(x, list):
+        if isinstance(x, list|tuple):
             return [ZmodPoint(xx, self) for xx in x]
-        if isinstance(x, tuple):
-            return (ZmodPoint(xx, self) for xx in x)
         return ZmodPoint(x, self)
 
     def __iter__(self):
@@ -53,7 +55,7 @@ class Zmod:
         return isinstance(other, ZmodPoint) and self.n == other.ring.n
 
     def order(self) -> int:
-        """Compute the order of the group Z_n^*."""
+        "Compute the order of the group Z_n^*."
         if self.group_order:
             return self.group_order
         # We compute euler_phi(n) and its factorization in one pass
@@ -76,7 +78,7 @@ class Zmod:
         return self.group_order
 
     def is_cyclic(self) -> bool:
-        """Test if the group Z_n^* is cyclic."""
+        "Test if the group Z_n^* is cyclic."
         n = self.n
         if n < 8:
             return True
@@ -88,8 +90,12 @@ class Zmod:
             return True
         return False
 
+    def is_field(self) -> bool:
+        "Test if Z_n is a field."
+        return is_prime(self.n)
+
     def generator(self) -> int | None:
-        """Return a generator of the group Z_n^*."""
+        "Return a generator of the group Z_n^*."
         if not self.is_cyclic():
             return None
         for a in range(2, self.n):
@@ -100,7 +106,7 @@ class Zmod:
                 return a
 
     def generators(self) -> list | None:
-        """Return a generator for all generators of the group Z_n^*."""
+        "Return a generator for all generators of the group Z_n^*."
         a = self.generator()
         if a is not None:
             self.order()
@@ -109,7 +115,7 @@ class Zmod:
                     yield a**j
 
     def star(self) -> list:
-        """Return a generator for all elements of the group Z_n^*."""
+        "Return a generator for all elements of the group Z_n^*."
         yield self(1)
         for a in range(2, self.n):
             if gcd(a, self.n) == 1:
@@ -204,13 +210,17 @@ 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
         return (self.x + tmp) % self.ring.n - tmp
 
     def order(self) -> int:
-        """Compute the order of the point in the group Z_n^*."""
+        "Compute the order of the point in the group Z_n^*."
         if self.x == 0 or gcd(self.x, self.ring.n) != 1:
             raise ValueError(f"{self.x} and {self.ring.n} are not coprime!")
         order = self.ring.order()  # use euler_phi(n) as our current guess
@@ -224,5 +234,5 @@ class ZmodPoint:
         return order
 
     def is_generator(self):
-        """Test if the point is a generator of the group Z_n^*."""
+        "Test if the point is a generator of the group Z_n^*."
         return self.ring.order() == self.order()

{kryptools-1.1 → 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.1"
+__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.1 → kryptools-1.3}/kryptools/aes.py

@@ -143,15 +143,19 @@ class AESKeySchedule:
         self.round += 1
         #RotWord
         tmp = list(self.key[:,3])
-        if self.showtmp: print("Start    :" + str(tmp))
+        if self.showtmp:
+        	print("Start    :" + str(tmp))
         tmp = rotate_left(tmp, 1)
-        if self.showtmp: print("RotWord  :" + str(tmp))
+        if self.showtmp:
+        	print("RotWord  :" + str(tmp))
         #SubWord
         tmp = list(map(lambda x: x.sbox(), tmp))
-        if self.showtmp: print("SubWord  :" + str(tmp))
+        if self.showtmp:
+        	print("SubWord  :" + str(tmp))
         #AddRound constant
         tmp[0] += GF2_aes(2)**(self.round - 1)
-        if self.showtmp: print("AddConst :" + str(tmp))
+        if self.showtmp:
+        	print("AddConst :" + str(tmp))
         tmp = Matrix(tmp)
         self.key[:,0] += tmp
         self.key[:,1] += self.key[:,0]

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.1 → kryptools-1.3}/kryptools/des.py

@@ -168,10 +168,10 @@ class FeistelCipher:
     def f_box(self, a: list[int], key: list[int], showtmp:bool = False) -> list[int]:
         "Nonlinear f-box"
         if showtmp:
-            def printtmp(title:str, a: list) -> None:
+            def printtmp(title: str, a: list) -> None:
                 print(f'{title}: {"".join(map(str,a))}')
         else:
-            def printtmp(title:str, a: list) -> None:
+            def printtmp(title: str, a: list) -> None:
                 pass
         a = permute(a, self.__class__.E_box)  # expansion box
         printtmp("EBox", a)