kryptools 1.3__tar.gz → 1.3.2__tar.gz

{kryptools-1.3 → kryptools-1.3.2}/PKG-INFO

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

{kryptools-1.3 → kryptools-1.3.2}/kryptools/GF2.py

@@ -62,6 +62,9 @@ class GF2:
             return [GF2nPoint(xx, self) for xx in x]
         return GF2nPoint(x, self)
 
+    def __len__(self):
+        return self.order
+
     def __iter__(self):
         for x in range(self.order):
             yield GF2nPoint(x, self)

{kryptools-1.3 → kryptools-1.3.2}/kryptools/Zmod.py

@@ -98,6 +98,10 @@ class Zmod:
         "Return a generator of the group Z_n^*."
         if not self.is_cyclic():
             return None
+        if self.n == 1:
+            return self(0)
+        if self.n == 2:
+            return self(1)
         for a in range(2, self.n):
             if gcd(a, self.n) > 1:
                 continue
@@ -109,17 +113,21 @@ class Zmod:
         "Return a generator for all generators of the group Z_n^*."
         a = self.generator()
         if a is not None:
+            yield a
             self.order()
-            for j in range(1, self.group_order):
+            for j in range(2, self.group_order):
                 if gcd(j, self.group_order) == 1:
                     yield a**j
 
     def star(self) -> list:
         "Return a generator for all elements of the group Z_n^*."
-        yield self(1)
-        for a in range(2, self.n):
-            if gcd(a, self.n) == 1:
-                yield self(a)
+        if self.n == 1:
+            yield self(0)
+        else:
+            yield self(1)
+            for a in range(2, self.n):
+                if gcd(a, self.n) == 1:
+                    yield self(a)
 
 
 class ZmodPoint:

{kryptools-1.3 → kryptools-1.3.2}/kryptools/__init__.py

@@ -5,7 +5,7 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024-2025, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.3"
+__version__ = "1.3.2"
 __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.3 → kryptools-1.3.2}/kryptools/code.py

@@ -17,31 +17,39 @@ def poly2bits(x: Poly) -> list:
 
 def left_standard_form(M: Matrix) -> (Matrix, Matrix):
     "Compute the left standard form of a generator matrix. Return the standard form and the pertmutation matrix."
+    # reduced row echelon form
     M = M.rref()
+    # purge zero rows
     for i in range(M.rows-1,-1,-1):
         if not M[i,:]:
-            M.delete_rows(i)  # remove zero rows
+            M.delete_rows(i)
+    # permute columns to get the identity on the left
     last = min(M.rows, M.cols)
     P = eye(M.cols)
     for i in range(last):
-        if not M[i,i]:
+        if not M[i,i]: # the diagonal entry vanishes
+            # find the index of the pivot and permute
             j = i + 1
-            while j <= last and not M[i, j]:
+            while j <= M.cols and not M[i, j]:
                 j += 1
-            if j <= last:
-                P[:,i], P[:,j] = P[:,j], P[:,i]
-                M[:,i], M[:,j] = M[:,j], M[:,i]
+            P[:,i], P[:,j] = P[:,j], P[:,i]
+            M[:,i], M[:,j] = M[:,j], M[:,i]
     return M, P
 
 def gen2pchk(G: Matrix) -> Matrix:
     "Compute the parity check matrix from a given generator matrix (and vice versa)."
     G, P = left_standard_form(G)
     d = G.cols - G.rows
-    assert d > 0
+    if d <= 0:
+        raise ValueError("A generator matrix must have more columns than rows!")
     zero = 0 * G[0]
+    one = zero**0
+    # we start with a zero matrix
     H = zeros(d, G.cols, zero = zero)
+    # create the identity on the right
     for i in range(d):
-        H[i,G.rows+i] = zero**0
+        H[i,G.rows+i] = one
+    # add minus the transpose of the right part of G as the left part
     tmp = - G[:,-d:].transpose()
     for i in range(G.cols - d):
         H[:, i] = tmp[:, i]
@@ -55,12 +63,12 @@ def hamming_dist(a: iter, b: iter):
 
 class Goppa():
     """
-    Binary Goppa code.
+    Binary irreducible Goppa code.
 
     Example:
 
     >>> gf = GF2(4) # base field GF(2^n)
-    >>> g = Poly([2, 0, 0, 1], ring = gf) # Polynomial for the code
+    >>> g = Poly([2, 0, 0, 1], ring = gf) # irreducible Polynomial for the code
     >>> alpha = list(gf) # list of points from the base field (must not contain zeros of g)
     >>> goppa = Goppa(gf, g, alpha)
     
@@ -68,17 +76,20 @@ class Goppa():
     >>> goppa.encode([1, 0, 1, 1])
     [0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1]
 
-    Decoding still works if there are atmost deg(g) errors:
+    Decoding still works if there are at most deg(g) errors:
     >>> goppa.decode([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0])
     [1, 0, 1, 1]
     
     """
 
     def __init__(self, gf: GF2, g: Poly, alpha: list["GF2Point"]):
-        assert all(map(g, alpha))
-        self.gf = gf
-        self.g = g
-        self.alpha = alpha
+        if not all(map(lambda x: x in gf, alpha)):
+            raise ValueError(f"{x}: alpha must be a list of elements from the Galois field!")
+        if not g.rabin_test():
+            raise ValueError(f"The polynomial g must be irreducible!")
+        self.gf = gf  # underlying Galois field
+        self.g = g  # polynomial
+        self.alpha = alpha # list of elements from gf
         # Compute the control matrix
         self.Z_2 = Zmod(2)
 
@@ -89,6 +100,9 @@ class Goppa():
         # Compute the generator matrix
         self.G = gen2pchk(self.H)
 
+    def __repr__(self):
+        return f"Binary irreducible Goppa code over GF(2^{self.gf.power}) with polynomial g(x) = {self.g}."
+
     def encode(self, x: list[int]):
         "Encode a given list of bits."
         x = Matrix(x, ring = self.Z_2)
@@ -109,16 +123,18 @@ class Goppa():
             v.modulus = None
             r0, r1 = self.g, v
             y0, y1 = Poly([self.gf(0)]), Poly([self.gf(1)])
-            while r1 and 2* r1.degree() > self.g.degree():
+            while 2 * r1.degree() > self.g.degree():
                 q, r = r0.divmod(r1)
                 r0, r1 = r1, r
                 y0, y1 = y1, y0 - q * y1
             a, b = r1, y1
             sigma = a**2 + b**2 * Poly([0,1], ring = self.gf)
             # correct the error
-            for x in self.gf:
+            for x in self.alpha:
                 if not sigma(x):
                     y[int(x)] += 1
+            if self.H * y:
+                raise ValueError("Decoding failed!")
         x = self.G.transpose().solve(y)
         x.map(int)
         return list(x)

{kryptools-1.3 → kryptools-1.3.2}/kryptools/la.py

@@ -191,7 +191,7 @@ class Matrix:
             return False
         if self.rows != other.rows or self.cols != other.cols:
             return False
-        return any(self[i] == other[i] for i in range(self.rows * self.cols))
+        return all(self[i] == other[i] for i in range(self.rows * self.cols))
 
     def __bool__(self):
         return any(bool(self[i]) for i in range(self.rows * self.cols))

{kryptools-1.3 → kryptools-1.3.2}/kryptools/poly.py

@@ -4,7 +4,7 @@ Polynomials
 
 from numbers import Number
 from .primes import is_prime
-from .factor import factorint
+#from .factor import factorint
 
 class Poly:
     """
@@ -387,11 +387,23 @@ class Poly:
             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
+        #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
             if g.degree():
                 return False
-        g = x**(q**n) - x
-        return not(g)
+        return True
+

{kryptools-1.3 → kryptools-1.3.2}/kryptools.egg-info/PKG-INFO

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

{kryptools-1.3 → kryptools-1.3.2}/pyproject.toml

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

{kryptools-1.3 → kryptools-1.3.2}/tests/test_GF2.py

@@ -8,6 +8,11 @@ num_tests = 50
 def test_GF2_ops():
     for n, modulus in [(4, None), (8, None), (8, 0b100011011), (12, None), (128, 0b11100001 << 120)]:
         gf = GF2(n, modulus=modulus)
+        assert gf(1)
+        assert not gf(0)
+        assert gf(1) == gf(1)
+        assert not gf(1) == gf(0)
+        assert not gf(0) == 0
         if gf.power < 17:
             assert len(list(gf)) == gf.order
             assert len(list(gf.star())) == gf.order - 1

{kryptools-1.3 → kryptools-1.3.2}/tests/test_Zmod.py

@@ -1,6 +1,6 @@
 import pytest
 from math import gcd
-from kryptools import Zmod, euler_phi
+from kryptools import Zmod, euler_phi, is_prime
 
 
 def test_Zmod_ops():
@@ -42,6 +42,11 @@ def test_Zmod_methods():
     assert list(Z_5.star()) == Z_5([1, 2, 3, 4])
     assert [Z_5(i).sharp() for i in range(Z_5.n)] == [0, 1, 2, -2, -1]
     assert [abs(Z_5(i)) for i in range(Z_5.n)] == [0, 1, 2, 2, 1]
+    assert not Z_5(0)
+    assert Z_5(1)
+    assert Z_5(2) == Z_5(2)
+    assert Z_5(2) != Z_5(3)
+    assert Z_5(2) != 2
     assert str(Z_5(3)) == "3"
     Z_5.short = False
     assert str(Z_5(6)) == "1 (mod 5)"
@@ -57,13 +62,22 @@ def test_Zmod_methods():
     assert Z_6(5).is_generator() is True
     assert list(Z_6.generators()) == Z_6([5])
     assert list(Z_6.star()) == Z_6([1, 5])
+    assert Z_6(1)
+    assert Z_6(2) == Z_6(2)
+    assert Z_6(2) != Z_6(3)
+    assert Z_5(2) != Z_6(2)
     assert str(Z_6(3)) == "3"
 
 
 def test_Zmod_order():
-    for n in range(2, 10):
-        Z_n = Zmod(n)
-        assert Z_n.order() == euler_phi(n)
+    for n in range(1, 100):
+        o = euler_phi(n)
+        assert Zmod(n).order() == o
+        assert len(list(Zmod(n).star())) == o
+
+def test_Zmod_field():
+    for n in range(1, 100):
+        assert Zmod(n).is_field() == is_prime(n)
 
 
 OEIS_A033948 = [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 17, 18, 19, 22, 23, 25, 26, 27,
@@ -71,7 +85,24 @@ OEIS_A033948 = [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 17, 18, 19, 22, 23, 25,
                 79, 81, 82, 83, 86, 89, 94, 97, 98, 101, 103, 106, 107, 109, 113, 118, 121, 122, 125,
                 127, 131, 134, 137, 139]
 
-
 def test_Zmod_cyclic():
     for n in range(2, OEIS_A033948[-1]+1):
         assert Zmod(n).is_cyclic() == (n in OEIS_A033948)
+
+OEIS_A046145 = [0, 1, 2, 3, 2, 5, 3, 0, 2, 3, 2, 0, 2, 3, 0, 0, 3, 5, 2, 0, 0, 7, 5, 0, 2, 7, 2, 0, 2, 0, 3, 0, 0, 3, 0,
+ 0, 2, 3, 0, 0, 6, 0, 3, 0, 0, 5, 5, 0, 3, 3, 0, 0, 2, 5, 0, 0, 0, 3, 2, 0, 2, 3, 0, 0, 0, 0, 2, 0, 0, 0,
+ 7, 0, 5, 5, 0, 0, 0, 0, 3, 0, 2, 7, 2, 0, 0, 3, 0, 0, 3, 0]
+
+def test_Zmod_generator():
+    for j, a in enumerate(OEIS_A046145):
+        aa = Zmod(j+1).generator()
+        if aa is None:
+            aa = 0
+        assert a == int(aa)
+
+def test_Zmod_generators():
+    for n in range(1, 100):
+        if Zmod(n).is_cyclic():
+            assert len(list(Zmod(n).generators())) == euler_phi(euler_phi(n))
+        else:
+            assert list(Zmod(n).generators()) == []

kryptools-1.3.2/tests/test_code.py

@@ -0,0 +1,41 @@
+import pytest
+from random import randint, seed
+from kryptools import Zmod, GF2, Poly, Matrix
+from kryptools import gen2pchk, Goppa
+
+seed(0)
+Z_2 = Zmod(2)
+
+def Hamming2(h: int) -> Matrix:
+    "Parity check matrix for the binary Hamming code."
+    out = []
+    for i in range(1,2**h):
+        out.append([int(d) for d in str(format(i, "0" + str(h) + "b"))])
+    return Matrix(out, ring = Z_2).transpose()
+
+
+def test_gen2pchk():
+    for h in range(2,6):
+        H = Hamming2(h)
+        G = gen2pchk(H)
+        assert not H * G.transpose()
+
+num_tests = 10
+
+def test_Goppa():
+    for gf, t in [ [GF2(4), 3],  [GF2(6), 4]]:
+        found = False
+        while not found:
+            c = [randint(0,gf.order-1) for _ in range(t)] + [1]
+            g = Poly(c, ring = gf)
+            found = g.rabin_test()
+        alpha = list(gf)
+
+        goppa = Goppa(gf, g, alpha)
+        for _ in range(num_tests):
+            x = [ randint(0,1) for _ in range(goppa.G.rows) ]
+            y = goppa.encode(x)
+            for _ in range(t):
+                i = randint(0, goppa.G.cols-1)
+                y[i] = 1- y[i]
+            assert goppa.decode(y) == x

{kryptools-1.3 → kryptools-1.3.2}/tests/test_la.py

@@ -5,6 +5,13 @@ from kryptools import Matrix, Zmod
 
 def test_Matrix():
     M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]])
+    Z = M.zeros()
+    assert M
+    assert M == M
+    assert not Z
+    Z[0] = 1
+    assert Z
+    assert Z != Z.zeros()
     assert len(M) == 3 * 3
     assert M[0] == 1
     assert M[:] == [1, 2, 3, 4, 5, 6, 7, 8, 12]

kryptools-1.3.2/tests/test_poly.py

@@ -0,0 +1,36 @@
+import pytest
+from kryptools import Poly, Zmod, GF2
+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

kryptools-1.3/tests/test_code.py

@@ -1,32 +0,0 @@
-import pytest
-from random import randint, seed
-from kryptools import Zmod, GF2, Poly, Matrix
-from kryptools import gen2pchk, Goppa
-
-seed(0)
-Z_2 = Zmod(2)
-G_Hamming = Matrix([
-[1, 0, 0, 0, 1, 1, 0],
-[0, 1, 0, 0, 1, 0, 1],
-[0, 0, 1, 0, 0, 1, 1],
-[0, 0, 0, 1, 1, 1, 1]
-], ring = Z_2)
-
-
-def test_gen2pchk():
-    H = gen2pchk(G_Hamming)
-    assert not H * G_Hamming.transpose()
-
-def test_Goppa():
-    gf = GF2(4)
-    g = Poly([2, 0, 0, 1], ring = gf)
-    alpha = list(gf)
-
-    goppa = Goppa(gf, g, alpha)
-    for _ in range(10):
-        x = [ randint(0,1) for _ in range(goppa.G.rows) ]
-        y = goppa.encode(x)
-        for _ in range(3):
-            i = randint(0, goppa.G.cols-1)
-            y[i] = 1- y[i]
-    assert goppa.decode(y) == x

kryptools-1.3/tests/test_poly.py

@@ -1,20 +0,0 @@
-import pytest
-from kryptools import Poly, Zmod, GF2
-
-
-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)