kryptools 1.4__tar.gz → 1.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.4
+Version: 1.5.1
 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.1}/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.1}/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
@@ -249,6 +261,8 @@ class GF2nPoint:
             return NotImplemented
         if not (self.x) and j < 0:
             raise ValueError("Division by zero.")
+        if self.field.order == 2:
+            return self
         if self.field.bitreversed:
             res = self.field(self.field.order >> 1)
         else:
@@ -278,6 +292,8 @@ class GF2nPoint:
 
     def sqrt(self) -> "GF2nPoint":
         "Compute the square root."
+        if self.field.order == 2:
+            return self
         return self**(self.field.order//2)
 
     def order(self) -> int:
@@ -300,11 +316,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.1}/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.1}/kryptools/__init__.py

@@ -5,7 +5,7 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024-2025, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.4"
+__version__ = "1.5.1"
 __email__ = "Gerald.Teschl@univie.ac.at"
 
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, is_carmichael_number, order, crt

{kryptools-1.4 → kryptools-1.5.1}/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):
@@ -305,11 +307,12 @@ class ReedSolomonCode(CyclicCode):
             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) ])
+        xx = [ -y(self.alpha**(-j)) for j in range(self.n) ]
+        x = Poly(xx)
         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) ]
+            A = Matrix([[ xx[j - l % self.n] for l in range(1, t+1) ] for j in range(self.k+t, self.k+2*t) ])
+            b = [ -xx[self.k + t + l ] for l in range(t) ]
             lam = Poly([one] + list(A.solve(b)))
             x_coordinates = []
             y_coordinates = []

{kryptools-1.4 → kryptools-1.5.1}/kryptools/keccak.py

@@ -161,16 +161,21 @@ class SHA3():
     def __init__(self, n: int = 256):
         if n not in (224, 256, 384, 512):
             raise ValueError(f"n must be one of: 224, 256, 384, 512")
-        self.keccak = Keccak(rate=1600-2*n)
+        self.keccak = Keccak(rate = 1600 - 2*n)
         self.keccak.pad = [b'\x86', b'\x06', b'\x80']
-        self.hash_length = n // 8  # in bytes
+        self.digest_size = n // 8  # in bytes
+        self.block_size = (1600 - 2*n) // 8  # in bytes
+        self.name = f"SHA3-{n}"
 
     def __call__(self, msg: bytes | str) -> bytes:
         "Compute the hash of the message given or absorbed."
         self.keccak.reset()
         self.keccak.absorb(msg)
-        return self.keccak.squeeze(self.hash_length)
+        return self.keccak.squeeze(self.digest_size)
 
+    def __repr__(self):
+        return self.name
+    
     def update(self, msg: bytes | str) -> None:
         "Absorb the given message into the sponge."
         self.keccak.absorb(msg)
@@ -179,10 +184,14 @@ class SHA3():
         "Compute the hash of the message given or absorbed."
         if msg is not None:
             self.keccak.absorb(msg)
-        digest = self.keccak.squeeze(self.hash_length)
+        digest = self.keccak.squeeze(self.digest_size)
         self.keccak.reset()
         return digest
 
+    def hexdigest(self, msg: bytes | str | None = None) -> bytes:
+        "Compute the hash of the message given or absorbed. Return as hex value."
+        return self.digest(msg).hex()
+
 
 class SHAKE():
     """
@@ -201,7 +210,19 @@ class SHAKE():
         self.keccak = Keccak(rate=1600-2*n)
         self.keccak.pad = [b'\x9f', b'\x1f', b'\x80']
         self.keccak.absorb(msg)
+        self.name = f"SHAKE-{n}"
+
+    def __repr__(self):
+        return self.name
 
     def __call__(self, r: int) -> bytes:
         "Extract `r` bytes."
         return self.keccak.squeeze(r)
+
+    def digest(self, r: int) -> bytes:
+        "Extract `r` bytes."
+        return self(r)
+
+    def hexdigest(self, r: int) -> bytes:
+        "Extract `r` bytes as hex values."
+        return self(r).hex()

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

@@ -4,8 +4,9 @@ Polynomials
 
 from math import prod
 from numbers import Number
+from random import randint
 from .primes import is_prime
-#from .factor import factorint
+
 
 class Poly:
     """
@@ -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)
@@ -35,28 +36,45 @@ class Poly:
             self.mod(modulus)
 
     def __call__(self, x):
-        zero = 0 * self.coeff[0]
-        if not type(x) == type(zero):
-            raise ValueError("Evaluation point must be an element of the field.")
-        return sum((c * x**j for j, c in enumerate(self.coeff)), start = zero)
+        result = 0 * self.coeff[0]
+        if not type(x) == type(result):
+            raise ValueError(
+                "Evaluation point must be an element of the ring.")
+        # Horner's method
+        for c in reversed(self.coeff):
+            result = result * x + c
+        return result
+
+        return sum((c * x**j for j, c in enumerate(self.coeff)), start=zero)
 
     def __getitem__(self, item):
