Пример #1
0
 def __call__(self, value, defMode=1, maxChunkSize=0):
     debug.logger & debug.flagEncoder and debug.logger(
         'encoder called for type %s, value:\n%s' %
         (value.__class__.__name__, value.prettyPrint()))
     tagSet = value.getTagSet()
     if len(tagSet) > 1:
         concreteEncoder = explicitlyTaggedItemEncoder
     else:
         if value.typeId is not None and value.typeId in self.__typeMap:
             concreteEncoder = self.__typeMap[value.typeId]
         elif tagSet in self.__tagMap:
             concreteEncoder = self.__tagMap[tagSet]
         else:
             tagSet = value.baseTagSet
             if tagSet in self.__tagMap:
                 concreteEncoder = self.__tagMap[tagSet]
             else:
                 raise Error('No encoder for %s' % (value, ))
     debug.logger & debug.flagEncoder and debug.logger(
         'using value codec %s chosen by %r' %
         (concreteEncoder.__class__.__name__, tagSet))
     substrate = concreteEncoder.encode(self, value, defMode, maxChunkSize)
     debug.logger & debug.flagEncoder and debug.logger(
         'built %s octets of substrate: %s\nencoder completed' %
         (len(substrate), debug.hexdump(substrate)))
     return substrate
Пример #2
0
 def __call__(self, value, defMode=1, maxChunkSize=0):
     debug.logger & debug.flagEncoder and debug.logger('encoder called for type %s, value:\n%s' % (value.__class__.__name__, value.prettyPrint()))
     tagSet = value.getTagSet()
     if len(tagSet) > 1:
         concreteEncoder = explicitlyTaggedItemEncoder
     else:
         if value.typeId is not None and value.typeId in self.__typeMap:
             concreteEncoder = self.__typeMap[value.typeId]
         elif tagSet in self.__tagMap:
             concreteEncoder = self.__tagMap[tagSet]
         else:
             tagSet = value.baseTagSet
             if tagSet in self.__tagMap:
                 concreteEncoder = self.__tagMap[tagSet]
             else:
                 raise Error('No encoder for %s' % (value,))
     debug.logger & debug.flagEncoder and debug.logger('using value codec %s chosen by %r' % (concreteEncoder.__class__.__name__, tagSet))
     substrate = concreteEncoder.encode(
         self, value, defMode, maxChunkSize
         )
     debug.logger & debug.flagEncoder and debug.logger('built %s octets of substrate: %s\nencoder completed' % (len(substrate), debug.hexdump(substrate)))
     return substrate
Пример #3
0
 def __call__(self, substrate, asn1Spec=None, tagSet=None,
              length=None, state=stDecodeTag, recursiveFlag=1,
              substrateFun=None):
     if debug.logger & debug.flagDecoder:
         debug.logger('decoder called at scope %s with state %d, working with up to %d octets of substrate: %s' % (debug.scope, state, len(substrate), debug.hexdump(substrate)))
     fullSubstrate = substrate
     while state != stStop:
         if state == stDecodeTag:
             # Decode tag
             if not substrate:
                 raise error.SubstrateUnderrunError(
                     'Short octet stream on tag decoding'
                     )
             if not isOctetsType(substrate) and \
                not isinstance(substrate, univ.OctetString):
                 raise error.PyAsn1Error('Bad octet stream type')
             
             firstOctet = substrate[0]
             substrate = substrate[1:]
             if firstOctet in self.__tagCache:
                 lastTag = self.__tagCache[firstOctet]
             else:
                 t = oct2int(firstOctet)
                 tagClass = t&0xC0
                 tagFormat = t&0x20
                 tagId = t&0x1F
                 if tagId == 0x1F:
                     tagId = 0
                     while 1:
                         if not substrate:
                             raise error.SubstrateUnderrunError(
                                 'Short octet stream on long tag decoding'
                                 )
                         t = oct2int(substrate[0])
                         tagId = tagId << 7 | (t&0x7F)
                         substrate = substrate[1:]
                         if not t&0x80:
                             break
                 lastTag = tag.Tag(
                     tagClass=tagClass, tagFormat=tagFormat, tagId=tagId
                     )
                 if tagId < 31:
                     # cache short tags
                     self.__tagCache[firstOctet] = lastTag
             if tagSet is None:
                 if firstOctet in self.__tagSetCache:
                     tagSet = self.__tagSetCache[firstOctet]
                 else:
                     # base tag not recovered
                     tagSet = tag.TagSet((), lastTag)
                     if firstOctet in self.__tagCache:
                         self.__tagSetCache[firstOctet] = tagSet
             else:
                 tagSet = lastTag + tagSet
             state = stDecodeLength
             debug.logger and debug.logger & debug.flagDecoder and debug.logger('tag decoded into %r, decoding length' % tagSet)
         if state == stDecodeLength:
             # Decode length
             if not substrate:
                  raise error.SubstrateUnderrunError(
                      'Short octet stream on length decoding'
                      )
             firstOctet  = oct2int(substrate[0])
             if firstOctet == 128:
                 size = 1
                 length = -1
             elif firstOctet < 128:
                 length, size = firstOctet, 1
             else:
                 size = firstOctet & 0x7F
                 # encoded in size bytes
                 length = 0
                 lengthString = substrate[1:size+1]
                 # missing check on maximum size, which shouldn't be a
                 # problem, we can handle more than is possible
                 if len(lengthString) != size:
                     raise error.SubstrateUnderrunError(
                         '%s<%s at %s' %
                         (size, len(lengthString), tagSet)
                         )
                 for char in lengthString:
                     length = (length << 8) | oct2int(char)
                 size = size + 1
             substrate = substrate[size:]
             if length != -1 and len(substrate) < length:
                 raise error.SubstrateUnderrunError(
                     '%d-octet short' % (length - len(substrate))
                     )
             state = stGetValueDecoder
             debug.logger and debug.logger & debug.flagDecoder and debug.logger('value length decoded into %d, payload substrate is: %s' % (length, debug.hexdump(substrate[:length])))
         if state == stGetValueDecoder:
             if asn1Spec is None:
                 state = stGetValueDecoderByTag
             else:
                 state = stGetValueDecoderByAsn1Spec
         #
         # There're two ways of creating subtypes in ASN.1 what influences
         # decoder operation. These methods are:
         # 1) Either base types used in or no IMPLICIT tagging has been
         #    applied on subtyping.
         # 2) Subtype syntax drops base type information (by means of
         #    IMPLICIT tagging.
         # The first case allows for complete tag recovery from substrate
         # while the second one requires original ASN.1 type spec for
         # decoding.
         #
         # In either case a set of tags (tagSet) is coming from substrate
         # in an incremental, tag-by-tag fashion (this is the case of
         # EXPLICIT tag which is most basic). Outermost tag comes first
         # from the wire.
         #            
         if state == stGetValueDecoderByTag:
             if tagSet in self.__tagMap:
                 concreteDecoder = self.__tagMap[tagSet]
             else:
                 concreteDecoder = None
             if concreteDecoder:
                 state = stDecodeValue
             else:
                 _k = tagSet[:1]
                 if _k in self.__tagMap:
                     concreteDecoder = self.__tagMap[_k]
                 else:
                     concreteDecoder = None
                 if concreteDecoder:
                     state = stDecodeValue
                 else:
                     state = stTryAsExplicitTag
             if debug.logger and debug.logger & debug.flagDecoder:
                 debug.logger('codec %s chosen by a built-in type, decoding %s' % (concreteDecoder and concreteDecoder.__class__.__name__ or "<none>", state == stDecodeValue and 'value' or 'as explicit tag'))
                 debug.scope.push(concreteDecoder is None and '?' or concreteDecoder.protoComponent.__class__.__name__)
         if state == stGetValueDecoderByAsn1Spec:
             if isinstance(asn1Spec, (dict, tagmap.TagMap)):
                 if tagSet in asn1Spec:
                     __chosenSpec = asn1Spec[tagSet]
                 else:
                     __chosenSpec = None
                 if debug.logger and debug.logger & debug.flagDecoder:
                     debug.logger('candidate ASN.1 spec is a map of:')
                     for t, v in asn1Spec.getPosMap().items():
                         debug.logger('  %r -> %s' % (t, v.__class__.__name__))
                     if asn1Spec.getNegMap():
                         debug.logger('but neither of: ')
                         for i in asn1Spec.getNegMap().items():
                             debug.logger('  %r -> %s' % (t, v.__class__.__name__))
                     debug.logger('new candidate ASN.1 spec is %s, chosen by %r' % (__chosenSpec is None and '<none>' or __chosenSpec.__class__.__name__, tagSet))
             else:
                 __chosenSpec = asn1Spec
                 debug.logger and debug.logger & debug.flagDecoder and debug.logger('candidate ASN.1 spec is %s' % asn1Spec.__class__.__name__)
             if __chosenSpec is not None and (
                    tagSet == __chosenSpec.getTagSet() or \
                    tagSet in __chosenSpec.getTagMap()
                    ):
                 # use base type for codec lookup to recover untagged types
                 baseTagSet = __chosenSpec.baseTagSet
                 if __chosenSpec.typeId is not None and \
                        __chosenSpec.typeId in self.__typeMap:
                     # ambiguous type
                     concreteDecoder = self.__typeMap[__chosenSpec.typeId]
                     debug.logger and debug.logger & debug.flagDecoder and debug.logger('value decoder chosen for an ambiguous type by type ID %s' % (__chosenSpec.typeId,))
                 elif baseTagSet in self.__tagMap:
                     # base type or tagged subtype
                     concreteDecoder = self.__tagMap[baseTagSet]
                     debug.logger and debug.logger & debug.flagDecoder and debug.logger('value decoder chosen by base %r' % (baseTagSet,))
                 else:
                     concreteDecoder = None
                 if concreteDecoder:
                     asn1Spec = __chosenSpec
                     state = stDecodeValue
                 else:
                     state = stTryAsExplicitTag
             elif tagSet == self.__endOfOctetsTagSet:
                 concreteDecoder = self.__tagMap[tagSet]
                 state = stDecodeValue
                 debug.logger and debug.logger & debug.flagDecoder and debug.logger('end-of-octets found')
             else:
                 concreteDecoder = None
                 state = stTryAsExplicitTag
             if debug.logger and debug.logger & debug.flagDecoder:
                 debug.logger('codec %s chosen by ASN.1 spec, decoding %s' % (state == stDecodeValue and concreteDecoder.__class__.__name__ or "<none>", state == stDecodeValue and 'value' or 'as explicit tag'))
                 debug.scope.push(__chosenSpec is None and '?' or __chosenSpec.__class__.__name__)
         if state == stTryAsExplicitTag:
             if tagSet and \
                    tagSet[0][1] == tag.tagFormatConstructed and \
                    tagSet[0][0] != tag.tagClassUniversal:
                 # Assume explicit tagging
                 concreteDecoder = explicitTagDecoder
                 state = stDecodeValue
             else:                    
                 concreteDecoder = None
                 state = self.defaultErrorState
             debug.logger and debug.logger & debug.flagDecoder and debug.logger('codec %s chosen, decoding %s' % (concreteDecoder and concreteDecoder.__class__.__name__ or "<none>", state == stDecodeValue and 'value' or 'as failure'))
         if state == stDumpRawValue:
             concreteDecoder = self.defaultRawDecoder
             debug.logger and debug.logger & debug.flagDecoder and debug.logger('codec %s chosen, decoding value' % concreteDecoder.__class__.__name__)
             state = stDecodeValue
         if state == stDecodeValue:
             if recursiveFlag == 0 and not substrateFun: # legacy
                 substrateFun = lambda a,b,c: (a,b[:c])
             if length == -1:  # indef length
                 value, substrate = concreteDecoder.indefLenValueDecoder(
                     fullSubstrate, substrate, asn1Spec, tagSet, length,
                     stGetValueDecoder, self, substrateFun
                     )
             else:
                 value, substrate = concreteDecoder.valueDecoder(
                     fullSubstrate, substrate, asn1Spec, tagSet, length,
                     stGetValueDecoder, self, substrateFun
                     )
             state = stStop
             debug.logger and debug.logger & debug.flagDecoder and debug.logger('codec %s yields type %s, value:\n%s\n...remaining substrate is: %s' % (concreteDecoder.__class__.__name__, value.__class__.__name__, value.prettyPrint(), substrate and debug.hexdump(substrate) or '<none>'))
         if state == stErrorCondition:
             raise error.PyAsn1Error(
                 '%r not in asn1Spec: %r' % (tagSet, asn1Spec)
                 )
     if debug.logger and debug.logger & debug.flagDecoder:
         debug.scope.pop()
         debug.logger('decoder left scope %s, call completed' % debug.scope)
     return value, substrate