kryptools 0.9.3__tar.gz → 0.9.5__tar.gz

{kryptools-0.9.3 → kryptools-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.3
+Version: 0.9.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

{kryptools-0.9.3 → kryptools-0.9.5}/kryptools/__init__.py

@@ -3,7 +3,7 @@ Implemenation of same basic algorithms used in cryptography.
 """
 
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, order, crt
-from .primes import sieve_eratosthenes, prime_pi, is_prime, next_prime, previous_prime, random_prime, random_strongprime, is_safeprime, random_safeprime
+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 .factor import factorint, divisors
 from .dlp import dlog
 from .ec import EC_Weierstrass

{kryptools-0.9.3 → kryptools-0.9.5}/kryptools/poly.py

@@ -4,6 +4,14 @@ Polynomials
 
 from numbers import Number
 
+display_reversed = True
+
+def poly_style_reversed(value: bool = True) -> None:
+    "Change the order of the coefficients when displaying polynomials."
+    global display_reversed
+    display_reversed = value
+
+
 class Poly:
     """
     Represents a polynomial as a list of coefficients.
@@ -40,7 +48,7 @@ class Poly:
         return len(self.coeff)
 
     def __repr__(self):
-        def prx(i: int):
+        def prx(i: int) -> str:
             if i == 0:
                 return ""
             if i == 1:
@@ -51,7 +59,10 @@ class Poly:
             return str(self.coeff[0])
         plus = ""
         tmp = ""
-        for i in reversed(range(len(self.coeff))):
+        coef_range = range(len(self.coeff))
+        if display_reversed:
+            coef_range = reversed(coef_range)
+        for i in coef_range:
             s = self.coeff[i]
             if not s:
                 continue
@@ -70,11 +81,15 @@ class Poly:
                 pass
             try:
                 if plus and s < 0:
-                    tmp += " - " + str(-s) + " " + prx(i)
+                    tmp += " - " + str(-s)
+                    if i != 0:
+                        tmp += " " + prx(i)
                     continue
             except:
                 pass
-            tmp += plus + str(s) + " " + prx(i)
+            tmp += plus + str(s)
+            if i != 0:
+                tmp += " " + prx(i)
             plus = " + "
         return tmp.strip()
 

{kryptools-0.9.3 → kryptools-0.9.5}/kryptools/primes.py

@@ -12,8 +12,12 @@ Tools for prime numbers:
     is_blumprime(n) test if n is a Blum prime
     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
+from math import isqrt, gcd, floor, ceil
 from random import randint
 from .nt import jacobi_symbol
 
@@ -50,39 +54,168 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
     """Run a Miller-Rabin test with given bases on `n`."""
     if n < 2:
         return False
-    if n % 2 == 0:
+    if n % 2 == 0:  # make sure n is odd
         return n == 2
+
+    # write n = m 2^k + 1
     m = (n - 1) // 2
     k = 1
     while m % 2 == 0:
         m //= 2
         k += 1
+
     if isinstance(bases, int):
         bases = [bases]
+
     for a in bases:
+        a %= n
+        if a == 0:
+            continue
         b = pow(a, m, n)
         if b == 1 or b == n - 1:
-            return True
+            continue
         for _ in range(1, k):
             b = pow(b, 2, n)
-            if b == 1:
+            if b == 0:  # n and a are not coprime
+                return False
+            if b == 1:  # 1 before -1
                 return False
             if b == n - 1:
-                return True
+                break
+        else: # no -1 found
+            return False
+    return True
+
+def _lucas_sequence(n, D, k):
+    """Evaluate a Lucas sequence."""
+    # P = 1
+    Q = (1 - D)//4
+    U = 1
+    V = 1
+    Qk = Q
+    b = k.bit_length()
+    while b > 1:
+        U = (U * V) % n
+        V = (V * V - 2 * Qk) % n
+        Qk *= Qk
+        b -= 1
+        if (k >> (b - 1)) & 1:
+            U, V = U + V, V + U * D
+            if U & 1:
+                U += n
+            if V & 1:
+                V += n
+            U, V = U >> 1, V >> 1
+            Qk *= Q
+        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)
+    rr = isqrt(n)
+    r =rr + 1
+    k1 = k-1
+    while rr < r:
+        r = rr
+        rr = (k1 * r + n // r ** 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:
+    """Run a strong Lucas primality test on `n`."""
+    if n < 2:
+        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
+        return False
+    
+    # write n = k 2^s - 1
+    k = (n + 1) // 2
+    s = 1
+    while k % 2 == 0:
+        k //= 2
+        s += 1
+
+    # Selfridge method for choosing D
+    
+    D = 5
+    while True:
+        g = gcd(abs(D), n)
+        if 1 < g < n:
+            return False
+        if jacobi_symbol(D, n) == -1:
+            break
+        if D > 0:
+            D = -D - 2
+        else:
+            D = -D + 2
+
+    U, V, Qk = _lucas_sequence(n, D, k)
+
+    if U == 0 or V == 0:
+        return True
+    for _ in range(1, s):
+        V = (V*V - 2*Qk) % n
+        if V == 0:
+            return True
+        Qk = pow(Qk, 2, n)
     return False
 
 def is_prime(n: int) -> bool:
     """Test if an integer `n` if probable prime."""
+    # Test small primes
+    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,
+              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):
+        if n % p == 0:
+            return n == p
     if n < 18446744073709551616:  # https://miller-rabin.appspot.com
         return miller_rabin_test(n, [2, 325, 9375, 28178, 450775, 9780504, 1795265022])
     if n < 3317044064679887385961981:
         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
