def test_chacha20_block_function(self):
key = binascii.unhexlify(
'000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f')
nonce = binascii.unhexlify('000000090000004a00000000')
key = make_array(key, 4, to_int=True)
nonce = make_array(nonce, 4, to_int=True)
plain_blocks = [0x0] * 16
state = chacha20(key, nonce, cnt=1)
expected = [
0xe4e7f110,
0x15593bd1,
0x1fdd0f50,
0xc47120a3,
0xc7f4d1c7,
0x0368c033,
0x9aaa2204,
0x4e6cd4c3,
0x466482d2,
0x09aa9f07,
0x05d7c214,
0xa2028bd9,
0xd19c12b5,
0xb94e16de,
0xe883d0cb,
0x4e3c50a2,
]
actual = state
self.assertEqual(expected, actual)
def test_enc_dec__diff_nonce(self):
polychacha = Chacha20Poly1305(self.key, self.nonce)
polychacha2 = Chacha20Poly1305(self.key, self.nonce2)
nonce = make_array(self.nonce, 4, to_int=True)
nonce2 = make_array(self.nonce2, 4, to_int=True)
enc = polychacha.encrypt(self.plain, nonce)
dec = polychacha2.decrypt(enc, nonce2)
self.assertNotEqual(self.plain, dec)
def test_vector_for_chacha20(self):
plaintext = \
b'Ladies and Gentl' + \
b'emen of the clas' + \
b"s of '99: If I c" + \
b'ould offer you o' + \
b'nly one tip for ' + \
b'the future, suns' + \
b'creen would be i' + \
b't.'
key = binascii.unhexlify(
'000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f')
nonce = binascii.unhexlify('000000000000004a00000000')
polychacha = Chacha20Poly1305(key, nonce)
nonce = make_array(nonce, 4, to_int=True)
c = polychacha.encrypt(plaintext, nonce)
expected_c = binascii.unhexlify(''.join("""
6e 2e 35 9a 25 68 f9 80 41 ba 07 28 dd 0d 69 81
e9 7e 7a ec 1d 43 60 c2 0a 27 af cc fd 9f ae 0b
f9 1b 65 c5 52 47 33 ab 8f 59 3d ab cd 62 b3 57
16 39 d6 24 e6 51 52 ab 8f 53 0c 35 9f 08 61 d8
07 ca 0d bf 50 0d 6a 61 56 a3 8e 08 8a 22 b6 5e
52 bc 51 4d 16 cc f8 06 81 8c e9 1a b7 79 37 36
5a f9 0b bf 74 a3 5b e6 b4 0b 8e ed f2 78 5e 42
87 4d
""".split()))
self.assertEqual(c, expected_c)
def test_aead(self):
polychacha = Chacha20Poly1305(self.key, self.nonce)
nonce = make_array(self.nonce, 4, to_int=True)
enc, tag = polychacha.chacha20_aead_encrypt(self.auth_data, self.plain,
nonce)
enc2, tag2 = polychacha.chacha20_aead_encrypt(self.auth_data2,
self.plain, nonce)
self.assertEqual(enc, enc2)
self.assertNotEqual(tag, tag2)
def test_vector_for_POLY1305_key_generation2(self):
key = binascii.unhexlify('00000000000000000000000000000000' * 2)
nonce = binascii.unhexlify('000000000000000000000000')
polychacha = Chacha20Poly1305(key, nonce)
s, r = polychacha.poly1305_key_gen(make_array(nonce, 4, to_int=True))
expected_r = 0x76b8e0ada0f13d90405d6ae55386bd28
expected_s = 0xbdd219b8a08ded1aa836efcc8b770dc7
self.assertEqual(s, expected_s)
self.assertEqual(r, expected_r)
def test_vector_for_POLY1305_key_generation1(self):
key = binascii.unhexlify(
'808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f')
nonce = binascii.unhexlify('000000000001020304050607')
polychacha = Chacha20Poly1305(key, nonce)
s, r = polychacha.poly1305_key_gen(make_array(nonce, 4, to_int=True))
expected_r = 0x8ad5a08b905f81cc815040274ab29471
expected_s = 0xa833b637e3fd0da508dbb8e2fdd1a646
self.assertEqual(r, expected_r)
self.assertEqual(s, expected_s)
def test_vector_for_POLY1305_key_generation3(self):
key = binascii.unhexlify(
'00000000000000000000000000000000' + \
'00000000000000000000000000000001')
nonce = binascii.unhexlify('000000000000000000000002')
polychacha = Chacha20Poly1305(key, nonce)
s, r = polychacha.poly1305_key_gen(make_array(nonce, 4, to_int=True))
expected_r = 0xecfa254f845f647473d3cb140da9e876
expected_s = 0x06cb33066c447b87bc2666dde3fbb739
self.assertEqual(s, expected_s)
self.assertEqual(r, expected_r)
def test_Vector_for_AEAD_CHACHA20_POLY1305(self):
plaintext = \
b'Ladies and Gentl' + \
b'emen of the clas' + \
b"s of '99: If I c" + \
b'ould offer you o' + \
b'nly one tip for ' + \
b'the future, suns' + \
b'creen would be i' + \
b't.'
aad = binascii.unhexlify('50515253c0c1c2c3c4c5c6c7')
key = binascii.unhexlify(''.join('''
80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f
90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f
'''.split()))
nonce = binascii.unhexlify('070000004041424344454647')
polychacha = Chacha20Poly1305(key, nonce)
nonce = make_array(nonce, 4, to_int=True)
s, r = polychacha.poly1305_key_gen(nonce)
self.assertEqual(r, 0x7bac2b252db447af09b67a55a4e95584)
self.assertEqual(s, 0x0ae1d6731075d9eb2a9375783ed553ff)
c = polychacha.encrypt(plaintext, nonce)
expected_c = binascii.unhexlify("".join("""
d3 1a 8d 34 64 8e 60 db 7b 86 af bc 53 ef 7e c2
a4 ad ed 51 29 6e 08 fe a9 e2 b5 a7 36 ee 62 d6
3d be a4 5e 8c a9 67 12 82 fa fb 69 da 92 72 8b
1a 71 de 0a 9e 06 0b 29 05 d6 a5 b6 7e cd 3b 36
92 dd bd 7f 2d 77 8b 8c 98 03 ae e3 28 09 1b 58
fa b3 24 e4 fa d6 75 94 55 85 80 8b 48 31 d7 bc
3f f4 de f0 8e 4b 7a 9d e5 76 d2 65 86 ce c6 4b
61 16
""".split()))
self.assertEqual(len(c), len(expected_c))
self.assertEqual(c, expected_c)
def test_chacha_poly_aead_final(self):
key = binascii.unhexlify(''.join("""
1c 92 40 a5 eb 55 d3 8a f3 33 88 86 04 f6 b5 f0
47 39 17 c1 40 2b 80 09 9d ca 5c bc 20 70 75 c0
""".split()))
nonce = binascii.unhexlify('000000000102030405060708')
aad = binascii.unhexlify('f33388860000000000004e91')
polychacha = Chacha20Poly1305(key, nonce)
s, r = polychacha.poly1305_key_gen(make_array(nonce, 4, to_int=True))
otk = (s, r)
self.assertEqual(r, 0xbdf04aa95ce4de8995b14bb6a18fecaf)
self.assertEqual(s, 0x26478f50c054f563dbc0a21e261572aa)
message = binascii.unhexlify(''.join("""
f3 33 88 86 00 00 00 00 00 00 4e 91 00 00 00 00
64 a0 86 15 75 86 1a f4 60 f0 62 c7 9b e6 43 bd
5e 80 5c fd 34 5c f3 89 f1 08 67 0a c7 6c 8c b2
4c 6c fc 18 75 5d 43 ee a0 9e e9 4e 38 2d 26 b0
bd b7 b7 3c 32 1b 01 00 d4 f0 3b 7f 35 58 94 cf
33 2f 83 0e 71 0b 97 ce 98 c8 a8 4a bd 0b 94 81
14 ad 17 6e 00 8d 33 bd 60 f9 82 b1 ff 37 c8 55
97 97 a0 6e f4 f0 ef 61 c1 86 32 4e 2b 35 06 38
36 06 90 7b 6a 7c 02 b0 f9 f6 15 7b 53 c8 67 e4
b9 16 6c 76 7b 80 4d 46 a5 9b 52 16 cd e7 a4 e9
90 40 c5 a4 04 33 22 5e e2 82 a1 b0 a0 6c 52 3e
af 45 34 d7 f8 3f a1 15 5b 00 47 71 8c bc 54 6a
0d 07 2b 04 b3 56 4e ea 1b 42 22 73 f5 48 27 1a
0b b2 31 60 53 fa 76 99 19 55 eb d6 31 59 43 4e
ce bb 4e 46 6d ae 5a 10 73 a6 72 76 27 09 7a 10
49 e6 17 d9 1d 36 10 94 fa 68 f0 ff 77 98 71 30
30 5b ea ba 2e da 04 df 99 7b 71 4d 6c 6f 2c 29
a6 ad 5c b4 02 2b 02 70 9b 00 00 00 00 00 00 00
0c 00 00 00 00 00 00 00 09 01 00 00 00 00 00 00
""".split()))
tag = polychacha.poly1305_mac(message, otk)
expected_tag = binascii.unhexlify('eead9d67890cbb22392336fea1851f38')
self.assertEqual(tag, expected_tag)
ciphertext = binascii.unhexlify(''.join("""
64 a0 86 15 75 86 1a f4 60 f0 62 c7 9b e6 43 bd
5e 80 5c fd 34 5c f3 89 f1 08 67 0a c7 6c 8c b2
4c 6c fc 18 75 5d 43 ee a0 9e e9 4e 38 2d 26 b0
bd b7 b7 3c 32 1b 01 00 d4 f0 3b 7f 35 58 94 cf
33 2f 83 0e 71 0b 97 ce 98 c8 a8 4a bd 0b 94 81
14 ad 17 6e 00 8d 33 bd 60 f9 82 b1 ff 37 c8 55
97 97 a0 6e f4 f0 ef 61 c1 86 32 4e 2b 35 06 38
36 06 90 7b 6a 7c 02 b0 f9 f6 15 7b 53 c8 67 e4
b9 16 6c 76 7b 80 4d 46 a5 9b 52 16 cd e7 a4 e9
90 40 c5 a4 04 33 22 5e e2 82 a1 b0 a0 6c 52 3e
af 45 34 d7 f8 3f a1 15 5b 00 47 71 8c bc 54 6a
0d 07 2b 04 b3 56 4e ea 1b 42 22 73 f5 48 27 1a
0b b2 31 60 53 fa 76 99 19 55 eb d6 31 59 43 4e
ce bb 4e 46 6d ae 5a 10 73 a6 72 76 27 09 7a 10
49 e6 17 d9 1d 36 10 94 fa 68 f0 ff 77 98 71 30
30 5b ea ba 2e da 04 df 99 7b 71 4d 6c 6f 2c 29
a6 ad 5c b4 02 2b 02 70 9b
""".split()))
decrypt_text = polychacha.decrypt(ciphertext,
make_array(nonce, 4, to_int=True))
print("[*] DEC TEXT :", decrypt_text)
expectd_plain = binascii.unhexlify(''.join("""
49 6e 74 65 72 6e 65 74 2d 44 72 61 66 74 73 20
61 72 65 20 64 72 61 66 74 20 64 6f 63 75 6d 65
6e 74 73 20 76 61 6c 69 64 20 66 6f 72 20 61 20
6d 61 78 69 6d 75 6d 20 6f 66 20 73 69 78 20 6d
6f 6e 74 68 73 20 61 6e 64 20 6d 61 79 20 62 65
20 75 70 64 61 74 65 64 2c 20 72 65 70 6c 61 63
65 64 2c 20 6f 72 20 6f 62 73 6f 6c 65 74 65 64
20 62 79 20 6f 74 68 65 72 20 64 6f 63 75 6d 65
6e 74 73 20 61 74 20 61 6e 79 20 74 69 6d 65 2e
20 49 74 20 69 73 20 69 6e 61 70 70 72 6f 70 72
69 61 74 65 20 74 6f 20 75 73 65 20 49 6e 74 65
72 6e 65 74 2d 44 72 61 66 74 73 20 61 73 20 72
65 66 65 72 65 6e 63 65 20 6d 61 74 65 72 69 61
6c 20 6f 72 20 74 6f 20 63 69 74 65 20 74 68 65
6d 20 6f 74 68 65 72 20 74 68 61 6e 20 61 73 20
2f e2 80 9c 77 6f 72 6b 20 69 6e 20 70 72 6f 67
72 65 73 73 2e 2f e2 80 9d
""".split()))
self.assertEqual(decrypt_text, expectd_plain)
def test_enc_dec(self):
polychacha = Chacha20Poly1305(self.key, self.nonce)
nonce = make_array(self.nonce, 4, to_int=True)
enc = polychacha.encrypt(self.plain, nonce)
dec = polychacha.decrypt(enc, nonce)
self.assertEqual(self.plain, dec)