kryptools 1.4__tar.gz → 1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.4
+Version: 1.5
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -42,7 +42,7 @@ 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, irreducibility test, Lagrange interpolation)
+* 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

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

@@ -24,7 +24,7 @@ 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, irreducibility test, Lagrange interpolation)
+* 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

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

@@ -3,6 +3,7 @@ Galois field GF(2^n).
 """
 
 from math import gcd
+from random import randint
 from .poly import Poly
 from .Zmod import Zmod
 from .factor import factorint
@@ -41,13 +42,14 @@ class GF2:
             if n in conway_polynomials2:
                 modulus = conway_polynomials2[n]
             else:
-                raise ValueError("Unknown power. Please specify a modulus.")
+                raise ValueError("Unknown degree. 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.degree = n  # n
+        self.characteristic = 2
         self.order = 2**n  # 2**n
         self.print_hex: bool = True
         self.byteorder: str = "big"  # big|little
@@ -55,7 +57,7 @@ class GF2:
         self.factors = {}  # factoring of the group order
 
     def __repr__(self):
-        return f"GF(2^{self.power})"
+        return f"GF(2^{self.degree})"
 
     def __call__(self, x: int | list | tuple | range | map):
         if isinstance(x, list|tuple|range|map):
@@ -74,7 +76,7 @@ class GF2:
             return self.order == other.order and self.modulus == other.modulus
         return False
 
-    def __contains__(self, other: "ZmodPoint") -> bool:
+    def __contains__(self, other: "GF2nPoint") -> bool:
         return isinstance(other, GF2nPoint) and self == other.field
 
     def _factors(self) -> dict:
@@ -83,12 +85,22 @@ class GF2:
             self.factors = factorint(self.mult_order)
         return self.factors
 
+    def zero(self) -> bool:
+        "Return zero."
+        return self(0)
+
     def one(self) -> bool:
         "Return one."
         if self.bitreversed:
             return self(self.order - 1)
         return self(1)
 
+    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))
+
     def is_cyclic(self) -> bool:
         "GF(2^n)^* is cyclic."
         return True
@@ -99,7 +111,7 @@ class GF2:
 
     def generator(self) -> int | None:
         "Return a generator of the group GF(2^n)^*."
-        if self.power == 1:
+        if self.degree == 1:
             return self(1)
         for a in range(2, self.order):
             a = self(a)
@@ -131,7 +143,7 @@ class GF2nPoint:
 
     def __repr__(self):
         if self.field.print_hex:
-            return format(self.x, "0"+str(self.field.power // 4)+"x")
+            return format(self.x, "0"+str(self.field.degree // 4)+"x")
         return self.x
 
     def __eq__(self, other):
@@ -146,16 +158,16 @@ class GF2nPoint:
         return self.x
 
     def __bytes__(self):
-        return self.x.to_bytes(self.field.power // 8, byteorder=self.field.byteorder)
+        return self.x.to_bytes(self.field.degree // 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"))]
+                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.power) + "b"))])
+                format(self.x, "0" + str(self.field.degree) + "b"))])
         return list(coeff)
 
     def poly(self) -> "Poly":
@@ -163,14 +175,14 @@ class GF2nPoint:
         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"))]
+                format(self.x, "0" + str(self.field.degree) + "b"))]
             coeff_modulus = [Z_2(int(d)) for d in str(
-                format((self.field.modulus << 1) + 1, "0" + str(self.field.power) + "b"))]
+                format((self.field.modulus << 1) + 1, "0" + str(self.field.degree) + "b"))]
         else:
             coeff = reversed([Z_2(int(d)) for d in str(
-                format(self.x, "0" + str(self.field.power) + "b"))])
+                format(self.x, "0" + str(self.field.degree) + "b"))])
             coeff_modulus = reversed([Z_2(int(d)) for d in str(
-                format(self.field.modulus, "0" + str(self.field.power) + "b"))])
+                format(self.field.modulus, "0" + str(self.field.degree) + "b"))])
         return Poly(list(coeff), modulus=list(coeff_modulus))
 
     def __hash__(self):
@@ -208,7 +220,7 @@ class GF2nPoint:
         z = 0
         y = other.x
         if self.field.bitreversed:
-            for d in bin(self.x)[2:].zfill(self.field.power):
+            for d in bin(self.x)[2:].zfill(self.field.degree):
                 if int(d):
                     z ^= y
                 if y % 2:
@@ -219,7 +231,7 @@ class GF2nPoint:
         else:
             bitmap1 = self.field.order
             bitmap2 = 1
-            for _ in range(self.field.power):
+            for _ in range(self.field.degree):
                 if self.x & bitmap2:
                     z ^= y
                 bitmap2 <<= 1
@@ -300,11 +312,11 @@ class GF2nPoint:
 
     def sbox(self, inv: bool = False) -> "GF2nPoint":
         "Apply the AES sbox."
-        if self.field.power == 8 and self.field.modulus == 0b100011011: # AES
+        if self.field.degree == 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
+        elif self.field.degree == 4 and self.field.modulus == 0b10011: # MiniAES
             if inv:
                 return miniaes_sbox_inv[self.x]
             return miniaes_sbox[self.x]

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

@@ -3,6 +3,7 @@ Ring of intergers modulo `n`.
 """
 
 from math import gcd
