kryptools 0.1__tar.gz → 0.3__tar.gz

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

@@ -1,10 +1,11 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.1
+Version: 0.3
 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
 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
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -33,3 +34,6 @@ The tools contained are:
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
 * Poly: a class for polynomials (division, modulo)
 * Zmod: a class for the ring of integers modulo an integer
+
+Documentation can be found in the jupyter notebook
+(currently incomplete: use the force, read the source).

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

@@ -19,3 +19,6 @@ The tools contained are:
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
 * Poly: a class for polynomials (division, modulo)
 * Zmod: a class for the ring of integers modulo an integer
+
+Documentation can be found in the jupyter notebook
+(currently incomplete: use the force, read the source).

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

@@ -2,12 +2,12 @@
 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 .factor import factorint
 from .dlp import dlog
 from .ec import EC_Weierstrass
-from .factor import factorint
-from .la import Matrix
-from .lat import hermite_nf, gram_schmidt, lll
-from .nt import cf, convergents, jacobi_symbol, sqrt_mod, euler_phi, order, carmichael_lambda
+from .la import Matrix, zeros, eye
+from .lat import gram_det, hadamard_ratio, hermite_nf, gram_schmidt, babai_round_cvp, babai_plane_cvp, lagrange_lr, lll, random_unimodular_matrix
 from .poly import Poly
-from .primes import sieve_eratosthenes, isprime
 from .Zmod import Zmod

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

@@ -28,10 +28,9 @@ def _dlog_switch(a: int, b: int, n: int, m: int) -> int:
     """Compute the discrete log_a(b) in Z_n of an element a of order m choosing an appropriate method."""
     if m < 1000:
         return dlog_naive(a, b, n, m)
-    elif log(m) - 6 < 2 * sqrt(log(n) * log(log(n))):  # compare the theoreticaly expected running times ob bsgs and ic; the constant 6 is determined experimentally
+    if log(m) - 6 < 2 * sqrt(log(n) * log(log(n))):  # compare the theoreticaly expected running times ob bsgs and ic; the constant 6 is determined experimentally
         return dlog_bsgs(a, b, n, m)
-    else:
-        return dlog_qs(a, b, n, m)
+    return dlog_qs(a, b, n, m)
 
 def _dlog_ph(a: int, b: int, n: int, q: int, k: int) -> int:
     """Compute the discrete log_a(b) in Z_n of an element a of order q^k using Pohlig-Hellman reduction."""

{kryptools-0.1 → kryptools-0.3}/kryptools/dlp_ic.py

@@ -3,9 +3,10 @@ Discrete log solvers: Index calculus
 """
 
 from math import gcd
-from random import randint
+from random import randint, seed
 from .primes import sieve_eratosthenes
 from .dlp_qs import determine_factorbound, determine_trialdivison_bounds, is_smooth
+seed(0)
 
 def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int = 0) -> int:
     """Compute the discrete log_a(b) in Z_p of an element a of prime order m using Index Calculus."""
@@ -68,7 +69,7 @@ def dlog_ic(a: int, b: int, n: int, m: int, pollard: bool = True, verbose: int =
             rinv = pow(ri, -1, m)
             relation[i] = 1
             for j in range(i+1, len_relations + 1):
-                    relation[j] = rinv * relation[j] % m
+                relation[j] = rinv * relation[j] % m
             relations[i] = relation
             if verbose > 2:
                 print(n_relations, f"rel found (index={i}) :", relation)

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

@@ -2,10 +2,11 @@
 Discrete log solvers: Quadratic sieve
 """
 
+from math import exp, log, sqrt, gcd, isqrt
+from random import randint, seed
 from .nt import sqrt_mod
 from .primes import sieve_eratosthenes
-from math import exp, log, sqrt, gcd
-
+seed(0)
 
 def determine_factorbound(n: int) -> (int, int):
     """Determines the optimal factor bound and the expected number of trys until a for a given n."""
