468 lines
15 KiB
Python
468 lines
15 KiB
Python
"""Self-test suite for Cryptodome.Hash.TurboSHAKE128 and TurboSHAKE256"""
|
|
|
|
import unittest
|
|
from binascii import unhexlify
|
|
|
|
from Cryptodome.SelfTest.st_common import list_test_cases
|
|
|
|
from Cryptodome.Hash import TurboSHAKE128, TurboSHAKE256
|
|
from Cryptodome.Util.py3compat import bchr
|
|
|
|
|
|
class TurboSHAKETest(unittest.TestCase):
|
|
|
|
def test_new_positive(self):
|
|
|
|
xof1 = self.TurboSHAKE.new()
|
|
xof1.update(b'90')
|
|
|
|
xof2 = self.TurboSHAKE.new(domain=0x1F)
|
|
xof2.update(b'90')
|
|
|
|
xof3 = self.TurboSHAKE.new(data=b'90')
|
|
|
|
out1 = xof1.read(128)
|
|
out2 = xof2.read(128)
|
|
out3 = xof3.read(128)
|
|
|
|
self.assertEqual(out1, out2)
|
|
self.assertEqual(out1, out3)
|
|
|
|
def test_new_domain(self):
|
|
xof1 = self.TurboSHAKE.new(domain=0x1D)
|
|
xof2 = self.TurboSHAKE.new(domain=0x20)
|
|
self.assertNotEqual(xof1.read(128), xof2.read(128))
|
|
|
|
def test_update(self):
|
|
pieces = [bchr(10) * 200, bchr(20) * 300]
|
|
|
|
xof1 = self.TurboSHAKE.new()
|
|
xof1.update(pieces[0]).update(pieces[1])
|
|
digest1 = xof1.read(10)
|
|
|
|
xof2 = self.TurboSHAKE.new()
|
|
xof2.update(pieces[0] + pieces[1])
|
|
digest2 = xof2.read(10)
|
|
|
|
self.assertEqual(digest1, digest2)
|
|
|
|
def test_update_negative(self):
|
|
xof1 = self.TurboSHAKE.new()
|
|
self.assertRaises(TypeError, xof1.update, u"string")
|
|
|
|
def test_read(self):
|
|
xof1 = self.TurboSHAKE.new()
|
|
digest = xof1.read(90)
|
|
|
|
# read returns a byte string of the right length
|
|
self.assertTrue(isinstance(digest, bytes))
|
|
self.assertEqual(len(digest), 90)
|
|
|
|
def test_update_after_read(self):
|
|
xof1 = self.TurboSHAKE.new()
|
|
xof1.update(b"rrrr")
|
|
xof1.read(90)
|
|
self.assertRaises(TypeError, xof1.update, b"ttt")
|
|
|
|
def test_new(self):
|
|
xof1 = self.TurboSHAKE.new(domain=0x07)
|
|
xof1.update(b'90')
|
|
digest1 = xof1.read(100)
|
|
|
|
xof2 = xof1.new()
|
|
xof2.update(b'90')
|
|
digest2 = xof2.read(100)
|
|
|
|
self.assertEqual(digest1, digest2)
|
|
|
|
self.assertRaises(TypeError, xof1.new, domain=0x07)
|
|
|
|
|
|
class TurboSHAKE128Test(TurboSHAKETest):
|
|
TurboSHAKE = TurboSHAKE128
|
|
|
|
|
|
class TurboSHAKE256Test(TurboSHAKETest):
|
|
TurboSHAKE = TurboSHAKE256
|
|
|
|
|
|
def txt2bin(txt):
|
|
clean = txt.replace(" ", "").replace("\n", "").replace("\r", "")
|
|
return unhexlify(clean)
|
|
|
|
|
|
def ptn(n):
|
|
res = bytearray(n)
|
|
pattern = b"".join([bchr(x) for x in range(0, 0xFB)])
|
|
for base in range(0, n - 0xFB, 0xFB):
|
|
res[base:base + 0xFB] = pattern
|
|
remain = n % 0xFB
|
|
if remain:
|
|
base = (n // 0xFB) * 0xFB
|
|
res[base:] = pattern[:remain]
|
|
assert len(res) == n
|
|
return res
|
|
|
|
|
|
def chunked(source, size):
|
|
for i in range(0, len(source), size):
|
|
yield source[i:i+size]
|
|
|
|
|
|
class TurboSHAKE128TV(unittest.TestCase):
|
|
|
|
def test_zero_1(self):
|
|
tv = """1E 41 5F 1C 59 83 AF F2 16 92 17 27 7D 17 BB 53
|
|
8C D9 45 A3 97 DD EC 54 1F 1C E4 1A F2 C1 B7 4C"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new().read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_zero_2(self):
|
|
tv = """1E 41 5F 1C 59 83 AF F2 16 92 17 27 7D 17 BB 53
|
|
8C D9 45 A3 97 DD EC 54 1F 1C E4 1A F2 C1 B7 4C
|
|
3E 8C CA E2 A4 DA E5 6C 84 A0 4C 23 85 C0 3C 15
|
|
E8 19 3B DF 58 73 73 63 32 16 91 C0 54 62 C8 DF"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new().read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_zero_3(self):
|
|
tv = """A3 B9 B0 38 59 00 CE 76 1F 22 AE D5 48 E7 54 DA
|
|
10 A5 24 2D 62 E8 C6 58 E3 F3 A9 23 A7 55 56 07"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new().read(10032)[-32:]
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_1(self):
|
|
tv = """55 CE DD 6F 60 AF 7B B2 9A 40 42 AE 83 2E F3 F5
|
|
8D B7 29 9F 89 3E BB 92 47 24 7D 85 69 58 DA A9"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=ptn(1)).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17(self):
|
|
tv = """9C 97 D0 36 A3 BA C8 19 DB 70 ED E0 CA 55 4E C6
|
|
E4 C2 A1 A4 FF BF D9 EC 26 9C A6 A1 11 16 12 33"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=ptn(17)).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_2(self):
|
|
tv = """96 C7 7C 27 9E 01 26 F7 FC 07 C9 B0 7F 5C DA E1
|
|
E0 BE 60 BD BE 10 62 00 40 E7 5D 72 23 A6 24 D2"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=ptn(17**2)).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_3(self):
|
|
tv = """D4 97 6E B5 6B CF 11 85 20 58 2B 70 9F 73 E1 D6
|
|
85 3E 00 1F DA F8 0E 1B 13 E0 D0 59 9D 5F B3 72"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=ptn(17**3)).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_4(self):
|
|
tv = """DA 67 C7 03 9E 98 BF 53 0C F7 A3 78 30 C6 66 4E
|
|
14 CB AB 7F 54 0F 58 40 3B 1B 82 95 13 18 EE 5C"""
|
|
|
|
btv = txt2bin(tv)
|
|
data = ptn(17**4)
|
|
|
|
# All at once
|
|
res = TurboSHAKE128.new(data=data).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
# Byte by byte
|
|
xof = TurboSHAKE128.new()
|
|
for x in data:
|
|
xof.update(bchr(x))
|
|
res = xof.read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
# Chunks of various prime sizes
|
|
for chunk_size in (13, 17, 19, 23, 31):
|
|
xof = TurboSHAKE128.new()
|
|
for x in chunked(data, chunk_size):
|
|
xof.update(x)
|
|
res = xof.read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_5(self):
|
|
tv = """B9 7A 90 6F BF 83 EF 7C 81 25 17 AB F3 B2 D0 AE
|
|
A0 C4 F6 03 18 CE 11 CF 10 39 25 12 7F 59 EE CD"""
|
|
|
|
btv = txt2bin(tv)
|
|
data = ptn(17**5)
|
|
|
|
# All at once
|
|
res = TurboSHAKE128.new(data=data).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
# Chunks
|
|
xof = TurboSHAKE128.new()
|
|
for chunk in chunked(data, 8192):
|
|
xof.update(chunk)
|
|
res = xof.read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_6(self):
|
|
tv = """35 CD 49 4A DE DE D2 F2 52 39 AF 09 A7 B8 EF 0C
|
|
4D 1C A4 FE 2D 1A C3 70 FA 63 21 6F E7 B4 C2 B1"""
|
|
|
|
btv = txt2bin(tv)
|
|
data = ptn(17**6)
|
|
|
|
res = TurboSHAKE128.new(data=data).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffff_d01(self):
|
|
tv = """BF 32 3F 94 04 94 E8 8E E1 C5 40 FE 66 0B E8 A0
|
|
C9 3F 43 D1 5E C0 06 99 84 62 FA 99 4E ED 5D AB"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=b"\xff\xff\xff", domain=0x01).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ff_d06(self):
|
|
tv = """8E C9 C6 64 65 ED 0D 4A 6C 35 D1 35 06 71 8D 68
|
|
7A 25 CB 05 C7 4C CA 1E 42 50 1A BD 83 87 4A 67"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=b'\xFF', domain=0x06).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffff_d07(self):
|
|
tv = """B6 58 57 60 01 CA D9 B1 E5 F3 99 A9 F7 77 23 BB
|
|
A0 54 58 04 2D 68 20 6F 72 52 68 2D BA 36 63 ED"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=b'\xFF' * 3, domain=0x07).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffffffffff_d0b(self):
|
|
tv = """8D EE AA 1A EC 47 CC EE 56 9F 65 9C 21 DF A8 E1
|
|
12 DB 3C EE 37 B1 81 78 B2 AC D8 05 B7 99 CC 37"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=b'\xFF' * 7, domain=0x0B).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ff_d30(self):
|
|
tv = """55 31 22 E2 13 5E 36 3C 32 92 BE D2 C6 42 1F A2
|
|
32 BA B0 3D AA 07 C7 D6 63 66 03 28 65 06 32 5B"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=b'\xFF', domain=0x30).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffff_d7f(self):
|
|
tv = """16 27 4C C6 56 D4 4C EF D4 22 39 5D 0F 90 53 BD
|
|
A6 D2 8E 12 2A BA 15 C7 65 E5 AD 0E 6E AF 26 F9"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE128.new(data=b'\xFF' * 3, domain=0x7F).read(32)
|
|
self.assertEqual(res, btv)
|
|
|
|
|
|
class TurboSHAKE256TV(unittest.TestCase):
|
|
|
|
def test_zero_1(self):
|
|
tv = """36 7A 32 9D AF EA 87 1C 78 02 EC 67 F9 05 AE 13
|
|
C5 76 95 DC 2C 66 63 C6 10 35 F5 9A 18 F8 E7 DB
|
|
11 ED C0 E1 2E 91 EA 60 EB 6B 32 DF 06 DD 7F 00
|
|
2F BA FA BB 6E 13 EC 1C C2 0D 99 55 47 60 0D B0"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new().read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_zero_2(self):
|
|
tv = """AB EF A1 16 30 C6 61 26 92 49 74 26 85 EC 08 2F
|
|
20 72 65 DC CF 2F 43 53 4E 9C 61 BA 0C 9D 1D 75"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new().read(10032)[-32:]
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_1(self):
|
|
tv = """3E 17 12 F9 28 F8 EA F1 05 46 32 B2 AA 0A 24 6E
|
|
D8 B0 C3 78 72 8F 60 BC 97 04 10 15 5C 28 82 0E
|
|
90 CC 90 D8 A3 00 6A A2 37 2C 5C 5E A1 76 B0 68
|
|
2B F2 2B AE 74 67 AC 94 F7 4D 43 D3 9B 04 82 E2"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=ptn(1)).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17(self):
|
|
tv = """B3 BA B0 30 0E 6A 19 1F BE 61 37 93 98 35 92 35
|
|
78 79 4E A5 48 43 F5 01 10 90 FA 2F 37 80 A9 E5
|
|
CB 22 C5 9D 78 B4 0A 0F BF F9 E6 72 C0 FB E0 97
|
|
0B D2 C8 45 09 1C 60 44 D6 87 05 4D A5 D8 E9 C7"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=ptn(17)).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_2(self):
|
|
tv = """66 B8 10 DB 8E 90 78 04 24 C0 84 73 72 FD C9 57
|
|
10 88 2F DE 31 C6 DF 75 BE B9 D4 CD 93 05 CF CA
|
|
E3 5E 7B 83 E8 B7 E6 EB 4B 78 60 58 80 11 63 16
|
|
FE 2C 07 8A 09 B9 4A D7 B8 21 3C 0A 73 8B 65 C0"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=ptn(17**2)).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_3(self):
|
|
tv = """C7 4E BC 91 9A 5B 3B 0D D1 22 81 85 BA 02 D2 9E
|
|
F4 42 D6 9D 3D 42 76 A9 3E FE 0B F9 A1 6A 7D C0
|
|
CD 4E AB AD AB 8C D7 A5 ED D9 66 95 F5 D3 60 AB
|
|
E0 9E 2C 65 11 A3 EC 39 7D A3 B7 6B 9E 16 74 FB"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=ptn(17**3)).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_4(self):
|
|
tv = """02 CC 3A 88 97 E6 F4 F6 CC B6 FD 46 63 1B 1F 52
|
|
07 B6 6C 6D E9 C7 B5 5B 2D 1A 23 13 4A 17 0A FD
|
|
AC 23 4E AB A9 A7 7C FF 88 C1 F0 20 B7 37 24 61
|
|
8C 56 87 B3 62 C4 30 B2 48 CD 38 64 7F 84 8A 1D"""
|
|
|
|
btv = txt2bin(tv)
|
|
data = ptn(17**4)
|
|
|
|
# All at once
|
|
res = TurboSHAKE256.new(data=data).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
# Byte by byte
|
|
xof = TurboSHAKE256.new()
|
|
for x in data:
|
|
xof.update(bchr(x))
|
|
res = xof.read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
# Chunks of various prime sizes
|
|
for chunk_size in (13, 17, 19, 23, 31):
|
|
xof = TurboSHAKE256.new()
|
|
for x in chunked(data, chunk_size):
|
|
xof.update(x)
|
|
res = xof.read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_5(self):
|
|
tv = """AD D5 3B 06 54 3E 58 4B 58 23 F6 26 99 6A EE 50
|
|
FE 45 ED 15 F2 02 43 A7 16 54 85 AC B4 AA 76 B4
|
|
FF DA 75 CE DF 6D 8C DC 95 C3 32 BD 56 F4 B9 86
|
|
B5 8B B1 7D 17 78 BF C1 B1 A9 75 45 CD F4 EC 9F"""
|
|
|
|
btv = txt2bin(tv)
|
|
data = ptn(17**5)
|
|
|
|
# All at once
|
|
res = TurboSHAKE256.new(data=data).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
# Chunks
|
|
xof = TurboSHAKE256.new()
|
|
for chunk in chunked(data, 8192):
|
|
xof.update(chunk)
|
|
res = xof.read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ptn_17_6(self):
|
|
tv = """9E 11 BC 59 C2 4E 73 99 3C 14 84 EC 66 35 8E F7
|
|
1D B7 4A EF D8 4E 12 3F 78 00 BA 9C 48 53 E0 2C
|
|
FE 70 1D 9E 6B B7 65 A3 04 F0 DC 34 A4 EE 3B A8
|
|
2C 41 0F 0D A7 0E 86 BF BD 90 EA 87 7C 2D 61 04"""
|
|
|
|
btv = txt2bin(tv)
|
|
data = ptn(17**6)
|
|
|
|
res = TurboSHAKE256.new(data=data).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffff_d01(self):
|
|
tv = """D2 1C 6F BB F5 87 FA 22 82 F2 9A EA 62 01 75 FB
|
|
02 57 41 3A F7 8A 0B 1B 2A 87 41 9C E0 31 D9 33
|
|
AE 7A 4D 38 33 27 A8 A1 76 41 A3 4F 8A 1D 10 03
|
|
AD 7D A6 B7 2D BA 84 BB 62 FE F2 8F 62 F1 24 24"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=b"\xff\xff\xff", domain=0x01).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ff_d06(self):
|
|
tv = """73 8D 7B 4E 37 D1 8B 7F 22 AD 1B 53 13 E3 57 E3
|
|
DD 7D 07 05 6A 26 A3 03 C4 33 FA 35 33 45 52 80
|
|
F4 F5 A7 D4 F7 00 EF B4 37 FE 6D 28 14 05 E0 7B
|
|
E3 2A 0A 97 2E 22 E6 3A DC 1B 09 0D AE FE 00 4B"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=b'\xFF', domain=0x06).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffff_d07(self):
|
|
tv = """18 B3 B5 B7 06 1C 2E 67 C1 75 3A 00 E6 AD 7E D7
|
|
BA 1C 90 6C F9 3E FB 70 92 EA F2 7F BE EB B7 55
|
|
AE 6E 29 24 93 C1 10 E4 8D 26 00 28 49 2B 8E 09
|
|
B5 50 06 12 B8 F2 57 89 85 DE D5 35 7D 00 EC 67"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=b'\xFF' * 3, domain=0x07).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffffffffff_d0b(self):
|
|
tv = """BB 36 76 49 51 EC 97 E9 D8 5F 7E E9 A6 7A 77 18
|
|
FC 00 5C F4 25 56 BE 79 CE 12 C0 BD E5 0E 57 36
|
|
D6 63 2B 0D 0D FB 20 2D 1B BB 8F FE 3D D7 4C B0
|
|
08 34 FA 75 6C B0 34 71 BA B1 3A 1E 2C 16 B3 C0"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=b'\xFF' * 7, domain=0x0B).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ff_d30(self):
|
|
tv = """F3 FE 12 87 3D 34 BC BB 2E 60 87 79 D6 B7 0E 7F
|
|
86 BE C7 E9 0B F1 13 CB D4 FD D0 C4 E2 F4 62 5E
|
|
14 8D D7 EE 1A 52 77 6C F7 7F 24 05 14 D9 CC FC
|
|
3B 5D DA B8 EE 25 5E 39 EE 38 90 72 96 2C 11 1A"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=b'\xFF', domain=0x30).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
def test_ffffff_d7f(self):
|
|
tv = """AB E5 69 C1 F7 7E C3 40 F0 27 05 E7 D3 7C 9A B7
|
|
E1 55 51 6E 4A 6A 15 00 21 D7 0B 6F AC 0B B4 0C
|
|
06 9F 9A 98 28 A0 D5 75 CD 99 F9 BA E4 35 AB 1A
|
|
CF 7E D9 11 0B A9 7C E0 38 8D 07 4B AC 76 87 76"""
|
|
|
|
btv = txt2bin(tv)
|
|
res = TurboSHAKE256.new(data=b'\xFF' * 3, domain=0x7F).read(64)
|
|
self.assertEqual(res, btv)
|
|
|
|
|
|
def get_tests(config={}):
|
|
tests = []
|
|
tests += list_test_cases(TurboSHAKE128Test)
|
|
tests += list_test_cases(TurboSHAKE256Test)
|
|
tests += list_test_cases(TurboSHAKE128TV)
|
|
tests += list_test_cases(TurboSHAKE256TV)
|
|
return tests
|
|
|
|
|
|
if __name__ == '__main__':
|
|
def suite():
|
|
return unittest.TestSuite(get_tests())
|
|
unittest.main(defaultTest='suite')
|