+from random import randint
 from .factor import factorint
 from .primes import is_prime
 from .nt import sqrt_mod, crt
@@ -31,9 +32,10 @@ class Zmod:
         if not isinstance(n, int) or n < 1:
             raise ValueError(f"{n} is not a positive integer.")
         self.n = n
+        self.isfield = None
         self.n_factors = {} # factoring of n
         self.short = short
-        self.group_order = 0
+        self.group_order = 0 # order of the multiplicative group
         self.factors = {}  # factoring of the multiplicative group order
 
     def __repr__(self):
@@ -56,6 +58,12 @@ class Zmod:
     def __contains__(self, other: "ZmodPoint") -> bool:
         return isinstance(other, ZmodPoint) and self.n == other.ring.n
 
+    def random(self, num: int = 0) -> "ZmodPoint":
+        "Return a single random point or a list of random points."
+        if num:
+            return([self(randint(0,self.n-1)) for _ in range(num)])
+        return self(randint(0,self.n-1))
+
     def order(self) -> int:
         "Compute the order of the group Z_n^*."
         if self.group_order:
@@ -63,7 +71,7 @@ class Zmod:
         # We compute euler_phi(n) and its factorization in one pass
         if not self.n_factors:
             self.n_factors = factorint(self.n)
-        for p, k in self.n_factors.items():  # first factorize n
+        for p, k in self.n_factors.items():  # factorization of n
             # factor p-1 and add the factors
             for pm, km in factorint(p - 1).items():
                 if pm in self.factors:
@@ -96,7 +104,18 @@ class Zmod:
 
     def is_field(self) -> bool:
         "Test if Z_n is a field."
-        return is_prime(self.n)
+        if self.isfield is None:
+            if self.n_factors:
+                if len(self.n_factors) == 1:
+                    self.isfield = True
+                else:
+                    self.isfield = False
+            elif is_prime(self.n):
+                self.isfield = True
+                self.n_factors = { self.n: 1}
+            else:
+                self.isfield = False
+        return self.isfield
 
     def generator(self) -> int | None:
         "Return a generator of the group Z_n^*."

{kryptools-1.4 → kryptools-1.5}/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.4"
+__version__ = "1.5"
 __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

{kryptools-1.4 → kryptools-1.5}/kryptools/code.py

@@ -114,22 +114,24 @@ class Goppa():
     def decode(self, y: list[int]):
         "Decode a given list of bits."
         y = Matrix(y, ring = self.Z_2)
+        zero = self.gf(0)
+        one = zero**0
         if self.H * y: # no code word
