kryptools 0.3__tar.gz → 0.5__tar.gz

{kryptools-0.3 → kryptools-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.3
+Version: 0.5
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools
@@ -9,7 +9,7 @@ Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -27,7 +27,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.3 → kryptools-0.5}/README.md

@@ -12,7 +12,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

kryptools-0.5/kryptools/Zmod.py

@@ -0,0 +1,175 @@
+"""
+Ring of intergers modulo `n`.
+"""
+
+from math import gcd
+from .factor import factorint
+
+
+class Zmod:
+    """
+    Ring of intergers modulo `n`.
+
+    Example:
+    
+    To define a finite Galois field modulo the prime 5 use
+    >>> gf=Zmod(5)
+    
+    To declare 3 as an element of our Galois filed use
+    >>> gf(3)
+    3 (mod 5)
+
+    The usual arithmetic operations are supported.
+    >>> gf(2) + gf(3)
+    0 (mod 5)
+    """
+
+    def __init__(self, n: int, short: bool = True):
+        self.n = n
+        self.short = short
+        self.group_order = 0
+        self.factors = {} # factoring of the group order
+
+    def __call__(self, x: int):
+        return ZmodPoint(x, self)
+
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            return self.n == other.n
+        return False
+
+    def __contains__(self, other: "ZmodPoint") -> bool:
+        return isinstance(other, ZmodPoint) and self.n == other.ring.n
+
+    def order(self) -> int:
+        """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
+        for p, k in factorint(self.n).items():  # first factorize n
+            for pm, km in factorint(p - 1).items():  # factor p-1 and add the factors
+                if pm in self.factors:
+                    self.factors[pm] += km
+                else:
+                    self.factors[pm] = km
+            if k > 1:  # if the multiplicity of of p is >1, then we need to add p**(k-1)
+                if p in self.factors:
+                    self.factors[p] += k - 1
+                else:
+                    self.factors[p] = k - 1
+        self.group_order = 1
+        for p, k in self.factors.items():
+            self.group_order *= p**k
+        return self.group_order
+
+
+class ZmodPoint:
+    "Represents a point in the ring Zmod."
+
+    def __init__(self, x: int, ring: "Zmod"):
+        self.x = int(x) % ring.n
+        self.ring = ring
+
+    def __repr__(self):
+        if self.ring.short:
+            return str(self.x)
+        return f"{self.x} (mod {self.ring.n})"
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__) or self.ring != other.ring:
+            return False
+        return self.x == other.x
+
+    def __bool__(self):
+        return self.x != 0
+
+    def __int__(self):
+        return self.x
+
+    def __hash__(self):
+        return hash(self.x)
+
+    def __add__(self, other: "ZmodPoint") -> "ZmodPoint":
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot add elements from different rings.")
+            return self.__class__(self.x + other.x, self.ring)
+        if isinstance(other, int):
+            return self.__class__(self.x + other, self.ring)
+        return NotImplemented
+
+    def __radd__(self, scalar: int) -> "ZmodPoint":
+        if isinstance(scalar, int):
+            return self.__class__(scalar + self.x, self.ring)
+        return NotImplemented
+
+    def __neg__(self) -> "ZmodPoint":
+        return self.__class__(-self.x, self.ring)
+
+    def __sub__(self, other: "ZmodPoint") -> "ZmodPoint":
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot subtract elements from different rings.")
+            return self.__class__(self.x - other.x, self.ring)
+        if isinstance(other, int):
+            return self.__class__(self.x - other, self.ring)
+        return NotImplemented
+
+    def __rsub__(self, scalar: int) -> "ZmodPoint":
+        if isinstance(scalar, int):
+            return self.__class__(scalar - self.x, self.ring)
+        return NotImplemented
+
+    def __mul__(self, other: "ZmodPoint") -> "ZmodPoint":
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot multiply elements from different rings.")
+            return self.__class__(self.x * other.x, self.ring)
+        if isinstance(other, int):
+            return self.__class__(self.x * other, self.ring)
+        return NotImplemented
+
+    def __rmul__(self, scalar: int) -> "ZmodPoint":
+        if isinstance(scalar, int):
+            return self.__class__(scalar * self.x, self.ring)
+        return NotImplemented
+
+    def __truediv__(self, other: "ZmodPoint") -> "ZmodPoint":
+        if isinstance(other, self.__class__):
+            if self.ring != other.ring:
+                raise NotImplementedError("Cannot divide elements from different rings.")
+            return self.__class__(self.x * pow(other.x, -1, self.ring.n), self.ring)
+        return NotImplemented
+
+    def __rtruediv__(self, scalar: int) -> "ZmodPoint":
+        if isinstance(scalar, int):
+            return self.__class__(scalar * pow(self.x, -1, self.ring.n), self.ring)
+        return NotImplemented
+
+    def __pow__(self, scalar: int) -> "ZmodPoint":
+        if isinstance(scalar, int):
+            return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)
+        return NotImplemented
+
+    def sharp(self):
+        "Returns a symmetric (w.r.t. 0) representative."
+        tmp = (self.ring.n - 1) // 2
+        return (self.x + tmp) % self.ring.n - tmp
+
+    def order(self) -> int:
+        """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
+        for p, k in self.ring.factors.items():
+            for _ in range(k):
+                order_try = order // p
+                if pow(self.x, order_try, self.ring.n) == 1:
+                    order = order_try
+                else:
+                    break
+        return order
+
+    def is_generator(self):
+        """Test if the point is a generator of the group Z_n^*."""
+        return self.ring.order() == self.order()

{kryptools-0.3 → kryptools-0.5}/kryptools/__init__.py

