basic functionalty
This commit is contained in:
shim_
899
modules/Crypto/Util/asn1.py
Normal file
899
modules/Crypto/Util/asn1.py
Normal file
@@ -0,0 +1,899 @@
|
||||
# -*- coding: ascii -*-
|
||||
#
|
||||
# Util/asn1.py : Minimal support for ASN.1 DER binary encoding.
|
||||
#
|
||||
# ===================================================================
|
||||
# The contents of this file are dedicated to the public domain. To
|
||||
# the extent that dedication to the public domain is not available,
|
||||
# everyone is granted a worldwide, perpetual, royalty-free,
|
||||
# non-exclusive license to exercise all rights associated with the
|
||||
# contents of this file for any purpose whatsoever.
|
||||
# No rights are reserved.
|
||||
#
|
||||
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
||||
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
||||
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
# ===================================================================
|
||||
""" ASN.1 DER encoding and decoding
|
||||
|
||||
This module provides minimal support for encoding and decoding `ASN.1`_ DER
|
||||
objects.
|
||||
|
||||
.. _`ASN.1`: ftp://ftp.rsasecurity.com/pub/pkcs/ascii/layman.asc
|
||||
|
||||
"""
|
||||
|
||||
from __future__ import nested_scopes
|
||||
|
||||
import sys
|
||||
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
from Crypto.Util.py3compat import *
|
||||
if sys.version_info[0] == 2 and sys.version_info[1] == 1:
|
||||
from Crypto.Util.py21compat import *
|
||||
|
||||
from Crypto.Util.number import long_to_bytes, bytes_to_long
|
||||
|
||||
__all__ = [ 'DerObject', 'DerInteger', 'DerOctetString', 'DerNull',
|
||||
'DerSequence', 'DerObjectId', 'DerBitString', 'DerSetOf',
|
||||
'newDerInteger', 'newDerOctetString', 'newDerSequence',
|
||||
'newDerObjectId', 'newDerBitString', 'newDerSetOf' ]
|
||||
|
||||
def _isInt(x, onlyNonNegative=False):
|
||||
test = 0
|
||||
try:
|
||||
test += x
|
||||
except TypeError:
|
||||
return False
|
||||
return not onlyNonNegative or x>=0
|
||||
|
||||
class BytesIO_EOF(BytesIO):
|
||||
"""This class differs from BytesIO in that an EOFError exception is
|
||||
raised whenever EOF is reached."""
|
||||
|
||||
def __init__(self, *params):
|
||||
BytesIO.__init__(self, *params)
|
||||
self.setRecord(False)
|
||||
|
||||
def setRecord(self, record):
|
||||
self._record = record
|
||||
self._recording = b("")
|
||||
|
||||
def read(self, length):
|
||||
s = BytesIO.read(self, length)
|
||||
if len(s)<length:
|
||||
raise EOFError
|
||||
if self._record:
|
||||
self._recording += s
|
||||
return s
|
||||
|
||||
def read_byte(self):
|
||||
return self.read(1)[0]
|
||||
|
||||
class NoDerElementError(EOFError):
|
||||
pass
|
||||
|
||||
class DerObject(object):
|
||||
"""Base class for defining a single DER object.
|
||||
|
||||
This class should never be directly instantiated.
|
||||
"""
|
||||
|
||||
def __init__(self, asn1Id=None, payload=b(''), implicit=None, constructed=False):
|
||||
"""Initialize the DER object according to a specific ASN.1 type.
|
||||
|
||||
:Parameters:
|
||||
asn1Id : integer
|
||||
The universal DER tag identifier for this object
|
||||
(e.g. 0x10 for a SEQUENCE). If None, the tag is not known
|
||||
yet.
|
||||
|
||||
payload : byte string
|
||||
The initial payload of the object.
|
||||
If not specified, the payload is empty.
|
||||
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag *asn1Id*.
|
||||
|
||||
constructed : bool
|
||||
True when the ASN.1 type is *constructed*.
|
||||
False when it is *primitive*.
|
||||
"""
|
||||
|
||||
if asn1Id==None:
|
||||
self._idOctet = None
|
||||
return
|
||||
asn1Id = self._convertTag(asn1Id)
|
||||
self._implicit = implicit
|
||||
if implicit:
|
||||
# In a BER/DER identifier octet:
|
||||
# * bits 4-0 contain the tag value
|
||||
# * bit 5 is set if the type is 'construted'
|
||||
# and unset if 'primitive'
|
||||
# * bits 7-6 depend on the encoding class
|
||||
#
|
||||
# Class | Bit 7, Bit 6
|
||||
# universal | 0 0
|
||||
# application | 0 1
|
||||
# context-spec | 1 0 (default for IMPLICIT)
|
||||
# private | 1 1
|
||||
#
|
||||
self._idOctet = 0x80 | self._convertTag(implicit)
|
||||
else:
|
||||
self._idOctet = asn1Id
|
||||
if constructed:
|
||||
self._idOctet |= 0x20
|
||||
self.payload = payload
|
||||
|
||||
def _convertTag(self, tag):
|
||||
"""Check if *tag* is a real DER tag.
|
||||
Convert it from a character to number if necessary.
|
||||
"""
|
||||
if not _isInt(tag):
|
||||
if len(tag)==1:
|
||||
tag = bord(tag[0])
|
||||
# Ensure that tag is a low tag
|
||||
if not (_isInt(tag) and 0 <= tag < 0x1F):
|
||||
raise ValueError("Wrong DER tag")
|
||||
return tag
|
||||
|
||||
def _lengthOctets(self):
|
||||
"""Build length octets according to the current object's payload.
|
||||
|
||||
Return a byte string that encodes the payload length (in
|
||||
bytes) in a format suitable for DER length octets (L).
|
||||
"""
|
||||
payloadLen = len(self.payload)
|
||||
if payloadLen>127:
|
||||
encoding = long_to_bytes(payloadLen)
|
||||
return bchr(len(encoding)+128) + encoding
|
||||
return bchr(payloadLen)
|
||||
|
||||
def encode(self):
|
||||
"""Return this DER element, fully encoded as a binary byte string."""
|
||||
# Concatenate identifier octets, length octets,
|
||||
# and contents octets
|
||||
return bchr(self._idOctet) + self._lengthOctets() + self.payload
|
||||
|
||||
def _decodeLen(self, s):
|
||||
"""Decode DER length octets from a file."""
|
||||
|
||||
length = bord(s.read_byte())
|
||||
if length<=127:
|
||||
return length
|
||||
payloadLength = bytes_to_long(s.read(length & 0x7F))
|
||||
# According to DER (but not BER) the long form is used
|
||||
# only when the length doesn't fit into 7 bits.
|
||||
if payloadLength<=127:
|
||||
raise ValueError("Not a DER length tag (but still valid BER).")
|
||||
return payloadLength
|
||||
|
||||
def decode(self, derEle):
|
||||
"""Decode a complete DER element, and re-initializes this
|
||||
object with it.
|
||||
|
||||
:Parameters:
|
||||
derEle : byte string
|
||||
A complete DER element.
|
||||
|
||||
:Raise ValueError:
|
||||
In case of parsing errors.
|
||||
:Raise EOFError:
|
||||
If the DER element is too short.
|
||||
"""
|
||||
|
||||
s = BytesIO_EOF(derEle)
|
||||
self._decodeFromStream(s)
|
||||
# There shouldn't be other bytes left
|
||||
try:
|
||||
b = s.read_byte()
|
||||
raise ValueError("Unexpected extra data after the DER structure")
|
||||
except EOFError:
|
||||
pass
|
||||
|
||||
def _decodeFromStream(self, s):
|
||||
"""Decode a complete DER element from a file."""
|
||||
|
||||
try:
|
||||
idOctet = bord(s.read_byte())
|
||||
except EOFError:
|
||||
raise NoDerElementError
|
||||
if self._idOctet != None:
|
||||
if idOctet != self._idOctet:
|
||||
raise ValueError("Unexpected DER tag")
|
||||
else:
|
||||
self._idOctet = idOctet
|
||||
length = self._decodeLen(s)
|
||||
self.payload = s.read(length)
|
||||
|
||||
class DerInteger(DerObject):
|
||||
"""Class to model a DER INTEGER.
|
||||
|
||||
An example of encoding is:
|
||||
|
||||
>>> from Crypto.Util.asn1 import DerInteger
|
||||
>>> from binascii import hexlify, unhexlify
|
||||
>>> int_der = DerInteger(9)
|
||||
>>> print hexlify(int_der.encode())
|
||||
|
||||
which will show ``020109``, the DER encoding of 9.
|
||||
|
||||
And for decoding:
|
||||
|
||||
>>> s = unhexlify(b'020109')
|
||||
>>> try:
|
||||
>>> int_der = DerInteger()
|
||||
>>> int_der.decode(s)
|
||||
>>> print int_der.value
|
||||
>>> except (ValueError, EOFError):
|
||||
>>> print "Not a valid DER INTEGER"
|
||||
|
||||
the output will be ``9``.
|
||||
"""
|
||||
|
||||
def __init__(self, value=0, implicit=None):
|
||||
"""Initialize the DER object as an INTEGER.
|
||||
|
||||
:Parameters:
|
||||
value : integer
|
||||
The value of the integer.
|
||||
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag for INTEGER (2).
|
||||
"""
|
||||
|
||||
DerObject.__init__(self, 0x02, b(''), implicit, False)
|
||||
self.value = value #: The integer value
|
||||
|
||||
def encode(self):
|
||||
"""Return the DER INTEGER, fully encoded as a
|
||||
binary string."""
|
||||
|
||||
number = self.value
|
||||
self.payload = b('')
|
||||
while True:
|
||||
self.payload = bchr(number&255) + self.payload
|
||||
if 128 <= number <= 255:
|
||||
self.payload = bchr(0x00) + self.payload
|
||||
if -128 <= number <= 255:
|
||||
break
|
||||
number >>= 8
|
||||
return DerObject.encode(self)
|
||||
|
||||
def decode(self, derEle):
|
||||
"""Decode a complete DER INTEGER DER, and re-initializes this
|
||||
object with it.
|
||||
|
||||
:Parameters:
|
||||
derEle : byte string
|
||||
A complete INTEGER DER element.
|
||||
|
||||
:Raise ValueError:
|
||||
In case of parsing errors.
|
||||
:Raise EOFError:
|
||||
If the DER element is too short.
|
||||
"""
|
||||
DerObject.decode(self, derEle)
|
||||
|
||||
def _decodeFromStream(self, s):
|
||||
"""Decode a complete DER INTEGER from a file."""
|
||||
|
||||
# Fill up self.payload
|
||||
DerObject._decodeFromStream(self, s)
|
||||
|
||||
# Derive self.value from self.payload
|
||||
self.value = 0L
|
||||
bits = 1
|
||||
for i in self.payload:
|
||||
self.value *= 256
|
||||
self.value += bord(i)
|
||||
bits <<= 8
|
||||
if self.payload and bord(self.payload[0]) & 0x80:
|
||||
self.value -= bits
|
||||
|
||||
def newDerInteger(number):
|
||||
"""Create a DerInteger object, already initialized with an integer."""
|
||||
|
||||
der = DerInteger(number)
|
||||
return der
|
||||
|
||||
class DerSequence(DerObject):
|
||||
"""Class to model a DER SEQUENCE.
|
||||
|
||||
This object behaves like a dynamic Python sequence.
|
||||
|
||||
Sub-elements that are INTEGERs behave like Python integers.
|
||||
|
||||
Any other sub-element is a binary string encoded as a complete DER
|
||||
sub-element (TLV).
|
||||
|
||||
An example of encoding is:
|
||||
|
||||
>>> from Crypto.Util.asn1 import DerSequence, DerInteger
|
||||
>>> from binascii import hexlify, unhexlify
|
||||
>>> obj_der = unhexlify('070102')
|
||||
>>> seq_der = DerSequence([4])
|
||||
>>> seq_der.append(9)
|
||||
>>> seq_der.append(obj_der.encode())
|
||||
>>> print hexlify(seq_der.encode())
|
||||
|
||||
which will show ``3009020104020109070102``, the DER encoding of the
|
||||
sequence containing ``4``, ``9``, and the object with payload ``02``.
|
||||
|
||||
For decoding:
|
||||
|
||||
>>> s = unhexlify(b'3009020104020109070102')
|
||||
>>> try:
|
||||
>>> seq_der = DerSequence()
|
||||
>>> seq_der.decode(s)
|
||||
>>> print len(seq_der)
|
||||
>>> print seq_der[0]
|
||||
>>> print seq_der[:]
|
||||
>>> except (ValueError, EOFError):
|
||||
>>> print "Not a valid DER SEQUENCE"
|
||||
|
||||
the output will be::
|
||||
|
||||
3
|
||||
4
|
||||
[4L, 9L, b'\x07\x01\x02']
|
||||
|
||||
"""
|
||||
|
||||
def __init__(self, startSeq=None, implicit=None):
|
||||
"""Initialize the DER object as a SEQUENCE.
|
||||
|
||||
:Parameters:
|
||||
startSeq : Python sequence
|
||||
A sequence whose element are either integers or
|
||||
other DER objects.
|
||||
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag for SEQUENCE (16).
|
||||
"""
|
||||
|
||||
DerObject.__init__(self, 0x10, b(''), implicit, True)
|
||||
if startSeq==None:
|
||||
self._seq = []
|
||||
else:
|
||||
self._seq = startSeq
|
||||
|
||||
## A few methods to make it behave like a python sequence
|
||||
|
||||
def __delitem__(self, n):
|
||||
del self._seq[n]
|
||||
def __getitem__(self, n):
|
||||
return self._seq[n]
|
||||
def __setitem__(self, key, value):
|
||||
self._seq[key] = value
|
||||
def __setslice__(self,i,j,sequence):
|
||||
self._seq[i:j] = sequence
|
||||
def __delslice__(self,i,j):
|
||||
del self._seq[i:j]
|
||||
def __getslice__(self, i, j):
|
||||
return self._seq[max(0, i):max(0, j)]
|
||||
def __len__(self):
|
||||
return len(self._seq)
|
||||
def __iadd__(self, item):
|
||||
self._seq.append(item)
|
||||
return self
|
||||
def append(self, item):
|
||||
self._seq.append(item)
|
||||
return self
|
||||
|
||||
def hasInts(self, onlyNonNegative=True):
|
||||
"""Return the number of items in this sequence that are
|
||||
integers.
|
||||
|
||||
:Parameters:
|
||||
onlyNonNegative : boolean
|
||||
If True, negative integers are not counted in.
|
||||
"""
|
||||
def _isInt2(x):
|
||||
return _isInt(x, onlyNonNegative)
|
||||
return len(filter(_isInt2, self._seq))
|
||||
|
||||
def hasOnlyInts(self, onlyNonNegative=True):
|
||||
"""Return True if all items in this sequence are integers
|
||||
or non-negative integers.
|
||||
|
||||
This function returns False is the sequence is empty,
|
||||
or at least one member is not an integer.
|
||||
|
||||
:Parameters:
|
||||
onlyNonNegative : boolean
|
||||
If True, the presence of negative integers
|
||||
causes the method to return False."""
|
||||
return self._seq and self.hasInts(onlyNonNegative)==len(self._seq)
|
||||
|
||||
def encode(self):
|
||||
"""Return this DER SEQUENCE, fully encoded as a
|
||||
binary string.
|
||||
|
||||
:Raises ValueError:
|
||||
If some elements in the sequence are neither integers
|
||||
nor byte strings.
|
||||
"""
|
||||
self.payload = b('')
|
||||
for item in self._seq:
|
||||
try:
|
||||
self.payload += item
|
||||
except TypeError:
|
||||
try:
|
||||
self.payload += DerInteger(item).encode()
|
||||
except TypeError:
|
||||
raise ValueError("Trying to DER encode an unknown object")
|
||||
return DerObject.encode(self)
|
||||
|
||||
def decode(self, derEle):
|
||||
"""Decode a complete DER SEQUENCE, and re-initializes this
|
||||
object with it.
|
||||
|
||||
:Parameters:
|
||||
derEle : byte string
|
||||
A complete SEQUENCE DER element.
|
||||
|
||||
:Raise ValueError:
|
||||
In case of parsing errors.
|
||||
:Raise EOFError:
|
||||
If the DER element is too short.
|
||||
|
||||
DER INTEGERs are decoded into Python integers. Any other DER
|
||||
element is not decoded. Its validity is not checked.
|
||||
"""
|
||||
DerObject.decode(self, derEle)
|
||||
|
||||
def _decodeFromStream(self, s):
|
||||
"""Decode a complete DER SEQUENCE from a file."""
|
||||
|
||||
self._seq = []
|
||||
|
||||
# Fill up self.payload
|
||||
DerObject._decodeFromStream(self, s)
|
||||
|
||||
# Add one item at a time to self.seq, by scanning self.payload
|
||||
p = BytesIO_EOF(self.payload)
|
||||
while True:
|
||||
try:
|
||||
p.setRecord(True)
|
||||
der = DerObject()
|
||||
der._decodeFromStream(p)
|
||||
|
||||
# Parse INTEGERs differently
|
||||
if der._idOctet != 0x02:
|
||||
self._seq.append(p._recording)
|
||||
else:
|
||||
derInt = DerInteger()
|
||||
derInt.decode(p._recording)
|
||||
self._seq.append(derInt.value)
|
||||
|
||||
except NoDerElementError:
|
||||
break
|
||||
# end
|
||||
|
||||
def newDerSequence(*der_objs):
|
||||
"""Create a DerSequence object, already initialized with all objects
|
||||
passed as parameters."""
|
||||
|
||||
der = DerSequence()
|
||||
for obj in der_objs:
|
||||
if isinstance(obj, DerObject):
|
||||
der += obj.encode()
|
||||
else:
|
||||
der += obj
|
||||
return der
|
||||
|
||||
class DerOctetString(DerObject):
|
||||
"""Class to model a DER OCTET STRING.
|
||||
|
||||
An example of encoding is:
|
||||
|
||||
>>> from Crypto.Util.asn1 import DerOctetString
|
||||
>>> from binascii import hexlify, unhexlify
|
||||
>>> os_der = DerOctetString(b'\\xaa')
|
||||
>>> os_der.payload += b'\\xbb'
|
||||
>>> print hexlify(os_der.encode())
|
||||
|
||||
which will show ``0402aabb``, the DER encoding for the byte string
|
||||
``b'\\xAA\\xBB'``.
|
||||
|
||||
For decoding:
|
||||
|
||||
>>> s = unhexlify(b'0402aabb')
|
||||
>>> try:
|
||||
>>> os_der = DerOctetString()
|
||||
>>> os_der.decode(s)
|
||||
>>> print hexlify(os_der.payload)
|
||||
>>> except (ValueError, EOFError):
|
||||
>>> print "Not a valid DER OCTET STRING"
|
||||
|
||||
the output will be ``aabb``.
|
||||
"""
|
||||
|
||||
def __init__(self, value=b(''), implicit=None):
|
||||
"""Initialize the DER object as an OCTET STRING.
|
||||
|
||||
:Parameters:
|
||||
value : byte string
|
||||
The initial payload of the object.
|
||||
If not specified, the payload is empty.
|
||||
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag for OCTET STRING (4).
|
||||
"""
|
||||
DerObject.__init__(self, 0x04, value, implicit, False)
|
||||
|
||||
def newDerOctetString(binstring):
|
||||
"""Create a DerOctetString object, already initialized with the binary
|
||||
string."""
|
||||
|
||||
if isinstance(binstring, DerObject):
|
||||
der = DerOctetString(binstring.encode())
|
||||
else:
|
||||
der = DerOctetString(binstring)
|
||||
return der
|
||||
|
||||
class DerNull(DerObject):
|
||||
"""Class to model a DER NULL element."""
|
||||
|
||||
def __init__(self):
|
||||
"""Initialize the DER object as a NULL."""
|
||||
|
||||
DerObject.__init__(self, 0x05, b(''), False)
|
||||
|
||||
class DerObjectId(DerObject):
|
||||
"""Class to model a DER OBJECT ID.
|
||||
|
||||
An example of encoding is:
|
||||
|
||||
>>> from Crypto.Util.asn1 import DerObjectId
|
||||
>>> from binascii import hexlify, unhexlify
|
||||
>>> oid_der = DerObjectId("1.2")
|
||||
>>> oid_der.value += ".840.113549.1.1.1"
|
||||
>>> print hexlify(oid_der.encode())
|
||||
|
||||
which will show ``06092a864886f70d010101``, the DER encoding for the
|
||||
RSA Object Identifier ``1.2.840.113549.1.1.1``.
|
||||
|
||||
For decoding:
|
||||
|
||||
>>> s = unhexlify(b'06092a864886f70d010101')
|
||||
>>> try:
|
||||
>>> oid_der = DerObjectId()
|
||||
>>> oid_der.decode(s)
|
||||
>>> print oid_der.value
|
||||
>>> except (ValueError, EOFError):
|
||||
>>> print "Not a valid DER OBJECT ID"
|
||||
|
||||
the output will be ``1.2.840.113549.1.1.1``.
|
||||
"""
|
||||
|
||||
def __init__(self, value='', implicit=None):
|
||||
"""Initialize the DER object as an OBJECT ID.
|
||||
|
||||
:Parameters:
|
||||
value : string
|
||||
The initial Object Identifier (e.g. "1.2.0.0.6.2").
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag for OBJECT ID (6).
|
||||
"""
|
||||
DerObject.__init__(self, 0x06, b(''), implicit, False)
|
||||
self.value = value #: The Object ID, a dot separated list of integers
|
||||
|
||||
def encode(self):
|
||||
"""Return the DER OBJECT ID, fully encoded as a
|
||||
binary string."""
|
||||
|
||||
comps = map(int,self.value.split("."))
|
||||
if len(comps)<2:
|
||||
raise ValueError("Not a valid Object Identifier string")
|
||||
self.payload = bchr(40*comps[0]+comps[1])
|
||||
for v in comps[2:]:
|
||||
enc = []
|
||||
while v:
|
||||
enc.insert(0, (v & 0x7F) | 0x80)
|
||||
v >>= 7
|
||||
enc[-1] &= 0x7F
|
||||
self.payload += b('').join(map(bchr, enc))
|
||||
return DerObject.encode(self)
|
||||
|
||||
def decode(self, derEle):
|
||||
"""Decode a complete DER OBJECT ID, and re-initializes this
|
||||
object with it.
|
||||
|
||||
:Parameters:
|
||||
derEle : byte string
|
||||
A complete DER OBJECT ID.
|
||||
|
||||
:Raise ValueError:
|
||||
In case of parsing errors.
|
||||
:Raise EOFError:
|
||||
If the DER element is too short.
|
||||
"""
|
||||
|
||||
DerObject.decode(self, derEle)
|
||||
|
||||
def _decodeFromStream(self, s):
|
||||
"""Decode a complete DER OBJECT ID from a file."""
|
||||
|
||||
# Fill up self.payload
|
||||
DerObject._decodeFromStream(self, s)
|
||||
|
||||
# Derive self.value from self.payload
|
||||
p = BytesIO_EOF(self.payload)
|
||||
comps = list(map(str, divmod(bord(p.read_byte()),40)))
|
||||
v = 0
|
||||
try:
|
||||
while True:
|
||||
c = p.read_byte()
|
||||
v = v*128 + (bord(c) & 0x7F)
|
||||
if not (bord(c) & 0x80):
|
||||
comps.append(str(v))
|
||||
v = 0
|
||||
except EOFError:
|
||||
pass
|
||||
self.value = '.'.join(comps)
|
||||
|
||||
def newDerObjectId(dottedstring):
|
||||
"""Create a DerObjectId object, already initialized with the given Object
|
||||
Identifier (a dotted string)."""
|
||||
|
||||
der = DerObjectId(dottedstring)
|
||||
return der
|
||||
|
||||
class DerBitString(DerObject):
|
||||
"""Class to model a DER BIT STRING.
|
||||
|
||||
An example of encoding is:
|
||||
|
||||
>>> from Crypto.Util.asn1 import DerBitString
|
||||
>>> from binascii import hexlify, unhexlify
|
||||
>>> bs_der = DerBitString(b'\\xaa')
|
||||
>>> bs_der.value += b'\\xbb'
|
||||
>>> print hexlify(bs_der.encode())
|
||||
|
||||
which will show ``040300aabb``, the DER encoding for the bit string
|
||||
``b'\\xAA\\xBB'``.
|
||||
|
||||
For decoding:
|
||||
|
||||
>>> s = unhexlify(b'040300aabb')
|
||||
>>> try:
|
||||
>>> bs_der = DerBitString()
|
||||
>>> bs_der.decode(s)
|
||||
>>> print hexlify(bs_der.value)
|
||||
>>> except (ValueError, EOFError):
|
||||
>>> print "Not a valid DER OCTET STRING"
|
||||
|
||||
the output will be ``aabb``.
|
||||
"""
|
||||
|
||||
def __init__(self, value=b(''), implicit=None):
|
||||
"""Initialize the DER object as a BIT STRING.
|
||||
|
||||
:Parameters:
|
||||
value : byte string
|
||||
The initial, packed bit string.
|
||||
If not specified, the bit string is empty.
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag for OCTET STRING (3).
|
||||
"""
|
||||
DerObject.__init__(self, 0x03, b(''), implicit, False)
|
||||
self.value = value #: The bitstring value (packed)
|
||||
|
||||
def encode(self):
|
||||
"""Return the DER BIT STRING, fully encoded as a
|
||||
binary string."""
|
||||
|
||||
# Add padding count byte
|
||||
self.payload = b('\x00') + self.value
|
||||
return DerObject.encode(self)
|
||||
|
||||
def decode(self, derEle):
|
||||
"""Decode a complete DER BIT STRING, and re-initializes this
|
||||
object with it.
|
||||
|
||||
:Parameters:
|
||||
derEle : byte string
|
||||
A complete DER BIT STRING.
|
||||
|
||||
:Raise ValueError:
|
||||
In case of parsing errors.
|
||||
:Raise EOFError:
|
||||
If the DER element is too short.
|
||||
"""
|
||||
|
||||
DerObject.decode(self, derEle)
|
||||
|
||||
def _decodeFromStream(self, s):
|
||||
"""Decode a complete DER BIT STRING DER from a file."""
|
||||
|
||||
# Fill-up self.payload
|
||||
DerObject._decodeFromStream(self, s)
|
||||
|
||||
if self.payload and bord(self.payload[0])!=0:
|
||||
raise ValueError("Not a valid BIT STRING")
|
||||
|
||||
# Fill-up self.value
|
||||
self.value = b('')
|
||||
# Remove padding count byte
|
||||
if self.payload:
|
||||
self.value = self.payload[1:]
|
||||
|
||||
def newDerBitString(binstring):
|
||||
"""Create a DerStringString object, already initialized with the binary
|
||||
string."""
|
||||
|
||||
if isinstance(binstring, DerObject):
|
||||
der = DerBitString(binstring.encode())
|
||||
else:
|
||||
der = DerBitString(binstring)
|
||||
return der
|
||||
|
||||
class DerSetOf(DerObject):
|
||||
"""Class to model a DER SET OF.
|
||||
|
||||
An example of encoding is:
|
||||
|
||||
>>> from Crypto.Util.asn1 import DerBitString
|
||||
>>> from binascii import hexlify, unhexlify
|
||||
>>> so_der = DerSetOf([4,5])
|
||||
>>> so_der.add(6)
|
||||
>>> print hexlify(so_der.encode())
|
||||
|
||||
which will show ``3109020104020105020106``, the DER encoding
|
||||
of a SET OF with items 4,5, and 6.
|
||||
|
||||
For decoding:
|
||||
|
||||
>>> s = unhexlify(b'3109020104020105020106')
|
||||
>>> try:
|
||||
>>> so_der = DerSetOf()
|
||||
>>> so_der.decode(s)
|
||||
>>> print [x for x in so_der]
|
||||
>>> except (ValueError, EOFError):
|
||||
>>> print "Not a valid DER SET OF"
|
||||
|
||||
the output will be ``[4L, 5L, 6L]``.
|
||||
"""
|
||||
|
||||
def __init__(self, startSet=None, implicit=None):
|
||||
"""Initialize the DER object as a SET OF.
|
||||
|
||||
:Parameters:
|
||||
startSet : container
|
||||
The initial set of integers or DER encoded objects.
|
||||
implicit : integer
|
||||
The IMPLICIT tag to use for the encoded object.
|
||||
It overrides the universal tag for SET OF (17).
|
||||
"""
|
||||
DerObject.__init__(self, 0x11, b(''), implicit, True)
|
||||
self._seq = []
|
||||
self._elemOctet = None
|
||||
if startSet:
|
||||
for e in startSet:
|
||||
self.add(e)
|
||||
|
||||
def __getitem__(self, n):
|
||||
return self._seq[n]
|
||||
|
||||
def __iter__(self):
|
||||
return iter(self._seq)
|
||||
|
||||
def __len__(self):
|
||||
return len(self._seq)
|
||||
|
||||
def add(self, elem):
|
||||
"""Add an element to the set.
|
||||
|
||||
:Parameters:
|
||||
elem : byte string or integer
|
||||
An element of the same type of objects already in the set.
|
||||
It can be an integer or a DER encoded object.
|
||||
"""
|
||||
if _isInt(elem):
|
||||
eo = 0x02
|
||||
else:
|
||||
eo = bord(elem[0])
|
||||
if self._elemOctet != eo:
|
||||
if self._elemOctet:
|
||||
raise ValueError("New element does not belong to the set")
|
||||
self._elemOctet = eo
|
||||
if not elem in self._seq:
|
||||
self._seq.append(elem)
|
||||
|
||||
def decode(self, derEle):
|
||||
"""Decode a complete SET OF DER element, and re-initializes this
|
||||
object with it.
|
||||
|
||||
DER INTEGERs are decoded into Python integers. Any other DER
|
||||
element is left undecoded; its validity is not checked.
|
||||
|
||||
:Parameters:
|
||||
derEle : byte string
|
||||
A complete DER BIT SET OF.
|
||||
|
||||
:Raise ValueError:
|
||||
In case of parsing errors.
|
||||
:Raise EOFError:
|
||||
If the DER element is too short.
|
||||
"""
|
||||
|
||||
DerObject.decode(self, derEle)
|
||||
|
||||
def _decodeFromStream(self, s):
|
||||
"""Decode a complete DER SET OF from a file."""
|
||||
|
||||
self._seq = []
|
||||
|
||||
# Fill up self.payload
|
||||
DerObject._decodeFromStream(self, s)
|
||||
|
||||
# Add one item at a time to self.seq, by scanning self.payload
|
||||
p = BytesIO_EOF(self.payload)
|
||||
setIdOctet = -1
|
||||
while True:
|
||||
try:
|
||||
p.setRecord(True)
|
||||
der = DerObject()
|
||||
der._decodeFromStream(p)
|
||||
|
||||
# Verify that all members are of the same type
|
||||
if setIdOctet < 0:
|
||||
setIdOctet = der._idOctet
|
||||
else:
|
||||
if setIdOctet != der._idOctet:
|
||||
raise ValueError("Not all elements are of the same DER type")
|
||||
|
||||
# Parse INTEGERs differently
|
||||
if setIdOctet != 0x02:
|
||||
self._seq.append(p._recording)
|
||||
else:
|
||||
derInt = DerInteger()
|
||||
derInt.decode(p._recording)
|
||||
self._seq.append(derInt.value)
|
||||
|
||||
except NoDerElementError:
|
||||
break
|
||||
# end
|
||||
|
||||
def encode(self):
|
||||
"""Return this SET OF DER element, fully encoded as a
|
||||
binary string.
|
||||
"""
|
||||
|
||||
# Elements in the set must be ordered in lexicographic order
|
||||
ordered = []
|
||||
for item in self._seq:
|
||||
if _isInt(item):
|
||||
bys = DerInteger(item).encode()
|
||||
else:
|
||||
bys = item
|
||||
ordered.append(bys)
|
||||
ordered.sort()
|
||||
self.payload = b('').join(ordered)
|
||||
return DerObject.encode(self)
|
||||
|
||||
def newDerSetOf(*der_objs):
|
||||
"""Create a DerSequence object, already initialized with all objects
|
||||
passed as parameters."""
|
||||
|
||||
der = DerSetOf()
|
||||
for obj in der_objs:
|
||||
if isinstance(obj, DerObject):
|
||||
der.add(obj.encode())
|
||||
else:
|
||||
der.add(obj)
|
||||
return der
|
||||
Reference in New Issue
Block a user