Estructura inicial funcional con documentación en el README.md de la FastAPI
This commit is contained in:
600
env/lib/python3.12/site-packages/spnego/_asn1.py
vendored
Normal file
600
env/lib/python3.12/site-packages/spnego/_asn1.py
vendored
Normal file
@@ -0,0 +1,600 @@
|
||||
# Copyright: (c) 2020, Jordan Borean (@jborean93) <jborean93@gmail.com>
|
||||
# MIT License (see LICENSE or https://opensource.org/licenses/MIT)
|
||||
|
||||
import collections
|
||||
import datetime
|
||||
import enum
|
||||
import struct
|
||||
import typing
|
||||
|
||||
from spnego._text import to_bytes, to_text
|
||||
|
||||
ASN1Value = collections.namedtuple("ASN1Value", ["tag_class", "constructed", "tag_number", "b_data"])
|
||||
"""A representation of an ASN.1 TLV as a Python object.
|
||||
|
||||
Defines the ASN.1 Type Length Value (TLV) values as separate objects for easier parsing. This is returned by
|
||||
:method:`unpack_asn1`.
|
||||
|
||||
Attributes:
|
||||
tag_class (TagClass): The tag class of the TLV.
|
||||
constructed (bool): Whether the value is constructed or 0, 1, or more element encodings (True) or not (False).
|
||||
tag_number (Union[TypeTagNumber, int]): The tag number of the value, can be a TypeTagNumber if the tag_class
|
||||
is `universal` otherwise it's an explicit tag number value.
|
||||
b_data (bytes): The raw byes of the TLV value.
|
||||
"""
|
||||
|
||||
|
||||
class TagClass(enum.IntEnum):
|
||||
universal = 0
|
||||
application = 1
|
||||
context_specific = 2
|
||||
private = 3
|
||||
|
||||
@classmethod
|
||||
def native_labels(cls) -> typing.Dict["TagClass", str]:
|
||||
return {
|
||||
TagClass.universal: "Universal",
|
||||
TagClass.application: "Application",
|
||||
TagClass.context_specific: "Context-specific",
|
||||
TagClass.private: "Private",
|
||||
}
|
||||
|
||||
|
||||
class TypeTagNumber(enum.IntEnum):
|
||||
end_of_content = 0
|
||||
boolean = 1
|
||||
integer = 2
|
||||
bit_string = 3
|
||||
octet_string = 4
|
||||
null = 5
|
||||
object_identifier = 6
|
||||
object_descriptor = 7
|
||||
external = 8
|
||||
real = 9
|
||||
enumerated = 10
|
||||
embedded_pdv = 11
|
||||
utf8_string = 12
|
||||
relative_oid = 13
|
||||
time = 14
|
||||
reserved = 15
|
||||
sequence = 16
|
||||
sequence_of = 16
|
||||
set = 17
|
||||
set_of = 17
|
||||
numeric_string = 18
|
||||
printable_string = 19
|
||||
t61_string = 20
|
||||
videotex_string = 21
|
||||
ia5_string = 22
|
||||
utc_time = 23
|
||||
generalized_time = 24
|
||||
graphic_string = 25
|
||||
visible_string = 26
|
||||
general_string = 27
|
||||
universal_string = 28
|
||||
character_string = 29
|
||||
bmp_string = 30
|
||||
date = 31
|
||||
time_of_day = 32
|
||||
date_time = 33
|
||||
duration = 34
|
||||
oid_iri = 35
|
||||
relative_oid_iri = 36
|
||||
|
||||
@classmethod
|
||||
def native_labels(cls) -> typing.Dict[int, str]:
|
||||
return {
|
||||
TypeTagNumber.end_of_content: "End-of-Content (EOC)",
|
||||
TypeTagNumber.boolean: "BOOLEAN",
|
||||
TypeTagNumber.integer: "INTEGER",
|
||||
TypeTagNumber.bit_string: "BIT STRING",
|
||||
TypeTagNumber.octet_string: "OCTET STRING",
|
||||
TypeTagNumber.null: "NULL",
|
||||
TypeTagNumber.object_identifier: "OBJECT IDENTIFIER",
|
||||
TypeTagNumber.object_descriptor: "Object Descriptor",
|
||||
TypeTagNumber.external: "EXTERNAL",
|
||||
TypeTagNumber.real: "REAL (float)",
|
||||
TypeTagNumber.enumerated: "ENUMERATED",
|
||||
TypeTagNumber.embedded_pdv: "EMBEDDED PDV",
|
||||
TypeTagNumber.utf8_string: "UTF8String",
|
||||
TypeTagNumber.relative_oid: "RELATIVE-OID",
|
||||
TypeTagNumber.time: "TIME",
|
||||
TypeTagNumber.reserved: "RESERVED",
|
||||
TypeTagNumber.sequence: "SEQUENCE or SEQUENCE OF",
|
||||
TypeTagNumber.set: "SET or SET OF",
|
||||
TypeTagNumber.numeric_string: "NumericString",
|
||||
TypeTagNumber.printable_string: "PrintableString",
|
||||
TypeTagNumber.t61_string: "T61String",
|
||||
TypeTagNumber.videotex_string: "VideotexString",
|
||||
TypeTagNumber.ia5_string: "IA5String",
|
||||
TypeTagNumber.utc_time: "UTCTime",
|
||||
TypeTagNumber.generalized_time: "GeneralizedTime",
|
||||
TypeTagNumber.graphic_string: "GraphicString",
|
||||
TypeTagNumber.visible_string: "VisibleString",
|
||||
TypeTagNumber.general_string: "GeneralString",
|
||||
TypeTagNumber.universal_string: "UniversalString",
|
||||
TypeTagNumber.character_string: "CHARACTER",
|
||||
TypeTagNumber.bmp_string: "BMPString",
|
||||
TypeTagNumber.date: "DATE",
|
||||
TypeTagNumber.time_of_day: "TIME-OF-DAY",
|
||||
TypeTagNumber.date_time: "DATE-TIME",
|
||||
TypeTagNumber.duration: "DURATION",
|
||||
TypeTagNumber.oid_iri: "OID-IRI",
|
||||
TypeTagNumber.relative_oid_iri: "RELATIVE-OID-IRI",
|
||||
}
|
||||
|
||||
|
||||
def extract_asn1_tlv(
|
||||
tlv: typing.Union[bytes, ASN1Value],
|
||||
tag_class: TagClass,
|
||||
tag_number: typing.Union[int, TypeTagNumber],
|
||||
) -> bytes:
|
||||
"""Extract the bytes and validates the existing tag of an ASN.1 value."""
|
||||
if isinstance(tlv, ASN1Value):
|
||||
if tag_class == TagClass.universal:
|
||||
label_name = TypeTagNumber.native_labels().get(tag_number, "Unknown tag type")
|
||||
msg = "Invalid ASN.1 %s tags, actual tag class %s and tag number %s" % (
|
||||
label_name,
|
||||
f"{type(tlv.tag_class).__name__}.{tlv.tag_class.name}",
|
||||
(
|
||||
f"{type(tlv.tag_number).__name__}.{tlv.tag_number.name}"
|
||||
if isinstance(tlv.tag_number, TypeTagNumber)
|
||||
else tlv.tag_number
|
||||
),
|
||||
)
|
||||
|
||||
else:
|
||||
msg = "Invalid ASN.1 tags, actual tag %s and number %s, expecting class %s and number %s" % (
|
||||
f"{type(tlv.tag_class).__name__}.{tlv.tag_class.name}",
|
||||
(
|
||||
f"{type(tlv.tag_number).__name__}.{tlv.tag_number.name}"
|
||||
if isinstance(tlv.tag_number, TypeTagNumber)
|
||||
else tlv.tag_number
|
||||
),
|
||||
f"{type(tag_class).__name__}.{tag_class.name}",
|
||||
(
|
||||
f"{type(tag_number).__name__}.{tag_number.name}"
|
||||
if isinstance(tag_number, TypeTagNumber)
|
||||
else tag_number
|
||||
),
|
||||
)
|
||||
|
||||
if tlv.tag_class != tag_class or tlv.tag_number != tag_number:
|
||||
raise ValueError(msg)
|
||||
|
||||
return tlv.b_data
|
||||
|
||||
return tlv
|
||||
|
||||
|
||||
def get_sequence_value(
|
||||
sequence: typing.Dict[int, ASN1Value],
|
||||
tag: int,
|
||||
structure_name: str,
|
||||
field_name: typing.Optional[str] = None,
|
||||
unpack_func: typing.Optional[typing.Callable[[typing.Union[bytes, ASN1Value]], typing.Any]] = None,
|
||||
) -> typing.Any:
|
||||
"""Gets an optional tag entry in a tagged sequence will a further unpacking of the value."""
|
||||
if tag not in sequence:
|
||||
return
|
||||
|
||||
if not unpack_func:
|
||||
return sequence[tag]
|
||||
|
||||
try:
|
||||
return unpack_func(sequence[tag])
|
||||
except ValueError as e:
|
||||
where = "%s in %s" % (field_name, structure_name) if field_name else structure_name
|
||||
raise ValueError("Failed unpacking %s: %s" % (where, str(e))) from e
|
||||
|
||||
|
||||
def pack_asn1(
|
||||
tag_class: TagClass,
|
||||
constructed: bool,
|
||||
tag_number: typing.Union[TypeTagNumber, int],
|
||||
b_data: bytes,
|
||||
) -> bytes:
|
||||
"""Pack the ASN.1 value into the ASN.1 bytes.
|
||||
|
||||
Will pack the raw bytes into an ASN.1 Type Length Value (TLV) value. A TLV is in the form:
|
||||
|
||||
| Identifier Octet(s) | Length Octet(s) | Data Octet(s) |
|
||||
|
||||
Args:
|
||||
tag_class: The tag class of the data.
|
||||
constructed: Whether the data is constructed (True), i.e. contains 0, 1, or more element encodings, or is
|
||||
primitive (False).
|
||||
tag_number: The type tag number if tag_class is universal else the explicit tag number of the TLV.
|
||||
b_data: The encoded value to pack into the ASN.1 TLV.
|
||||
|
||||
Returns:
|
||||
bytes: The ASN.1 value as raw bytes.
|
||||
"""
|
||||
b_asn1_data = bytearray()
|
||||
|
||||
# ASN.1 Identifier octet is
|
||||
#
|
||||
# | Octet 1 | | Octet 2 |
|
||||
# | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 |
|
||||
# | Class | P/C | Tag Number (0-30) | | More | Tag number |
|
||||
#
|
||||
# If Tag Number is >= 31 the first 5 bits are 1 and the 2nd octet is used to encode the length.
|
||||
if tag_class < 0 or tag_class > 3:
|
||||
raise ValueError("tag_class must be between 0 and 3")
|
||||
|
||||
identifier_octets = tag_class << 6
|
||||
identifier_octets |= (1 if constructed else 0) << 5
|
||||
|
||||
if tag_number < 31:
|
||||
identifier_octets |= tag_number
|
||||
b_asn1_data.append(identifier_octets)
|
||||
else:
|
||||
# Set the first 5 bits of the first octet to 1 and encode the tag number in subsequent octets.
|
||||
identifier_octets |= 31
|
||||
b_asn1_data.append(identifier_octets)
|
||||
b_asn1_data.extend(_pack_asn1_octet_number(tag_number))
|
||||
|
||||
# ASN.1 Length octet for DER encoding is always in the definite form. This form packs the lengths in the following
|
||||
# octet structure:
|
||||
#
|
||||
# | Octet 1 | | Octet n |
|
||||
# | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 |
|
||||
# | Long form | Short = length, Long = num octets | | Big endian length for long |
|
||||
#
|
||||
# Basically if the length < 127 it's encoded in the first octet, otherwise the first octet 7 bits indicates how
|
||||
# many subsequent octets were used to encode the length.
|
||||
length = len(b_data)
|
||||
if length < 128:
|
||||
b_asn1_data.append(length)
|
||||
else:
|
||||
length_octets = bytearray()
|
||||
while length:
|
||||
length_octets.append(length & 0b11111111)
|
||||
length >>= 8
|
||||
|
||||
# Reverse the octets so the higher octets are first, add the initial length octet with the MSB set and add them
|
||||
# all to the main ASN.1 byte array.
|
||||
length_octets.reverse()
|
||||
b_asn1_data.append(len(length_octets) | 0b10000000)
|
||||
b_asn1_data.extend(length_octets)
|
||||
|
||||
return bytes(b_asn1_data) + b_data
|
||||
|
||||
|
||||
def pack_asn1_bit_string(
|
||||
value: bytes,
|
||||
tag: bool = True,
|
||||
) -> bytes:
|
||||
# First octet is the number of unused bits in the last octet from the LSB.
|
||||
b_data = b"\x00" + value
|
||||
if tag:
|
||||
b_data = pack_asn1(TagClass.universal, False, TypeTagNumber.bit_string, b_data)
|
||||
|
||||
return b_data
|
||||
|
||||
|
||||
def pack_asn1_enumerated(
|
||||
value: int,
|
||||
tag: bool = True,
|
||||
) -> bytes:
|
||||
"""Packs an int into an ASN.1 ENUMERATED byte value with optional universal tagging."""
|
||||
b_data = pack_asn1_integer(value, tag=False)
|
||||
if tag:
|
||||
b_data = pack_asn1(TagClass.universal, False, TypeTagNumber.enumerated, b_data)
|
||||
|
||||
return b_data
|
||||
|
||||
|
||||
def pack_asn1_general_string(
|
||||
value: typing.Union[str, bytes],
|
||||
tag: bool = True,
|
||||
encoding: str = "ascii",
|
||||
) -> bytes:
|
||||
"""Packs an string value into an ASN.1 GeneralString byte value with optional universal tagging."""
|
||||
b_data = to_bytes(value, encoding=encoding)
|
||||
if tag:
|
||||
b_data = pack_asn1(TagClass.universal, False, TypeTagNumber.general_string, b_data)
|
||||
|
||||
return b_data
|
||||
|
||||
|
||||
def pack_asn1_integer(
|
||||
value: int,
|
||||
tag: bool = True,
|
||||
) -> bytes:
|
||||
"""Packs an int value into an ASN.1 INTEGER byte value with optional universal tagging."""
|
||||
# Thanks to https://github.com/andrivet/python-asn1 for help with the negative value logic.
|
||||
is_negative = False
|
||||
limit = 0x7F
|
||||
if value < 0:
|
||||
value = -value
|
||||
is_negative = True
|
||||
limit = 0x80
|
||||
|
||||
b_int = bytearray()
|
||||
while value > limit:
|
||||
val = value & 0xFF
|
||||
|
||||
if is_negative:
|
||||
val = 0xFF - val
|
||||
|
||||
b_int.append(val)
|
||||
value >>= 8
|
||||
|
||||
b_int.append(((0xFF - value) if is_negative else value) & 0xFF)
|
||||
|
||||
if is_negative:
|
||||
for idx, val in enumerate(b_int):
|
||||
if val < 0xFF:
|
||||
b_int[idx] += 1
|
||||
break
|
||||
|
||||
b_int[idx] = 0
|
||||
|
||||
if is_negative and b_int[-1] == 0x7F: # Two's complement corner case
|
||||
b_int.append(0xFF)
|
||||
|
||||
b_int.reverse()
|
||||
|
||||
b_value = bytes(b_int)
|
||||
if tag:
|
||||
b_value = pack_asn1(TagClass.universal, False, TypeTagNumber.integer, b_value)
|
||||
|
||||
return b_value
|
||||
|
||||
|
||||
def pack_asn1_object_identifier(
|
||||
oid: str,
|
||||
tag: bool = True,
|
||||
) -> bytes:
|
||||
"""Packs an str value into an ASN.1 OBJECT IDENTIFIER byte value with optional universal tagging."""
|
||||
b_oid = bytearray()
|
||||
oid_split = [int(i) for i in oid.split(".")]
|
||||
|
||||
if len(oid_split) < 2:
|
||||
raise ValueError("An OID must have 2 or more elements split by '.'")
|
||||
|
||||
# The first byte of the OID is the first 2 elements (x.y) as (x * 40) + y
|
||||
b_oid.append((oid_split[0] * 40) + oid_split[1])
|
||||
|
||||
for val in oid_split[2:]:
|
||||
b_oid.extend(_pack_asn1_octet_number(val))
|
||||
|
||||
b_value = bytes(b_oid)
|
||||
if tag:
|
||||
b_value = pack_asn1(TagClass.universal, False, TypeTagNumber.object_identifier, b_value)
|
||||
|
||||
return b_value
|
||||
|
||||
|
||||
def pack_asn1_octet_string(
|
||||
b_data: bytes,
|
||||
tag: bool = True,
|
||||
) -> bytes:
|
||||
"""Packs an bytes value into an ASN.1 OCTET STRING byte value with optional universal tagging."""
|
||||
if tag:
|
||||
b_data = pack_asn1(TagClass.universal, False, TypeTagNumber.octet_string, b_data)
|
||||
|
||||
return b_data
|
||||
|
||||
|
||||
def pack_asn1_sequence(
|
||||
sequence: typing.List[bytes],
|
||||
tag: bool = True,
|
||||
) -> bytes:
|
||||
"""Packs a list of encoded bytes into an ASN.1 SEQUENCE byte value with optional universal tagging."""
|
||||
b_data = b"".join(sequence)
|
||||
if tag:
|
||||
b_data = pack_asn1(TagClass.universal, True, TypeTagNumber.sequence, b_data)
|
||||
|
||||
return b_data
|
||||
|
||||
|
||||
def _pack_asn1_octet_number(num: int) -> bytes:
|
||||
"""Packs an int number into an ASN.1 integer value that spans multiple octets."""
|
||||
num_octets = bytearray()
|
||||
|
||||
while num:
|
||||
# Get the 7 bit value of the number.
|
||||
octet_value = num & 0b01111111
|
||||
|
||||
# Set the MSB if this isn't the first octet we are processing (overall last octet)
|
||||
if len(num_octets):
|
||||
octet_value |= 0b10000000
|
||||
|
||||
num_octets.append(octet_value)
|
||||
|
||||
# Shift the number by 7 bits as we've just processed them.
|
||||
num >>= 7
|
||||
|
||||
# Finally we reverse the order so the higher octets are first.
|
||||
num_octets.reverse()
|
||||
|
||||
return num_octets
|
||||
|
||||
|
||||
def unpack_asn1(b_data: bytes) -> typing.Tuple[ASN1Value, bytes]:
|
||||
"""Unpacks an ASN.1 TLV into each element.
|
||||
|
||||
Unpacks the raw ASN.1 value into a `ASN1Value` tuple and returns the remaining bytes that are not part of the
|
||||
ASN.1 TLV.
|
||||
|
||||
Args:
|
||||
b_data: The raw bytes to unpack as an ASN.1 TLV.
|
||||
|
||||
Returns:
|
||||
ASN1Value: The ASN.1 value that is unpacked from the raw bytes passed in.
|
||||
bytes: Any remaining bytes that are not part of the ASN1Value.
|
||||
"""
|
||||
octet1 = struct.unpack("B", b_data[:1])[0]
|
||||
tag_class = TagClass((octet1 & 0b11000000) >> 6)
|
||||
constructed = bool(octet1 & 0b00100000)
|
||||
tag_number = octet1 & 0b00011111
|
||||
|
||||
length_offset = 1
|
||||
if tag_number == 31:
|
||||
tag_number, octet_count = _unpack_asn1_octet_number(b_data[1:])
|
||||
length_offset += octet_count
|
||||
|
||||
if tag_class == TagClass.universal:
|
||||
tag_number = TypeTagNumber(tag_number)
|
||||
|
||||
b_data = b_data[length_offset:]
|
||||
|
||||
length = struct.unpack("B", b_data[:1])[0]
|
||||
length_octets = 1
|
||||
|
||||
if length & 0b10000000:
|
||||
# If the MSB is set then the length octet just contains the number of octets that encodes the actual length.
|
||||
length_octets += length & 0b01111111
|
||||
length = 0
|
||||
|
||||
for idx in range(1, length_octets):
|
||||
octet_val = struct.unpack("B", b_data[idx : idx + 1])[0]
|
||||
length += octet_val << (8 * (length_octets - 1 - idx))
|
||||
|
||||
value = ASN1Value(
|
||||
tag_class=tag_class,
|
||||
constructed=constructed,
|
||||
tag_number=tag_number,
|
||||
b_data=b_data[length_octets : length_octets + length],
|
||||
)
|
||||
|
||||
return value, b_data[length_octets + length :]
|
||||
|
||||
|
||||
def unpack_asn1_bit_string(value: typing.Union[ASN1Value, bytes]) -> bytes:
|
||||
"""Unpacks an ASN.1 BIT STRING value."""
|
||||
b_data = extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.bit_string)
|
||||
|
||||
# First octet is the number of unused bits in the last octet from the LSB.
|
||||
unused_bits = struct.unpack("B", b_data[:1])[0]
|
||||
last_octet = struct.unpack("B", b_data[-2:-1])[0]
|
||||
last_octet = (last_octet >> unused_bits) << unused_bits
|
||||
|
||||
return b_data[1:-1] + struct.pack("B", last_octet)
|
||||
|
||||
|
||||
def unpack_asn1_boolean(value: typing.Union[ASN1Value, bytes]) -> bool:
|
||||
"""Unpacks an ASN.1 BOOLEAN value."""
|
||||
b_data = extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.boolean)
|
||||
|
||||
return b_data != b"\x00"
|
||||
|
||||
|
||||
def unpack_asn1_enumerated(value: typing.Union[ASN1Value, bytes]) -> int:
|
||||
"""Unpacks an ASN.1 ENUMERATED value."""
|
||||
b_data = extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.enumerated)
|
||||
|
||||
return unpack_asn1_integer(b_data)
|
||||
|
||||
|
||||
def unpack_asn1_general_string(value: typing.Union[ASN1Value, bytes]) -> bytes:
|
||||
"""Unpacks an ASN.1 GeneralString value."""
|
||||
return extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.general_string)
|
||||
|
||||
|
||||
def unpack_asn1_generalized_time(value: typing.Union[ASN1Value, bytes]) -> datetime.datetime:
|
||||
"""Unpacks an ASN.1 GeneralizedTime value."""
|
||||
data = to_text(extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.generalized_time))
|
||||
|
||||
# While ASN.1 can have a timezone encoded, KerberosTime is the only thing we use and it is always in UTC with the
|
||||
# Z prefix. We strip out the Z because Python 2 doesn't support the %z identifier and add the UTC tz to the object.
|
||||
# https://www.rfc-editor.org/rfc/rfc4120#section-5.2.3
|
||||
if data.endswith("Z"):
|
||||
data = data[:-1]
|
||||
|
||||
err = None
|
||||
for datetime_format in ["%Y%m%d%H%M%S.%f", "%Y%m%d%H%M%S"]:
|
||||
try:
|
||||
dt = datetime.datetime.strptime(data, datetime_format)
|
||||
return dt.replace(tzinfo=datetime.timezone.utc)
|
||||
except ValueError as e:
|
||||
err = e
|
||||
|
||||
else:
|
||||
raise err # type: ignore
|
||||
|
||||
|
||||
def unpack_asn1_integer(value: typing.Union[ASN1Value, bytes]) -> int:
|
||||
"""Unpacks an ASN.1 INTEGER value."""
|
||||
b_int = bytearray(extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.integer))
|
||||
|
||||
is_negative = b_int[0] & 0b10000000
|
||||
if is_negative:
|
||||
# Get the two's compliment.
|
||||
for i in range(len(b_int)):
|
||||
b_int[i] = 0xFF - b_int[i]
|
||||
|
||||
for i in range(len(b_int) - 1, -1, -1):
|
||||
if b_int[i] == 0xFF:
|
||||
b_int[i - 1] += 1
|
||||
b_int[i] = 0
|
||||
break
|
||||
|
||||
else:
|
||||
b_int[i] += 1
|
||||
break
|
||||
|
||||
int_value = 0
|
||||
for val in b_int:
|
||||
int_value = (int_value << 8) | val
|
||||
|
||||
if is_negative:
|
||||
int_value *= -1
|
||||
|
||||
return int_value
|
||||
|
||||
|
||||
def unpack_asn1_object_identifier(value: typing.Union[ASN1Value, bytes]) -> str:
|
||||
"""Unpacks an ASN.1 OBJECT IDENTIFIER value."""
|
||||
b_data = extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.object_identifier)
|
||||
|
||||
first_element = struct.unpack("B", b_data[:1])[0]
|
||||
second_element = first_element % 40
|
||||
ids = [(first_element - second_element) // 40, second_element]
|
||||
|
||||
idx = 1
|
||||
while idx != len(b_data):
|
||||
oid, octet_len = _unpack_asn1_octet_number(b_data[idx:])
|
||||
ids.append(oid)
|
||||
idx += octet_len
|
||||
|
||||
return ".".join([str(i) for i in ids])
|
||||
|
||||
|
||||
def unpack_asn1_octet_string(value: typing.Union[ASN1Value, bytes]) -> bytes:
|
||||
"""Unpacks an ASN.1 OCTET STRING value."""
|
||||
return extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.octet_string)
|
||||
|
||||
|
||||
def unpack_asn1_sequence(value: typing.Union[ASN1Value, bytes]) -> typing.List[ASN1Value]:
|
||||
"""Unpacks an ASN.1 SEQUENCE value."""
|
||||
b_data = extract_asn1_tlv(value, TagClass.universal, TypeTagNumber.sequence)
|
||||
|
||||
values = []
|
||||
while b_data:
|
||||
v, b_data = unpack_asn1(b_data)
|
||||
values.append(v)
|
||||
|
||||
return values
|
||||
|
||||
|
||||
def unpack_asn1_tagged_sequence(value: typing.Union[ASN1Value, bytes]) -> typing.Dict[int, ASN1Value]:
|
||||
"""Unpacks an ASN.1 SEQUENCE value as a dictionary."""
|
||||
return dict([(e.tag_number, unpack_asn1(e.b_data)[0]) for e in unpack_asn1_sequence(value)])
|
||||
|
||||
|
||||
def _unpack_asn1_octet_number(b_data: bytes) -> typing.Tuple[int, int]:
|
||||
"""Unpacks an ASN.1 INTEGER value that can span across multiple octets."""
|
||||
i = 0
|
||||
idx = 0
|
||||
while True:
|
||||
element = struct.unpack("B", b_data[idx : idx + 1])[0]
|
||||
idx += 1
|
||||
|
||||
i = (i << 7) + (element & 0b01111111)
|
||||
if not element & 0b10000000:
|
||||
break
|
||||
|
||||
return i, idx # int value and the number of octets used.
|
||||
Reference in New Issue
Block a user