def main():
args = misc.parse_arguments()
# Compile the ASN.1 specification
asn = asn1tools.compile_files(args.asn_dir + VALID_ASN_FILE, 'der')
# Import the root private key and cert
root_privkey = io.import_rsa_private_key(args.root_key_file)
root_pubkey = root_privkey.publickey()
# Generate an RSA public key pair for intermediate CA
(sub_privkey, sub_pubkey) = crypto.new_rsa_keypair(2048)
# Encode intermediate tbsCertificate
sub_tbs = x509.default_tbs(issuer_public_key=root_pubkey,
subject_public_key=sub_pubkey,
issuer_cn='root',
subject_cn='intermediate',
is_ca=True,
additional_extensions=[],
asn=asn)
sub_tbs_der = asn.encode('TBSCertificate', sub_tbs)
# Sign the intermediate tbsCertificate
sub_sig = crypto.rsa_sha256_sign(root_privkey, sub_tbs_der)
# Encode the intermediate CA Certificate
sub_cert_der = x509.certificate(sub_tbs, sub_sig, asn)
# Generate an RSA public key pair for end entity certificate
(end_privkey, end_pubkey) = crypto.new_rsa_keypair(2048)
# Encode end entity tbsCertificate
end_tbs = x509.default_tbs(issuer_public_key=sub_pubkey,
subject_public_key=end_pubkey,
issuer_cn='intermediate',
subject_cn='localhost',
is_ca=False,
additional_extensions=[],
asn=asn)
make_end_cert_expired(end_tbs)
end_tbs_der = asn.encode('TBSCertificate', end_tbs)
# Sign the end entity tbsCertificate
end_sig = crypto.rsa_sha256_sign(sub_privkey, end_tbs_der)
# Encode the end entity Certificate
end_cert_der = x509.certificate(end_tbs, end_sig, asn)
# Write the chain into file
io.export_chain([end_cert_der, sub_cert_der],
args.build_dir + EXPORTED_CHAIN_NAME)
# Export the private key
io.export_private_key(end_privkey, args.build_dir + EXPORTED_KEY_NAME)
def test_foo(self):
foo = asn1tools.compile_files(['tests/files/foo.asn'], 'gser')
datas = [('Question', {
'id': 1,
'question': 'Is 1+1=3?'
}, b'question Question ::= { id 1, question "Is 1+1=3?" }')]
for name, decoded, encoded in datas:
self.assertEqual(foo.encode(name, decoded), encoded)
def test_repr_all_types(self):
all_types = asn1tools.compile_files('tests/files/all_types.asn', 'oer')
self.assertEqual(repr(all_types.types['Boolean']), 'Boolean(Boolean)')
self.assertEqual(repr(all_types.types['Integer']), 'Integer(Integer)')
self.assertEqual(repr(all_types.types['Real']), 'Real(Real)')
self.assertEqual(repr(all_types.types['Bitstring']),
'BitString(Bitstring)')
self.assertEqual(repr(all_types.types['Octetstring']),
'OctetString(Octetstring)')
self.assertEqual(repr(all_types.types['Null']), 'Null(Null)')
self.assertEqual(repr(all_types.types['Objectidentifier']),
'ObjectIdentifier(Objectidentifier)')
self.assertEqual(repr(all_types.types['Enumerated']),
'Enumerated(Enumerated)')
self.assertEqual(repr(all_types.types['Utf8string']),
'UTF8String(Utf8string)')
self.assertEqual(repr(all_types.types['Sequence']),
'Sequence(Sequence, [])')
self.assertEqual(repr(all_types.types['Set']), 'Set(Set, [])')
self.assertEqual(repr(all_types.types['Sequence2']),
'Sequence(Sequence2, [Integer(a)])')
self.assertEqual(repr(all_types.types['Set2']),
'Set(Set2, [Integer(a)])')
self.assertEqual(repr(all_types.types['Numericstring']),
'NumericString(Numericstring)')
self.assertEqual(repr(all_types.types['Printablestring']),
'PrintableString(Printablestring)')
self.assertEqual(repr(all_types.types['Ia5string']),
'IA5String(Ia5string)')
self.assertEqual(repr(all_types.types['Universalstring']),
'UniversalString(Universalstring)')
self.assertEqual(repr(all_types.types['Visiblestring']),
'VisibleString(Visiblestring)')
self.assertEqual(repr(all_types.types['Generalstring']),
'GeneralString(Generalstring)')
self.assertEqual(repr(all_types.types['Bmpstring']),
'BMPString(Bmpstring)')
self.assertEqual(repr(all_types.types['Teletexstring']),
'TeletexString(Teletexstring)')
self.assertEqual(repr(all_types.types['Graphicstring']),
'GraphicString(Graphicstring)')
self.assertEqual(repr(all_types.types['Utctime']), 'UTCTime(Utctime)')
self.assertEqual(repr(all_types.types['SequenceOf']),
'SequenceOf(SequenceOf, Integer())')
self.assertEqual(repr(all_types.types['SetOf']),
'SetOf(SetOf, Integer())')
self.assertEqual(repr(all_types.types['GeneralizedTime1']),
'GeneralizedTime(GeneralizedTime1)')
self.assertEqual(repr(all_types.types['Choice']),
'Choice(Choice, [Integer(a)])')
self.assertEqual(repr(all_types.types['Any']), 'Any(Any)')
self.assertEqual(
repr(all_types.types['Sequence12']),
'Sequence(Sequence12, [SequenceOf(a, Recursive(Sequence12))])')
def main():
c_source = asn1tools.compile_files(
['asn1/c_source.asn', 'asn1/programming_types.asn'], 'oer')
start_server = websockets.serve(functools.partial(echo, c_source=c_source),
'localhost', 8765)
print('Listening for websocket clients on localhost:8765...')
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
def test_all_types(self):
all_types = asn1tools.compile_files('tests/files/all_types.asn', 'jer')
datas = [
('Boolean', True, b'true'),
('Integer', 127, b'127'),
('Integer', 0, b'0'),
('Integer', -128, b'-128'),
('Real', 1.0, b'1.0'),
('Real', -2.0, b'-2.0'),
('Real', float('inf'), b'"INF"'),
('Real', float('-inf'), b'"-INF"'),
('Octetstring', b'\x00', b'"00"'),
('Null', None, b'null'),
('Enumerated', 'one', b'"one"'),
('Utf8string', 'foo', b'"foo"'),
('Sequence', {}, b'{}'),
('Sequence2', {'a': 1}, b'{"a":1}'),
('Set', {}, b'{}'),
('Set2', {'a': 2}, b'{"a":2}'),
('Numericstring', '123', b'"123"'),
('Printablestring', 'foo', b'"foo"'),
('Ia5string', 'bar', b'"bar"'),
('Universalstring', 'bar', b'"bar"'),
('Visiblestring', 'bar', b'"bar"'),
('Bmpstring', b'bar', b'"bar"'),
('Teletexstring', b'fum', b'"fum"'),
('SequenceOf', [], b'[]'),
('SetOf', [], b'[]'),
]
for type_name, decoded, encoded in datas:
self.assertEqual(all_types.encode(type_name, decoded), encoded)
self.assertEqual(all_types.decode(type_name, encoded), decoded)
self.assertEqual(all_types.encode('Real', float('nan')), b'"NaN"')
self.assertTrue(math.isnan(all_types.decode('Real', b'"NaN"')))
self.assertEqual(all_types.decode('Real', b'"0"'), 0.0)
self.assertEqual(all_types.decode('Real', b'"-0"'), 0.0)
decoded_message = (b'\x80', 1)
encoded_message = b'{"value":"80","length":1}'
self.assertEqual(loadb(all_types.encode('Bitstring', decoded_message)),
loadb(encoded_message))
self.assertEqual(all_types.decode('Bitstring', encoded_message),
decoded_message)
with self.assertRaises(NotImplementedError):
all_types.encode('Sequence12', {'a': [{'a': []}]})
with self.assertRaises(NotImplementedError):
all_types.decode('Sequence12', b'{"a": [{"a": []}]}')
def __init__(self, AgentListener, dir_name=dir_name):
"""
:param AgentListener: the DUST agent.
:param dir_name: current directory were this python file is located.
"""
self.cam_asn1 = asn1tools.compile_files('./cam121.asn', 'uper')
template_cam_json = os.path.join(dir_name, "cam_template.json") # "cam_template.json")
f = open(template_cam_json, "r")
self.template_cam = json.load(f)
self.agent_listener_dust: AgentListenerDust = AgentListener
def test_all_types_automatic_tags(self):
all_types = asn1tools.compile_files(
'tests/files/all_types_automatic_tags.asn', 'xer')
datas = [
('Sequence3',
{'a': 1, 'c': 2,'d': True},
b'<Sequence3><a>1</a><c>2</c><d><true /></d></Sequence3>')
]
for type_name, decoded, encoded in datas:
self.assert_encode_decode_string(all_types, type_name, decoded, encoded)
def __init__(self, file):
#print("in FirmwareFileC constructor")
self.file = file
self.counter = 0
self.f = open(self.file, 'r')
self.dataList = list()
asn1_dir = os.path.join("") #("../../../../Downloads", "..")
self.daq_messages = asn1tools.compile_files([
os.path.join(asn1_dir, "DAQMessages.asn"),
os.path.join(asn1_dir, "ProgrammingTypes.asn")
],
codec="oer")
def test_all_types_automatic_tags(self):
all_types = asn1tools.compile_files(
'tests/files/all_types_automatic_tags.asn', 'der')
datas = [('Sequence3', {
'a': 1,
'c': 2,
'd': True
}, b'\x30\x09\x80\x01\x01\x82\x01\x02\x83\x01\xff')]
for type_name, decoded, encoded in datas:
self.assert_encode_decode(all_types, type_name, decoded, encoded)
def test_all_types_automatic_tags(self):
foo = asn1tools.compile_files(
'tests/files/all_types_automatic_tags.asn', 'jer')
datas = [('Sequence3', {
'a': 1,
'c': 2,
'd': True
}, b'{"a":1,"c":2,"d":true}')]
for type_name, decoded, encoded in datas:
self.assert_encode_decode_string(foo, type_name, decoded, encoded)
def __init__(self,
client_ip=DEF_CLIENT,
port=DEF_SERVER_PORT,
client_port=DEF_CLIENT_PORT):
# Listening socket
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.bind(('localhost', port))
# Protocol syntax
self.protocol = asn1tools.compile_files('TicTacToe.asn')
try:
print("Listening for incoming connexions ...")
self.state = "Listening"
self.s.listen(5)
# Waiting for 2 clients
sock, addr = self.s.accept()
self.cl1 = Client(sock, addr, '', 'X')
self.cl1.sock.send(
self.protocol.encode('ServerAnswer', ('helloX', {})))
self.cl1.name = self.protocol.decode(
'Command', self.cl1.sock.recv(128))[1]['name']
while not Server.checkName(self.cl1.name):
self.cl1.sock.send(
self.protocol.encode('ServerAnswer', ('invalidName', {})))
self.cl1.name = self.protocol.decode(
'Command', self.cl1.sock.recv(128))[1]['name']
print("Player 1 connected:")
print(self.cl1)
sock, addr = self.s.accept()
self.cl2 = Client(sock, addr, '', 'O')
self.cl2.sock.send(
self.protocol.encode('ServerAnswer', ('helloO', {})))
self.cl2.name = self.protocol.decode(
'Command', self.cl2.sock.recv(128))[1]['name']
while not Server.checkName(self.cl2.name):
self.cl2.sock.send(
self.protocol.encode('ServerAnswer', ('invalidName', {})))
self.cl2.name = self.protocol.decode(
'Command', self.cl2.sock.recv(128))[1]['name']
print("Player 2 connected:")
print(self.cl2)
self.state = "Connected"
except Exception as e:
print("Initialization error")
self.quit()
raise e
def method_unpickle():
pickled = pickle.dumps(asn1tools.compile_files(RRC_8_6_0_ASN_PATH))
print("Unpickling compiled object... ", end='', flush=True)
def unpickle():
pickle.loads(pickled)
time = timeit.timeit(unpickle, number=ITERATIONS)
print('done.')
return round(time, 5), len(pickled)
def asn1tools_encode_decode():
snmp_v1 = asn1tools.compile_files(SNMP_V1_ASN_PATHS)
def encode():
snmp_v1.encode('Message', DECODED_MESSAGE_ASN1TOOLS, check_types=False)
def decode():
snmp_v1.decode('Message', ENCODED_MESSAGE)
encode_time = timeit.timeit(encode, number=ITERATIONS)
decode_time = timeit.timeit(decode, number=ITERATIONS)
return encode_time, decode_time
def test_all_types_automatic_tags(self):
all_types = asn1tools.compile_files(
'tests/files/all_types_automatic_tags.asn', 'xer')
datas = [
('Sequence14',
{'a': 1, 'c': 2,'d': True},
b'<Sequence14><a>1</a><c>2</c><d><true /></d></Sequence14>')
]
for type_name, decoded, encoded in datas:
self.assertEqual(all_types.encode(type_name, decoded), encoded)
self.assertEqual(all_types.decode(type_name, encoded), decoded)
def encode_decode_jer():
rrc_8_6_0 = asn1tools.compile_files(RRC_8_6_0_ASN_PATH, 'jer')
def encode():
rrc_8_6_0.encode('BCCH-DL-SCH-Message', DECODED_MESSAGE)
def decode():
rrc_8_6_0.decode('BCCH-DL-SCH-Message', ENCODED_MESSAGE_JER)
encode_time = timeit.timeit(encode, number=ITERATIONS)
decode_time = timeit.timeit(decode, number=ITERATIONS)
return encode_time, decode_time
def test_all_types_automatic_tags(self):
all_types = asn1tools.compile_files(
'tests/files/all_types_automatic_tags.asn', 'uper')
datas = [('Sequence14', {
'a': 1,
'c': 2,
'd': True
}, b'\x00\x80\x80\x81\x40')]
for type_name, decoded, encoded in datas:
self.assertEqual(all_types.encode(type_name, decoded), encoded)
self.assertEqual(all_types.decode(type_name, encoded), decoded)
def asn1tools_encode_decode():
rrc = asn1tools.compile_files(RRC_8_6_0_ASN_PATH, 'uper')
def encode():
rrc.encode('BCCH-DL-SCH-Message', DECODED_MESSAGE_ASN1TOOLS)
def decode():
rrc.decode('BCCH-DL-SCH-Message', ENCODED_MESSAGE)
encode_time = timeit.timeit(encode, number=ITERATIONS)
decode_time = timeit.timeit(decode, number=ITERATIONS)
return encode_time, decode_time
def test_foo_indent(self):
foo = asn1tools.compile_files(['tests/files/foo.asn'], 'gser')
datas = [('Question', {
'id': 1,
'question': 'Is 1+1=3?'
}, b'question Question ::= {\n'
b' id 1,\n'
b' question "Is 1+1=3?"\n'
b'}')]
for name, decoded, encoded in datas:
actual = foo.encode(name, decoded, indent=2)
self.assertEqual(actual, encoded)
def test_x691_a1(self):
a1 = asn1tools.compile_files('tests/files/x691_a1.asn', 'per')
decoded_message = {
'name': {
'givenName': 'John',
'initial': 'P',
'familyName': 'Smith'
},
'title':
'Director',
'number':
51,
'dateOfHire':
'19710917',
'nameOfSpouse': {
'givenName': 'Mary',
'initial': 'T',
'familyName': 'Smith'
},
'children': [{
'name': {
'givenName': 'Ralph',
'initial': 'T',
'familyName': 'Smith'
},
'dateOfBirth': '19571111'
}, {
'name': {
'givenName': 'Susan',
'initial': 'B',
'familyName': 'Jones'
},
'dateOfBirth': '19590717'
}]
}
encoded_message = (
b'\x80\x04\x4a\x6f\x68\x6e\x01\x50\x05\x53\x6d\x69\x74\x68\x01\x33'
b'\x08\x44\x69\x72\x65\x63\x74\x6f\x72\x08\x31\x39\x37\x31\x30\x39'
b'\x31\x37\x04\x4d\x61\x72\x79\x01\x54\x05\x53\x6d\x69\x74\x68\x02'
b'\x05\x52\x61\x6c\x70\x68\x01\x54\x05\x53\x6d\x69\x74\x68\x08\x31'
b'\x39\x35\x37\x31\x31\x31\x31\x05\x53\x75\x73\x61\x6e\x01\x42\x05'
b'\x4a\x6f\x6e\x65\x73\x08\x31\x39\x35\x39\x30\x37\x31\x37')
with self.assertRaises(NotImplementedError):
encoded = a1.encode('PersonnelRecord', decoded_message)
self.assertEqual(encoded, encoded_message)
decoded = a1.decode('PersonnelRecord', encoded)
self.assertEqual(decoded, decoded_message)
def test_decode_all_types(self):
all_types = asn1tools.compile_files('tests/files/all_types.asn', 'per')
self.assertEqual(all_types.decode('Bitstring', b'\x04\x40'),
(b'\x40', 4))
self.assertEqual(all_types.decode('Octetstring', b'\x01\x00'), b'\x00')
self.assertEqual(all_types.decode('Null', b'\x05\x00'), None)
self.assertEqual(all_types.decode('Objectidentifier', b'\x01\x2a'),
'1.2')
self.assertEqual(
all_types.decode('Objectidentifier', b'\x03\x2a\x82\x4d'),
'1.2.333')
self.assertEqual(all_types.decode('Enumerated', b'\x00'), 'one')
with self.assertRaises(NotImplementedError):
all_types.decode('Utf8string', b'\x0c\x03foo')
self.assertEqual(all_types.decode('Sequence', b''), {})
with self.assertRaises(NotImplementedError):
all_types.decode('Sequence12', b'\x80\x01\x00')
with self.assertRaises(NotImplementedError):
all_types.decode('Set', b'\x31\x00')
with self.assertRaises(NotImplementedError):
all_types.decode('Numericstring', b'\x12\x03123')
with self.assertRaises(NotImplementedError):
all_types.decode('Printablestring', b'\x13\x03foo')
self.assertEqual(all_types.decode('Ia5string', b'\x03bar'), 'bar')
with self.assertRaises(NotImplementedError):
all_types.decode('Universalstring', b'\x1c\x03bar')
with self.assertRaises(NotImplementedError):
all_types.decode('Visiblestring', b'\x1a\x03bar')
with self.assertRaises(NotImplementedError):
all_types.decode('Generalstring', b'\x1b\x03bar')
with self.assertRaises(NotImplementedError):
all_types.decode('Bmpstring', b'\x1e\x03bar')
with self.assertRaises(NotImplementedError):
all_types.decode('Teletexstring', b'\x14\x03fum')
with self.assertRaises(NotImplementedError):
all_types.decode('Utctime', b'\x17\x0d010203040506Y')
def test_all_types_automatic_tags(self):
all_types = asn1tools.compile_files(
'tests/files/all_types_automatic_tags.asn', 'jer')
datas = [('Sequence3', {
'a': 1,
'c': 2,
'd': True
}, b'{"a":1,"c":2,"d":true}')]
for type_name, decoded, encoded in datas:
self.assertEqual(loadb(all_types.encode(type_name, decoded)),
loadb(encoded))
self.assertEqual(all_types.decode(type_name, encoded), decoded)
def test_x691_a1(self):
a1 = asn1tools.compile_files('tests/files/x691_a1.asn', 'uper')
decoded_message = {
'name': {
'givenName': 'John',
'initial': 'P',
'familyName': 'Smith'
},
'title':
'Director',
'number':
51,
'dateOfHire':
'19710917',
'nameOfSpouse': {
'givenName': 'Mary',
'initial': 'T',
'familyName': 'Smith'
},
'children': [{
'name': {
'givenName': 'Ralph',
'initial': 'T',
'familyName': 'Smith'
},
'dateOfBirth': '19571111'
}, {
'name': {
'givenName': 'Susan',
'initial': 'B',
'familyName': 'Jones'
},
'dateOfBirth': '19590717'
}]
}
encoded_message = (
b'\x82\x4a\xdf\xa3\x70\x0d\x00\x5a\x7b\x74\xf4\xd0\x02\x66\x11\x13'
b'\x4f\x2c\xb8\xfa\x6f\xe4\x10\xc5\xcb\x76\x2c\x1c\xb1\x6e\x09\x37'
b'\x0f\x2f\x20\x35\x01\x69\xed\xd3\xd3\x40\x10\x2d\x2c\x3b\x38\x68'
b'\x01\xa8\x0b\x4f\x6e\x9e\x9a\x02\x18\xb9\x6a\xdd\x8b\x16\x2c\x41'
b'\x69\xf5\xe7\x87\x70\x0c\x20\x59\x5b\xf7\x65\xe6\x10\xc5\xcb\x57'
b'\x2c\x1b\xb1\x6e')
encoded = a1.encode('PersonnelRecord', decoded_message)
self.assertEqual(encoded, encoded_message)
decoded = a1.decode('PersonnelRecord', encoded)
self.assertEqual(decoded, decoded_message)
def test_encode_all_types(self):
all_types = asn1tools.compile_files('tests/files/all_types.asn', 'per')
self.assertEqual(all_types.encode('Bitstring', (b'\x40', 4)),
b'\x04\x40')
self.assertEqual(all_types.encode('Octetstring', b'\x00'), b'\x01\x00')
self.assertEqual(all_types.encode('Null', None), b'')
self.assertEqual(all_types.encode('Objectidentifier', '1.2'),
b'\x01\x2a')
self.assertEqual(all_types.encode('Objectidentifier', '1.2.333'),
b'\x03\x2a\x82\x4d')
self.assertEqual(all_types.encode('Enumerated', 'one'), b'\x00')
with self.assertRaises(NotImplementedError):
all_types.encode('Utf8string', 'foo')
self.assertEqual(all_types.encode('Sequence', {}), b'')
with self.assertRaises(NotImplementedError):
all_types.encode('Sequence12', {'a': [{'a': []}]})
with self.assertRaises(NotImplementedError):
all_types.encode('Set', {})
with self.assertRaises(NotImplementedError):
all_types.encode('Numericstring', '123')
with self.assertRaises(NotImplementedError):
all_types.encode('Printablestring', 'foo')
self.assertEqual(all_types.encode('Ia5string', 'bar'), b'\x03bar')
with self.assertRaises(NotImplementedError):
all_types.encode('Universalstring', 'bar')
with self.assertRaises(NotImplementedError):
all_types.encode('Visiblestring', 'bar')
with self.assertRaises(NotImplementedError):
all_types.encode('Generalstring', 'bar')
with self.assertRaises(NotImplementedError):
all_types.encode('Bmpstring', b'bar')
with self.assertRaises(NotImplementedError):
all_types.encode('Teletexstring', b'fum')
with self.assertRaises(NotImplementedError):
all_types.encode('Utctime', '010203040506')
def test_x691_a3(self):
a3 = asn1tools.compile_files('tests/files/x691_a3.asn', 'per')
return
decoded = {
'name': {
'givenName': 'John',
'initial': 'P',
'familyName': 'Smith'
},
'title':
'Director',
'number':
51,
'dateOfHire':
'19710917',
'nameOfSpouse': {
'givenName': 'Mary',
'initial': 'T',
'familyName': 'Smith'
},
'children': [{
'name': {
'givenName': 'Ralph',
'initial': 'T',
'familyName': 'Smith'
},
'dateOfBirth': '19571111'
}, {
'name': {
'givenName': 'Susan',
'initial': 'B',
'familyName': 'Jones'
},
'dateOfBirth': '19590717',
'sex': 'female'
}]
}
encoded = (
b'\x40\xc0\x4a\x6f\x68\x6e\x50\x08\x53\x6d\x69\x74\x68\x00\x00\x33'
b'\x08\x44\x69\x72\x65\x63\x74\x6f\x72\x00\x19\x71\x09\x17\x03\x4d'
b'\x61\x72\x79\x54\x08\x53\x6d\x69\x74\x68\x01\x00\x52\x61\x6c\x70'
b'\x68\x54\x08\x53\x6d\x69\x74\x68\x00\x19\x57\x11\x11\x82\x00\x53'
b'\x75\x73\x61\x6e\x42\x08\x4a\x6f\x6e\x65\x73\x00\x19\x59\x07\x17'
b'\x01\x01\x40')
self.assert_encode_decode(a3, 'PersonnelRecord', decoded, encoded)
def method_compile_cached_file():
print("Using cached compilation... ", end='', flush=True)
asn1tools.compile_files(RRC_8_6_0_ASN_PATH, cache_dir=CACHE_DIR)
def compile_file():
asn1tools.compile_files(RRC_8_6_0_ASN_PATH, cache_dir=CACHE_DIR)
time = timeit.timeit(compile_file, number=ITERATIONS)
print('done.')
def dir_size(path):
total = 0
for entry in os.scandir(path):
if entry.is_file():
total += entry.stat().st_size
elif entry.is_dir():
total += dir_size(entry.path)
return total
return round(time, 5), dir_size(CACHE_DIR)
def test_x691_a4(self):
a4 = asn1tools.compile_files('tests/files/x691_a4.asn', 'per')
decoded = {
'a': 253,
'b': True,
'c': ('e', True),
'g': '123',
'h': True
}
encoded = (b'\x9e\x00\x01\x80\x01\x02\x91\xa4')
with self.assertRaises(NotImplementedError):
self.assert_encode_decode(a4, 'Ax', decoded, encoded)
def compile_files(schema_list, asn1_format):
try:
return asn1tools.compile_files(schema_list, asn1_format)
except asn1tools.parser.ParseError:
# Parse each file in turn in case there's a syntax error, so we can tell the
# user which file has the problem.
for path in schema_list:
f_contents = open(path).read()
try:
asn1tools.compile_string(f_contents)
except asn1tools.parser.ParseError as exception:
print("While parsing %s:" % path)
print(exception)
sys.exit(1)
assert 0
def test_encode_decode_bad_type_name(self):
foo = asn1tools.compile_files('tests/files/foo.asn')
# Encode.
with self.assertRaises(asn1tools.EncodeError) as cm:
foo.encode('BadTypeName', b'')
self.assertEqual(str(cm.exception),
"Type 'BadTypeName' not found in types dictionary.")
# Decode.
with self.assertRaises(asn1tools.DecodeError) as cm:
foo.decode('BadTypeName', b'')
self.assertEqual(str(cm.exception),
"Type 'BadTypeName' not found in types dictionary.")
def test_x691_a1(self):
a1 = asn1tools.compile_files('tests/files/x691_a1.asn', 'oer')
decoded = {
'name': {
'givenName': 'John',
'initial': 'P',
'familyName': 'Smith'
},
'title': 'Director',
'number': 51,
'dateOfHire': '19710917',
'nameOfSpouse': {
'givenName': 'Mary',
'initial': 'T',
'familyName': 'Smith'
},
'children': [
{
'name': {
'givenName': 'Ralph',
'initial': 'T',
'familyName': 'Smith'
},
'dateOfBirth': '19571111'
},
{
'name': {
'givenName': 'Susan',
'initial': 'B',
'familyName': 'Jones'
},
'dateOfBirth': '19590717'
}
]
}
encoded = (
b'\x80\x04\x4a\x6f\x68\x6e\x01\x50\x05\x53\x6d\x69\x74\x68\x01\x33'
b'\x08\x44\x69\x72\x65\x63\x74\x6f\x72\x08\x31\x39\x37\x31\x30\x39'
b'\x31\x37\x04\x4d\x61\x72\x79\x01\x54\x05\x53\x6d\x69\x74\x68\x01'
b'\x02\x05\x52\x61\x6c\x70\x68\x01\x54\x05\x53\x6d\x69\x74\x68\x08'
b'\x31\x39\x35\x37\x31\x31\x31\x31\x05\x53\x75\x73\x61\x6e\x01\x42'
b'\x05\x4a\x6f\x6e\x65\x73\x08\x31\x39\x35\x39\x30\x37\x31\x37'
)
self.assert_encode_decode(a1, 'PersonnelRecord', decoded, encoded)
def test_decode_all_types(self):
all_types = asn1tools.compile_files('tests/files/all_types.asn',
'uper')
self.assertEqual(all_types.decode('Boolean', b'\x80'), True)
self.assertEqual(all_types.decode('Boolean', b'\x00'), False)
self.assertEqual(all_types.decode('Integer', b'\x03\x00\x80\x00'),
32768)
self.assertEqual(all_types.decode('Integer', b'\x02\x7f\xff'), 32767)
self.assertEqual(all_types.decode('Integer', b'\x02\x01\x00'), 256)
self.assertEqual(all_types.decode('Integer', b'\x02\x00\xff'), 255)
self.assertEqual(all_types.decode('Integer', b'\x02\x00\x80'), 128)
self.assertEqual(all_types.decode('Integer', b'\x01\x7f'), 127)
self.assertEqual(all_types.decode('Integer', b'\x01\x01'), 1)
self.assertEqual(all_types.decode('Integer', b'\x01\x00'), 0)
self.assertEqual(all_types.decode('Integer', b'\x01\xff'), -1)
self.assertEqual(all_types.decode('Integer', b'\x01\x80'), -128)
self.assertEqual(all_types.decode('Integer', b'\x02\xff\x7f'), -129)
self.assertEqual(all_types.decode('Integer', b'\x02\xff\x00'), -256)
self.assertEqual(all_types.decode('Integer', b'\x02\x80\x00'), -32768)
self.assertEqual(all_types.decode('Integer', b'\x03\xff\x7f\xff'),
-32769)
self.assertEqual(all_types.decode('Bitstring', b'\x04\x40'),
(b'\x40', 4))
self.assertEqual(all_types.decode('Bitstring2', b'\x12\x80'),
(b'\x12\x80', 9))
self.assertEqual(all_types.decode('Bitstring3', b'\x4d'), (b'\x34', 6))
self.assertEqual(all_types.decode('Octetstring', b'\x01\x00'), b'\x00')
self.assertEqual(all_types.decode('Octetstring2', b'\xab\xcd'),
b'\xab\xcd')
self.assertEqual(all_types.decode('Octetstring3', b'\xab\xcd\xef'),
b'\xab\xcd\xef')
self.assertEqual(
all_types.decode('Octetstring4', b'\x31\x35\x79\xbd\xe0'),
b'\x89\xab\xcd\xef')
self.assertEqual(all_types.decode('Enumerated', b'\x00'), 'one')
self.assertEqual(all_types.decode('Enumerated2', b'\x40'), 'two')
self.assertEqual(all_types.decode('Sequence', b''), {})
self.assertEqual(all_types.decode('Sequence2', b'\x00'), {'a': 0})
self.assertEqual(all_types.decode('Sequence2', b'\x80\x80\x80'),
{'a': 1})
with self.assertRaises(NotImplementedError):
all_types.decode('Sequence12', b'\x80\x80')
self.assertEqual(all_types.decode('Ia5string', b'\x03\xc5\x87\x90'),
'bar')
