kryptools 1.0__tar.gz → 1.0.2__tar.gz

{kryptools-1.0 → kryptools-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: kryptools
-Version: 1.0
+Version: 1.0.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -14,6 +14,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # kryptools
 Gerald Teschl <Gerald.Teschl@univie.ac.at>

{kryptools-1.0 → kryptools-1.0.2}/kryptools/GF2.py

@@ -234,6 +234,7 @@ class GF2_aes(GF_2):
     order: int = 256  # 2**n
 
     def sbox(self, inv: bool = False) -> "GF2_aes":
+        "Apply the AES sbox."
         if inv:
             return aes_sbox_inv[self.x]
         return aes_sbox[self.x]
@@ -260,6 +261,7 @@ class GF2_miniaes(GF_2):
     order: int = 16  # 2**n
 
     def sbox(self, inv: bool = False) -> "GF2_miniaes":
+        "Apply the Mini-AES sbox."
         if inv:
             return miniaes_sbox_inv[self.x]
         return miniaes_sbox[self.x]
@@ -277,5 +279,3 @@ class GF2_ghash(GF_2):
     power: int = 128  # n
     order: int = 2**128  # 2**n
     bitreversed: bool = True
-
-

{kryptools-1.0 → kryptools-1.0.2}/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.15"
+__version__ = "1.0.2"
 __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
@@ -21,4 +21,4 @@ from .Zmod import Zmod
 from .GF2 import GF2, GF2_aes, GF2_miniaes, GF2_ghash
 from .blockcipher import BlockCipher, bytexor
 from .aes import AESKeySchedule, AESCipher, AESBlockCipher
-from .des import list2int, SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, DESBlockCipher
+from .des import list2int, int2list, permute, invert_permutation, rotate_left, SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, DESBlockCipher

{kryptools-1.0 → kryptools-1.0.2}/kryptools/aes.py

@@ -137,7 +137,7 @@ class AESKeySchedule:
             for j in range(4):
                 tmp.append(int(self.key[j, i]))
         return bytes(tmp)
-            
+
     def next(self) -> None:
         "Apply one round of the key shedule and return the next key."
         self.round += 1
@@ -169,6 +169,7 @@ class AESKeySchedule:
         return keys
 
 class AESBlockCipher(BlockCipher):
+    "Block cipher class for AES"
     blocksize = 16
     def set_key(self, key: bytes):
         if not isinstance(key, bytes) and len(key) != self.__class__.blocksize:

{kryptools-1.0 → kryptools-1.0.2}/kryptools/blockcipher.py

@@ -10,9 +10,9 @@ def bytexor(a: bytes, b: bytes) -> bytes:
 
 class BlockCipher:
     "Generic class for a block cipher."
-    
+
     blocksize: int = 1 # blocksize in bytes
-    
+
     def __init__(self, key: bytes|int = None, mode: str|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
@@ -53,7 +53,7 @@ class BlockCipher:
         try:
             method = getattr(self, "encrypt_" + mode.lower())
         except:
-            raise ValueError("Unsupported encryption mode: ",mode.lower())
+            raise ValueError("Unsupported encryption mode: ", mode)
         if key:
             self.set_key(key)
         return method(text)
@@ -65,7 +65,7 @@ class BlockCipher:
         try:
             method = getattr(self, "decrypt_" + mode)
         except:
-            raise ValueError("Unsupported encryption mode: ",mode)
+            raise ValueError("Unsupported encryption mode: ", mode)
         if key:
             self.set_key(key)
         return method(ctext)
@@ -89,7 +89,7 @@ class BlockCipher:
     def encrypt_cbc(self, text: bytes, iv: bytes | None = None, padding: bool = True) -> bytes:
         "Encrypt using CBC mode."
         ctext = bytearray(b'')
-        if iv == None:
+        if iv is None:
             bb = randbytes(self.__class__.blocksize)  # iv
         else:
             bb = iv
@@ -114,7 +114,7 @@ class BlockCipher:
     def encrypt_cfb(self, text: bytes, iv: bytes | None = None) -> bytes:
         "Encrypt using CFB mode."
         ctext = bytearray(b'')
-        if iv == None:
+        if iv is None:
             bb = randbytes(self.__class__.blocksize)  # iv
         else:
             bb = iv
@@ -139,7 +139,7 @@ class BlockCipher:
     def encrypt_ofb(self, text: bytes, iv: bytes | None = None) -> bytes:
         "Encrypt using OFB mode."
         ctext = bytearray(b'')
-        if iv == None:
+        if iv is None:
             z = randbytes(self.__class__.blocksize)  # iv
         else:
             z = iv
@@ -156,7 +156,7 @@ class BlockCipher:
         ctext = ctext[self.__class__.blocksize:]  # remove iv
         for b in self.blocksplit(ctext, False):
             z = self.encrypt_block(z)
-            text.extend(bytexor(b, z)) 
+            text.extend(bytexor(b, z))
         return bytes(text)
 
     def adv_ctr(self, z: bytes, s: int) -> bytes:
@@ -164,17 +164,16 @@ class BlockCipher:
         zz = bytearray(z)
         for i in range(self.__class__.blocksize-1, self.__class__.blocksize-s-1, -1):
             c = z[i]+1
-            if (c < 256):
+            if c < 256:
                 zz[i] = c
                 break
-            else:
-                zz[i] = 0
+            zz[i] = 0
         return zz
 
     def encrypt_ctr(self, text: bytes, iv: bytes | None = None) -> bytes:
         "Encrypt using CTR mode."
         ctext = bytearray(b'')
-        if iv == None:
+        if iv is None:
             ctr = randbytes(self.__class__.blocksize)  # iv
         else:
             ctr = iv
@@ -281,14 +280,14 @@ class BlockCipher:
             len_block = b'\x00' * (self.__class__.blocksize // 2) + len_block
             tag = 0
         return h, len_block, tag
-    
-    
+
+
     def encrypt_gcm(self, text: bytes, iv: bytes | None = None, aad: bytes | None = None) -> bytes:
         "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
-        if iv == None:
+        if iv is None:
             iv = randbytes(self.__class__.blocksize - len_ctr)
         else:
             assert len(iv) + \

{kryptools-1.0 → kryptools-1.0.2}/kryptools/des.py

@@ -6,15 +6,29 @@ from math import ceil
 from .blockcipher import BlockCipher
 
 def permute(a: list[int], permutation: tuple[int]) -> list[int]:
-    "Apply a permutation to a list"
+    "Apply a permutation (DES style - counting starts at 1) to a list."
     return [ a[i-1] for i in permutation]
 
+def invert_permutation(permutation: tuple[int]) -> tuple[int]:
+    "Invert a permutation (DES style - counting starts at 1)."
+    inverse = [ 0 ] * len(permutation)
+    for i, j in enumerate(permutation):
+        inverse[j-1] = i+1
+    return tuple(inverse)
+
 def rotate_left(l: list, n: int = 1) -> list:
     "Rotate a list cyclically n places to the left."
     n = n % len(l)
     return l[n:] + l[:n]
 
+def int2list(x: int, length: int = 8) -> list:
+    "Convert an integer or character to a list of binary digits."
+    if not isinstance(x, int):
+        x = ord(x)
+    return [int(d) for d in str(format(x, "0" + str(length) + "b"))]
+
 def list2int(a: list) -> int:
+    "Convert a list of binary digits to an integer."
     s = 0
     for i, d in enumerate(reversed(a)):
         if d:
@@ -48,7 +62,7 @@ class FeistelKeySchedule:
 
     def __repr__(self):
         if self.__class__.print_hex:
-           return str(format(int(self), "0" + str(ceil(self.keylength/4)) + "x"))
+            return str(format(int(self), "0" + str(ceil(self.keylength/4)) + "x"))
         return str(self.state)
 
     def __int__(self):
@@ -68,7 +82,7 @@ class FeistelKeySchedule:
 
     def reset(self) -> None:
         "Reset key schedule."
-        self.state = self.state = permute(self.key, self.__class__.IP)
+        self.state = permute(self.key, self.__class__.IP)
         self.round = 0
 
     def gen_keys(self) -> list:
@@ -79,7 +93,7 @@ class FeistelKeySchedule:
         for _ in range(len(self.__class__.ROT)):
             keys.append(self.next())
         return keys
-        
+
 
 
 class FeistelCipher:
@@ -96,7 +110,7 @@ class FeistelCipher:
     P_box: tuple = tuple() # permutation after sbox
     S_split: tuple = tuple() # bit selection for sbox
     S_box: tuple = tuple() # list of sboxes
-    
+
     def __init__(self, key: bytes = None):
         self.keys = []
         self.state = [ 0 ] * (self.__class__.blocksize * 8)
@@ -112,7 +126,7 @@ class FeistelCipher:
 
     def __repr__(self):
         if self.__class__.print_hex:
-           return str(format(int(self), "0" + str(self.__class__.blocksize * 2) + "x"))
+            return str(format(int(self), "0" + str(self.__class__.blocksize * 2) + "x"))
         s = ''
         for i, d in enumerate(self.state):
             if not i % 8 and 0 < i < self.__class__.blocksize * 8:
@@ -138,7 +152,7 @@ class FeistelCipher:
     def xor(self, a: list[int], b: list[int]) -> list[int]:
         "XOR two lists"
         return [ i ^ j for i, j in zip(a,b)]
-        
+
     def left(self) -> list[int]:
         "Left halve"
         return self.state[:self.__class__.blocksize * 4]
@@ -151,10 +165,18 @@ class FeistelCipher:
         "Switch left and right halves"
         self.state = self.right() + self.left()
 
-    def f_box(self, a: list[int], key: list[int]) -> list[int]:
+    def f_box(self, a: list[int], key: list[int], showtmp:bool = False) -> list[int]:
         "Nonlinear f-box"
+        if showtmp:
+            def printtmp(title:str, a: list) -> None:
+                print(f'{title}: {"".join(map(str,a))}')
+        else:
+            def printtmp(title:str, a: list) -> None:
+                pass
         a = permute(a, self.__class__.E_box)  # expansion box
+        printtmp("EBox", a)
         a = self.xor(a, key)  # add key
+        printtmp("XKey", a)
         split = len(self.__class__.S_split)
         # apply sboxes
         num_sbox = len(self.__class__.S_box)  # number of sboxes
@@ -168,7 +190,9 @@ class FeistelCipher:
             s = self.__class__.S_box[i][index]
             aa += [int(d) for d in str(format(s, "0" + str(out_len) + "b"))]
         a = aa
+        printtmp("SBox", a)
         a = permute(a, self.__class__.P_box) # permutation box
+        printtmp("PBox", a)
         return a
 
     def ip(self) -> None:
@@ -298,7 +322,7 @@ class DESCipher(FeistelCipher):
              0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
              4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
              15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13),
-        (15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 1,
+        (15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
              3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
              0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
              13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9),
@@ -330,6 +354,7 @@ class DESCipher(FeistelCipher):
 
 
 class DESBlockCipher(BlockCipher):
+    "Block cipher class for DES"
     blocksize = 8
     def set_key(self, key: bytes):
         if not isinstance(key, bytes) and len(key) != self.__class__.blocksize:

{kryptools-1.0 → kryptools-1.0.2}/kryptools/factor_pm1.py

@@ -47,7 +47,7 @@ def factor_pm1(n: int, B1: int | None = None, B2: int | None = None, x: int = 2,
     g = gcd(x - 1, n)
     if g == n:  # we hit a multiple of n
         if verbose:
-             print("\nFailed after stage one.")
+            print("\nFailed after stage one.")
         return None
     if 1 < g:
         if verbose > 1:

{kryptools-1.0 → kryptools-1.0.2}/kryptools/la.py

@@ -51,6 +51,7 @@ class Matrix:
         return '\n'.join(out)
 
     def latex(self) -> str:
+        "Produce LaTeX code for the matrix."
         res = "\\begin{pmatrix}\n"
         for row in self.matrix:
             res += " & ".join(map(str, row)) + '\\\\\n'
@@ -214,7 +215,7 @@ class Matrix:
 
     def rref(self) -> "Matrix":
         "Compute the reduced echelon form of a matrix M."
-        zero, one = self._guess_zero()
+        one = self._guess_zero()[1]
         n, m = self.cols, self.rows
         R = self[:, :]
         i = 0

{kryptools-1.0 → kryptools-1.0.2}/kryptools/nt.py

@@ -25,7 +25,7 @@ def egcd(a: int, b: int) -> (int, int, int):
         if b < 0:
             return -b, 0, -1
         return b, 0, 1
-    if a < 0:    
+    if a < 0:
         r0, r1 = -a, b
         x0, x1, y0, y1 = -1, 0, 0, 1
     else:

{kryptools-1.0 → kryptools-1.0.2}/kryptools/poly.py

@@ -315,6 +315,5 @@ class Poly:
             raise NotImplementedError(f"Cannot compute gcd: {other} must be a polynomial.")
         r0, r1 = other, self
         while r1:
-            q, r = r0.divmod(r1)
-            r0, r1 = r1, r
+            r0, r1 = r1, r0.divmod(r1)[1]
         return r0

{kryptools-1.0 → kryptools-1.0.2}/kryptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: kryptools
-Version: 1.0
+Version: 1.0.2
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -14,6 +14,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 # kryptools
 Gerald Teschl <Gerald.Teschl@univie.ac.at>

{kryptools-1.0 → kryptools-1.0.2}/pyproject.toml

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

kryptools-1.0.2/tests/test_des.py

@@ -0,0 +1,59 @@
+import pytest
+from kryptools import SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, list2int
+
+
+def test_SDES():
+    # Test the key schedule
+    key = 34
+    test_values = [[0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 1, 0]]
+
+    ks = SDESKeySchedule(key)
+    assert ks.gen_keys() == test_values
+
+    # Test the encryption
+    x = b'\x01'
+    y = b'\xb9'
+
+    sdes = SDESCipher(key)
+    sdes(x).encrypt()
+    assert bytes(sdes) == y
+    assert sdes.decrypt() == x
+
+
+def test_DES():
+    # Test the key schedule
+    key = 0x0123456789ABCDEF.to_bytes(8, 'big')
+    test_values = [0x0B02679B49A5, 0x69A659256A26, 0x45D48AB428D2, 0x7289D2A58257, 0x3CE80317A6C2, 0x23251E3C8545, 0x6C04950AE4C6, 0x5788386CE581,
+                   0xC0C9E926B839, 0x91E307631D72, 0x211F830D893A, 0x7130E5455C54, 0x91C4D04980FC, 0x5443B681DC8D, 0xB691050A16B5, 0xCA3D03B87032]
+
+    ks = DESKeySchedule(key)
+    keys = ks.gen_keys()
+    for k1, k2 in zip(keys, test_values):
+        assert list2int(k1) == k2
+
+    # Test the encryption (Handbook of Applied Cryptography and NBS Special Publication 500-20)
+    test_values = [[ 0x0123456789ABCDEF, 0x4E6F772069732074, 0x3FA40E8A984D4815 ],
+        [0x10316E028C8F3B4A, 0x0000000000000000, 0x82DCBAFBDEAB6602],
+        [0x0101010101010101, 0x95F8A5E5DD31D900, 0x8000000000000000],
+        [0x0101010101010101, 0xDD7F121CA5015619, 0x4000000000000000],
+        [0x0101010101010101, 0x2E8653104F3834EA, 0x2000000000000000],
+        [0x0101010101010101, 0x4BD388FF6CD81D4F, 0x1000000000000000],
+        [0x0101010101010101, 0x20B9E767B2FB1456, 0x0800000000000000],
+        [0x0101010101010101, 0x8000000000000000, 0x95F8A5E5DD31D900],
+        [0x0101010101010101, 0x4000000000000000, 0xDD7F121CA5015619],
+        [0x0101010101010101, 0x2000000000000000, 0x2E8653104F3834EA],
+        [0x0101010101010101, 0x1000000000000000, 0x4BD388FF6CD81D4F],
+        [0x8001010101010101, 0x0000000000000000, 0x95A8D72813DAA94D],
+        [0x4001010101010101, 0x0000000000000000, 0x0EEC1487DD8C26D5],
+        [0x2001010101010101, 0x0000000000000000, 0x7AD16FFB79C45926],
+        [0x1001010101010101, 0x0000000000000000, 0xD3746294CA6A6CF3]]
+
+    for key, x, y in test_values:
+        key = key.to_bytes(8, 'big')
+        x = x.to_bytes(8, 'big')
+        y = y.to_bytes(8, 'big')
+
+        des = DESCipher(key)
+        des(x).encrypt()
+        assert bytes(des) == y
+        assert des.decrypt() == x

kryptools-1.0/tests/test_des.py

@@ -1,42 +0,0 @@
-import pytest
-from kryptools import SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, list2int
-
-
-def test_SDES():
-    # Test the key schedule
-    key = 34
-    test_values = [[0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 1, 0]]
-
-    ks = SDESKeySchedule(key)
-    assert ks.gen_keys() == test_values
-
-    # Test the encryption
-    x = b'\x01'
-    y = b'\xb9'
-
-    sdes = SDESCipher(key)
-    sdes(x).encrypt()
-    assert bytes(sdes) == y
-    assert sdes.decrypt() == x
-
-
-def test_DES():
-    # Test the key schedule
-    key = 0x0123456789ABCDEF.to_bytes(8, 'big')
-    test_values = [0x0B02679B49A5, 0x69A659256A26, 0x45D48AB428D2, 0x7289D2A58257, 0x3CE80317A6C2, 0x23251E3C8545, 0x6C04950AE4C6, 0x5788386CE581,
-                   0xC0C9E926B839, 0x91E307631D72, 0x211F830D893A, 0x7130E5455C54, 0x91C4D04980FC, 0x5443B681DC8D, 0xB691050A16B5, 0xCA3D03B87032]
-
-    ks = DESKeySchedule(key)
-    keys = ks.gen_keys()
-    for k1, k2 in zip(keys, test_values):
-        assert list2int(k1) == k2
-
-    # Test the encryption (Handbook of Applied Cryptography)
-    key = 0x0123456789ABCDEF.to_bytes(8, 'big')
-    x = 0x4E6F772069732074.to_bytes(8, 'big')
-    y = 0x3FA40E8A984D4815.to_bytes(8, 'big')
-
-    des = DESCipher(key)
-    des(x).encrypt()
-    assert bytes(des) == y
-    assert des.decrypt() == x