kryptools 0.9.8__tar.gz → 0.9.10__tar.gz

{kryptools-0.9.8 → kryptools-0.9.10}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.8
+Version: 0.9.10
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
+License: MIT
 Project-URL: Homepage, https://github.com/teschlg/kryptools
+Project-URL: Source, https://github.com/teschlg/kryptools
 Project-URL: Issues, https://github.com/teschlg/kryptools/issues
 Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/Zmod.py

@@ -4,7 +4,7 @@ Ring of intergers modulo `n`.
 
 from math import gcd
 from .factor import factorint
-
+from .intfuncs import prime_power
 
 class Zmod:
     """
@@ -25,12 +25,18 @@ class Zmod:
     """
 
     def __init__(self, n: int, short: bool = True):
+        if not isinstance(n, int) or n < 1:
+            raise ValueError(f"{n} is not a positive integer.")
         self.n = n
         self.short = short
         self.group_order = 0
         self.factors = {} # factoring of the group order
 
-    def __call__(self, x: int):
+    def __call__(self, x: int|list|tuple):
+        if isinstance(x, list):
+            return [ZmodPoint(xx, self) for xx in x]
+        elif isinstance(x, tuple):
+            return (ZmodPoint(xx, self) for xx in x)
         return ZmodPoint(x, self)
 
     def __eq__(self, other):
@@ -62,8 +68,25 @@ class Zmod:
             self.group_order *= p**k
         return self.group_order
 
-    def generator(self, all = False) -> int:
+    def is_cyclic(self) -> bool:
+        """Test if the group Z_n^* is cyclic."""
+        n = self.n
+        if n < 8:
+            return True
+        if not n % 2:
+            n //= 2
+        if not n % 2:
+            return False
+        if prime_power(n):
+            return True
+        return False
+
+    def generator(self, all = False) -> int|None:
         """Return a generator of the group Z_n^*."""
+        if not self.is_cyclic():
+            if all:
+                return []
+            return None
         for a in range(2, self.n):
             if gcd(a, self.n) > 1:
                 continue
@@ -76,7 +99,7 @@ class Zmod:
 
     def star(self) -> int:
         """Return a list of all elements of the group Z_n^*."""
-        elements = [ 1 ]
+        elements = [ self(1) ]
         for a in range(2, self.n):
             if gcd(a, self.n) > 1:
                 continue

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/__init__.py

@@ -5,11 +5,12 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "0.9.8"
+__version__ = "0.9.10"
 __email__ = "Gerald.Teschl@univie.ac.at"
 
-from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, order, crt
+from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, is_carmichael_number, order, crt
 from .primes import sieve_eratosthenes, prime_pi, is_prime, next_prime, previous_prime, random_prime, random_strongprime, is_safeprime, random_safeprime, is_blumprime, random_blumprime, miller_rabin_test, lucas_test
+from .intfuncs import iroot, ilog, perfect_square, perfect_power, prime_power
 from .factor import factorint, divisors
 from .dlp import dlog
 from .ec import EC_Weierstrass

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/ec.py

@@ -71,6 +71,10 @@ class EC_Weierstrass():
         return False
 
     def __contains__(self, P: "ECPoint") -> bool:
+        if not isinstance(P, ECPoint) or P.curve != self:
+            return False
+        if P.x is None and P.y is None:
+            return True
         return P.y**2 == P.x**3 + self.a * P.x + self.b
 
     def info(self):
@@ -268,7 +272,7 @@ class ECPoint:
                 else:
                     y = (curve.p - y1) % curve.p
             self.y = curve.gf(y)
-            if not self in curve:
+            if self not in curve:
                 raise ValueError("Point not on curve!")
 
     def __repr__(self):

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/factor.py

@@ -116,7 +116,7 @@ def factorint(n: int, verbose: int = 0, trial_bnd: int = 2500) -> dict:
         B2 += B2 & 1
         num_curves *= 2
         D = isqrt(B2)
-        
+
         if verbose:
             print(f"Round {round+1} (B1={B1})")
 
@@ -172,16 +172,21 @@ def factorint(n: int, verbose: int = 0, trial_bnd: int = 2500) -> dict:
 
 def divisors(n:int, proper:bool = False) -> int:
     """Returns an unsorted list of all divisors of an integer `n`."""
+    if not isinstance(n, int):
+        raise ValueError("Number must be an integer!")
+    n = abs(n)
+    if proper:
+        divisors = []
+    else:
+        divisors = [1]
+    if n <= 1:
+        return divisors
     facctordict= factorint(n)
     primes = [p for p in facctordict]
     nprimes = len(primes)
     multiplicites = [facctordict[p] for p in primes]
 
     exponents = [0] * nprimes
-    if proper:
-        divisors = []
-    else:
-        divisors = [1]
     i = 0
     while True:
         exponents[i] += 1

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/factor_ecm.py

