| # $Id: asn1.py 23 2006-11-08 15:45:33Z dugsong $ |
| # -*- coding: utf-8 -*- |
| """Abstract Syntax Notation #1.""" |
| from __future__ import absolute_import |
| from __future__ import print_function |
| |
| import struct |
| from calendar import timegm |
| |
| from . import dpkt |
| from .compat import compat_ord |
| |
| # Type class |
| CLASSMASK = 0xc0 |
| UNIVERSAL = 0x00 |
| APPLICATION = 0x40 |
| CONTEXT = 0x80 |
| PRIVATE = 0xc0 |
| |
| # Constructed (vs. primitive) |
| CONSTRUCTED = 0x20 |
| |
| # Universal-class tags |
| TAGMASK = 0x1f |
| INTEGER = 2 |
| BIT_STRING = 3 # arbitrary bit string |
| OCTET_STRING = 4 # arbitrary octet string |
| NULL = 5 |
| OID = 6 # object identifier |
| SEQUENCE = 16 # ordered collection of types |
| SET = 17 # unordered collection of types |
| PRINT_STRING = 19 # printable string |
| T61_STRING = 20 # T.61 (8-bit) character string |
| IA5_STRING = 22 # ASCII |
| UTC_TIME = 23 |
| |
| |
| def utctime(buf): |
| """Convert ASN.1 UTCTime string to UTC float. |
| |
| TODO: Long description here. |
| |
| Args: |
| buf: A buffer with format "yymnddhhmm" |
| |
| Returns: |
| A floating point number, indicates seconds since the Epoch. |
| """ |
| yy = int(buf[:2]) |
| mn = int(buf[2:4]) |
| dd = int(buf[4:6]) |
| hh = int(buf[6:8]) |
| mm = int(buf[8:10]) |
| try: |
| ss = int(buf[10:12]) |
| buf = buf[12:] |
| except TypeError: |
| ss = 0 |
| buf = buf[10:] |
| |
| if buf[0] == '+': |
| hh -= int(buf[1:3]) |
| mm -= int(buf[3:5]) |
| elif buf[0] == '-': |
| hh += int(buf[1:3]) |
| mm += int(buf[3:5]) |
| return timegm((2000 + yy, mn, dd, hh, mm, ss, 0, 0, 0)) |
| |
| |
| def decode(buf): |
| """Sleazy ASN.1 decoder. |
| |
| TODO: Long description here. |
| |
| Args: |
| buf: A buffer with Sleazy ASN.1 data. |
| |
| Returns: |
| A list of (id, value) tuples from ASN.1 BER/DER encoded buffer. |
| |
| Raises: |
| UnpackError: An error occurred the ASN.1 length exceed. |
| """ |
| msg = [] |
| while buf: |
| t = compat_ord(buf[0]) |
| constructed = t & CONSTRUCTED |
| tag = t & TAGMASK |
| l_ = compat_ord(buf[1]) |
| c = 0 |
| if constructed and l_ == 128: |
| # XXX - constructed, indefinite length |
| msg.append((t, decode(buf[2:]))) |
| elif l_ >= 128: |
| c = l_ & 127 |
| if c == 1: |
| l_ = compat_ord(buf[2]) |
| elif c == 2: |
| l_ = struct.unpack('>H', buf[2:4])[0] |
| elif c == 3: |
| l_ = struct.unpack('>I', buf[1:5])[0] & 0xfff |
| c = 2 |
| elif c == 4: |
| l_ = struct.unpack('>I', buf[2:6])[0] |
| else: |
| # XXX - can be up to 127 bytes, but... |
| raise dpkt.UnpackError('excessive long-form ASN.1 length %d' % l_) |
| |
| # Skip type, length |
| buf = buf[2 + c:] |
| |
| # Parse content |
| if constructed: |
| msg.append((t, decode(buf))) |
| elif tag == INTEGER: |
| if l_ == 0: |
| n = 0 |
| elif l_ == 1: |
| n = compat_ord(buf[0]) |
| elif l_ == 2: |
| n = struct.unpack('>H', buf[:2])[0] |
| elif l_ == 3: |
| n = struct.unpack('>I', buf[:4])[0] >> 8 |
| elif l_ == 4: |
| n = struct.unpack('>I', buf[:4])[0] |
| else: |
| raise dpkt.UnpackError('excessive integer length > %d bytes' % l_) |
| msg.append((t, n)) |
| elif tag == UTC_TIME: |
| msg.append((t, utctime(buf[:l_]))) |
| else: |
| msg.append((t, buf[:l_])) |
| |
| # Skip content |
| buf = buf[l_:] |
| return msg |
| |
| |
| def test_asn1(): |
| s = ( |
| b'0\x82\x02Q\x02\x01\x0bc\x82\x02J\x04xcn=Douglas J Song 1, ou=Information Technology Division,' |
| b' ou=Faculty and Staff, ou=People, o=University of Michigan, c=US\n\x01\x00\n\x01\x03\x02\x01' |
| b'\x00\x02\x01\x00\x01\x01\x00\x87\x0bobjectclass0\x82\x01\xb0\x04\rmemberOfGroup\x04\x03acl' |
| b'\x04\x02cn\x04\x05title\x04\rpostalAddress\x04\x0ftelephoneNumber\x04\x04mail\x04\x06member' |
| b'\x04\thomePhone\x04\x11homePostalAddress\x04\x0bobjectClass\x04\x0bdescription\x04\x18' |
| b'facsimileTelephoneNumber\x04\x05pager\x04\x03uid\x04\x0cuserPassword\x04\x08joinable\x04\x10' |
| b'associatedDomain\x04\x05owner\x04\x0erfc822ErrorsTo\x04\x08ErrorsTo\x04\x10rfc822RequestsTo\x04\n' |
| b'RequestsTo\x04\tmoderator\x04\nlabeledURL\x04\nonVacation\x04\x0fvacationMessage\x04\x05drink\x04\x0e' |
| b'lastModifiedBy\x04\x10lastModifiedTime\x04\rmodifiersname\x04\x0fmodifytimestamp\x04\x0ccreatorsname' |
| b'\x04\x0fcreatetimestamp' |
| ) |
| assert decode(s) == [ |
| (48, [ |
| (2, 11), |
| (99, [ |
| (4, ( |
| b'cn=Douglas J Song 1, ' |
| b'ou=Information Technology Division, ' |
| b'ou=Faculty and Staff, ' |
| b'ou=People, ' |
| b'o=University of Michigan, ' |
| b'c=US' |
| )), |
| (10, b'\x00'), |
| (10, b'\x03'), |
| (2, 0), |
| (2, 0), |
| (1, b'\x00'), |
| (135, b'objectclass'), |
| (48, [ |
| (4, b'memberOfGroup'), |
| (4, b'acl'), |
| (4, b'cn'), |
| (4, b'title'), |
| (4, b'postalAddress'), |
| (4, b'telephoneNumber'), |
| (4, b'mail'), |
| (4, b'member'), |
| (4, b'homePhone'), |
| (4, b'homePostalAddress'), |
| (4, b'objectClass'), |
| (4, b'description'), |
| (4, b'facsimileTelephoneNumber'), |
| (4, b'pager'), |
| (4, b'uid'), |
| (4, b'userPassword'), |
| (4, b'joinable'), |
| (4, b'associatedDomain'), |
| (4, b'owner'), |
| (4, b'rfc822ErrorsTo'), |
| (4, b'ErrorsTo'), |
| (4, b'rfc822RequestsTo'), |
| (4, b'RequestsTo'), |
| (4, b'moderator'), |
| (4, b'labeledURL'), |
| (4, b'onVacation'), |
| (4, b'vacationMessage'), |
| (4, b'drink'), |
| (4, b'lastModifiedBy'), |
| (4, b'lastModifiedTime'), |
| (4, b'modifiersname'), |
| (4, b'modifytimestamp'), |
| (4, b'creatorsname'), |
| (4, b'createtimestamp'), |
| ]) |
| ]) |
| ]) |
| ] |
| |
| |
| def test_utctime(): |
| buf = ( |
| '201005' # yymndd |
| '012345' # hhmmss |
| '+1234' # +hhmm |
| ) |
| assert utctime(buf) == 1601815785.0 |
| |
| buf = ( |
| '201005' # yymndd |
| '012345' # hhmmss |
| '-1234' # -hhmm |
| ) |
| assert utctime(buf) == 1601906265.0 |
| |
| |
| def test_decode(): |
| import pytest |
| from binascii import unhexlify |
| buf = unhexlify( |
| '20' # CONSTRUCTED |
| '80' # 128 | 0 |
| ) |
| assert decode(buf) == [(32, []), (32, [])] |
| |
| # unpacking UTC_TIME |
| buf = unhexlify( |
| '17' # t: code: UTC_TIME |
| '81' # l_: code: 128 | 1 (constructed |
| '22' # data len |
| '3230313030353031323334352b30303030' |
| |
| ) |
| assert decode(buf) == [(23, 1601861025.0)] |
| |
| # unpacking 2-byte size; zero-length integer |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '82' # l_: 128 | 2 |
| '0000' # new l_ |
| ) |
| assert decode(buf) == [(2, 0)] |
| |
| # unpacking 3-byte size |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '83' # l_: 128 | 3 |
| '000001' # new l_ |
| ) |
| assert decode(buf) == [(2, 1)] |
| |
| # unpacking 4-byte size |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '84' # l_: 128 | 4 |
| '00000002' # new l_ |
| 'abcd' |
| ) |
| assert decode(buf) == [(2, 43981)] |
| |
| # unpacking 4-byte size |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '85' # l_: 128 | 5 |
| ) |
| with pytest.raises(dpkt.UnpackError, match="excessive long-form ASN.1 length 133"): |
| decode(buf) |
| |
| # unpacking 1-byte size; 4-byte integer |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '81' # l_: 128 | 1 |
| '04' # new l_ |
| '12345678' # integer |
| ) |
| assert decode(buf) == [(2, 305419896)] |
| |
| # unpacking 1-byte size; 4-byte integer |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '81' # l_: 128 | 1 |
| '05' # new l_ |
| ) |
| with pytest.raises(dpkt.UnpackError, match="excessive integer length > 5 bytes"): |
| decode(buf) |
| |
| # unpacking 1-byte size; 3-byte integer |
| buf = unhexlify( |
| '02' # t: INTEGER |
| '81' # l_: 128 | 1 |
| '03' # new l_ |
| '123456' # integer |
| |
| '02' # t: INTEGER |
| '81' # l_: 128 | 1 |
| '00' # new l_ |
| ) |
| assert decode(buf) == [ |
| (2, 1193046), |
| (2, 0), |
| ] |
