kryptools 0.9.8__tar.gz → 0.9.9__tar.gz

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

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

@@ -30,7 +30,11 @@ class Zmod:
         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):
@@ -76,7 +80,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.9}/kryptools/__init__.py

@@ -5,7 +5,7 @@ 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.9"
 __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

{kryptools-0.9.8 → kryptools-0.9.9}/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.9}/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})")
 

{kryptools-0.9.8 → kryptools-0.9.9}/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.9}/kryptools/factor_fmt.py

@@ -2,7 +2,7 @@
 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:

{kryptools-0.9.8 → kryptools-0.9.9}/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.9}/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.8 → kryptools-0.9.9}/kryptools/la.py

@@ -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.9}/kryptools/nt.py

@@ -143,6 +143,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:
@@ -224,7 +226,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.9}/kryptools/primes.py

@@ -72,7 +72,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)
@@ -154,7 +154,7 @@ def lucas_test(n: int) -> bool:
         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
@@ -163,7 +163,7 @@ def lucas_test(n: int) -> bool:
         s += 1
 
     # Selfridge method for choosing D
-    
+
     D = 5
     while True:
         g = gcd(abs(D), n)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.9.8
+Version: 0.9.9
 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.8 → kryptools-0.9.9}/kryptools.egg-info/SOURCES.txt

@@ -24,4 +24,13 @@ 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_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.9}/pyproject.toml

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

kryptools-0.9.9/tests/test_Zmod.py

@@ -0,0 +1,51 @@
+import pytest
+from math import gcd
+from kryptools import Zmod
+
+def test_Zmod():
+	for n in [5, 6]:
+		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) )
+
+	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"

kryptools-0.9.9/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.9/tests/test_ec.py

@@ -0,0 +1,25 @@
+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
+	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.9/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.9/tests/test_la.py

@@ -0,0 +1,15 @@
+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]])
+	M.map(Fraction)
+	Mi = M.inv()
+	assert M * Mi == M.eye()
+
+	Z_11 = Zmod(11)
+	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.9/tests/test_lat.py

@@ -0,0 +1,9 @@
+import pytest
+from fractions import Fraction
+from kryptools import Matrix, gram_schmidt
+
+
+def test_gram_schmidt():
+	V = Matrix([[5, 8], [0, 1]], ring=Fraction)
+	Vs, M = gram_schmidt(V)
+	assert V == Vs * M

kryptools-0.9.9/tests/test_nt.py

@@ -0,0 +1,38 @@
+import pytest
+from kryptools import carmichael_lambda, euler_phi, moebius_mu
+
+#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]
+
+
+

kryptools-0.9.9/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.9/tests/test_primes.py

@@ -0,0 +1,27 @@
+import pytest
+from kryptools import sieve_eratosthenes, prime_pi, next_prime, previous_prime
+
+
+#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 ]
+
+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]