-            s = self.gf(0) # syndrom polynomial
+            s = zero # 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)
+                s += int(y[i]) * Poly([-x, one], modulus = self.g).inv()
+            v = (s.inv() - Poly([zero, one], 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)])
+            y0, y1 = Poly([zero]), Poly([one])
             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)
+            sigma = a**2 + b**2 * Poly([zero, one])
             # correct the error
             for x in self.alpha:
                 if not sigma(x):

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

@@ -4,6 +4,7 @@ Polynomials
 
 from math import prod
 from numbers import Number
+from random import randint
 from .primes import is_prime
 #from .factor import factorint
 
@@ -24,7 +25,7 @@ class Poly:
 
     def __init__(self, coeff: list, ring=None, modulus: list = None):
         self.coeff = list(coeff)
-        for i in range(len(self.coeff) - 1, 0, -1):
+        for i in range(len(self.coeff) - 1, 0, -1):  # strip leading zeros
             if self.coeff[i]:
                 break
             self.coeff.pop(i)
@@ -49,6 +50,9 @@ class Poly:
     def __len__(self):
         return len(self.coeff)
 
+    def __hash__(self):
+        return hash(tuple(self.coeff))
+
     def __repr__(self, latex = False):
         def prx(i: int) -> str:
             if i == 0:
@@ -142,27 +146,34 @@ class Poly:
                     ring = None
         return zero, one, ring
 
+    def _guess_field(self):
+        zero, one, field = self._guess_ring()
+        if not field:
+            raise ValueError("The polynomial does not seem to be over a known finite field.")
+        if hasattr(field, 'n'):  # Zmod
+            p = field.n
+            q = field.n
+            if not field.is_field():
+                raise ValueError("The polynomial does not seem to be over a finite field.")
+        else:  # G2 or galois
+            p = field.characteristic
+            q = field.order
+        return field, zero, one, q, p
+    
     def __add__(self, other: "Poly") -> "Poly":
-        zero = 0 * self.coeff[0]
         if not isinstance(other, self.__class__):
             if self._check_type(other):
                 tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
             return NotImplemented