@@ -2,8 +2,8 @@
 Implemenation of same basic algorithms used in cryptography.
 """
 
-from .nt import cf, convergents, jacobi_symbol, sqrt_mod, euler_phi, order, carmichael_lambda
-from .primes import sieve_eratosthenes, isprime
+from .nt import egcd, crt, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, order, carmichael_lambda
+from .primes import sieve_eratosthenes, is_prime, next_prime, random_prime, random_strongprime, is_safeprime, random_safeprime
 from .factor import factorint
 from .dlp import dlog
 from .ec import EC_Weierstrass

{kryptools-0.3 → kryptools-0.5}/kryptools/dlp.py

@@ -11,7 +11,7 @@ from .dlp_qs import dlog_qs
 from .factor import factorint
 
 
-def dlog_naive(a: int, b: int, n: int, m: int = None) -> int:
+def dlog_naive(a: int, b: int, n: int, m: int = None) -> int|None:
     """Compute the discrete log_a(b) in Z_n of an element a of order m by exhaustive search."""
     a %= n
     b %= n
@@ -43,14 +43,14 @@ def _dlog_ph(a: int, b: int, n: int, q: int, k: int) -> int:
     for j in range(2, k + 1):
         aj = pow(a, q ** (k - j), n)
         bj = pow(b, q ** (k - j), n)
-        yj = _dlog_switch(a1, bj * pow(aj, -xj, n) % n, n, q)
+        yj = _dlog_switch(a1, bj * pow(aj, -xj, n) % n, n, q)  # pylint: disable=E1130
         if yj is None:
             return None
         xj = xj + q ** (j - 1) * yj % q**j
     return xj
 
 
-def dlog(a: int, b: int, n: int, m: int = None) -> int:
+def dlog(a: int, b: int, n: int, m: int|None = None) -> int:
     """Compute the discrete log_a(b) in Z_n of an element a of order m using Pohlig-Hellman reduction."""
     a %= n
     b %= n
@@ -60,7 +60,8 @@ def dlog(a: int, b: int, n: int, m: int = None) -> int:
         mf = factorint(m)
     else:
         m, mf = order(a, n, True)
-    assert pow(b, m, n) == 1, "DLP not solvable."
+    if pow(b, m, n) != 1:
+        raise ValueError("DLP not solvable.")
     # We first use Pohlig-Hellman to split m into powers of prime factors
     mm = []
     ll = []

{kryptools-0.3 → kryptools-0.5}/kryptools/dlp_qs.py

@@ -227,7 +227,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                 if r == 0:
                     roots = [ -(inv2 * aa) % p ]  # one root
                 else:
-                    roots = [ (inv2 * (r - aa)) % p, (inv2 * (-r - aa)) % p ]  # two roots
+                    roots = [ (inv2 * (r - aa)) % p, (inv2 * (-r - aa)) % p ]  # two roots  pylint: disable=E1130
             for r in roots:
                 x = r  # start value for x
                 while x < max_j:
@@ -255,10 +255,10 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
         relation = find_relation(include_b)
         res = process_relation(relation)
         if res:
-            return(res)
+            return res
 
     #
-    # find the B-smooth numbers and add them to the system 
+    # find the B-smooth numbers and add them to the system
     #
 
     for s in range(sieve_bound):

{kryptools-0.3 → kryptools-0.5}/kryptools/ec.py

@@ -7,6 +7,7 @@ from random import randint
 from .factor import factorint
 from .nt import legendre_symbol, sqrt_mod, crt
 from .Zmod import Zmod
+from .poly import Poly
 
 class EC_Weierstrass():
     """
@@ -39,6 +40,7 @@ class EC_Weierstrass():
         self.b = self.gf(b % p)
         self.group_order = order
         self.group_order_factors = None
+        self.psi_list = [ Poly([ 0 ], ring = self.gf ) ] # division polynomials
         self.short = False  # display points in short format
         self.hex = False  # display points as hex values in compressed format
 
@@ -139,6 +141,28 @@ class EC_Weierstrass():
             j = legendre_symbol(y2, self.p)
         return ECPoint(x, randint(0, 1), self, short = True)
 
+    def psi(self, n: int):
+        """The x-part of the n'th division polynomial."""
+
+        if len(self.psi_list) < 5:
+            self.psi_list = [ Poly([i], ring = self.gf) for i in range(3)]
+            self.psi_list += [ Poly([-self.a * self.a, 12 * self.b, 6 * self.a, 0, 3], ring = self.gf) ]
+            self.psi_list += [ Poly([-4 * self.a**3 - 32 * self.b * self.b, -16 * self.a * self.b, -20 * self.a * self.a, 80 * self.b, 20 * self.a, 0, 4], ring = self.gf) ]
+        if len(self.psi_list) < n + 1:
+            y2 = Poly([self.b, self.a, 0, 1], ring = self.gf)**2
+            ti = 1 / self.gf(2)
+            for m in range(len(self.psi_list), n + 1):
+                if m % 2:  # odd
+                    m = (m - 1) // 2
+                    if m % 2:
+                        self.psi_list += [ self.psi_list[m + 2] * self.psi_list[m]**3 - y2 * self.psi_list[m - 1] * self.psi_list[m + 1]**3]
+                    else:
+                        self.psi_list += [ y2 * self.psi_list[m + 2] * self.psi_list[m]**3 - self.psi_list[m - 1] * self.psi_list[m + 1]**3]
+                else:  # even
+                    m = m // 2
+                    self.psi_list += [ ti * self.psi_list[m] * (self.psi_list[m + 2] * self.psi_list[m - 1]**2 - self.psi_list[m - 2] * self.psi_list[m + 1]**2) ]
+        return self.psi_list[n]
+
     def order(self, order: int = None) -> int:
         "Return the group order."
         if order:
@@ -296,7 +320,7 @@ class ECPoint:
     def __neg__(self) -> "ECPoint":
         if self.x is None or not self.y:
             return self
