kryptools 1.3.5__tar.gz → 1.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.3.5
+Version: 1.5
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -42,10 +42,12 @@ The tools contained are:
 * linear codes: Hamming distance, left standard form, parity check matrix
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
-* Poly: a class for polynomials (division, modulo)
+* Poly: a class for polynomials (division, modulo, 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
+* CyclicCode: a class for encoding and decoding cyclic codes
+* ReedSolomonCode: a class for encoding and decoding Reed-Solomon codes
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

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

@@ -24,10 +24,12 @@ The tools contained are:
 * linear codes: Hamming distance, left standard form, parity check matrix
 
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
-* Poly: a class for polynomials (division, modulo)
+* Poly: a class for polynomials (division, modulo, 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
+* CyclicCode: a class for encoding and decoding cyclic codes
+* ReedSolomonCode: a class for encoding and decoding Reed-Solomon codes
 
 * BlockCipher: a class implementing the usual modes of operation (ECB, CBC, GCM, etc.)
 * AESCipher: individual AES operations

{kryptools-1.3.5 → 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,10 +57,10 @@ 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):
-        if isinstance(x, list|tuple):
+    def __call__(self, x: int | list | tuple | range | map):
+        if isinstance(x, list|tuple|range|map):
             return [GF2nPoint(xx, self) for xx in x]
         return GF2nPoint(x, self)
 
@@ -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.3.5 → 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,16 +32,17 @@ 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):
         return f"Z_{self.n}"
 
-    def __call__(self, x: int | list | tuple):
-        if isinstance(x, list|tuple):
+    def __call__(self, x: int | list | tuple | range | map):
+        if isinstance(x, list|tuple|range|map):
             return [ZmodPoint(xx, self) for xx in x]
         return ZmodPoint(x, self)
 
@@ -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.3.5 → 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.3.5"
+__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
@@ -16,10 +16,10 @@ from .dlp import dlog
 from .ec import EC_Weierstrass
 from .la import Matrix, zeros, eye
 from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_round_bnd, babai_plane_cvp, babai_plane_bnd, lagrange_lr, lll, random_unimodular_matrix
-from .poly import Poly
+from .poly import Poly, lagrange_interpolation
 from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash
-from .code import left_standard_form, gen2pchk, hamming_dist, Goppa
+from .code import left_standard_form, gen2pchk, hamming_dist, Goppa, CyclicCode, ReedSolomonCode
 from .blockcipher import BlockCipher, bytexor
 from .aes import AESKeySchedule, AESCipher, AESBlockCipher
 from .des import list2int, int2list, permute, invert_permutation, rotate_left, SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, DESBlockCipher

kryptools-1.5/kryptools/code.py

@@ -0,0 +1,328 @@
+"""
+Linear codes
+"""
+
+from math import prod
+from .Zmod import Zmod
+from .GF2 import GF2
+from .poly import Poly, lagrange_interpolation
+from .la import Matrix, eye, zeros
+
+
+def poly2bits(x: Poly) -> list:
+    "Convert a polynomial in GF(2^n)[x] to a list of binary digits."
+    out = []
+    for c in x.coeff:
+        out += c.bits()
+    return out
+
+def left_standard_form(M: Matrix) -> (Matrix, Matrix):
+    "Compute the left standard form of a generator matrix. Return the standard form and the pertmutation matrix."
+    # reduced row echelon form
+    M = M.rref()
+    # purge zero rows
+    for i in range(M.rows-1,-1,-1):
+        if not M[i,:]:
+            M.delete_rows(i)
+    # permute columns to get the identity on the left
+    last = min(M.rows, M.cols)
+    P = eye(M.cols)
+    for i in range(last):
+        if not M[i,i]: # the diagonal entry vanishes
+            # find the index of the pivot and permute
+            j = i + 1
+            while j <= M.cols and not M[i, j]:
+                j += 1
+            P[:,i], P[:,j] = P[:,j], P[:,i]
+            M[:,i], M[:,j] = M[:,j], M[:,i]
+    return M, P
+
+def gen2pchk(G: Matrix) -> Matrix:
+    "Compute the parity check matrix from a given generator matrix (and vice versa)."
+    G, P = left_standard_form(G)
+    d = G.cols - G.rows
+    if d <= 0:
+        raise ValueError("A generator matrix must have more columns than rows!")
+    zero = 0 * G[0]
+    one = zero**0
+    # we start with a zero matrix
+    H = zeros(d, G.cols, zero = zero)
+    # create the identity on the right
+    for i in range(d):
+        H[i,G.rows+i] = one
+    # add minus the transpose of the right part of G as the left part
+    tmp = - G[:,-d:].transpose()
+    for i in range(G.cols - d):
+        H[:, i] = tmp[:, i]
+    return H * P.transpose()
+
+def hamming_dist(a: iter, b: iter):
+    "Hamming distance of two iterables."
+    if len(a) != len(b):
+        raise ValueError("Both iteralbles must have equal length.")
+    return sum(aa != bb for aa, bb in zip(a, b))
+
+class Goppa():
+    """
+    Binary irreducible Goppa code.
+
+    Example:
+
+    >>> gf = GF2(4) # base field GF(2^4)
+    >>> g = Poly([2, 0, 0, 1], ring = gf) # irreducible Polynomial for the code
+    >>> alpha = list(gf) # list of points from the base field (must not contain zeros of g)
+    >>> goppa = Goppa(gf, g, alpha)
+    
+    To encode a list of bits (the length must be equal to the dimension k of the code)
+    >>> goppa.encode([1, 0, 1, 1])
+    [0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1]
+
+    Decoding still works if there are at most deg(g) errors:
+    >>> goppa.decode([0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0])
+    [1, 0, 1, 1]
+    
+    """
+
+    def __init__(self, gf: GF2, g: Poly, alpha: list["GF2Point"]):
+        if not all(map(lambda x: x in gf, alpha)):
+            raise ValueError(f"{x}: alpha must be a list of elements from the Galois field!")
+        if not g.rabin_test():
+            raise ValueError("The polynomial g must be irreducible!")
+        self.gf = gf  # underlying Galois field
+        self.g = g  # polynomial
+        self.alpha = alpha # list of elements from gf
+        # Compute the control matrix
+        self.Z_2 = Zmod(2)
+
+        tmp =[]
+        for x in alpha:
+            tmp.append(Poly([-x, 1], ring = gf, modulus = g).inv().bits())
+        self.H = Matrix(tmp, ring=self.Z_2).transpose()
+        # Compute the generator matrix
+        self.G = gen2pchk(self.H)
+
+    def __repr__(self):
+        return f"Binary irreducible Goppa code over GF(2^{self.gf.power}) with polynomial g(x) = {self.g}."
+
+    def encode(self, x: list[int]):
+        "Encode a given list of bits."
+        x = Matrix(x, ring = self.Z_2)
+        y = self.G.transpose() * x
+        y.map(int)
+        return list(y)
+
+    def decode(self, y: list[int]):
+        "Decode a given list of bits."
+        y = Matrix(y, ring = self.Z_2)
+        zero = self.gf(0)
+        one = zero**0
+        if self.H * y: # no code word
+            s = zero # syndrom polynomial
+            for i, x in enumerate(self.alpha):
+                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([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([zero, one])
+            # correct the error
+            for x in self.alpha:
+                if not sigma(x):
+                    y[int(x)] += 1
+            if self.H * y:
+                raise ValueError("Decoding failed!")
+        x = self.G.transpose().solve(y)
+        x.map(int)
+        return list(x)
+
+class CyclicCode():
+    """
+    Cyclic code.
+
+    Example:
+
+    >>> n = 4 # length of the code
+    >>> g = Poly([1, 1], ring = Zmod(2)) # generating Polynomial for the code
+    >>> cc = CyclicCode(n, g)
+    
+    To encode a list of letters (the length must be equal to the dimension k of the code):
+    >>> cc.encode([0,1,0], ring = Zmod(2))
+    [0, 1, 1, 0]
+
+    Decoding is only implemnted for code words:
+    >>> cc.decode([0, 1, 1, 0], ring = Zmod(2))
+    [0, 1, 0]
+    
+    """
+
+    def __init__(self, n:int, g: Poly):
+        if n < 2:
+            raise ValueError(f"Code lenght {n} must be at least 2!")
+        zero = 0 * g[0]
+        try:
+            order = zero.ring.n  # Zmod
+        except:
+            try:
+                order = zero.field.order  # GF2
+            except:
+                try:
+                    order = type(zero).order  # galois
+                except:
+                    raise ValueError("Unknown base filed!")
+        self.order = order  # order of the base field
+        one = zero**0
+        modulus = Poly([-one] + [zero] * (n-1) + [one])
+        self.modulus = modulus
+        if modulus % g:
+            raise ValueError(f"The polynomial g must be a factor of x^{n} - 1!")
+        self.n = n  # lenght
+        self.k = n - g.degree()  # dimension
+        self.g = g  # generating polynomial
+        self.h = Poly(modulus) // g
+
+    def __repr__(self):
+        return f"Cyclic [{self.n}, {self.k}] code over GF({self.order}) with generator polynomial g(x) = {self.g}."
+    
+    def encode(self, x: list|Poly, gf = None, systematic_form = False):
+        "Encode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        if isinstance(x, list | tuple):
+            as_list = True
+            x = Poly(x, ring = gf)
+        if x.degree() >= self.k:
+            raise ValueError(f"Degree can be at most {self.k-1}.")
+        if systematic_form:
+            x.coeff = [zero] * self.g.degree() + x.coeff
+            y = x - (x % self.g)
+        else:
+            y = self.g * x
+        if as_list:
+            return y.coeff + [zero] * (self.n - len(y.coeff))
+        return y
+
+    def decode(self, y: list|Poly, gf = None, systematic_form = False):
+        "Decode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        if isinstance(y, list | tuple):
+            as_list = True
+            y = Poly(y, ring = gf)
+        if y.degree() >= self.n:
+            raise ValueError(f"Degree can be at most {self.n-1}.")
+        x, r = y.divmod(self.g)
+        if r:
+            raise NotImplementedError(f"Word is no code word! Cannot decode.")
+        if systematic_form:
+            x.coeff = y.coeff[self.g.degree():]
+        if as_list:
+            return x.coeff + [zero] * (self.k - len(x.coeff))
+        return x
+
+    def generator_matrix(self):
+        "Return the generator matrix of the code."
+        zero = 0 * self.g[0]
+        return Matrix([[zero] * j + self.g.coeff + [zero] * (self.k - j - 1 ) for j in range(self.k)])
+
+    def check_matrix(self):
+        "Return the parity check matrix of the code."
+        zero = 0 * self.g[0]
+        tmp = list(reversed(self.h.coeff))
+        return Matrix([[zero] * j + tmp + [zero] * (self.n - self.k - j - 1 ) for j in range(self.n-self.k)])
+
+class ReedSolomonCode(CyclicCode):
+    """
+    Reed-Solomon code.
+
+    Example:
+
+    >>> gf = Zmod(13) # Galois field
+    >>> k = 3 # dimension of the code
+    >>> rsc = ReedSolomonCode(k, gf)
+    
+    To encode a list of letters (the length must be equal to the dimension k of the code; conversion to the Galois field is done automatically):
+    >>> cc.encode([1, 2, 3])
+    [0, 1, 1, 0]
+
+    Decoding is only implemnted for code words:
+    >>> cc.decode([0, 1, 1, 0], ring = Zmod(2))
+    [0, 1, 0]
+    
+    """
+    def __init__(self, k:int, gf, alpha = None):
+        zero = gf(0)
+        one = zero**0
+        self. gf = gf
+        try:
+            n = gf.order()
+        except:
+            n = gf.order - 1
+        self.order = n + 1  # order of the base field
+        self.n = n  # lenght
+        self.k = k  # dimension
+        self.d = n - k - 1  # minimal distance
+        self.modulus = Poly([-one] + [zero] * (n-1) + [one])
+        if alpha is None:
+            try:
+                alpha = gf.generator()  # Zmod|GF2
+            except:
+                alpha = gf.primitive_element  # galois
+        self.alpha = alpha
+        self.g = prod([Poly([-alpha**j, one]) for j in range(1,n-k+1)], start = one) # generating polynomial
+        self.h = Poly(self.modulus) // self.g  # check polynomial
+        assert k == n - self.g.degree()
+        assert self.g * self.h == self.modulus
+
+    def __repr__(self):
+        return f"Reed-Solomon-Code [{self.n}, {self.k}, {self.d}] over GF({self.n+1})."
+
+    def encode(self, x: list|Poly):
+        "Encode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        if isinstance(x, list | tuple):
+            as_list = True
+            x = Poly(x, ring = self.gf)
+        if x.degree() >= self.k:
+            raise ValueError(f"Degree can be at most {self.k-1}.")
+        y = [ x(self.alpha**j) for j in range(self.n) ]
+        if as_list:
+            return y + [zero] * (self.n - len(y))
+        return Poly(y)
+
+    def decode(self, y: list|Poly):
+        "Decode a given list or polynomial."
+        as_list = False
+        zero = 0 * self.g[0]
+        one = zero**0
+        if isinstance(y, list | tuple):
+            as_list = True
+            y = Poly(y, ring = self.gf)
+        if y.degree() >= self.n:
+            raise ValueError(f"Degree can be at most {self.n-1}.")
+        x = Poly([ -y(self.alpha**(-j)) for j in range(self.n) ])
+        if x.degree() >= self.k: # No codewort
+            t = (self.n - self.k) // 2
+            A = Matrix([[ x[j - l % self.n] for l in range(1, t+1) ] for j in range(self.k+t, self.k+2*t) ])
+            b = [ -x[self.k + t + l ] for l in range(t) ]
+            lam = Poly([one] + list(A.solve(b)))
+            x_coordinates = []
+            y_coordinates = []
+            for j in range(self.n):
+                if len(x_coordinates) == self.k:
+                    break
+                alphaj = self.alpha**j
+                if lam(alphaj):
+                    x_coordinates.append(alphaj)
+                    y_coordinates.append(y[j])
+            x = lagrange_interpolation(x_coordinates, y_coordinates)
+        if as_list:
+            return x.coeff + [zero] * (self.k - len(x.coeff))
+        return x

{kryptools-1.3.5 → kryptools-1.5}/kryptools/dlp_qs.py

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