TripleDNN

Current Directory: /opt/imunify360/venv/lib/python3.11/site-packages/Crypto/SelfTest/Hash

File Name	Size	Actions
📁 __pycache__	Folder	Edit \| Delete \| Rename \| Download
__init__.py	3713 bytes	Edit \| Delete \| Rename \| Download
common.py	9878 bytes	Edit \| Delete \| Rename \| Download
test_BLAKE2.py	16314 bytes	Edit \| Delete \| Rename \| Download
test_CMAC.py	13360 bytes	Edit \| Delete \| Rename \| Download
test_HMAC.py	19941 bytes	Edit \| Delete \| Rename \| Download
test_KMAC.py	11704 bytes	Edit \| Delete \| Rename \| Download
test_KangarooTwelve.py	10455 bytes	Edit \| Delete \| Rename \| Download
test_MD2.py	2324 bytes	Edit \| Delete \| Rename \| Download
test_MD4.py	2347 bytes	Edit \| Delete \| Rename \| Download
test_MD5.py	3284 bytes	Edit \| Delete \| Rename \| Download
test_Poly1305.py	18297 bytes	Edit \| Delete \| Rename \| Download
test_RIPEMD160.py	2663 bytes	Edit \| Delete \| Rename \| Download
test_SHA1.py	2926 bytes	Edit \| Delete \| Rename \| Download
test_SHA224.py	2533 bytes	Edit \| Delete \| Rename \| Download
test_SHA256.py	3617 bytes	Edit \| Delete \| Rename \| Download
test_SHA384.py	2714 bytes	Edit \| Delete \| Rename \| Download
test_SHA3_224.py	2830 bytes	Edit \| Delete \| Rename \| Download
test_SHA3_256.py	2831 bytes	Edit \| Delete \| Rename \| Download
test_SHA3_384.py	2830 bytes	Edit \| Delete \| Rename \| Download
test_SHA3_512.py	2831 bytes	Edit \| Delete \| Rename \| Download
test_SHA512.py	5198 bytes	Edit \| Delete \| Rename \| Download
test_SHAKE.py	4715 bytes	Edit \| Delete \| Rename \| Download
test_TupleHash.py	8135 bytes	Edit \| Delete \| Rename \| Download
test_cSHAKE.py	6792 bytes	Edit \| Delete \| Rename \| Download
test_keccak.py	8889 bytes	Edit \| Delete \| Rename \| Download

import unittest
from binascii import unhexlify, hexlify

from Crypto.Util.py3compat import tobytes
from Crypto.SelfTest.st_common import list_test_cases

from Crypto.Hash import TupleHash128, TupleHash256

class TupleHashTest(unittest.TestCase):

def new(self, *args, **kwargs):
        return self.TupleHash.new(*args, **kwargs)

def test_new_positive(self):

h = self.new()
        for new_func in self.TupleHash.new, h.new:

for dbits in range(64, 1024 + 1, 8):
                hobj = new_func(digest_bits=dbits)
                self.assertEqual(hobj.digest_size * 8, dbits)

for dbytes in range(8, 128 + 1):
                hobj = new_func(digest_bytes=dbytes)
                self.assertEqual(hobj.digest_size, dbytes)

hobj = h.new()
        self.assertEqual(hobj.digest_size, self.default_bytes)

def test_new_negative(self):

h = self.new()
        for new_func in self.TupleHash.new, h.new:
            self.assertRaises(TypeError, new_func,
                              digest_bytes=self.minimum_bytes,
                              digest_bits=self.minimum_bits)
            self.assertRaises(ValueError, new_func, digest_bytes=0)
            self.assertRaises(ValueError, new_func,
                              digest_bits=self.minimum_bits + 7)
            self.assertRaises(ValueError, new_func,
                              digest_bits=self.minimum_bits - 8)
            self.assertRaises(ValueError, new_func,
                              digest_bits=self.minimum_bytes - 1)

def test_default_digest_size(self):
        digest = self.new().digest()
        self.assertEqual(len(digest), self.default_bytes)

def test_update(self):
        h = self.new()
        h.update(b'')
        h.digest()

h = self.new()
        h.update(b'')
        h.update(b'STRING1')
        h.update(b'STRING2')
        mac1 = h.digest()

h = self.new()
        h.update(b'STRING1')
        h.update(b'STRING2')
        mac2 = h.digest()

self.assertNotEqual(mac1, mac2)

def test_update_negative(self):
        h = self.new()
        self.assertRaises(TypeError, h.update, u"string")
        self.assertRaises(TypeError, h.update, None)

def test_digest(self):
        h = self.new()
        digest = h.digest()

# hexdigest does not change the state
        self.assertEqual(h.digest(), digest)
        # digest returns a byte string
        self.assertTrue(isinstance(digest, type(b"digest")))

def test_update_after_digest(self):
        msg = b"rrrrttt"

# Normally, update() cannot be done after digest()
        h = self.new()
        h.update(msg)
        dig1 = h.digest()
        self.assertRaises(TypeError, h.update, dig1)

def test_hex_digest(self):
        mac = self.new()
        digest = mac.digest()
        hexdigest = mac.hexdigest()

# hexdigest is equivalent to digest
        self.assertEqual(hexlify(digest), tobytes(hexdigest))
        # hexdigest does not change the state
        self.assertEqual(mac.hexdigest(), hexdigest)
        # hexdigest returns a string
        self.assertTrue(isinstance(hexdigest, type("digest")))

def test_bytearray(self):

data = b"\x00\x01\x02"

# Data can be a bytearray (during operation)
        data_ba = bytearray(data)

h1 = self.new()
        h2 = self.new()
        h1.update(data)
        h2.update(data_ba)
        data_ba[:1] = b'\xFF'

self.assertEqual(h1.digest(), h2.digest())

def test_memoryview(self):

data = b"\x00\x01\x02"

def get_mv_ro(data):
            return memoryview(data)

def get_mv_rw(data):
            return memoryview(bytearray(data))

for get_mv in (get_mv_ro, get_mv_rw):

# Data can be a memoryview (during operation)
            data_mv = get_mv(data)

h1 = self.new()
            h2 = self.new()
            h1.update(data)
            h2.update(data_mv)
            if not data_mv.readonly:
                data_mv[:1] = b'\xFF'

self.assertEqual(h1.digest(), h2.digest())

class TupleHash128Test(TupleHashTest):

TupleHash = TupleHash128

minimum_bytes = 8
    default_bytes = 64

minimum_bits = 64
    default_bits = 512

class TupleHash256Test(TupleHashTest):

TupleHash = TupleHash256

minimum_bytes = 8
    default_bytes = 64

minimum_bits = 64
    default_bits = 512

class NISTExampleTestVectors(unittest.TestCase):

# http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/TupleHash_samples.pdf
    test_data = [
        (
            (
                "00 01 02",
                "10 11 12 13 14 15",
            ),
            "",
            "C5 D8 78 6C 1A FB 9B 82 11 1A B3 4B 65 B2 C0 04"
            "8F A6 4E 6D 48 E2 63 26 4C E1 70 7D 3F FC 8E D1",
            "KMAC128 Sample #1 NIST",
            TupleHash128
        ),
        (
            (
                "00 01 02",
                "10 11 12 13 14 15",
            ),
            "My Tuple App",
            "75 CD B2 0F F4 DB 11 54 E8 41 D7 58 E2 41 60 C5"
            "4B AE 86 EB 8C 13 E7 F5 F4 0E B3 55 88 E9 6D FB",
            "KMAC128 Sample #2 NIST",
            TupleHash128
        ),
        (
            (
                "00 01 02",
                "10 11 12 13 14 15",
                "20 21 22 23 24 25 26 27 28",
            ),
            "My Tuple App",
            "E6 0F 20 2C 89 A2 63 1E DA 8D 4C 58 8C A5 FD 07"
            "F3 9E 51 51 99 8D EC CF 97 3A DB 38 04 BB 6E 84",
            "KMAC128 Sample #3 NIST",
            TupleHash128
        ),
        (
            (
                "00 01 02",
                "10 11 12 13 14 15",
            ),
            "",
            "CF B7 05 8C AC A5 E6 68 F8 1A 12 A2 0A 21 95 CE"
            "97 A9 25 F1 DB A3 E7 44 9A 56 F8 22 01 EC 60 73"
            "11 AC 26 96 B1 AB 5E A2 35 2D F1 42 3B DE 7B D4"
            "BB 78 C9 AE D1 A8 53 C7 86 72 F9 EB 23 BB E1 94",
            "KMAC256 Sample #4 NIST",
            TupleHash256
        ),
        (
            (
                "00 01 02",
                "10 11 12 13 14 15",
            ),
            "My Tuple App",
            "14 7C 21 91 D5 ED 7E FD 98 DB D9 6D 7A B5 A1 16"
            "92 57 6F 5F E2 A5 06 5F 3E 33 DE 6B BA 9F 3A A1"
            "C4 E9 A0 68 A2 89 C6 1C 95 AA B3 0A EE 1E 41 0B"
            "0B 60 7D E3 62 0E 24 A4 E3 BF 98 52 A1 D4 36 7E",
            "KMAC256 Sample #5 NIST",
            TupleHash256
        ),
        (
            (
                "00 01 02",
                "10 11 12 13 14 15",
                "20 21 22 23 24 25 26 27 28",
            ),
            "My Tuple App",
            "45 00 0B E6 3F 9B 6B FD 89 F5 47 17 67 0F 69 A9"
            "BC 76 35 91 A4 F0 5C 50 D6 88 91 A7 44 BC C6 E7"
            "D6 D5 B5 E8 2C 01 8D A9 99 ED 35 B0 BB 49 C9 67"
            "8E 52 6A BD 8E 85 C1 3E D2 54 02 1D B9 E7 90 CE",
            "KMAC256 Sample #6 NIST",
            TupleHash256
        ),

]

def setUp(self):
        td = []
        for tv_in in self.test_data:
            tv_out = [None] * len(tv_in)

tv_out[0] = []
            for string in tv_in[0]:
                tv_out[0].append(unhexlify(string.replace(" ", "")))

tv_out[1] = tobytes(tv_in[1])    # Custom
            tv_out[2] = unhexlify(tv_in[2].replace(" ", ""))
            tv_out[3] = tv_in[3]
            tv_out[4] = tv_in[4]
            td.append(tv_out)
        self.test_data = td

def runTest(self):

for data, custom, digest, text, module in self.test_data:
            hd = module.new(custom=custom, digest_bytes=len(digest))
            for string in data:
                hd.update(string)
            self.assertEqual(hd.digest(), digest, msg=text)

def get_tests(config={}):
    tests = []

tests += list_test_cases(TupleHash128Test)
    tests += list_test_cases(TupleHash256Test)
    tests.append(NISTExampleTestVectors())

return tests

if __name__ == '__main__':
    def suite():
        return unittest.TestSuite(get_tests())
    unittest.main(defaultTest='suite')