-        return ECPoint(self.x, -self.y, self.curve)
+        return ECPoint(self.x, -self.y, self.curve)  # pylint: disable=E1130
 
     def order(self) -> int:
         """Compute the order of an element."""
@@ -311,17 +335,23 @@ class ECPoint:
                     break
         return order
 
-    def dlog(Q, P: "ECPoint") -> int:
+    def psi(self, n: int):
+        """Value of the n'th division polynomial."""
+        if n % 2:
+            return self.curve.psi(n)(self.x)
+        return self.y * self.curve.psi(n)(self.x)
+
+    def dlog(self, other: "ECPoint") -> int:
         """Compute the discrete log_P(Q) in EC."""
-        m = P.order()
+        m = other.order()
         mf = factorint(m)
-        assert m * Q == P.curve(None, None), "DLP not solvable."
+        assert m * self == other.curve(None, None), "DLP not solvable."
         # We first use Pohlig-Hellman to split m into powers of prime factors
         mm = []
         ll = []
         for pj, kj in mf.items():
-            Pj = (m // pj**kj) * P
-            Qj = (m // pj**kj) * Q
+            Pj = (m // pj**kj) * other
+            Qj = (m // pj**kj) * self
             l = Qj.dlog_ph(Pj, pj, kj)
             if l is None:
                 return None
@@ -329,58 +359,58 @@ class ECPoint:
             ll += [l]
         return crt(ll, mm)
 
-    def dlog_ph(Q, P: "ECPoint", q: int, k: int) -> int:
+    def dlog_ph(self, other: "ECPoint", q: int, k: int) -> int:
         """Compute the discrete log_P(Q) in EC if P has order q^k using Pohlig-Hellman reduction."""
         if k == 1 or q**k < 10000:
-            return Q.dlog_switch(P, q**k)
-        Pj = q**(k - 1) * P
+            return self.dlog_switch(other, q**k)
+        Pj = q**(k - 1) * self
         P1 = Pj
-        Qj = q**(k - 1) * Q
+        Qj = q**(k - 1) * other
         xj = Qj.dlog_switch(P1, q)
         for j in range(2, k + 1):
-            Pj = q**(k - j) * P
-            Qj = q**(k - j) * Q - xj * Pj
+            Pj = q**(k - j) * self
+            Qj = q**(k - j) * other - xj * Pj
             yj = Qj.dlog_switch(P1, q)
             xj = xj + q ** (j - 1) * yj % q**j
         return xj
 
-    def dlog_switch(Q, P: "ECPoint", m: int) -> int:
+    def dlog_switch(self, other: "ECPoint", m: int) -> int:
         """Compute the discrete log_P(Q) in EC if P has order m choosing an appropriate method."""
         if m < 100:
-            return Q.dlog_naive(P, m)
-        return Q.dlog_bsgs(P, m)
+            return self.dlog_naive(other, m)
+        return self.dlog_bsgs(other, m)
 
-    def dlog_naive(Q, P: "ECPoint", m: int) -> int:
+    def dlog_naive(self, other: "ECPoint", m: int) -> int:
         """Compute the discrete log_P(Q) in EC using an exhaustive search."""
-        if not Q.curve == P.curve and not isinstance(Q, P.__class__):
+        if not self.curve == other.curve and not isinstance(self, other.__class__):
             raise ValueError("Points must be on the same curve!")
         j = 0
         xx, yy = None, None
-        while xx != Q.x:
+        while xx != self.x:
             j += 1
-            xx, yy = P.curve.add(xx, yy, P.x, P.y)
+            xx, yy = self.curve.add(xx, yy, other.x, other.y)
             if xx is None:
                 raise ValueError("DLP not solvabel!")
-        if  yy == Q.y:
+        if  yy == self.y:
             return j
         return m - j
 
-    def dlog_bsgs(Q, P: "ECPoint", m: int) -> int:
+    def dlog_bsgs(self, other: "ECPoint", m: int) -> int:
         """Compute the discrete log_P(Q) in EC if P has order m using Shanks' baby-step-giant-step algorithm."""
-        if not Q.curve == P.curve and not isinstance(P, Q.__class__):
+        if not self.curve == other.curve and not isinstance(other, self.__class__):
             raise ValueError("Points must be on the same curve!")
         mm = 1 + isqrt(m - 1)
         m2 = mm//2 + mm % 1  # we use the group symmetry to halve the number of steps
         # initialize baby_steps table
         baby_steps = {}
-        baby_step = P
+        baby_step = other
         for j in range(1,m2+1):
             baby_steps[int(baby_step.x)] = j, int(baby_step.y)
-            baby_step += P
+            baby_step += other
 
         # now take the giant steps
-        giant_stride = -mm * P
-        giant_step = Q
+        giant_stride = -mm * other
+        giant_step = self
         for l in range(mm+1):
             if giant_step.x is None:
                 return l * mm

{kryptools-0.3 → kryptools-0.5}/kryptools/factor.py

@@ -4,7 +4,7 @@ Factorization of integers:
 """
 
 from math import isqrt, gcd
-from .primes import sieve_eratosthenes, isprime
+from .primes import sieve_eratosthenes, is_prime
 from .factor_pm1 import _pm1_parameters, factor_pm1
 from .factor_ecm import _ecm_parameters, factor_ecm
 #from .factor_qs import factor_qs
@@ -15,21 +15,18 @@ from .factor_ecm import _ecm_parameters, factor_ecm
 
 
 def _factor_fermat(n: int, steps: int = 10) -> list:
-    a = isqrt(n - 1) + 1
-    step =2
-    if n % 3 == 2:  # if n % 3 = 2, then a must be a multiple of 3
-        a += 2 - ((a - 1) % 3)
-        step = 3
-    elif (n % 4 == 1) ^ (a & 1):  # if n % 4 = 1,3 then a must be odd, even, respectively
-        a += 1
-    for _ in range(steps):
-        #if a > (n + 9) // 6:
-        #     return
+    "Fermat method"
+    parameters = {11: (12, 6), 23: (12, 0),
+                  5: (6, 3), 17: (6, 3),
+                  19: (4, 2), 7: (4, 0),
+                  1: (2, 1), 13: (2, 1)}
+    start = isqrt(n - 1) + 1
+    step, mod = parameters[n % 24]
+    start += (mod - start) % step
+    for a in range(start, min(start + steps * step,(n + 9) // 6) + 1, step):
         b = isqrt(a * a - n)
         if b * b == a * a - n:
             return a - b
-        a += step
-
 
 def factorint(n: int, verbose: int = 0) -> list:
     "Factor a number."
@@ -42,7 +39,7 @@ def factorint(n: int, verbose: int = 0) -> list:
         for m in mm:
             if m in prime_factors:
                 prime_factors[m] += k
-            elif isprime(m):
+            elif is_prime(m):
                 prime_factors[m] = k
             else:
                 if m in remaining_factors:
@@ -66,7 +63,7 @@ def factorint(n: int, verbose: int = 0) -> list:
         return prime_factors
     if verbose:
         print("Trial division found:", list(prime_factors))
-    if isprime(n):
+    if is_prime(n):
         prime_factors[n] = 1
         return prime_factors
     remaining_factors = { n: 1 }
@@ -130,7 +127,7 @@ def factorint(n: int, verbose: int = 0) -> list:
                 else:
                     remaining_factors[m] = new_factors[m]
             if verbose > 1: print("Remaining: ", remaining_factors)
-   
+
         if len(remaining_factors) == 0:
             return prime_factors
 

{kryptools-0.3 → kryptools-0.5}/kryptools/factor_ecm.py

@@ -5,6 +5,7 @@ Integer factorization: Lentra's ECM
 from math import gcd, isqrt, log
 from random import randint, seed
 from .primes import sieve_eratosthenes
+seed(0)
 
 # Crandall and Pomerance: Primes (doi=10.1007/0-387-28979-8)
 # Algorithm 7.2.7
@@ -83,7 +84,7 @@ def _ecm_parameters(B1: int, B2: int = None, D: int = None, primes: tuple = None
     return D, stage_one, stage_two_deltas
 
 
-def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm_parameters: tuple = None):
+def factor_ecm(n: int, B1: int = 11000, B2: int = 1900000, curves: int = 74, ecm_parameters: tuple|None = None):
     "Factors a number n using Lentsta's ECM method."    
 
     if ecm_parameters:

kryptools-0.5/kryptools/factor_fmt.py

@@ -0,0 +1,30 @@
+"""
+Integer factorization: Fermat's method
+"""
+
+from math import isqrt
+
+
+def factor_fermat(n: int) -> list:
+    """Find factors of n using the method of Fermat."""
+    factors = []
+    parameters = {11: (12, 6), 23: (12, 0),
+                  5: (6, 3), 17: (6, 3),
+                  19: (4, 2), 7: (4, 0),
+                  1: (2, 1), 13: (2, 1)}
+   # Speedup only works if n is neiter a multipl of 2 or 3
+    for p in (2, 3):
+        while n % p == 0:
+            factors.append(p)
+            n //= p
+    start = isqrt(n - 1) + 1
+    step, mod = parameters[n % 24]
+    start += (mod - start) % step
+    for a in range(start, (n + 9) // 6 + 1, step):
+        b = isqrt(a * a - n)
+        if b * b == a * a - n:
+            factors.append(a - b)
+            factors.append(a + b)
+            return factors
+    factors.append(n)
+    return factors

{kryptools-0.3 → kryptools-0.5}/kryptools/factor_pm1.py

@@ -24,7 +24,7 @@ def _pm1_parameters(B1: int, B2: int = None, primes: tuple = None):
             continue
         if q > B2:
             break
-        stage_two_deltas.append(q - p)
+        stage_two_deltas.append(q - p)  # pylint: disable=W0631
 
     return stage_one, stage_two_deltas
 

{kryptools-0.3 → kryptools-0.5}/kryptools/factor_qs.py

@@ -54,11 +54,11 @@ def factor_qs(n: int) -> list:
     for i, p in enumerate(factorbase):
         r1 = sqrt_mod(n, p)
         assert r1 is not None # only quadratic residues
-        r2 = -r1 % p
+        r2 = -r1 % p # pylint: disable=E1130
         if r1 == r2:
             factorbase_root[i] = [ r1 ]
         else:
-            factorbase_root[i] = [ r1, -r1 % p ]
+            factorbase_root[i] = [ r1, -r1 % p ]  # pylint: disable=E1130
 
     m = isqrt(n - 1) + 1
     d = m**2 - n
@@ -168,7 +168,7 @@ def factor_qs(n: int) -> list:
                     res = process_relation(j, mask)
                     if res:
                         return res
-                del(factors[j])
+                del factors[j]
             else:
-                del(factors[j])  # the number is unlikely to factor
+                del factors[j]  # the number is unlikely to factor
         sieve_bound += sieve_step  # increase the sieve and continue

{kryptools-0.3 → kryptools-0.5}/kryptools/la.py

@@ -3,6 +3,8 @@ Linear algebra
 """
 
 from math import inf, sqrt, prod
+from numbers import Number
+
 
 class Matrix:
     """
@@ -61,8 +63,10 @@ class Matrix:
             else:
                 cols = range(self.cols)[j]
             return Matrix([[self.matrix[i][j] for j in cols] for i in rows])
-        i, j = divmod(item, self.cols)
-        return self.matrix[i][j]
+        if isinstance(item, int):
+            i, j = divmod(item, self.cols)
+            return self.matrix[i][j]
+        return Matrix([self.matrix[k // self.cols][k % self.cols] for k in range(self.cols * self.rows)[item]])
 
     def __setitem__(self, item, value):
         if isinstance(item, tuple):
@@ -147,12 +151,16 @@ class Matrix:
         return result
 
     def __add__(self, other) -> "Matrix":
-        if isinstance(other, Matrix) and other.cols == self.cols and other.rows == self.rows:
+        if isinstance(other, Matrix):
+            if other.cols != self.cols or other.rows != self.rows:
+                raise NotImplementedError("Matrix dimensions do not match!")
             return Matrix([ [ x1 + y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
         return NotImplemented
 
     def __sub__(self, other) -> "Matrix":
-        if isinstance(other, Matrix) and other.cols == self.cols and other.rows == self.rows:
+        if isinstance(other, Matrix):
+            if other.cols != self.cols or other.rows != self.rows:
+                raise NotImplementedError("Matrix dimensions do not match!")
             return Matrix([ [ x1 - y1 for x1, y1 in zip(x,y)] for x, y in zip(self.matrix, other.matrix)])
         return NotImplemented
 
@@ -162,12 +170,14 @@ class Matrix:
     def __mul__(self, other) -> "Matrix":
         if isinstance(other, Matrix):
             return self.multiply(other)
+        if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
+            return Matrix([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def __rmul__(self, other) -> "Matrix":
-        if isinstance(other, Matrix):
-            return self.multiply(other)
-        return Matrix([ [item * other for item in row] for row in self.matrix ])
+        if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
+             return Matrix([ [item * other for item in row] for row in self.matrix ])
+        return NotImplemented
 
     def rref(self) -> "Matrix":
         "Compute the reduced echelon form of a matrix M."
@@ -242,20 +252,26 @@ class Matrix:
             n, m = self.cols, self.rows
         elif not n:
             n = m
-        zero = 0 * self[0]
+        try:
+            zero = 0 * self[0]
+        except:
+            zero = 0
         return Matrix([[ zero for j in range(n)] for i in range(m) ])
 
     def eye(self, m: int = None, n: int = None):
         "Returns an identity matrix of the same dimension"
         def delta(i, j):
             if i == j:
-                return 1
-            return 0
+                return one
+            return zero
         if not m and not n:
             n, m = self.cols, self.rows
         elif not n:
             n = m
-        zero = 0 * self[0]
+        try:
+            zero = 0 * self[0]
+        except:
+            zero = 0
         one = 1 + zero
         return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])
 

{kryptools-0.3 → kryptools-0.5}/kryptools/lat.py

@@ -104,6 +104,7 @@ def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
     assert 0 < delta <= 1, f"LLL reqires 0 < delta={delta} <= 1"
     j = 1
     U = V[:, :]
+    U.map(int)
     Us = U[:, :]
     Us.map(Fraction)
     M = U.zeros()

{kryptools-0.3 → kryptools-0.5}/kryptools/nt.py

@@ -1,29 +1,21 @@
 """
 Number theory tools:
-    lcm(a, b) least common mutiple of a and b
     egcd(a,b) extended Euclidean agorithm
     crt([a1, a2, ...],[m1, m2, ...]) Chinese Remainder Theorem
     cf(Fraction(m,n)) continued fraction expansions
     convergents() convergents of a continued fraction
+    legendre_symbol(a, p) compute the Legendre symbol of a with respect to the prime p
+    jacobi_symbol(a, n) compute the Jacobi symbol of a with respect to n
     sqrt_mod(n, p) square root of n modulo a prime p
     order(a, n) oder of a in the multiplicative group Z_n^*
 """
-from math import gcd, prod
+from math import gcd, lcm, prod
 from fractions import Fraction
 
-# Euclid and friends
-
-def lcm(a: int, b: int) -> int:
-    """Compute the least common multiple of a and b."""
-    if b == 0:
-        return 0
-    if bool(a > 0) != bool(b > 0):
-        a = -a
-    return (a // gcd(a, b)) * b
-
+# extended Euclid
 
 def egcd(a: int, b: int) -> (int, int, int):
-    """Perform the extended Euclidean agorithm. Returns gcd, x, y such that a x + b y = gcd."""
+    """Perform the extended Euclidean agorithm. Returns `gcd`, `x`, `y` such that `a x + b y = gcd`."""
     r0, r1 = a, b
     x0, x1, y0, y1 = 1, 0, 0, 1
     while r1 != 0:
@@ -36,8 +28,8 @@ def egcd(a: int, b: int) -> (int, int, int):
 
 # Chinese remainder theorem
 
-def crt(a: list, m: list) -> int:
-    """Solve given linear congruences x[j] % m[j] == a[j] using the Chinese Remainder Theorem."""
+def crt(a: list[int], m: list[int]) -> int:
+    """Solve given linear congruences x % m[j] == a[j] using the Chinese Remainder Theorem."""
     l = len(a)
     assert len(m) == l, "The lists of numbers and modules must have equal length."
     M = prod(m)
@@ -112,6 +104,7 @@ def crt(a: list, m: list) -> int:
 
 
 def fraction_repr(self):
+    "Representation of a fraction."
     if self.denominator == 1:
         return str(self.numerator)
     return str(self.numerator) + "/" + str(self.denominator)
@@ -178,8 +171,8 @@ def jacobi_symbol(a: int, n: int) -> int:
         return t
     return 0
 
-def sqrt_mod(a: int, p: int) -> list:
-    "Compute a square root of a modulo p unsing Cipolla's algorithm."
+def sqrt_mod(a: int, p: int) -> int:
+    "Compute a square root of `a` modulo `p` unsing Cipolla's algorithm."
     a %= p
     if a == 0 or a == 1:
         return a
@@ -211,13 +204,13 @@ from .factor import factorint
 
 
 def euler_phi(n: int) -> int:
-    """Euler's phi function of n."""
+    """Euler's phi function of `n`."""
     k = factorint(n)
     return prod([(p - 1) * p ** (k[p] - 1) for p in k])
 
 
 def carmichael_lambda(n: int) -> int:
-    """Carmichael's lambda function of n."""
+    """Carmichael's lambda function of `n`."""
     k = factorint(n)
     lam_all = []  # values corresponding to the prime factors
     for p in k:
@@ -233,10 +226,10 @@ def carmichael_lambda(n: int) -> int:
 # Order in Z_p^*
 
 def order(a: int, n: int, factor=False) -> int:
-    """Compute the order of a in the group Z_n^*."""
+    """Compute the order of `a` in the group Z_n^*."""
     a %= n
     assert a != 0 and gcd(a, n) == 1, f"{a} and {n} are not coprime!"
-    factors = dict()  # We compute euler_phi(n) and its factorization in one pass
+    factors = {}  # We compute euler_phi(n) and its factorization in one pass
     for p, k in factorint(n).items():  # first factorize n
         for pm, km in factorint(p - 1).items():  # factor p-1 and add the factors
             if pm in factors:
@@ -263,7 +256,7 @@ def order(a: int, n: int, factor=False) -> int:
             else:
                 break
         if factor and i < k:
-            factors_order[p] = k - i
+            factors_order[p] = k - i  # pylint: disable=E0606
     if factor:
         return order_a, factors_order
     return order_a

{kryptools-0.3 → kryptools-0.5}/kryptools/poly.py

@@ -2,6 +2,8 @@
 Polynomials
 """
 
+from numbers import Number
+
 class Poly:
     """
     Represents a polynomial as a list of coefficients.
@@ -25,9 +27,18 @@ class Poly:
         if modulus:
             self.mod(modulus)
 
+    def __call__(self, x):
+        return sum(c * x**j for j, c in enumerate(self.coeff))
+
     def __getitem__(self, item):
         return self.coeff[item]
 
+    def __setitem__(self, item, value):
+        self.coeff[item] = value
+
+    def __len__(self):
+        return len(self.coeff)
+
     def __repr__(self):
         def prx(i: int):
             if i == 0:
@@ -37,7 +48,7 @@ class Poly:
             return "x^" + str(i)
 
         if len(self.coeff) == 1:
-            return str(int(self.coeff[0]))
+            return str(self.coeff[0])
         plus = ""
         tmp = ""
         for i in reversed(range(len(self.coeff))):
@@ -76,19 +87,20 @@ class Poly:
         return bool(self.degree()) or bool(self.coeff[0])
 
     def degree(self):
+        "Return the degree."
         return len(self.coeff) - 1
 
     def map(self, func):
+        "Apply a given function to all coefficients."
         self.coeff = list(map(func, self.coeff))
 
     def __add__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
-                tmp = self.coeff[:]
+            tmp = self.coeff[:]
+            if isinstance(other, int) or type(other) == type(tmp[0]):
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                return NotImplemented
+            return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
             scoeff = self.coeff + (lo - ls) * [0]
@@ -105,12 +117,10 @@ class Poly:
 
     def __radd__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if isinstance(other, Number) or type(other) == type(self.coeff[0]):
                 tmp = self.coeff[:]
                 tmp[0] += other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                pass
         return NotImplemented
 
     def __neg__(self) -> "Poly":
@@ -118,12 +128,11 @@ class Poly:
 
     def __sub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if isinstance(other, int) or type(other) == type(self.coeff[0]):
                 tmp = self.coeff[:]
                 tmp[0] -= other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                return NotImplemented
+            return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
             scoeff = self.coeff + (lo - ls) * [0]
@@ -136,24 +145,21 @@ class Poly:
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
-        return self.__class__([s - o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
+        return self.__class__([s - o for s, o in zip(scoeff, ocoeff)], modulus = modulus)
 
     def __rsub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
+            if isinstance(other, int) or type(other) == type(self.coeff[0]):
                 tmp = self.coeff[:]
                 tmp[0] -= other
                 return self.__class__(tmp, modulus=self.modulus)
-            except:
-                pass
         return NotImplemented
 
     def __mul__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            try:
-                return Poly([other * s for s in self.coeff])
-            except:
-                return NotImplemented
+            if isinstance(other, int) or type(other) == type(self.coeff[0]):
+                return Poly([other * s for s in self.coeff], modulus = self.modulus)
+            return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         coeff = [0] * (ls + lo - 1)
         for k in range(ls + lo - 1):
@@ -166,25 +172,38 @@ class Poly:
         modulus = self.modulus
         if not modulus and other.modulus:
             modulus = other.modulus
-        return self.__class__(coeff, modulus=modulus)
+        return self.__class__(coeff, modulus = modulus)
 
     def __rmul__(self, other: int) -> "Poly":
-        return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
+        if isinstance(other, int) or type(other) == type(self.coeff[0]):
+            return self.__class__([other * s for s in self.coeff], modulus=self.modulus)
+        return NotImplemented
 
     def __pow__(self, i: int) -> "Poly":
-        res = self.__class__([1], modulus=self.modulus)
+        if not isinstance(i, int):
+            return NotImplemented
+        zero = 0 * self.coeff[0]
+        one = zero + 1
+        res = self.__class__([one], modulus=self.modulus)
         if i < 0:
             if not self.modulus:
-                raise NotImplementedError(f"Cannot divide.")
+                raise NotImplementedError("Cannot divide polynomials without modulus.")
             tmp = self.inv()
+            i *= -1
         else:
             tmp = self
         for _ in range(i):
             res *= tmp
         return res
 
+    def __floordiv__(self, other: "Poly") -> "Poly":
+        return self.divmod(other)[0]
+
+    def __mod__(self, other: "Poly") -> "Poly":
+        return self.divmod(other)[1]
+
     def divmod(self, other: "Poly") -> ("Poly", "Poly"):
-        "Polynom division with remainder"
+        "Polynom division with remainder."
         if isinstance(other, list):
             other = self.__class__(other)
         elif not isinstance(other, self.__class__):
@@ -215,7 +234,7 @@ class Poly:
         )
 
     def mod(self, other: "Poly") -> None:
-        "Remainder of polynom division"
+        "Reduce with respect to a given polynomial."
         if isinstance(other, list):
             other = self.__class__(other)
         elif not isinstance(other, self.__class__):
@@ -241,6 +260,7 @@ class Poly:
             self.coeff.pop(i)
 
     def inv(self, other: "Poly" = None) -> "Poly":
+        "Inverse modulo a given polynomial."
         if not other:
             other = self.modulus
         if isinstance(other, list):
@@ -249,10 +269,10 @@ class Poly:
             raise NotImplementedError(f"Cannot invert {self} modulo {other}.")
         if not other:
             raise NotImplementedError(f"{other} must be nonzero.")
+        zero = 0 * self.coeff[0]
+        one = zero +1
         r0, r1 = other, self
-        y0, y1 = self.__class__([0], modulus=self.modulus), self.__class__(
-            [1], modulus=self.modulus
-        )
+        y0, y1 = self.__class__([zero], modulus=self.modulus), self.__class__([one], modulus=self.modulus)
         while r1:
             q, r = r0.divmod(r1)
             r0, r1 = r1, r
@@ -260,6 +280,6 @@ class Poly:
         if r0.degree() != 0:
             raise ValueError(f"{self} is not invertible mod {other}.")
         tmp = 1 / r0[0]
-        for i in range(y0.degree()):
+        for i in range(len(y0)):
             y0.coeff[i] *= tmp
         return y0

{kryptools-0.3 → kryptools-0.5}/kryptools/primes.py

@@ -1,10 +1,16 @@
 """
 Tools for prime numbers:
     sieve_eratosthenes(B) a tuple of all primes up to including B
-    isprime(n) test if n is probably prime
+    is_prime(n) test if n is probably prime
+    next_prime(n) find the next prime larger or equal n
+    random_prime(l) find a random prime with bit length at least l
+    random_strongprime(l) find a random strong prime with bit length at least l
+    is_safeprime(n) test if n is a safe prime
+    random_safeprime(n) find a random safe prime with bit length at least l and ord(2)=(p-1)/2
     miller_rabin_test(n, b) Miller-Rabin primality test with base b
 """
 from math import isqrt, gcd
+from random import randint
 from .nt import jacobi_symbol
 
 # Erathostenes
@@ -13,15 +19,15 @@ def sieve_eratosthenes(B: int) -> list:
     """ "Returns a list of all primes up to (including) max."""
     B1 = (isqrt(B) -1)//2
     B = (B - 1)//2
-    is_prime = [True] * (B + 1)  # to begin with, all numbers are potentially prime
+    isprime = [True] * (B + 1)  # to begin with, all numbers are potentially prime
     # sieve out the primes p=2*q+1 starting at 3 in steps of 2 (ignoring even numbers)
     for q in range(1, B1 + 1):
-        if is_prime[q]: # sieve out all multiples; numbers p*q with q<p were already sieved out previously
+        if isprime[q]: # sieve out all multiples; numbers p*q with q<p were already sieved out previously
             qq = (q << 1) * (q + 1)
             p = (q << 1) | 1
-            is_prime[qq :: p] = [False] * ((B - qq) // p + 1)
+            isprime[qq :: p] = [False] * ((B - qq) // p + 1)
 
-    return tuple([2] + [2 * q + 1 for q in range(1, B + 1) if is_prime[q]])
+    return tuple([2] + [2 * q + 1 for q in range(1, B + 1) if isprime[q]])
 
 # Primality testing
 
@@ -51,7 +57,7 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
                 return True
     return False
 
-def isprime(n: int) -> bool:
+def is_prime(n: int) -> bool:
     """Test if an integer n if probable prime."""
     if n < 18446744073709551616:  # https://miller-rabin.appspot.com
         return miller_rabin_test(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022])
@@ -59,6 +65,43 @@ def isprime(n: int) -> bool:
         return miller_rabin_test(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41])
     return miller_rabin_test(n, [2]) and _is_strong_lucas_prp(n)  # Baillie–PSW primality test
 
+def next_prime(n: int) -> int:
+    """Find the next prime larger or equal n."""
+    n |= 1  # make sure n is odd
+    while not is_prime(n):
+        n += 2
+    return n
+
+def random_prime(l: int) -> int:
+    """Find a random prime with bit length at least l."""
+    return next_prime(randint(2 ** (l - 1), 2**l - 1))
+
+def random_strongprime(l: int) -> int:
+    """Find a random strong prime with bit length at least l using Gordon's algorithm."""
+    t = random_prime(l)
+    s = random_prime(l)
+    u = 2 * t
+    uu = u * randint(1, 100)
+    while not is_prime(uu + 1):
+        uu += u
+    r = uu + 1
+    u = 2 * r * s
+    uu = u * randint(1, 100) + 2 * s * pow(s, r - 2, r) - 1
+    while not is_prime(uu):
+        uu += u
+    return t, s, r, uu
+
+def is_safeprime(p: int) -> bool:
+    """Tests if a number is a safe prime."""
+    return is_prime(p) and is_prime((p - 1) // 2)
+
+def random_safeprime(l: int) -> int:
+    """Find a random safe prime with bit length at least l and ord(2)=(p-1)/2."""
+    p = randint(2 ** (l - 1), 2**l - 1)
+    p = p - (p % 24) + 23
+    while not is_safeprime(p):
+        p += 24
+    return p
 
 def _lucas_sequence(n, D, k):
     """Evaluate a Lucas sequence."""

{kryptools-0.3 → kryptools-0.5}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.3
+Version: 0.5
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 Project-URL: Homepage, https://github.com/teschlg/kryptools
@@ -9,7 +9,7 @@ Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
@@ -27,7 +27,7 @@ The tools contained are:
 * number theory: sqrt modulo primes, crt, continued fractions, etc.
 * primes: Sieve of Erathostenes, primality tests
 * solvers for discrete logarithms (naive, Pollard rho, Shanks baby step/giant step, index calculus, quadratic sieve)
-* integer factorization (Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
+* integer factorization (Fermat, Pollard p-1, Lentra's ECM, Dixon, basic quadratic sieve)
 * linear algebra: Hermite normal form, Gram-Schmidt
 * lattices: Babai rounding/nearest plane, lattice reduction
 

{kryptools-0.3 → kryptools-0.5}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "kryptools"
-version = "0.3"
+version = "0.5"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]
 description = "Implemenation of same basic algorithms used in cryptography."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

kryptools-0.3/kryptools/Zmod.py

@@ -1,115 +0,0 @@
-"""
-Ring of intergers modulo `n`.
-"""
-
-class Zmod:
-    """
-    Ring of intergers modulo `n`.
-
-    Example:
-    
-    To define a finite Galois field modulo the prime 5 use
-    >>> gf=Zmod(5)
-    
-    To declare 3 as an element of our Galois filed use
-    >>> gf(3)
-    3 (mod 5)
-
-    The usual arithmetic operations are supported.
-    >>> gf(2) + gf(3)
-    0 (mod 5)
-    """
-
-    def __init__(self, n: int, short: bool = False):
-        self.n = n
-        self.short = short
-
-    def __call__(self, x: int):
-        return ZmodPoint(x, self)
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return self.n == other.n
-        return False
-
-    def __contains__(self, other: "ZmodPoint") -> bool:
-        return isinstance(other, ZmodPoint) and self.n == other.ring.n
-
-
-class ZmodPoint:
-    "Represents a point in the ring Zmod."
-
-    def __init__(self, x: int, ring: "Zmod"):
-        if isinstance(x, self.__class__) and x.ring.n == ring.n:
-            self.x = int(x)
-        else:
-            self.x = int(x) % ring.n
-        self.ring = ring
-
-    def __repr__(self):
-        if self.ring.short:
-            return str(self.x)
-        return f"{self.x} (mod {self.ring.n})"
-
-    def __eq__(self, other):
-        if not isinstance(other, self.__class__) or self.ring != other.ring:
-            return False
-        return self.x == other.x
-
-    def __bool__(self):
-        return self.x != 0
-
-    def __int__(self):
-        return self.x
-
-    def sharp(self):
-        "Returns a symmetric (w.r.t. 0) representative."
-        tmp = (self.ring.n - 1) // 2
-        return (self.x + tmp) % self.ring.n - tmp
-
-    def __hash__(self):
-        return hash(self.x)
-
-    def __add__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if isinstance(other, self.__class__) and self.ring == other.ring:
-            return self.__class__(self.x + other.x, self.ring)
-        if isinstance(other, int):
-            return self.__class__(self.x + other, self.ring)
-        return NotImplemented
-
-    def __radd__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar + self.x, self.ring)
-
-    def __neg__(self) -> "ZmodPoint":
-        return self.__class__(-self.x, self.ring)
-
-    def __sub__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if isinstance(other, self.__class__) and self.ring == other.ring:
-            return self.__class__(self.x - other.x, self.ring)
-        if isinstance(other, int):
-            return self.__class__(self.x - other, self.ring)
-        return NotImplemented
-
-    def __rsub__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar - self.x, self.ring)
-
-    def __mul__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if isinstance(other, self.__class__) and self.ring == other.ring:
-            return self.__class__(self.x * other.x, self.ring)
-        if isinstance(other, int):
-            return self.__class__(self.x * other, self.ring)
-        return NotImplemented
-
-    def __rmul__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar * self.x, self.ring)
-
-    def __truediv__(self, other: "ZmodPoint") -> "ZmodPoint":
-        if not isinstance(other, self.__class__) or self.ring != other.ring:
-            return NotImplemented
-        return self.__class__(self.x * pow(other.x, -1, self.ring.n), self.ring)
-
-    def __rtruediv__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(scalar * pow(self.x, -1, self.ring.n), self.ring)
-
-    def __pow__(self, scalar: int) -> "ZmodPoint":
-        return self.__class__(pow(self.x, scalar, self.ring.n), self.ring)

kryptools-0.3/kryptools/factor_fmt.py

@@ -1,30 +0,0 @@
-"""
-Integer factorization: Fermat's method
-"""
-
-from math import isqrt
-
-
-def factor_fermat(n: int) -> list:
-    """Find factors of n using the method of Fermat."""
-    factors = []
-    # Fermat only works if n has two factors which are either both even or both odd
-    while n % 2 == 0:
-        factors.append(2)
-        n //= 2
-    a = isqrt(n - 1) + 1
-    step =2
-    if n % 3 == 2:  # if n % 3 = 2, then a must be a multiple of 3
-        a += 2 - ((a - 1) % 3)
-        step = 3
-    elif (n % 4 == 1) ^ (a & 1):  # if n % 4 = 1,3 then a must be odd, even, respectively
-        a += 1
-    while a <= (n + 9) // 6:
-        b = isqrt(a * a - n)
-        if b * b == a * a - n:
-            factors.append(a - b)
-            factors.append(a + b)
-            return factors
-        a += step
-    factors.append(n)
-    return factors