Debian Codegraph @

tests/test_asn1.py

raw
1 # -*- coding: utf-8 -*-
2 # Copyright: (c) 2020, Jordan Borean (@jborean93) <[email protected]>
3 # MIT License (see LICENSE or https://opensource.org/licenses/MIT)
4
5 import datetime
6 import re
7 import typing
8
9 import pytest
10
11 import spnego._asn1 as asn1
12
13 ASN1_TAG_TESTS = [
14 # Simple universal
15 (asn1.TagClass.universal, False, asn1.TypeTagNumber.octet_string, b"\x00", b"\x04\x01\x00"),
16 # Constructed value
17 (asn1.TagClass.universal, True, asn1.TypeTagNumber.octet_string, b"\x00\x00", b"\x24\x02\x00\x00"),
18 # Large tag number
19 (asn1.TagClass.application, True, 1024, b"\x00\x00", b"\x7F\x88\x00\x02\x00\x00"),
20 (asn1.TagClass.application, True, 1048576, b"\x00\x00", b"\x7F\xC0\x80\x00\x02\x00\x00"),
21 # Long length
22 (asn1.TagClass.universal, False, asn1.TypeTagNumber.octet_string, b"\x00" * 127, b"\x04\x7F" + (b"\x00" * 127)),
23 (asn1.TagClass.universal, False, asn1.TypeTagNumber.octet_string, b"\x00" * 128, b"\x04\x81\x80" + (b"\x00" * 128)),
24 (
25 asn1.TagClass.universal,
26 False,
27 asn1.TypeTagNumber.octet_string,
28 b"\x00" * 1024,
29 b"\x04\x82\x04\x00" + (b"\x00" * 1024),
30 ),
31 ]
32
33 # openssl asn1parse -genstr 'INTEGER:<val>' -out test && hexdump -C test && rm test
34 INTEGER_TESTS = [ # INTEGER has weird rules that I don't fully understand, use a test of test cases.
35 (-748591, b"\x02\x03\xF4\x93\xD1"),
36 (-32769, b"\x02\x03\xFF\x7F\xFF"),
37 (-32768, b"\x02\x02\x80\x00"),
38 (-32767, b"\x02\x02\x80\x01"),
39 (-257, b"\x02\x02\xFE\xFF"),
40 (-256, b"\x02\x02\xFF\x00"),
41 (-255, b"\x02\x02\xFF\x01"),
42 (-129, b"\x02\x02\xFF\x7F"),
43 (-128, b"\x02\x01\x80"),
44 (-127, b"\x02\x01\x81"),
45 (-17, b"\x02\x01\xEF"),
46 (-16, b"\x02\x01\xF0"),
47 (-10, b"\x02\x01\xF6"),
48 (-1, b"\x02\x01\xFF"),
49 (0, b"\x02\x01\x00"),
50 (1, b"\x02\x01\x01"),
51 (10, b"\x02\x01\x0A"),
52 (16, b"\x02\x01\x10"),
53 (17, b"\x02\x01\x11"),
54 (127, b"\x02\x01\x7F"),
55 (128, b"\x02\x02\x00\x80"),
56 (129, b"\x02\x02\x00\x81"),
57 (255, b"\x02\x02\x00\xFF"),
58 (256, b"\x02\x02\x01\x00"),
59 (257, b"\x02\x02\x01\x01"),
60 (32767, b"\x02\x02\x7F\xFF"),
61 (32768, b"\x02\x03\x00\x80\x00"),
62 (32769, b"\x02\x03\x00\x80\x01"),
63 (748591, b"\x02\x03\x0B\x6C\x2F"),
64 ]
65
66 OID_TESTS = [
67 ("1.2", b"\x06\x01\x2A"),
68 ("1.2.3", b"\x06\x02\x2A\x03"),
69 ("1.2.3.1024.2", b"\x06\x05\x2A\x03\x88\x00\x02"),
70 ]
71
72
73 def test_tag_class_native_labels():
74 actual = asn1.TagClass.native_labels()
75
76 assert isinstance(actual, dict)
77 assert actual[asn1.TagClass.universal] == "Universal"
78
79
80 def test_type_tag_number_native_labels():
81 actual = asn1.TypeTagNumber.native_labels()
82
83 assert isinstance(actual, dict)
84 assert actual[asn1.TypeTagNumber.end_of_content] == "End-of-Content (EOC)"
85
86
87 @pytest.mark.parametrize(
88 "value, tag_class, tag_number, expected",
89 [
90 (
91 asn1.unpack_asn1(asn1.pack_asn1_octet_string(b"\x00\x01"))[0],
92 asn1.TagClass.universal,
93 asn1.TypeTagNumber.octet_string,
94 b"\x00\x01",
95 ),
96 (b"\x00\x01", asn1.TagClass.universal, asn1.TypeTagNumber.octet_string, b"\x00\x01"),
97 (asn1.ASN1Value(asn1.TagClass.application, True, 1023, b"\x00"), asn1.TagClass.application, 1023, b"\x00"),
98 ],
99 )
100 def test_extract_asn1_tlv(value, tag_class, tag_number, expected):
101 actual = asn1.extract_asn1_tlv(value, tag_class, tag_number)
102 assert actual == expected
103
104
105 def test_extract_asn1_tlv_invalid_universal_class():
106 expected = (
107 "Invalid ASN.1 OCTET STRING tags, actual tag class TagClass.universal and tag number " "TypeTagNumber.integer"
108 )
109 with pytest.raises(ValueError, match=re.escape(expected)):
110 asn1.extract_asn1_tlv(
111 asn1.ASN1Value(asn1.TagClass.universal, False, asn1.TypeTagNumber.integer, b"\x01"),
112 asn1.TagClass.universal,
113 asn1.TypeTagNumber.octet_string,
114 )
115
116
117 def test_extract_asn1_invalid_other_class():
118 expected = (
119 "Invalid ASN.1 tags, actual tag TagClass.application and number 1024, expecting class "
120 "TagClass.application and number 512"
121 )
122 with pytest.raises(ValueError, match=re.escape(expected)):
123 asn1.extract_asn1_tlv(
124 asn1.ASN1Value(asn1.TagClass.application, True, 1024, b"\x01"), asn1.TagClass.application, 512
125 )
126
127
128 def test_get_sequence_value():
129 input_sequence = asn1.pack_asn1_sequence(
130 [asn1.pack_asn1(asn1.TagClass.context_specific, True, 1, asn1.pack_asn1_integer(1))]
131 )
132 output_sequence = asn1.unpack_asn1_tagged_sequence(asn1.unpack_asn1(input_sequence)[0])
133
134 actual = asn1.get_sequence_value(output_sequence, 1, "Structure", "field-name", asn1.unpack_asn1_integer)
135 assert actual == 1
136
137
138 def test_get_sequence_value_raw():
139 input_sequence = asn1.pack_asn1_sequence(
140 [asn1.pack_asn1(asn1.TagClass.context_specific, True, 1, asn1.pack_asn1_integer(1))]
141 )
142 output_sequence = asn1.unpack_asn1_tagged_sequence(asn1.unpack_asn1(input_sequence)[0])
143
144 actual = asn1.get_sequence_value(output_sequence, 1, "Structure")
145 assert actual == asn1.ASN1Value(asn1.TagClass.universal, False, asn1.TypeTagNumber.integer, b"\x01")
146
147
148 def test_get_sequence_value_no_tag():
149 input_sequence = asn1.pack_asn1_sequence(
150 [asn1.pack_asn1(asn1.TagClass.context_specific, True, 1, asn1.pack_asn1_integer(1))]
151 )
152 output_sequence = asn1.unpack_asn1_tagged_sequence(asn1.unpack_asn1(input_sequence)[0])
153
154 actual = asn1.get_sequence_value(output_sequence, 2, "Structure")
155 assert actual is None
156
157
158 def test_get_sequence_value_failure_with_field_name():
159 input_sequence = asn1.pack_asn1_sequence(
160 [asn1.pack_asn1(asn1.TagClass.context_specific, True, 1, asn1.pack_asn1_integer(1))]
161 )
162 output_sequence = asn1.unpack_asn1_tagged_sequence(asn1.unpack_asn1(input_sequence)[0])
163
164 expected = (
165 "Failed unpacking field-name in Structure: Invalid ASN.1 OCTET STRING tags, actual tag class "
166 "TagClass.universal and tag number TypeTagNumber.integer"
167 )
168 with pytest.raises(ValueError, match=re.escape(expected)):
169 asn1.get_sequence_value(output_sequence, 1, "Structure", "field-name", asn1.unpack_asn1_octet_string)
170
171
172 def test_get_sequence_value_failure_without_field_name():
173 input_sequence = asn1.pack_asn1_sequence(
174 [asn1.pack_asn1(asn1.TagClass.context_specific, True, 1, asn1.pack_asn1_integer(1))]
175 )
176 output_sequence = asn1.unpack_asn1_tagged_sequence(asn1.unpack_asn1(input_sequence)[0])
177
178 expected = (
179 "Failed unpacking Structure: Invalid ASN.1 OCTET STRING tags, actual tag class "
180 "TagClass.universal and tag number TypeTagNumber.integer"
181 )
182 with pytest.raises(ValueError, match=re.escape(expected)):
183 asn1.get_sequence_value(output_sequence, 1, "Structure", unpack_func=asn1.unpack_asn1_octet_string)
184
185
186 @pytest.mark.parametrize("tag_class, constructed, tag_number, data, expected", ASN1_TAG_TESTS)
187 def test_pack_asn1_tlv(tag_class, constructed, tag_number, data, expected):
188 actual = asn1.pack_asn1(tag_class, constructed, tag_number, data)
189 assert actual == expected
190
191
192 @pytest.mark.parametrize("tag_class, constructed, tag_number, data, value", ASN1_TAG_TESTS)
193 def test_unpack_asn1_tlv(tag_class, constructed, tag_number, data, value):
194 actual = asn1.unpack_asn1(value)
195
196 assert actual[0].tag_class == tag_class
197 assert actual[0].constructed == constructed
198 assert actual[0].tag_number == tag_number
199 assert actual[0].b_data == data
200 assert actual[1] == b""
201
202
203 def test_unpack_asn1_tlv_remaining_data():
204 actual = asn1.unpack_asn1(b"\x04\x01\x00\x01")
205
206 assert actual[0].tag_class == asn1.TagClass.universal
207 assert not actual[0].constructed
208 assert actual[0].tag_number == asn1.TypeTagNumber.octet_string
209 assert actual[0].b_data == b"\x00"
210 assert actual[1] == b"\x01"
211
212
213 def test_pack_asn1_tlv_invalid_class():
214 expected = "tag_class must be between 0 and 3"
215 with pytest.raises(ValueError, match=re.escape(expected)):
216 asn1.pack_asn1(10, False, 0, b"") # type: ignore[arg-type]
217
218
219 def test_pack_asn1_bit_string():
220 actual = asn1.pack_asn1_bit_string(b"\x01\x01")
221 assert actual == b"\x03\x03\x00\x01\x01"
222
223
224 @pytest.mark.parametrize(
225 "value, expected",
226 [
227 (b"\x03\x03\x00\x01\x01", b"\x01\x01"),
228 (b"\x03\x03\x01\x01\x01", b"\x01\x00"),
229 ],
230 )
231 def test_unpack_asn1_bit_string(value, expected):
232 actual = asn1.unpack_asn1_bit_string(value[2:])
233 assert actual == expected
234
235 actual = asn1.unpack_asn1_bit_string(asn1.unpack_asn1(value)[0])
236 assert actual == expected
237
238
239 def test_pack_asn1_general_string():
240 actual = asn1.pack_asn1_general_string("cafe")
241 assert actual == b"\x1B\x04\x63\x61\x66\x65"
242
243
244 def test_pack_asn1_enumerated():
245 actual = asn1.pack_asn1_enumerated(1024)
246 assert actual == b"\x0A\x02\x04\x00"
247
248
249 def test_unpack_asn1_enumerated():
250 value = b"\x0A\x02\x04\x00"
251 expected = 1024
252
253 actual = asn1.unpack_asn1_enumerated(value[2:])
254 assert actual == expected
255
256 actual = asn1.unpack_asn1_enumerated(asn1.unpack_asn1(value)[0])
257 assert actual == expected
258
259
260 def test_pack_asn1_general_string_encoding():
261 actual = asn1.pack_asn1_general_string("café", encoding="utf-8")
262 assert actual == b"\x1B\x05\x63\x61\x66\xC3\xA9"
263
264
265 def test_unpack_asn1_general_string():
266 value = b"\x1B\x05\x63\x61\x66\xC3\xA9"
267 expected = b"\x63\x61\x66\xC3\xA9"
268
269 actual = asn1.unpack_asn1_general_string(value[2:])
270 assert actual == expected
271
272 actual = asn1.unpack_asn1_general_string(asn1.unpack_asn1(value)[0])
273 assert actual == expected
274
275
276 @pytest.mark.parametrize("value, expected", INTEGER_TESTS)
277 def test_pack_asn1_integer(value, expected):
278 actual = asn1.pack_asn1_integer(value)
279 assert actual == expected
280
281 actual_untagged = asn1.pack_asn1_integer(value, tag=False)
282 assert actual_untagged == expected[2:]
283
284
285 @pytest.mark.parametrize("expected, value", INTEGER_TESTS)
286 def test_unpack_asn1_integer(expected, value):
287 asn1_value = asn1.unpack_asn1(value)[0]
288 actual = asn1.unpack_asn1_integer(asn1_value)
289 assert actual == expected
290
291 actual = asn1.unpack_asn1_integer(value[2:])
292 assert actual == expected
293
294
295 @pytest.mark.parametrize("value, expected", OID_TESTS)
296 def test_pack_object_identifier(value, expected):
297 actual = asn1.pack_asn1_object_identifier(value)
298 assert actual == expected
299
300
301 def test_pack_object_identifier_invalid_value():
302 expected = "An OID must have 2 or more elements split by '.'"
303 with pytest.raises(ValueError, match=re.escape(expected)):
304 asn1.pack_asn1_object_identifier("1")
305
306
307 @pytest.mark.parametrize("expected, value", OID_TESTS)
308 def test_unpack_object_identifier(expected, value):
309 asn1_value = asn1.unpack_asn1(value)[0]
310 actual = asn1.unpack_asn1_object_identifier(asn1_value)
311 assert actual == expected
312
313 actual = asn1.unpack_asn1_object_identifier(value[2:])
314 assert actual == expected
315
316
317 def test_pack_asn1_sequence():
318 inner_val = asn1.pack_asn1_octet_string(b"\x01\x02")
319 actual = asn1.pack_asn1_sequence([inner_val, inner_val])
320
321 assert actual == b"\x30\x08\x04\x02\x01\x02\x04\x02\x01\x02"
322
323
324 def test_unpack_asn1_sequence():
325 value = b"\x30\x08\x04\x02\x01\x02\x04\x02\x01\x02"
326
327 def actual_test(expected: typing.List) -> bool:
328 assert isinstance(expected, list)
329
330 for a in expected:
331 assert isinstance(a, asn1.ASN1Value)
332 assert a.tag_class == asn1.TagClass.universal
333 assert not a.constructed
334 assert a.tag_number == asn1.TypeTagNumber.octet_string
335 assert a.b_data == b"\x01\x02"
336
337 return True
338
339 actual = asn1.unpack_asn1_sequence(value[2:])
340 assert actual_test(actual)
341
342 actual = asn1.unpack_asn1_sequence(asn1.unpack_asn1(value)[0])
343 assert actual_test(actual)
344
345
346 def test_pack_asn1_octet_string():
347 actual = asn1.pack_asn1_octet_string(b"\x01\x02")
348 assert actual == b"\x04\x02\x01\x02"
349
350
351 def test_unpack_asn1_octet_string():
352 value = b"\x04\x02\x01\x02"
353 expected = b"\x01\x02"
354
355 actual = asn1.unpack_asn1_octet_string(value[2:])
356 assert actual == expected
357
358 actual = asn1.unpack_asn1_octet_string(asn1.unpack_asn1(value)[0])
359 assert actual == expected
360
361
362 @pytest.mark.parametrize(
363 "value, expected",
364 [
365 (b"\x00", False),
366 (b"\x01", True),
367 (b"\x02", True),
368 ],
369 )
370 def test_unpack_asn1_boolean(value, expected):
371 actual = asn1.unpack_asn1_boolean(value)
372 assert actual == expected
373
374 actual = asn1.unpack_asn1_boolean(asn1.unpack_asn1(b"\x01\x01" + value)[0])
375 assert actual == expected
376
377
378 @pytest.mark.parametrize(
379 "value",
380 [
381 b"\x31\x39\x37\x30\x30\x31\x30\x31\x30\x30\x30\x30\x30\x30\x5A",
382 b"\x31\x39\x37\x30\x30\x31\x30\x31\x30\x30\x30\x30\x30\x30\x2E\x30\x30\x30\x30\x30\x30\x5A",
383 ],
384 )
385 def test_unpack_asn1_generalized_time(value):
386 expected = datetime.datetime.fromtimestamp(0, tz=datetime.timezone.utc)
387
388 actual = asn1.unpack_asn1_generalized_time(value)
389 assert actual == expected
390
391 packed_value = asn1.pack_asn1(asn1.TagClass.universal, False, asn1.TypeTagNumber.generalized_time, value)
392 actual = asn1.unpack_asn1_generalized_time(asn1.unpack_asn1(packed_value)[0])
393 assert actual == expected
394
395
396 def test_unpack_asn1_generalized_time_format_err():
397 expected = "time data '1970' does not match format"
398 with pytest.raises(ValueError, match=expected):
399 asn1.unpack_asn1_generalized_time(b"\x31\x39\x37\x30")