kryptools 1.5__tar.gz → 1.5.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.5
+Version: 1.5.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

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

@@ -261,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:
@@ -290,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:

{kryptools-1.5 → 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.5"
+__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.5 → kryptools-1.5.1}/kryptools/code.py

@@ -307,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.5 → 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.5 → kryptools-1.5.1}/kryptools/poly.py

@@ -6,7 +6,7 @@ from math import prod
 from numbers import Number
 from random import randint
 from .primes import is_prime
-#from .factor import factorint
+
 
 class Poly:
     """
@@ -36,31 +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 __hash__(self):
         return hash(tuple(self.coeff))
 
-    def __repr__(self, latex = False):
+    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:
@@ -105,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):
@@ -149,17 +163,19 @@ class Poly:
     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.")
+            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.")
+                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":
         if not isinstance(other, self.__class__):
             if self._check_type(other):
@@ -172,8 +188,8 @@ class Poly:
             modulus = other.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)
+            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
@@ -197,7 +213,8 @@ class Poly:
             return NotImplemented
         zero = 0 * self.coeff[0]
         ls, lo = len(self.coeff), len(other.coeff)
-        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) ]
+        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
@@ -211,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":
@@ -227,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:
@@ -245,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()
@@ -284,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
@@ -314,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): # strip leading zeros
+        for i in range(len(self.coeff) - 1, 0, -1):  # strip leading zeros
             if self.coeff[i]:
                 break
             self.coeff.pop(i)
@@ -330,8 +351,9 @@ class Poly:
         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)
+            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
@@ -349,7 +371,8 @@ class Poly:
         "Greates common divisor with a given polynomial."
         ring = self._guess_ring()[-1]
         if not isinstance(other, self.__class__):
-            raise NotImplementedError(f"Cannot compute gcd: {other} must be a polynomial.")
+            raise NotImplementedError(f"Cannot compute gcd: {
+                                      other} must be a polynomial.")
         if not self:
             if not other:
                 return Poly([self.coeff[0]])
@@ -366,7 +389,8 @@ class 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 not isinstance(other, self.__class__):
-            raise NotImplementedError(f"Cannot perform egcd: {other} must be a polynomial.")
+            raise NotImplementedError(f"Cannot perform egcd: {
+                                      other} must be a polynomial.")
         if not self:
             if not other:
                 return Poly([zero]), Poly([zero]), Poly([zero])
@@ -388,23 +412,23 @@ 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 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
+        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}
+            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 
+        # first we find all factors which are not a power of p
         i = 1
         while w.degree() > 0:
             y = w.gcd(c)
@@ -418,11 +442,11 @@ class Poly:
         if c.degree() > 0:
             # compute the p'th root of c
             d = c.degree() // p
-            root = [ zero ] * (d + 1)
+            root = [zero] * (d + 1)
             while d >= 0:
                 root[d] = c.coeff[d * p]**pr
                 d -= 1
-            #assert Poly(root)**p == c, root
+            # assert Poly(root)**p == c, root
             for fac, mult in Poly(root).square_free_factors().items():
                 factors[fac] = p * mult
         return factors
@@ -432,21 +456,18 @@ class Poly:
         multiplicities = self.square_free_factors().values()
         return len(multiplicities) == 1 and multiplicities[0] == 1
 
-    def distinct_degree_factors(self, test:bool = False) -> bool|dict:
+    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
+        x = Poly([zero, one], modulus=self.coeff)  # x
+        b = x
         k = 1
         while k <= w.degree()//2:
-            if k == 1:
-                b = xq
-            else:
-                b **= q  # we compute x^{q^k} mod a recursively
+            b **= q  # we compute x^{q^k} mod a recursively
             g = w.gcd(b - x)  # gcd with x^{q^k} - x
             if g.degree():
                 if test:
@@ -462,43 +483,45 @@ class Poly:
 
     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)
+        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)
+        return self.distinct_degree_factors(test=True)
 
-    def equal_degree_factors(self ,k:int) -> list:
+    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
+            degree = field.degree
         else:
             degree = 1
         d = self.degree()
-        if not isinstance(k, int) or k < 1 :
+        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}.")
+            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 ]
+
+        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
+            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):
+                for i in range(1, k):
                     g += h**q
                 if degree > 1:
                     h = g
-                    for i in range(1,degree):
+                    for i in range(1, degree):
                         g += g**2
             else:  # Cantor–Zassenhaus
-                g **= qk
+                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
@@ -526,18 +549,20 @@ class Poly:
             factors = {}
         for fac1, m in self.square_free_factors().items():
             for k, fac2 in fac1.distinct_degree_factors().items():
-                if k == fac2.degree(): # irreducible
+                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":
+
+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
@@ -545,9 +570,10 @@ def lagrange_interpolation(x_coordinates:list, y_coordinates:list) -> "Poly":
     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.5 → kryptools-1.5.1}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.5
+Version: 1.5.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

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

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

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

@@ -18,21 +18,20 @@ def test_GF2_ops():
             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.5 → 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 → kryptools-1.5.1}/tests/test_poly.py

@@ -4,23 +4,48 @@ 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)
 
-    Z_5 = Zmod(5)
-    p.map(Z_5)
-    q.map(Z_5)
+    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]]:
@@ -38,13 +63,13 @@ def test_rabin():
         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]]:
+    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([randint(0,order-1) for _ in range(t)], ring =gf)
+                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():