-        ls, lo = len(self.coeff), len(other.coeff)
-        if ls < lo:
-            scoeff = self.coeff + (lo - ls) * [zero]
-        else:
-            scoeff = self.coeff
-        if ls > lo:
-            ocoeff = other.coeff + (ls - lo) * [zero]
-        else:
-            ocoeff = other.coeff
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
-        return self.__class__([s + o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
+        ls, lo = len(self.coeff), len(other.coeff)
+        if ls < lo:
+            return self.__class__([ s + o for s, o in zip(self.coeff, other.coeff) ] + other.coeff[ls:], modulus=modulus)
+        return self.__class__([ s + o for s, o in zip(self.coeff, other.coeff) ] + self.coeff[lo:], modulus=modulus)
 
     def __radd__(self, other: "Poly") -> "Poly":
         return self + other
@@ -186,9 +197,7 @@ class Poly:
             return NotImplemented
         zero = 0 * self.coeff[0]
         ls, lo = len(self.coeff), len(other.coeff)
-        coeff = [None] * (ls + lo - 1)
-        for k in range(ls + lo - 1):
-            coeff[k] = sum((self.coeff[j] * other.coeff[k - j] for j in range(max(0, k - lo + 1), min(ls, k + 1))), start=zero)
+        coeff = [ sum((self.coeff[j] * other.coeff[k - j] for j in range(max(0, k - lo + 1), min(ls, k + 1))), start=zero) for k in range(ls + lo - 1) ]
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
@@ -308,7 +317,7 @@ class Poly:
             tmp = self.coeff[sd - i] * one # "* 1" is here to make sure we get a copy
             for j in range(od + 1):
                 self.coeff[sd - i - j] -= tmp * oth[od - j]
-        for i in range(len(self.coeff) - 1, 0, -1):
+        for i in range(len(self.coeff) - 1, 0, -1): # strip leading zeros
             if self.coeff[i]:
                 break
             self.coeff.pop(i)
@@ -318,53 +327,60 @@ class Poly:
         if not other:
             other = self.modulus
         zero, one, ring = self._guess_ring()
-        if isinstance(other, list):
-            other = self.__class__(other, ring=ring)
-        elif not isinstance(other, self.__class__):
-            raise NotImplementedError(f"Cannot invert {self} modulo {other}.")
+        if isinstance(other, self.__class__):
+            other = other.coeff
+        elif not isinstance(other, list):
+            raise NotImplementedError(f"{other} must be a list of coefficients or a polynomial.")
+        other = Poly(other, ring = ring)
         if not other:
             raise NotImplementedError(f"{other} must be nonzero.")
         r0, r1 = other, self
-        y0, y1 = self.__class__([zero], modulus=self.modulus), self.__class__([one], modulus=self.modulus)
+        y0, y1 = self.__class__([zero]), self.__class__([one])
         while r1:
             q, r = r0.divmod(r1)
             r0, r1 = r1, r
             y0, y1 = y1, y0 - q * y1
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
-        tmp = one / r0[0]
-        for i in range(len(y0)):
-            y0.coeff[i] *= tmp
-        return y0
+        y0.modulus = self.modulus
+        return y0 / r0.coeff[0]
 
     def gcd(self, other: "Poly") -> "Poly":
         "Greates common divisor with a given polynomial."
         ring = self._guess_ring()[-1]
-        if isinstance(other, list):
-            other = self.__class__(other, ring=ring)
-        elif not isinstance(other, self.__class__):
+        if not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot compute gcd: {other} must be a polynomial.")
+        if not self:
+            if not other:
+                return Poly([self.coeff[0]])
+            tmp = other / other.coeff[-1]
+            tmp.modulus = None
+            return tmp
         r0, r1 = other, self
         while r1:
             r0, r1 = r1, r0.divmod(r1)[1]
-        return r0
+        r0.modulus = None
+        return r0 / r0.coeff[-1]
 
     def egcd(self, other: "Poly") -> ("Poly", "Poly", "Poly"):
         """Perform the extended Euclidean agorithm for polynomials. Returns gcd, x, y such that other * x + self * y = gcd."""
         zero, one, ring = self._guess_ring()
-        if isinstance(other, list):
-            other = self.__class__(other, ring=ring)
-        elif not isinstance(other, self.__class__):
+        if not isinstance(other, self.__class__):
             raise NotImplementedError(f"Cannot perform egcd: {other} must be a polynomial.")
+        if not self:
+            if not other:
+                return Poly([zero]), Poly([zero]), Poly([zero])
+            return other / other.coeff[-1], Poly([zero]), one / other.coeff[-1]
         r0, r1 = other, self
-        x0, x1 = self.__class__([one], modulus=self.modulus), self.__class__([zero], modulus=self.modulus)
-        y0, y1 = self.__class__([zero], modulus=self.modulus), self.__class__([one], modulus=self.modulus)
+        x0, x1 = self.__class__([one]), self.__class__([zero])
+        y0, y1 = self.__class__([zero]), self.__class__([one])
         while r1:
             q, r = r0.divmod(r1)
             r0, r1 = r1, r
-            x0, x1 = x1, x0 - q * x1
-            y0, y1 = y1, y0 - q * y1
-        return r0, x0, y0
+            x0, x1 = x1, x0 - x1 * q
+            y0, y1 = y1, y0 - y1 * q
+        lcr0 = r0.coeff[-1]
+        return r0 / lcr0, x0 / lcr0, y0 / lcr0
 
     def derivative(self) -> "Poly":
         "Returns the formal derivative."
@@ -375,39 +391,147 @@ class Poly:
             tmp = [ j * self.coeff[j] for j in range(1, l) ]
         return self.__class__(tmp, modulus=self.modulus)
 
-    def rabin_test(self) -> bool:
-        """Determine if a polynomial is irreducible over a Galois field using a Rabin test."""
-        ring = self._guess_ring()[-1]
-        if not ring:
-            raise ValueError("The polynomial does not seem to be over a known finite field.")
-        try:
-            q = ring.n  # Zmod
-            isfield = is_prime(q)
-        except:
-            q = ring.order  # GF2
-            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
-        #    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):
+    def square_free_factors(self) -> dict:
+        "Determine the square free factors of a polynomial over a Galois field."
+        _, zero, _, q, p = self._guess_field()
+        pr = q // p # x^pr will be the p'th root of x
+        if self.degree() < 1:
+            return {}
+        if self.degree() == 1:
+            return { self  / self.coeff[-1]: 1}
+        factors = {}
+        w = self / self.coeff[-1]
+        c = w.gcd(w.derivative())
+        w = w // c
+
+        # first we find all factors which are not a power of p 
+        i = 1
+        while w.degree() > 0:
+            y = w.gcd(c)
+            fac = w // y
+            if fac.degree() > 0:
+                factors[fac] = i
+            w = y
+            c //= y
+            i += 1
+        # c is now a power of p
+        if c.degree() > 0:
+            # compute the p'th root of c
+            d = c.degree() // p
+            root = [ zero ] * (d + 1)
+            while d >= 0:
+                root[d] = c.coeff[d * p]**pr
+                d -= 1
+            #assert Poly(root)**p == c, root
+            for fac, mult in Poly(root).square_free_factors().items():
+                factors[fac] = p * mult
+        return factors
+
+    def is_square_free(self) -> bool:
+        "Test if the polynomial over a Galois field is square free."
+        multiplicities = self.square_free_factors().values()
+        return len(multiplicities) == 1 and multiplicities[0] == 1
+
+    def distinct_degree_factors(self, test:bool = False) -> bool|dict:
+        "Factors the polynomial over a Galois field into distinct products of irredicible factors of the same degree."
+        _, zero, one, q, _ = self._guess_field()
+        if self.degree() < 1:
+            raise ValueError("The polynomial must be non-constant.")
+        factors = {}
+        w = self
+        x = Poly([zero, one])  # x
+        xq = Poly(q * [zero] + [one], modulus = self.coeff)  # x^q modulo self to keep the polynomials small
+        k = 1
+        while k <= w.degree()//2:
             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
+            g = w.gcd(b - x)  # gcd with x^{q^k} - x
             if g.degree():
-                return False
-        return True
+                if test:
+                    return False
+                factors[k] = g
+                w = w // factors[k]
+            k += 1
+        if test:
+            return True
+        if w.degree() > 0:
+            factors[w.degree()] = w
+        return factors
+
+    def rabin_test(self) -> bool:
+        "Determine if a polynomial is irreducible over a Galois field using a Rabin test."
+        return self.distinct_degree_factors(test = True)
+
+    def is_irreducible(self) -> bool:
+        "Test if the polynomial over a Galois field is irreducibel."
+        if self.degree() == 0:
+            return False
+        return self.distinct_degree_factors(test = True)
 
+    def equal_degree_factors(self ,k:int) -> list:
+        "Factors a square free product of irreducibel polynomials of degree `k` over a Galois field."
+        field, zero, one, q, p = self._guess_field()
+        if hasattr(field, "degree"):
+            degree= field.degree
+        else:
+            degree = 1
+        d = self.degree()
+        if not isinstance(k, int) or k < 1 :
+            raise ValueError(f"The degree {k} must be a positive integer.")
+        if d < k or d % k:
+            raise ValueError(f"The polynomial is no product of irreducibel polynomials of degree {k}.")
+        r = d // k
+        qk = (q**k - 1) // 2
+        poly = [0] * k + [1]
+ 
+        factors = [ self ]
+        while len(factors) < r:
+            g = Poly([randint(0,q-1) for _ in range(d+1)], ring = field, modulus = self)
+            if p == 2: # Gathen-Shoup
+                h = g
+                for i in range(1,k):
+                    g += h**q
+                if degree > 1:
+                    h = g
+                    for i in range(1,degree):
+                        g += g**2
+            else:  # Cantor–Zassenhaus
+                g **= qk
+            factors2 = []  # list for the next round (to avoid the the new factors are tested a second time with the same g)
+            for fac in factors:
+                if fac.degree() == k:  # this one is already irreducible
+                    factors2.append(fac)
+                    continue
+                gg = fac.gcd(g)
+                if gg.degree() == 0 or gg.degree() == fac.degree():  # trivial factor
+                    factors2.append(fac)
+                    continue
+                gg.modulus = None
+                factors2.append(gg)
+                factors2.append(fac // gg)
+            factors = factors2
+        return factors
+
+    def factor(self) -> dict:
+        "Factors a polynomials over a Galois field."
+        if self.degree() < 1:
+            return {self: 1}
+        c = Poly([self.coeff[-1]])
+        one = c**0
+        if c != one:
+            factors = {c: 1}
+        else:
+            factors = {}
+        for fac1, m in self.square_free_factors().items():
+            for k, fac2 in fac1.distinct_degree_factors().items():
+                if k == fac2.degree(): # irreducible
+                    factors[fac2] = m
+                else:
+                    for fac3 in fac2.equal_degree_factors(k):
+                        factors[fac3] = m
+        return dict(sorted(factors.items(), key=lambda item: item[0].degree()))
 
 def lagrange_interpolation(x_coordinates:list, y_coordinates:list) -> "Poly":
     "Compute the Lagrange interpolation polynomial from a given list of x and y values."
@@ -416,7 +540,7 @@ def lagrange_interpolation(x_coordinates:list, y_coordinates:list) -> "Poly":
         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
+    # guess zero and one
     zero = 0 * x_coordinates[0]
     one = zero**0
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.4
+Version: 1.5
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -42,7 +42,7 @@ 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, irreducibility test, Lagrange interpolation)
+* 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

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

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

{kryptools-1.4 → kryptools-1.5}/tests/test_GF2.py

@@ -13,7 +13,7 @@ def test_GF2_ops():
         assert gf(1) == gf(1)
         assert not gf(1) == gf(0)
         assert not gf(0) == 0
-        if gf.power < 17:
+        if gf.degree < 17:
             assert len(list(gf)) == gf.order
             assert len(list(gf.star())) == gf.order - 1
             assert len(list(gf.generators())) == euler_phi(gf.order - 1)

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

@@ -1,8 +1,9 @@
 import pytest
-from random import sample, choices
+from math import prod
+from random import sample, choices, randint, seed
 from kryptools import Poly, Zmod, GF2, lagrange_interpolation
 from kryptools import divisors, moebius_mu
-
+seed(0)
 
 def test_Poly():
     p = Poly([2, 0, 2])
@@ -36,6 +37,19 @@ def test_rabin():
                 count += 1
         assert count == sum([moebius_mu(d) * order ** (t // d) for d in divisors(t)]) // t
 
+def test_factor():
+    for gf,t in [ [Zmod(7), 14], [GF2(4), 11]]:
+        order = len(list(gf))
+        one = Poly([gf(1)])
+        for _ in range(20):
+            p = one
+            while p.degree() < 1:
+                p = Poly([randint(0,order-1) for _ in range(t)], ring =gf)
+            factors = p.factor()
+            assert prod([f**k for f,k in factors.items()], start = one) == p, p
+            for fac in factors.keys():
+                assert fac.degree() == 0 or fac.rabin_test(), p
+
 def test_lagrange():
     for gf in [ Zmod(2), Zmod(3), Zmod(5), Zmod(7), Zmod(23), GF2(4), GF2(6)]:
         all = list(gf)