@@ -49,18 +50,18 @@ def is_smooth(n: int, factorbase: list, factorbase_len: int, smallprimes_len: in
         while n % p == 0:  # divide by p as many times as possible
             factors[i] += 1
             n = n // p
-    if pollard_k: 
+    if pollard_k:
         if gcd(pow(2, pollard_k, n)-1, n) == 1: # Pollard p-1 test
             return None  # most likely not smooth, give up
         for i in range(smallprimes_len, factorbase_len):
             p = factorbase[i]
             while n % p == 0:  # divide by p as many times as possible
                 factors[i] += 1
-                n = n // p    
+                n = n // p
     if n != 1:
         return None  # the number factors if at the end nothing is left
     return factors
-    
+
 def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor: float = None, verbose: int = 0) -> int:
     """
     Compute the discrete log_a(b) in Z_p of an element a of prime order m using Index Calculus with a quadratic sieve.
@@ -103,7 +104,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
             relation += [ 0, x ]
         relation = [0] * sieve_bound + relation # sieve values + primes + b + x
         return relation
-    
+
    # this functions does the linear algebra
     def process_relation(relation: list) -> None or int:
         """Add a new relation to the linear system and keep the system in echelon form."""
@@ -121,10 +122,10 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                     relation[j] = (relation[j] - ri * relations[i][j]) % m
                 continue
             # normalize the first nonzero entry
-            rinv = pow(ri, -1, m)  
+            rinv = pow(ri, -1, m)
             relation[i] = 1
             for j in range(i+1, len_relations + 1):
-                    relation[j] = rinv * relation[j] % m
+                relation[j] = rinv * relation[j] % m
             relations[i] = relation
             if verbose > 2:
                 print(n_relations, f"rel found (index={i}) :", relation)
@@ -142,8 +143,8 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
         #        if ri > 0:
         #            relations[i][index] = 0
         #            for j in range(index+1, len_relations + 1):
-        #                relations[i][j] = (relations[i][j] - ri * relation[j]) % m           
-        #print(n_relations, f"i={i}={index} ({len_relations})", relations)       
+        #                relations[i][j] = (relations[i][j] - ri * relation[j]) % m
+        #print(n_relations, f"i={i}={index} ({len_relations})", relations)
         if index == len_relations - 1:  # we found the solution
             if verbose:
                 print(f"Success after {n_relations} relations out of {len_relations}.")
@@ -159,7 +160,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     # Determine the parameters
     #
 
-    B, expected_trys, expected_trys2 = determine_factorbound(n) 
+    B, expected_trys, expected_trys2 = determine_factorbound(n)
     max_trys = 10 * expected_trys
     factorbase = []
     factorbase = tuple(p for p in sieve_eratosthenes(B) if gcd(p,n) == 1)  # compute the factorbse
@@ -171,7 +172,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     if pollard:  # should we speed up trial division with Pollard p-1
         smallprimes_len, pollard_k = determine_trialdivison_bounds(B // 150, factorbase)
     no_sieve_bound = 1  # We do not sieve for primes smaller than this bound (not worth the effort)
-    no_sieve_primes = [ ]  
+    no_sieve_primes = [ ]
     for i in range(factorbase_len):
         if factorbase[i] > no_sieve_bound:
             break
@@ -194,7 +195,7 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     #
     # Do the sieving
     #
-    
+
     sn = isqrt(n - 1) + 1 # ceil(sqrt(n))
     d = sn**2 - n
     sn2 = 2 * sn
@@ -202,7 +203,6 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
     for j in range(sieve_bound):
         # we sieve with respect to the quadratic polynomial f_j(x) = (x+sn)*(x+j+sn) - n = x^2 + (2*sn+j)*x + (d+j*sn)
         snj = sn2 + j
-        snj2 = snj**2
         dj = d + j * sn
         max_j = sieve_bound - j
         for i in range(factorbase_len):
@@ -293,5 +293,5 @@ def dlog_qs(a: int, b: int, n: int, m: int, pollard: bool = True, sieve_factor:
                 res = process_relation(relation)
                 if res:
                     return(res)
- 
+
     raise Exception(f"Sorry, Quadratic sieve could not find enough relations! ({n_relations} - {n_relations_redundant} = {n_relations - n_relations_redundant} out of {len_relations}). Try to increase sieve_factor={sieve_factor}")

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

@@ -26,12 +26,13 @@ class EC_Weierstrass():
     >>> P + Q
     (195, 41)
     """
+    # pylint: disable=too-many-instance-attributes
 
     def __init__(self, p: int, a: int, b: int, order: int = None):
         if p < 3:
             raise ValueError(f"{p} must be a prime larger than 2.")
         if (4 * pow(a, 3, p) + 27 * pow(b, 2, p) ) % p == 0:
-            raise ValueError(f"Curve is singular!")
+            raise ValueError("Curve is singular!")
         self.p = p
         self.gf = Zmod(p, short = True)
         self.a = self.gf(a % p)
@@ -44,9 +45,9 @@ class EC_Weierstrass():
     def __call__(self, x: int | str | None = None, y: int | None = None, short: bool = False):
         if isinstance(x, str):
             x = x.replace(" ", "")
-            type = x[:2]
+            coordinate_type = x[:2]
             x = x[2:]
-            if type == '02' or type == '03':
+            if coordinate_type in ('02', '03'):
                 short = 1
                 x = int(x, 16)
                 if type == '02':
