我正在寻找解析asn.1规范文件并从中生成解码器的解决方案。
理想情况下，我希望使用Python模块，但如果没有可用的模块，我会使用C/C++库，并利用那里众多的解决方案将它们与Python接口。
过去我一直在使用pyasn1并手动构建一切，但已经变得难以控制。
我也粗略地看了libtasn1和asn1c。第一个无法解析最简单的文件。第二个有一个很好的解析器，但为解码生成C代码似乎太复杂；该解决方案对于简单的规范工作良好，但处理复杂的规范时却容易挂掉。
还有其他优秀的替代方案吗？
7个回答
13
我几年前写了这样的解析器。它为pyasn1库生成python类。我在ericsson文档中使用它来制作CDR的解析器。
我现在尝试在这里发布代码。
import sys
from pyparsing import *
OpenBracket = Regex("[({]").suppress()
CloseBracket = Regex("[)}]").suppress()
def Enclose(val):
return OpenBracket + val + CloseBracket
def SetDefType(typekw):
def f(a, b, c):
c["defType"] = typekw
return f
def NoDashes(a, b, c):
return c[0].replace("-", "_")
def DefineTypeDef(typekw, typename, typedef):
return typename.addParseAction(SetDefType(typekw)).setResultsName("definitionType") - \
Optional(Enclose(typedef).setResultsName("definition"))
SizeConstraintBodyOpt = Word(nums).setResultsName("minSize") - \
Optional(Suppress(Literal("..")) - Word(nums + "n").setResultsName("maxSize"))
SizeConstraint = Group(Keyword("SIZE").suppress() - Enclose(SizeConstraintBodyOpt)).setResultsName("sizeConstraint")
Constraints = Group(delimitedList(SizeConstraint)).setResultsName("constraints")
DefinitionBody = Forward()
TagPrefix = Enclose(Word(nums).setResultsName("tagID")) - Keyword("IMPLICIT").setResultsName("tagFormat")
OptionalSuffix = Optional(Keyword("OPTIONAL").setResultsName("isOptional"))
JunkPrefix = Optional("--F--").suppress()
AName = Word(alphanums + "-").setParseAction(NoDashes).setResultsName("name")
SingleElement = Group(JunkPrefix - AName - Optional(TagPrefix) - DefinitionBody.setResultsName("typedef") - OptionalSuffix)
NamedTypes = Dict(delimitedList(SingleElement)).setResultsName("namedTypes")
SetBody = DefineTypeDef("Set", Keyword("SET"), NamedTypes)
SequenceBody = DefineTypeDef("Sequence", Keyword("SEQUENCE"), NamedTypes)
ChoiceBody = DefineTypeDef("Choice", Keyword("CHOICE"), NamedTypes)
SetOfBody = (Keyword("SET") + Optional(SizeConstraint) + Keyword("OF")).setParseAction(SetDefType("SetOf")) + Group(DefinitionBody).setResultsName("typedef")
SequenceOfBody = (Keyword("SEQUENCE") + Optional(SizeConstraint) + Keyword("OF")).setParseAction(SetDefType("SequenceOf")) + Group(DefinitionBody).setResultsName("typedef")
CustomBody = DefineTypeDef("constructed", Word(alphanums + "-").setParseAction(NoDashes), Constraints)
NullBody = DefineTypeDef("Null", Keyword("NULL"), Constraints)
OctetStringBody = DefineTypeDef("OctetString", Regex("OCTET STRING"), Constraints)
IA5StringBody = DefineTypeDef("IA5String", Keyword("IA5STRING"), Constraints)
EnumElement = Group(Word(printables).setResultsName("name") - Enclose(Word(nums).setResultsName("value")))
NamedValues = Dict(delimitedList(EnumElement)).setResultsName("namedValues")
EnumBody = DefineTypeDef("Enum", Keyword("ENUMERATED"), NamedValues)
BitStringBody = DefineTypeDef("BitString", Keyword("BIT") + Keyword("STRING"), NamedValues)
DefinitionBody << (OctetStringBody | SetOfBody | SetBody | ChoiceBody | SequenceOfBody | SequenceBody | EnumBody | BitStringBody | IA5StringBody | NullBody | CustomBody)
Definition = AName - Literal("::=").suppress() - Optional(TagPrefix) - DefinitionBody
Definitions = Dict(ZeroOrMore(Group(Definition)))
pf = Definitions.parseFile(sys.argv[1])
TypeDeps = {}
TypeDefs = {}
def SizeConstraintHelper(size):
s2 = s1 = size.get("minSize")
s2 = size.get("maxSize", s2)
try:
return("constraint.ValueSizeConstraint(%s, %s)" % (int(s1), int(s2)))
except ValueError:
pass
ConstraintMap = {
'sizeConstraint' : SizeConstraintHelper,
}
def ConstraintHelper(c):
result = []
for key, value in c.items():
r = ConstraintMap[key](value)
if r:
result.append(r)
return result
def GenerateConstraints(c, ancestor, element, level=1):
result = ConstraintHelper(c)
if result:
return [ "subtypeSpec = %s" % " + ".join(["%s.subtypeSpec" % ancestor] + result) ]
return []
def GenerateNamedValues(definitions, ancestor, element, level=1):
result = [ "namedValues = namedval.NamedValues(" ]
for kw in definitions:
result.append(" ('%s', %s)," % (kw["name"], kw["value"]))
result.append(")")
return result
OptMap = {
False: "",
True: "Optional",
}
def GenerateNamedTypesList(definitions, element, level=1):
result = []
for val in definitions:
name = val["name"]
typename = None
isOptional = bool(val.get("isOptional"))
subtype = []
constraints = val.get("constraints")
if constraints:
cg = ConstraintHelper(constraints)
subtype.append("subtypeSpec=%s" % " + ".join(cg))
tagId = val.get("tagID")
if tagId:
subtype.append("implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, %s)" % tagId)
if subtype:
subtype = ".subtype(%s)" % ", ".join(subtype)
else:
subtype = ""
cbody = []
if val["defType"] == "constructed":
typename = val["typedef"]
element["_d"].append(typename)
elif val["defType"] == "Null":
typename = "univ.Null"
elif val["defType"] == "SequenceOf":
typename = "univ.SequenceOf"
print val.items()
cbody = [ " componentType=%s()" % val["typedef"]["definitionType"] ]
elif val["defType"] == "Choice":
typename = "univ.Choice"
indef = val.get("definition")
if indef:
cbody = [ " %s" % x for x in GenerateClassDefinition(indef, name, typename, element) ]
construct = [ "namedtype.%sNamedType('%s', %s(" % (OptMap[isOptional], name, typename), ")%s)," % subtype ]
if not cbody:
result.append("%s%s%s" % (" " * level, construct[0], construct[1]))
else:
result.append(" %s" % construct[0])
result.extend(cbody)
result.append(" %s" % construct[1])
return result
def GenerateNamedTypes(definitions, ancestor, element, level=1):
result = [ "componentType = namedtype.NamedTypes(" ]
result.extend(GenerateNamedTypesList(definitions, element))
result.append(")")
return result
defmap = {
'constraints' : GenerateConstraints,
'namedValues' : GenerateNamedValues,
'namedTypes' : GenerateNamedTypes,
}
def GenerateClassDefinition(definition, name, ancestor, element, level=1):
result = []
for defkey, defval in definition.items():
if defval:
fn = defmap.get(defkey)
if fn:
result.extend(fn(defval, ancestor, element, level))
return [" %s" % x for x in result]
def GenerateClass(element, ancestor):
name = element["name"]
top = "class %s(%s):" % (name, ancestor)
definition = element.get("definition")
body = []
if definition:
body = GenerateClassDefinition(definition, name, ancestor, element)
else:
typedef = element.get("typedef")
if typedef:
element["_d"].append(typedef["definitionType"])
body.append(" componentType = %s()" % typedef["definitionType"])
szc = element.get('sizeConstraint')
if szc:
body.extend(GenerateConstraints({ 'sizeConstraint' : szc }, ancestor, element))
if not body:
body.append(" pass")
TypeDeps[name] = list(frozenset(element["_d"]))
return "\n".join([top] + body)
StaticMap = {
"Null" : "univ.Null",
"Enum" : "univ.Enumerated",
"OctetString" : "univ.OctetString",
"IA5String" : "char.IA5String",
"Set" : "univ.Set",
"Sequence" : "univ.Sequence",
"Choice" : "univ.Choice",
"SetOf" : "univ.SetOf",
"BitString" : "univ.BitString",
"SequenceOf" : "univ.SequenceOf",
}
def StaticConstructor(x):
x["_d"] = []
if x["defType"] == "constructed":
dt = x["definitionType"]
x["_d"].append(dt)
else:
dt = StaticMap[x["defType"]]
return GenerateClass(x, dt)
for element in pf:
TypeDefs[element["name"]] = StaticConstructor(element)
while TypeDefs:
ready = [ k for k, v in TypeDeps.items() if len(v) == 0 ]
if not ready:
x = list()
for a in TypeDeps.values():
x.extend(a)
x = frozenset(x) - frozenset(TypeDeps.keys())
print TypeDefs
raise ValueError, sorted(x)
for t in ready:
for v in TypeDeps.values():
try:
v.remove(t)
except ValueError:
pass
del TypeDeps[t]
print TypeDefs[t]
print
print
del TypeDefs[t]
这将使用与此示例类似的语法文件进行操作：
CarrierInfo ::= OCTET STRING (SIZE(2..3))
ChargeAreaCode ::= OCTET STRING (SIZE(3))
ChargeInformation ::= OCTET STRING (SIZE(2..33))
ChargedParty ::= ENUMERATED
(chargingOfCallingSubscriber (0),
chargingOfCalledSubscriber (1),
noCharging (2))
ChargingOrigin ::= OCTET STRING (SIZE(1))
Counter ::= OCTET STRING (SIZE(1..4))
Date ::= OCTET STRING (SIZE(3..4))
您需要在生成的文件顶部添加此行：
from pyasn1.type import univ, namedtype, namedval, constraint, tag, char
请将结果命名为defs.py。然后，我给defs附加了一堆漂亮的打印机（如果您没有，请跳过）
import defs, parsers
def rplPrettyOut(self, value):
return repr(self.decval(value))
for name in dir(parsers):
if (not name.startswith("_")) and hasattr(defs, name):
target = getattr(defs, name)
target.prettyOut = rplPrettyOut
target.decval = getattr(parsers, name)
然后，就开始了以下内容：
def ParseBlock(self, block):
while block and block[0] != '\x00':
result, block = pyasn1.codec.ber.decoder.decode(block, asn1Spec=parserimp.defs.CallDataRecord())
yield result
如果你仍然感兴趣，我会把代码放在某个地方。事实上，无论如何我都会把它放在某个地方 - 但是如果你有兴趣，请告诉我，我会指向那里。
- Stingray
1
5我可能有兴趣在一个开源项目中使用这个（http://packages.python.org/DendroPy/）。这段代码是否属于公共领域或者是可用的比较宽松的开源许可证，例如BSD、MIT等？ - Jeet
3
我是LEPL的作者，它是一个用Python编写的解析器，你想做的事情正是我的“TODO”列表中的一项。
我不会很快开始这个项目，但你可以考虑使用LEPL来构建你的解决方案，因为：
1- 它是一个纯Python的解决方案（使生活更简单）。
2- 它已经能够解析二进制数据和文本，所以你只需要使用一个工具——相同的解析器用于解析ASN1规范和二进制数据。
主要的缺点是：
1- 它是一个相当新的软件包，所以可能比其他一些软件包更容易出现错误，并且支持社区也不是很大。
2- 它仅限于Python 2.6及以上版本（二进制解析器仅适用于Python 3及以上版本）。
有关更多信息，请参见http://www.acooke.org/lepl，特别是有关二进制解析的部分，请参见手册的相关部分（由于Stack Overflow认为我是垃圾邮件，所以无法直接链接）。
安德鲁
PS：我还没有开始此项目的主要原因是，据我所知，ASN 1规范并不免费提供。如果你有权访问它们，而且不违法的话，一份副本将不胜感激（不幸的是，我目前正在另一个项目上工作，所以仍需要时间来实现这个项目，但这将帮助我更快地使它工作……）。
我不会很快开始这个项目，但你可以考虑使用LEPL来构建你的解决方案，因为：
1- 它是一个纯Python的解决方案（使生活更简单）。
2- 它已经能够解析二进制数据和文本，所以你只需要使用一个工具——相同的解析器用于解析ASN1规范和二进制数据。
主要的缺点是：
1- 它是一个相当新的软件包，所以可能比其他一些软件包更容易出现错误，并且支持社区也不是很大。
2- 它仅限于Python 2.6及以上版本（二进制解析器仅适用于Python 3及以上版本）。
有关更多信息，请参见http://www.acooke.org/lepl，特别是有关二进制解析的部分，请参见手册的相关部分（由于Stack Overflow认为我是垃圾邮件，所以无法直接链接）。
安德鲁
PS：我还没有开始此项目的主要原因是，据我所知，ASN 1规范并不免费提供。如果你有权访问它们，而且不违法的话，一份副本将不胜感激（不幸的是，我目前正在另一个项目上工作，所以仍需要时间来实现这个项目，但这将帮助我更快地使它工作……）。
- andrew cooke
1
LEPL 看起来确实很有趣，但就短期而言，我的需求之一是与 Python 2.4 的兼容性。 - elventear
2
这里有一个ANTLR ASN.1语法，使用ANTLR，您应该能够制作一个ASN.1解析器。生成用于pyasn1的代码留给作者自己完成 :-)
- Martin v. Löwis
1
链接中的引用：“语法远远不完整。我没有ANTLR的经验。” - jfs
2
我有使用pyasn1的经验，足以解析相当复杂的语法。语法是用Python结构表达的，因此不需要运行代码生成器。
- Denis Otkidach
1
2pyasn1的问题在于数据结构必须手动编写。这对于小的asn.1定义来说还可以，但对于大型定义则不行。 - elventear
1
我最近创建了一个名为asn1tools的Python包，它将ASN.1规范编译成Python对象，可用于编码和解码消息。
>>> import asn1tools
>>> foo = asn1tools.compile_file('tests/files/foo.asn')
>>> encoded = foo.encode('Question', {'id': 1, 'question': 'Is 1+1=3?'})
>>> encoded
bytearray(b'0\x0e\x02\x01\x01\x16\x09Is 1+1=3?')
>>> foo.decode('Question', encoded)
{'id': 1, 'question': 'Is 1+1=3?'}
- Erik Moqvist
1
我曾经使用asn1c完成了类似的工作，并在其周围构建了一个Pyrex扩展。包装结构在3GPP TS 32.401中有描述。
使用Pyrex，您可以编写足够厚的包装器，以在本机Python数据类型和正确的ASN.1表示之间进行转换（包装器生成器，如SWIG，倾向于不对类型执行复杂操作）。我编写的包装器还跟踪了底层C数据结构的所有权（例如，访问子结构时，返回Python对象，但没有底层数据的副本，只有引用共享）。
最终，这个包装器是以一种半自动的方式编写的，但因为这是我唯一使用ASN.1的工作，所以我从未完全自动化代码生成的步骤。
您可以尝试使用其他Python-C包装器并执行完全自动的转换：工作量会减少，但然后您将把复杂性（和重复的容易出错的操作）移交给结构用户：因此，我更喜欢Pyrex的方式。 asn1c绝对是一个不错的选择。
- piro
1
我所拥有的asn1定义非常长，看起来很复杂。asn1c生成的代码似乎在处理这个文件时出现了问题，我们的想法是不要再调试另一个工具。 - elventear
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接