+    return miller_rabin_test(n, [2]) and lucas_test(n)  # Baillie–PSW primality test
+
+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 is_blumprime(p: int) -> bool:
+    """Tests if a number is a Blum prime."""
+    return p % 4 == 3 and is_prime(p)
+
+
+# Generation of primes
+
 
 def next_prime(n: int) -> int:
     """Find the next prime larger or equal `n`."""
     if n < 3:
         return 2
+    n = ceil(n)
     n |= 1  # make sure n is odd
     while not is_prime(n):
         n += 2
@@ -92,6 +225,7 @@ def previous_prime(n: int) -> int:
     """Find the previous prime smaller or equal `n`."""
     if n < 3:
         return 2
+    n = floor(n)
     n += (n & 1) - 1  # make sure n is odd
     while not is_prime(n):
         n -= 2
@@ -116,87 +250,18 @@ def random_strongprime(l: int) -> int:
         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 pseudorandom 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
+    p = p - (p % 24) + 23  # make sure p % 24 = 23
     while not is_safeprime(p):
         p += 24
     return p
 
-def is_blumprime(p: int) -> bool:
-    """Tests if a number is a Blum prime."""
-    return p % 4 == 3 and is_prime(p)
-
 def random_blumprime(l: int) -> int:
     """Find a pseudorandom Blum prime with bit length at least `l`."""
     p = randint(2 ** (l - 1), 2**l - 1)
-    p = p - (p % 4) + 3
+    p = p - (p % 4) + 3  # make sure p % 4 = 3
     while not is_prime(p):
         p += 4
     return p
-
-def _lucas_sequence(n, D, k):
-    """Evaluate a Lucas sequence."""
-    # P = 1
-    Q = (1 - D)//4
-    U = 1
-    V = 1
-    Qk = Q
-    b = k.bit_length()
-    while b > 1:
-        U = (U * V) % n
-        V = (V * V - 2 * Qk) % n
-        Qk *= Qk
-        b -= 1
-        if (k >> (b - 1)) & 1:
-            U, V = U + V, V + U * D
-            if U & 1:
-                U += n
-            if V & 1:
-                V += n
-            U, V = U >> 1, V >> 1
-            Qk *= Q
-        Qk %= n
-    return U % n, V % n, Qk
-
-
-def _is_strong_lucas_prp(n: int) -> bool:
-    """Strong Lucas primality test."""
-
-    # remove powers of 2 from n+1 (= k * 2**s)
-    k = (n + 1) // 2
-    s = 1
-    while k % 2 == 0:
-        k //= 2
-        s += 1
-    # gernerate parameters
-    D = 5
-    while True:
-        g = gcd(abs(D), n)
-        if 1 < g < n:
-            return False
-        if jacobi_symbol(D, n) == -1:
-            break
-        if D > 0:
-            D = -D - 2
-        else:
-            D = -D + 2
-
-    if D == 0:
-        return False
-
-    U, V, Qk = _lucas_sequence(n, D, k)
-
-    if U == 0 or V == 0:
-        return True
-    for _ in range(1, s):
-        V = (V*V - 2*Qk) % n
-        if V == 0:
-            return True
-        Qk = pow(Qk, 2, n)
-    return False

{kryptools-0.9.3 → kryptools-0.9.5}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.3
+Version: 0.9.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

{kryptools-0.9.3 → kryptools-0.9.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kryptools"
-version = "0.9.3"
+version = "0.9.5"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]