Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
encoded.extend(data)
def decode(self, data, offset):
offset = self.decode_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
decoded = data[offset:end_offset].decode('ascii')
decoded = datetime.date(*time.strptime(decoded, '%Y%m%d')[:3])
return decoded, end_offset
def __repr__(self):
return 'Date({})'.format(self.name)
class TimeOfDay(Type):
def __init__(self, name):
super(TimeOfDay, self).__init__(name,
'TIME-OF-DAY',
Tag.TIME_OF_DAY)
def encode(self, data, encoded):
data = str(data).replace(':', '').encode('ascii')
encoded.extend(self.tag)
encoded.append(len(data))
encoded.extend(data)
def decode(self, data, offset):
offset = self.decode_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
def encode(self, data, encoded):
encoded.extend(data)
def decode(self, data, offset):
start = offset
offset = skip_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
return data[start:end_offset], end_offset
def __repr__(self):
return 'Any({})'.format(self.name)
class AnyDefinedBy(Type):
def __init__(self, name, type_member, choices):
super(AnyDefinedBy, self).__init__(name,
'ANY DEFINED BY',
None,
None)
self.type_member = type_member
self.choices = choices
def encode(self, data, encoded, values):
if self.choices:
try:
self.choices[values[self.type_member]].encode(data, encoded)
except KeyError:
raise EncodeError('Bad AnyDefinedBy choice {}.'.format(
values[self.type_member]))
encoded.append(len(encoded_subidentifiers))
encoded.extend(encoded_subidentifiers)
def decode(self, data, offset):
offset = self.decode_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
decoded = decode_object_identifier(data, offset, end_offset)
return decoded, end_offset
def __repr__(self):
return 'ObjectIdentifier({})'.format(self.name)
class Enumerated(Type):
def __init__(self, name, values, numeric):
super(Enumerated, self).__init__(name,
'ENUMERATED',
Tag.ENUMERATED)
if numeric:
self.value_to_data = {k: k for k in enum_values_as_dict(values)}
self.data_to_value = self.value_to_data
else:
self.value_to_data = enum_values_as_dict(values)
self.data_to_value = {v: k for k, v in self.value_to_data.items()}
self.has_extension_marker = (EXTENSION_MARKER in values)
def format_names(self):
return format_or(sorted(list(self.value_to_data.values())))
def encode(self, data, encoded):
encoded.extend(self.tag)
encoded.extend(encode_length_definite(len(data)))
encoded.extend(data)
def decode_primitive_contents(self, data, offset, length):
return bytes(data[offset:offset + length])
def decode_constructed_segments(self, segments):
return bytes().join(segments)
def __repr__(self):
return 'OctetString({})'.format(self.name)
class ObjectIdentifier(Type):
def __init__(self, name):
super(ObjectIdentifier, self).__init__(name,
'OBJECT IDENTIFIER',
Tag.OBJECT_IDENTIFIER)
def encode(self, data, encoded):
encoded_subidentifiers = encode_object_identifier(data)
encoded.extend(self.tag)
encoded.append(len(encoded_subidentifiers))
encoded.extend(encoded_subidentifiers)
def decode(self, data, offset):
offset = self.decode_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
'SET',
Tag.SET,
root_members,
additions)
class SetOf(ArrayType):
def __init__(self, name, element_type):
super(SetOf, self).__init__(name,
'SET OF',
Tag.SET,
element_type)
class Choice(Type):
def __init__(self, name, root_members, additions):
super(Choice, self).__init__(name, 'CHOICE', None)
members = root_members
if additions is not None:
for addition in additions:
if isinstance(addition, list):
members += addition
else:
members.append(addition)
self.has_extension_marker = True
else:
self.has_extension_marker = False
except KeyError:
raise DecodeError('Bad AnyDefinedBy choice {}.'.format(
values[self.type_member]))
else:
start = offset
offset = skip_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
return data[start:end_offset], end_offset
def __repr__(self):
return 'AnyDefinedBy({})'.format(self.name)
class ExplicitTag(Type):
def __init__(self, name, inner):
super(ExplicitTag, self).__init__(name, 'ExplicitTag', None)
self.inner = inner
def set_default(self, value):
self.inner.set_default(value)
def get_default(self):
return self.inner.get_default()
def is_default(self, value):
return self.inner.is_default(value)
def has_default(self):
return self.inner.has_default()
return end_offset
def set_default(self, value):
self.default = value
def get_default(self):
return self.default
def is_default(self, value):
return value == self.default
def has_default(self):
return self.default is not None
class PrimitiveOrConstructedType(Type):
def __init__(self, name, type_name, number, segment, flags=0):
super(PrimitiveOrConstructedType, self).__init__(name,
type_name,
number,
flags)
self.segment = segment
self.constructed_tag = copy(self.tag)
self.constructed_tag[0] |= Encoding.CONSTRUCTED
def set_tag(self, number, flags):
self.tag = encode_tag(number, flags)
self.constructed_tag = copy(self.tag)
self.constructed_tag[0] |= Encoding.CONSTRUCTED
def decode_tag(self, data, offset):
break
elif (offset - start_offset) >= length:
# End of definite length sequence.
break
decoded_element, offset = self.element_type.decode(data, offset)
decoded.append(decoded_element)
return decoded, offset
def __repr__(self):
return '{}({}, {})'.format(self.__class__.__name__,
self.name,
self.element_type)
class Boolean(Type):
def __init__(self, name):
super(Boolean, self).__init__(name,
'BOOLEAN',
Tag.BOOLEAN)
def encode(self, data, encoded):
encoded.extend(self.tag)
encoded.append(1)
encoded.append(0xff * data)
def decode(self, data, offset):
offset = self.decode_tag(data, offset)
length, contents_offset = decode_length_definite(data, offset)
if length != 1:
TAG = Tag.UNIVERSAL_STRING
ENCODING = 'utf-32-be'
class TeletexString(StringType):
TAG = Tag.T61_STRING
ENCODING = 'iso-8859-1'
class ObjectDescriptor(GraphicString):
TAG = Tag.OBJECT_DESCRIPTOR
class UTCTime(Type):
def __init__(self, name):
super(UTCTime, self).__init__(name,
'UTCTime',
Tag.UTC_TIME)
def encode(self, data, encoded):
data = utc_time_from_datetime(data).encode('ascii')
encoded.extend(self.tag)
encoded.append(len(data))
encoded.extend(data)
def decode(self, data, offset):
offset = self.decode_tag(data, offset)
length, offset = decode_length_definite(data, offset)
end_offset = offset + length
raise e
value = member.get_default()
values[member.name] = value
return offset
def __repr__(self):
return '{}({}, [{}])'.format(
self.__class__.__name__,
self.name,
', '.join([repr(member) for member in self.root_members]))
class ArrayType(Type):
def __init__(self, name, tag_name, tag, element_type):
super(ArrayType, self).__init__(name,
tag_name,
tag,
Encoding.CONSTRUCTED)
self.element_type = element_type
def set_tag(self, number, flags):
super(ArrayType, self).set_tag(number,
flags | Encoding.CONSTRUCTED)
def encode(self, data, encoded):
encoded_elements = bytearray()
for entry in data: