AlkantarClanX12
Your IP : 3.147.65.111
# -*- coding: ascii -*-
#
# Util/asn1.py : Minimal support for ASN.1 DER binary encoding.
#
# ===================================================================
# The contents of this file are dedicated to the public domain. To
# the extent that dedication to the public domain is not available,
# everyone is granted a worldwide, perpetual, royalty-free,
# non-exclusive license to exercise all rights associated with the
# contents of this file for any purpose whatsoever.
# No rights are reserved.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# ===================================================================
import struct
from Crypto.Util.py3compat import byte_string, bchr, bord
from Crypto.Util.number import long_to_bytes, bytes_to_long
__all__ = ['DerObject', 'DerInteger', 'DerBoolean', 'DerOctetString',
'DerNull', 'DerSequence', 'DerObjectId', 'DerBitString', 'DerSetOf']
# Useful references:
# - https://luca.ntop.org/Teaching/Appunti/asn1.html
# - https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/
# - https://www.zytrax.com/tech/survival/asn1.html
# - https://www.oss.com/asn1/resources/books-whitepapers-pubs/larmouth-asn1-book.pdf
# - https://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
# - https://misc.daniel-marschall.de/asn.1/oid-converter/online.php
def _is_number(x, only_non_negative=False):
test = 0
try:
test = x + test
except TypeError:
return False
return not only_non_negative or x >= 0
class BytesIO_EOF(object):
"""This class differs from BytesIO in that a ValueError exception is
raised whenever EOF is reached."""
def __init__(self, initial_bytes):
self._buffer = initial_bytes
self._index = 0
self._bookmark = None
def set_bookmark(self):
self._bookmark = self._index
def data_since_bookmark(self):
assert self._bookmark is not None
return self._buffer[self._bookmark:self._index]
def remaining_data(self):
return len(self._buffer) - self._index
def read(self, length):
new_index = self._index + length
if new_index > len(self._buffer):
raise ValueError("Not enough data for DER decoding: expected %d bytes and found %d" % (new_index, len(self._buffer)))
result = self._buffer[self._index:new_index]
self._index = new_index
return result
def read_byte(self):
return bord(self.read(1)[0])
class DerObject(object):
"""Base class for defining a single DER object.
This class should never be directly instantiated.
"""
def __init__(self, asn1Id=None, payload=b'', implicit=None,
constructed=False, explicit=None):
"""Initialize the DER object according to a specific ASN.1 type.
:Parameters:
asn1Id : integer or byte
The universal DER tag number for this object
(e.g. 0x10 for a SEQUENCE).
If None, the tag is not known yet.
payload : byte string
The initial payload of the object (that it,
the content octets).
If not specified, the payload is empty.
implicit : integer or byte
The IMPLICIT tag number (< 0x1F) to use for the encoded object.
It overrides the universal tag *asn1Id*.
It cannot be combined with the ``explicit`` parameter.
By default, there is no IMPLICIT tag.
constructed : bool
True when the ASN.1 type is *constructed*.
False when it is *primitive* (default).
explicit : integer or byte
The EXPLICIT tag number (< 0x1F) to use for the encoded object.
It cannot be combined with the ``implicit`` parameter.
By default, there is no EXPLICIT tag.
"""
if asn1Id is None:
# The tag octet will be read in with ``decode``
self._tag_octet = None
return
asn1Id = self._convertTag(asn1Id)
self.payload = payload
# In a BER/DER identifier octet:
# * bits 4-0 contain the tag value
# * bit 5 is set if the type is 'constructed'
# and unset if 'primitive'
# * bits 7-6 depend on the encoding class
#
# Class | Bit 7, Bit 6
# ----------------------------------
# universal | 0 0
# application | 0 1
# context-spec | 1 0 (default for IMPLICIT/EXPLICIT)
# private | 1 1
#
constructed_bit = 0x20 if constructed else 0x00
if None not in (explicit, implicit):
raise ValueError("Explicit and implicit tags are"
" mutually exclusive")
if implicit is not None:
# IMPLICIT tag overrides asn1Id
self._tag_octet = 0x80 | constructed_bit | self._convertTag(implicit)
elif explicit is not None:
# 'constructed bit' is always asserted for an EXPLICIT tag
self._tag_octet = 0x80 | 0x20 | self._convertTag(explicit)
self._inner_tag_octet = constructed_bit | asn1Id
else:
# Neither IMPLICIT nor EXPLICIT
self._tag_octet = constructed_bit | asn1Id
def _convertTag(self, tag):
"""Check if *tag* is a real DER tag (5 bits).
Convert it from a character to number if necessary.
"""
if not _is_number(tag):
if len(tag) == 1:
tag = bord(tag[0])
# Ensure that tag is a low tag
if not (_is_number(tag) and 0 <= tag < 0x1F):
raise ValueError("Wrong DER tag")
return tag
@staticmethod
def _definite_form(length):
"""Build length octets according to BER/DER
definite form.
"""
if length > 127:
encoding = long_to_bytes(length)
return bchr(len(encoding) + 128) + encoding
return bchr(length)
def encode(self):
"""Return this DER element, fully encoded as a binary byte string."""
# Concatenate identifier octets, length octets,
# and contents octets
output_payload = self.payload
# In case of an EXTERNAL tag, first encode the inner
# element.
if hasattr(self, "_inner_tag_octet"):
output_payload = (bchr(self._inner_tag_octet) +
self._definite_form(len(self.payload)) +
self.payload)
return (bchr(self._tag_octet) +
self._definite_form(len(output_payload)) +
output_payload)
def _decodeLen(self, s):
"""Decode DER length octets from a file."""
length = s.read_byte()
if length > 127:
encoded_length = s.read(length & 0x7F)
if bord(encoded_length[0]) == 0:
raise ValueError("Invalid DER: length has leading zero")
length = bytes_to_long(encoded_length)
if length <= 127:
raise ValueError("Invalid DER: length in long form but smaller than 128")
return length
def decode(self, der_encoded, strict=False):
"""Decode a complete DER element, and re-initializes this
object with it.
Args:
der_encoded (byte string): A complete DER element.
Raises:
ValueError: in case of parsing errors.
"""
if not byte_string(der_encoded):
raise ValueError("Input is not a byte string")
s = BytesIO_EOF(der_encoded)
self._decodeFromStream(s, strict)
# There shouldn't be other bytes left
if s.remaining_data() > 0:
raise ValueError("Unexpected extra data after the DER structure")
return self
def _decodeFromStream(self, s, strict):
"""Decode a complete DER element from a file."""
idOctet = s.read_byte()
if self._tag_octet is not None:
if idOctet != self._tag_octet:
raise ValueError("Unexpected DER tag")
else:
self._tag_octet = idOctet
length = self._decodeLen(s)
self.payload = s.read(length)
# In case of an EXTERNAL tag, further decode the inner
# element.
if hasattr(self, "_inner_tag_octet"):
p = BytesIO_EOF(self.payload)
inner_octet = p.read_byte()
if inner_octet != self._inner_tag_octet:
raise ValueError("Unexpected internal DER tag")
length = self._decodeLen(p)
self.payload = p.read(length)
# There shouldn't be other bytes left
if p.remaining_data() > 0:
raise ValueError("Unexpected extra data after the DER structure")
class DerInteger(DerObject):
"""Class to model a DER INTEGER.
An example of encoding is::
>>> from Crypto.Util.asn1 import DerInteger
>>> from binascii import hexlify, unhexlify
>>> int_der = DerInteger(9)
>>> print hexlify(int_der.encode())
which will show ``020109``, the DER encoding of 9.
And for decoding::
>>> s = unhexlify(b'020109')
>>> try:
>>> int_der = DerInteger()
>>> int_der.decode(s)
>>> print int_der.value
>>> except ValueError:
>>> print "Not a valid DER INTEGER"
the output will be ``9``.
:ivar value: The integer value
:vartype value: integer
"""
def __init__(self, value=0, implicit=None, explicit=None):
"""Initialize the DER object as an INTEGER.
:Parameters:
value : integer
The value of the integer.
implicit : integer
The IMPLICIT tag to use for the encoded object.
It overrides the universal tag for INTEGER (2).
"""
DerObject.__init__(self, 0x02, b'', implicit,
False, explicit)
self.value = value # The integer value
def encode(self):
"""Return the DER INTEGER, fully encoded as a
binary string."""
number = self.value
self.payload = b''
while True:
self.payload = bchr(int(number & 255)) + self.payload
if 128 <= number <= 255:
self.payload = bchr(0x00) + self.payload
if -128 <= number <= 255:
break
number >>= 8
return DerObject.encode(self)
def decode(self, der_encoded, strict=False):
"""Decode a DER-encoded INTEGER, and re-initializes this
object with it.
Args:
der_encoded (byte string): A complete INTEGER DER element.
Raises:
ValueError: in case of parsing errors.
"""
return DerObject.decode(self, der_encoded, strict=strict)
def _decodeFromStream(self, s, strict):
"""Decode a complete DER INTEGER from a file."""
# Fill up self.payload
DerObject._decodeFromStream(self, s, strict)
if strict:
if len(self.payload) == 0:
raise ValueError("Invalid encoding for DER INTEGER: empty payload")
if len(self.payload) >= 2 and struct.unpack('>H', self.payload[:2])[0] < 0x80:
raise ValueError("Invalid encoding for DER INTEGER: leading zero")
# Derive self.value from self.payload
self.value = 0
bits = 1
for i in self.payload:
self.value *= 256
self.value += bord(i)
bits <<= 8
if self.payload and bord(self.payload[0]) & 0x80:
self.value -= bits
class DerBoolean(DerObject):
"""Class to model a DER-encoded BOOLEAN.
An example of encoding is::
>>> from Crypto.Util.asn1 import DerBoolean
>>> bool_der = DerBoolean(True)
>>> print(bool_der.encode().hex())
which will show ``0101ff``, the DER encoding of True.
And for decoding::
>>> s = bytes.fromhex('0101ff')
>>> try:
>>> bool_der = DerBoolean()
>>> bool_der.decode(s)
>>> print(bool_der.value)
>>> except ValueError:
>>> print "Not a valid DER BOOLEAN"
the output will be ``True``.
:ivar value: The boolean value
:vartype value: boolean
"""
def __init__(self, value=False, implicit=None, explicit=None):
"""Initialize the DER object as a BOOLEAN.
Args:
value (boolean):
The value of the boolean. Default is False.
implicit (integer or byte):
The IMPLICIT tag number (< 0x1F) to use for the encoded object.
It overrides the universal tag for BOOLEAN (1).
It cannot be combined with the ``explicit`` parameter.
By default, there is no IMPLICIT tag.
explicit (integer or byte):
The EXPLICIT tag number (< 0x1F) to use for the encoded object.
It cannot be combined with the ``implicit`` parameter.
By default, there is no EXPLICIT tag.
"""
DerObject.__init__(self, 0x01, b'', implicit, False, explicit)
self.value = value # The boolean value
def encode(self):
"""Return the DER BOOLEAN, fully encoded as a binary string."""
self.payload = b'\xFF' if self.value else b'\x00'
return DerObject.encode(self)
def decode(self, der_encoded, strict=False):
"""Decode a DER-encoded BOOLEAN, and re-initializes this object with it.
Args:
der_encoded (byte string): A DER-encoded BOOLEAN.
Raises:
ValueError: in case of parsing errors.
"""
return DerObject.decode(self, der_encoded, strict)
def _decodeFromStream(self, s, strict):
"""Decode a DER-encoded BOOLEAN from a file."""
# Fill up self.payload
DerObject._decodeFromStream(self, s, strict)
if len(self.payload) != 1:
raise ValueError("Invalid encoding for DER BOOLEAN: payload is not 1 byte")
if bord(self.payload[0]) == 0:
self.value = False
elif bord(self.payload[0]) == 0xFF:
self.value = True
else:
raise ValueError("Invalid payload for DER BOOLEAN")
class DerSequence(DerObject):
"""Class to model a DER SEQUENCE.
This object behaves like a dynamic Python sequence.
Sub-elements that are INTEGERs behave like Python integers.
Any other sub-element is a binary string encoded as a complete DER
sub-element (TLV).
An example of encoding is:
>>> from Crypto.Util.asn1 import DerSequence, DerInteger
>>> from binascii import hexlify, unhexlify
>>> obj_der = unhexlify('070102')
>>> seq_der = DerSequence([4])
>>> seq_der.append(9)
>>> seq_der.append(obj_der.encode())
>>> print hexlify(seq_der.encode())
which will show ``3009020104020109070102``, the DER encoding of the
sequence containing ``4``, ``9``, and the object with payload ``02``.
For decoding:
>>> s = unhexlify(b'3009020104020109070102')
>>> try:
>>> seq_der = DerSequence()
>>> seq_der.decode(s)
>>> print len(seq_der)
>>> print seq_der[0]
>>> print seq_der[:]
>>> except ValueError:
>>> print "Not a valid DER SEQUENCE"
the output will be::
3
4
[4, 9, b'\x07\x01\x02']
"""
def __init__(self, startSeq=None, implicit=None, explicit=None):
"""Initialize the DER object as a SEQUENCE.
:Parameters:
startSeq : Python sequence
A sequence whose element are either integers or
other DER objects.
implicit : integer or byte
The IMPLICIT tag number (< 0x1F) to use for the encoded object.
It overrides the universal tag for SEQUENCE (16).
It cannot be combined with the ``explicit`` parameter.
By default, there is no IMPLICIT tag.
explicit : integer or byte
The EXPLICIT tag number (< 0x1F) to use for the encoded object.
It cannot be combined with the ``implicit`` parameter.
By default, there is no EXPLICIT tag.
"""
DerObject.__init__(self, 0x10, b'', implicit, True, explicit)
if startSeq is None:
self._seq = []
else:
self._seq = startSeq
# A few methods to make it behave like a python sequence
def __delitem__(self, n):
del self._seq[n]
def __getitem__(self, n):
return self._seq[n]
def __setitem__(self, key, value):
self._seq[key] = value
def __setslice__(self, i, j, sequence):
self._seq[i:j] = sequence
def __delslice__(self, i, j):
del self._seq[i:j]
def __getslice__(self, i, j):
return self._seq[max(0, i):max(0, j)]
def __len__(self):
return len(self._seq)
def __iadd__(self, item):
self._seq.append(item)
return self
def append(self, item):
self._seq.append(item)
return self
def insert(self, index, item):
self._seq.insert(index, item)
return self
def hasInts(self, only_non_negative=True):
"""Return the number of items in this sequence that are
integers.
Args:
only_non_negative (boolean):
If ``True``, negative integers are not counted in.
"""
items = [x for x in self._seq if _is_number(x, only_non_negative)]
return len(items)
def hasOnlyInts(self, only_non_negative=True):
"""Return ``True`` if all items in this sequence are integers
or non-negative integers.
This function returns False is the sequence is empty,
or at least one member is not an integer.
Args:
only_non_negative (boolean):
If ``True``, the presence of negative integers
causes the method to return ``False``."""
return self._seq and self.hasInts(only_non_negative) == len(self._seq)
def encode(self):
"""Return this DER SEQUENCE, fully encoded as a
binary string.
Raises:
ValueError: if some elements in the sequence are neither integers
nor byte strings.
"""
self.payload = b''
for item in self._seq:
if byte_string(item):
self.payload += item
elif _is_number(item):
self.payload += DerInteger(item).encode()
else:
self.payload += item.encode()
return DerObject.encode(self)
def decode(self, der_encoded, strict=False, nr_elements=None, only_ints_expected=False):
"""Decode a complete DER SEQUENCE, and re-initializes this
object with it.
Args:
der_encoded (byte string):
A complete SEQUENCE DER element.
nr_elements (None or integer or list of integers):
The number of members the SEQUENCE can have
only_ints_expected (boolean):
Whether the SEQUENCE is expected to contain only integers.
strict (boolean):
Whether decoding must check for strict DER compliancy.
Raises:
ValueError: in case of parsing errors.
DER INTEGERs are decoded into Python integers. Any other DER
element is not decoded. Its validity is not checked.
"""
self._nr_elements = nr_elements
result = DerObject.decode(self, der_encoded, strict=strict)
if only_ints_expected and not self.hasOnlyInts():
raise ValueError("Some members are not INTEGERs")
return result
def _decodeFromStream(self, s, strict):
"""Decode a complete DER SEQUENCE from a file."""
self._seq = []
# Fill up self.payload
DerObject._decodeFromStream(self, s, strict)
# Add one item at a time to self.seq, by scanning self.payload
p = BytesIO_EOF(self.payload)
while p.remaining_data() > 0:
p.set_bookmark()
der = DerObject()
der._decodeFromStream(p, strict)
# Parse INTEGERs differently
if der._tag_octet != 0x02:
self._seq.append(p.data_since_bookmark())
else:
derInt = DerInteger()
data = p.data_since_bookmark()
derInt.decode(data, strict=strict)
self._seq.append(derInt.value)
ok = True
if self._nr_elements is not None:
try:
ok = len(self._seq) in self._nr_elements
except TypeError:
ok = len(self._seq) == self._nr_elements
if not ok:
raise ValueError("Unexpected number of members (%d)"
" in the sequence" % len(self._seq))
class DerOctetString(DerObject):
"""Class to model a DER OCTET STRING.
An example of encoding is:
>>> from Crypto.Util.asn1 import DerOctetString
>>> from binascii import hexlify, unhexlify
>>> os_der = DerOctetString(b'\\xaa')
>>> os_der.payload += b'\\xbb'
>>> print hexlify(os_der.encode())
which will show ``0402aabb``, the DER encoding for the byte string
``b'\\xAA\\xBB'``.
For decoding:
>>> s = unhexlify(b'0402aabb')
>>> try:
>>> os_der = DerOctetString()
>>> os_der.decode(s)
>>> print hexlify(os_der.payload)
>>> except ValueError:
>>> print "Not a valid DER OCTET STRING"
the output will be ``aabb``.
:ivar payload: The content of the string
:vartype payload: byte string
"""
def __init__(self, value=b'', implicit=None):
"""Initialize the DER object as an OCTET STRING.
:Parameters:
value : byte string
The initial payload of the object.
If not specified, the payload is empty.
implicit : integer
The IMPLICIT tag to use for the encoded object.
It overrides the universal tag for OCTET STRING (4).
"""
DerObject.__init__(self, 0x04, value, implicit, False)
class DerNull(DerObject):
"""Class to model a DER NULL element."""
def __init__(self):
"""Initialize the DER object as a NULL."""
DerObject.__init__(self, 0x05, b'', None, False)
class DerObjectId(DerObject):
"""Class to model a DER OBJECT ID.
An example of encoding is:
>>> from Crypto.Util.asn1 import DerObjectId
>>> from binascii import hexlify, unhexlify
>>> oid_der = DerObjectId("1.2")
>>> oid_der.value += ".840.113549.1.1.1"
>>> print hexlify(oid_der.encode())
which will show ``06092a864886f70d010101``, the DER encoding for the
RSA Object Identifier ``1.2.840.113549.1.1.1``.
For decoding:
>>> s = unhexlify(b'06092a864886f70d010101')
>>> try:
>>> oid_der = DerObjectId()
>>> oid_der.decode(s)
>>> print oid_der.value
>>> except ValueError:
>>> print "Not a valid DER OBJECT ID"
the output will be ``1.2.840.113549.1.1.1``.
:ivar value: The Object ID (OID), a dot separated list of integers
:vartype value: string
"""
def __init__(self, value='', implicit=None, explicit=None):
"""Initialize the DER object as an OBJECT ID.
:Parameters:
value : string
The initial Object Identifier (e.g. "1.2.0.0.6.2").
implicit : integer
The IMPLICIT tag to use for the encoded object.
It overrides the universal tag for OBJECT ID (6).
explicit : integer
The EXPLICIT tag to use for the encoded object.
"""
DerObject.__init__(self, 0x06, b'', implicit, False, explicit)
self.value = value
def encode(self):
"""Return the DER OBJECT ID, fully encoded as a
binary string."""
comps = [int(x) for x in self.value.split(".")]
if len(comps) < 2:
raise ValueError("Not a valid Object Identifier string")
if comps[0] > 2:
raise ValueError("First component must be 0, 1 or 2")
if comps[0] < 2 and comps[1] > 39:
raise ValueError("Second component must be 39 at most")
subcomps = [40 * comps[0] + comps[1]] + comps[2:]
encoding = []
for v in reversed(subcomps):
encoding.append(v & 0x7F)
v >>= 7
while v:
encoding.append((v & 0x7F) | 0x80)
v >>= 7
self.payload = b''.join([bchr(x) for x in reversed(encoding)])
return DerObject.encode(self)
def decode(self, der_encoded, strict=False):
"""Decode a complete DER OBJECT ID, and re-initializes this
object with it.
Args:
der_encoded (byte string):
A complete DER OBJECT ID.
strict (boolean):
Whether decoding must check for strict DER compliancy.
Raises:
ValueError: in case of parsing errors.
"""
return DerObject.decode(self, der_encoded, strict)
def _decodeFromStream(self, s, strict):
"""Decode a complete DER OBJECT ID from a file."""
# Fill up self.payload
DerObject._decodeFromStream(self, s, strict)
# Derive self.value from self.payload
p = BytesIO_EOF(self.payload)
subcomps = []
v = 0
while p.remaining_data():
c = p.read_byte()
v = (v << 7) + (c & 0x7F)
if not (c & 0x80):
subcomps.append(v)
v = 0
if len(subcomps) == 0:
raise ValueError("Empty payload")
if subcomps[0] < 40:
subcomps[:1] = [0, subcomps[0]]
elif subcomps[0] < 80:
subcomps[:1] = [1, subcomps[0] - 40]
else:
subcomps[:1] = [2, subcomps[0] - 80]
self.value = ".".join([str(x) for x in subcomps])
class DerBitString(DerObject):
"""Class to model a DER BIT STRING.
An example of encoding is:
>>> from Crypto.Util.asn1 import DerBitString
>>> bs_der = DerBitString(b'\\xAA')
>>> bs_der.value += b'\\xBB'
>>> print(bs_der.encode().hex())
which will show ``030300aabb``, the DER encoding for the bit string
``b'\\xAA\\xBB'``.
For decoding:
>>> s = bytes.fromhex('030300aabb')
>>> try:
>>> bs_der = DerBitString()
>>> bs_der.decode(s)
>>> print(bs_der.value.hex())
>>> except ValueError:
>>> print "Not a valid DER BIT STRING"
the output will be ``aabb``.
:ivar value: The content of the string
:vartype value: byte string
"""
def __init__(self, value=b'', implicit=None, explicit=None):
"""Initialize the DER object as a BIT STRING.
:Parameters:
value : byte string or DER object
The initial, packed bit string.
If not specified, the bit string is empty.
implicit : integer
The IMPLICIT tag to use for the encoded object.
It overrides the universal tag for BIT STRING (3).
explicit : integer
The EXPLICIT tag to use for the encoded object.
"""
DerObject.__init__(self, 0x03, b'', implicit, False, explicit)
# The bitstring value (packed)
if isinstance(value, DerObject):
self.value = value.encode()
else:
self.value = value
def encode(self):
"""Return the DER BIT STRING, fully encoded as a
byte string."""
# Add padding count byte
self.payload = b'\x00' + self.value
return DerObject.encode(self)
def decode(self, der_encoded, strict=False):
"""Decode a complete DER BIT STRING, and re-initializes this
object with it.
Args:
der_encoded (byte string): a complete DER BIT STRING.
strict (boolean):
Whether decoding must check for strict DER compliancy.
Raises:
ValueError: in case of parsing errors.
"""
return DerObject.decode(self, der_encoded, strict)
def _decodeFromStream(self, s, strict):
"""Decode a complete DER BIT STRING DER from a file."""
# Fill-up self.payload
DerObject._decodeFromStream(self, s, strict)
if self.payload and bord(self.payload[0]) != 0:
raise ValueError("Not a valid BIT STRING")
# Fill-up self.value
self.value = b''
# Remove padding count byte
if self.payload:
self.value = self.payload[1:]
class DerSetOf(DerObject):
"""Class to model a DER SET OF.
An example of encoding is:
>>> from Crypto.Util.asn1 import DerBitString
>>> from binascii import hexlify, unhexlify
>>> so_der = DerSetOf([4,5])
>>> so_der.add(6)
>>> print hexlify(so_der.encode())
which will show ``3109020104020105020106``, the DER encoding
of a SET OF with items 4,5, and 6.
For decoding:
>>> s = unhexlify(b'3109020104020105020106')
>>> try:
>>> so_der = DerSetOf()
>>> so_der.decode(s)
>>> print [x for x in so_der]
>>> except ValueError:
>>> print "Not a valid DER SET OF"
the output will be ``[4, 5, 6]``.
"""
def __init__(self, startSet=None, implicit=None):
"""Initialize the DER object as a SET OF.
:Parameters:
startSet : container
The initial set of integers or DER encoded objects.
implicit : integer
The IMPLICIT tag to use for the encoded object.
It overrides the universal tag for SET OF (17).
"""
DerObject.__init__(self, 0x11, b'', implicit, True)
self._seq = []
# All elements must be of the same type (and therefore have the
# same leading octet)
self._elemOctet = None
if startSet:
for e in startSet:
self.add(e)
def __getitem__(self, n):
return self._seq[n]
def __iter__(self):
return iter(self._seq)
def __len__(self):
return len(self._seq)
def add(self, elem):
"""Add an element to the set.
Args:
elem (byte string or integer):
An element of the same type of objects already in the set.
It can be an integer or a DER encoded object.
"""
if _is_number(elem):
eo = 0x02
elif isinstance(elem, DerObject):
eo = self._tag_octet
else:
eo = bord(elem[0])
if self._elemOctet != eo:
if self._elemOctet is not None:
raise ValueError("New element does not belong to the set")
self._elemOctet = eo
if elem not in self._seq:
self._seq.append(elem)
def decode(self, der_encoded, strict=False):
"""Decode a complete SET OF DER element, and re-initializes this
object with it.
DER INTEGERs are decoded into Python integers. Any other DER
element is left undecoded; its validity is not checked.
Args:
der_encoded (byte string): a complete DER BIT SET OF.
strict (boolean):
Whether decoding must check for strict DER compliancy.
Raises:
ValueError: in case of parsing errors.
"""
return DerObject.decode(self, der_encoded, strict)
def _decodeFromStream(self, s, strict):
"""Decode a complete DER SET OF from a file."""
self._seq = []
# Fill up self.payload
DerObject._decodeFromStream(self, s, strict)
# Add one item at a time to self.seq, by scanning self.payload
p = BytesIO_EOF(self.payload)
setIdOctet = -1
while p.remaining_data() > 0:
p.set_bookmark()
der = DerObject()
der._decodeFromStream(p, strict)
# Verify that all members are of the same type
if setIdOctet < 0:
setIdOctet = der._tag_octet
else:
if setIdOctet != der._tag_octet:
raise ValueError("Not all elements are of the same DER type")
# Parse INTEGERs differently
if setIdOctet != 0x02:
self._seq.append(p.data_since_bookmark())
else:
derInt = DerInteger()
derInt.decode(p.data_since_bookmark(), strict)
self._seq.append(derInt.value)
# end
def encode(self):
"""Return this SET OF DER element, fully encoded as a
binary string.
"""
# Elements in the set must be ordered in lexicographic order
ordered = []
for item in self._seq:
if _is_number(item):
bys = DerInteger(item).encode()
elif isinstance(item, DerObject):
bys = item.encode()
else:
bys = item
ordered.append(bys)
ordered.sort()
self.payload = b''.join(ordered)
return DerObject.encode(self)