@@ -70,15 +71,17 @@ class EC_Weierstrass():
         return P.y**2 == P.x**3 + self.a * P.x + self.b
 
     def info(self):
-        format = "Weierstrass curve y^2 = x^3"
+        "Display some basic info on the curve"
+        out = "Weierstrass curve y^2 = x^3"
         if int(self.a):
-            format += f" + {self.a} x"
+            out += f" + {self.a} x"
         if int(self.b):
-            format += f" + {self.b}"
-        format += f" over Z_{self.p}."
-        print(format)
+            out += f" + {self.b}"
+        out += f" over Z_{self.p}."
+        print(out)
 
     def add(self, x1, y1, x2, y2):
+        "Point addition"
         if x1 is None:
             return x2, y2
         if x2 is None:
@@ -93,6 +96,7 @@ class EC_Weierstrass():
         return x3, y3
 
     def dbl(self, x, y):
+        "Point doubling"
         if x is None or not y:
             return None, None
         s = (3 * x**2 + self.a) / (2 * y)
@@ -101,6 +105,7 @@ class EC_Weierstrass():
         return x3, y3
 
     def mult(self, j: int, x, y):  # Addition-subtraction ladder
+        "Point multiplication"
         if j == 0:
             return None, None
         if j < 0:
@@ -126,6 +131,7 @@ class EC_Weierstrass():
         return xx, yy
 
     def random(self):
+        "Return a random point."
         j = -1
         while j == -1:
             x = self.gf(randint(0, self.p - 1))
@@ -134,6 +140,7 @@ class EC_Weierstrass():
         return ECPoint(x, randint(0, 1), self, short = True)
 
     def order(self, order: int = None) -> int:
+        "Return the group order."
         if order:
             self.group_order = order
         elif not self.group_order:
@@ -144,6 +151,7 @@ class EC_Weierstrass():
         return self.group_order
 
     def factor_order(self) -> dict:
+        "Factor the group order."
         if self.group_order_factors:
             return self.group_order_factors
         if not self.group_order:
@@ -152,6 +160,7 @@ class EC_Weierstrass():
         return self.group_order_factors
 
     def order_naive(self) -> int:
+        "Return the order of the group by adding the Legendre symbols."
         a1 = (int(self.a) + 1) % self.p
         y = int(self.b)
         order = self.p + 1 + legendre_symbol(y, self.p)
@@ -161,6 +170,7 @@ class EC_Weierstrass():
         return order
 
     def order_shanks_mestre(self) -> int:
+        "Return the order of the group using the Shanks-Mestre algorithm."
         if self.p < 230:
             return self.order_naive()
         j = 1
@@ -215,7 +225,7 @@ class EC_Weierstrass():
 
 class ECPoint:
     "Point on an elliptic curve"
-    def __init__(self, x: int, y: int, curve: EC_Weierstrass, short:bool = False):
+    def __init__(self, x: int|None, y: int|None, curve: EC_Weierstrass, short:bool = False):
         self.curve = curve
         if x is None:
             self.x = None
