kryptools 1.5__tar.gz → 1.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.5
+Version: 1.5.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -16,6 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
+[![Pypi](https://img.shields.io/pypi/v/kryptools)](https://pypi.org/project/kryptools)
+[![PyVersion](https://img.shields.io/pypi/pyversions/kryptools)](https://www.python.org)
+[![License](https://img.shields.io/pypi/l/kryptools)](https://github.com/teschlg/kryptools/blob/main/LICENSE)
+[![Pylint](https://github.com/teschlg/kryptools/actions/workflows/pylint.yml/badge.svg)](https://github.com/teschlg/kryptools/actions/workflows/pylint.yml)
+[![Pytest](https://github.com/teschlg/kryptools/actions/workflows/run_test.yml/badge.svg)](https://github.com/teschlg/kryptools/actions/workflows/run_test.yml)
+
 # kryptools
 Gerald Teschl <Gerald.Teschl@univie.ac.at>
 

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

@@ -1,3 +1,9 @@
+[![Pypi](https://img.shields.io/pypi/v/kryptools)](https://pypi.org/project/kryptools)
+[![PyVersion](https://img.shields.io/pypi/pyversions/kryptools)](https://www.python.org)
+[![License](https://img.shields.io/pypi/l/kryptools)](https://github.com/teschlg/kryptools/blob/main/LICENSE)
+[![Pylint](https://github.com/teschlg/kryptools/actions/workflows/pylint.yml/badge.svg)](https://github.com/teschlg/kryptools/actions/workflows/pylint.yml)
+[![Pytest](https://github.com/teschlg/kryptools/actions/workflows/run_test.yml/badge.svg)](https://github.com/teschlg/kryptools/actions/workflows/run_test.yml)
+
 # kryptools
 Gerald Teschl <Gerald.Teschl@univie.ac.at>
 
@@ -39,4 +45,4 @@ The tools contained are:
 * Keccak: individual sponge operations, SHA3, SHAKE
 
 Documentation can be found in the jupyter notebook
-(mostly done, but might not contain everything: use the force, read the source).
+(mostly done, but might not contain everything: use the force, read the source).

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

@@ -135,7 +135,7 @@ class GF2:
 class GF2nPoint:
     "Represents a point in the Galois field GF(2^n)."
 
-    def __init__(self, x: int, field: "GF2n"):
+    def __init__(self, x: int, field: "GF2"):
         if isinstance(x, bytes | bytearray):
             x = int.from_bytes(x, byteorder=field.byteorder)
         self.x = int(x) % field.order
@@ -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:
@@ -276,25 +278,27 @@ class GF2nPoint:
             x *= x
         return res
 
-    def __lshift__(self, i: int) -> "GF2nPoint":
+    def __lshift__(self, j: int) -> "GF2nPoint":
         "Cyclic rotation to the left."
-        x = self.x << i
+        x = self.x << j
         x = (x % self.field.order) + (x // self.field.order)
         return self.field(x)
 
-    def __rshift__(self, i: int) -> "GF2nPoint":
+    def __rshift__(self, j: int) -> "GF2nPoint":
         "Cyclic rotation to the right."
-        x = self.x >> i
-        x += (self.field.order >> i) * (self.x % 2**i)
+        x = self.x >> j
+        x += (self.field.order >> j) * (self.x % 2**j)
         return self.field(x)
 
     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:
         "Compute the order of the point in the group GF(2^n)^*."
-        self.field._factors()
+        self.field._factors()  # pylint: disable=W0212
         order = self.field.mult_order  # our current guess
         one = self.field.one()
         for p, k in self.field.factors.items():
@@ -316,7 +320,7 @@ class GF2nPoint:
             if inv:
                 return aes_sbox_inv[self.x]
             return aes_sbox[self.x]
-        elif self.field.degree == 4 and self.field.modulus == 0b10011: # MiniAES
+        if self.field.degree == 4 and self.field.modulus == 0b10011: # MiniAES
             if inv:
                 return miniaes_sbox_inv[self.x]
             return miniaes_sbox[self.x]
@@ -349,7 +353,7 @@ for i in range(256):
 aes_sbox = list(map(GF2_aes, aes_sbox))
 aes_sbox_inv = list(map(GF2_aes, aes_sbox_inv))
 
-    
+
 # sbox for Mini-AES
 GF2_miniaes = GF2(4, 0b10011)  # x^4 + x + 1 = Mini-AES
 
@@ -365,4 +369,4 @@ miniaes_sbox_inv = list(map(GF2_miniaes, miniaes_sbox_inv))
 
 #Ghash
 
-GF2_ghash = GF2(128, 0b11100001 << 120)  # 1 + x + x^2 + x^7 (+ x^128) = Ghash
+GF2_ghash = GF2(128, 0b11100001 << 120)  # 1 + x + x^2 + x^7 (+ x^128) = Ghash

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

@@ -267,6 +267,7 @@ class ZmodPoint:
         return order
 
     def sqrt(self) -> "ZmodPoint":
+        "Compute a square root of the point."
         if not self.ring.n_factors:
             self.ring.n_factors = factorint(self.ring.n)
         a = int(self)
@@ -297,7 +298,7 @@ class ZmodPoint:
                     raise ValueError("No quadratic residue!")
                 m = 4 # start at 2^2
                 x = ak % m # this is the root mod m
-                for i in range(3, k + 1):
+                for _ in range(3, k + 1):
                     # test all 4 poosible roots
                     if (x**2 - ak) % (m * 2):
                         x = m - x

{kryptools-1.5 → kryptools-1.5.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.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.2}/kryptools/aes.py

@@ -144,18 +144,18 @@ class AESKeySchedule:
         #RotWord
         tmp = list(self.key[:,3])
         if self.showtmp:
-        	print("Start    :" + str(tmp))
+            print("Start    :" + str(tmp))
         tmp = rotate_left(tmp, 1)
         if self.showtmp:
-        	print("RotWord  :" + str(tmp))
+            print("RotWord  :" + str(tmp))
         #SubWord
         tmp = list(map(lambda x: x.sbox(), tmp))
         if self.showtmp:
-        	print("SubWord  :" + str(tmp))
+            print("SubWord  :" + str(tmp))
         #AddRound constant
         tmp[0] += GF2_aes(2)**(self.round - 1)
         if self.showtmp:
-        	print("AddConst :" + str(tmp))
+            print("AddConst :" + str(tmp))
         tmp = Matrix(tmp)
         self.key[:,0] += tmp
         self.key[:,1] += self.key[:,0]

{kryptools-1.5 → kryptools-1.5.2}/kryptools/blockcipher.py

@@ -50,9 +50,9 @@ class BlockCipher:
         "Encrypt using the given mode."
         if mode is None:
             mode = self.mode
-        try:
+        if hasattr(self, "encrypt_" + mode.lower()):
             method = getattr(self, "encrypt_" + mode.lower())
-        except:
+        else:
             raise ValueError("Unsupported encryption mode: ", mode)
         if key:
             self.set_key(key)
@@ -62,9 +62,9 @@ class BlockCipher:
         "Decrypt using the given mode."
         if mode is None:
             mode = self.mode
-        try:
+        if hasattr(self, "decrypt_" + mode):
             method = getattr(self, "decrypt_" + mode)
-        except:
+        else:
             raise ValueError("Unsupported encryption mode: ", mode)
         if key:
             self.set_key(key)
@@ -218,7 +218,7 @@ class BlockCipher:
             key_extra ^= R_b
 
         pad = len(text) % self.__class__.blocksize
-        if pad or not len(text):
+        if pad or not text:
             # Compute key K2
             text += b'\x80' + b'\x00' * (self.__class__.blocksize - pad - 1)
             msb = key_extra >> (self.__class__.blocksize * 8 - 1)

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

@@ -85,7 +85,7 @@ class Goppa():
 
     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!")
+            raise ValueError("All elements of alpha must be from the Galois field!")
         if not g.rabin_test():
             raise ValueError("The polynomial g must be irreducible!")
         self.gf = gf  # underlying Galois field
@@ -166,16 +166,14 @@ class CyclicCode():
         if n < 2:
             raise ValueError(f"Code lenght {n} must be at least 2!")
         zero = 0 * g[0]
-        try:
+        if hasattr(zero, "ring"):
             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!")
+        elif hasattr(zero, "field"):
+            order = zero.field.order  # GF2
+        elif hasattr(type(zero), "order"):
+            order = type(zero).order  # galois
+        else:
+            raise ValueError("Unknown base field!")
         self.order = order  # order of the base field
         one = zero**0
         modulus = Poly([-one] + [zero] * (n-1) + [one])
@@ -189,7 +187,7 @@ class CyclicCode():
 
     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
@@ -219,7 +217,7 @@ class CyclicCode():
             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.")
+            raise NotImplementedError("Word is no code word! Cannot decode.")
         if systematic_form:
             x.coeff = y.coeff[self.g.degree():]
         if as_list:
@@ -256,24 +254,24 @@ class ReedSolomonCode(CyclicCode):
     [0, 1, 0]
     
     """
-    def __init__(self, k:int, gf, alpha = None):
+    def __init__(self, k:int, gf, alpha = None):  # pylint: disable=W0231
         zero = gf(0)
         one = zero**0
-        self. gf = gf
-        try:
-            n = gf.order()
-        except:
-            n = gf.order - 1
+        self.gf = gf
+        if hasattr(gf, "n"):
+            n = gf.n - 1  # Zmod
+        else:
+            n = gf.order - 1  # GF2|galois
         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:
+            if hasattr(gf, "primitive_element"):
                 alpha = gf.primitive_element  # galois
+            else:
+                alpha = gf.generator()  # Zmod|GF2
         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
@@ -283,7 +281,7 @@ class ReedSolomonCode(CyclicCode):
     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):
+    def encode(self, x: list|Poly):  # pylint: disable=W0221
         "Encode a given list or polynomial."
         as_list = False
         zero = 0 * self.g[0]
@@ -297,7 +295,7 @@ class ReedSolomonCode(CyclicCode):
             return y + [zero] * (self.n - len(y))
         return Poly(y)
 
-    def decode(self, y: list|Poly):
+    def decode(self, y: list|Poly):  # pylint: disable=W0221
         "Decode a given list or polynomial."
         as_list = False
         zero = 0 * self.g[0]
@@ -307,11 +305,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.2}/kryptools/des.py

@@ -171,7 +171,7 @@ class FeistelCipher:
             def printtmp(title: str, a: list) -> None:
                 print(f'{title}: {"".join(map(str,a))}')
         else:
-            def printtmp(title: str, a: list) -> None:
+            def printtmp(title: str, a: list) -> None:  # pylint: disable=W0613
                 pass
         a = permute(a, self.__class__.E_box)  # expansion box
         printtmp("EBox", a)

{kryptools-1.5 → kryptools-1.5.2}/kryptools/dlp_ic.py

@@ -37,7 +37,7 @@ def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int =
                 break
             trys += 1
         else:
-            raise Exception(f"Sorry, Index Calculus failed to find a relation after {trys} trys.")
+            raise RuntimeWarning(f"Sorry, Index Calculus failed to find a relation after {trys} trys.")
         if verbose > 2:
             if include_b:
                 print(f"rel found: b*a^{x}=", b * pow(a, x, n) % n, relation)
@@ -101,7 +101,7 @@ def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int =
             x = (m - relations[index][len_relations]) % m
             if pow(a, x, n) == b:
                 return x
-            raise Exception("Sorry, Index Calculus failed! Either the DLP is not solvable, or the order is not prime or incorrect.")
+            raise RuntimeWarning("Sorry, Index Calculus failed! Either the DLP is not solvable, or the order is not prime or incorrect.")
 
     #
     # Determine the parameters
@@ -111,7 +111,7 @@ def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int =
     factorbase = tuple(p for p in sieve_eratosthenes(B) if gcd(p,n) == 1)  # compute the factorbse
     factorbase_len = len(factorbase)  # length of the factorbase
     if factorbase_len == 0:
-        raise Exception("Sorry, Index Calculus could not find a factorbase!")
+        raise RuntimeWarning("Sorry, Index Calculus could not find a factorbase!")
     smallprimes_len, pollard_k = factorbase_len, None
     if pollard:  # should we speed up trial division with Pollard p-1
         smallprimes_len, pollard_k = determine_trialdivison_bounds(B // 150, factorbase)
@@ -137,4 +137,4 @@ def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int =
         if res:
             return res
 
-    raise Exception("Sorry, Index Calculus could not find enough relations! ({n_relations} - {n_relations_redundant} = {n_relations - n_relations_redundant} out of {len_relations})")
+    raise RuntimeWarning("Sorry, Index Calculus could not find enough relations! ({n_relations} - {n_relations_redundant} = {n_relations - n_relations_redundant} out of {len_relations})")

{kryptools-1.5 → kryptools-1.5.2}/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 to find a new relation after {trys} trys.")
+            raise RuntimeWarning(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)
@@ -160,7 +160,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
             x = (m - relations[index][len_relations]) % m
             if pow(a, x, n) == b:
                 return x
-            raise Exception("Sorry, Quadratic Sieve failed! Either the DLP is not solvable or the order is not prime or incorrect.")
+            raise RuntimeWarning("Sorry, Quadratic Sieve failed! Either the DLP is not solvable or the order is not prime or incorrect.")
 
     #
     # Determine the parameters
@@ -173,7 +173,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     factorbase_log = [log(p) for p in factorbase]  # we add these up to test if a number will probably factor
     factorbase_len = len(factorbase)  # length of the factorbase
     if factorbase_len == 0:
-        raise Exception("Sorry, Index Calculus could not find a factorbase!")
+        raise RuntimeWarning("Sorry, Index Calculus could not find a factorbase!")
     smallprimes_len, pollard_k = factorbase_len, None
     if pollard:  # should we speed up trial division with Pollard p-1
         smallprimes_len, pollard_k = determine_trialdivison_bounds(B // 150, factorbase)
@@ -300,4 +300,4 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                 if res:
                     return res
 
-    raise Exception(f"Sorry, Quadratic sieve could not find enough relations! ({n_relations} - {n_relations_redundant} = {n_relations - n_relations_redundant} out of {len_relations}). Try to increase sieve_factor={sieve_factor}")
+    raise RuntimeWarning(f"Sorry, Quadratic sieve could not find enough relations! ({n_relations} - {n_relations_redundant} = {n_relations - n_relations_redundant} out of {len_relations}). Try to increase sieve_factor={sieve_factor}")

{kryptools-1.5 → kryptools-1.5.2}/kryptools/dlp_rho.py

@@ -59,4 +59,4 @@ def dlog_rho(a: int, b: int, n: int, m: int = None, brent=0) -> int:
                 l += mm
             return l
         trys -= 1
-    raise Exception("Sorry, pollard rho failed!")
+    raise RuntimeWarning("Sorry, pollard rho failed!")

{kryptools-1.5 → kryptools-1.5.2}/kryptools/factor.py

@@ -55,21 +55,22 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
         prime_factors[-1] = 1
 
     def add_factors(m: int, mm: tuple) -> None:
+        "Delete m from remaining factors and add its factors mm to the appropriate dict."
         k = remaining_factors[m]
         del remaining_factors[m]
 
-        for m in mm:
-            if m in prime_factors:
-                prime_factors[m] += k
-            elif is_prime(m, trialdivision=False):
-                prime_factors[m] = k
+        for m_i in mm:
+            if m_i in prime_factors:
+                prime_factors[m_i] += k
+            elif is_prime(m_i, trialdivision=False):
+                prime_factors[m_i] = k
             else:
-                if m in remaining_factors:
-                    remaining_factors[m] += k
-                elif m in new_factors:
-                    new_factors[m] += k
+                if m_i in remaining_factors:
+                    remaining_factors[m_i] += k
+                elif m_i in new_factors:
+                    new_factors[m_i] += k
                 else:
-                    new_factors[m] = k
+                    new_factors[m_i] = k
 
     if verbose:
         print(f"Factoring: {n} ({floor(log10(n)) + 1} digits)")
@@ -92,7 +93,7 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
     if res:
         n, k = res
     else:
-        n, k = n, 1
+        k = 1
     if is_prime(n, trialdivision=False):
         prime_factors[n] = k
         return prime_factors
@@ -114,7 +115,7 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
     ]
     fermat_steps = 10
 
-    for round, parameters in enumerate(ECM_PARAMETERS):
+    for nr, parameters in enumerate(ECM_PARAMETERS):
         fermat_steps += 10
         B1, B2, num_curves = parameters
         p_max = isqrt(max(remaining_factors))+1
@@ -126,7 +127,7 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
         D = isqrt(B2)
 
         if verbose:
-            print(f"Round {round+1} (B1={B1})")
+            print(f"Round {nr+1} (B1={B1})")
 
         primes = sieve_eratosthenes(B1 - 1 + ((B2 - B1 + 1) // (2 * D) + 1) * 2 * D)
         pm1_parameters = tuple([10 * B1, B2] + list(_pm1_parameters(10 * B1, B2, primes=primes)))
@@ -135,14 +136,14 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
         methods = {_factor_fermat: "fmt", factor_pm1: "pm1", factor_ecm: "ecm"}  #, factor_qs: "qs"}
         while remaining_factors:
             new_factors = {}
-            for method in methods:
-                factors = list(remaining_factors)
+            for method, method_name in methods.items():
+                factors = list(remaining_factors) # make a copy to avoid a runtime error if the dict changes
                 for m in factors:
-                    if method == _factor_fermat:
+                    if method == _factor_fermat:  # pylint: disable=W0143
                         tmp = _factor_fermat(m, maxsteps=fermat_steps, verbose=max(0, verbose - 1))
-                    elif method == factor_pm1:
+                    elif method == factor_pm1:  # pylint: disable=W0143
                         tmp = factor_pm1(m, pm1_parameters=pm1_parameters, verbose=max(0, verbose - 1))
-                    elif method == factor_ecm:
+                    elif method == factor_ecm:  # pylint: disable=W0143
                         tmp = factor_ecm(m, ecm_parameters=ecm_parameters, verbose=max(0, verbose - 1))
                     else:
                         tmp = method(m, verbose=max(0, verbose - 1))
@@ -160,16 +161,18 @@ def factorint(n: int, trial_bnd: int = 2500, verbose: int = 0) -> dict:
                                     tmp3.append(x)
                         else:
                             tmp3 = [tmp, tmp2]
-                        if verbose > 0: print(f"Factors found ({methods[method]}): ", tmp3)
+                        if verbose > 0:
+                            print(f"Factors found ({method_name}): ", tmp3)
                         add_factors(m, tmp3)
             if not new_factors:
                 break
-            for m in new_factors:
+            for m, k in new_factors.items():
                 if m in remaining_factors:
-                    remaining_factors[m] += new_factors[m]
+                    remaining_factors[m] += k
                 else:
-                    remaining_factors[m] = new_factors[m]
-            if verbose > 1: print("Remaining: ", remaining_factors)
+                    remaining_factors[m] = k
+            if verbose > 1:
+                print("Remaining: ", remaining_factors)
 
         if len(remaining_factors) == 0:
             return prime_factors
@@ -190,7 +193,7 @@ def divisors(n:int, proper:bool = False) -> int:
     if n <= 1:
         return divisor_list
     facctordict= factorint(n)
-    primes = [p for p in facctordict]
+    primes = list(facctordict)
     nprimes = len(primes)
     multiplicites = [facctordict[p] for p in primes]
 

{kryptools-1.5 → kryptools-1.5.2}/kryptools/factor_qs.py

@@ -9,7 +9,7 @@ from .nt import legendre_symbol, sqrt_mod
 
 def bytexor(a: bytearray, b: bytes) -> bytes:
     """Xor the bytestring `b` to the bytearry `a`."""
-    for i in range(len(a)):
+    for i in range(len(a)):  # pylint: disable=C0200
         a[i] ^= b[i]
 
 

{kryptools-1.5 → kryptools-1.5.2}/kryptools/keccak.py

@@ -160,16 +160,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)
+            raise ValueError("n must be one of: 224, 256, 384, 512")
+        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."
@@ -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():
     """
@@ -197,11 +206,23 @@ class SHAKE():
 
     def __init__(self, msg: bytes | str, n: int = 128) -> None:
         if n not in (128, 256):
-            raise ValueError(f"n must be one of: 128, 256")
+            raise ValueError("n must be one of: 128, 256")
         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.2}/kryptools/la.py

@@ -50,7 +50,7 @@ class Matrix:
             out[i] += self.__class__.print_post
         return '\n'.join(out)
 
-    def _repr_mimebundle_(self, **kwargs):
+    def _repr_mimebundle_(self, **kwargs):  # pylint: disable=W0613
         return {
             "text/plain": repr(self),
             "text/latex": "$\\displaystyle" + self.latex() + "$"
@@ -137,11 +137,11 @@ class Matrix:
             if len(cols) == self.cols:
                 self.delete_rows(rows)
                 return
-            elif len(rows) == self.rows:
+            if len(rows) == self.rows:
                 self.delete_columns(cols)
                 return
         raise ValueError("Can only delete entire rows or entire columns!")
-            
+
     def delete_rows(self, rows: int|list) -> None:
         "Deletes a row or a list of rows."
         if isinstance(rows, int):
@@ -153,7 +153,7 @@ class Matrix:
         for i in reversed(sorted(rows)):
             del self.matrix[i]
         self.rows -= len(rows)
-    
+
     def delete_columns(self, cols: int|list) -> None:
         "Deletes a column or a list of columns."
         if isinstance(cols, int):
@@ -166,7 +166,7 @@ class Matrix:
             for j in reversed(sorted(cols)):
                 del self.matrix[i][j]
         self.cols -= len(cols)
-    
+
     def append_row(self, row: list|tuple, ring = None) -> None:
         "Append a row."
         if not isinstance(row, list|tuple) or len(row) != self.cols: