kryptools 1.3.4__tar.gz → 1.4__tar.gz

{kryptools-1.3.4 → kryptools-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.3.4
+Version: 1.4
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -42,10 +42,12 @@ The tools contained are:
 * 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)
+* Poly: a class for polynomials (division, modulo, irreducibility test, 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
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.3.4 → kryptools-1.4}/README.md

@@ -24,10 +24,12 @@ The tools contained are:
 * 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)
+* Poly: a class for polynomials (division, modulo, irreducibility test, 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
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.3.4 → kryptools-1.4}/kryptools/GF2.py

@@ -57,8 +57,8 @@ class GF2:
     def __repr__(self):
         return f"GF(2^{self.power})"
 
-    def __call__(self, x: int | list | tuple):
-        if isinstance(x, list|tuple):
+    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)
 

{kryptools-1.3.4 → kryptools-1.4}/kryptools/Zmod.py

@@ -5,6 +5,7 @@ Ring of intergers modulo `n`.
 from math import gcd
 from .factor import factorint
 from .primes import is_prime
+from .nt import sqrt_mod, crt
 from .intfuncs import prime_power
 
 
@@ -30,15 +31,16 @@ class Zmod:
         if not isinstance(n, int) or n < 1:
             raise ValueError(f"{n} is not a positive integer.")
         self.n = n
+        self.n_factors = {} # factoring of n
         self.short = short
         self.group_order = 0
-        self.factors = {}  # factoring of the group order
+        self.factors = {}  # factoring of the multiplicative group order
 
     def __repr__(self):
-        return f"Z_{self.n})"
+        return f"Z_{self.n}"
 
-    def __call__(self, x: int | list | tuple):
-        if isinstance(x, list|tuple):
+    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)
 
@@ -59,7 +61,9 @@ class Zmod:
         if self.group_order:
             return self.group_order
         # We compute euler_phi(n) and its factorization in one pass
-        for p, k in factorint(self.n).items():  # first factorize n
+        if not self.n_factors:
+            self.n_factors = factorint(self.n)
+        for p, k in self.n_factors.items():  # first factorize n
             # factor p-1 and add the factors
             for pm, km in factorint(p - 1).items():
                 if pm in self.factors:
@@ -243,6 +247,56 @@ class ZmodPoint:
                     break
         return order
 