@@ -343,7 +353,7 @@ class ECPoint:
     def dlog_naive(Q, P: "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__):
-            raise ValueError(f"Points must be on the same curve!")
+            raise ValueError("Points must be on the same curve!")
         j = 0
         xx, yy = None, None
         while xx != Q.x:
@@ -358,7 +368,7 @@ class ECPoint:
     def dlog_bsgs(Q, P: "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__):
-            raise ValueError(f"Points must be on the same curve!")
+            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
@@ -372,7 +382,7 @@ class ECPoint:
         giant_stride = -mm * P
         giant_step = Q
         for l in range(mm+1):
-            if giant_step.x == None:
+            if giant_step.x is None:
                 return l * mm
             if int(giant_step.x) in baby_steps:
                 j = baby_steps[int(giant_step.x)][0]

kryptools-0.3/kryptools/factor_dix.py

@@ -0,0 +1,107 @@
+"""
+Integer factorization: Dixon's method
+"""
+
+from math import isqrt, gcd, sqrt, log, exp, ceil
+from .primes import sieve_eratosthenes
+from .nt import legendre_symbol
+from .factor_qs import bytexor, byteset, bytetest
+
+def is_smooth(n: int, factorbase: list, lfb: int) -> bytes or None:
+    """Try to factor n with respect to a given factorbase.
+    Upon success a bytestring, whose bits are the exponents with repect to the factorbase mod 2, is returned.
+    Otherwise None."""
+    factors = bytearray(b"\x00") * lfb  # we store the exponents mod 2 as bits
+    if n < 0:
+        byteset(factors, 0)
+        n *= -1
+    for i, p in enumerate(factorbase):
+        k = 0
+        while n % p == 0:  # divide by p as many times as possible
+            k = (k + 1) % 2  # we only need the exponents mod 2
+            n = n // p
+        if k:
+            byteset(factors, i + 1)
+    if n != 1:
+        return None  # the number factors if at the end nothing is left
+    return factors
+
+def factor_dixon(n: int) -> list:
+    """Find factors of n using the method of Dixon."""
+    # first determine the bound B for the factorbase: Choosing B=p^(1/u) Canfield-Erdös-Pomerance gives us
+    # the expected running time |B|^2 u^u = u^(u+2) p^(2/u)/log(n). There is no explicit expression for the optimum, hence
+    # we use Newton
+    u = 2 * sqrt(log(n) / log(log(n)))  # asymptotic value
+    for _ in range(3):
+        u = (2 * log(n) + u * u * (2 + log(u))) / (
+            2 + 3 * u + 2 * u * log(u)
+        )  # Newton iteration
+    B = int(exp(log(n) / u))
+
+    # B = int(exp(0.5 * sqrt( log(n) * log(log(n)) )*( 1 + 1/log(log(n)) )))
+    factorbase = []
+    for p in sieve_eratosthenes(B):  # compute the factorbase
+        ls = legendre_symbol(n, p)
+        if ls == 0:  # we already found a factor;-)
+            if n == p:
+                return n
+            return p
+        if ls == 1:  # we only take primes such that n is quadratic residue
+            factorbase.append(p)
+    lf = len(factorbase) + 1  # length of the factorbase (including -1)
+    lfb = ceil(lf / 8)  # the number of bytes we need to store a relation
+    m = isqrt(n - 1) + 1
+    def process_relation(j: int, relation: bytes):
+        nonlocal relation_no, values, relations
+        relation_no += 1
+        rhs = bytearray(b"\x00") * lfb # construct the k'th row of the identity matrix
+        byteset(rhs, relation_no)
+        relation += rhs  # extend the relation with this row
+        values[relation_no] = j  # store the value which lead to the relation
+        # do the Gauss elimination
+        index = lf # this will be the index of the first nonzero entry
+        # print(f'{j:3}', ' '.join(f'{b:08b}' for b in reversed(relation)))
+        for i in range(lf):
+            if bytetest(relation, i) and relations[i] is not None:  # make this entry zero if we can (Gauss elimination)
+                bytexor(relation, relations[i])
+            if bytetest(relation, i) and index == lf:  # is this the index of the first nonzero entry?
+                index = i
+        # print(f'{j:3}', ' '.join(f'{b:08b}' for b in reversed(relation)))
+        if index == lf:  # the new relation is linearly dependent: we have found a linear combination of the 0 vector
+            # now we need to determine the factors
+            u = 1  # product over all values m - j such that f(m-j) is B-smooth
+            v = 1  # sqrt of the product over all f(m-j) which are B-smooth
+            w = 1  # save nonsquare terms for the next round
+            for i in range(lf):
+                if bytetest(relation, lfb * 8 + i):  # select the relations which sum to the 0 vector
+                    ui = m + values[i]
+                    u = (u * ui) % n
+                    vi = ui ** 2 - n
+                    d = gcd(w, vi)
+                    v = (v * d) % n  # sqrt of the part which is already square
+                    w = (w // d) * (vi // d)  # this part is not square yet
+            v = v * isqrt(w) % n
+            res = gcd(u - v, n)
+            if 1 < res < n:
+                return res
+            relation_no -= 1  # this one did not work, try again
+        else:
+            relations[index] = relation
+        return None
+
+    relation_no = -1
+    relations = [None] * lf  # here we will store the relations in case we found a B-smooth number
+    values = [None] * lf  # here we will store the values leading to the B-smooth numbers
+    for j in range(1,m): # loop over j=0,1,-1,2,-2,...
+        if j & 1 == 0:
+            j >>= 1
+        else:
+            j >>= 1
+            j *= -1
+        relation = is_smooth((j + m) ** 2 - n, factorbase, lfb)  # test if f(j) is B-smooth
+        if relation is None:
+            continue
+        res = process_relation(j, relation)
+        if res:
+            return res
+    return n

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

@@ -11,6 +11,7 @@ from .primes import sieve_eratosthenes
 
 
 def dbl(P, c2, p):
+    "EC Montgommery point doubling"
     # c2 = c - 2
     t1 = (P[0] + P[1]) % p
     t2 = (P[0] - P[1]) % p
@@ -19,12 +20,14 @@ def dbl(P, c2, p):
 
 
 def add(P1, P2, P3, p):
+    "EC Montgommery point addition"
     t1 = pow(P1[0] * P2[0] - P1[1] * P2[1], 2, p)
     t2 = pow(P1[0] * P2[1] - P2[0] * P1[1], 2, p)
     return P3[1] * t1 % p, P3[0] * t2 % p
 
 
 def mult(k, P, c2, p):
+    "EC Montgommery point multiplication"
     if k == 1:
         return P
     if k == 2:

kryptools-0.3/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 = []
+    # 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

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

@@ -2,7 +2,7 @@
 Linear algebra
 """
 
-from math import sqrt, prod
+from math import inf, sqrt, prod
 
 class Matrix:
     """
@@ -48,12 +48,18 @@ class Matrix:
             i, j = item
             if isinstance(i, int) and isinstance(j, int):
                 return self.matrix[i][j]
-            rows = range(self.rows)[i]
             if isinstance(i, int):
-                rows = [ rows ]
-            cols = range(self.cols)[j]
+                rows = [ i ]
+            elif isinstance(i, list):
+                rows = i
+            else:
+                rows = range(self.rows)[i]
             if isinstance(j, int):
-                cols = [ cols ]
+                cols = [ j ]
+            elif isinstance(j, list):
+                cols = i
+            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]
@@ -64,12 +70,18 @@ class Matrix:
             if isinstance(i, int) and isinstance(j, int):
                 self.matrix[i][j] = value
                 return
-            rows = range(self.rows)[i]
             if isinstance(i, int):
-                rows = [ rows ]
-            cols = range(self.cols)[j]
+                rows = [ i ]
+            elif isinstance(i, list):
+                rows = i
+            else:
+                rows = range(self.rows)[i]
             if isinstance(j, int):
-                cols = [ cols ]
+                cols = [ j ]
+            elif isinstance(j, list):
+                cols = i
+            else:
+                cols = range(self.cols)[j]
             for i, ii in zip(cols,range(len(cols))):
                 for j, jj in zip(rows,range(len(rows))):
                     self.matrix[j][i] = value[jj,ii]
@@ -97,11 +109,20 @@ class Matrix:
         "Squared Frobenius/Euclidean norm."
         return sum( sum(x*x for x in row) for row in self.matrix )
 
-    def norm(self) -> float:
-        "Frobenius/Euclidean norm."
-        return sqrt(self.norm2())
+    def norm(self, p: int = 2) -> float:
+        "p-norm of a matrix regarded as a vector."
+        if p == 2:
+            return sqrt(self.norm2())
+        if p == 1:
+            return sum( sum(abs(x) for x in row) for row in self.matrix )
+        if p == inf:
+            return max( max(abs(x) for x in row) for row in self.matrix )
+        tmp = sum( sum(abs(x)**p for x in row) for row in self.matrix )
+        return tmp**(1/p)
+
 
     def dot(self, other) -> int:
+        "Dot product of two vectors."
         if self.rows == 1 and other.rows == 1 and self.cols == other.cols:
             return sum(x * y for x, y in zip(self.matrix[0], other.matrix[0]))
         if self.cols == 1 and other.cols == 1 and self.rows == other.rows:
@@ -109,17 +130,21 @@ class Matrix:
         return NotImplemented
 
     def transpose(self) -> "Matrix":
+        "Transpose of a matrix."
         return Matrix([list(i) for i in zip(*self.matrix)])
 
     def multiply(self, other) -> "Matrix":
-        if not isinstance(other, Matrix) or self.cols != other.rows:
+        "Matrix multiplication."
+        if not isinstance(other, Matrix):
             return NotImplemented
-        result = [[0 for j in range(other.cols)] for i in range(self.rows)]
+        if self.cols != other.rows:
+            raise NotImplementedError("Matrix dimensions do not match!")
+        result = self.zeros(self.rows, other.cols)
         for i in range(self.rows):
             for j in range(other.cols):
                 for k in range(other.rows):
-                    result[i][j] += self.matrix[i][k] * other.matrix[k][j]
-        return Matrix(result)
+                    result.matrix[i][j] += self.matrix[i][k] * other.matrix[k][j]
+        return result
 
     def __add__(self, other) -> "Matrix":
         if isinstance(other, Matrix) and other.cols == self.cols and other.rows == self.rows:
@@ -150,7 +175,7 @@ class Matrix:
         R = self[:, :]
         i = 0
         for j in range(n):
-            if not R[i, j]: # search for am nonzero entry in the present column
+            if not R[i, j]: # search for a nonzero entry in the present column
                 for ii in range(i+1,m):
                     if R[ii, j]:
                         R[i, :], R[ii, :] = R[ii, :], R[i, :]  # swap rows
@@ -173,12 +198,12 @@ class Matrix:
         "Compute the determinant of a matrix M."
         if self.rows != self.rows:
             raise ValueError("Matrix must be square!")
-        n = self.cols
+        n, m = self.cols, self.rows
         R = self[:, :]
         D = 1
         i = 0
         for j in range(n):
-            if not R[i, j]: # search for am nonzero entry in the present column
+            if not R[i, j]: # search for a nonzero entry in the present column
                 for ii in range(i+1,m):
                     if R[ii, j]:
                         D *= -1
@@ -211,13 +236,42 @@ class Matrix:
             raise ValueError("Matrix is not invertible!")
         return MM[:,n:]
 
+    def zeros(self, m: int = None, n: int = None):
+        "Returns a zero matrix of the same dimension"
+        if not m and not n:
+            n, m = self.cols, self.rows
+        elif not n:
+            n = m
+        zero = 0 * self[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
+        if not m and not n:
+            n, m = self.cols, self.rows
+        elif not n:
+            n = m
+        zero = 0 * self[0]
+        one = 1 + zero
+        return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])
+
 
-def zeros(m:int, n: int) -> "Matrix":
+def zeros(m: int, n: int = None) -> "Matrix":
+    "Returns a zero matrix of the given dimension"
+    if not n:
+        n = m
     return Matrix([[ 0 for j in range(n)] for i in range(m) ])
 
-def eye(m:int, n: int) -> "Matrix":
+def eye(m:int, n: int = None) -> "Matrix":
+    "Returns an identity matrix of the given dimension"
     def delta(i, j):
         if i == j:
             return 1
         return 0
+    if not n:
+        n = m
     return Matrix([[ delta(i, j) for j in range(n) ] for i in range(m) ])

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

@@ -4,13 +4,8 @@ Lattice tools
 
 from math import prod
 from fractions import Fraction
-from .la import Matrix, zeros, eye
-
-def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
-    "Babai's rounding algorithm for solving the CVP."
-    s = U.inv() * x
-    k = s.map(round)
-    return U * k
+from random import choice, sample
+from .la import Matrix, zeros
 
 def hermite_nf(M: Matrix) -> Matrix:
     "Compute the Hermite normal form of a matrix M."
@@ -57,7 +52,7 @@ def norm2(v: Matrix) -> float:
 
 def gram_schmidt(U: Matrix) -> (Matrix, Matrix):
     "Compute the Gram-Schmidt orthogonalization of the column vectors of a matrix M."
-    M = eye(U.cols, U.rows)
+    M = U.eye()
     Us = U[:, :]
     for j in range(1, U.rows):
         tmp = U[:, j]
@@ -68,13 +63,21 @@ def gram_schmidt(U: Matrix) -> (Matrix, Matrix):
     return Us, M
 
 def gram_det(U: Matrix) -> float:
+    "Compute the Gram determinant of a matrix."
     Us = gram_schmidt(U)[0]
     return prod([Us[:, i].norm() for i in range(U.rows)])
 
 def hadamard_ratio(M: Matrix) -> float:
+    "Compute the Hadamard ratio of a matrix."
     m = M.rows
     return (gram_det(M) / prod([M[:, i].norm() for i in range(m)])) ** (1 / m)
 
+def babai_round_cvp(x: Matrix, U: Matrix) -> Matrix:
+    "Babai's rounding algorithm for solving the CVP."
+    s = U.inv() * x
+    k = s.applyfunc(round)
+    return U * k
+
 def babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
     "Babai's closest plane algorithm for solving the CVP."
     Us = gram_schmidt(U)[0]
@@ -83,6 +86,18 @@ def babai_plane_cvp(x: Matrix, U: Matrix) -> Matrix:
         y = y - round(y.dot(Us[:, k]) / norm2(Us[:, k])) * U[:, k]
     return (x - y).applyfunc(round)
 
+def lagrange_lr(V: Matrix) -> Matrix:
+    "Lagrange lattice reduction."
+    assert (V.rows, V.cols) == (2, 2)
+    v1, v2 = V[:, 0], V[:, 1]
+    if norm2(v1) > norm2(v2):
+        v1, v2 = v2, v1
+    v3 = v2 - round(v1.dot(v2) / norm2(v1)) * v1
+    while norm2(v3) < norm2(v1):
+        v2, v1 = v1, v3
+        v3 = v2 - round(v1.dot(v2) / norm2(v1)) * v1
+    return Matrix([list(v1), list(v3)]).transpose()
+
 def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
     "lll algorithm for lattice reduction"
 
@@ -91,7 +106,7 @@ def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
     U = V[:, :]
     Us = U[:, :]
     Us.map(Fraction)
-    M = zeros(U.cols, U.rows)
+    M = U.zeros()
     M.map(Fraction)
     M[0, 0] = norm2(Us[:, 0])  # we store the squared norms on the diagonal
     for l in range(1, U.rows):  # Gram-Schmidt decomposition
@@ -147,11 +162,9 @@ def lll(V: Matrix, delta: float = 0.75, sort: bool = True) -> Matrix:
             U[:, j] = tmp[j]
     return U
 
-from random import choice, sample
-
-def random_unimodular_matrix(n: int, iterations: int = 50, max_val: int = 9) -> Matrix:
+def random_unimodular_matrix(n: int, iterations: int = 50, max_val: int = None) -> Matrix:
     "Create a random unimodular matrix of dimension n."
-    W = Matrix.zeros(n, n)
+    W = zeros(n)
     for i in range(n):
         for j in range(i, n):
             W[i, j] = choice([-1, 1])
@@ -159,10 +172,10 @@ def random_unimodular_matrix(n: int, iterations: int = 50, max_val: int = 9) ->
     for _ in range(iterations):
         i, j = sample(range(n), 2)
         tmp = W[i, :] + choice([-1, 1]) * W[j, :]
-        if max([abs(x) for x in tmp]) <= max_val:
+        if not max_val or max([abs(x) for x in tmp]) <= max_val:
             W[i, :] = tmp
         i, j = sample(range(n), 2)
         tmp = W[:, i] + choice([-1, 1]) * W[:, j]
-        if max([abs(x) for x in tmp]) <= max_val:
+        if not max_val or max([abs(x) for x in tmp]) <= max_val:
             W[:, i] = tmp
     return W

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

@@ -10,7 +10,6 @@ Number theory tools:
 """
 from math import gcd, prod
 from fractions import Fraction
-from .factor import factorint
 
 # Euclid and friends
 
@@ -115,8 +114,7 @@ def crt(a: list, m: list) -> int:
 def fraction_repr(self):
     if self.denominator == 1:
         return str(self.numerator)
-    else:
-        return str(self.numerator) + "/" + str(self.denominator)
+    return str(self.numerator) + "/" + str(self.denominator)
 
 Fraction.__repr__ = fraction_repr
 
@@ -209,7 +207,7 @@ def sqrt_mod(a: int, p: int) -> list:
 
 # Euler phi and Carmichael function
 
-from math import prod
+from .factor import factorint
 
 
 def euler_phi(n: int) -> int:
@@ -250,22 +248,22 @@ def order(a: int, n: int, factor=False) -> int:
                 factors[p] += k - 1
             else:
                 factors[p] = k - 1
-    order = 1  # compute the group order euler_phi(n) as our current guess
+    order_a = 1  # compute the group order euler_phi(n) as our current guess
     for p, k in factors.items():
-        order *= p**k
+        order_a *= p**k
     if factor:  # we compute the factorization of the order along the way
         factors_order = {}  # factorization of the order
     for p, k in factors.items():
         i = 0
         for _ in range(k):
-            order_try = order // p
+            order_try = order_a // p
             if pow(a, order_try, n) == 1:
-                order = order_try
+                order_a = order_try
                 i += 1
             else:
                 break
         if factor and i < k:
             factors_order[p] = k - i
     if factor:
-        return order, factors_order
-    return order
+        return order_a, factors_order
+    return order_a

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

@@ -83,7 +83,12 @@ class Poly:
 
     def __add__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            raise NotImplementedError(f"Cannot add {self} and {other}.")
+            try:
+                tmp = self.coeff[:]
+                tmp[0] += other
+                return self.__class__(tmp, modulus=self.modulus)
+            except:
+                return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
             scoeff = self.coeff + (lo - ls) * [0]
@@ -98,12 +103,27 @@ class Poly:
             modulus = other.modulus
         return self.__class__([s + o for s, o in zip(scoeff, ocoeff)], modulus=modulus)
 
+    def __radd__(self, other: "Poly") -> "Poly":
+        if not isinstance(other, self.__class__):
+            try:
+                tmp = self.coeff[:]
+                tmp[0] += other
+                return self.__class__(tmp, modulus=self.modulus)
+            except:
+                pass
+        return NotImplemented
+
     def __neg__(self) -> "Poly":
         return Poly([-s for s in self.coeff], modulus=self.modulus)
 
     def __sub__(self, other: "Poly") -> "Poly":
         if not isinstance(other, self.__class__):
-            raise NotImplementedError(f"Cannot subtract {self} and {other}.")
+            try:
+                tmp = self.coeff[:]
+                tmp[0] -= other
+                return self.__class__(tmp, modulus=self.modulus)
+            except:
+                return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         if ls < lo:
             scoeff = self.coeff + (lo - ls) * [0]
@@ -118,11 +138,22 @@ class Poly:
             modulus = other.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:
+                tmp = self.coeff[:]
+                tmp[0] -= other
+                return self.__class__(tmp, modulus=self.modulus)
+            except:
+                pass
+        return NotImplemented
+
     def __mul__(self, other: "Poly") -> "Poly":
-        if isinstance(other, int):
-            return Poly([other * s for s in self.coeff])
         if not isinstance(other, self.__class__):
-            raise NotImplementedError(f"Cannot multiply {self} and {other}.")
+            try:
+                return Poly([other * s for s in self.coeff])
+            except:
+                return NotImplemented
         ls, lo = len(self.coeff), len(other.coeff)
         coeff = [0] * (ls + lo - 1)
         for k in range(ls + lo - 1):
@@ -153,6 +184,7 @@ class Poly:
         return res
 
     def divmod(self, other: "Poly") -> ("Poly", "Poly"):
+        "Polynom division with remainder"
         if isinstance(other, list):
             other = self.__class__(other)
         elif not isinstance(other, self.__class__):
@@ -183,6 +215,7 @@ class Poly:
         )
 
     def mod(self, other: "Poly") -> None:
+        "Remainder of polynom division"
         if isinstance(other, list):
             other = self.__class__(other)
         elif not isinstance(other, self.__class__):

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

@@ -4,7 +4,8 @@ Tools for prime numbers:
     isprime(n) test if n is probably prime
     miller_rabin_test(n, b) Miller-Rabin primality test with base b
 """
-from math import isqrt
+from math import isqrt, gcd
+from .nt import jacobi_symbol
 
 # Erathostenes
 
@@ -86,8 +87,6 @@ def _lucas_sequence(n, D, k):
 
 def _is_strong_lucas_prp(n: int) -> bool:
     """Strong Lucas primality test."""
-    from math import gcd
-    from .nt import jacobi_symbol
 
     # remove powers of 2 from n+1 (= k * 2**s)
     k = (n + 1) // 2

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

@@ -1,10 +1,11 @@
 Metadata-Version: 2.1
 Name: kryptools
-Version: 0.1
+Version: 0.3
 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
 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
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -33,3 +34,6 @@ The tools contained are:
 * Matrix: a class for Matrices (inverse, det, reduced echelon form, etc.)
 * Poly: a class for polynomials (division, modulo)
 * Zmod: a class for the ring of integers modulo an integer
+
+Documentation can be found in the jupyter notebook
+(currently incomplete: use the force, read the source).

{kryptools-0.1 → kryptools-0.3}/kryptools.egg-info/SOURCES.txt

@@ -10,7 +10,9 @@ kryptools/dlp_qs.py
 kryptools/dlp_rho.py
 kryptools/ec.py
 kryptools/factor.py
+kryptools/factor_dix.py
 kryptools/factor_ecm.py
+kryptools/factor_fmt.py
 kryptools/factor_pm1.py
 kryptools/factor_qs.py
 kryptools/la.py

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

@@ -1,6 +1,6 @@
 [project]
 name = "kryptools"
-version = "0.1"
+version = "0.3"
 authors = [
   { name="Gerald Teschl", email="gerald.teschl@univie.ac.at" },
 ]
@@ -15,4 +15,5 @@ classifiers = [
 
 [project.urls]
 Homepage = "https://github.com/teschlg/kryptools"
-Issues = "https://github.com/teschlg/kryptools/issues"
+Issues = "https://github.com/teschlg/kryptools/issues"
+Docs = "https://github.com/teschlg/kryptools/tree/main/doc"

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

@@ -5,6 +5,9 @@ Factorization of integers:
 
 from math import isqrt, gcd
 from .primes import sieve_eratosthenes, isprime
+from .factor_pm1 import _pm1_parameters, factor_pm1
+from .factor_ecm import _ecm_parameters, factor_ecm
+#from .factor_qs import factor_qs
 
 
 # Factoring
@@ -27,9 +30,6 @@ def _factor_fermat(n: int, steps: int = 10) -> list:
             return a - b
         a += step
 
-from .factor_pm1 import _pm1_parameters, factor_pm1
-from .factor_ecm import _ecm_parameters, factor_ecm
-#from .factor_qs import factor_qs
 
 def factorint(n: int, verbose: int = 0) -> list:
     "Factor a number."