Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
class Boolean(Type):
def __init__(self, name):
super(Boolean, self).__init__(name, 'BOOLEAN')
def encode(self, data, encoder):
encoder.append_bit(bool(data))
def decode(self, decoder):
return bool(decoder.read_bit())
def __repr__(self):
return 'Boolean({})'.format(self.name)
class Integer(Type):
def __init__(self, name):
super(Integer, self).__init__(name, 'INTEGER')
self.minimum = None
self.maximum = None
self.has_extension_marker = False
self.number_of_bits = None
self.number_of_indefinite_bits = None
def set_restricted_to_range(self, minimum, maximum, has_extension_marker):
self.has_extension_marker = has_extension_marker
if minimum == 'MIN' or maximum == 'MAX':
return
self.minimum = minimum
decoded = []
for length in decoder.read_length_determinant_chunks():
for _ in range(length):
decoded_element = self.element_type.decode(decoder)
decoded.append(decoded_element)
return decoded
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')
def encode(self, data, encoder):
encoder.append_bit(bool(data))
def decode(self, decoder):
return bool(decoder.read_bit())
def __repr__(self):
return 'Boolean({})'.format(self.name)
class Integer(Type):
encoder.align()
encoder.append_length_determinant(len(encoded_subidentifiers))
encoder.append_bytes(bytearray(encoded_subidentifiers))
def decode(self, decoder):
decoder.align()
length = decoder.read_length_determinant()
data = decoder.read_bytes(length)
return decode_object_identifier(bytearray(data), 0, len(data))
def __repr__(self):
return 'ObjectIdentifier({})'.format(self.name)
class Enumerated(Type):
def __init__(self, name, values, numeric):
super(Enumerated, self).__init__(name, 'ENUMERATED')
root, additions = enum_values_split(values)
root = sorted(root, key=itemgetter(1))
# Root.
index_to_data, data_to_index = self.create_maps(root,
numeric)
self.root_index_to_data = index_to_data
self.root_data_to_index = data_to_index
self.root_number_of_bits = integer_as_number_of_bits(len(index_to_data) - 1)
if numeric:
self.root_data_to_value = {k: k for k in enum_values_as_dict(root)}
else:
for length in decoder.read_length_determinant_chunks():
for _ in range(length):
value = decoder.read_non_negative_binary_integer(
self.bits_per_character)
value = self.permitted_alphabet.decode(value)
decoded += to_byte_array(value, orig_bits_per_character)
return decoded.decode(self.ENCODING)
def __repr__(self):
return '{}({})'.format(self.__class__.__name__,
self.name)
class StringType(Type):
ENCODING = None
LENGTH_MULTIPLIER = 1
def __init__(self, name):
super(StringType, self).__init__(name, self.__class__.__name__)
def encode(self, data, encoder):
encoded = data.encode(self.ENCODING)
encoder.align()
for offset, length in encoder.append_length_determinant_chunks(len(data)):
offset *= self.LENGTH_MULTIPLIER
data = encoded[offset:offset + self.LENGTH_MULTIPLIER * length]
encoder.append_bytes(data)
encoded = encode_real(data)
encoder.align()
encoder.append_length_determinant(len(encoded))
encoder.append_bytes(encoded)
def decode(self, decoder):
decoder.align()
length = decoder.read_length_determinant()
return decode_real(bytearray(decoder.read_bytes(length)))
def __repr__(self):
return 'Real({})'.format(self.name)
class Null(Type):
def __init__(self, name):
super(Null, self).__init__(name, 'NULL')
def encode(self, _, _encoder):
pass
def decode(self, _):
return None
def __repr__(self):
return 'Null({})'.format(self.name)
class BitString(Type):
'year': (choice, data.year),
'month': data.month,
'day': data.day
}
return self._inner.encode(data, encoder)
def decode(self, decoder):
decoded = self._inner.decode(decoder)
return datetime.date(decoded['year'][1],
decoded['month'],
decoded['day'])
class TimeOfDay(Type):
def __init__(self, name):
super(TimeOfDay, self).__init__(name, 'TIME-OF-DAY')
hours = Integer('hours')
minutes = Integer('minutes')
seconds = Integer('seconds')
hours.set_restricted_to_range(0, 24, False)
minutes.set_restricted_to_range(0, 59, False)
seconds.set_restricted_to_range(0, 60, False)
self._inner = Sequence('TIME-OF-DAY-ENCODING',
[hours, minutes, seconds],
None)
def encode(self, data, encoder):
data = {
'hours': data.hour,
alignment_bits = (offset - decoder.number_of_bits) % 8
if alignment_bits != 0:
decoder.skip_bits(8 - alignment_bits)
return decoded
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,
element_type,
minimum,
maximum,
has_extension_marker,
type_name):
super(ArrayType, self).__init__(name, type_name)
self.element_type = element_type
self.minimum = minimum
self.maximum = maximum
self.has_extension_marker = has_extension_marker
if is_unbound(minimum, maximum):
self.number_of_bits = None
def decode_unbound(self, decoder):
decoder.align()
decoded = []
number_of_bits = 0
for length in decoder.read_length_determinant_chunks():
decoded.append(decoder.read_bits(length))
number_of_bits += length
return (b''.join(decoded), number_of_bits)
def __repr__(self):
return 'BitString({})'.format(self.name)
class OctetString(Type):
def __init__(self, name, minimum, maximum, has_extension_marker):
super(OctetString, self).__init__(name, 'OCTET STRING')
self.set_size_range(minimum, maximum, has_extension_marker)
def set_size_range(self, minimum, maximum, has_extension_marker):
self.minimum = minimum
self.maximum = maximum
self.has_extension_marker = has_extension_marker
if is_unbound(minimum, maximum):
self.number_of_bits = None
else:
size = self.maximum - self.minimum
if size == 0 and self.maximum >= 65536:
def encode(self, data, encoder):
encoder.align()
encoder.append_length_determinant(len(data))
encoder.append_bytes(data)
def decode(self, decoder):
decoder.align()
length = decoder.read_length_determinant()
return decoder.read_bytes(length)
def __repr__(self):
return 'OpenType({})'.format(self.name)
class Any(Type):
def __init__(self, name):
super(Any, self).__init__(name, 'ANY')
def encode(self, _, _encoder):
raise NotImplementedError('ANY is not yet implemented.')
def decode(self, _decoder):
raise NotImplementedError('ANY is not yet implemented.')
def __repr__(self):
return 'Any({})'.format(self.name)
class Recursive(Type, compiler.Recursive):
def decode(self, decoder):
decoder.align()
encoded = []
for length in decoder.read_length_determinant_chunks():
encoded.append(decoder.read_bytes(self.LENGTH_MULTIPLIER * length))
return b''.join(encoded).decode(self.ENCODING)
def __repr__(self):
return '{}({})'.format(self.__class__.__name__,
self.name)
class MembersType(Type):
def __init__(self,
name,
root_members,
additions,
type_name):
super(MembersType, self).__init__(name, type_name)
self.root_members = root_members
self.additions = additions
self.optionals = [
member
for member in root_members
if member.optional or member.default is not None
]
def encode(self, data, encoder):