Refactoring of the asn1 module

The following changes are included:

- Decoding is a much simpler operation. The internal
  logic is based on stream of binary data, and not
  on string indexing anymore. Additionally,
  decoding used to look like this:

     bitmap = DerObject()
     bitmap.decode(input_buffer, True)
     if bitmap.isType('BIT STRING'):
        ... proceed with parsing ...
     else:
        ... error ...

  Whereas now, it is cleaner and more compact:

     bitmap = DerBitString()
     bitmap.decode(input_buffer)

  Any error condition will lead to an exception.

- isType() method has been removed because of the above.
- Added examples and documentation
- Added support IMPLICIT tags
- Added support for negative INTEGERs
- Added DerSetOf ASN.1 class
- DerObjectID can be initialized from the dotted representation of
  the Object ID.
- DerBitString has a new member 'value' to hold the binary
  string. The member 'payload' should not be accessed anymore.
- DerObjectID has a new member 'value' to hold the dotted representation
  of the Object ID string. The member 'payload' should not be accessed
  anymore.
- Added operator += to DER SEQUENCE. Now it is possible to do:

      my_str = DerOctetString(b'ZYZ')
      seq = DerSequence()
      seq += 0
      seq += my_str.encode()
- Update to test cases

1 files changed, 604 insertions, 244 deletions

diff --git a/lib/Crypto/SelfTest/Util/test_asn1.py b/lib/Crypto/SelfTest/Util/test_asn1.py
index bbd0a39..58d12b4 100644
--- a/lib/Crypto/SelfTest/Util/test_asn1.py
+++ b/lib/Crypto/SelfTest/Util/test_asn1.py
@@ -28,262 +28,622 @@ import unittest
 import sys
 
 from Crypto.Util.py3compat import *
-from Crypto.Util.asn1 import DerSequence, DerObject
+from Crypto.Util.asn1 import *
+if sys.version_info[0] == 2 and sys.version_info[1] == 1:
+    from Crypto.Util.py21compat import *
 
 class DerObjectTests(unittest.TestCase):
 
-	def testObjEncode1(self):
-		# No payload
-		der = DerObject(b('\x33'))
-		self.assertEquals(der.encode(), b('\x33\x00'))
-		# Small payload
-		der.payload = b('\x45')
-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
-		# Invariant
-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
-		# Initialize with numerical tag
-		der = DerObject(b(0x33))
-		der.payload = b('\x45')
-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
-
-	def testObjEncode2(self):
-		# Known types
-		der = DerObject('SEQUENCE')
-		self.assertEquals(der.encode(), b('\x30\x00'))
-		der = DerObject('BIT STRING')
-		self.assertEquals(der.encode(), b('\x03\x00'))
-		
-	def testObjEncode3(self):
-		# Long payload
-		der = DerObject(b('\x34'))
-		der.payload = b("0")*128
-		self.assertEquals(der.encode(), b('\x34\x81\x80' + "0"*128))		
-
-	def testObjDecode1(self):
-		# Decode short payload
-		der = DerObject()
-		der.decode(b('\x20\x02\x01\x02'))
-		self.assertEquals(der.payload, b("\x01\x02"))
-		self.assertEquals(der.typeTag, 0x20)
-
-	def testObjDecode2(self):
-		# Decode short payload
-		der = DerObject()
-		der.decode(b('\x22\x81\x80' + "1"*128))
-		self.assertEquals(der.payload, b("1")*128)
-		self.assertEquals(der.typeTag, 0x22)
+    def testObjInit1(self):
+        # Fail with invalid tag format (must be 1 byte)
+        self.assertRaises(ValueError, DerObject, b('\x00\x99'))
+        # Fail with invalid implicit tag (must be <0x1F)
+        self.assertRaises(ValueError, DerObject, 0x1F)
 
