1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
from unittest import TestCase
from pqconnect.common.constants import (
EPHEMERAL_KEY_REQUEST,
STATIC_KEY_REQUEST,
)
from pqconnect.common.crypto import dh, ekem
from pqconnect.request import (
EphemeralKeyRequest,
EphemeralKeyResponse,
KeyRequest,
KeyRequestHandler,
KeyResponseHandler,
StaticKeyRequest,
StaticKeyResponse,
UnexpectedRequestException,
UnpackException,
)
class TestKeyRequest(TestCase):
def setUp(self) -> None:
pass
def tearDown(self) -> None:
pass
def test_init(self) -> None:
try:
kr = KeyRequest(0)
self.assertTrue(False, "wrong type")
except TypeError:
self.assertTrue(True)
try:
kr = KeyRequest(b"\x00\x00")
self.assertTrue(True)
except Exception:
self.assertTrue(False)
def test_pack(self) -> None:
msg_type = b"\x01\xff"
try:
kr = KeyRequest(msg_type)
kr._pack_bts([1, b"1"])
self.assertTrue(False, "Should have thrown a TypeError")
except TypeError:
self.assertTrue(True)
try:
kr._pack_bts(["1", b"1"])
self.assertTrue(False, "Should have thrown a TypeError")
except TypeError:
self.assertTrue(True)
try:
kr._pack_bts([b"hello", b"goodbye"])
self.assertEqual(
kr.payload, msg_type + b"\x00\x05hello\x00\x07goodbye"
)
except Exception:
self.assertTrue(False)
def test_unpack(self) -> None:
msg_type = b"\x01\xf1" # no significance
payload = msg_type + b"\x00\x05hello\x00\x07goodbye"
payload_wrong0 = payload + b"\x00\x00"
payload_wrong1 = payload + b"\x00\x01"
payload_wrong2 = msg_type + b"\x00\x05hello\x00\x08goodbye"
try:
kr = KeyRequest(msg_type=msg_type, payload=payload)
vals = kr._unpack_bts()
self.assertEqual(vals[0], b"hello")
self.assertEqual(vals[1], b"goodbye")
self.assertEqual(len(vals), 2)
except Exception:
self.assertTrue(False)
try:
kr = KeyRequest(msg_type, payload_wrong0)
vals = kr._unpack_bts()
self.assertTrue(False, "Extraneous zero-length value undetected")
except UnpackException:
self.assertTrue(True)
try:
kr = KeyRequest(msg_type, payload_wrong1)
vals = kr._unpack_bts()
self.assertTrue(False, "payload too long")
except UnpackException:
self.assertTrue(True)
try:
kr = KeyRequest(msg_type, payload_wrong2)
vals = kr._unpack_bts()
self.assertTrue(False, "payload truncated")
except UnpackException:
self.assertTrue(True)
class TestKeyRequestHandler(TestCase):
def setUp(self) -> None:
pass
def tearDown(self) -> None:
pass
def test_request_handler(self) -> None:
"""Tests that correct request is returned"""
skr = StaticKeyRequest(depth=2, pos=20).payload
eph_request = EphemeralKeyRequest()
ekr = bytes(eph_request)
handler_request = KeyRequestHandler(skr).request()
self.assertTrue(isinstance(handler_request, StaticKeyRequest))
self.assertEqual(handler_request.depth, 2)
self.assertEqual(handler_request.pos, 20)
handler_request1 = KeyRequestHandler(ekr).request()
self.assertTrue(
isinstance(handler_request1, EphemeralKeyRequest),
type(handler_request1),
)
def test_invalid_request_handled(self) -> None:
"""Should return None and not raise any exceptions"""
fake = b"this is not a real request"
more_fake = StaticKeyRequest()
more_fake._pack_bts([b"hello", b"I", b"am", b"fake"])
print(more_fake.payload)
self.assertIsNone(KeyRequestHandler(fake).request())
self.assertIsNone(KeyRequestHandler(more_fake.payload).request())
class TestResponseHandler(TestCase):
def setUp(self) -> None:
pass
def tearDown(self) -> None:
pass
def test_response(self) -> None:
sreq = StaticKeyResponse(depth=2, pos=25, keydata=b"Hi")
resp = KeyResponseHandler(sreq.payload).response()
self.assertTrue(isinstance(resp, StaticKeyResponse))
ereq = EphemeralKeyResponse(pqpk=b"0" * ekem.pklen, npqpk=b"0" * 32)
resp = KeyResponseHandler(ereq.payload).response()
self.assertTrue(isinstance(resp, EphemeralKeyResponse))
class TestEphemeralRequestResponse(TestCase):
def test_same_size(self) -> None:
req = EphemeralKeyRequest()
sntrup, _ = ekem.keypair()
ecc, _ = dh.keypair()
resp = EphemeralKeyResponse(pqpk=sntrup, npqpk=ecc)
self.assertEqual(len(bytes(req)), len(bytes(resp)))
|