+        if item >= len(self.coeff):
+            return self.coeff[0] * 0
         return self.coeff[item]
 
     def __setitem__(self, item, value):
+        if item >= len(self.coeff):
+            zero = self.coeff[0] * 0
+            self.coeff += [zero] * (item - len(self.coeff) + 1)
         self.coeff[item] = value
 
+    def __iter__(self):
+        yield from self.coeff
+        
     def __len__(self):
         return len(self.coeff)
 
-    def __repr__(self, latex = False):
+    def __hash__(self):
+        return hash(tuple(self.coeff))
+
+    def __repr__(self, latex=False):
         def prx(i: int) -> str:
             if i == 0:
                 return ""
             if i == 1:
                 return self.__class__.print_x
             if latex:
-                return self.__class__.print_x + "^{" + str(i) +"}"
+                return self.__class__.print_x + "^{" + str(i) + "}"
             return self.__class__.print_x + self.__class__.print_pow + str(i)
 
         if not self:
@@ -101,7 +119,7 @@ class Poly:
     def _repr_mimebundle_(self, **kwargs):
         return {
             "text/plain": repr(self),
-            "text/latex": "$" + self.__repr__(latex = True) + "$"
+            "text/latex": "$" + self.__repr__(latex=True) + "$"
         }
 
     def __eq__(self, other):
@@ -142,27 +160,36 @@ 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 +213,8 @@ 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
@@ -202,13 +228,15 @@ class Poly:
             return self.__class__([s / other for s in self.coeff], modulus=self.modulus)
         if isinstance(other, self.__class__):
             if not other.modulus:
-                raise NotImplementedError("Cannot invert polynomials without modulus.")
+                raise NotImplementedError(
+                    "Cannot invert polynomials without modulus.")
             return self * other.inv()
         return NotImplemented
 
     def __rtruediv__(self, other) -> "Poly":
         if not self.modulus:
-            raise NotImplementedError("Cannot invert polynomials without modulus.")
+            raise NotImplementedError(
+                "Cannot invert polynomials without modulus.")
         return other * self.inv()
 
     def __pow__(self, j: int) -> "Poly":
@@ -218,7 +246,8 @@ class Poly:
         res = self.__class__([one], modulus=self.modulus)
         if j < 0:
             if not self.modulus:
-                raise NotImplementedError("Cannot divide polynomials without modulus.")
+                raise NotImplementedError(
+                    "Cannot divide polynomials without modulus.")
             tmp = self.inv()
             j *= -1
         else:
@@ -236,7 +265,8 @@ class Poly:
         "List of bits of all coefficients."
         ring = self.coeff[0].__class__
         if not (hasattr(ring, 'bits') and callable(ring.bits)):
-            raise NotImplementedError("Coefficients cannot be converted to bits.")
+            raise NotImplementedError(
+                "Coefficients cannot be converted to bits.")
         out = []
         for c in self.coeff:
             out += c.bits()
@@ -275,8 +305,8 @@ class Poly:
             oth = [c * tmp for c in other.coeff]
             rem = [c * tmp for c in self.coeff]
         else:
-            oth = other.coeff
-            rem = [c * one for c in self.coeff] # "* 1" is here to make sure we get a copy
+            oth = other.coeff  # "* 1" is here to make sure we get a copy
+            rem = [c * one for c in self.coeff]
         for i in range(sd - od + 1):
             tmp = rem[sd - i] * one  # "* 1" is here to make sure we get a copy
             div[sd - od - i] = tmp
@@ -305,10 +335,10 @@ class Poly:
         else:
             oth = other.coeff
         for i in range(sd - od + 1):
-            tmp = self.coeff[sd - i] * one # "* 1" is here to make sure we get a copy
+            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 +348,63 @@ 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__):
-            raise NotImplementedError(f"Cannot compute gcd: {other} must be a polynomial.")
+        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__):
-            raise NotImplementedError(f"Cannot perform egcd: {other} must be a polynomial.")
+        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."
@@ -372,58 +412,168 @@ class Poly:
         if l == 1:
             tmp = 0 * self.coeff[0]
         else:
-            tmp = [ j * self.coeff[j] for j in range(1, l) ]
+            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):
-            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
+    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], modulus=self.coeff)  # x
+        b = x
+        k = 1
+        while k <= w.degree()//2:
+            b **= q  # we compute x^{q^k} mod a recursively
+            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 lagrange_interpolation(x_coordinates:list, y_coordinates:list) -> "Poly":
+    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 = g**qk - one
+            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."
     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.')
+        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
 
     poly = Poly([zero])
-    L_all = prod([Poly([-x, one]) for x in x_coordinates], start = one)
+    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
+        poly += (y /
+                 prod([x - xx for xx in x_coordinates if xx != x], start=one)) * L
     return poly

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

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

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

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