+    # ------
+
+    def testObjEncode1(self):
+        # No payload
+        der = DerObject(b('\x02'))
+        self.assertEquals(der.encode(), b('\x02\x00'))
+        # Small payload (primitive)
+        der.payload = b('\x45')
+        self.assertEquals(der.encode(), b('\x02\x01\x45'))
+        # Invariant
+        self.assertEquals(der.encode(), b('\x02\x01\x45'))
+        # Initialize with numerical tag
+        der = DerObject(0x04)
+        der.payload = b('\x45')
+        self.assertEquals(der.encode(), b('\x04\x01\x45'))
+        # Initialize with constructed type
+        der = DerObject(b('\x10'), constructed=True)
+        self.assertEquals(der.encode(), b('\x30\x00'))
+
+    def testObjEncode2(self):
+        # Initialize with payload
+        der = DerObject(0x03, b('\x12\x12'))
+        self.assertEquals(der.encode(), b('\x03\x02\x12\x12'))
+        
+    def testObjEncode3(self):
+        # Long payload
+        der = DerObject(b('\x10'))
+        der.payload = b("0")*128
+        self.assertEquals(der.encode(), b('\x10\x81\x80' + "0"*128))        
+
+    def testObjEncode4(self):
+        # Implicit tags (constructed)
+        der = DerObject(0x10, implicit=1, constructed=True)
+        der.payload = b('ppll')
+        self.assertEquals(der.encode(), b('\xa1\x04ppll'))
+        # Implicit tags (primitive)
+        der = DerObject(0x02, implicit=0x1E, constructed=False)
+        der.payload = b('ppll')
+        self.assertEquals(der.encode(), b('\x9E\x04ppll'))
+    
+    # -----
+
+    def testObjDecode1(self):
+        # Decode short payload
+        der = DerObject(0x02)
+        der.decode(b('\x02\x02\x01\x02'))
+        self.assertEquals(der.payload, b("\x01\x02"))
+        self.assertEquals(der._idOctet, 0x02)
+
+    def testObjDecode2(self):
+        # Decode long payload
+        der = DerObject(0x02)
+        der.decode(b('\x02\x81\x80' + "1"*128))
+        self.assertEquals(der.payload, b("1")*128)
+        self.assertEquals(der._idOctet, 0x02)
+
+    def testObjDecode3(self):
+        # Decode payload with too much data gives error
+        der = DerObject(0x02)
+        self.assertRaises(ValueError, der.decode, b('\x02\x02\x01\x02\xFF'))
+        # Decode payload with too little data gives error
+        der = DerObject(0x02)
+        self.assertRaises(EOFError, der.decode, b('\x02\x02\x01'))
+
+    def testObjDecode4(self):
+        # Decode implicit tag (primitive)
+        der = DerObject(0x02, constructed=False, implicit=0xF)
+        self.assertRaises(ValueError, der.decode, b('\x02\x02\x01\x02'))
+        der.decode(b('\x8F\x01\x00'))
+        self.assertEquals(der.payload, b('\x00'))
+        # Decode implicit tag (constructed)
+        der = DerObject(0x02, constructed=True, implicit=0xF)
+        self.assertRaises(ValueError, der.decode, b('\x02\x02\x01\x02'))
+        der.decode(b('\xAF\x01\x00'))
+        self.assertEquals(der.payload, b('\x00'))
+
+    def testObjDecode5(self):
+        # Decode payload with unexpected tag gives error
+        der = DerObject(0x02)
+        self.assertRaises(ValueError, der.decode, b('\x03\x02\x01\x02'))
+
+    def testObjDecode6(self):
+        # Arbitrary DER object
+        der = DerObject()
+        der.decode(b('\x65\x01\x88'))
+        self.assertEquals(der._idOctet, 0x65)
+        self.assertEquals(der.payload, b('\x88'))
+
+class DerIntegerTests(unittest.TestCase):
+
+    def testInit1(self):
+        der = newDerInteger(1)
+        self.assertEquals(der.encode(), b('\x02\x01\x01'))
+
+    def testEncode1(self):
+        # Single-byte integers
+        # Value 0
+        der = DerInteger(0)
+        self.assertEquals(der.encode(), b('\x02\x01\x00'))
+        # Value 1
+        der = DerInteger(1)
+        self.assertEquals(der.encode(), b('\x02\x01\x01'))
+        # Value 127
+        der = DerInteger(127)
+        self.assertEquals(der.encode(), b('\x02\x01\x7F'))
+
+    def testEncode2(self):
+        # Multi-byte integers
+        # Value 128
+        der = DerInteger(128)
+        self.assertEquals(der.encode(), b('\x02\x02\x00\x80'))
+        # Value 0x180
+        der = DerInteger(0x180L)
+        self.assertEquals(der.encode(), b('\x02\x02\x01\x80'))
+        # One very long integer
+        der = DerInteger(2L**2048)
+        self.assertEquals(der.encode(),
+        b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
+
+    def testEncode3(self):
+        # Negative integers
+        # Value -1
+        der = DerInteger(-1)
+        self.assertEquals(der.encode(), b('\x02\x01\xFF'))
+        # Value -128
+        der = DerInteger(-128)
+        self.assertEquals(der.encode(), b('\x02\x01\x80'))
+        # Value 
+        der = DerInteger(-87873)
+        self.assertEquals(der.encode(), b('\x02\x03\xFE\xA8\xBF'))
+
+    # -----
+
+    def testDecode1(self):
+        # Single-byte integer
+        der = DerInteger()
+        # Value 0
+        der.decode(b('\x02\x01\x00'))
+        self.assertEquals(der.value, 0)
+        # Value 1
+        der.decode(b('\x02\x01\x01'))
+        self.assertEquals(der.value, 1)
+        # Value 127
+        der.decode(b('\x02\x01\x7F'))
+        self.assertEquals(der.value, 127)
+
+    def testDecode2(self):
+        # Multi-byte integer
+        der = DerInteger()
+        # Value 0x180L
+        der.decode(b('\x02\x02\x01\x80'))
+        self.assertEquals(der.value,0x180L)
+        # One very long integer
+        der.decode(
+        b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
+        self.assertEquals(der.value,2L**2048)
+
+    def testDecode3(self):
+        # Negative integer
+        der = DerInteger()
+        # Value -1
+        der.decode(b('\x02\x01\xFF'))
+        self.assertEquals(der.value, -1)
+        # Value -32768
+        der.decode(b('\x02\x02\x80\x00'))
+        self.assertEquals(der.value, -32768)
+
+    def testDecode5(self):
+        # We still accept BER integer format
+        der = DerInteger()
+        # Redundant leading zeroes
+        der.decode(b('\x02\x02\x00\x01'))
+        self.assertEquals(der.value, 1)
+        # Redundant leading 0xFF
+        der.decode(b('\x02\x02\xFF\xFF'))
+        self.assertEquals(der.value, -1)
+        # Empty payload
+        der.decode(b('\x02\x00'))
+        self.assertEquals(der.value, 0)
+
+    def testErrDecode1(self):
+        # Wide length field
+        der = DerInteger()
+        self.assertRaises(ValueError, der.decode, b('\x02\x81\x01\x01'))
+ 
 class DerSequenceTests(unittest.TestCase):
 
-	def testEncode1(self):
-		# Empty sequence
-		der = DerSequence()
-		self.assertEquals(der.encode(), b('0\x00'))
-		self.failIf(der.hasOnlyInts())
-		# One single-byte integer (zero)
-		der.append(0)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
-		self.failUnless(der.hasOnlyInts())
-		# Invariant
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
-
-	def testEncode2(self):
-		# One single-byte integer (non-zero)
-		der = DerSequence()
-		der.append(127)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x7f'))
-		# Indexing
-		der[0] = 1
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],1)
-		self.assertEquals(der[-1],1)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x01'))
-		#
-		der[:] = [1]
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],1)
-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x01'))
-	
-	def testEncode3(self):
-		# One multi-byte integer (non-zero)
-		der = DerSequence()
-		der.append(0x180L)
-		self.assertEquals(der.encode(), b('0\x04\x02\x02\x01\x80'))
-	
-	def testEncode4(self):
-		# One very long integer
-		der = DerSequence()
-		der.append(2**2048)
-		self.assertEquals(der.encode(), b('0\x82\x01\x05')+
-		b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
-
-	def testEncode5(self):
-		# One single-byte integer (looks negative)
-		der = DerSequence()
-		der.append(0xFFL)
-		self.assertEquals(der.encode(), b('0\x04\x02\x02\x00\xff'))
-	
-	def testEncode6(self):
-		# Two integers
-		der = DerSequence()
-		der.append(0x180L)
-		der.append(0xFFL)
-		self.assertEquals(der.encode(), b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
-		self.failUnless(der.hasOnlyInts())
-		#
-		der.append(0x01)
-		der[1:] = [9,8]
-		self.assertEquals(len(der),3)
-		self.assertEqual(der[1:],[9,8])
-		self.assertEqual(der[1:-1],[9])
-		self.assertEquals(der.encode(), b('0\x0A\x02\x02\x01\x80\x02\x01\x09\x02\x01\x08'))
-
-	def testEncode7(self):
-		# One integer and another type (no matter what it is)
-		der = DerSequence()
-		der.append(0x180L)
-		der.append(b('\x00\x02\x00\x00'))
-		self.assertEquals(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
-		self.failIf(der.hasOnlyInts())
-
-	####
-
-	def testDecode1(self):
-		# Empty sequence
-		der = DerSequence()
-		der.decode(b('0\x00'))
-		self.assertEquals(len(der),0)
-		# One single-byte integer (zero)
-		der.decode(b('0\x03\x02\x01\x00'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0)
-		# Invariant
-		der.decode(b('0\x03\x02\x01\x00'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0)
-
-	def testDecode2(self):
-		# One single-byte integer (non-zero)
-		der = DerSequence()
-		der.decode(b('0\x03\x02\x01\x7f'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],127)
-	
-	def testDecode3(self):
-		# One multi-byte integer (non-zero)
-		der = DerSequence()
-		der.decode(b('0\x04\x02\x02\x01\x80'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0x180L)
-
-	def testDecode4(self):
-		# One very long integer
-		der = DerSequence()
-		der.decode(b('0\x82\x01\x05')+
-		b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
-		b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],2**2048)
-
-	def testDecode5(self):
-		# One single-byte integer (looks negative)
-		der = DerSequence()
-		der.decode(b('0\x04\x02\x02\x00\xff'))
-		self.assertEquals(len(der),1)
-		self.assertEquals(der[0],0xFFL)
-
-	def testDecode6(self):
-		# Two integers
-		der = DerSequence()
-		der.decode(b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
-		self.assertEquals(len(der),2)
-		self.assertEquals(der[0],0x180L)
-		self.assertEquals(der[1],0xFFL)
-
-	def testDecode7(self):
-		# One integer and 2 other types
-		der = DerSequence()
-		der.decode(b('0\x0A\x02\x02\x01\x80\x24\x02\xb6\x63\x12\x00'))
-		self.assertEquals(len(der),3)
-		self.assertEquals(der[0],0x180L)
-		self.assertEquals(der[1],b('\x24\x02\xb6\x63'))
-		self.assertEquals(der[2],b('\x12\x00'))
-
-	def testDecode8(self):
-		# Only 2 other types
-		der = DerSequence()
-		der.decode(b('0\x06\x24\x02\xb6\x63\x12\x00'))
-		self.assertEquals(len(der),2)
-		self.assertEquals(der[0],b('\x24\x02\xb6\x63'))
-		self.assertEquals(der[1],b('\x12\x00'))
-
-	def testErrDecode1(self):
-		# Not a sequence
-		der = DerSequence()
-		self.assertRaises(ValueError, der.decode, b(''))
-		self.assertRaises(ValueError, der.decode, b('\x00'))
-		self.assertRaises(ValueError, der.decode, b('\x30'))
-
-	def testErrDecode2(self):
-		# Wrong payload type
-		der = DerSequence()
-		self.assertRaises(ValueError, der.decode, b('\x30\x00\x00'), True)
-
-	def testErrDecode3(self):
-		# Wrong length format
-		der = DerSequence()
-		self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\x01\x00'))
-		self.assertRaises(ValueError, der.decode, b('\x30\x81\x03\x02\x01\x01'))
-		self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x81\x01\x01'))
-
-	def testErrDecode4(self):
-		# Wrong integer format
-		der = DerSequence()
-		# Multi-byte encoding for zero
-		#self.assertRaises(ValueError, der.decode, '\x30\x04\x02\x02\x00\x00')
-		# Negative integer
-		self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x01\xFF'))
+    def testInit1(self):
+        der = newDerSequence(1, DerInteger(2), '0\x00')
+        self.assertEquals(der.encode(), b('0\x08\x02\x01\x01\x02\x01\x020\x00'))
+
+    def testEncode1(self):
+        # Empty sequence
+        der = DerSequence()
+        self.assertEquals(der.encode(), b('0\x00'))
+        self.failIf(der.hasOnlyInts())
+        # One single-byte integer (zero)
+        der.append(0)
+        self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
+        self.assertEquals(der.hasInts(),1)
+        self.assertEquals(der.hasInts(False),1)
+        self.failUnless(der.hasOnlyInts())
+        self.failUnless(der.hasOnlyInts(False))
+        # Invariant
+        self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
+
+    def testEncode2(self):
+        # Indexing
+        der = DerSequence()
+        der.append(0)
+        der[0] = 1
+        self.assertEquals(len(der),1)
+        self.assertEquals(der[0],1)
+        self.assertEquals(der[-1],1)
+        self.assertEquals(der.encode(), b('0\x03\x02\x01\x01'))
+        #
+        der[:] = [1]
+        self.assertEquals(len(der),1)
+        self.assertEquals(der[0],1)
+        self.assertEquals(der.encode(), b('0\x03\x02\x01\x01'))
+    
+    def testEncode3(self):
+        # One multi-byte integer (non-zero)
+        der = DerSequence()
+        der.append(0x180L)
+        self.assertEquals(der.encode(), b('0\x04\x02\x02\x01\x80'))
+    
+    def testEncode4(self):
+        # One very long integer
+        der = DerSequence()
+        der.append(2L**2048)
+        self.assertEquals(der.encode(), b('0\x82\x01\x05')+
+        b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
+
+    def testEncode5(self):
+        der = DerSequence()
+        der += 1
+        der += b('\x30\x00')
+        self.assertEquals(der.encode(), b('\x30\x05\x02\x01\x01\x30\x00'))
+
+    def testEncode6(self):
+        # Two positive integers
+        der = DerSequence()
+        der.append(0x180L)
+        der.append(0xFFL)
+        self.assertEquals(der.encode(), b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
+        self.failUnless(der.hasOnlyInts())
+        self.failUnless(der.hasOnlyInts(False))
+        # Two mixed integers
+        der = DerSequence()
+        der.append(2)
+        der.append(-2)
+        self.assertEquals(der.encode(), b('0\x06\x02\x01\x02\x02\x01\xFE'))
+        self.assertEquals(der.hasInts(), 1)
+        self.assertEquals(der.hasInts(False), 2)
+        self.failIf(der.hasOnlyInts())
+        self.failUnless(der.hasOnlyInts(False))
+        #
+        der.append(0x01)
+        der[1:] = [9,8]
+        self.assertEquals(len(der),3)
+        self.assertEqual(der[1:],[9,8])
+        self.assertEqual(der[1:-1],[9])
+        self.assertEquals(der.encode(), b('0\x09\x02\x01\x02\x02\x01\x09\x02\x01\x08'))
+
+    def testEncode7(self):
+        # One integer and another type (no matter what it is)
+        der = DerSequence()
+        der.append(0x180L)
+        der.append(b('\x00\x02\x00\x00'))
+        self.assertEquals(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
+        self.failIf(der.hasOnlyInts())
+
+    ####
+
+    def testDecode1(self):
+        # Empty sequence
+        der = DerSequence()
+        der.decode(b('0\x00'))
+        self.assertEquals(len(der),0)
+        # One single-byte integer (zero)
+        der.decode(b('0\x03\x02\x01\x00'))
+        self.assertEquals(len(der),1)
+        self.assertEquals(der[0],0)
+        # Invariant
+        der.decode(b('0\x03\x02\x01\x00'))
+        self.assertEquals(len(der),1)
+        self.assertEquals(der[0],0)
+
+    def testDecode2(self):
+        # One single-byte integer (non-zero)
+        der = DerSequence()
+        der.decode(b('0\x03\x02\x01\x7f'))
+        self.assertEquals(len(der),1)
+        self.assertEquals(der[0],127)
+    
+    def testDecode4(self):
+        # One very long integer
+        der = DerSequence()
+        der.decode(b('0\x82\x01\x05')+
+        b('\x02\x82\x01\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')+
+        b('\x00\x00\x00\x00\x00\x00\x00\x00\x00'))
+        self.assertEquals(len(der),1)
+        self.assertEquals(der[0],2L**2048)
+
+    def testDecode6(self):
+        # Two integers
+        der = DerSequence()
+        der.decode(b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
+        self.assertEquals(len(der),2)
+        self.assertEquals(der[0],0x180L)
+        self.assertEquals(der[1],0xFFL)
+
+    def testDecode7(self):
+        # One integer and 2 other types
+        der = DerSequence()
+        der.decode(b('0\x0A\x02\x02\x01\x80\x24\x02\xb6\x63\x12\x00'))
+        self.assertEquals(len(der),3)
+        self.assertEquals(der[0],0x180L)
+        self.assertEquals(der[1],b('\x24\x02\xb6\x63'))
+        self.assertEquals(der[2],b('\x12\x00'))
+
+    def testDecode8(self):
+        # Only 2 other types
+        der = DerSequence()
+        der.decode(b('0\x06\x24\x02\xb6\x63\x12\x00'))
+        self.assertEquals(len(der),2)
+        self.assertEquals(der[0],b('\x24\x02\xb6\x63'))
+        self.assertEquals(der[1],b('\x12\x00'))
+        self.assertEquals(der.hasInts(), 0)
+        self.assertEquals(der.hasInts(False), 0)
+        self.failIf(der.hasOnlyInts())
+        self.failIf(der.hasOnlyInts(False))
+
+    def testErrDecode1(self):
+        # Not a sequence
+        der = DerSequence()
+        self.assertRaises(EOFError, der.decode, b(''))
+        self.assertRaises(ValueError, der.decode, b('\x00'))
+        self.assertRaises(EOFError, der.decode, b('\x30'))
+
+    def testErrDecode2(self):
+        der = DerSequence()
+        # Too much data
+        self.assertRaises(ValueError, der.decode, b('\x30\x00\x00'))
+
+    def testErrDecode3(self):
+        # Wrong length format
+        der = DerSequence()
+        # Missing length in sub-item
+        self.assertRaises(EOFError, der.decode, b('\x30\x04\x02\x01\x01\x00'))
+        # Valid BER, but invalid DER length
+        self.assertRaises(ValueError, der.decode, b('\x30\x81\x03\x02\x01\x01'))
+        self.assertRaises(ValueError, der.decode, b('\x30\x04\x02\x81\x01\x01'))
+
+class DerOctetStringTests(unittest.TestCase):
+
+    def testInit1(self):
+        der = newDerOctetString(b('\xFF'))
+        self.assertEquals(der.encode(), b('\x04\x01\xFF'))
+
+    def testEncode1(self):
+        # Empty sequence
+        der = DerOctetString()
+        self.assertEquals(der.encode(), b('\x04\x00'))
+        # Small payload
+        der.payload = b('\x01\x02')
+        self.assertEquals(der.encode(), b('\x04\x02\x01\x02'))
+
+    ####
+
+    def testDecode1(self):
+        # Empty sequence
+        der = DerOctetString()
+        der.decode(b('\x04\x00'))
+        self.assertEquals(der.payload, b(''))
+        # Small payload
+        der.decode(b('\x04\x02\x01\x02'))
+        self.assertEquals(der.payload, b('\x01\x02'))
+
+    def testErrDecode1(self):
+        # No leftovers allowed
+        der = DerOctetString()
+        self.assertRaises(ValueError, der.decode, b('\x04\x01\x01\xff'))
+ 
+class DerNullTests(unittest.TestCase):
+
+    def testEncode1(self):
+        der = DerNull()
+        self.assertEquals(der.encode(), b('\x05\x00'))
+
+    ####
+
+    def testDecode1(self):
+        # Empty sequence
+        der = DerNull()
+        der.decode(b('\x05\x00'))
+
+class DerObjectIdTests(unittest.TestCase):
+
+    def testInit1(self):
+        der = newDerObjectId("1.1")
+        self.assertEquals(der.encode(), b('\x06\x01)'))
+
+    def testEncode1(self):
+        der = DerObjectId('1.2.840.113549.1.1.1')
+        self.assertEquals(der.encode(), b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))
+        #
+        der = DerObjectId()
+        der.value = '1.2.840.113549.1.1.1'
+        self.assertEquals(der.encode(), b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))
+
+    ####
+
+    def testDecode1(self):
+        # Empty sequence
+        der = DerObjectId()
+        der.decode(b('\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01'))
+        self.assertEquals(der.value, '1.2.840.113549.1.1.1')
+
+class DerBitStringTests(unittest.TestCase):
+
+    def testInit1(self):
+        der = newDerBitString(b("\xFF"))
+        self.assertEquals(der.encode(), b('\x03\x02\x00\xFF'))
+
+    def testEncode1(self):
+        # Empty sequence
+        der = DerBitString()
+        self.assertEquals(der.encode(), b('\x03\x01\x00'))
+        # Small payload
+        der = DerBitString(b('\x01\x02'))
+        self.assertEquals(der.encode(), b('\x03\x03\x00\x01\x02'))
+        # Small payload
+        der = DerBitString()
+        der.value = b('\x01\x02')
+        self.assertEquals(der.encode(), b('\x03\x03\x00\x01\x02'))
+
+    ####
+
+    def testDecode1(self):
+        # Empty sequence
+        der = DerBitString()
+        der.decode(b('\x03\x00'))
+        self.assertEquals(der.value, b(''))
+        # Small payload
+        der.decode(b('\x03\x03\x00\x01\x02'))
+        self.assertEquals(der.value, b('\x01\x02'))
+
+class DerSetOfTests(unittest.TestCase):
+
+    def testInit1(self):
+        der = newDerSetOf(DerInteger(1), DerInteger(2))
+        self.assertEquals(der.encode(), b('1\x06\x02\x01\x01\x02\x01\x02'))
+
+    def testEncode1(self):
+        # Empty set
+        der = DerSetOf()
+        self.assertEquals(der.encode(), b('1\x00'))
+        # One single-byte integer (zero)
+        der.add(0)
+        self.assertEquals(der.encode(), b('1\x03\x02\x01\x00'))
+        # Invariant
+        self.assertEquals(der.encode(), b('1\x03\x02\x01\x00'))
+
+    def testEncode2(self):
+        # Two integers
+        der = DerSetOf()
+        der.add(0x180L)
+        der.add(0xFFL)
+        self.assertEquals(der.encode(), b('1\x08\x02\x02\x00\xff\x02\x02\x01\x80'))
+        # Initialize with integers
+        der = DerSetOf([0x180L, 0xFFL])
+        self.assertEquals(der.encode(), b('1\x08\x02\x02\x00\xff\x02\x02\x01\x80'))
+
+    def testEncode3(self):
+        # One integer and another type (no matter what it is)
+        der = DerSetOf()
+        der.add(0x180L)
+        self.assertRaises(ValueError, der.add, b('\x00\x02\x00\x00'))
+
+    def testEncode4(self):
+        # Only non integers
+        der = DerSetOf()
+        der.add(b('\x01\x00'))
+        der.add(b('\x01\x01\x01'))
+        self.assertEquals(der.encode(), b('1\x05\x01\x00\x01\x01\x01'))
+
+    ####
+
+    def testDecode1(self):
+        # Empty sequence
+        der = DerSetOf()
+        der.decode(b('1\x00'))
+        self.assertEquals(len(der),0)
+        # One single-byte integer (zero)
+        der.decode(b('1\x03\x02\x01\x00'))
+        self.assertEquals(len(der),1)
+        self.assertEquals(list(der),[0])
+
+    def testDecode2(self):
+        # Two integers
+        der = DerSetOf()
+        der.decode(b('1\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
+        self.assertEquals(len(der),2)
+        l = list(der)
+        self.failUnless(0x180 in l)
+        self.failUnless(0xFF in l)
+
+    def testDecode3(self):
+        # One integer and 2 other types
+        der = DerSetOf()
+        #import pdb; pdb.set_trace()
+        self.assertRaises(ValueError, der.decode,
+            b('0\x0A\x02\x02\x01\x80\x24\x02\xb6\x63\x12\x00'))
 
+    def testErrDecode1(self):
+        # No leftovers allowed
+        der = DerSetOf()
+        self.assertRaises(ValueError, der.decode,
+            b('1\x08\x02\x02\x01\x80\x02\x02\x00\xff\xAA'))
+ 
 def get_tests(config={}):
     from Crypto.SelfTest.st_common import list_test_cases
     listTests = []
     listTests += list_test_cases(DerObjectTests)
+    listTests += list_test_cases(DerIntegerTests)
     listTests += list_test_cases(DerSequenceTests)
+    listTests += list_test_cases(DerOctetStringTests)
+    listTests += list_test_cases(DerNullTests)
+    listTests += list_test_cases(DerObjectIdTests)
+    listTests += list_test_cases(DerBitStringTests)
+    listTests += list_test_cases(DerSetOfTests)
     return listTests
 
 if __name__ == '__main__':