@@ -177,4 +177,3 @@ def factor_ecm(n: int, B1: int|None = None, B2: int|None = None, curves: int = 1
 
     if verbose > 1:
         print(f"\nNo factor after trying {curves} curves.")
-

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/factor_fmt.py

@@ -2,11 +2,13 @@
 Integer factorization: Fermat's method
 """
 
-from math import isqrt, log10, floor, log10
+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."""
+    if not isinstance(n, int) or n < 1:
+        raise ValueError("Number to be factored must be a positive integer!")
     if verbose:
         print(f"Factoring (Fermat): {n} ({floor(log10(n)) + 1} digits)")
     factors = []
@@ -19,6 +21,8 @@ def factor_fermat(n: int, maxsteps: int|None = None, verbose: int = 0) -> list:
         while n % p == 0:
             factors.append(p)
             n //= p
+    if n == 1:
+        return factors
     start = isqrt(n - 1) + 1
     step, mod = parameters[n % 24]
     start += (mod - start) % step

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/factor_pm1.py

@@ -59,7 +59,7 @@ def factor_pm1(n: int, B1: int|None = None, B2: int|None = None, x: int = 2, pm1
     y = pow(x, stage_two_deltas[0], n)
     D = (y - 1) % n
     for k, d in enumerate(stage_two_deltas[1:]):
-        if not d in saved:
+        if d not in saved:
             saved[d] = pow(x, d, n)
         y = y * saved[d] % n
         D = D * (y - 1) % n

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/factor_rho.py

@@ -55,4 +55,3 @@ def factor_rho(n: int, x: int = 2, maxinit: int = 10, maxiter: int = 1000, brent
         x = randint(1, n - 1)  # new x_0
     if verbose > 1:
         print("")
-

kryptools-0.9.10/kryptools/intfuncs.py

@@ -0,0 +1,106 @@
+"""
+Integer Functions:
+    iroot(k, n) integer k'th root of n
+    ilog(b, n) integer log of n with respect ot base b
+    perfect_square(n) test if a number is a perfect square
+    perfect_power(n) test if a number is a perfect power
+    prime_power(n) test if a number is a prime power
+"""
+from math import isqrt
+from .primes import sieve_eratosthenes, is_prime
+
+
+def iroot(k: int, n: int) -> int:
+    """For a given positive integers `n` and `k`, finds the largest integer `r` such that `r**k <= n`."""
+    if not isinstance(k, int) or k < 1:
+        raise ValueError(f"k={k} must be a positive integer.")
+    if not isinstance(n, int) or n < 0:
+        raise ValueError(f"n={n} must be a nonegative integer.")
+    if n <= 1 or k == 1:
+        return n
+    if k == 2:
+        return isqrt(n)
+    rr = n
+    kk = k
+    while kk > 1:
+        kk //= 2
+        rr = isqrt(rr)
+    r = rr + 1
+    k1 = k-1
+    while rr < r:
+        r = rr
+        rr = (k1 * rr + n // rr ** k1) // k # Newton iteration
+    return r
+
+def ilog(b: int, n:int) -> int:
+    """For a given positive integer `n`, finds the largest integer `l` such that `b**l <= n`."""
+    # https://stackoverflow.com/questions/39190815/how-to-make-perfect-power-algorithm-more-efficient/39191163#39191163
+    if not isinstance(b, int) or b < 2:
+        raise ValueError(f"base b={b} must a positive integer larger then one.")
+    if not isinstance(n, int) or n <= 0:
+        raise ValueError(f"n={n} must be a positive integer.")
+    if n == 1:
+        return 0
+    if b == 2:
+        return n.bit_length() - 1
+    lo, blo, hi, bhi = 0, 1, 1, b
+    while bhi < n:
+        lo, blo, hi, bhi = hi, bhi, hi + hi, bhi * bhi
+    while 1 < (hi - lo):
+        mid = (lo + hi) // 2
+        bmid = blo * pow(b, mid - lo)
+        if n < bmid:
+            hi, bhi = mid, bmid
+        elif bmid < n:
+            lo, blo = mid, bmid
+        else: return mid
+    if bhi == n: return hi
+    return lo
+
+
+def perfect_square(n: int) -> int|None:
+    """Returns the root if `n` is a perfect square and None else."""
+    if not isinstance(n, int) or n < 2:
+        return None
+    s = isqrt(n)
+    if s*s == n:
+        return s
+
+def perfect_power(n: int) -> tuple|None:
+    """Returns integers `(m, p)` with `m**p == n` if `n` is a perfect power and None else."""
+    if not isinstance(n, int) or abs(n) < 2:
+        return None
+    sign = 1
+    if n < 0:
+        sign = -1
+        n = abs(n)
+    for p in sieve_eratosthenes(n.bit_length() - 1):
+        m = iroot(p, n)
+        if pow(m, p) == n:
+            if sign == 1:
+                return m, p
+            if p > 2:
+                return -m, p
+
+def prime_power(n: int) -> tuple|None:
+    """Returns integers `(p, k)` with `p**k == n` if `n` is a prime power and None else."""
+    if not isinstance(n, int) or n < 2:
+        return None    
+    if is_prime(n):
+        return (n, 1)
+    r = n
+    k = 1
+    while r.bit_length() > 20:
+        k += 1
+        r = iroot(k, n)
+        if r**k == n and is_prime(r):
+            return (r, k)
+    for p in sieve_eratosthenes(r - 1):
+        k = 0
+        while n % p == 0:
+            k += 1
+            n //= p
+        if k >= 1:
+            if n == 1:
+                return (p, k)
+            return None

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/la.py

@@ -69,7 +69,7 @@ class Matrix:
         if isinstance(item, int):
             i, j = divmod(item, self.cols)
             return self.matrix[i][j]
-        return self.__class__([self.matrix[k // self.cols][k % self.cols] for k in range(self.cols * self.rows)[item]])
+        return [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):
@@ -187,12 +187,12 @@ 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]):
+        if isinstance(other, Number) or type(other) is type(self.matrix[0][0]):
             return self.__class__([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 
     def __rmul__(self, other) -> "Matrix":
-        if isinstance(other, Number) or type(other) == type(self.matrix[0][0]):
+        if isinstance(other, Number) or type(other) is type(self.matrix[0][0]):
             return self.__class__([ [item * other for item in row] for row in self.matrix ])
         return NotImplemented
 

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/nt.py

@@ -9,6 +9,7 @@ Number theory tools:
     euler_phi(n) Euler phi function of n
     carmichael_lambda(n) Carmichael lambda function of n
     moebius_mu(n) Moebius function of n
+    is_carmichael_number(n) tests if a number is a Carmichael number
     order(a, n) oder of a in the multiplicative group Z_n^*
     crt([a1, a2, ...],[m1, m2, ...]) Chinese Remainder Theorem
 """
@@ -73,6 +74,8 @@ def convergents(cont_frac: list[int]) -> float:
 
 def legendre_symbol(a: int, p: int) -> int:
     """Compute the Legendre symbol of `a` with respect to the prime `p`."""
+    if not isinstance(p, int) or p < 2:
+        raise ValueError(f"{p} must be a prime.")
     a = a % p
     if a == 0:
         return 0
@@ -81,7 +84,9 @@ def legendre_symbol(a: int, p: int) -> int:
     return -1
 
 def jacobi_symbol(a: int, n: int) -> int:
-    """Compute the Jacobi symbol of `a` with respect to the integer `n`."""
+    """Compute the Jacobi symbol of `a` with respect to the odd integer `n`."""
+    if not isinstance(n, int) or n < 1 or not n % 2:
+        raise ValueError(f"{n} must be a positive odd integer.")
     # Crandall/Pomerance Algorithm 2.3.5
     a = a % n
     t = 1
@@ -143,6 +148,8 @@ def carmichael_lambda(n: int) -> int:
     """Carmichael's lambda function of `n`."""
     if not isinstance(n, int) or n < 1:
         raise ValueError(f"{n} is not a positive integer")
+    if n == 1:
+        return 1
     k = factorint(n)
     lam_all = []  # values corresponding to the prime factors
     for p in k:
@@ -168,6 +175,15 @@ def moebius_mu(n: int) -> int:
         return -1
     return 1
 
+def is_carmichael_number(n: int) -> bool:
+    """Tests if a number is a Carmichael number using Korselt's criterion."""
+    if n < 561:
+        return False
+    factors = factorint(n)
+    if len(factors) == 1:  # prime
+        return False
+    return max(factors.values()) == 1 and not any((n-1) % (p-1) for p in factors)
+
 # Order in Z_p^*
 
 def order(a: int, n: int, factor=False) -> int:
@@ -215,7 +231,12 @@ def crt(a: list[int], m: list[int], coprime = True) -> int:
     if l != len(a):
         raise ValueError("The lists of numbers and modules must have equal length.")
 
-    if not coprime: # make a copy
+    if not coprime:
+        if not all( (isinstance(mi, int) and mi > 1) for mi in m):
+            raise ValueError("Moduli must be positive integers larger than one.")
+        if not all( isinstance(ai, int) for ai in a):
+            raise ValueError("Residues must be integers.")
+        # make a copy
         m = [ mi for mi in m ]
         a = [ ai for ai in a ]
         for i in range(l):
@@ -224,7 +245,7 @@ def crt(a: list[int], m: list[int], coprime = True) -> int:
                 if g == 1: # moduli are coprime, nothing to be done
                     continue
                 if (a[i] - a[j]) % g:
-                     raise ValueError(f"Congruences not solvable!")
+                    raise ValueError("Congruences not solvable!")
                 for p, k in factorint(g).items():
                     p = p**k #  remove this factor from one of the equations
                     if gcd(m[i] // p, p) == 1:

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools/primes.py

@@ -13,9 +13,6 @@ Tools for prime numbers:
     random_blumprime(l) find a pseudorandom Blum prime with bit length at least l
     miller_rabin_test(n, b) Miller-Rabin primality test with base b
     lucas_test(n) strong Lucas test
-    perfect_square(n) test if a number is a perfect square
-    perfect_power(n) test if a number is a perfect power
-    iroot(k, n) integer k'th root of n
 """
 from math import isqrt, gcd, floor, ceil
 from random import randint
@@ -72,7 +69,7 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
         if a == 0:
             continue
         b = pow(a, m, n)
-        if b == 1 or b == n - 1:
+        if b in (1, n - 1):
             continue
         for _ in range(1, k):
             b = pow(b, 2, n)
@@ -110,40 +107,6 @@ def _lucas_sequence(n, D, k):
         Qk %= n
     return U % n, V % n, Qk
 
-
-def perfect_square(n: int) -> int|None:
-    """Returns the root if `n` is a perfect square and None else."""
-    s = isqrt(n)
-    if s*s == n:
-        return s
-
-def iroot(k: int, n: int) -> int:
-    """Compute the integer k'th root of n."""
-    if not isinstance(k, int) or n < 1:
-        raise ValueError(f"{k} is not a positive integer")
-    if k == 1:
-        return n
-    if k == 2:
-        return isqrt(n)
-    r = isqrt(n)
-    while r**k >= n:
-        rr = r
-        r = isqrt(r)
-    r =rr + 1
-    k1 = k-1
-    while rr < r:
-        r = rr
-        rr = (k1 * rr + n // rr ** k1) // k # Newton iteration
-    return r
-
-def perfect_power(n: int) -> tuple|None:
-    """Returns integers `(m, p)` with `m**p == n` if `n` is a perfect power and None else."""
-    for p in sieve_eratosthenes(n.bit_length() - 1):
-        m = iroot(p, n)
-        if pow(m, p) == n:
-            return (m, p)
-
-
 # https://en.wikipedia.org/wiki/Lucas_pseudoprime#Implementing_a_Lucas_probable_prime_test
 
 def lucas_test(n: int) -> bool:
@@ -152,9 +115,10 @@ def lucas_test(n: int) -> bool:
         return False
     if n % 2 == 0:
         return n == 2
-    if perfect_square(n) is not None:  # the search for D will not succeed in this case
+    s = isqrt(n)
+    if s * s == n:  # the search for D will not succeed in this case
         return False
-    
+
     # write n = k 2^s - 1
     k = (n + 1) // 2
     s = 1
@@ -163,7 +127,7 @@ def lucas_test(n: int) -> bool:
         s += 1
 
     # Selfridge method for choosing D
-    
+
     D = 5
     while True:
         g = gcd(abs(D), n)
@@ -189,6 +153,8 @@ def lucas_test(n: int) -> bool:
 
 def is_prime(n: int, trialdivision: bool = True) -> bool:
     """Test if an integer `n` if probable prime."""
+    if not isinstance(n, int) or n < 2:
+        return False
     # Test small primes
     if trialdivision:
         for p in (2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools.egg-info/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.8
+Version: 0.9.10
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
+License: MIT
 Project-URL: Homepage, https://github.com/teschlg/kryptools
+Project-URL: Source, https://github.com/teschlg/kryptools
 Project-URL: Issues, https://github.com/teschlg/kryptools/issues
 Project-URL: Docs, https://github.com/teschlg/kryptools/tree/main/doc
 Classifier: Programming Language :: Python :: 3

{kryptools-0.9.8 → kryptools-0.9.10}/kryptools.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ kryptools/factor_fmt.py
 kryptools/factor_pm1.py
 kryptools/factor_qs.py
 kryptools/factor_rho.py
+kryptools/intfuncs.py
 kryptools/la.py
 kryptools/lat.py
 kryptools/nt.py
@@ -24,4 +25,16 @@ kryptools/primes.py
 kryptools.egg-info/PKG-INFO
 kryptools.egg-info/SOURCES.txt
 kryptools.egg-info/dependency_links.txt
-kryptools.egg-info/top_level.txt
+kryptools.egg-info/top_level.txt
+tests/test_Zmod.py
+tests/test_dlog.py
+tests/test_ec.py
+tests/test_factor.py
+tests/test_factor_fmt.py
+tests/test_factor_qs.py
+tests/test_intfuncs.py
+tests/test_la.py
+tests/test_lat.py
+tests/test_nt.py
+tests/test_poly.py
+tests/test_primes.py

{kryptools-0.9.8 → kryptools-0.9.10}/pyproject.toml

@@ -1,11 +1,12 @@
 [project]
 name = "kryptools"
-version = "0.9.8"
+version = "0.9.10"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]
 description = "Implemenation of same basic algorithms used in cryptography."
 readme = "README.md"
+license = { text = "MIT" }
 requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -15,5 +16,6 @@ classifiers = [
 
 [project.urls]
 Homepage = "https://github.com/teschlg/kryptools"
+Source = "https://github.com/teschlg/kryptools"
 Issues = "https://github.com/teschlg/kryptools/issues"
 Docs = "https://github.com/teschlg/kryptools/tree/main/doc"

kryptools-0.9.10/tests/test_Zmod.py

@@ -0,0 +1,66 @@
+import pytest
+from math import gcd
+from kryptools import Zmod, euler_phi
+
+def test_Zmod_ops():
+	for n in range(2, 10):
+		Z_n = Zmod(n)
+		for a in range(n):
+			aa = Z_n(a)
+			bool(aa) == bool(a)
+			for i in range(4):
+				assert aa ** i == Z_n(pow(a, i, n))
+				if i == 0 or gcd(a, n) == 1:
+					assert aa ** -i == Z_n(pow(a, -i, n))
+				else:
+					with pytest.raises(ValueError):
+						aa ** -i
+			if gcd(a, n) == 1:
+				assert aa ** aa.order() == Z_n(1)
+			else:
+				with pytest.raises(ValueError):
+					aa.order()
+			for b in range(n):
+				bb = Z_n(b)
+				assert aa + bb == Z_n(a + b)
+				assert aa - bb == Z_n(a - b)
+				assert aa * bb == Z_n(a * b)
+				if gcd(b, n) == 1:
+					assert aa / bb == Z_n( a * pow(b, -1, n) )
+
+def test_Zmod_methods():
+	Z_5 = Zmod(5)
+	assert Z_5(3).order() == 4
+	assert Z_5(1).is_generator() == False
+	assert Z_5(3).is_generator() == True
+	assert Z_5.generator(all = True) == Z_5([2, 3])
+	assert Z_5.star() == Z_5([1, 2, 3, 4])
+	assert [Z_5(i).sharp() for i in range(Z_5.n)] == [0, 1, 2, -2, -1]
+	assert [abs(Z_5(i)) for i in range(Z_5.n)] == [0, 1, 2, 2, 1]
+	assert str(Z_5(3)) == "3"
+	Z_5.short = False
+	assert str(Z_5(6)) == "1 (mod 5)"
+
+	Z_6 = Zmod(6)
+	assert Z_6(5).order() == 2
+	with pytest.raises(ValueError):
+		Z_6(3).order()
+	assert Z_6(1).is_generator() == False
+	assert Z_6(5).is_generator() == True
+	assert Z_6.generator(all = True) == Z_6([5])
+	assert Z_6.star() == Z_6([1, 5])
+	assert str(Z_6(3)) == "3"
+
+def test_Zmod_order():
+	for n in range(2,10):
+		Z_n = Zmod(n)
+		assert Z_n.order() == euler_phi(n)
+
+OEIS_A033948 = [ 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 13, 14, 17, 18, 19, 22, 23, 25, 26, 27,
+	29, 31, 34, 37, 38, 41, 43, 46, 47, 49, 50, 53, 54, 58, 59, 61, 62, 67, 71, 73, 74,
+	79, 81, 82, 83, 86, 89, 94, 97, 98, 101, 103, 106, 107, 109, 113, 118, 121, 122, 125,
+	127, 131, 134, 137, 139 ]
+
+def test_Zmod_cyclic():
+	for n in range(2, OEIS_A033948[-1]+1):
+		assert Zmod(n).is_cyclic() == (n in OEIS_A033948)

kryptools-0.9.10/tests/test_dlog.py

@@ -0,0 +1,18 @@
+import pytest
+from random import randint, seed
+from kryptools import dlog
+
+seed(0)
+
+with pytest.raises(ValueError):
+	dlog(1, 3, 10)
+
+def test_dlogt():
+	for data in (
+			[557639, 278819, 2],
+			[24570203447, 12285101723, 2],
+			[28031135240181527, 14015567620090763, 2] ):
+		p, m, a = data  # m is the order of a in Z_p
+		x = randint(2, m - 1)
+		b = pow(a, x, p)
+		assert dlog(a, b, p) == x

kryptools-0.9.10/tests/test_ec.py

@@ -0,0 +1,27 @@
+import pytest
+from random import randint, seed
+from kryptools import EC_Weierstrass
+seed(0)
+
+
+def test_EC():
+	ec = EC_Weierstrass(239, 3, 1)
+	O = ec(None, None)  # point at infinity
+	assert O in ec
+	P = ec.random()
+	assert P in ec
+	Q = ec.random()
+	assert Q in ec
+	assert P + O == P
+	assert O + P == P
+	assert P - P == O
+	assert P + P == 2 * P
+	R = O
+	for i in range(5):
+		assert i * P == R
+		R += P
+	assert P + Q == Q + P
+	assert Q.order() * Q == O
+	k = randint(1, ec.order())
+	R = k * Q
+	assert R.dlog(Q) == k

kryptools-0.9.10/tests/test_factor.py

@@ -0,0 +1,18 @@
+import pytest
+from kryptools import factorint, is_prime
+
+def myprod(factors: dict) -> int:
+	n = 1
+	for p in factors:
+		assert is_prime(p)
+		n *= p**factors[p]
+	return n
+
+
+def test_factorint():
+	assert factorint(0) == {0: 1}
+	assert factorint(1) == {}
+	for n in ( 1489576198567193874913874619387459183543154617315437135656,
+				2**128 - 1,
+				4521089809**7 ):
+		assert n == myprod(factorint(n))

kryptools-0.9.10/tests/test_factor_fmt.py

@@ -0,0 +1,12 @@
+import pytest
+from math import prod
+from kryptools import is_prime
+from kryptools.factor_fmt import factor_fermat
+
+
+def test_fermat():
+	for n in range(1,1000):
+		factors = factor_fermat(n)
+		assert n == prod(factors)
+		if len(factors) == 1:
+			assert is_prime(n)

kryptools-0.9.10/tests/test_factor_qs.py

@@ -0,0 +1,9 @@
+import pytest
+from kryptools import is_prime
+from kryptools.factor_qs import factor_qs
+
+
+def test_qs():
+	for n in [ 832283, 2**32+1 ]:
+		m = factor_qs(n)
+		assert n % m == 0 and 1 < m and m < n

kryptools-0.9.10/tests/test_intfuncs.py

@@ -0,0 +1,78 @@
+import pytest
+from random import randint, seed
+from math import gcd
+from kryptools import sieve_eratosthenes, factorint
+from kryptools import iroot, ilog, perfect_square, perfect_power, prime_power
+seed(0)
+
+
+def test_iroot():
+	assert iroot(3, 0) == 0
+	assert iroot(3, 1) == 1
+	assert iroot(1, 3) == 3
+	for _ in range(100):
+		n = randint(0, 10**10)
+		for k in range(2, 5):
+			r = iroot(k, n)
+			assert r ** k <= n and (r+1) ** k > n
+
+def test_ilog():
+	for n in range(1, 10000):
+		for b in range(2,5):
+			l = ilog(b, n)
+			assert b**l <= n and b**(l+1) > n
+	for _ in range(1000):
+		n = randint(1, 10**10)
+		for b in range(2,5):
+			l = ilog(b, n)
+			assert b**l <= n and b**(l+1) > n
+
+def test_perfect_square():
+	for n in (-1, 0, 1):
+		assert perfect_square(n) == None
+	for n in range(2, 1000):
+		factors = factorint(n)
+		res = perfect_square(n) 
+		if all( not (k % 2) for k in factors.values()):
+			assert isinstance(res, int)
+			assert res**2 == n
+		else:
+			assert res == None
+
+def test_perfect_power():
+	for n in (-1, 0, 1):
+		assert perfect_power(n) == None
+	for n in range(2, 1000):
+		factors = factorint(n)
+		res = perfect_power(n)
+		g = gcd(*factors.values())
+		if g > 1:
+			assert isinstance(res, tuple)
+			assert res[0]**res[1] == n
+			n = -n
+			res = perfect_power(n)
+			while not g % 2:
+				g //= 2
+			if g > 1:
+				assert isinstance(res, tuple)
+				assert res[0]**res[1] == n
+			else:
+				assert res == None
+		else:
+			assert res == None
+			assert perfect_power(-n) == None
+
+def test_prime_power():
+	for n in (-1, 0, 1):
+		assert prime_power(n) == None
+	for p in sieve_eratosthenes(30):
+		for k in range(1,6):
+			assert prime_power(p**k) == (p, k)
+	for n in range(2, 1000):
+		factors = factorint(n)
+		res = prime_power(n)
+		if len(factors) > 1:
+			assert res is None
+		else:
+			p, k = res
+			assert n == p**k

kryptools-0.9.10/tests/test_la.py

@@ -0,0 +1,20 @@
+import pytest
+from fractions import Fraction
+from kryptools import Matrix, Zmod
+
+
+def test_Matrix():
+	M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]])
+	assert len(M) == 3 * 3
+	assert M[0] == 1
+	assert M[:] == [1, 2, 3, 4, 5, 6, 7, 8, 12]
+	assert 2 * M - M == M
+	M.map(Fraction)
+	Mi = M.inv()
+	assert M * Mi == M.eye()
+
+	Z_11 = Zmod(11)
+	assert 2 * M - M == M
+	M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 12]], ring=Z_11)
+	Mi = M.inv()
+	assert M * Mi == M.eye()

kryptools-0.9.10/tests/test_lat.py

@@ -0,0 +1,15 @@
+import pytest
+from fractions import Fraction
+from kryptools import Matrix, gram_schmidt, random_unimodular_matrix
+
+
+def test_gram_schmidt():
+	V = Matrix([[5, 8], [0, 1]], ring=Fraction)
+	Vs, M = gram_schmidt(V)
+	assert V == Vs * M
+
+def test_random_unimodular_matrix():
+	for i in range(2, 5):
+		U = random_unimodular_matrix(i)
+		U.map(Fraction)
+		assert U.det() in (-1, 1)

kryptools-0.9.10/tests/test_nt.py

@@ -0,0 +1,96 @@
+import pytest
+from random import randint, seed
+from math import prod, lcm
+from fractions import Fraction
+from kryptools import sieve_eratosthenes, is_prime
+from kryptools import egcd, crt, cf, convergents, legendre_symbol, jacobi_symbol, carmichael_lambda, euler_phi, moebius_mu, is_carmichael_number
+seed(0)
+
+
+def test_egcd():
+	for a in range(100):
+		for b in range(100):
+			g, x, y = egcd(a, b)
+			assert x * a + y * b == g
+
+def test_crt():
+	maxsize = 1000
+	numtests = 100
+	primes = sieve_eratosthenes(11)
+	n = prod(primes)
+	for _ in range(numtests):
+		x = randint(0, n-1)
+		assert x == crt([x % p for p in primes], primes)
+	for _ in range(numtests):
+		m = []
+		for _ in range(10):
+			m.append(randint(2, maxsize))
+		M = lcm(*m)
+		x = randint(0, M-1)
+
+def test_cf():
+	for x in (Fraction(21,11), Fraction(11,21), Fraction(1,3)):
+		assert convergents(cf(x))[-1] == x
+
+jacobi_data = (
+	(1, 1), (0, 1, -1, 0), (0, 1, -1, -1, 1, 0), (0, 1, 1, -1, 1, -1, -1, 0),
+	(0, 1, 1, 0, 1, 1, 0, 1, 1, 0), (0, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, 0),
+	(0, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 0),
+	(0, 1, 1, 0, 1, 0, 0, -1, 1, 0, 0, -1, 0, -1, -1, 0),
+	(0, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, -1, 1, 1, 0) )
+
+def test_jacobi_symbol():
+	for i in range(len(jacobi_data)):
+		n = 2 * i + 1
+		if is_prime(n):
+			for x in range(n+1):
+				assert jacobi_symbol(x, n) == jacobi_data[i][x]
+				assert jacobi_symbol(x, n) == legendre_symbol(x, n)
+		else:
+			for x in range(n+1):
+				assert jacobi_symbol(x, n) == jacobi_data[i][x]
+
+#https://oeis.org/A000010
+OEIS_A000010 = [
+		1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18, 8, 12, 10, 22, 8, 20,
+		12, 18, 12, 28, 8, 30, 16, 20, 16, 24, 12, 36, 18, 24, 16, 40, 12, 42, 20, 24, 22,
+		46, 16, 42, 20, 32, 24, 52, 18, 40, 24, 36, 28, 58, 16, 60, 30, 36, 32, 48, 20,
+		66, 32, 44 ]
+
+def test_euler_phi():
+	for n in range(1, len(OEIS_A000010)+1):
+		assert euler_phi(n) == OEIS_A000010[n - 1]
+
+#https://oeis.org/A002322
+OEIS_A002322 = [
+		1, 1, 2, 2, 4, 2, 6, 2, 6, 4, 10, 2, 12, 6, 4, 4, 16, 6, 18, 4, 6, 10, 22, 2, 20,
+		12, 18, 6, 28, 4, 30, 8, 10, 16, 12, 6, 36, 18, 12, 4, 40, 6, 42, 10, 12, 22, 46,
+		4, 42, 20, 16, 12, 52, 18, 20, 6, 18, 28, 58, 4, 60, 30, 6, 16, 12, 10, 66, 16,
+		22, 12, 70, 6, 72, 36, 20, 18, 30, 12, 78, 4, 54 ]
+
+def test_carmichael_lambda():
+	for n in range(1, len(OEIS_A002322)+1):
+		assert carmichael_lambda(n) == OEIS_A002322[n - 1]
+
+#https://oeis.org/A008683
+OEIS_A008683 = [
+		1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0, -1, 0, 1, 1, -1, 0,
+		0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1, 1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0,
+		0, 1, 0, -1, 0, 1, 0, 1, 1, -1, 0, -1, 1, 0, 0, 1, -1, -1, 0, 1, -1, -1, 0, -1, 1,
+		0, 0, 1, -1 ]
+
+def test_moebius_mu():
+	for n in range(1, len(OEIS_A008683)+1):
+		assert moebius_mu(n) == OEIS_A008683[n - 1]
+
+OEIS_A002997 = [ 561, 1105, 1729, 2465, 2821, 6601, 8911, 10585, 15841, 29341, 41041,
+	46657, 52633, 62745, 63973, 75361, 101101, 115921, 126217, 162401, 172081, 188461,
+	252601, 278545, 294409, 314821, 334153, 340561, 399001, 410041, 449065, 488881,
+	512461, 530881, 552721 ]
+
+def test_is_carmichael_number():
+	for n in range(OEIS_A002997[4]+2):
+		assert is_carmichael_number(n) == (n in OEIS_A002997)
+	for n in OEIS_A002997:
+		assert is_carmichael_number(n) == True
+

kryptools-0.9.10/tests/test_poly.py

@@ -0,0 +1,15 @@
+import pytest
+from kryptools import Poly, Zmod
+
+
+def test_Poly():
+	p = Poly([2, 0, 2])
+	q = Poly([1, 2, 3, 4])
+	d, m = q.divmod(p)
+	assert d * p + m == q
+	
+	Z_5 = Zmod(5)
+	p.map(Z_5)
+	q.map(Z_5)
+	d, m = q.divmod(p)
+	assert d * p + m == q

kryptools-0.9.10/tests/test_primes.py

@@ -0,0 +1,104 @@
+import pytest
+from math import isqrt
+from random import randint, seed
+from kryptools import sieve_eratosthenes, prime_pi, next_prime, previous_prime, is_prime, is_safeprime, miller_rabin_test, lucas_test
+seed(0)
+
+#https://oeis.org/A000040
+OEIS_A000010 = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
+	71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157,
+	163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,
+	257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353,
+	359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457,
+	461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571,
+	577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673,
+	677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797,
+	809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
+	919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021,
+	1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109,
+	1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223 ]
+
+def sieve(max: int) -> list:
+	is_prime = [True] * (max + 1)  # to begin with, all numbers are potentially prime
+	is_prime[0 :: 2] = [False] * (max // 2 + 1)
+	is_prime[1] = False
+	is_prime[2] = True
+
+	# sieve out the primes starting at 3 in steps of 2 (ignoring even numbers)
+	for p in range(3, isqrt(max - 1) + 2, 2):
+		if is_prime[p]: # sieve out all multiples; note that numbers p*q with q<p were already sieved out previously
+			pp = p * p
+			p2 = p + p
+			is_prime[pp :: p2] = [False] * ((max - pp) // p2 + 1)
+	return is_prime
+
+prime_test = sieve(OEIS_A000010[-1])
+assert [ p for p in range(OEIS_A000010[-1]+1) if prime_test[p] ] == OEIS_A000010
+
+def test_sieve_eratosthenes():
+	for i, p in enumerate(sieve_eratosthenes(OEIS_A000010[-1])):
+		assert p == OEIS_A000010[i]
+		if i > 0:
+			assert previous_prime(p-1) == OEIS_A000010[i-1]
+		if i < len(OEIS_A000010) - 1:
+			assert next_prime(p+1) == OEIS_A000010[i+1]
+
+#https://oeis.org/A000040
+OEIS_A000720 = [ 0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9,
+	9, 9, 9, 9, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 14, 14, 14, 14,
+	15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 17, 17, 18, 18, 18, 18, 18, 18, 19,
+	19, 19, 19, 20, 20, 21, 21, 21, 21, 21, 21 ]
+
+def test_prime_pi():
+	for n in range(1, len(OEIS_A000720)+1):
+		assert prime_pi(n) == OEIS_A000720[n - 1]
+
+max_sieve = 25326001
+prime_test = sieve(max_sieve)
+
+def test_is_prime():
+	for n in range(max_sieve + 1):
+		assert is_prime(n) == prime_test[n]
+
+OEIS_A005385 = [ 5, 7, 11, 23, 47, 59, 83, 107, 167, 179, 227, 263, 347, 359, 383, 467,
+	479, 503, 563, 587, 719, 839, 863, 887, 983, 1019, 1187, 1283, 1307, 1319, 1367, 1439,
+	1487, 1523, 1619, 1823, 1907, 2027, 2039, 2063, 2099, 2207, 2447, 2459, 2579, 2819,
+	2879, 2903, 2963 ]
+
+def test_is_safeprime():
+	for n in range(OEIS_A000720[-1]+2):
+		assert is_safeprime(n) == (n in OEIS_A005385)
+	for n in OEIS_A005385:
+		assert is_safeprime(n) == True
+
+OEIS_A014233 = [ 2047, 1373653, 25326001, 3215031751, 2152302898747, 3474749660383,
+	341550071728321, 341550071728321, 3825123056546413051, 3825123056546413051,
+	3825123056546413051, 318665857834031151167461, 3317044064679887385961981 ]
+
+if OEIS_A014233[2] > max_sieve:
+	prime_test = sieve(OEIS_A014233[2])
+
+def test_miller_rabin():
+	for i, n in enumerate(OEIS_A014233[0:3]):
+		bases = OEIS_A000010[:i+1]
+		assert miller_rabin_test(n, bases) == True
+		if i < 1:
+			for m in range(3, n, 2):
+				assert miller_rabin_test(m, bases) == prime_test[m]
+		else:
+			for _ in range(500 * i):
+				r = randint(2, n)
+				assert miller_rabin_test(m, bases) == prime_test[m]
+
+OEIS_A217255 = [ 5459, 5777, 10877, 16109, 18971, 22499, 24569, 25199, 40309, 58519,
+	75077, 97439, 100127, 113573, 115639, 130139, 155819, 158399, 161027, 162133, 176399,
+	176471, 189419, 192509, 197801, 224369, 230691, 231703, 243629, 253259, 268349,
+	288919, 313499, 324899 ]
+
+if OEIS_A217255[30] > max_sieve:
+	prime_test = sieve(OEIS_A217255[30])
+
+def test_lucas():
+	for m in range(2, OEIS_A217255[30]+1):
+		if not (lucas_test(m) == prime_test[m]):
+			assert m in OEIS_A217255