def test_per_sequence(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
ASN1.ASN1Obj.CODEC = PER
#
PER._REPR_INT = 'bin'
PER._REPR_ENUM = 'bin'
PER._SAFE = True
#
PER.VARIANT = 'A'
if print_info: print('testing OCTET STRING and SEQUENCE encoding / decoding (PER aligned)')
PER.VARIANT = 'A'
a = inline('''
A ::= SEQUENCE {
s1 INTEGER (1..50, ...),
s2 ENUMERATED {first, second, third},
s3 BOOLEAN OPTIONAL,
s4 INTEGER (-10..20) DEFAULT 5,
s5 OCTET STRING (SIZE(2..10, ...)),
...,
s8 INTEGER,
s9 BOOLEAN
}
''')
b = a.clone()
a.encode({'s1':2, 's2':'second', 's3':True, 's4':2, 's5':'abcdef'})
#print('a (2, second, True, 2, abcdef): %s' % a._msg.show())
assert(a._msg.__hex__() == '605b08616263646566')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':2, 's2':'second', 's5':'abcdef'})
#print('a (2, second, abcdef): %s' % a._msg.show())
assert(a._msg.__hex__() == '005200616263646566')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':2, 's2':'second', 's5':'a', 's8':500000})
#print('a (2, second, a, 500000): %s' % a._msg.show())
assert(a._msg.__hex__() == '805801610300040307a120')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':200, 's2':'third', 's3':False, 's5':'', 's8':5000000, 's9':True})
#print('a (200, third, False, , 5000000, True): %s' % a._msg.show())
assert(a._msg.__hex__() == 'd00200c89000038004034c4b400180')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':200, 's2':'third', 's3':False, 's5':300*'A', 's8':-10, 's9':True})
#print('a (200, third, False, , 300*A, -10, True): %s' % a.show())
assert(a._msg.__hex__() == 'd00200c890812c41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414103800201f60180')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
if print_info: print('testing OCTET STRING and SEQUENCE encoding (PER unaligned)')
PER.VARIANT = 'U'
a.encode({'s1':2, 's2':'second', 's3':True, 's4':2, 's5':'abcdef'})
#print('a (2, second, True, 2, abcdef): %s' % a._msg.show())
assert(a._msg.__bin__() == '01100000010110110000100011000010110001001100011011001000110010101100110')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':2, 's2':'second', 's5':'abcdef'})
#print('a (2, second, abcdef): %s' % a._msg.show())
assert(a._msg.__bin__() == '00000000010100100011000010110001001100011011001000110010101100110')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':2, 's2':'second', 's5':'a', 's8':500000})
#print('a (2, second, a, 500000): %s' % a._msg.show())
assert(a._msg.__bin__() == '100000000101100000001011000010000001100000010000000011000001111010000100100000')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':200, 's2':'third', 's3':False, 's5':'', 's8':5000000, 's9':True})
#print('a (200, third, False, , 5000000, True): %s' % a._msg.show())
assert(a._msg.__bin__() == '110100000010000000001100100010010000000000000011100000100000000110100110001001011010000000000000110000000')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1':200, 's2':'third', 's3':False, 's5':300*'A', 's8':-10, 's9':True})
#print('a (200, third, False, , 300*A, -10, True): %s' % a._msg.show())
assert(a._msg.__hex__() == 'd0200c89812c414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141038100fb00c00')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
PER.VARIANT = 'A'
a = inline('''
A ::= SEQUENCE {
s1 INTEGER {first(1), second(2)} (1..50, ...),
s2 ENUMERATED {first, second, third},
s3 SEQUENCE { s31 BOOLEAN,
s32 NULL,
s33 BIT STRING (SIZE(56..64)),
s34 BOOLEAN DEFAULT FALSE},
...,
s4 NULL OPTIONAL,
s5 CHOICE { s51 INTEGER (-20..50),
s52 BOOLEAN,
s53 NULL,
s54 BOOLEAN }
}
''')
b = a.clone()
a.encode({'s1':-5000,
's2':'third',
's3':{'s31':True, 's32':None, 's33':(1, 64), 's34':False},
's4':None,
's5':('s52', True)
})
#print('a (-5000, third, {True, None, (1, 64), False}, None, (s52, True)): %s' % a._msg.show())
assert(a._msg.__hex__() == 'c002ec78980000000000000001038001000160')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
PER.VARIANT = 'U'
a.encode({'s1':-5000,
's2':'third',
's3':{'s31':True, 's32':None, 's33':(1, 64), 's34':False},
's4':None,
's5':('s52', True)
})
#print('a (-5000, third, {True, None, (1, 64), False}, None, (s52, True)): %s' % a._msg.show())
assert(a._msg.__hex__() == 'c0bb1e26000000000000000040e020002c0' and a._msg.bit_len() == 139)
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
if print_info: print('testing SEQUENCE OF encoding / decoding (PER aligned)')
PER.VARIANT = 'A'
a = inline('''
A ::= SEQUENCE (SIZE(2..10, ...)) OF OCTET STRING (SIZE(0..10, ...))
''')
b = a.clone()
a.encode(['abc', '', 5*'a', 11*'A', 25*'B'])
#print('a (abc, , 5*a, 11*A, 25*B): %s' % a._msg.show())
assert(a._msg.__hex__() == '18c061626301406161616161800b4141414141414141414141801942424242424242424242424242424242424242424242424242')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode([13*'XY'])
#print('a (13*XY): %s' % a._msg.show())
assert(a._msg.__hex__() == '8001801a5859585958595859585958595859585958595859585958595859')
b.decode(str(a))
assert(a._msg.__hex__() == b._msg.__hex__() and a() == b())
#
a = inline('''
A ::= SEQUENCE SIZE(2..10, ...) OF INTEGER (0..300)
''')
b = a.clone()
a.encode(range(300))
assert(a.__hex__() == '80812c0000000100020003000400050006000700080009000a000b000c000d000e000f0010001100120013001400150016001700180019001a001b001c001d001e001f0020002100220023002400250026002700280029002a002b002c002d002e002f0030003100320033003400350036003700380039003a003b003c003d003e003f0040004100420043004400450046004700480049004a004b004c004d004e004f0050005100520053005400550056005700580059005a005b005c005d005e005f0060006100620063006400650066006700680069006a006b006c006d006e006f0070007100720073007400750076007700780079007a007b007c007d007e007f0080008100820083008400850086008700880089008a008b008c008d008e008f0090009100920093009400950096009700980099009a009b009c009d009e009f00a000a100a200a300a400a500a600a700a800a900aa00ab00ac00ad00ae00af00b000b100b200b300b400b500b600b700b800b900ba00bb00bc00bd00be00bf00c000c100c200c300c400c500c600c700c800c900ca00cb00cc00cd00ce00cf00d000d100d200d300d400d500d600d700d800d900da00db00dc00dd00de00df00e000e100e200e300e400e500e600e700e800e900ea00eb00ec00ed00ee00ef00f000f100f200f300f400f500f600f700f800f900fa00fb00fc00fd00fe00ff0100010101020103010401050106010701080109010a010b010c010d010e010f0110011101120113011401150116011701180119011a011b011c011d011e011f0120012101220123012401250126012701280129012a012b')
b.decode(str(a))
assert(a() == b())
if print_info: print('testing SEQUENCE OF encoding / decoding (PER unaligned)')
PER.VARIANT = 'U'
a = inline('''
A ::= SEQUENCE (SIZE(2..10, ...)) OF OCTET STRING (SIZE(0..10, ...))
''')
b = a.clone()
a.encode(['abc', '', 5*'a', 11*'A', 25*'B'])
#print('a (abc, , 5*a, 11*A, 25*B): %s' % a._msg.show())
assert(a._msg.__hex__() == '18d85898c05616161616185a0a0a0a0a0a0a0a0a0a0a0c6509090909090909090909090909090909090909090909090908' and a._msg.bit_len() == 390)
b.decode(str(a))
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode([13*'XY'])
#print('a (13*XY): %s' % a._msg.show())
assert(a._msg.__hex__() == '80c696165616561656165616561656165616561656165616561656164' and a._msg.bit_len() == 226)
b.decode(str(a))
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a = inline('''
A ::= SEQUENCE SIZE(2..10, ...) OF INTEGER (0..300)
''')
b = a.clone()
a.encode(range(300))
assert(a.__hex__() == 'c0960000202018100a0603820120a058301a0e078402212098502a160b860321a0d8703a1e0f8804222118904a26138a0522a158b05a2e178c06232198d06a361b8e0723a1d8f07a3e1f9008242219108a4623920924a259309a4e27940a25229950aa562b960b25a2d970ba5e2f980c26231990ca66339a0d26a359b0da6e379c0e272399d0ea763b9e0f27a3d9f0fa7e3fa01028241a110a8643a21128a45a311a8e47a41229249a512a964ba61329a4da713a9e4fa8142a251a914aa653aa152aa55ab15aae57ac162b259ad16ab65bae172ba5daf17abe5fb0182c261b118ac663b2192ca65b319ace67b41a2d269b51aad66bb61b2da6db71bade6fb81c2e271b91cae673ba1d2ea75bb1daee77bc1e2f279bd1eaf67bbe1f2fa7dbf1fafe7fc02030281c120b0683c22130a85c321b0e87c42231289c522b168bc62331a8dc723b1e8fc82432291c924b2693ca2532a958' and a._msg.bit_len() == 2717)
b.decode(str(a))
assert(a() == b())
def test_def(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
MODULE_OPT.TAG = TAG_AUTO
if print_info: print('testing NULL definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_NULL)
A.set_val(None)
if print_info: print('testing BOOLEAN definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_BOOL)
A.set_val(False)
A.set_val(True)
if print_info: print('testing INTEGER definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_INTEGER)
A.set_val(0)
A.set_val(-999999999999999999999999999)
A.set_val(111999999999999999999999999999111)
if print_info: print('testing ENUMERATED definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_ENUM)
A._cont = OD([('un', 1), ('deux', 2), ('trois', 3)])
A.set_val('un') # parce qu'un tien vaut mieux que deux tu l'auras
if print_info: print('testing BIT STRING definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_BIT_STR)
A.set_val((0b11001100111000, 16))
A.parse_value("'0011001100111000'B")
A.parse_value("'3338'H")
if print_info: print('testing OCTET STRING definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_OCTET_STR)
A.set_val('la grande truite')
A.parse_value("'11001100111000'B")
A.parse_value("'3338'H")
if print_info: print('testing CHOICE definition')
A = inline('''
A ::= CHOICE {
a1 BOOLEAN,
a2 INTEGER (0..20),
a3 NULL,
a4 INTEGER(MIN..100, ...),
...,
a5 BIT STRING (SIZE(0..80))
}''')
A.set_val( ('a1', True) )
A.set_val( ('a2', 12) )
A.set_val( ('a3', None) )
A.set_val( ('a4', -50000000) )
A.set_val( ('a5', (1000000000000000000001, 70)) )
A = inline('''
A ::= CHOICE {
c1 INTEGER {first(1), second(2)} (1..50, ...),
c2 ENUMERATED {first, second, third, ..., fourth},
c3 BIT STRING {first-bit(1), second-bit(2)} (SIZE(8..16, ...)),
c4 OCTET STRING (SIZE(10..20)),
c5 CHOICE { c51 INTEGER (-20..50),
c52 BOOLEAN,
c53 NULL,
c54 BOOLEAN },
...,
c6 OBJECT IDENTIFIER,
c7 BOOLEAN
}
''')
A.set_val( ('c1', 500) )
A.set_val( ('c2', 'fourth') )
A.set_val( ('c3', (0b10100000, 12)) )
A.set_val( ('c4', 'abcdefghijklmn') )
A.set_val( ('c5', ('c54', True)) )
A.set_val( ('c6', (1, 2, 3)) )
A.set_val( ('c7', False) )
if print_info: print('testing SEQUENCE definition')
A = inline('''
A ::= SEQUENCE {
s1 INTEGER {first(1), second(2)} (1..50, ...),
s2 ENUMERATED {first, second, third},
s3 SEQUENCE { s31 BOOLEAN,
s32 NULL,
s33 BIT STRING (SIZE(56..64)),
s34 BOOLEAN DEFAULT FALSE},
...,
s4 NULL OPTIONAL,
s5 CHOICE { s51 INTEGER (-20..50),
s52 BOOLEAN,
s53 NULL,
s54 BOOLEAN }
}
''')
A.set_val({'s1':50,
's2':'third',
's3':{'s31':True, 's32':None, 's33':(1, 64)}
})
A.set_val({'s1':-5000,
's2':'third',
's3':{'s31':True, 's32':None, 's33':(1, 64), 's34':False},
's4':None,
's5':('s52', True)
})
if print_info: print('testing SEQUENCE OF definition')
A = inline('''
A ::= SEQUENCE (SIZE(1..5, ...)) OF INTEGER (0..MAX)
''')
A.set_val([1, 2, 5, 41, 566321564])
A = inline('''
A ::= SEQUENCE (SIZE(1..3, ...)) OF OCTET STRING (SIZE(0..10, ...))
''')
A.set_val(['a', 'abcdef', 'abcdef'*50])
if print_info: print('testing CLASS definition')
C3 = inline('''
C3 ::= INTEGER
''')
C3.set_val(230000)
A = inline('''
A ::= CLASS {
&c1 INTEGER UNIQUE,
&c2 ENUMERATED {first},
&C3,
&c4 INTEGER } WITH SYNTAX {
IDENT &c1 PLACE &c2 TYPE &C3 VALUE &c4 }
''')
A.set_val({'c1':10,
'c2':'first',
'C3':('C3', 23000),
'c4':1
})
def test_per_choice(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
ASN1.ASN1Obj.CODEC = PER
#
PER._REPR_INT = 'bin'
PER._REPR_ENUM = 'bin'
PER._SAFE = True
#
PER.VARIANT = 'A'
if print_info: print('testing BIT STRING and CHOICE encoding /decoding (PER aligned)')
PER.VARIANT = 'A'
a = inline('''
A ::= CHOICE {
a1 BIT STRING (SIZE(4..8)),
a2 BIT STRING (SIZE(5..10, ...)),
...,
a3 BIT STRING,
a4 BIT STRING (SIZE(4..8, ...))
}
''')
b = a.clone()
#
a.encode(('a1', (0b111000, 6)))
#print('a1 (0b111000): %s' % a._msg.show())
assert(a._msg.__hex__() == '10e0')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b10101, 5)))
#print('a2 (0b10101): %s' % a._msg.show())
assert(a._msg.__hex__() == '40a8')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b111111111111111111111, 21)))
#print('a2 (0x1fffff): %s' % a._msg.show())
assert(a._msg.__hex__() == '6015fffff8')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (1, 1)))
#print('a3 (0b1): %s' % a._msg.show())
assert(a._msg.__hex__() == '80020180')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (0x617a6572747975696f70617a6572747975696f70, 160)))
#print('a3 (azertyuiopazertyuiop): %s' % a._msg.show())
assert(a._msg.__hex__() == '801680a0617a6572747975696f70617a6572747975696f70')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (0, 0)))
#print('a4 (0): %s' % a._msg.show())
assert(a._msg.__hex__() == '81028000')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (0x4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141, 4000)))
#print('a5 (500*"A"): %s' % a._msg.show())
assert(str(a) == '\x81\x81\xf7\x80\x8f\xa0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
if print_info: print('testing BIT STRING and CHOICE encoding / decoding (PER unaligned)')
PER.VARIANT = 'U'
#
a.encode(('a1', (0b111000, 6)))
#print('a1 (0b111000): %s' % a._msg.show())
assert(a._msg.__bin__() == '00010111000')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b10101, 5)))
#print('a2 (0b10101): %s' % a._msg.show())
assert(a._msg.__bin__() == '01000010101')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b111111111111111111111, 21)))
#print('a2 (0x1fffff): %s' % a._msg.show())
assert(a._msg.__bin__() == '01100010101111111111111111111111')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (1, 1)))
#print('a3 (0b1): %s' % a._msg.show())
assert(a._msg.__bin__() == '10000000000000100000000110000000')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (0x617a6572747975696f70617a6572747975696f70, 160)))
#print('a3 (azertyuiopazertyuiop): %s' % a._msg.show())
assert(a._msg.__hex__() == '801680a0617a6572747975696f70617a6572747975696f70')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (0, 0)))
#print('a4 (0): %s' % a._msg.show())
assert(a.__bin__() == '10000001000000101000000000000000')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (0x4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141, 4000)))
#print('a5 (500*"A"): %s' % a._msg.show())
assert(a.__hex__() == '8181f7c7d020a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a080')
b.decode( str(a) )
assert(a._msg.__bin__() == b._msg.__bin__() and a() == b())
def test_per_integer(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
ASN1.ASN1Obj.CODEC = PER
#
PER._REPR_INT = 'bin'
PER._REPR_ENUM = 'bin'
#
PER.VARIANT = 'A'
PER._SAFE = True
if print_info: print('testing unconstrained INTEGER encoding / decoding (PER)')
i1 = inline('I1 ::= INTEGER')
i1.encode(4096)
#print('i1:\n%s' % i1._msg.show())
assert(str(i1) == '\x02\x10\x00')
i1d = inline('I1D ::= INTEGER')
buf = i1d.decode(str(i1))
assert(str(i1d) == str(i1) and i1d() == i1())
i2 = inline('I2 ::= INTEGER (MIN..65535)')
i2.encode(127)
#print('i2:\n%s' % i2._msg.show())
assert(str(i2) == '\x01\x7f')
i2d = inline('I2D ::= INTEGER (MIN..65535)')
buf = i2d.decode(str(i2))
assert(str(i2d) == str(i2) and i2d() == i2())
i3 = inline('I3 ::= INTEGER (MIN..65535)')
i3.encode(-128)
#print('i3:\n%s' % i3._msg.show())
assert(str(i3) == '\x01\x80')
i3d = inline('I3D ::= INTEGER (MIN..65535)')
buf = i3d.decode(str(i3))
assert(str(i3d) == str(i3) and i3d() == i3())
i4 = inline('I4 ::= INTEGER (MIN..65535)')
i4.encode(128)
#print('i4:\n%s' % i4._msg.show())
assert(str(i4) == '\x02\x00\x80')
i4d = inline('I4D ::= INTEGER (MIN..65535)')
buf = i4d.decode(str(i4))
assert(str(i4d) == str(i4) and i4d() == i4())
#return i1, i2, i3, i4
if print_info: print('testing semi-constrained INTEGER encoding / decoding (PER)')
i5 = inline('I5 ::= INTEGER (-1..MAX)')
i5.encode(4096)
#print('i5: %s' % i5._msg.show())
assert(str(i5) == '\x02\x10\x01')
i5d = inline('I5D ::= INTEGER (-1..MAX)')
buf = i5d.decode(str(i5))
assert(str(i5d) == str(i5) and i5d() == i5())
i6 = inline('I6 ::= INTEGER (1..MAX)')
i6.encode(127)
#print('i6: %s' % i6._msg.show())
assert(str(i6) == '\x01~')
i6d = inline('I6D ::= INTEGER (1..MAX)')
buf = i6d.decode(str(i6))
assert(str(i6d) == str(i6) and i6d() == i6())
i7 = inline('I7 ::= INTEGER (0..MAX)')
i7.encode(128)
#print('i7: %s' % i7._msg.show())
assert(str(i7) == '\x01\x80')
i7d = inline('I7D ::= INTEGER (0..MAX)')
buf = i7d.decode(str(i7))
assert(str(i7d) == str(i7) and i7d() == i7())
#return i1, i2, i3, i4, i5, i6, i7
if print_info: print('testing constrained INTEGER encoding / decoding (PER aligned / unaligned)')
i8 = inline('I8 ::= INTEGER(3..6)')
i8.encode(3)
assert(i8._msg.__bin__() == '00')
i8d = inline('I8D ::= INTEGER(3..6)')
buf = i8d.decode(str(i8))
assert(str(i8d) == str(i8) and i8d() == i8())
i8.encode(4)
assert(i8._msg.__bin__() == '01')
buf = i8d.decode(str(i8))
assert(str(i8d) == str(i8) and i8d() == i8())
i8.encode(5)
assert(i8._msg.__bin__() == '10')
buf = i8d.decode(str(i8))
assert(str(i8d) == str(i8) and i8d() == i8())
i8.encode(6)
assert(i8._msg.__bin__() == '11')
buf = i8d.decode(str(i8))
assert(str(i8d) == str(i8) and i8d() == i8())
#print('i8 (6): %s' % i8._msg.show())
i9 = inline('I9 ::= INTEGER (4000..4254)')
i9.encode(4002)
assert(str(i9) == '\x02')
i9d = inline('I9D ::= INTEGER (4000..4254)')
buf = i9d.decode(str(i9))
assert(str(i9d) == str(i9) and i9d() == i9())
i9.encode(4006)
assert(str(i9) == '\x06')
buf = i9d.decode(str(i9))
assert(str(i9d) == str(i9) and i9d() == i9())
#print('i9 (4006): %s' % i9._msg.show())
i10 = inline('I10 ::= INTEGER (4000..4255)')
i10.encode(4002)
assert(str(i10) == '\x02')
i10d = inline('I10D ::= INTEGER (4000..4255)')
buf = i10d.decode(str(i10))
assert(str(i10d) == str(i10) and i10d() == i10())
i10.encode(4006)
assert(str(i10) == '\x06')
buf = i10d.decode(str(i10))
assert(str(i10d) == str(i10) and i10d() == i10())
#print('i10 (4006): %s' % i10._msg.show())
i11 = inline('I11 ::= INTEGER (0..32000)')
i11.encode(0)
assert(str(i11) == '\0\0')
i11d = inline('I11D ::= INTEGER (0..32000)')
buf = i11d.decode(str(i11))
assert(str(i11d) == str(i11) and i11d() == i11())
i11.encode(31000)
assert(str(i11) == '\x79\x18')
buf = i11d.decode(str(i11))
assert(str(i11d) == str(i11) and i11d() == i11())
#print('i11 (31000): %s' % i11._msg.show())
i12 = inline('I12 ::= INTEGER (1..65538)')
i12.encode(1)
assert(str(i12) == '\0\0')
i12d = inline('I12D ::= INTEGER (1..65538)')
buf = i12d.decode(str(i12))
assert(str(i12d) == str(i12) and i12d() == i12())
i12.encode(257)
assert(str(i12) == '@\x01\x00')
buf = i12d.decode(str(i12))
assert(str(i12d) == str(i12) and i12d() == i12())
i12.encode(65538)
assert(str(i12) == '\x80\x01\x00\x01')
buf = i12d.decode(str(i12))
assert(str(i12d) == str(i12) and i12d() == i12())
#print('i12 (65538 - aligned): %s' % i12._msg.show())
PER.VARIANT = 'U'
i12.encode(1)
assert(i12._msg.__bin__() == '00000000000000000')
buf = i12d.decode(str(i12))
assert(i12d() == i12())
i12.encode(257)
assert(i12._msg.__bin__() == '00000000100000000')
buf = i12d.decode(str(i12))
assert(i12d() == i12())
i12.encode(65538)
assert(i12._msg.__bin__() == '10000000000000001')
buf = i12d.decode(str(i12))
assert(i12d() == i12())
#print('i12 (65538 - unaligned): %s' % i12._msg.show())
#return i8, i9, i10, i11, i12
PER.VARIANT = 'A'
if print_info: print('testing extended INTEGER encoding / decoding (PER aligned / unaligned)')
i13 = inline('I13 ::= INTEGER(MIN..65535, ...)')
i13.encode(127)
assert(str(i13) == '\x00\x01\x7f')
i13d = inline('I13D ::= INTEGER(MIN..65535, ...)')
buf = i13d.decode(str(i13))
assert(str(i13d) == str(i13) and i13d() == i13())
i13.encode(65536)
assert(str(i13) == '\x80\x03\x01\x00\x00')
buf = i13d.decode(str(i13))
assert(str(i13d) == str(i13) and i13d() == i13())
#print('i13 (65536): %s' % i13._msg.show())
i14 = inline('I14 ::= INTEGER (-1..MAX, ...)')
i14.encode(4096)
assert(str(i14) == '\x00\x02\x10\x01')
i14d = inline('I14D ::= INTEGER (-1..MAX, ...)')
buf = i14d.decode(str(i14))
assert(str(i14d) == str(i14) and i14d() == i14())
i14.encode(-8)
assert(str(i14) == '\x80\x01\xf8')
buf = i14d.decode(str(i14))
assert(str(i14d) == str(i14) and i14d() == i14())
#print('i14 (-8): %s' % i14._msg.show())
i15 = inline('I15 ::= INTEGER (3..6, ...)')
i15.encode(4)
assert(i15._msg.__bin__() == '001')
i15d = inline('I15D ::= INTEGER (3..6, ...)')
buf = i15d.decode(str(i15))
assert(str(i15d) == str(i15) and i15d() == i15())
i15.encode(8)
assert(str(i15) == '\x80\x01\x08')
buf = i15d.decode(str(i15))
assert(str(i15d) == str(i15) and i15d() == i15())
#print('i15 (8): %s' % i15._msg.show())
i16 = inline('I16 ::= INTEGER (1..65538, ...)')
i16.encode(257)
assert(str(i16) == ' \x01\x00')
i16d = inline('I16D ::= INTEGER (1..65538, ...)')
buf = i16d.decode(str(i16))
assert(str(i16d) == str(i16) and i16d() == i16())
i16.encode(65539)
assert(str(i16) == '\x80\x03\x01\x00\x03')
buf = i16d.decode(str(i16))
assert(str(i16d) == str(i16) and i16d() == i16())
#print('i16 (65539 - aligned): %s' % i16._msg.show())
#
PER.VARIANT = 'U'
i16.encode(257)
assert(i16._msg.__bin__() == '000000000100000000')
buf = i16d.decode(str(i16))
assert(i16d() == i16())
i16.encode(65539)
assert(i16._msg.__bin__() == '100000011000000010000000000000011')
buf = i16d.decode(str(i16))
assert(i16d() == i16())
#print('i16 (65539 - unaligned): %s' % i16._msg.show())
#return i13, i14, i15, i16
PER.VARIANT = 'A'
def test_per_sequence(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
ASN1.ASN1Obj.CODEC = PER
#
PER._REPR_INT = 'bin'
PER._REPR_ENUM = 'bin'
PER._SAFE = True
#
PER.VARIANT = 'A'
if print_info:
print(
'testing OCTET STRING and SEQUENCE encoding / decoding (PER aligned)'
)
PER.VARIANT = 'A'
a = inline('''
A ::= SEQUENCE {
s1 INTEGER (1..50, ...),
s2 ENUMERATED {first, second, third},
s3 BOOLEAN OPTIONAL,
s4 INTEGER (-10..20) DEFAULT 5,
s5 OCTET STRING (SIZE(2..10, ...)),
...,
s8 INTEGER,
s9 BOOLEAN
}
''')
b = a.clone()
a.encode({'s1': 2, 's2': 'second', 's3': True, 's4': 2, 's5': 'abcdef'})
#print('a (2, second, True, 2, abcdef): %s' % a._msg.show())
assert (a._msg.__hex__() == '605b08616263646566')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1': 2, 's2': 'second', 's5': 'abcdef'})
#print('a (2, second, abcdef): %s' % a._msg.show())
assert (a._msg.__hex__() == '005200616263646566')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1': 2, 's2': 'second', 's5': 'a', 's8': 500000})
#print('a (2, second, a, 500000): %s' % a._msg.show())
assert (a._msg.__hex__() == '805801610300040307a120')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({
's1': 200,
's2': 'third',
's3': False,
's5': '',
's8': 5000000,
's9': True
})
#print('a (200, third, False, , 5000000, True): %s' % a._msg.show())
assert (a._msg.__hex__() == 'd00200c89000038004034c4b400180')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({
's1': 200,
's2': 'third',
's3': False,
's5': 300 * 'A',
's8': -10,
's9': True
})
#print('a (200, third, False, , 300*A, -10, True): %s' % a.show())
assert (
a._msg.__hex__() ==
'd00200c890812c41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414103800201f60180'
)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
if print_info:
print('testing OCTET STRING and SEQUENCE encoding (PER unaligned)')
PER.VARIANT = 'U'
a.encode({'s1': 2, 's2': 'second', 's3': True, 's4': 2, 's5': 'abcdef'})
#print('a (2, second, True, 2, abcdef): %s' % a._msg.show())
assert (
a._msg.__bin__() ==
'01100000010110110000100011000010110001001100011011001000110010101100110'
)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1': 2, 's2': 'second', 's5': 'abcdef'})
#print('a (2, second, abcdef): %s' % a._msg.show())
assert (a._msg.__bin__(
) == '00000000010100100011000010110001001100011011001000110010101100110')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({'s1': 2, 's2': 'second', 's5': 'a', 's8': 500000})
#print('a (2, second, a, 500000): %s' % a._msg.show())
assert (
a._msg.__bin__() ==
'100000000101100000001011000010000001100000010000000011000001111010000100100000'
)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({
's1': 200,
's2': 'third',
's3': False,
's5': '',
's8': 5000000,
's9': True
})
#print('a (200, third, False, , 5000000, True): %s' % a._msg.show())
assert (
a._msg.__bin__() ==
'110100000010000000001100100010010000000000000011100000100000000110100110001001011010000000000000110000000'
)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode({
's1': 200,
's2': 'third',
's3': False,
's5': 300 * 'A',
's8': -10,
's9': True
})
#print('a (200, third, False, , 300*A, -10, True): %s' % a._msg.show())
assert (
a._msg.__hex__() ==
'd0200c89812c414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141038100fb00c00'
)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
PER.VARIANT = 'A'
a = inline('''
A ::= SEQUENCE {
s1 INTEGER {first(1), second(2)} (1..50, ...),
s2 ENUMERATED {first, second, third},
s3 SEQUENCE { s31 BOOLEAN,
s32 NULL,
s33 BIT STRING (SIZE(56..64)),
s34 BOOLEAN DEFAULT FALSE},
...,
s4 NULL OPTIONAL,
s5 CHOICE { s51 INTEGER (-20..50),
s52 BOOLEAN,
s53 NULL,
s54 BOOLEAN }
}
''')
b = a.clone()
a.encode({
's1': -5000,
's2': 'third',
's3': {
's31': True,
's32': None,
's33': (1, 64),
's34': False
},
's4': None,
's5': ('s52', True)
})
#print('a (-5000, third, {True, None, (1, 64), False}, None, (s52, True)): %s' % a._msg.show())
assert (a._msg.__hex__() == 'c002ec78980000000000000001038001000160')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
PER.VARIANT = 'U'
a.encode({
's1': -5000,
's2': 'third',
's3': {
's31': True,
's32': None,
's33': (1, 64),
's34': False
},
's4': None,
's5': ('s52', True)
})
#print('a (-5000, third, {True, None, (1, 64), False}, None, (s52, True)): %s' % a._msg.show())
assert (a._msg.__hex__() == 'c0bb1e26000000000000000040e020002c0'
and a._msg.bit_len() == 139)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
if print_info:
print('testing SEQUENCE OF encoding / decoding (PER aligned)')
PER.VARIANT = 'A'
a = inline('''
A ::= SEQUENCE (SIZE(2..10, ...)) OF OCTET STRING (SIZE(0..10, ...))
''')
b = a.clone()
a.encode(['abc', '', 5 * 'a', 11 * 'A', 25 * 'B'])
#print('a (abc, , 5*a, 11*A, 25*B): %s' % a._msg.show())
assert (
a._msg.__hex__() ==
'18c061626301406161616161800b4141414141414141414141801942424242424242424242424242424242424242424242424242'
)
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
a.encode([13 * 'XY'])
#print('a (13*XY): %s' % a._msg.show())
assert (a._msg.__hex__() ==
'8001801a5859585958595859585958595859585958595859585958595859')
b.decode(str(a))
assert (a._msg.__hex__() == b._msg.__hex__() and a() == b())
#
a = inline('''
A ::= SEQUENCE SIZE(2..10, ...) OF INTEGER (0..300)
''')
b = a.clone()
a.encode(range(300))
assert (
a.__hex__() ==
'80812c0000000100020003000400050006000700080009000a000b000c000d000e000f0010001100120013001400150016001700180019001a001b001c001d001e001f0020002100220023002400250026002700280029002a002b002c002d002e002f0030003100320033003400350036003700380039003a003b003c003d003e003f0040004100420043004400450046004700480049004a004b004c004d004e004f0050005100520053005400550056005700580059005a005b005c005d005e005f0060006100620063006400650066006700680069006a006b006c006d006e006f0070007100720073007400750076007700780079007a007b007c007d007e007f0080008100820083008400850086008700880089008a008b008c008d008e008f0090009100920093009400950096009700980099009a009b009c009d009e009f00a000a100a200a300a400a500a600a700a800a900aa00ab00ac00ad00ae00af00b000b100b200b300b400b500b600b700b800b900ba00bb00bc00bd00be00bf00c000c100c200c300c400c500c600c700c800c900ca00cb00cc00cd00ce00cf00d000d100d200d300d400d500d600d700d800d900da00db00dc00dd00de00df00e000e100e200e300e400e500e600e700e800e900ea00eb00ec00ed00ee00ef00f000f100f200f300f400f500f600f700f800f900fa00fb00fc00fd00fe00ff0100010101020103010401050106010701080109010a010b010c010d010e010f0110011101120113011401150116011701180119011a011b011c011d011e011f0120012101220123012401250126012701280129012a012b'
)
b.decode(str(a))
assert (a() == b())
if print_info:
print('testing SEQUENCE OF encoding / decoding (PER unaligned)')
PER.VARIANT = 'U'
a = inline('''
A ::= SEQUENCE (SIZE(2..10, ...)) OF OCTET STRING (SIZE(0..10, ...))
''')
b = a.clone()
a.encode(['abc', '', 5 * 'a', 11 * 'A', 25 * 'B'])
#print('a (abc, , 5*a, 11*A, 25*B): %s' % a._msg.show())
assert (
a._msg.__hex__() ==
'18d85898c05616161616185a0a0a0a0a0a0a0a0a0a0a0c6509090909090909090909090909090909090909090909090908'
and a._msg.bit_len() == 390)
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode([13 * 'XY'])
#print('a (13*XY): %s' % a._msg.show())
assert (a._msg.__hex__()
== '80c696165616561656165616561656165616561656165616561656164'
and a._msg.bit_len() == 226)
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a = inline('''
A ::= SEQUENCE SIZE(2..10, ...) OF INTEGER (0..300)
''')
b = a.clone()
a.encode(range(300))
assert (
a.__hex__() ==
'c0960000202018100a0603820120a058301a0e078402212098502a160b860321a0d8703a1e0f8804222118904a26138a0522a158b05a2e178c06232198d06a361b8e0723a1d8f07a3e1f9008242219108a4623920924a259309a4e27940a25229950aa562b960b25a2d970ba5e2f980c26231990ca66339a0d26a359b0da6e379c0e272399d0ea763b9e0f27a3d9f0fa7e3fa01028241a110a8643a21128a45a311a8e47a41229249a512a964ba61329a4da713a9e4fa8142a251a914aa653aa152aa55ab15aae57ac162b259ad16ab65bae172ba5daf17abe5fb0182c261b118ac663b2192ca65b319ace67b41a2d269b51aad66bb61b2da6db71bade6fb81c2e271b91cae673ba1d2ea75bb1daee77bc1e2f279bd1eaf67bbe1f2fa7dbf1fafe7fc02030281c120b0683c22130a85c321b0e87c42231289c522b168bc62331a8dc723b1e8fc82432291c924b2693ca2532a958'
and a._msg.bit_len() == 2717)
b.decode(str(a))
assert (a() == b())
def test_per_choice(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
ASN1.ASN1Obj.CODEC = PER
#
PER._REPR_INT = 'bin'
PER._REPR_ENUM = 'bin'
PER._SAFE = True
#
PER.VARIANT = 'A'
if print_info:
print('testing BIT STRING and CHOICE encoding /decoding (PER aligned)')
PER.VARIANT = 'A'
a = inline('''
A ::= CHOICE {
a1 BIT STRING (SIZE(4..8)),
a2 BIT STRING (SIZE(5..10, ...)),
...,
a3 BIT STRING,
a4 BIT STRING (SIZE(4..8, ...))
}
''')
b = a.clone()
#
a.encode(('a1', (0b111000, 6)))
#print('a1 (0b111000): %s' % a._msg.show())
assert (a._msg.__hex__() == '10e0')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b10101, 5)))
#print('a2 (0b10101): %s' % a._msg.show())
assert (a._msg.__hex__() == '40a8')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b111111111111111111111, 21)))
#print('a2 (0x1fffff): %s' % a._msg.show())
assert (a._msg.__hex__() == '6015fffff8')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (1, 1)))
#print('a3 (0b1): %s' % a._msg.show())
assert (a._msg.__hex__() == '80020180')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (0x617a6572747975696f70617a6572747975696f70, 160)))
#print('a3 (azertyuiopazertyuiop): %s' % a._msg.show())
assert (
a._msg.__hex__() == '801680a0617a6572747975696f70617a6572747975696f70')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (0, 0)))
#print('a4 (0): %s' % a._msg.show())
assert (a._msg.__hex__() == '81028000')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (
0x4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141,
4000)))
#print('a5 (500*"A"): %s' % a._msg.show())
assert (
str(a) ==
'\x81\x81\xf7\x80\x8f\xa0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
)
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
if print_info:
print(
'testing BIT STRING and CHOICE encoding / decoding (PER unaligned)'
)
PER.VARIANT = 'U'
#
a.encode(('a1', (0b111000, 6)))
#print('a1 (0b111000): %s' % a._msg.show())
assert (a._msg.__bin__() == '00010111000')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b10101, 5)))
#print('a2 (0b10101): %s' % a._msg.show())
assert (a._msg.__bin__() == '01000010101')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a2', (0b111111111111111111111, 21)))
#print('a2 (0x1fffff): %s' % a._msg.show())
assert (a._msg.__bin__() == '01100010101111111111111111111111')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (1, 1)))
#print('a3 (0b1): %s' % a._msg.show())
assert (a._msg.__bin__() == '10000000000000100000000110000000')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a3', (0x617a6572747975696f70617a6572747975696f70, 160)))
#print('a3 (azertyuiopazertyuiop): %s' % a._msg.show())
assert (
a._msg.__hex__() == '801680a0617a6572747975696f70617a6572747975696f70')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (0, 0)))
#print('a4 (0): %s' % a._msg.show())
assert (a.__bin__() == '10000001000000101000000000000000')
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
a.encode(('a4', (
0x4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141,
4000)))
#print('a5 (500*"A"): %s' % a._msg.show())
assert (
a.__hex__() ==
'8181f7c7d020a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a080'
)
b.decode(str(a))
assert (a._msg.__bin__() == b._msg.__bin__() and a() == b())
def test_def(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
MODULE_OPT.TAG = TAG_AUTO
if print_info: print('testing NULL definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_NULL)
A.set_val(None)
if print_info: print('testing BOOLEAN definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_BOOL)
A.set_val(False)
A.set_val(True)
if print_info: print('testing INTEGER definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_INTEGER)
A.set_val(0)
A.set_val(-999999999999999999999999999)
A.set_val(111999999999999999999999999999111)
if print_info: print('testing ENUMERATED definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_ENUM)
A._cont = OD([('un', 1), ('deux', 2), ('trois', 3)])
A.set_val('un') # parce qu'un tien vaut mieux que deux tu l'auras
if print_info: print('testing BIT STRING definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_BIT_STR)
A.set_val((0b11001100111000, 16))
A.parse_value("'0011001100111000'B")
A.parse_value("'3338'H")
if print_info: print('testing OCTET STRING definition')
A = ASN1.ASN1Obj(name='A', type=TYPE_OCTET_STR)
A.set_val('la grande truite')
A.parse_value("'11001100111000'B")
A.parse_value("'3338'H")
if print_info: print('testing CHOICE definition')
A = inline('''
A ::= CHOICE {
a1 BOOLEAN,
a2 INTEGER (0..20),
a3 NULL,
a4 INTEGER(MIN..100, ...),
...,
a5 BIT STRING (SIZE(0..80))
}''')
A.set_val(('a1', True))
A.set_val(('a2', 12))
A.set_val(('a3', None))
A.set_val(('a4', -50000000))
A.set_val(('a5', (1000000000000000000001, 70)))
A = inline('''
A ::= CHOICE {
c1 INTEGER {first(1), second(2)} (1..50, ...),
c2 ENUMERATED {first, second, third, ..., fourth},
c3 BIT STRING {first-bit(1), second-bit(2)} (SIZE(8..16, ...)),
c4 OCTET STRING (SIZE(10..20)),
c5 CHOICE { c51 INTEGER (-20..50),
c52 BOOLEAN,
c53 NULL,
c54 BOOLEAN },
...,
c6 OBJECT IDENTIFIER,
c7 BOOLEAN
}
''')
A.set_val(('c1', 500))
A.set_val(('c2', 'fourth'))
A.set_val(('c3', (0b10100000, 12)))
A.set_val(('c4', 'abcdefghijklmn'))
A.set_val(('c5', ('c54', True)))
A.set_val(('c6', (1, 2, 3)))
A.set_val(('c7', False))
if print_info: print('testing SEQUENCE definition')
A = inline('''
A ::= SEQUENCE {
s1 INTEGER {first(1), second(2)} (1..50, ...),
s2 ENUMERATED {first, second, third},
s3 SEQUENCE { s31 BOOLEAN,
s32 NULL,
s33 BIT STRING (SIZE(56..64)),
s34 BOOLEAN DEFAULT FALSE},
...,
s4 NULL OPTIONAL,
s5 CHOICE { s51 INTEGER (-20..50),
s52 BOOLEAN,
s53 NULL,
s54 BOOLEAN }
}
''')
A.set_val({
's1': 50,
's2': 'third',
's3': {
's31': True,
's32': None,
's33': (1, 64)
}
})
A.set_val({
's1': -5000,
's2': 'third',
's3': {
's31': True,
's32': None,
's33': (1, 64),
's34': False
},
's4': None,
's5': ('s52', True)
})
if print_info: print('testing SEQUENCE OF definition')
A = inline('''
A ::= SEQUENCE (SIZE(1..5, ...)) OF INTEGER (0..MAX)
''')
A.set_val([1, 2, 5, 41, 566321564])
A = inline('''
A ::= SEQUENCE (SIZE(1..3, ...)) OF OCTET STRING (SIZE(0..10, ...))
''')
A.set_val(['a', 'abcdef', 'abcdef' * 50])
if print_info: print('testing CLASS definition')
C3 = inline('''
C3 ::= INTEGER
''')
C3.set_val(230000)
A = inline('''
A ::= CLASS {
&c1 INTEGER UNIQUE,
&c2 ENUMERATED {first},
&C3,
&c4 INTEGER } WITH SYNTAX {
IDENT &c1 PLACE &c2 TYPE &C3 VALUE &c4 }
''')
A.set_val({'c1': 10, 'c2': 'first', 'C3': ('C3', 23000), 'c4': 1})
def test_per_integer(print_info=True):
ASN1.ASN1Obj._SAFE = True
ASN1.ASN1Obj._RET_STRUCT = True
ASN1.ASN1Obj.CODEC = PER
#
PER._REPR_INT = 'bin'
PER._REPR_ENUM = 'bin'
#
PER.VARIANT = 'A'
PER._SAFE = True
if print_info:
print('testing unconstrained INTEGER encoding / decoding (PER)')
i1 = inline('I1 ::= INTEGER')
i1.encode(4096)
#print('i1:\n%s' % i1._msg.show())
assert (str(i1) == '\x02\x10\x00')
i1d = inline('I1D ::= INTEGER')
buf = i1d.decode(str(i1))
assert (str(i1d) == str(i1) and i1d() == i1())
i2 = inline('I2 ::= INTEGER (MIN..65535)')
i2.encode(127)
#print('i2:\n%s' % i2._msg.show())
assert (str(i2) == '\x01\x7f')
i2d = inline('I2D ::= INTEGER (MIN..65535)')
buf = i2d.decode(str(i2))
assert (str(i2d) == str(i2) and i2d() == i2())
i3 = inline('I3 ::= INTEGER (MIN..65535)')
i3.encode(-128)
#print('i3:\n%s' % i3._msg.show())
assert (str(i3) == '\x01\x80')
i3d = inline('I3D ::= INTEGER (MIN..65535)')
buf = i3d.decode(str(i3))
assert (str(i3d) == str(i3) and i3d() == i3())
i4 = inline('I4 ::= INTEGER (MIN..65535)')
i4.encode(128)
#print('i4:\n%s' % i4._msg.show())
assert (str(i4) == '\x02\x00\x80')
i4d = inline('I4D ::= INTEGER (MIN..65535)')
buf = i4d.decode(str(i4))
assert (str(i4d) == str(i4) and i4d() == i4())
#return i1, i2, i3, i4
if print_info:
print('testing semi-constrained INTEGER encoding / decoding (PER)')
i5 = inline('I5 ::= INTEGER (-1..MAX)')
i5.encode(4096)
#print('i5: %s' % i5._msg.show())
assert (str(i5) == '\x02\x10\x01')
i5d = inline('I5D ::= INTEGER (-1..MAX)')
buf = i5d.decode(str(i5))
assert (str(i5d) == str(i5) and i5d() == i5())
i6 = inline('I6 ::= INTEGER (1..MAX)')
i6.encode(127)
#print('i6: %s' % i6._msg.show())
assert (str(i6) == '\x01~')
i6d = inline('I6D ::= INTEGER (1..MAX)')
buf = i6d.decode(str(i6))
assert (str(i6d) == str(i6) and i6d() == i6())
i7 = inline('I7 ::= INTEGER (0..MAX)')
i7.encode(128)
#print('i7: %s' % i7._msg.show())
assert (str(i7) == '\x01\x80')
i7d = inline('I7D ::= INTEGER (0..MAX)')
buf = i7d.decode(str(i7))
assert (str(i7d) == str(i7) and i7d() == i7())
#return i1, i2, i3, i4, i5, i6, i7
if print_info:
print(
'testing constrained INTEGER encoding / decoding (PER aligned / unaligned)'
)
i8 = inline('I8 ::= INTEGER(3..6)')
i8.encode(3)
assert (i8._msg.__bin__() == '00')
i8d = inline('I8D ::= INTEGER(3..6)')
buf = i8d.decode(str(i8))
assert (str(i8d) == str(i8) and i8d() == i8())
i8.encode(4)
assert (i8._msg.__bin__() == '01')
buf = i8d.decode(str(i8))
assert (str(i8d) == str(i8) and i8d() == i8())
i8.encode(5)
assert (i8._msg.__bin__() == '10')
buf = i8d.decode(str(i8))
assert (str(i8d) == str(i8) and i8d() == i8())
i8.encode(6)
assert (i8._msg.__bin__() == '11')
buf = i8d.decode(str(i8))
assert (str(i8d) == str(i8) and i8d() == i8())
#print('i8 (6): %s' % i8._msg.show())
i9 = inline('I9 ::= INTEGER (4000..4254)')
i9.encode(4002)
assert (str(i9) == '\x02')
i9d = inline('I9D ::= INTEGER (4000..4254)')
buf = i9d.decode(str(i9))
assert (str(i9d) == str(i9) and i9d() == i9())
i9.encode(4006)
assert (str(i9) == '\x06')
buf = i9d.decode(str(i9))
assert (str(i9d) == str(i9) and i9d() == i9())
#print('i9 (4006): %s' % i9._msg.show())
i10 = inline('I10 ::= INTEGER (4000..4255)')
i10.encode(4002)
assert (str(i10) == '\x02')
i10d = inline('I10D ::= INTEGER (4000..4255)')
buf = i10d.decode(str(i10))
assert (str(i10d) == str(i10) and i10d() == i10())
i10.encode(4006)
assert (str(i10) == '\x06')
buf = i10d.decode(str(i10))
assert (str(i10d) == str(i10) and i10d() == i10())
#print('i10 (4006): %s' % i10._msg.show())
i11 = inline('I11 ::= INTEGER (0..32000)')
i11.encode(0)
assert (str(i11) == '\0\0')
i11d = inline('I11D ::= INTEGER (0..32000)')
buf = i11d.decode(str(i11))
assert (str(i11d) == str(i11) and i11d() == i11())
i11.encode(31000)
assert (str(i11) == '\x79\x18')
buf = i11d.decode(str(i11))
assert (str(i11d) == str(i11) and i11d() == i11())
#print('i11 (31000): %s' % i11._msg.show())
i12 = inline('I12 ::= INTEGER (1..65538)')
i12.encode(1)
assert (str(i12) == '\0\0')
i12d = inline('I12D ::= INTEGER (1..65538)')
buf = i12d.decode(str(i12))
assert (str(i12d) == str(i12) and i12d() == i12())
i12.encode(257)
assert (str(i12) == '@\x01\x00')
buf = i12d.decode(str(i12))
assert (str(i12d) == str(i12) and i12d() == i12())
i12.encode(65538)
assert (str(i12) == '\x80\x01\x00\x01')
buf = i12d.decode(str(i12))
assert (str(i12d) == str(i12) and i12d() == i12())
#print('i12 (65538 - aligned): %s' % i12._msg.show())
PER.VARIANT = 'U'
i12.encode(1)
assert (i12._msg.__bin__() == '00000000000000000')
buf = i12d.decode(str(i12))
assert (i12d() == i12())
i12.encode(257)
assert (i12._msg.__bin__() == '00000000100000000')
buf = i12d.decode(str(i12))
assert (i12d() == i12())
i12.encode(65538)
assert (i12._msg.__bin__() == '10000000000000001')
buf = i12d.decode(str(i12))
assert (i12d() == i12())
#print('i12 (65538 - unaligned): %s' % i12._msg.show())
#return i8, i9, i10, i11, i12
PER.VARIANT = 'A'
if print_info:
print(
'testing extended INTEGER encoding / decoding (PER aligned / unaligned)'
)
i13 = inline('I13 ::= INTEGER(MIN..65535, ...)')
i13.encode(127)
assert (str(i13) == '\x00\x01\x7f')
i13d = inline('I13D ::= INTEGER(MIN..65535, ...)')
buf = i13d.decode(str(i13))
assert (str(i13d) == str(i13) and i13d() == i13())
i13.encode(65536)
assert (str(i13) == '\x80\x03\x01\x00\x00')
buf = i13d.decode(str(i13))
assert (str(i13d) == str(i13) and i13d() == i13())
#print('i13 (65536): %s' % i13._msg.show())
i14 = inline('I14 ::= INTEGER (-1..MAX, ...)')
i14.encode(4096)
assert (str(i14) == '\x00\x02\x10\x01')
i14d = inline('I14D ::= INTEGER (-1..MAX, ...)')
buf = i14d.decode(str(i14))
assert (str(i14d) == str(i14) and i14d() == i14())
i14.encode(-8)
assert (str(i14) == '\x80\x01\xf8')
buf = i14d.decode(str(i14))
assert (str(i14d) == str(i14) and i14d() == i14())
#print('i14 (-8): %s' % i14._msg.show())
i15 = inline('I15 ::= INTEGER (3..6, ...)')
i15.encode(4)
assert (i15._msg.__bin__() == '001')
i15d = inline('I15D ::= INTEGER (3..6, ...)')
buf = i15d.decode(str(i15))
assert (str(i15d) == str(i15) and i15d() == i15())
i15.encode(8)
assert (str(i15) == '\x80\x01\x08')
buf = i15d.decode(str(i15))
assert (str(i15d) == str(i15) and i15d() == i15())
#print('i15 (8): %s' % i15._msg.show())
i16 = inline('I16 ::= INTEGER (1..65538, ...)')
i16.encode(257)
assert (str(i16) == ' \x01\x00')
i16d = inline('I16D ::= INTEGER (1..65538, ...)')
buf = i16d.decode(str(i16))
assert (str(i16d) == str(i16) and i16d() == i16())
i16.encode(65539)
assert (str(i16) == '\x80\x03\x01\x00\x03')
buf = i16d.decode(str(i16))
assert (str(i16d) == str(i16) and i16d() == i16())
#print('i16 (65539 - aligned): %s' % i16._msg.show())
#
PER.VARIANT = 'U'
i16.encode(257)
assert (i16._msg.__bin__() == '000000000100000000')
buf = i16d.decode(str(i16))
assert (i16d() == i16())
i16.encode(65539)
assert (i16._msg.__bin__() == '100000011000000010000000000000011')
buf = i16d.decode(str(i16))
assert (i16d() == i16())
#print('i16 (65539 - unaligned): %s' % i16._msg.show())
#return i13, i14, i15, i16
PER.VARIANT = 'A'
