kryptools 1.0.2__tar.gz → 1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.0.2
+Version: 1.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -49,5 +49,10 @@ The tools contained are:
 * AESCipher: individual AES operations
 * DESCipher: individual DES operations
 
+* SHA1
+* Keccak individual sponge operations
+* SHA3
+* SHAKE
+
 Documentation can be found in the jupyter notebook
 (mostly done, but might not contain everything: use the force, read the source).

{kryptools-1.0.2 → kryptools-1.1}/README.md

@@ -31,5 +31,10 @@ The tools contained are:
 * AESCipher: individual AES operations
 * DESCipher: individual DES operations
 
+* SHA1
+* Keccak individual sponge operations
+* SHA3
+* SHAKE
+
 Documentation can be found in the jupyter notebook
 (mostly done, but might not contain everything: use the force, read the source).

{kryptools-1.0.2 → kryptools-1.1}/kryptools/__init__.py

@@ -3,9 +3,9 @@ Implemenation of same basic algorithms used in cryptography.
 """
 
 __author__ = "Gerald Teschl"
-__copyright__ = "Copyright 2024, Gerald Teschl"
+__copyright__ = "Copyright 2024-2025, Gerald Teschl"
 __license__ = "MIT License"
-__version__ = "1.0.2"
+__version__ = "1.1"
 __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
@@ -22,3 +22,5 @@ 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, int2list, permute, invert_permutation, rotate_left, SDESKeySchedule, SDESCipher, DESKeySchedule, DESCipher, DESBlockCipher
+from .keccak import Keccak, SHA3, SHAKE
+from .sha1 import SHA1

kryptools-1.1/kryptools/keccak.py

@@ -0,0 +1,203 @@
+"""
+Keccak Sponge, SHA3, SHAKE
+"""
+
+
+class Keccak:
+    "Keccak sponge"
+    MASK_64 = (1 << 64) - 1
+    rounds = 24
+
+    def __init__(self, rate: int = 1088):
+        if rate % 64:
+            raise ValueError(f"Rate {rate} must be a multiple of 64.")
+        self.pad = [b'\x81', b'\x01', b'\x80']
+        self.rate = rate // 8  # in bytes
+        self.reset()
+
+    def reset(self):
+        self.state = [0] * 25
+        self.lfsr = 1
+        self.buffer = b''
+        self.rnd_bytes = None
+
+    def __repr__(self):
+        out = ""
+        for i in range(5):
+            for j in range(5):
+                out += "%016x" % self.state[5 * i + j]
+                if j < 4:
+                    out += " "
+            if i < 4:
+                out += "\n"
+        return out
+
+    def f(self) -> None:
+        "Apply f to the state."
+        self.lfsr = 1
+        for r in range(Keccak.rounds):
+            self.theta()
+            self.pi()
+            self.rho()
+            self.chi()
+            self.iota()
+
+    def absorb(self, msg: bytes | str) -> None:
+        "Absorbe a message into the state."
+        if isinstance(msg, str):
+            msg = msg.encode()
+        msg = self.buffer + msg
+        msg_len = len(msg) - len(msg) % self.rate
+        msg, self.buffer = msg[:msg_len], msg[msg_len:]
+        for i in range(len(msg)//self.rate):
+            self.absorb_block(msg[i*self.rate:(i+1)*self.rate])
+
+    def absorb_block(self, block: bytes) -> None:
+        "Absorbe a block into the state. Pad the block if neccessary."
+
+        if len(block) > self.rate:
+            raise ValueError(f"Block must be at most {self.rate} bytes.")
+        padlen = self.rate - len(block)
+        if padlen == 1:
+            block += self.pad[0]
+        else:
+            block += self.pad[1] + (b'\x00' * (padlen - 2)) + self.pad[2]
+        for i in range(len(block)//8):
+            self.state[i] ^= int.from_bytes(block[i*8:(i+1)*8], 'little')
+        self.f()
+
+    def squeeze(self, r: int) -> bytes:
+        "Squeesze out 'r' bytes from the state."
+        if r <= 0:
+            raise ValueError("Number of bytes must be positive.")
+        if self.rnd_bytes is None:
+            self.absorb_block(self.buffer)
+            self.rnd_bytes = self.extract_block()
+        while r > len(self.rnd_bytes):
+            self.f()
+            self.rnd_bytes += self.extract_block()
+        out, self.rnd_bytes = self.rnd_bytes[:r], self.rnd_bytes[r:]
+        return out
+
+    def extract_block(self) -> bytes:
+        "Extract one block from the state."
+        out = b''
+        for i in range(self.rate//8):
+            out += self.state[i].to_bytes(8, 'little')
+        return out
+
+    def left_rotate(self, w: int, n: int) -> int:
+        "Left rotate a 64-bit integer w by n bits."
+        return ((w << n) & Keccak.MASK_64) | (w >> (64 - n))
+
+    def theta(self) -> None:
+        "Apply Theta to the state."
+        v = [0] * 5
+        for j in range(5):
+            for i in range(5):
+                v[j] ^= self.state[5 * i + j]
+
+        for j in range(5):
+            h = v[(j + 4) % 5] ^ self.left_rotate(v[(j + 1) % 5], 1)
+            for i in range(5):
+                self.state[5 * i + j] ^= h
+
+    def pi(self) -> None:
+        "Apply Pi to the state."
+        i, j = 0, 1
+
+        for t in range(1, 25):
+            idx = 5 * i + j
+            w = (t * (t + 1) // 2) % 64
+            self.state[idx] = self.left_rotate(self.state[idx], w)
+            i, j = (3 * i + 2 * j) % 5, i
+
+    def rho(self) -> None:
+        "Apply Rho to the state."
+        i, j = 0, 1
+        vv = self.state[1]
+
+        for _ in range(24):
+            i, j = (3 * i + 2 * j) % 5, i
+            idx = 5 * i + j
+            self.state[idx], vv = vv, self.state[idx]
+
+    def chi(self) -> None:
+        "Apply Chi to the state."
+        v = [0] * 5
+
+        for i in range(0, 25, 5):
+            for j in range(5):
+                v[j] = self.state[i + j]
+            for j in range(5):
+                self.state[i + j] ^= (v[(j + 1) % 5] ^
+                                      Keccak.MASK_64) & v[(j + 2) % 5]
+
+    def iota(self) -> None:
+        "Apply Iota to the state."
+        for w in [0, 1, 3, 7, 15, 31, 63]:
+            self.state[0] ^= ((self.lfsr & 1) << w)
+            self.lfsr <<= 1
+            self.lfsr &= Keccak.MASK_64
+            if (self.lfsr & 0x100):
+                self.lfsr ^= 0x171
+
+
+class SHA3():
+    """
+    SHA3 secure hash algorithm
+
+    Example:
+
+    >>>sha3 = SHA3(256)
+    >>>sha3("abc").hex()
+    '3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532'
+    """
+
+    def __init__(self, n: int = 256):
+        if n not in (224, 256, 384, 512):
+            raise ValueError(f"n must be one of: 224, 256, 384, 512")
+        self.keccak = Keccak(rate=1600-2*n)
+        self.keccak.pad = [b'\x86', b'\x06', b'\x80']
+        self.hash_length = n // 8  # in bytes
+
+    def __call__(self, msg: bytes | str) -> bytes:
+        "Compute the hash of the message given or absorbed."
+        self.keccak.reset()
+        self.keccak.absorb(msg)
+        return self.keccak.squeeze(self.hash_length)
+
+    def update(self, msg: bytes | str) -> None:
+        "Absorb the given message into the sponge."
+        self.keccak.absorb(msg)
+
+    def digest(self, msg: bytes | str | None = None) -> bytes:
+        "Compute the hash of the message given or absorbed."
+        if msg is not None:
+            self.keccak.absorb(msg)
+        digest = self.keccak.squeeze(self.hash_length)
+        self.keccak.reset()
+        return digest
+
+
+class SHAKE():
+    """
+    SHAKE Extendable output function
+
+    Example:
+
+    >>> shake = SHAKE(b'secret', n = 128)
+    >>> shake(8)
+    b'O:dn&\\xb2i>'
+    """
+
+    def __init__(self, msg: bytes | str, n: int = 128) -> None:
+        if n not in (128, 256):
+            raise ValueError(f"n must be one of: 128, 256")
+        self.keccak = Keccak(rate=1600-2*n)
+        self.keccak.pad = [b'\x9f', b'\x1f', b'\x80']
+        self.keccak.absorb(msg)
+
+    def __call__(self, r: int) -> bytes:
+        "Extract `r` bytes."
+        return self.keccak.squeeze(r)

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

@@ -50,6 +50,12 @@ class Matrix:
             out[i] += self.__class__.print_post
         return '\n'.join(out)
 
+    def _repr_mimebundle_(self, **kwargs):
+        return {
+            "text/plain": self.__repr__(),
+            "text/latex": "$\\displaystyle" + self.latex() + "$"
+        }
+
     def latex(self) -> str:
         "Produce LaTeX code for the matrix."
         res = "\\begin{pmatrix}\n"

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

@@ -44,12 +44,14 @@ class Poly:
     def __len__(self):
         return len(self.coeff)
 
-    def __repr__(self):
+    def __repr__(self, latex = False):
         def prx(i: int) -> str:
             if i == 0:
                 return ""
             if i == 1:
                 return self.__class__.print_x
+            if latex:
+                return self.__class__.print_x + "^{" + str(i) +"}"
             return self.__class__.print_x + self.__class__.print_pow + str(i)
 
         if not self:
@@ -91,6 +93,12 @@ class Poly:
             plus = " + "
         return tmp.strip()
 
+    def _repr_mimebundle_(self, **kwargs):
+        return {
+            "text/plain": self.__repr__(),
+            "text/latex": "$" + self.__repr__(latex = True) + "$"
+        }
+
     def __eq__(self, other):
         if not isinstance(other, self.__class__):
             return False

kryptools-1.1/kryptools/sha1.py

@@ -0,0 +1,86 @@
+"""
+SHA1
+"""
+
+class SHA1:
+    "SHA1 Hash function"
+
+    h_init = (0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0)
+
+    def __init__(self):
+        pass
+
+    def __call__(self, message: bytes|str, h_init: list = h_init, length: int = None) -> int:
+        return self.hash(message, h_init, length)
+
+    def left_rotate(self, w: int, n: int) -> int:
+        """Left rotate a 32-bit integer w by n bits."""
+        return ((w << n) | (w >> (32 - n))) & 0xffffffff
+    def pad(self, msg: bytes, length: int = None) -> bytes:
+        """Pad a message. Optionally augment the message length."""
+        msg=bytearray(msg)
+        l=len(msg)
+        if length:
+            l+=length
+        msg+=b'\x80'+b'\x00'*((55 - l) % 64) # append 1 plus zeros such that the length % 64 = 56
+        msg += int(l*8).to_bytes(8, byteorder='big') # add the bit length of the message
+        return bytes(msg)
+
+    def compression_function(self, h: list, chunk: bytes) -> list:
+        """Process a chunk of data and return the new digest variables."""
+        assert len(chunk) == 64, "Chunk must be 64 bytes."
+
+        w = [0] * 80
+
+        # Break chunk into sixteen 4-byte big-endian words w[i]
+        for i in range(16):
+            w[i] = int.from_bytes(chunk[i * 4:(i+1) * 4], byteorder='big')
+ 
+        # Message schedule: extend the sixteen 32-bit words into eighty 32-bit words
+        for i in range(16, 80):
+            # Note: SHA-0 differs by not having this leftrotate
+            w[i] = self.left_rotate(w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16], 1)
+
+        # Initialize hash value for this chunk
+        a, b, c, d, e = h
+
+        for i in range(80):
+            if 0 <= i <= 19:
+                # Use alternative 1 for f from FIPS PB 180-1 to avoid bitwise not
+                f = d ^ (b & (c ^ d))
+                k = 0x5A827999
+            elif 20 <= i <= 39:
+                f = b ^ c ^ d
+                k = 0x6ED9EBA1
+            elif 40 <= i <= 59:
+                f = (b & c) | (b & d) | (c & d)
+                k = 0x8F1BBCDC
+            elif 60 <= i <= 79:
+                f = b ^ c ^ d
+                k = 0xCA62C1D6
+
+            a, b, c, d, e = ((self.left_rotate(a, 5) + f + e + k + w[i]) & 0xffffffff,
+                             a, self.left_rotate(b, 30), c, d)
+
+        # Add this chunk's hash to result so far
+        h0 = (h[0] + a) & 0xffffffff
+        h1 = (h[1] + b) & 0xffffffff
+        h2 = (h[2] + c) & 0xffffffff
+        h3 = (h[3] + d) & 0xffffffff
+        h4 = (h[4] + e) & 0xffffffff
+
+        return [h0, h1, h2, h3, h4]
+
+    def hash(self, message: bytes|str, h_init: list = h_init, length: int = None) -> int:
+        """
+        Computes SHA1 of a given message.
+        Optinally the initial hash can be given and the length of the message can be augmented.
+        """
+        if isinstance(message, str):
+            message = message.encode()
+        message= self.pad(message, length)
+        h = h_init # initialize the status
+        for i in range(0, len(message), 64):
+            h = self.compression_function(h, message[i:i+64])
+        #return (h[0] << 128) | (h[1] << 96) | (h[2] << 64) | (h[3] << 32) | h[4]
+        return b''.join(map(lambda n: int.to_bytes(n,4), h))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kryptools
-Version: 1.0.2
+Version: 1.1
 Summary: Implemenation of same basic algorithms used in cryptography.
 Author-email: Gerald Teschl <gerald.teschl@univie.ac.at>
 License: MIT
@@ -49,5 +49,10 @@ The tools contained are:
 * AESCipher: individual AES operations
 * DESCipher: individual DES operations
 
+* SHA1
+* Keccak individual sponge operations
+* SHA3
+* SHAKE
+
 Documentation can be found in the jupyter notebook
 (mostly done, but might not contain everything: use the force, read the source).

{kryptools-1.0.2 → kryptools-1.1}/kryptools.egg-info/SOURCES.txt

@@ -22,11 +22,13 @@ kryptools/factor_pm1.py
 kryptools/factor_qs.py
 kryptools/factor_rho.py
 kryptools/intfuncs.py
+kryptools/keccak.py
 kryptools/la.py
 kryptools/lat.py
 kryptools/nt.py
 kryptools/poly.py
 kryptools/primes.py
+kryptools/sha1.py
 kryptools.egg-info/PKG-INFO
 kryptools.egg-info/SOURCES.txt
 kryptools.egg-info/dependency_links.txt
@@ -42,8 +44,10 @@ tests/test_factor_fmt.py
 tests/test_factor_pm1.py
 tests/test_factor_qs.py
 tests/test_intfuncs.py
+tests/test_keccak.py
 tests/test_la.py
 tests/test_lat.py
 tests/test_nt.py
 tests/test_poly.py
-tests/test_primes.py
+tests/test_primes.py
+tests/test_sha1.py

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

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

kryptools-1.1/tests/test_keccak.py

@@ -0,0 +1,54 @@
+import pytest
+
+from kryptools import Keccak, SHA3
+
+
+def test_KECCAK():
+	result = [ 0xf1258f7940e1dde7, 0x84d5ccf933c0478a, 0xd598261ea65aa9ee, 0xbd1547306f80494d, 0x8b284e056253d057,
+		0xff97a42d7f8e6fd4, 0x90fee5a0a44647c4, 0x8c5bda0cd6192e76, 0xad30a6f71b19059c, 0x30935ab7d08ffc64,
+		0xeb5aa93f2317d635, 0xa9a6e6260d712103, 0x81a57c16dbcf555f, 0x43b831cd0347c826, 0x1f22f1a11a5569f,
+		0x5e5635a21d9ae61, 0x64befef28cc970f2, 0x613670957bc46611, 0xb87c5a554fd00ecb, 0x8c3ee88a1ccf32c8,
+		0x940c7922ae3a2614, 0x1841f924a2c509e4, 0x16f53526e70465c2, 0x75f644e97f30a13b, 0xeaf1ff7b5ceca249 ]
+	keccak = Keccak()
+	keccak.f()
+	assert keccak.state == result
+
+
+# https://www.di-mgt.com.au/sha_testvectors.html
+all_tests = [
+{"message" : { "data" : "abc", "count" : 1},
+"SHA-3-224" : "e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf",
+"SHA-3-256" : "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532",
+"SHA-3-384" : "ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25",
+"SHA-3-512" : "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0"
+},
+{"message" : { "data" : "", "count" : 1},
+"SHA-3-224" : "6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7",
+"SHA-3-256" : "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a",
+"SHA-3-384" : "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004",
+"SHA-3-512" : "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26"
+},
+{"message" : { "data" : "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", "count" : 1},
+"SHA-3-224" : "8a24108b154ada21c9fd5574494479ba5c7e7ab76ef264ead0fcce33",
+"SHA-3-256" : "41c0dba2a9d6240849100376a8235e2c82e1b9998a999e21db32dd97496d3376",
+"SHA-3-384" : "991c665755eb3a4b6bbdfb75c78a492e8c56a22c5c4d7e429bfdbc32b9d4ad5aa04a1f076e62fea19eef51acd0657c22",
+"SHA-3-512" : "04a371e84ecfb5b8b77cb48610fca8182dd457ce6f326a0fd3d7ec2f1e91636dee691fbe0c985302ba1b0d8dc78c086346b533b49c030d99a27daf1139d6e75e"
+},
+{"message" : { "data" : "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", "count" : 1},
+"SHA-3-224" : "543e6868e1666c1a643630df77367ae5a62a85070a51c14cbf665cbc",
+"SHA-3-256" : "916f6061fe879741ca6469b43971dfdb28b1a32dc36cb3254e812be27aad1d18",
+"SHA-3-384" : "79407d3b5916b59c3e30b09822974791c313fb9ecc849e406f23592d04f625dc8c709b98b43b3852b337216179aa7fc7",
+"SHA-3-512" : "afebb2ef542e6579c50cad06d2e578f9f8dd6881d7dc824d26360feebf18a4fa73e3261122948efcfd492e74e82e2189ed0fb440d187f382270cb455f21dd185"
+}
+]
+
+def test_SHA3():
+	for test in all_tests:
+		msg = bytes(test["message"]["data"], 'utf-8')
+		for key in test:
+			if key[:5] != "SHA-3":
+				continue
+			n = int(key[6:])
+			h = int(test[key], 16)
+			k = SHA3(n)(msg)
+			assert int.from_bytes(k, 'big') == h, f"{n}: {msg}"

kryptools-1.1/tests/test_sha1.py

@@ -0,0 +1,16 @@
+import pytest
+
+from kryptools import SHA1
+
+
+# tests from https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/examples/sha_all.pdf
+
+test_vectors = [
+[b'abc', 0xA9993E364706816ABA3E25717850C26C9CD0D89D ],
+[b'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq', 0x84983E441C3BD26EBAAE4AA1F95129E5E54670F1]
+]
+
+def test_sha1():
+    sha1 = SHA1()
+    for msg, digest in test_vectors:
+        assert int.from_bytes(sha1(msg)) == digest