kryptools 1.1__tar.gz → 1.2__tar.gz

{kryptools-1.1 → kryptools-1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.1
+Version: 1.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -49,10 +49,8 @@ The tools contained are:
 * AESCipher: individual AES operations
 * DESCipher: individual DES operations
 
-* SHA1
-* Keccak individual sponge operations
-* SHA3
-* SHAKE
+* SHA1: custom initial state, padding function
+* 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).

{kryptools-1.1 → kryptools-1.2}/README.md

@@ -31,10 +31,8 @@ The tools contained are:
 * AESCipher: individual AES operations
 * DESCipher: individual DES operations
 
-* SHA1
-* Keccak individual sponge operations
-* SHA3
-* SHAKE
+* SHA1: custom initial state, padding function
+* 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).

kryptools-1.2/kryptools/GF2.py

@@ -0,0 +1,351 @@
+"""
+Galois field GF(2^n).
+"""
+
+from math import gcd
+from .poly import Poly
+from .Zmod import Zmod
+from .factor import factorint
+from .conway_polynomials import conway_polynomials2
+
+
+class GF2:
+    """
+    Create a Galois field GF(2^n).
+
+    Elements of a Galois filed are specified by integers from 0 to 2**n-1, which are
+    identified with polynomials whose coefficients are the binary digits of the integer.
+    Multiplication is polynomial multiplication modulo a given irreducible polynomial.
+    If the polynomial has the n'th bit set, the lowest bit corresponds to the constant coefficient
+    (like in AES). Otherwise, the bit order is reversed (like for Ghash). The default modulus is
+    choosen from a list of Conway polynomials.
+
+    Example:
+
+    To define the Galois field GF(2^8) use
+    >>> gf=GF2(8)
+
+    To declare 3 as an element of our Galois field use (elements are displayed as hex numbers)
+    >>> gf(3)
+    03
+
+    The usual arithmetic operations are supported.
+    >>> gf(2) * gf(123)
+    f6
+
+    """
+    def __init__(self, n: int, modulus: int | None = None):
+        if not isinstance(n, int) or n < 1:
+            raise ValueError(f"{n} is not a positive integer.")
+        if not modulus:
+            if n in conway_polynomials2:
+                modulus = conway_polynomials2[n]
+            else:
+                raise ValueError("Unknown power. 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.order = 2**n  # 2**n
+        self.print_hex: bool = True
+        self.byteorder: str = "big"  # big|little
+        self.mult_order = self.order -1
+        self.factors = {}  # factoring of the group order
+
+    def __repr__(self):
+        return f"GF(2^{self.power})"
+
+    def __call__(self, x: int | list | tuple):
+        if isinstance(x, list|tuple):
+            return [GF2nPoint(xx, self) for xx in x]
+        return GF2nPoint(x, self)
+
+    def __iter__(self):
+        for x in range(self.order):
+            yield GF2nPoint(x, self)
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.order == other.order and self.modulus == other.modulus
+        return False
+
+    def __contains__(self, other: "ZmodPoint") -> bool:
+        return isinstance(other, GF2nPoint) and self == other.field
+
+    def _factors(self) -> dict:
+        "Return the factroization order of the group order of GF(2^n)^*."
+        if not self.factors:
+            self.factors = factorint(self.mult_order)
+        return self.factors
+
+    def one(self) -> bool:
+        "Return one."
+        if self.bitreversed:
+            return self(self.order - 1)
+        return self(1)
+
+    def is_cyclic(self) -> bool:
+        "GF(2^n)^* is cyclic."
+        return True
+
+    def is_field(self) -> bool:
+        "GF(2^n) is a field."
+        return True
+
+    def generator(self) -> int | None:
+        "Return a generator of the group GF(2^n)^*."
+        for a in range(2, self.order):
+            a = self(a)
+            if a.is_generator():
+                return a
+
+    def generators(self) -> list | None:
+        "Return a generator for all generators of the group GF(2^n)^*."
+        a = self.generator()
+        if a is not None:
+            for j in range(1, self.mult_order):
+                if gcd(j, self.mult_order) == 1:
+                    yield a**j
+
+    def star(self) -> list:
+        "Return a generator for all elements of the group GF(2^n)n^*."
+        for x in range(1, self.order):
+            yield self(x)
+
+
+class GF2nPoint:
+    "Represents a point in the Galois field GF(2^n)."
+
+    def __init__(self, x: int, field: "GF2n"):
+        if isinstance(x, bytes | bytearray):
+            x = int.from_bytes(x, byteorder=field.byteorder)
+        self.x = int(x) % field.order
+        self.field = field
+
+    def __repr__(self):
+        if self.field.print_hex:
+            return format(self.x, "0"+str(self.field.power // 4)+"x")
+        return self.x
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__) or self.field != other.field:
+            return False
+        return self.x == other.x
+
+    def __bool__(self):
+        return bool(self.x)
+
+    def __int__(self):
+        return self.x
+
+    def __bytes__(self):
+        return self.x.to_bytes(self.field.power // 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"))]
+        else:
+            coeff = reversed([int(d) for d in str(
+                format(self.x, "0" + str(self.field.power) + "b"))])
+        return list(coeff)
+
+    def poly(self) -> "Poly":
+        "Convert to a polynomial."
+        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"))]
+            coeff_modulus = [Z_2(int(d)) for d in str(
+                format((self.field.modulus << 1) + 1, "0" + str(self.field.power) + "b"))]
+        else:
+            coeff = reversed([Z_2(int(d)) for d in str(
+                format(self.x, "0" + str(self.field.power) + "b"))])
+            coeff_modulus = reversed([Z_2(int(d)) for d in str(
+                format(self.field.modulus, "0" + str(self.field.power) + "b"))])
+        return Poly(list(coeff), modulus=list(coeff_modulus))
+
+    def __hash__(self):
+        return hash(self.x)
+
+    def __add__(self, other: "GF2nPoint") -> "GF2nPoint":
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        if self.field != other.field:
+            raise NotImplementedError("Cannot add elements from different fields.")
+        return self.field(self.x ^ other.x)
+
+    def __neg__(self) -> "GF2nPoint":
+        return self
+
+    def __pos__(self) -> "GF2nPoint":
+        return self
+
+    def __sub__(self, other: "GF2nPoint") -> "GF2nPoint":
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        if self.field != other.field:
+            raise NotImplementedError("Cannot add elements from different fields.")
+        return self.field(self.x ^ other.x)
+
+    def __mul__(self, other: "GF2nPoint") -> "GF2nPoint":
+        if isinstance(other, int):
+            if other % 2:
+                return self
+            return self.field(0)
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        if self.field != other.field:
+            raise NotImplementedError("Cannot add elements from different fields.")
+        z = 0
+        y = other.x
+        if self.field.bitreversed:
+            for d in bin(self.x)[2:].zfill(self.field.power):
+                if int(d):
+                    z ^= y
+                if y % 2:
+                    y >>= 1
+                    y ^= self.field.modulus
+                else:
+                    y >>= 1
+        else:
+            bitmap1 = self.field.order
+            bitmap2 = 1
+            for _ in range(self.field.power):
+                if self.x & bitmap2:
+                    z ^= y
+                bitmap2 <<= 1
+                y <<= 1
+                if y & bitmap1:
+                    y ^= self.field.modulus
+        return self.field(z)
+
+    def __rmul__(self, scalar: int) -> "GF2nPoint":
+        if isinstance(scalar, int):
+            if scalar % 2:
+                return self
+            return self.field(0)
+        return NotImplemented
+
+    def __truediv__(self, other: "GF2nPoint") -> "GF2nPoint":
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+        if self.field != other.field:
+            raise NotImplementedError("Cannot add elements from different fields.")
+        if not other.x:
+            raise ValueError("Division by zero.")
+        return self * other**(self.field.order - 2)
+
+    def __pow__(self, j: int) -> "GF2nPoint":
+        if not isinstance(j, int):
+            return NotImplemented
+        if not (self.x) and j < 0:
+            raise ValueError("Division by zero.")
+        if self.field.bitreversed:
+            res = self.field(self.field.order >> 1)
+        else:
+            res = self.field(1)
+        x = self.field(self.x)
+        j %= self.field.order - 1
+        while j > 0:
+            # If j is odd, multiply with x
+            if j & 1:
+                res *= x
+            # Now square
+            j = j >> 1  # j= j/2
+            x *= x
+        return res
+
+    def __lshift__(self, i: int) -> "GF2nPoint":
+        "Cyclic rotation to the left."
+        x = self.x << i
+        x = (x % self.field.order) + (x // self.field.order)
+        return self.field(x)
+
+    def __rshift__(self, i: int) -> "GF2nPoint":
+        "Cyclic rotation to the right."
+        x = self.x >> i
+        x += (self.field.order >> i) * (self.x % 2**i)
+        return self.field(x)
+
+    def sqrt(self) -> "GF2nPoint":
+        "Compute the square root."
+        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()
+        order = self.field.mult_order  # our current guess
+        one = self.field.one()
+        for p, k in self.field.factors.items():
+            for _ in range(k):
+                order_try = order // p
+                if self ** order_try == one:
+                    order = order_try
+                else:
+                    break
+        return order
+
+    def is_generator(self):
+        "Test if the point is a generator of the group GF(2^n)^*."
+        return self.field.mult_order == self.order()
+
+    def sbox(self, inv: bool = False) -> "GF2nPoint":
+        "Apply the AES sbox."
+        if self.field.power == 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
+            if inv:
+                return miniaes_sbox_inv[self.x]
+            return miniaes_sbox[self.x]
+        raise ValueError("sbox is only availaible for AES/MiniAES field.")
+
+# sbox for AES
+GF2_aes = GF2(8, 0b100011011)  # x^8 + x^4 + x^3 + x + 1 = AES
+
+aes_sbox = [99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118,
+ 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192,
+ 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21,
+ 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9,
+ 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83,
+ 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208,
+ 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81,
+ 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205,
+ 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96,
+ 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224,
+ 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231,
+ 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186,
+ 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112,
+ 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225,
+ 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140,
+ 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22]
+
+# inverse sbox for AES
+aes_sbox_inv = [ 0 for i in range(256) ]
+for i in range(256):
+    aes_sbox_inv[aes_sbox[i]] = i
+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
+
+miniaes_sbox = [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7]
+
+# inverse sbox for MiniAES
+miniaes_sbox_inv = [ 0 for i in range(16) ]
+for i in range(16):
+    miniaes_sbox_inv[miniaes_sbox[i]] = i
+
+miniaes_sbox = list(map(GF2_miniaes, miniaes_sbox))
+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

{kryptools-1.1 → kryptools-1.2}/kryptools/Zmod.py

@@ -4,6 +4,7 @@ Ring of intergers modulo `n`.
 
 from math import gcd
 from .factor import factorint
+from .primes import is_prime
 from .intfuncs import prime_power
 
 
@@ -33,11 +34,12 @@ class Zmod:
         self.group_order = 0
         self.factors = {}  # factoring of the group order
 
+    def __repr__(self):
+        return f"Z_{self.n})"
+
     def __call__(self, x: int | list | tuple):
-        if isinstance(x, list):
+        if isinstance(x, list|tuple):
             return [ZmodPoint(xx, self) for xx in x]
-        if isinstance(x, tuple):
-            return (ZmodPoint(xx, self) for xx in x)
         return ZmodPoint(x, self)
 
     def __iter__(self):
@@ -53,7 +55,7 @@ class Zmod:
         return isinstance(other, ZmodPoint) and self.n == other.ring.n
 
     def order(self) -> int:
-        """Compute the order of the group Z_n^*."""
+        "Compute the order of the group Z_n^*."
         if self.group_order:
             return self.group_order
         # We compute euler_phi(n) and its factorization in one pass
@@ -76,7 +78,7 @@ class Zmod:
         return self.group_order
 
     def is_cyclic(self) -> bool:
-        """Test if the group Z_n^* is cyclic."""
+        "Test if the group Z_n^* is cyclic."
         n = self.n
         if n < 8:
             return True
@@ -88,8 +90,12 @@ class Zmod:
             return True
         return False
 
+    def is_field(self) -> bool:
+        "Test if Z_n is a field."
+        return is_prime(self.n)
+
     def generator(self) -> int | None:
-        """Return a generator of the group Z_n^*."""
+        "Return a generator of the group Z_n^*."
         if not self.is_cyclic():
             return None
         for a in range(2, self.n):
@@ -100,7 +106,7 @@ class Zmod:
                 return a
 
     def generators(self) -> list | None:
-        """Return a generator for all generators of the group Z_n^*."""
+        "Return a generator for all generators of the group Z_n^*."
         a = self.generator()
         if a is not None:
             self.order()
@@ -109,7 +115,7 @@ class Zmod:
                     yield a**j
 
     def star(self) -> list:
-        """Return a generator for all elements of the group Z_n^*."""
+        "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:
@@ -210,7 +216,7 @@ class ZmodPoint:
         return (self.x + tmp) % self.ring.n - tmp
 
     def order(self) -> int:
-        """Compute the order of the point in the group Z_n^*."""
+        "Compute the order of the point in the group Z_n^*."
         if self.x == 0 or gcd(self.x, self.ring.n) != 1:
             raise ValueError(f"{self.x} and {self.ring.n} are not coprime!")
         order = self.ring.order()  # use euler_phi(n) as our current guess
@@ -224,5 +230,5 @@ class ZmodPoint:
         return order
 
     def is_generator(self):
-        """Test if the point is a generator of the group Z_n^*."""
+        "Test if the point is a generator of the group Z_n^*."
         return self.ring.order() == self.order()

{kryptools-1.1 → kryptools-1.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.1"
+__version__ = "1.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.1 → kryptools-1.2}/kryptools/aes.py

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

{kryptools-1.1 → kryptools-1.2}/kryptools/des.py

@@ -168,10 +168,10 @@ class FeistelCipher:
     def f_box(self, a: list[int], key: list[int], showtmp:bool = False) -> list[int]:
         "Nonlinear f-box"
         if showtmp:
-            def printtmp(title:str, a: list) -> None:
+            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:
                 pass
         a = permute(a, self.__class__.E_box)  # expansion box
         printtmp("EBox", a)

{kryptools-1.1 → kryptools-1.2}/kryptools/dlp.py

@@ -12,7 +12,7 @@ from .factor import factorint
 
 
 def dlog_naive(a: int, b: int, n: int, m: int = None, verbose: int = 0) -> int | None:
-    """Compute the discrete log_a(b) in Z_n of an element a of order m by exhaustive search."""
+    """Compute the discrete log_a(b) in Z_n of an element `a` of order `m` by exhaustive search."""
     a %= n
     b %= n
     if not m:
@@ -35,7 +35,7 @@ def dlog_naive(a: int, b: int, n: int, m: int = None, verbose: int = 0) -> int |
 
 
 def _dlog_switch(a: int, b: int, n: int, m: int, verbose: int = 0) -> int:
-    """Compute the discrete log_a(b) in Z_n of an element a of order m choosing an appropriate method."""
+    """Compute the discrete log_a(b) in Z_n of an element `a` of order `m` choosing an appropriate method."""
     if m < 1000:
         if verbose > 1:
             print(f"Naive search: {a}^x = {b} (order={m})")
@@ -51,7 +51,7 @@ def _dlog_switch(a: int, b: int, n: int, m: int, verbose: int = 0) -> int:
 
 
 def _dlog_ph(a: int, b: int, n: int, q: int, k: int, verbose: int = 0) -> int:
-    """Compute the discrete log_a(b) in Z_n of an element a of order q^k using Pohlig-Hellman reduction."""
+    """Compute the discrete log_a(b) in Z_n of an element `a` of order `q^k` using Pohlig-Hellman reduction."""
     if verbose > 1:
         print(f"PH reduction: {a}^x = {b} (order={q}^{k})")
     if k == 1 or q**k < 10000:

{kryptools-1.1 → kryptools-1.2}/kryptools/dlp_bsgs.py

@@ -6,7 +6,7 @@ from math import isqrt
 
 
 def dlog_bsgs(a: int, b: int, n: int, m: int = None, verbose: int = 0) -> int:
-    """Compute the discrete log_a(b) in Z_n of an element a of order m using Shanks' baby-step-giant-step algorithm."""
+    """Compute the discrete log_a(b) in Z_n of an element `a` of order `m` using Shanks' baby-step-giant-step algorithm."""
     a %= n
     b %= n
     if not m:

{kryptools-1.1 → kryptools-1.2}/kryptools/dlp_ic.py

@@ -10,7 +10,7 @@ seed(0)
 
 
 def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int = 0) -> int:
-    """Compute the discrete log_a(b) in Z_p of an element a of prime order m using Index Calculus."""
+    """Compute the discrete log_a(b) in Z_p of an element `a` of prime order `m` using Index Calculus."""
 
     # assert is_prime(m), "The order of a must be prime."
     # assert order(a, n) == m, "The order of a is incorrect."

{kryptools-1.1 → kryptools-1.2}/kryptools/dlp_qs.py

@@ -10,7 +10,7 @@ seed(0)
 
 
 def determine_factorbound(n: int) -> (int, int):
-    """Determines the optimal factor bound and the expected number of trys until a for a given n."""
+    """Determines the optimal factor bound and the expected number of trys until a relation is found for a given `n`."""
     # Choosing B=p^(1/u) Canfield-Erdös-Pomerance gives us the expected running time |factorbase|^2 u^u = u^(u+2) n^(2/u)/log(n).
     # There is no explicit expression for the optimum, hence we use Newton
     u = 2 * sqrt(log(n) / log(log(n)))  # asymptotic value
@@ -47,7 +47,7 @@ def determine_trialdivison_bounds(B: int, factorbase: list) -> (int, int):
 
 
 def is_smooth(n: int, factorbase: list, factorbase_len: int, smallprimes_len: int, pollard_k: int = None) -> list or None:
-    """Try to factor n with respect to a a given factorbase. Upon success a list of exponents with repect to the factorbase is returned. Otherwise None."""
+    """Try to factor `n` with respect to a given factorbase. Upon success a list of exponents with repect to the factorbase is returned. Otherwise None."""
     # factorbase_len = len(factorbase)
     factors = [0] * factorbase_len
     for i in range(smallprimes_len):
@@ -70,7 +70,7 @@ def is_smooth(n: int, factorbase: list, factorbase_len: int, smallprimes_len: in
 
 def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor: float = None, verbose: int = 0) -> int:
     """
-    Compute the discrete log_a(b) in Z_p of an element a of prime order m using Index Calculus with a quadratic sieve.
+    Compute the discrete log_a(b) in Z_p of an element `a` of prime order `m` using Index Calculus with a quadratic sieve.
     The problem is assumed solvable.
     """
     # assert is_prime(m), "The order of a must be prime."

{kryptools-1.1 → kryptools-1.2}/kryptools/dlp_rho.py

@@ -7,7 +7,7 @@ from random import randint
 
 
 def dlog_rho(a: int, b: int, n: int, m: int = None, brent=0) -> int:
-    """Compute the discrete log_a(b) in Z_p of an element a of order m using Pollard's rho algorithm."""
+    """Compute the discrete log_a(b) in Z_p of an element `a` of order `m` using Pollard's rho algorithm."""
     a %= n
     b %= n
     if not m:

{kryptools-1.1 → kryptools-1.2}/kryptools/factor_dix.py

@@ -9,7 +9,7 @@ from .factor_qs import bytexor, byteset, bytetest
 
 
 def is_smooth(n: int, factorbase: list, lfb: int) -> bytes | None:
-    """Try to factor n with respect to a given factorbase.
+    """Try to factor `n` with respect to a given factorbase.
     Upon success a bytestring, whose bits are the exponents with repect to the factorbase mod 2, is returned.
     Otherwise None."""
     factors = bytearray(b"\x00") * lfb  # we store the exponents mod 2 as bits
@@ -29,7 +29,7 @@ def is_smooth(n: int, factorbase: list, lfb: int) -> bytes | None:
 
 
 def factor_dixon(n: int) -> int | None:
-    """Find factors of n using the method of Dixon."""
+    """Find factors of `n` using the method of Dixon."""
     # first determine the bound B for the factorbase: Choosing B=p^(1/u) Canfield-Erdös-Pomerance gives us
     # the expected running time |B|^2 u^u = u^(u+2) p^(2/u)/log(n). There is no explicit expression for the optimum, hence
     # we use Newton
@@ -55,6 +55,7 @@ def factor_dixon(n: int) -> int | None:
     m = isqrt(n - 1) + 1
 
     def process_relation(j: int, relation: bytes):
+        "Add a relation to the linear system and reduce the new system."
         nonlocal relation_no, values, relations
         relation_no += 1
         # construct the k'th row of the identity matrix

{kryptools-1.1 → kryptools-1.2}/kryptools/factor_ecm.py

@@ -89,7 +89,7 @@ def _ecm_parameters(B1: int, B2: int | None = None, D: int | None = None, primes
 
 
 def factor_ecm(n: int, B1: int | None = None, B2: int | None = None, curves: int = 150, ecm_parameters: tuple | None = None, verbose: int = 0) -> int | None:
-    "Factors a number n using Lentsta's ECM method."
+    "Factors a number `n` using Lentsta's ECM method."
 
     if ecm_parameters:
         B1, B2, curves, D, stage_one, stage_two_deltas = ecm_parameters

{kryptools-1.1 → kryptools-1.2}/kryptools/factor_fmt.py

@@ -6,7 +6,7 @@ from math import isqrt, floor, log10
 
 
 def factor_fermat(n: int, maxsteps: int | None = None, verbose: int = 0) -> list:
-    """Find factors of n using the method of Fermat."""
+    """Find factors of `n` using the method of Fermat."""
     if not isinstance(n, int) or n < 1:
         raise ValueError("Number to be factored must be a positive integer!")
     if verbose:

{kryptools-1.1 → kryptools-1.2}/kryptools/factor_pm1.py

@@ -27,7 +27,7 @@ def _pm1_parameters(B1: int, B2: int, primes: tuple = None) -> tuple:
 
 
 def factor_pm1(n: int, B1: int | None = None, B2: int | None = None, x: int = 2, pm1_parameters: tuple = None, verbose: int = 0) -> int | None:
-    "Factors a number n using Pollard's p-1 method."
+    "Factors a number `n` using Pollard's p-1 method."
     if pm1_parameters:
         B1, B2, stage_one, stage_two_deltas = pm1_parameters
     else: