| 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") |