def testIndefModeChunkedSubst(self):
assert decoder.decode(
ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111,
120, 0, 0)),
substrateFun=lambda a, b, c: (b, str2octs(''))
) == (ints2octs(
(4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0)), str2octs(''))
def encode(self, encodeFun, value, defMode, maxChunkSize, ifNotEmpty=False):
substrate, isConstructed, isOctets = self.encodeValue(
encodeFun, value, defMode, maxChunkSize, ifNotEmpty=ifNotEmpty
)
if ifNotEmpty and not substrate:
return substrate
tagSet = value.tagSet
# tagged value?
if tagSet:
if not isConstructed: # primitive form implies definite mode
defMode = True
header = self.encodeTag(tagSet[-1], isConstructed)
header += self.encodeLength(len(substrate), defMode)
if isOctets:
substrate = ints2octs(header) + substrate
else:
substrate = ints2octs(header + substrate)
eoo = self._encodeEndOfOctets(encodeFun, defMode)
if eoo:
substrate += eoo
return substrate
def testSpec(self):
try:
decoder.decode(ints2octs((2, 1, 12)), asn1Spec=univ.Null()) == (12, null)
except PyAsn1Error:
pass
else:
assert 0, "wrong asn1Spec worked out"
assert decoder.decode(ints2octs((2, 1, 12)), asn1Spec=univ.Integer()) == (12, null)
def _bitsFilter(value):
# rfc1902.Bits does not really initialize from sequences
# Clean bits values
# .1.3.6.1.2.1.17.6.1.1.1.0 = BITS: 5B 00 00 00 [[...]1 3 4 6 7
match = re.match(r'^([0-9a-fA-F]{2}(\s+[0-9a-fA-F]{2})*)\s+\[', value)
if match:
return ints2octs([int(y, 16) for y in match.group(1).split(' ')])
return ints2octs([int(y, 16) for y in value.split(' ')])
def testDefModeChunkedSubst(self):
assert decoder.decode(
ints2octs(
(36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120)
),
substrateFun=lambda a, b, c: (b, c),
) == (
ints2octs((4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120)),
23,
)
def testWithOptionalAndDefaultedIndefModeSubst(self):
assert decoder.decode(
ints2octs(
(48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)
),
substrateFun=lambda a, b, c: (b, c),
) == (
ints2octs((5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)),
-1,
)
def encode(self, value, asn1Spec=None, encodeFun=None, **options):
if asn1Spec is None:
tagSet = value.tagSet
else:
tagSet = asn1Spec.tagSet
# untagged item?
if not tagSet:
substrate, isConstructed, isOctets = self.encodeValue(
value, asn1Spec, encodeFun, **options
)
return substrate
defMode = options.get('defMode', True)
for idx, singleTag in enumerate(tagSet.superTags):
defModeOverride = defMode
# base tag?
if not idx:
substrate, isConstructed, isOctets = self.encodeValue(
value, asn1Spec, encodeFun, **options
)
if not substrate and isConstructed and options.get('ifNotEmpty', False):
return substrate
# primitive form implies definite mode
if not isConstructed:
defModeOverride = True
header = self.encodeTag(singleTag, isConstructed)
header += self.encodeLength(len(substrate), defModeOverride)
if isOctets:
substrate = ints2octs(header) + substrate
if not defModeOverride:
substrate += self.eooOctetsSubstrate
else:
substrate = header + substrate
if not defModeOverride:
substrate += self.eooIntegerSubstrate
if not isOctets:
substrate = ints2octs(substrate)
return substrate
def testTaggedUndefLength(self):
s = self.s.subtype(
explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 4)
)
s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
assert encoder.encode(s, defMode=False, maxChunkSize=3) == ints2octs(
(164, 128, 36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0, 0, 0))
def testBin4(self):
# choose binEncBase automatically for all further Real (testBin[4-7])
binEncBase, encoder.typeMap[univ.Real.typeId].binEncBase = encoder.typeMap[univ.Real.typeId].binEncBase, None
assert encoder.encode(
univ.Real((1, 2, 0)) # check exponenta = 0
) == ints2octs((9, 3, 128, 0, 1))
encoder.typeMap[univ.Real.typeId].binEncBase = binEncBase
def testBin3(self):
# change binEncBase in the RealEncoder instance => for all further Real
binEncBase, encoder.typeMap[univ.Real.typeId].binEncBase = encoder.typeMap[univ.Real.typeId].binEncBase, 16
assert encoder.encode(
univ.Real((0.00390625, 2, 0)) # check encbase = 16
) == ints2octs((9, 3, 160, 254, 1))
encoder.typeMap[univ.Real.typeId].binEncBase = binEncBase
def testNoEooData(self):
try:
decoder.decode(ints2octs((0x23, 0x80, 0x00, 0x01, 0x00)))
except PyAsn1Error:
pass
else:
assert 0, 'end-of-contents octets accepted with unexpected data'
def testIndefModeChunked(self):
assert decoder.decode(
ints2octs(
(
36,
128,
4,
4,
81,
117,
105,
99,
4,
4,
107,
32,
98,
114,
4,
4,
111,
119,
110,
32,
4,
3,
102,
111,
120,
0,
0,
)
)
) == (str2octs("Quick brown fox"), null)
def testTagFormat(self):
try:
decoder.decode(ints2octs((33, 1, 1)))
except PyAsn1Error:
pass
else:
assert 0, 'wrong tagFormat worked out'
def testNoLongFormEoo(self):
try:
decoder.decode(ints2octs((0x23, 0x80, 0x00, 0x81, 0x00)))
except PyAsn1Error:
pass
else:
assert 0, 'end-of-contents octets accepted with invalid long-form length'
def testNoConstructedEoo(self):
try:
decoder.decode(ints2octs((0x23, 0x80, 0x20, 0x00)))
except PyAsn1Error:
pass
else:
assert 0, 'end-of-contents octets accepted with invalid constructed encoding'
def testUnexpectedEoo(self):
try:
decoder.decode(ints2octs((0, 0)))
except PyAsn1Error:
pass
else:
assert 0, 'end-of-contents octets accepted at top level'
def testDefiniteNoEoo(self):
try:
decoder.decode(ints2octs((0x23, 0x02, 0x00, 0x00)))
except PyAsn1Error:
pass
else:
assert 0, 'end-of-contents octets accepted inside definite-length encoding'
def testReservedLength(self):
try:
decoder.decode(ints2octs((6, 255, 0)))
except PyAsn1Error:
pass
else:
assert 0, 'reserved length tolarated'
def testShortEncoding(self):
try:
decoder.decode(ints2octs((9, 1, 131)))
except PyAsn1Error:
pass
else:
assert 0, 'accepted too-short real'
def testZeroLength(self):
try:
decoder.decode(ints2octs((6, 0, 0)))
except PyAsn1Error:
pass
else:
assert 0, 'zero length tolarated'
def testIndefiniteLength(self):
try:
decoder.decode(ints2octs((6, 128, 0)))
except PyAsn1Error:
pass
else:
assert 0, 'indefinite length tolarated'
def testTypeChecking(self):
try:
decoder.decode(ints2octs((35, 4, 2, 2, 42, 42)))
except PyAsn1Error:
pass
else:
assert 0, 'accepted mis-encoded bit-string constructed out of an integer'
def testBadSpec(self):
try:
decoder.decode(ints2octs((48, 2, 5, 0)), asn1Spec='not an Asn1Item')
except PyAsn1Error:
pass
else:
assert 0, 'Invalid asn1Spec accepted'
def testWithOptionalIndefModeChunked(self):
self.__initWithOptional()
assert decoder.decode(
ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0,
0, 0, 0)),
asn1Spec=self.s
) == (self.s, null)
def testLeading0x80Case4(self):
try:
decoder.decode(ints2octs((6, 2, 0x80, 0x7F)))
except PyAsn1Error:
pass
else:
assert 0, "Leading 0x80 tolarated"
def __init__(self, tagMap, typeMap={}):
self.__tagMap = tagMap
self.__typeMap = typeMap
# Tag & TagSet objects caches
self.__tagCache = {}
self.__tagSetCache = {}
self.__eooSentinel = ints2octs((0, 0))
def testLeading0x80Case1(self):
try:
decoder.decode(ints2octs((6, 5, 85, 4, 128, 129, 0)))
except PyAsn1Error:
pass
else:
assert 0, "Leading 0x80 tolarated"
def testIndefMode(self):
v, s = decoder.decode(
ints2octs(
(
101,
128,
36,
128,
4,
15,
81,
117,
105,
99,
107,
32,
98,
114,
111,
119,
110,
32,
102,
111,
120,
0,
0,
0,
0,
)
)
)
assert self.o.isSameTypeWith(v)
assert not s
def testLarge2(self):
assert decoder.decode(
ints2octs(
(
0x06,
0x13,
0x88,
0x37,
0x83,
0xC6,
0xDF,
0xD4,
0xCC,
0xB3,
0xFF,
0xFF,
0xFE,
0xF0,
0xB8,
0xD6,
0xB8,
0xCB,
0xE2,
0xB6,
0x47,
)
)
) == ((2, 999, 18446744073709551535184467440737095), null)
def testWithOptionalAndDefaultedDefModeChunked(self):
self.__initWithOptionalAndDefaulted()
assert decoder.decode(
ints2octs(
(48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1)),
asn1Spec=self.s
) == (self.s, null)
def testBin5(self): # case of 2 octs for exponenta and negative exponenta
assert decoder.decode( # (3, 2, -1020) encoded with base = 16
ints2octs((9, 4, 161, 255, 1, 3))) == (univ.Real(
(3, 2, -1020)), null)
def testDecoder(self):
assert decoder.decode(
ints2octs((28, 12, 0, 0, 0, 97, 0, 0, 0, 98, 0, 0, 0,
99))) == (char.UniversalString(
version_info[0] == 3 and 'abc'
or unicode('abc')), null)
def testMinusOne(self):
assert decoder.decode(ints2octs((2, 1, 255))) == (-1, null)
def testBin4(self): # check exponenta = 0
assert decoder.decode( # (1, 2, 0) encoded with base = 2
ints2octs((9, 3, 128, 0, 1))) == (univ.Real((1, 2, 0)), null)
def testMinusInf(self):
assert decoder.decode(ints2octs(
(9, 1, 65))) == (univ.Real('-inf'), null)
def testBin3(self): # check base = 16
assert decoder.decode( # (0.00390625, 2, 0) encoded with base = 16
ints2octs((9, 3, 160, 254, 1))) == (univ.Real((1, 2, -8)), null)
def testTaggedImIndefMode(self):
s = univ.Any('\004\003fox').subtype(
implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
assert decoder.decode(ints2octs((164, 128, 4, 3, 102, 111, 120, 0, 0)),
asn1Spec=s) == (s, null)
def testByUntaggedIndefMode(self):
assert decoder.decode(ints2octs((4, 3, 102, 111, 120)),
asn1Spec=self.s) == (univ.Any('\004\003fox'),
null)
def testPosLong(self):
assert decoder.decode(
ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255,
255))) == (0xffffffffffffffff, null)
def testExplicitTagUndefLength(self):
s = self.s.subtype(explicitTag=tag.Tag(tag.tagClassContext,
tag.tagFormatConstructed, 4))
s.setComponentByPosition(0, univ.Null(null))
assert decoder.decode(ints2octs((164, 128, 5, 0, 0, 0)),
asn1Spec=s) == (s, null)
def testEmpty(self):
assert decoder.decode(ints2octs((9, 0))) == (univ.Real(0.0), null)
def testWithoutSpec(self):
self.s.setComponentByPosition(0, univ.Null(null))
assert decoder.decode(ints2octs((5, 0))) == (self.s, null)
assert decoder.decode(ints2octs((5, 0))) == (univ.Null(null), null)
def testWithOptionalAndDefaultedIndefModeChunked(self):
self.__initWithOptionalAndDefaulted()
assert decoder.decode(ints2octs(
(48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32,
98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)),
asn1Spec=self.s) == (self.s, null)
def testUndefLength(self):
self.s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
assert decoder.decode(ints2octs((36, 128, 4, 3, 97, 98, 99, 4, 3, 100,
101, 102, 4, 2, 103, 104, 0, 0)),
asn1Spec=self.s) == (self.s, null)
def testWithDefaultedIndefModeChunked(self):
self.__initWithDefaulted()
assert decoder.decode(ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0)),
asn1Spec=self.s) == (self.s, null)
def testBySpec(self):
self.s.setComponentByPosition(0, univ.Null(null))
assert decoder.decode(ints2octs((5, 0)),
asn1Spec=self.s) == (self.s, null)
def testWithOptionalDefModeChunked(self):
self.__initWithOptional()
assert decoder.decode(ints2octs(
(48, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98,
114, 4, 3, 111, 119, 110)),
asn1Spec=self.s) == (self.s, null)
def testZeroLong(self):
assert decoder.decode(ints2octs((2, 1, 0))) == (0, null)
def testWithOptionaIndefMode(self):
self.__initWithOptional()
assert decoder.decode(ints2octs(
(48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98,
114, 111, 119, 110, 0, 0, 0, 0)),
asn1Spec=self.s) == (self.s, null)
def testWithDefaultedDefMode(self):
self.__initWithDefaulted()
assert decoder.decode(ints2octs((48, 5, 5, 0, 2, 1, 1)),
asn1Spec=self.s) == (self.s, null)
def testPosInt(self):
assert decoder.decode(ints2octs((2, 1, 12))) == (12, null)
def testNegInt(self):
assert decoder.decode(ints2octs((2, 1, 244))) == (-12, null)
def testWithOptionalAndDefaultedDefModeChunked(self):
assert decoder.decode(
ints2octs(
(48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32,
98, 114, 4, 3, 111, 119, 110, 2, 1, 1))) == (self.s, null)
def testIndefModeChunked(self):
self.__init()
assert decoder.decode(ints2octs((48, 128, 5, 0, 0, 0)),
asn1Spec=self.s) == (self.s, null)
def testDecoder(self):
assert decoder.decode(ints2octs(
(12, 3, 97, 98,
99))) == (char.UTF8String(version_info[0] == 3 and 'abc'
or unicode('abc')), null)
def testCache(self):
assert decoder.decode(ints2octs(
(0x1f, 2, 1, 0))) == decoder.decode(ints2octs((0x1f, 2, 1, 0)))
def testDecoder(self):
assert decoder.decode(ints2octs(
(30, 6, 0, 97, 0, 98, 0,
99))) == (char.BMPString(version_info[0] == 3 and 'abc'
or unicode('abc')), null)
def testWithOptionalAndDefaultedIndefMode(self):
assert decoder.decode(
ints2octs(
(48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98,
114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))) == (self.s, null)
def testByUntaggedSubst(self):
assert decoder.decode(ints2octs((4, 3, 102, 111, 120)),
asn1Spec=self.s,
substrateFun=lambda a, b, c:
(b, c)) == (ints2octs((4, 3, 102, 111, 120)), 5)
def testPlusInf(self):
assert decoder.decode(ints2octs(
(9, 1, 64))) == (univ.Real('inf'), null)
