kryptools 1.9.4__tar.gz → 1.9.6__tar.gz

{kryptools-1.9.4 → kryptools-1.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.9.4
+Version: 1.9.6
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools/Zmod.py

@@ -2,8 +2,9 @@
 Ring of intergers modulo `n`.
 """
 
-from math import gcd
+from math import gcd, floor
 from random import randint
+from fractions import Fraction
 from .factor import factorint
 from .primes import is_prime
 from .nt import sqrt_mod, crt
@@ -60,6 +61,13 @@ class Zmod:
     def __contains__(self, other: "ZmodPoint") -> bool:
         return isinstance(other, ZmodPoint) and self.n == other.ring.n
 
+    def decompress(self, x: int, d: int) -> "ZmodPoint":
+        "Decompress an integer `x` with at most `d` bits to Z_n."
+        if not isinstance(d, int) or d <= 0 or d >= self.n.bit_length():
+            raise ValueError("The number of bits must be between 1 and the bit length of the modulus.")
+        x %= 2**d
+        return ZmodPoint( floor(Fraction(x * self.n, 2**d) + Fraction(1, 2) ), self)
+
     def random(self, num: int = 0) -> "ZmodPoint":
         "Return a single random point or a list of random points."
         if num:
@@ -255,8 +263,14 @@ class ZmodPoint:
             return self.x
         return self.ring.n - self.x
 
+    def compress(self, d: int) -> list:
+        "Returns the value compressed to `d` bits."
+        if not isinstance(d, int) or d <= 0 or d > self.ring.n.bit_length():
+            raise ValueError("The number of bits must be between 1 and the bit length of the modulus.")
+        return floor(Fraction(self.x * 2**d, self.ring.n) + Fraction(1, 2) ) % 2**d
+
     def bits(self) -> list:
-        "Convert to a list of bits."
+        "Returns a list of bits."
         return [int(d) for d in str(format(self.x, "0" + str(int.bit_length(self.ring.n - 1)) + "b"))]
 
     def sharp(self):

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools/__init__.py

@@ -5,7 +5,7 @@ Implemenation of same basic algorithms used in cryptography.
 __author__ = "Gerald Teschl"
 __copyright__ = "Copyright 2024-2026, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.9.4"
+__version__ = "1.9.6"
 __email__ = "Gerald.Teschl@univie.ac.at"
 
 from .nt import egcd, cf, convergents, legendre_symbol, jacobi_symbol, sqrt_mod, euler_phi, carmichael_lambda, moebius_mu, is_carmichael_number, order, crt

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools/blockcipher.py

@@ -13,10 +13,11 @@ class BlockCipher:
 
     blocksize: int = 1 # blocksize in bytes
 
-    def __init__(self, key: bytes|int = None, mode: str|None = None):
+    def __init__(self, key: bytes|int = None, mode: str|None = None, ctrlen: int | None = None):
         self.key = None  # here we store the key (if any)
         self.cipher = None  # here we can store an instance of the cipher initialized with the key
         self.mode = mode # here we store the default en/decryption mode
+        self.ctrlen = ctrlen # default counter length for CTR mode
         if key:
             self.set_key(key)
 
@@ -142,6 +143,7 @@ class BlockCipher:
         if iv is None:
             z = randbytes(self.__class__.blocksize)  # iv
         else:
+            assert len(iv) == self.__class__.blocksize, "Length of IV must be equal to the block length."
             z = iv
         ctext.extend(z)  # add iv as first block of the cipher text
         for b in self.blocksplit(text, False):
@@ -159,40 +161,73 @@ class BlockCipher:
             text.extend(bytexor(b, z))
         return bytes(text)
 
-    def adv_ctr(self, z: bytes, s: int) -> bytes:
+    def adv_ctr(self, z: bytearray, ctrlen: int) -> bytes:
         "Advance the counter."
-        zz = bytearray(z)
-        for i in range(self.__class__.blocksize-1, self.__class__.blocksize-s-1, -1):
+        for i in range(self.__class__.blocksize-1, self.__class__.blocksize-ctrlen-1, -1):
             c = z[i]+1
             if c < 256:
-                zz[i] = c
+                z[i] = c
                 break
-            zz[i] = 0
-        return zz
+            z[i] = 0
+        return z
 
-    def encrypt_ctr(self, text: bytes, iv: bytes | None = None) -> bytes:
+    def encrypt_ctr(self, text: bytes, ctrlen: int | None = None, nonce: bytes = b'', iv: bytes | None = None) -> bytes:
         "Encrypt using CTR mode."
-        ctext = bytearray(b'')
+        if ctrlen is None:
+            ctrlen = self.ctrlen
+            if ctrlen is None:
+                if self.blocksize >= 8:
+                    ctrlen = 4
+                else:
+                    ctrlen = 0 # use the entire iv as counter
+        assert 0 <= ctrlen <= self.__class__.blocksize, "Counter too long."
+        assert len(nonce) + ctrlen <= self.__class__.blocksize, "Nonce too long."
         if iv is None:
-            ctr = randbytes(self.__class__.blocksize)  # iv
-        else:
-            ctr = iv
-        ctext.extend(ctr)  # add iv as first block of the cipher text
+            iv = randbytes(self.__class__.blocksize - ctrlen - len(nonce))# iv
+        iv = nonce + iv
+        assert len(iv) + ctrlen <= self.__class__.blocksize, "IV too long."
+        if ctrlen == 0 and len(iv) < self.__class__.blocksize:
+            ctrlen = self.__class__.blocksize - len(iv)
+        assert len(iv) + ctrlen == self.__class__.blocksize, "Length of nonce + iv + ctr do not match the blocksize."
+        ctr = bytearray(iv + b"\x00" * ctrlen)
+        if ctrlen == 0:
+            ctrlen = self.__class__.blocksize
+
+        ctext = bytearray(iv)  # add nonce+iv as first block of the cipher text
         for b in self.blocksplit(text, False):
+            ctr = self.adv_ctr(ctr, ctrlen)
             z = self.encrypt_block(ctr)
             ctext.extend(bytexor(b, z))
-            ctr = self.adv_ctr(ctr, self.__class__.blocksize)
         return bytes(ctext)
 
-    def decrypt_ctr(self, ctext: bytes) -> bytes:
+    def decrypt_ctr(self, ctext: bytes, ctrlen: int | None = None, nonce: bytes = b'', iv: bytes | None = None) -> bytes:
         "Decrypt using CTR mode."
+        if ctrlen is None:
+            ctrlen = self.ctrlen
+            if ctrlen is None:
+                if self.blocksize >= 8:
+                    ctrlen = 4
+                else:
+                    ctrlen = 0 # use the entire iv as counter
+        assert 0 <= ctrlen <= self.__class__.blocksize, "Counter too long."
+        assert len(nonce) + ctrlen <= self.__class__.blocksize, "Nonce too long."
+        if iv is None:
+            iv = ctext[:self.__class__.blocksize - ctrlen - len(nonce)]
+            ctext = ctext[self.__class__.blocksize - ctrlen - len(nonce):]  # remove iv
+        iv = nonce + iv
+        assert len(iv) +ctrlen <= self.__class__.blocksize, "IV too long."
+        if ctrlen == 0 and len(iv) < self.__class__.blocksize:
+            ctrlen = self.__class__.blocksize - len(iv)
+        assert len(iv) + ctrlen == self.__class__.blocksize, "Length of nonce + iv + ctr do not match the blocksize."
+        ctr = bytearray(iv + b"\x00" * ctrlen)
+        if ctrlen == 0:
+            ctrlen = self.__class__.blocksize
+
         text = bytearray(b'')
-        ctr = ctext[:self.__class__.blocksize]  # iv
-        ctext = ctext[self.__class__.blocksize:]  # remove iv
         for b in self.blocksplit(ctext, False):
+            ctr = self.adv_ctr(ctr, ctrlen)
             z = self.encrypt_block(ctr)
             text.extend(bytexor(b, z))
-            ctr = self.adv_ctr(ctr, self.__class__.blocksize)
         return bytes(text)
 
     def mac_cbc(self, text: bytes, padding: bool = True) -> bytes:
@@ -286,21 +321,21 @@ class BlockCipher:
         "Encrypt using Galois CTR mode."
         assert self.__class__.blocksize == 16, "GHASH requires a blocksize of 16 bytes."
         ctext = bytearray(b'')
-        len_ctr = self.__class__.blocksize // 4
+        ctrlen = self.__class__.blocksize // 4
         if iv is None:
-            iv = randbytes(self.__class__.blocksize - len_ctr)
+            iv = randbytes(self.__class__.blocksize - ctrlen)
         else:
             assert len(iv) + \
-                len_ctr == self.__class__.blocksize, "IV has inappropriate length!"
-        ctr = iv + (len_ctr - 1) * b'\x00' + b'\x01'
-        ctr0 = ctr
+                ctrlen == self.__class__.blocksize, "IV has inappropriate length!"
+        ctr = bytearray(iv + (ctrlen - 1) * b'\x00' + b'\x01')
+        ctr0 = bytes(ctr)
         ctext.extend(iv)
         h, len_block, tag = self._aad_helper(len(text), aad)
         for b in self.blocksplit(text, 0):
-            ctr = self.adv_ctr(ctr, len_ctr)
+            ctr = self.adv_ctr(ctr, ctrlen)
             z = self.encrypt_block(ctr)
             ctext.extend(bytexor(b, z))
-        tag = self.ghash(ctext[self.__class__.blocksize - len_ctr:], h, init=tag)
+        tag = self.ghash(ctext[self.__class__.blocksize - ctrlen:], h, init=tag)
         tag = self.ghash(len_block, h, init=tag).to_bytes(
             self.__class__.blocksize, byteorder="big")
         z = self.encrypt_block(ctr0)
@@ -311,11 +346,11 @@ class BlockCipher:
         "Decrypt using Galois CTR mode."
         assert self.__class__.blocksize == 16, "GHASH requires a blocksize of 16 bytes."
         text = bytearray(b'')
-        len_ctr = self.__class__.blocksize // 4
-        iv = ctext[:self.__class__.blocksize - len_ctr]  # iv
-        ctr = iv + (len_ctr - 1) * b'\x00' + b'\x01'
+        ctrlen = self.__class__.blocksize // 4
+        iv = ctext[:self.__class__.blocksize - ctrlen]  # iv
+        ctr = bytearray(iv + (ctrlen - 1) * b'\x00' + b'\x01')
         mac = ctext[-self.__class__.blocksize:]  # mac
-        ctext = ctext[self.__class__.blocksize - len_ctr:-self.__class__.blocksize]
+        ctext = ctext[self.__class__.blocksize - ctrlen:-self.__class__.blocksize]
         h, len_block, tag = self._aad_helper(len(ctext), aad)
         tag = self.ghash(ctext, h, init=tag)
         tag = self.ghash(len_block, h, init=tag).to_bytes(
@@ -324,7 +359,7 @@ class BlockCipher:
         tag = bytexor(tag, z)
         assert tag == mac, "Incorrect MAC!"
         for b in self.blocksplit(ctext, 0):
-            ctr = self.adv_ctr(ctr, len_ctr)
+            ctr = self.adv_ctr(ctr, ctrlen)
             z = self.encrypt_block(ctr)
             text.extend(bytexor(b, z))
         return bytes(text)

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools/dlp_rho.py

@@ -12,6 +12,11 @@ def dlog_rho(a: int, b: int, n: int, m: int = None, brent=0) -> int:
     b %= n
     if not m:
         m = n - 1
+    else:
+        if pow(a, m, n) != 1:
+            raise ValueError("Incorrect order.")
+        if pow(b, m, n) != 1:
+            raise ValueError("DLP not solvable.")
     trys = 10
     max_iter = 10 * isqrt(m)  # stop iterating and try a different start value
 

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools/factor_rho.py

@@ -9,7 +9,7 @@ from random import randint
 def factor_rho(n: int, x: int = 2, maxinit: int = 10, maxiter: int = 1000, brent: bool = True, verbose: int = 0) -> int | None:
     """Factor `n` using the Pollard's rho method with start value `x`."""
     if not maxiter:
-        maxiter = 10 * isqrt(n)  # stop iterating and try a different start value
+        maxiter = 3 * isqrt(isqrt(n))  # stop iterating and try a different start value
 
     def f(x: int) -> int:
         return (pow(x, 2, n) + 2) % n

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools/poly.py

@@ -220,6 +220,12 @@ class Poly:
             return self.__class__(list(map(func, self.coeff)), modulus = list(map(func, self.modulus)))
         return self.__class__(list(map(func, self.coeff)), modulus = self.modulus, cyclic = self.cyclic)
 
+    def compress(self, d: int) -> list:
+        "Retun a list of compressed coefficients."
+        if not hasattr(self.coeff[0], "compress"):
+            raise ValueError("The unerlying ring does not seem to support compression.")
+        return [ c.compress(d) for c in self.coeff ]
+
     def _check_type(self, other):
         "Check if self and other can be added/multiplied."
         return isinstance(other, int) or (isinstance(other, Number) and isinstance(self.coeff[0], Number)) or type(other) == type(self.coeff[0])  # pylint: disable=C0123

{kryptools-1.9.4 → kryptools-1.9.6}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.9.4
+Version: 1.9.6
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT

{kryptools-1.9.4 → kryptools-1.9.6}/pyproject.toml

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

{kryptools-1.9.4 → kryptools-1.9.6}/tests/test_aes.py

@@ -46,26 +46,28 @@ def test_AES():
 
     # AES-128-CTR
     k = bytes.fromhex('AE6852F8121067CC4BF7A5765577F39E')
-    iv = bytes.fromhex('00000030000000000000000000000001')
+    nonce = bytes.fromhex("00000030")
+    iv = bytes.fromhex('0000000000000000')
     m = bytes.fromhex('53696E676C6520626C6F636B206D7367')
     c = bytes.fromhex('E4095D4FB7A7B3792D6175A3261311B8')
 
     aes.set_key(k)
-    res = aes.encrypt_ctr(m, iv=iv)
-    assert res[16:] == c
-    assert aes.decrypt_ctr(res) == m
+    res = aes.encrypt_ctr(m, nonce=nonce, iv=iv)
+    assert res[len(nonce) + len(iv):] == c
+    assert aes.decrypt_ctr(res, aes.blocksize - len(nonce) - len(iv)) == m
 
     k = bytes.fromhex('7691BE035E5020A8AC6E618529F9A0DC')
-    iv = bytes.fromhex('00E0017B27777F3F4A1786F000000001')
+    nonce = bytes.fromhex("00E0017B")
+    iv = bytes.fromhex('27777F3F4A1786F0')
     m = bytes.fromhex(
         '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20212223')
     c = bytes.fromhex(
         'C1CF48A89F2FFDD9CF4652E9EFDB72D74540A42BDE6D7836D59A5CEAAEF3105325B2072F')
 
     aes.set_key(k)
-    res = aes.encrypt_ctr(m, iv=iv)
-    assert res[16:] == c
-    assert aes.decrypt_ctr(res) == m
+    res = aes.encrypt_ctr(m, nonce=nonce, iv=iv)
+    assert res[len(nonce) + len(iv):] == c
+    assert aes.decrypt_ctr(res,aes.blocksize - len(nonce) - len(iv)) == m
 
     # AES-128-GCM
     k = bytes.fromhex('00000000000000000000000000000000')
@@ -79,6 +81,9 @@ def test_AES():
     res = aes.encrypt_gcm(m, aad=aad, iv=iv)
     assert res[12:-16] == c and res[-16:] == mac
     assert aes.decrypt_gcm(res, aad=aad) == m
+    with pytest.raises(AssertionError):
+        assert aes.decrypt_gcm(res, aad= b'\x00') == m
+
 
     k = bytes.fromhex('00000000000000000000000000000000')
     iv = bytes.fromhex('000000000000000000000000')