kryptools 1.5.3__tar.gz → 1.7__tar.gz

{kryptools-1.5.3 → kryptools-1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.5.3
+Version: 1.7
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -47,13 +47,16 @@ 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.)
+* BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer
 * GF2: a class for Galois fields GF(2^n)
-* Goppa: a class for encoding and decoding Goppa codes
+* BinaryCode: a class for encoding and decoding binary linear codes
+* GoppaCode: a class for encoding and decoding binary 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.3 → kryptools-1.7}/README.md

@@ -29,13 +29,16 @@ 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.)
+* BinaryMatrix: a class for Matrices with binary entries (for much faster row operations)
 * Poly: a class for polynomials (division, modulo, factoring and irreducibility test over finite fields, Lagrange interpolation)
 * Zmod: a class for the ring of integers modulo an integer
 * GF2: a class for Galois fields GF(2^n)
-* Goppa: a class for encoding and decoding Goppa codes
+* BinaryCode: a class for encoding and decoding binary linear codes
+* GoppaCode: a class for encoding and decoding binary 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.3 → kryptools-1.7}/kryptools/GF2.py

@@ -35,7 +35,7 @@ class GF2:
     f6
 
     """
-    def __init__(self, n: int, modulus: int | None = None):
+    def __init__(self, n: int, modulus: int | None = None, cached = False):
         if not isinstance(n, int) or n < 1:
             raise ValueError(f"{n} is not a positive integer.")
         if not modulus:
@@ -55,14 +55,23 @@ class GF2:
         self.byteorder: str = "big"  # big|little
         self.mult_order = self.order - 1
         self.factors = {}  # factoring of the group order
+        self.cached = False  # use precomputed log/exp tables to speed up multiplication
+        self.log = None  # precomputed log table
+        self.exp = None  # precomputed exp table
+        if cached:
+            self.cache()
 
     def __repr__(self):
         return f"GF(2^{self.degree})"
 
     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 +89,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."
@@ -111,10 +120,12 @@ class GF2:
 
     def generator(self) -> int | None:
         "Return a generator of the group GF(2^n)^*."
+        if self.cached:
+            return self.exp[1]
         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 +140,35 @@ 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)))
+
+    def cache(self) -> None:
+        "Create a exp/log table to speed up multiplication."
+        if not self.cached:
+            self.exp = [ 0 ] * self.mult_order
+            self.log = [ 0 ] * self.order
+            g = self.generator()
+            gj = self.one()
+            for j in range(self.mult_order):
+                self.exp[j] = gj
+                self.log[gj.x] = j
+                gj *= g
+            self.cached = True
 
 
 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 +192,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)
+            coeff.reverse()
+        return coeff
 
     def poly(self) -> "Poly":
         "Convert to a polynomial."
@@ -193,7 +221,7 @@ 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)
 
     __sub__ = __add__
 
@@ -206,11 +234,15 @@ class 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:
-            raise NotImplementedError("Cannot add elements from different fields.")
+            raise NotImplementedError("Cannot multiply elements from different fields.")
+        if self.field.cached:
+            if self.x and other.x:
+                return self.field.exp[(self.field.log[self.x] + self.field.log[other.x]) % self.field.mult_order]
+            return self.field.zero()
         z = 0
         y = other.x
         if self.field.bitreversed:
@@ -232,13 +264,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":
@@ -253,16 +285,22 @@ class GF2nPoint:
     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.x == 0:
+            if j < 0:
+                raise ValueError("Division by zero.")
+            if j:
+                return self
+            return self.field.one()
+        j %= self.field.mult_order
+        if self.field.cached:
+            return self.field.exp[j * self.field.log[self.x] % self.field.mult_order]
         if self.field.order == 2:
             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:
@@ -276,13 +314,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."
@@ -308,6 +346,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
@@ -321,7 +370,7 @@ class GF2nPoint:
         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
+GF2_aes = GF2(8, 0b100011011, cached = True)  # 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,

{kryptools-1.5.3 → kryptools-1.7}/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.3 → kryptools-1.7}/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.3"
+__version__ = "1.7"
 __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
@@ -14,12 +14,12 @@ from .intfuncs import iroot, ilog, perfect_square, perfect_power, prime_power
 from .factor import factorint, divisors
 from .dlp import dlog
 from .ec import EC_Weierstrass
-from .la import Matrix, zeros, eye
+from .la import Matrix, zeros, eye, circulant, BinaryMatrix
 from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_round_bnd, babai_plane_cvp, babai_plane_bnd, lagrange_lr, lll, random_unimodular_matrix
-from .poly import Poly, lagrange_interpolation
+from .poly import Poly, PolyBinMult, 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, BinaryCode, GolayCode, HammingCode, ReedMullerCode, GoppaCode, 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