Fix unhexlify in Python 3.2

Under Python 3.2, unhexlify expects to receive a `bytes` object.
Passing it a (unicodr) `str` object causes it to raise the following
exception:

    TypeError: 'str' does not support the buffer interface

2 files changed, 33 insertions, 33 deletions

diff --git a/lib/Crypto/SelfTest/PublicKey/test_import_DSA.py b/lib/Crypto/SelfTest/PublicKey/test_import_DSA.py
index 02f7d91..1cb6837 100644
--- a/lib/Crypto/SelfTest/PublicKey/test_import_DSA.py
+++ b/lib/Crypto/SelfTest/PublicKey/test_import_DSA.py
@@ -43,7 +43,7 @@ class ImportKeyTests(unittest.TestCase):
         for mname, mvalue in ImportKeyTests.__dict__.items():
             if mname[:4] in ('der_', 'pem_', 'ssh_'):
                 if mname[:4] == 'der_':
-                    mvalue = unhexlify(mvalue)
+                    mvalue = unhexlify(tobytes(mvalue))
                 mvalue = tobytes(mvalue)
                 setattr(self, mname, mvalue)
 
diff --git a/lib/Crypto/SelfTest/Util/test_Padding.py b/lib/Crypto/SelfTest/Util/test_Padding.py
index 03c28ea..5a3d199 100644
--- a/lib/Crypto/SelfTest/Util/test_Padding.py
+++ b/lib/Crypto/SelfTest/Util/test_Padding.py
@@ -31,32 +31,32 @@ class PKCS7_Tests(unittest.TestCase):
 
     def test1(self):
         padded = pad(b(""), 4)
-        self.failUnless(padded == uh("04040404"))
+        self.failUnless(padded == uh(b("04040404")))
         padded = pad(b(""), 4, 'pkcs7')
-        self.failUnless(padded == uh("04040404"))
+        self.failUnless(padded == uh(b("04040404")))
         back = unpad(padded, 4)
         self.failUnless(back == b(""))
 
     def test2(self):
-        padded = pad(uh("12345678"), 4)
-        self.failUnless(padded == uh("1234567804040404"))
+        padded = pad(uh(b("12345678")), 4)
+        self.failUnless(padded == uh(b("1234567804040404")))
         back = unpad(padded, 4)
-        self.failUnless(back == uh("12345678"))
+        self.failUnless(back == uh(b("12345678")))
 
     def test3(self):
-        padded = pad(uh("123456"), 4)
-        self.failUnless(padded == uh("12345601"))
+        padded = pad(uh(b("123456")), 4)
+        self.failUnless(padded == uh(b("12345601")))
         back = unpad(padded, 4)
-        self.failUnless(back == uh("123456"))
+        self.failUnless(back == uh(b("123456")))
 
     def test4(self):
-        padded = pad(uh("1234567890"), 4)
-        self.failUnless(padded == uh("1234567890030303"))
+        padded = pad(uh(b("1234567890")), 4)
+        self.failUnless(padded == uh(b("1234567890030303")))
         back = unpad(padded, 4)
-        self.failUnless(back == uh("1234567890"))
+        self.failUnless(back == uh(b("1234567890")))
 
     def testn1(self):
-        self.assertRaises(ValueError, pad, uh("12"), 4, 'pkcs8')
+        self.assertRaises(ValueError, pad, uh(b("12")), 4, 'pkcs8')
 
     def testn2(self):
         self.assertRaises(ValueError, unpad, b("\0\0\0"), 4)
@@ -70,27 +70,27 @@ class X923_Tests(unittest.TestCase):
 
     def test1(self):
         padded = pad(b(""), 4, 'x923')
-        self.failUnless(padded == uh("00000004"))
+        self.failUnless(padded == uh(b("00000004")))
         back = unpad(padded, 4, 'x923')
         self.failUnless(back == b(""))
 
     def test2(self):
-        padded = pad(uh("12345678"), 4, 'x923')
-        self.failUnless(padded == uh("1234567800000004"))
+        padded = pad(uh(b("12345678")), 4, 'x923')
+        self.failUnless(padded == uh(b("1234567800000004")))
         back = unpad(padded, 4, 'x923')
-        self.failUnless(back == uh("12345678"))
+        self.failUnless(back == uh(b("12345678")))
 
     def test3(self):
-        padded = pad(uh("123456"), 4, 'x923')
-        self.failUnless(padded == uh("12345601"))
+        padded = pad(uh(b("123456")), 4, 'x923')
+        self.failUnless(padded == uh(b("12345601")))
         back = unpad(padded, 4, 'x923')
-        self.failUnless(back == uh("123456"))
+        self.failUnless(back == uh(b("123456")))
 
     def test4(self):
-        padded = pad(uh("1234567890"), 4, 'x923')
-        self.failUnless(padded == uh("1234567890000003"))
+        padded = pad(uh(b("1234567890")), 4, 'x923')
+        self.failUnless(padded == uh(b("1234567890000003")))
         back = unpad(padded, 4, 'x923')
-        self.failUnless(back == uh("1234567890"))
+        self.failUnless(back == uh(b("1234567890")))
 
     def testn1(self):
         self.assertRaises(ValueError, unpad, b("123456\x02"), 4, 'x923')
@@ -101,28 +101,28 @@ class ISO7816_Tests(unittest.TestCase):
 
     def test1(self):
         padded = pad(b(""), 4, 'iso7816')
-        self.failUnless(padded == uh("80000000"))
+        self.failUnless(padded == uh(b("80000000")))
         back = unpad(padded, 4, 'iso7816')
         self.failUnless(back == b(""))
 
     def test2(self):
-        padded = pad(uh("12345678"), 4, 'iso7816')
-        self.failUnless(padded == uh("1234567880000000"))
+        padded = pad(uh(b("12345678")), 4, 'iso7816')
+        self.failUnless(padded == uh(b("1234567880000000")))
         back = unpad(padded, 4, 'iso7816')
-        self.failUnless(back == uh("12345678"))
+        self.failUnless(back == uh(b("12345678")))
 
     def test3(self):
-        padded = pad(uh("123456"), 4, 'iso7816')
-        self.failUnless(padded == uh("12345680"))
+        padded = pad(uh(b("123456")), 4, 'iso7816')
+        self.failUnless(padded == uh(b("12345680")))
         #import pdb; pdb.set_trace()
         back = unpad(padded, 4, 'iso7816')
-        self.failUnless(back == uh("123456"))
+        self.failUnless(back == uh(b("123456")))
 
     def test4(self):
-        padded = pad(uh("1234567890"), 4, 'iso7816')
-        self.failUnless(padded == uh("1234567890800000"))
+        padded = pad(uh(b("1234567890")), 4, 'iso7816')
+        self.failUnless(padded == uh(b("1234567890800000")))
         back = unpad(padded, 4, 'iso7816')
-        self.failUnless(back == uh("1234567890"))
+        self.failUnless(back == uh(b("1234567890")))
 
     def testn1(self):
         self.assertRaises(ValueError, unpad, b("123456\x81"), 4, 'iso7816')