Local fork of Henryk Ploetz' smardcard shell
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
cyberflex-shell/TLV_utils.py

525 lines
17 KiB

import binascii, utils, re, sys
class identifier:
"""An identifier, because I'm too lazy to use quotes all over the place.
Instantiating an object of this type registers a name in the current scope, essentially
making each instantiation of this class equal to
foo = identifier("foo")
even when you only write
identifier("foo")
"""
def __init__(self,name):
self.name = name
sys._getframe(1).f_locals[name] = self
def __str__(self):
return self.name
def __repr__(self):
return "identifier(%r)" % self.name
identifier("context_FCP")
identifier("context_FMD")
identifier("context_FCI")
identifier("recurse")
identifier("binary")
identifier("number")
identifier("ascii")
identifier("utf8")
file_descriptor_byte_descriptions = [
#mask byte no match match
(0x80, 0x80, None, "RFU"),
(0xC0, 0x40, "non shareable", "shareable"),
(0xB8, 0x00, None, "working EF"),
(0xB8, 0x08, None, "internal EF"),
(0xB8, 0x10, None, "Reserved for proprietary uses"),
(0xB8, 0x18, None, "Reserved for proprietary uses"),
(0xB8, 0x20, None, "Reserved for proprietary uses"),
(0xB8, 0x28, None, "Reserved for proprietary uses"),
(0xB8, 0x30, None, "Reserved for proprietary uses"),
(0xB8, 0x38, None, "DF"),
(0x87, 0x00, None, "No file structure information given"),
(0x87, 0x01, None, "Transparent"),
(0x87, 0x02, None, "Linear fixed, no further info"),
(0x87, 0x03, None, "Linear fixed, SIMPLE-TLV"),
(0x87, 0x04, None, "Linear variable, no further info"),
(0x87, 0x05, None, "Linear variable, SIMPLE-TLV"),
(0x87, 0x06, None, "Cyclic, no further info"),
(0x87, 0x07, None, "Cyclic, SIMPLE-TLV"),
]
data_coding_byte_descriptions = [
(0x60, 0x00, None, "one-time write"),
(0x60, 0x20, None, "proprietary"),
(0x60, 0x40, None, "write OR"),
(0x60, 0x60, None, "write AND"),
]
life_cycle_status_byte_descriptions = [
(0xF0, 0x00, "Proprietary", None),
(0xFF, 0x00, None, "No information given"),
(0xFF, 0x01, None, "Creation state"),
(0xFF, 0x03, None, "Initialisation state"),
(0xFD, 0x05, None, "Operational state (activated)"),
(0xFD, 0x04, None, "Operational state (deactivated)"),
(0xFC, 0x0C, None, "Termination state"),
]
def decode_file_descriptor_byte(value, verbose = True):
result = " %s" % utils.hexdump(value, short=True)
if not verbose:
attributes = utils.parse_binary(ord(value[0]), file_descriptor_byte_descriptions, False)
if len(value) > 1:
attributes.append(
"data coding byte, behavior of write functions: %s, data unit size in in nibbles: %i" % (
"".join( utils.parse_binary(ord(value[1]), data_coding_byte_descriptions) ),
2 ** (ord(value[1])&0x07)
)
)
if len(value) > 2:
i = 0
for j in value[2:4]:
i = i * 256 + ord(j)
attributes.append(
"maximum record length: %s" % i
)
if len(value) > 4:
i = 0
for j in value[4:6]:
i = i * 256 + ord(j)
attributes.append(
"number of records: %s" % i
)
return result + " (%s)" % "; ".join(attributes)
else:
result = result + "\nFile descriptor byte:\n"
result = result + "\t" + "\n\t".join(
utils.parse_binary(ord(value[0]), file_descriptor_byte_descriptions, True)
)
if len(value) > 1:
result = result + "\nData coding byte (0x%02X):\n" % ord(value[1])
result = result + "\tBehavior of write functions: %s\n\tData unit size in in nibbles: %i" % (
"".join( utils.parse_binary(ord(value[1]), data_coding_byte_descriptions) ),
2 ** (ord(value[1])&0x07)
)
if len(value) > 2:
i = 0
for j in value[2:4]:
i = i * 256 + ord(j)
result = result + "\nMaximum record length: %s" % i
if len(value) > 4:
i = 0
for j in value[4:6]:
i = i * 256 + ord(j)
result = result + "\nNumber of records: %s" % i
return result
def parse_oid(value):
result = []
def next_arc(data):
bits = ord(data[0]) & 0x7F
while ord(data[0]) & 0x80 != 0:
data = data[1:]
bits = (bits << 7) + (ord(data[0]) & 0x7F)
data = data[1:]
return bits, data
arc, value = next_arc(value)
if arc < 40:
result.append( 0 )
result.append( arc )
elif arc < 80:
result.append( 1 )
result.append( arc-40 )
else:
result.append( 2 )
result.append( arc-80 )
while len(value) > 0:
arc,value = next_arc(value)
result.append( arc )
return tuple(result)
oidCache = {}
def loadOids(filename="oids.txt"):
try:
fp = file(filename, "r")
except (SystemExit,KeyboardInterrupt):
raise
except:
pass
else:
try:
lines = fp.readlines()
finally:
fp.close()
for line in lines:
if line.strip() == "" or line[0] == "#":
continue
parts = line.strip().split(None,2)
if len(parts) < 3:
parts.append(parts[1])
oidCache[parts[0]] = tuple(parts[1:])
def decode_oid(value):
oid = parse_oid(value)
str_rep = ".".join([str(a) for a in oid])
if len(oidCache) == 0:
loadOids()
description = oidCache.get(str_rep, None)
if description is None:
steps = [oid[:e] for e in range(len(oid)-1, 0, -1)]
for step in steps:
new_str_rep = ".".join([str(a) for a in step])
if oidCache.has_key(new_str_rep):
description = ("%s %s" % (oidCache[new_str_rep][0], ".".join([str(a) for a in oid[len(step):]])),)
break
if description is None:
description = ("No description available",)
return " %s (%s)" % (str_rep, description[0])
_gtimere = re.compile(r'(\d{4})(\d\d)(\d\d)(\d\d)(?:(\d\d)(\d\d(?:[.,]\d+)?)?)?(|Z|(?:[+-]\d\d(?:\d\d)?))$')
def decode_generalized_time(value):
matches = _gtimere.match(value)
if not matches:
return " "+value
else:
matches = matches.groups()
result = [" %s-%s-%s %s:" % matches[:4]]
if matches[4] is not None:
result.append("%s:" % matches[4])
if matches[5] is not None:
result.append("%s" % matches[5])
else:
result.append("00")
else:
result.append(":00:00")
if matches[6] == "Z":
result.append(" UTC")
elif matches[6] != "":
result.append(" ")
result.append(matches[6])
if len(matches[6]) < 5:
result.append("00")
return "".join(result)
_utimere = re.compile(r'(\d\d)(\d\d)(\d\d)(\d\d)(?:(\d\d))?(Z|(?:[+-]\d\d(?:\d\d)?))$')
def decode_utc_time(value):
matches = _utimere.match(value)
if not matches:
return " "+value
else:
matches = matches.groups()
result = [" %s-%s-%s %s:" % matches[:4]]
if matches[4] is not None:
result.append("%s:" % matches[4])
if matches[5] is not None:
result.append("%s" % matches[5])
else:
result.append("00")
else:
result.append(":00:00")
if matches[6] == "Z":
result.append(" UTC")
elif matches[6] != "":
result.append(" ")
result.append(matches[6])
if len(matches[6]) < 5:
result.append("00")
return "".join(result)
def decode_bit_string(value):
unused_len = ord(value[0])
value = value[1:]
bits = []
for i in range(len(value)):
v = ord(value[i])
l = 8
if i == len(value)-1:
l = l - unused_len
for j in range(l):
bits.append( (v & 0x80) >> 7 )
v = v << 1
def do_some_bits(slice):
result = []
for index, bit in enumerate(slice):
if index % 4 == 0:
result.append(" ")
if index % 8 == 0:
result.append(" ")
result.append(str(bit))
return result
if len(bits) <= 16:
return " '%s'B" % "".join(do_some_bits(bits)).strip()
else:
step = 32
result = []
head, tail = bits[:step], bits[step:]
offset = 0
while offset == 0 or len(tail) > 0:
result.append("%05x: %s" % (offset, "".join(do_some_bits(head)).strip()))
offset += step
head, tail = tail[:step], tail[step:]
return "\n" + "\n".join(result)
def decode_lcs(value):
value = ord(value[0])
return " 0x%02x\n%s" % (value, "\n".join(
utils.parse_binary(value, life_cycle_status_byte_descriptions, True)
)
)
def decode_sfi(value):
if len(value) == 0: return ""
return " 0x%02x" % (ord(value[0]) >> 3)
tags = {
None: {
0x01: (lambda a: (len(a) > 0 and ord(a[0]) != 0) and " True" or " False", "Boolean"),
0x02: (number, "Integer"),
0x03: (decode_bit_string, "Bit string"),
0x04: (binary, "Octet string"),
0x05: (lambda a: " Null", "Null"),
0x06: (decode_oid, "Object identifier"),
0x0A: (number, "Enumerated"),
0x0C: (utf8, "UTF-8 string"),
0x12: (ascii, "Numeric string"),
0x13: (ascii, "Printable string"),
0x14: (ascii, "Teletex string"), ## FIXME: support escape sequences?
0x15: (ascii, "Videotext string"), ## dito
0x16: (ascii, "IA5String"),
0x17: (decode_utc_time, "UTC time"),
0x18: (decode_generalized_time, "Generalized time"),
0x30: (recurse, "Sequence", None),
0x31: (recurse, "Set", None),
0x62: (recurse, "File Control Parameters", context_FCP),
0x64: (recurse, "File Management Data", context_FMD),
0x6F: (recurse, "File Control Information", context_FCI),
},
context_FCI: {
0x80: (number, "Number of data bytes in the file, excluding structural information"),
0x81: (number, "Number of data bytes in the file, including structural information"),
0x82: (decode_file_descriptor_byte, "File descriptor byte"),
0x83: (binary, "File identifier"),
0x84: (binary, "DF name"),
0x85: (binary, "Proprietary information"),
0x86: (binary, "Security attributes"),
0x87: (binary, "Identifier of an EF containing an extension of the FCI"),
0x88: (decode_sfi, "Short EF identifier"),
0x8A: (decode_lcs, "Life cycle status byte"),
0xA5: (recurse, "Proprietary information", None),
},
}
tags[context_FCP] = tags[context_FCI]
BER_CLASSES = {
0x0: "universal",
0x1: "application",
0x2: "context-specific",
0x3: "private",
}
def tlv_unpack(data):
ber_class = (ord(data[0]) & 0xC0) >> 6
constructed = (ord(data[0]) & 0x20) != 0 ## 0 = primitive, 0x20 = constructed
tag = ord(data[0])
data = data[1:]
if (tag & 0x1F) == 0x1F:
tag = (tag << 8) | ord(data[0])
while ord(data[0]) & 0x80 == 0x80:
data = data[1:]
tag = (tag << 8) | ord(data[0])
data = data[1:]
length = ord(data[0])
if length < 0x80:
data = data[1:]
elif length & 0x80 == 0x80:
length_ = 0
data = data[1:]
for i in range(0,length & 0x7F):
length_ = length_ * 256 + ord(data[0])
data = data[1:]
length = length_
value = data[:length]
rest = data[length:]
return ber_class, constructed, tag, length, value, rest
def decode(data, context = None, level = 0, tags=tags):
result = []
while len(data) > 0:
if ord(data[0]) in (0x00, 0xFF):
data = data[1:]
continue
ber_class, constructed, tag, length, value, data = tlv_unpack(data)
interpretation = tags.get(context, tags.get(None, {})).get(tag, None)
if interpretation is None:
if not constructed: interpretation = [binary, "Unknown field"]
else: interpretation = [recurse, "Unknown structure", ber_class in (0, 1) and context or None]
interpretation[1] = "%s (%s class)" % (interpretation[1], BER_CLASSES[ber_class])
interpretation = tuple(interpretation)
current = ["\t"*level]
current.append("Tag 0x%02X, Len 0x%02X, '%s':" % (tag, length, interpretation[1]))
if interpretation[0] is recurse:
current.append("\n")
current.append( decode(value, interpretation[2], level+1, tags=tags) )
elif interpretation[0] is number:
num = 0
for i in value:
num = num * 256
num = num + ord(i)
current.append( " 0x%02x (%i)" % (num, num))
elif interpretation[0] is ascii:
current.append( " %s" % value)
elif interpretation[0] is utf8:
current.append( " %s" % unicode(value, "utf-8"))
elif interpretation[0] is binary:
if len(value) < 0x10:
current.append( " %s" % utils.hexdump(value, short=True))
else:
current.append( "\n" + "\t"*(level+1) )
current.append( ("\n" + "\t"*(level+1)).join( utils.hexdump(value).splitlines() ) )
elif callable(interpretation[0]):
current.append( ("\n"+"\t"*(level+1)).join(interpretation[0](value).splitlines()) )
result.append( "".join(current) )
return "\n".join(result)
def tlv_find_tag(tlv_data, tag, num_results = None):
"""Find (and return) all instances of tag in the given tlv structure (as returned by unpack).
If num_results is specified then at most that many results will be returned."""
results = []
def find_recursive(tlv_data):
for d in tlv_data:
t,l,v = d[:3]
if t == tag:
results.append(d)
else:
if isinstance(v, list): # FIXME Refactor the whole TLV code into a class
find_recursive(v)
if num_results is not None and len(results) >= num_results:
return
find_recursive(tlv_data)
return results
def unpack(data, with_marks = None, offset = 0, include_filler=False):
result = []
while len(data) > 0:
if ord(data[0]) in (0x00, 0xFF):
if include_filler:
if with_marks is None:
result.append( (ord(data[0]), None, None) )
else:
result.append( (ord(data[0]), None, None, () ) )
data = data[1:]
offset = offset + 1
continue
l = len(data)
ber_class, constructed, tag, length, value, data = tlv_unpack(data)
stop = offset + (l - len(data))
start = stop - length
if with_marks is not None:
marks = []
for type, mark_start, mark_stop in with_marks:
if (mark_start, mark_stop) == (start, stop):
marks.append(type)
marks = (marks, )
else:
marks = ()
if not constructed:
result.append( (tag, length, value) + marks )
else:
result.append( (tag, length, unpack(value, with_marks, offset = start)) + marks )
offset = stop
return result
def pack(tlv_data, recalculate_length = False):
result = []
for data in tlv_data:
tag, length, value = data[:3]
if tag in (0xff, 0x00):
result.append( chr(tag) )
continue
if not isinstance(value, str):
value = pack(value, recalculate_length)
if recalculate_length:
length = len(value)
t = ""
while tag > 0:
t = chr( tag & 0xff ) + t
tag = tag >> 8
if length < 0x7F:
l = chr(length)
else:
l = ""
while length > 0:
l = chr( length & 0xff ) + l
length = length >> 8
assert len(l) < 0x7f
l = chr( 0x80 | len(l) ) + l
result.append(t)
result.append(l)
result.append(value)
return "".join(result)
if __name__ == "__main__":
test = binascii.unhexlify("".join(("6f 2b 83 02 2f 00 81 02 01 00 82 03 05 41 26 85" \
+"02 01 00 86 18 60 00 00 00 ff ff b2 00 00 00 ff" \
+"ff dc 00 00 00 ff ff e4 10 00 00 ff ff").split()))
#decoded = decode(test)
#print decoded
#print decode(file("c100").read())
marks = [ ('[', 5, 8) ]
a = binascii.a2b_hex( "".join( "80 01 aa b0 03 81 01 bb ff ff 00".split() ) )
b = unpack( a, with_marks=marks, include_filler=True)
print b
c = pack(b, recalculate_length = True)
print utils.hexdump(a)
print utils.hexdump(c)
loadOids()