+    def sqrt(self) -> "ZmodPoint":
+        if not self.ring.n_factors:
+            self.ring.n_factors = factorint(self.ring.n)
+        a = int(self)
+        if a in (0, 1):
+            return self.ring(a)
+        roots = []
+        powers = []
+        for p, k in self.ring.n_factors.items():
+            q = p**(k-1)
+            pk = q * p
+            ak = a % pk
+            powers.append(pk)
+            if ak in (0, 1):
+                roots.append(ak)
+                continue
+            # write ak as p^j * invertible
+            j = 0
+            while ak % p == 0:
+                j += 1
+                ak //= p
+            if j % 2:
+                raise ValueError("No quadratic residue!")
+            if ak == 1:
+                roots.append(p**(j//2))
+                continue
+            if p == 2:
+                if ak % 8 != 1:
+                    raise ValueError("No quadratic residue!")
+                m = 4 # start at 2^2
+                x = ak % m # this is the root mod m
+                for i in range(3, k + 1):
+                    # test all 4 poosible roots
+                    if (x**2 - ak) % (m * 2):
+                        x = m - x
+                        if (x**2 - ak) % (m*2):
+                            x = (x * (m//2-1)) % m
+                            if (x**2 - ak) % (m * 2):
+                                x = m - x
+                    m *= 2
+            else:
+                # odd prime: Cipolla's formula
+                x = sqrt_mod(ak, p)
+                if x is None:
+                    raise ValueError("No quadratic residue!")
+                if k > 1:
+                    x = pow(x, q, pk) * pow(ak,((p-2)*q+1)//2, pk) % pk
+            roots.append((p**(j//2) * x) % pk)
+        return self.ring(crt(roots, powers))
+
     def is_generator(self):
         "Test if the point is a generator of the group Z_n^*."
         return self.ring.order() == self.order()

{kryptools-1.3.4 → kryptools-1.4}/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.3.4"
+__version__ = "1.4"
 __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
@@ -16,10 +16,10 @@ from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye
 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
+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
+from .code import left_standard_form, gen2pchk, hamming_dist, Goppa, CyclicCode, ReedSolomonCode
 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.4/kryptools/code.py

@@ -0,0 +1,326 @@
+"""
+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
+
+
+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^4)
+    >>> 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("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)
+
+class CyclicCode():
+    """
+    Cyclic code.
+
+    Example:
+
+    >>> n = 4 # length of the code
+    >>> g = Poly([1, 1], ring = Zmod(2)) # generating Polynomial for the code
+    >>> cc = CyclicCode(n, g)
+    
+    To encode a list of letters (the length must be equal to the dimension k of the code):
+    >>> cc.encode([0,1,0], ring = Zmod(2))
+    [0, 1, 1, 0]
+
+    Decoding is only implemnted for code words:
+    >>> cc.decode([0, 1, 1, 0], ring = Zmod(2))
+    [0, 1, 0]
+    
+    """
+
+    def __init__(self, n:int, g: Poly):
+        if n < 2:
+            raise ValueError(f"Code lenght {n} must be at least 2!")
+        zero = 0 * g[0]
+        try:
+            order = zero.ring.n  # Zmod
+        except:
+            try:
+                order = zero.field.order  # GF2
+            except:
+                try:
+                    order = type(zero).order  # galois
+                except:
+                    raise ValueError("Unknown base filed!")
+        self.order = order  # order of the base field
+        one = zero**0
+        modulus = Poly([-one] + [zero] * (n-1) + [one])
+        self.modulus = modulus
+        if modulus % g:
+            raise ValueError(f"The polynomial g must be a factor of x^{n} - 1!")
+        self.n = n  # lenght
+        self.k = n - g.degree()  # dimension
+        self.g = g  # generating polynomial
+        self.h = Poly(modulus) // g
+
+    def __repr__(self):
+        return f"Cyclic [{self.n}, {self.k}] code over GF({self.order}) with generator polynomial g(x) = {self.g}."
+    
+    def encode(self, x: list|Poly, gf = None, systematic_form = False):
+        "Encode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        if isinstance(x, list | tuple):
+            as_list = True
+            x = Poly(x, ring = gf)
+        if x.degree() >= self.k:
+            raise ValueError(f"Degree can be at most {self.k-1}.")
+        if systematic_form:
+            x.coeff = [zero] * self.g.degree() + x.coeff
+            y = x - (x % self.g)
+        else:
+            y = self.g * x
+        if as_list:
+            return y.coeff + [zero] * (self.n - len(y.coeff))
+        return y
+
+    def decode(self, y: list|Poly, gf = None, systematic_form = False):
+        "Decode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        if isinstance(y, list | tuple):
+            as_list = True
+            y = Poly(y, ring = gf)
+        if y.degree() >= self.n:
+            raise ValueError(f"Degree can be at most {self.n-1}.")
+        x, r = y.divmod(self.g)
+        if r:
+            raise NotImplementedError(f"Word is no code word! Cannot decode.")
+        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 generator_matrix(self):
+        "Return the generator matrix of the code."
+        zero = 0 * self.g[0]
+        return Matrix([[zero] * j + self.g.coeff + [zero] * (self.k - j - 1 ) for j in range(self.k)])
+
+    def check_matrix(self):
+        "Return the parity check matrix of the code."
+        zero = 0 * self.g[0]
+        tmp = list(reversed(self.h.coeff))
+        return Matrix([[zero] * j + tmp + [zero] * (self.n - self.k - j - 1 ) for j in range(self.n-self.k)])
+
+class ReedSolomonCode(CyclicCode):
+    """
+    Reed-Solomon code.
+
+    Example:
+
+    >>> gf = Zmod(13) # Galois field
+    >>> k = 3 # dimension of the code
+    >>> 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]
+
+    Decoding is only implemnted for code words:
+    >>> cc.decode([0, 1, 1, 0], ring = Zmod(2))
+    [0, 1, 0]
+    
+    """
+    def __init__(self, k:int, gf, alpha = None):
+        zero = gf(0)
+        one = zero**0
+        self. gf = gf
+        try:
+            n = gf.order()
+        except:
+            n = gf.order - 1
+        self.order = n + 1  # order of the base field
+        self.n = n  # lenght
+        self.k = k  # dimension
+        self.d = n - k - 1  # minimal distance
+        self.modulus = Poly([-one] + [zero] * (n-1) + [one])
+        if alpha is None:
+            try:
+                alpha = gf.generator()  # Zmod|GF2
+            except:
+                alpha = gf.primitive_element  # galois
+        self.alpha = alpha
+        self.g = prod([Poly([-alpha**j, one]) for j in range(1,n-k+1)], start = one) # generating polynomial
+        self.h = Poly(self.modulus) // self.g  # check polynomial
+        assert k == n - self.g.degree()
+        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})."
+
+    def encode(self, x: list|Poly):
+        "Encode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        if isinstance(x, list | tuple):
+            as_list = True
+            x = Poly(x, ring = self.gf)
+        if x.degree() >= self.k:
+            raise ValueError(f"Degree can be at most {self.k-1}.")
+        y = [ x(self.alpha**j) for j in range(self.n) ]
+        if as_list:
+            return y + [zero] * (self.n - len(y))
+        return Poly(y)
+
+    def decode(self, y: list|Poly):
+        "Decode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        one = zero**0
+        if isinstance(y, list | tuple):
+            as_list = True
+            y = Poly(y, ring = self.gf)
+        if y.degree() >= self.n:
+            raise ValueError(f"Degree can be at most {self.n-1}.")
+        x = Poly([ -y(self.alpha**(-j)) for j in range(self.n) ])
+        if x.degree() >= self.k: # No codewort
+            t = (self.n - self.k) // 2
+            A = Matrix([[ x[j - l % self.n] for l in range(1, t+1) ] for j in range(self.k+t, self.k+2*t) ])
+            b = [ -x[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)
+        if as_list:
+            return x.coeff + [zero] * (self.k - len(x.coeff))
+        return x

{kryptools-1.3.4 → kryptools-1.4}/kryptools/dlp_qs.py

@@ -97,7 +97,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                 break
             trys += 1
         else:
-            raise Exception(f"Sorry, Quadratic Sieve failed failed to find a new relation after {trys} trys.")
+            raise Exception(f"Sorry, Quadratic Sieve failed to find a new relation after {trys} trys.")
         if verbose > 2:
             if include_b:
                 print(f"rel found: b*a^{x}=", b * pow(a, x, n) % n, relation)

{kryptools-1.3.4 → kryptools-1.4}/kryptools/factor.py

@@ -6,6 +6,7 @@ Factorization of integers:
 
 from math import isqrt, gcd, prod, floor, log10
 from .primes import sieve_eratosthenes, is_prime
+from .intfuncs import perfect_power
 from .factor_pm1 import _pm1_parameters, factor_pm1
 from .factor_ecm import _ecm_parameters, factor_ecm
 #from .factor_qs import factor_qs
@@ -86,10 +87,16 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
         return prime_factors
     if verbose:
         print("Trial division found:", list(prime_factors))
+    # check if the remainder is a perfect power
+    res = perfect_power(n)
+    if res:
+        n, k = res
+    else:
+        n, k = n, 1
     if is_prime(n, trialdivision=False):
-        prime_factors[n] = 1
+        prime_factors[n] = k
         return prime_factors
-    remaining_factors = {n: 1}
+    remaining_factors = {n: k}
 
     # https://gitlab.inria.fr/zimmerma/ecm/
     ECM_PARAMETERS = [

{kryptools-1.3.4 → kryptools-1.4}/kryptools/nt.py

@@ -111,7 +111,7 @@ def jacobi_symbol(a: int, n: int) -> int:
     return 0
 
 
-def sqrt_mod(a: int, p: int) -> int:
+def sqrt_mod(a: int, p: int) -> int|None:
     """Compute a square root of `a` modulo `p` unsing Cipolla's algorithm."""
     a %= p
     if a in (0, 1):
@@ -120,6 +120,12 @@ def sqrt_mod(a: int, p: int) -> int:
         return None
     if p % 4 == 3:  # easy case
         return pow(a, (p + 1) // 4, p)
+    if p % 8 == 5:
+        x = pow(a, (p + 3)//8, p)
+        c = pow(x, 2, p)
+        if c % p == a:
+            return x
+        return (x * pow(2, (p - 1)//4, p)) % p
     # Cipolla's algorithm
     for c in range(1, p):  # find a field extension
         tmp = (c * c - a) % p

{kryptools-1.3.4 → kryptools-1.4}/kryptools/poly.py

@@ -2,6 +2,7 @@
 Polynomials
 """
 
+from math import prod
 from numbers import Number
 from .primes import is_prime
 #from .factor import factorint
@@ -407,3 +408,22 @@ class Poly:
                 return False
         return True
 
+
+def lagrange_interpolation(x_coordinates:list, y_coordinates:list) -> "Poly":
+    "Compute the Lagrange interpolation polynomial from a given list of x and y values."
+    l = len(x_coordinates)
+    if l == 0 or l != len(y_coordinates):
+        raise ValueError('List of x and y values must be nonempty of equal length.')
+    if l != len(set(x_coordinates)):
+        raise ValueError('List of x values must not contain duplicate values.')
+    # Guess zero and one
+    zero = 0 * x_coordinates[0]
+    one = zero**0
+
+    poly = Poly([zero])
+    L_all = prod([Poly([-x, one]) for x in x_coordinates], start = one)
+
+    for x, y in zip(x_coordinates, y_coordinates):
+        L = L_all // Poly([-x, one])
+        poly += (y / prod([x -xx for xx in x_coordinates if xx != x], start = one)) * L
+    return poly

{kryptools-1.3.4 → kryptools-1.4}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.3.4
+Version: 1.4
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -42,10 +42,12 @@ The tools contained are:
 * 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)
+* Poly: a class for polynomials (division, modulo, irreducibility test, 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
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.3.4 → kryptools-1.4}/pyproject.toml

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

{kryptools-1.3.4 → kryptools-1.4}/tests/test_Zmod.py

@@ -87,6 +87,26 @@ def test_ZmodP_order():
                 xx *=x
             assert o == x.order()
 
+def test_ZmodP_sqrt():
+    for n in range(1,100):
+        print(n)
+        ring = Zmod(n)
+        one = ring(1)
+        roots = {} # compute a dict of all roots
+        for x in ring:
+            y = x**2
+            if y in roots:
+               roots[y].append(x)
+            else:
+                roots[y] = [ x ]
+        for x in ring:
+            if x not in roots:
+                with pytest.raises(ValueError):
+                    x.sqrt()
+            else:
+                y = x.sqrt()
+                assert y**2 == x
+
 def test_Zmod_field():
     for n in range(1, 100):
         assert Zmod(n).is_field() == is_prime(n)

{kryptools-1.3.4 → kryptools-1.4}/tests/test_code.py

@@ -1,7 +1,7 @@
 import pytest
 from random import randint, seed
 from kryptools import Zmod, GF2, Poly, Matrix
-from kryptools import gen2pchk, Goppa
+from kryptools import gen2pchk, Goppa, CyclicCode, ReedSolomonCode
 
 seed(0)
 Z_2 = Zmod(2)
@@ -39,3 +39,24 @@ def test_Goppa():
                 i = randint(0, goppa.G.cols-1)
                 y[i] = 1- y[i]
             assert goppa.decode(y) == x
+
+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)
+        for _ in range(num_tests):
+            x = [ gf(randint(0, cc.order-1)) for _ in range(cc.k) ]
+            y = cc.encode(x)
+            assert cc.decode(y) == x
+
+def test_ReedSolomon():
+    for gf, k in [ [Zmod(13), 3],  [GF2(6), 4]]:
+        rsc = ReedSolomonCode(k, gf)
+        t = (rsc.n - rsc.k) // 2
+        for _ in range(num_tests):
+            x = [ gf(randint(0, rsc.n)) for _ in range(rsc.k) ]
+            y = rsc.encode(x)
+            for _ in range(t):
+                i = randint(0, rsc.n-1)
+                y[i] += gf(1)
+            assert rsc.decode(y) == x

{kryptools-1.3.4 → kryptools-1.4}/tests/test_poly.py

@@ -1,5 +1,6 @@
 import pytest
-from kryptools import Poly, Zmod, GF2
+from random import sample, choices
+from kryptools import Poly, Zmod, GF2, lagrange_interpolation
 from kryptools import divisors, moebius_mu
 
 
@@ -33,4 +34,16 @@ def test_rabin():
             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
+        assert count == sum([moebius_mu(d) * order ** (t // d) for d in divisors(t)]) // t
+
+def test_lagrange():
+    for gf in [ Zmod(2), Zmod(3), Zmod(5), Zmod(7), Zmod(23), GF2(4), GF2(6)]:
+        all = list(gf)
+        l = len(all)//2
+        for _ in range(10):
+            x_coordinates = sample(all, l)
+            y_coordinates = choices(all, k = l)
+            p = lagrange_interpolation(x_coordinates, y_coordinates)
+            assert p.degree() <= len(x_coordinates) - 1
+            for x, y in zip(x_coordinates, y_coordinates):
+                assert p(x) == y

kryptools-1.3.4/kryptools/code.py

@@ -1,140 +0,0 @@
-"""
-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)