kryptools 0.9.2__tar.gz → 0.9.4__tar.gz

{kryptools-0.9.2 → kryptools-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.2
+Version: 0.9.4
 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.2 → kryptools-0.9.4}/kryptools/Zmod.py

@@ -62,6 +62,26 @@ class Zmod:
             self.group_order *= p**k
         return self.group_order
 
+    def generator(self, all = False) -> int:
+        """Return a generator of the group Z_n^*."""
+        for a in range(2, self.n):
+            if gcd(a, self.n) > 1:
+                continue
+            a = self(a)
+            if a.is_generator():
+                if all:
+                    self.order()
+                    return list( a**j for j in range(1, self.group_order) if gcd(j,self.group_order) == 1 )
+                return a
+
+    def star(self) -> int:
+        """Return a list of all elements of the group Z_n^*."""
+        elements = [ 1 ]
+        for a in range(2, self.n):
+            if gcd(a, self.n) > 1:
+                continue
+            elements.append(self(a))
+        return elements
 
 class ZmodPoint:
     "Represents a point in the ring Zmod."

{kryptools-0.9.2 → kryptools-0.9.4}/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, 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.2 → kryptools-0.9.4}/kryptools/primes.py

@@ -1,16 +1,20 @@
 """
 Tools for prime numbers:
     sieve_eratosthenes(B) a tuple of all primes up to including B
+    prime_pi(n) number of primes below or equal n
     is_prime(n) test if n is probably prime
     next_prime(n) find the next prime larger or equal n
     previous_prime(n) find the previous prime smaller or equal n
     random_prime(l) find a pseudorandom prime with bit length at least l
     random_strongprime(l) find a pseudorandom strong prime with bit length at least l
     is_safeprime(n) test if n is a safe prime
-    random_safeprime(n) find a pseudorandom safe prime with bit length at least l and ord(2)=(p-1)/2
+    random_safeprime(l) find a pseudorandom safe prime with bit length at least l and ord(2)=(p-1)/2
+    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
 """
-from math import isqrt, gcd
+from math import isqrt, gcd, floor, ceil
 from random import randint
 from .nt import jacobi_symbol
 
@@ -18,6 +22,11 @@ from .nt import jacobi_symbol
 
 def sieve_eratosthenes(B: int) -> tuple:
     """Returns a tuple of all primes up to (including) `B`."""
+    if B < 2:
+        return ()
+    if B < 3:
+        return [2]
+    B= floor(B)
     B1 = (isqrt(B) - 1)//2
     B = (B - 1)//2
     isprime = [True] * (B + 1)  # to begin with, all odd numbers are potentially prime
@@ -30,6 +39,11 @@ def sieve_eratosthenes(B: int) -> tuple:
 
     return tuple([2] + [2 * q + 1 for q in range(1, B + 1) if isprime[q]])
 
+def prime_pi(x: float) -> int:
+    """Prime-counting function pi(x). Returns the number of primes below or equal `x`."""
+    return len(sieve_eratosthenes(x))
+
+
 # Primality testing
 
 
@@ -58,63 +72,6 @@ def miller_rabin_test(n: int, bases: list[int] | int) -> bool:
                 return True
     return False
 
-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])
-    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
-
-def next_prime(n: int) -> int:
-    """Find the next prime larger or equal `n`."""
-    if n < 3:
-        return 2
-    n |= 1  # make sure n is odd
-    while not is_prime(n):
-        n += 2
-    return n
-
-def previous_prime(n: int) -> int:
-    """Find the previous prime smaller or equal `n`."""
-    if n < 3:
-        return 2
-    n += (n & 1) - 1  # make sure n is odd
-    while not is_prime(n):
-        n -= 2
-    return n
-
-def random_prime(l: int) -> int:
-    """Find a pseudorandom 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 pseudorandom 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 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
-    while not is_safeprime(p):
-        p += 24
-    return p
-
 def _lucas_sequence(n, D, k):
     """Evaluate a Lucas sequence."""
     # P = 1
@@ -140,8 +97,8 @@ def _lucas_sequence(n, D, k):
     return U % n, V % n, Qk
 
 
-def _is_strong_lucas_prp(n: int) -> bool:
-    """Strong Lucas primality test."""
+def lucas_test(n: int) -> bool:
+    """Run a strong Lucas primality test on `n`."""
 
     # remove powers of 2 from n+1 (= k * 2**s)
     k = (n + 1) // 2
@@ -175,3 +132,78 @@ def _is_strong_lucas_prp(n: int) -> bool:
             return True
         Qk = pow(Qk, 2, n)
     return False
+
+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])
+    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 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
+    return n
+
+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
+    return n
+
+def random_prime(l: int) -> int:
+    """Find a pseudorandom 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 pseudorandom 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 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  # make sure p % 24 = 23
+    while not is_safeprime(p):
+        p += 24
+    return 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  # make sure p % 4 = 3
+    while not is_prime(p):
+        p += 4
+    return p

{kryptools-0.9.2 → kryptools-0.9.4}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.2
+Version: 0.9.4
 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.2 → kryptools-0.9.4}/pyproject.toml

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