@@ -13,26 +13,25 @@ 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)
         for _ in range(num_tests):
-            a = randint(0, gf.order-1)
-            b = randint(0, gf.order-1)
-            assert (gf(a) + gf(b)).poly() == gf(a).poly() + gf(b).poly()
-            assert (gf(a) - gf(b)).poly() == gf(a).poly() - gf(b).poly()
-            assert (gf(a) * gf(b)).poly() == gf(a).poly() * gf(b).poly()
-            if not (b):
-                continue
-            assert (gf(a) / gf(b)).poly() == gf(a).poly() / gf(b).poly()
+            a = gf(randint(0, gf.order-1))
+            b = gf(randint(0, gf.order-1))
+            assert (a + b).poly() == a.poly() + b.poly()
+            assert (a - b).poly() == a.poly() - b.poly()
+            assert (a * b).poly() == a.poly() * b.poly()
+            if a:
+                assert (a**-1).poly() == a.poly().inv()
+            if b:
+                assert (a / b).poly() == a.poly() / b.poly()
+            assert a.sqrt()**2 == a
         with pytest.raises(ValueError):
             gf(1) / gf(0)
         with pytest.raises(ValueError):
             gf(0)**-1
-        for _ in range(num_tests):
-            a = randint(1, gf.order-1)
-            assert (gf(a)**-1).poly() == gf(a).poly().inv()
 
 def test_GF2_order():
     for n in range(1, 8):
@@ -53,7 +52,7 @@ def test_GF2P_order():
                 xx *=x
             assert o == x.order()
 
-def test_Zmod_generator():
+def test_GF2_generator():
     for n in range(1, 9):
         gf = GF2(n)
         a = gf.generator()

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

@@ -89,7 +89,6 @@ def test_ZmodP_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

kryptools-1.5.1/tests/test_poly.py

@@ -0,0 +1,88 @@
+import pytest
+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)
+num_tests = 10
+
+def test_Poly():
+    p = Poly([2, 0, 2])
+    q = Poly([1, 2, 3, 4])
+    d, m = q.divmod(p)
+    assert d * p + m == q
+    for _ in range(num_tests):
+        p = Poly([randint(0,100) for _ in range(10)])
+        q = Poly([randint(0,100) for _ in range(12)])
+        x = randint(0,100)
+        assert p(x) == sum((c * x**j for j, c in enumerate(p.coeff)), start=0)
+        assert (p + q)(x) == p(x) + q(x)
+        assert (p - q)(x) == p(x) - q(x)
+        assert (p*q)(x) == p(x) * q(x)
+
+    gf = Zmod(5)
+    p = Poly([2, 0, 2], ring = gf)
+    q = Poly([1, 2, 3, 4], ring = gf)
+    d, m = q.divmod(p)
+    assert d * p + m == q
+    for _ in range(num_tests):
+        p = Poly(gf.random(10))
+        q = Poly(gf.random(12))
+        x = gf.random()
+        assert p(x) == sum((c * x**j for j, c in enumerate(p.coeff)), start=gf(0))
+        assert (p + q)(x) == p(x) + q(x)
+        assert (p - q)(x) == p(x) - q(x)
+        assert (p * q)(x) == p(x) * q(x)
+
+    gf = GF2(8, modulus=0b100011011)
+    p = Poly([2, 1, 1, 3], modulus=[1, 0, 0, 0, 1], ring=gf)
+    q = p.inv()
+    assert p * q == Poly([1], modulus=[1, 0, 0, 0, 1], ring=gf)
+    for _ in range(num_tests):
+        p = Poly(gf.random(10))
+        q = Poly(gf.random(12))
+        x = gf.random()
+        assert p(x) == sum((c * x**j for j, c in enumerate(p.coeff)), start=gf(0))
+        assert (p + q)(x) == p(x) + q(x)
+        assert (p - q)(x) == p(x) - q(x)
+        assert (p * q)(x) == p(x) * q(x)
+
+def test_rabin():
+    for gf,t in [ [Zmod(7), 4], [GF2(4), 3]]:
+        order = len(list(gf))
+        count = 0
+        for i in range(order**t):
+            c = []
+            while i:
+                i, m = divmod(i, order)
+                c.append(m)
+            c += [0] * (t- len(c)) + [1]
+            a = Poly(c, ring=gf)
+            if a.rabin_test():
+                count += 1
+        assert count == sum([moebius_mu(d) * order ** (t // d) for d in divisors(t)]) // t
+
+def test_factor():
+    for gf, t in [ [Zmod(7), 14], [GF2(4), 9]]:
+        order = len(list(gf))
+        one = Poly([gf(1)])
+        for _ in range(20):
+            p = one
+            while p.degree() < 1:
+                p = Poly(gf.random(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)
+        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.4/tests/test_poly.py

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