security/py-pycrypto: Fix build with setuptools 58.0.0+

3 files changed, 1336 insertions, 7 deletions

diff --git a/security/py-pycrypto/files/patch-2to3 b/security/py-pycrypto/files/patch-2to3
new file mode 100644
index 000000000000..19396d777fa0
--- /dev/null
+++ b/security/py-pycrypto/files/patch-2to3
@@ -0,0 +1,1329 @@
+--- lib/Crypto/Protocol/AllOrNothing.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/Protocol/AllOrNothing.py
+@@ -48,6 +48,7 @@ import operator
+ import sys
+ from Crypto.Util.number import bytes_to_long, long_to_bytes
+ from Crypto.Util.py3compat import *
++from functools import reduce
+ 
+ def isInt(x):
+     test = 0
+@@ -186,11 +187,11 @@ class AllOrNothing:
+         # better have at least 2 blocks, for the padbytes package and the hash
+         # block accumulator
+         if len(blocks) < 2:
+-            raise ValueError, "List must be at least length 2."
++            raise ValueError("List must be at least length 2.")
+ 
+         # blocks is a list of strings.  We need to deal with them as long
+         # integers
+-        blocks = map(bytes_to_long, blocks)
++        blocks = list(map(bytes_to_long, blocks))
+ 
+         # Calculate the well-known key, to which the hash blocks are
+         # encrypted, and create the hash cipher.
+@@ -271,15 +272,15 @@ Where:
+ 
+     def usage(code, msg=None):
+         if msg:
+-            print msg
+-        print usagemsg % {'program': sys.argv[0],
+-                          'ciphermodule': ciphermodule}
++            print(msg)
++        print(usagemsg % {'program': sys.argv[0],
++                          'ciphermodule': ciphermodule})
+         sys.exit(code)
+ 
+     try:
+         opts, args = getopt.getopt(sys.argv[1:],
+                                    'c:l', ['cipher=', 'aslong'])
+-    except getopt.error, msg:
++    except getopt.error as msg:
+         usage(1, msg)
+ 
+     if args:
+@@ -297,23 +298,23 @@ Where:
+     module = __import__('Crypto.Cipher.'+ciphermodule, None, None, ['new'])
+ 
+     x = AllOrNothing(module)
+-    print 'Original text:\n=========='
+-    print __doc__
+-    print '=========='
++    print('Original text:\n==========')
++    print(__doc__)
++    print('==========')
+     msgblocks = x.digest(b(__doc__))
+-    print 'message blocks:'
+-    for i, blk in zip(range(len(msgblocks)), msgblocks):
++    print('message blocks:')
++    for i, blk in zip(list(range(len(msgblocks))), msgblocks):
+         # base64 adds a trailing newline
+-        print '    %3d' % i,
++        print('    %3d' % i, end=' ')
+         if aslong:
+-            print bytes_to_long(blk)
++            print(bytes_to_long(blk))
+         else:
+-            print base64.encodestring(blk)[:-1]
++            print(base64.encodestring(blk)[:-1])
+     #
+     # get a new undigest-only object so there's no leakage
+     y = AllOrNothing(module)
+     text = y.undigest(msgblocks)
+     if text == b(__doc__):
+-        print 'They match!'
++        print('They match!')
+     else:
+-        print 'They differ!'
++        print('They differ!')
+--- lib/Crypto/Protocol/Chaffing.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/Protocol/Chaffing.py
+@@ -106,9 +106,9 @@ class Chaff:
+         """
+ 
+         if not (0.0<=factor<=1.0):
+-            raise ValueError, "'factor' must be between 0.0 and 1.0"
++            raise ValueError("'factor' must be between 0.0 and 1.0")
+         if blocksper < 0:
+-            raise ValueError, "'blocksper' must be zero or more"
++            raise ValueError("'blocksper' must be zero or more")
+ 
+         self.__factor = factor
+         self.__blocksper = blocksper
+@@ -139,8 +139,8 @@ class Chaff:
+         # number of chaff blocks to add per message block that is being
+         # chaffed.
+         count = len(blocks) * self.__factor
+-        blocksper = range(self.__blocksper)
+-        for i, wheat in zip(range(len(blocks)), blocks):
++        blocksper = list(range(self.__blocksper))
++        for i, wheat in zip(list(range(len(blocks))), blocks):
+             # it shouldn't matter which of the n blocks we add chaff to, so for
+             # ease of implementation, we'll just add them to the first count
+             # blocks
+@@ -185,9 +185,9 @@ abolish it, and to institute new Government, laying it
+ principles and organizing its powers in such form, as to them shall seem most
+ likely to effect their Safety and Happiness.
+ """
+-    print 'Original text:\n=========='
+-    print text
+-    print '=========='
++    print('Original text:\n==========')
++    print(text)
++    print('==========')
+ 
+     # first transform the text into packets
+     blocks = [] ; size = 40
+@@ -195,7 +195,7 @@ likely to effect their Safety and Happiness.
+         blocks.append( text[i:i+size] )
+ 
+     # now get MACs for all the text blocks.  The key is obvious...
+-    print 'Calculating MACs...'
++    print('Calculating MACs...')
+     from Crypto.Hash import HMAC, SHA
+     key = 'Jefferson'
+     macs = [HMAC.new(key, block, digestmod=SHA).digest()
+@@ -205,13 +205,13 @@ likely to effect their Safety and Happiness.
+ 
+     # put these into a form acceptable as input to the chaffing procedure
+     source = []
+-    m = zip(range(len(blocks)), blocks, macs)
+-    print m
++    m = list(zip(list(range(len(blocks))), blocks, macs))
++    print(m)
+     for i, data, mac in m:
+         source.append((i, data, mac))
+ 
+     # now chaff these
+-    print 'Adding chaff...'
++    print('Adding chaff...')
+     c = Chaff(factor=0.5, blocksper=2)
+     chaffed = c.chaff(source)
+ 
+@@ -221,7 +221,7 @@ likely to effect their Safety and Happiness.
+     # the chaff
+ 
+     wheat = []
+-    print 'chaffed message blocks:'
++    print('chaffed message blocks:')
+     for i, data, mac in chaffed:
+         # do the authentication
+         h = HMAC.new(key, data, digestmod=SHA)
+@@ -232,14 +232,14 @@ likely to effect their Safety and Happiness.
+         else:
+             tag = '   '
+         # base64 adds a trailing newline
+-        print tag, '%3d' % i, \
+-              repr(data), encodestring(mac)[:-1]
++        print(tag, '%3d' % i, \
++              repr(data), encodestring(mac)[:-1])
+ 
+     # now decode the message packets and check it against the original text
+-    print 'Undigesting wheat...'
++    print('Undigesting wheat...')
+     # PY3K: This is meant to be text, do not change to bytes (data)
+     newtext = "".join(wheat)
+     if newtext == text:
+-        print 'They match!'
++        print('They match!')
+     else:
+-        print 'They differ!'
++        print('They differ!')
+--- lib/Crypto/PublicKey/_DSA.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/PublicKey/_DSA.py
+@@ -50,7 +50,7 @@ def generateQ(randfunc):
+         q=q*256+c
+     while (not isPrime(q)):
+         q=q+2
+-    if pow(2,159L) < q < pow(2,160L):
++    if pow(2,159) < q < pow(2,160):
+         return S, q
+     raise RuntimeError('Bad q value generated')
+ 
+@@ -80,7 +80,7 @@ def generate_py(bits, randfunc, progress_func=None):
+                 V[k]=bytes_to_long(SHA.new(S+bstr(N)+bstr(k)).digest())
+             W=V[n] % powb
+             for k in range(n-1, -1, -1):
+-                W=(W<<160L)+V[k]
++                W=(W<<160)+V[k]
+             X=W+powL1
+             p=X-(X%(2*obj.q)-1)
+             if powL1<=p and isPrime(p):
+--- lib/Crypto/PublicKey/_RSA.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/PublicKey/_RSA.py
+@@ -37,12 +37,12 @@ def generate_py(bits, randfunc, progress_func=None, e=
+     if present, to display the progress of the key generation.
+     """
+     obj=RSAobj()
+-    obj.e = long(e)
++    obj.e = int(e)
+ 
+     # Generate the prime factors of n
+     if progress_func:
+         progress_func('p,q\n')
+-    p = q = 1L
++    p = q = 1
+     while number.size(p*q) < bits:
+         # Note that q might be one bit longer than p if somebody specifies an odd
+         # number of bits for the key. (Why would anyone do that?  You don't get
+--- lib/Crypto/PublicKey/_slowmath.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/PublicKey/_slowmath.py
+@@ -81,12 +81,12 @@ class _RSAKey(object):
+ 
+ def rsa_construct(n, e, d=None, p=None, q=None, u=None):
+     """Construct an RSAKey object"""
+-    assert isinstance(n, long)
+-    assert isinstance(e, long)
+-    assert isinstance(d, (long, type(None)))
+-    assert isinstance(p, (long, type(None)))
+-    assert isinstance(q, (long, type(None)))
+-    assert isinstance(u, (long, type(None)))
++    assert isinstance(n, int)
++    assert isinstance(e, int)
++    assert isinstance(d, (int, type(None)))
++    assert isinstance(p, (int, type(None)))
++    assert isinstance(q, (int, type(None)))
++    assert isinstance(u, (int, type(None)))
+     obj = _RSAKey()
+     obj.n = n
+     obj.e = e
+@@ -151,7 +151,7 @@ class _DSAKey(object):
+         # SECURITY TODO - We _should_ be computing SHA1(m), but we don't because that's the API.
+         if not self.has_private():
+             raise TypeError("No private key")
+-        if not (1L < k < self.q):
++        if not (1 < k < self.q):
+             raise ValueError("k is not between 2 and q-1")
+         inv_k = inverse(k, self.q)   # Compute k**-1 mod q
+         r = pow(self.g, k, self.p) % self.q  # r = (g**k mod p) mod q
+@@ -169,11 +169,11 @@ class _DSAKey(object):
+         return v == r
+ 
+ def dsa_construct(y, g, p, q, x=None):
+-    assert isinstance(y, long)
+-    assert isinstance(g, long)
+-    assert isinstance(p, long)
+-    assert isinstance(q, long)
+-    assert isinstance(x, (long, type(None)))
++    assert isinstance(y, int)
++    assert isinstance(g, int)
++    assert isinstance(p, int)
++    assert isinstance(q, int)
++    assert isinstance(x, (int, type(None)))
+     obj = _DSAKey()
+     obj.y = y
+     obj.g = g
+--- lib/Crypto/PublicKey/RSA.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/PublicKey/RSA.py
+@@ -288,7 +288,7 @@ class _RSAobj(pubkey.pubkey):
+             self.implementation = RSAImplementation()
+         t = []
+         for k in self.keydata:
+-            if not d.has_key(k):
++            if k not in d:
+                 break
+             t.append(d[k])
+         self.key = self.implementation._math.rsa_construct(*tuple(t))
+@@ -582,7 +582,7 @@ class RSAImplementation(object):
+                     if privateKey.isType('OCTET STRING'):
+                         return self._importKeyDER(privateKey.payload)
+ 
+-        except ValueError, IndexError:
++        except ValueError as IndexError:
+             pass
+ 
+         raise ValueError("RSA key format is not supported")
+--- lib/Crypto/Random/Fortuna/FortunaAccumulator.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/Random/Fortuna/FortunaAccumulator.py
+@@ -34,9 +34,9 @@ import time
+ import warnings
+ 
+ from Crypto.pct_warnings import ClockRewindWarning
+-import SHAd256
++from . import SHAd256
+ 
+-import FortunaGenerator
++from . import FortunaGenerator
+ 
+ class FortunaPool(object):
+     """Fortuna pool type
+@@ -89,7 +89,7 @@ def which_pools(r):
+             retval.append(i)
+         else:
+             break   # optimization.  once this fails, it always fails
+-        mask = (mask << 1) | 1L
++        mask = (mask << 1) | 1
+     return retval
+ 
+ class FortunaAccumulator(object):
+--- lib/Crypto/Random/OSRNG/posix.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/Random/OSRNG/posix.py
+@@ -29,7 +29,7 @@ import errno
+ import os
+ import stat
+ 
+-from rng_base import BaseRNG
++from .rng_base import BaseRNG
+ from Crypto.Util.py3compat import b
+ 
+ class DevURandomRNG(BaseRNG):
+@@ -63,7 +63,7 @@ class DevURandomRNG(BaseRNG):
+         while len(data) < N:
+             try:
+                 d = self.__file.read(N - len(data))
+-            except IOError, e:
++            except IOError as e:
+                 # read(2) has been interrupted by a signal; redo the read
+                 if e.errno == errno.EINTR:
+                     continue
+--- lib/Crypto/Random/random.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/Random/random.py
+@@ -47,7 +47,7 @@ class StrongRandom(object):
+         """Return a python long integer with k random bits."""
+         if self._randfunc is None:
+             self._randfunc = Random.new().read
+-        mask = (1L << k) - 1
++        mask = (1 << k) - 1
+         return mask & bytes_to_long(self._randfunc(ceil_div(k, 8)))
+ 
+     def randrange(self, *args):
+@@ -64,9 +64,9 @@ class StrongRandom(object):
+             step = 1
+         else:
+             raise TypeError("randrange expected at most 3 arguments, got %d" % (len(args),))
+-        if (not isinstance(start, (int, long))
+-                or not isinstance(stop, (int, long))
+-                or not isinstance(step, (int, long))):
++        if (not isinstance(start, int)
++                or not isinstance(stop, int)
++                or not isinstance(step, int)):
+             raise TypeError("randrange requires integer arguments")
+         if step == 0:
+             raise ValueError("randrange step argument must not be zero")
+@@ -86,7 +86,7 @@ class StrongRandom(object):
+ 
+     def randint(self, a, b):
+         """Return a random integer N such that a <= N <= b."""
+-        if not isinstance(a, (int, long)) or not isinstance(b, (int, long)):
++        if not isinstance(a, int) or not isinstance(b, int):
+             raise TypeError("randint requires integer arguments")
+         N = self.randrange(a, b+1)
+         assert a <= N <= b
+@@ -108,7 +108,7 @@ class StrongRandom(object):
+ 
+         # Choose a random item (without replacement) until all the items have been
+         # chosen.
+-        for i in xrange(len(x)):
++        for i in range(len(x)):
+             x[i] = items.pop(self.randrange(len(items)))
+ 
+     def sample(self, population, k):
+@@ -120,9 +120,9 @@ class StrongRandom(object):
+ 
+         retval = []
+         selected = {}  # we emulate a set using a dict here
+-        for i in xrange(k):
++        for i in range(k):
+             r = None
+-            while r is None or selected.has_key(r):
++            while r is None or r in selected:
+                 r = self.randrange(num_choices)
+             retval.append(population[r])
+             selected[r] = 1
+--- lib/Crypto/SelfTest/Cipher/common.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/SelfTest/Cipher/common.py
+@@ -97,9 +97,9 @@ class CipherSelfTest(unittest.TestCase):
+             from Crypto.Util import Counter
+             ctr_class = _extract(params, 'ctr_class', Counter.new)
+             ctr_params = _extract(params, 'ctr_params', {}).copy()
+-            if ctr_params.has_key('prefix'): ctr_params['prefix'] = a2b_hex(b(ctr_params['prefix']))
+-            if ctr_params.has_key('suffix'): ctr_params['suffix'] = a2b_hex(b(ctr_params['suffix']))
+-            if not ctr_params.has_key('nbits'):
++            if 'prefix' in ctr_params: ctr_params['prefix'] = a2b_hex(b(ctr_params['prefix']))
++            if 'suffix' in ctr_params: ctr_params['suffix'] = a2b_hex(b(ctr_params['suffix']))
++            if 'nbits' not in ctr_params:
+                 ctr_params['nbits'] = 8*(self.module.block_size - len(ctr_params.get('prefix', '')) - len(ctr_params.get('suffix', '')))
+             params['counter'] = ctr_class(**ctr_params)
+ 
+@@ -202,7 +202,7 @@ class CTRWraparoundTest(unittest.TestCase):
+ 
+         for disable_shortcut in (0, 1): # (False, True) Test CTR-mode shortcut and PyObject_CallObject code paths
+             for little_endian in (0, 1): # (False, True) Test both endiannesses
+-                ctr = Counter.new(8*self.module.block_size, initial_value=2L**(8*self.module.block_size)-1, little_endian=little_endian, disable_shortcut=disable_shortcut)
++                ctr = Counter.new(8*self.module.block_size, initial_value=2**(8*self.module.block_size)-1, little_endian=little_endian, disable_shortcut=disable_shortcut)
+                 cipher = self.module.new(a2b_hex(self.key), self.module.MODE_CTR, counter=ctr)
+                 block = b("\x00") * self.module.block_size
+                 cipher.encrypt(block)
+@@ -347,12 +347,12 @@ def make_block_tests(module, module_name, test_data):
+             tests.append(CipherStreamingSelfTest(module, params))
+ 
+         # When using CTR mode, test the non-shortcut code path.
+-        if p_mode == 'CTR' and not params.has_key('ctr_class'):
++        if p_mode == 'CTR' and 'ctr_class' not in params:
+             params2 = params.copy()
+             params2['description'] += " (shortcut disabled)"
+             ctr_params2 = params.get('ctr_params', {}).copy()
+             params2['ctr_params'] = ctr_params2
+-            if not params2['ctr_params'].has_key('disable_shortcut'):
++            if 'disable_shortcut' not in params2['ctr_params']:
+                 params2['ctr_params']['disable_shortcut'] = 1
+             tests.append(CipherSelfTest(module, params2))
+     return tests
+--- lib/Crypto/SelfTest/Cipher/test_pkcs1_15.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/SelfTest/Cipher/test_pkcs1_15.py
+@@ -41,7 +41,7 @@ def t2b(t):
+     """Convert a text string with bytes in hex form to a byte string"""
+     clean = b(rws(t))
+     if len(clean)%2 == 1:
+-        print clean
++        print(clean)
+         raise ValueError("Even number of characters expected")
+     return a2b_hex(clean)
+ 
+@@ -154,7 +154,7 @@ HKukWBcq9f/UOmS0oEhai/6g+Uf7VHJdWaeO5LzuvwU=
+         def testEncryptVerify1(self):
+                 # Encrypt/Verify messages of length [0..RSAlen-11]
+                 # and therefore padding [8..117]
+-                for pt_len in xrange(0,128-11+1):
++                for pt_len in range(0,128-11+1):
+                     pt = self.rng(pt_len)
+                     cipher = PKCS.new(self.key1024)
+                     ct = cipher.encrypt(pt)
+--- lib/Crypto/SelfTest/PublicKey/test_ElGamal.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/SelfTest/PublicKey/test_ElGamal.py
+@@ -105,8 +105,8 @@ class ElGamalTest(unittest.TestCase):
+                 d = self.convert_tv(tv, as_longs)
+                 key = ElGamal.construct(d['key'])
+                 ct = key.encrypt(d['pt'], d['k'])
+-                self.assertEquals(ct[0], d['ct1'])
+-                self.assertEquals(ct[1], d['ct2'])
++                self.assertEqual(ct[0], d['ct1'])
++                self.assertEqual(ct[1], d['ct2'])
+ 
+     def test_decryption(self):
+         for tv in self.tve:
+@@ -114,7 +114,7 @@ class ElGamalTest(unittest.TestCase):
+                 d = self.convert_tv(tv, as_longs)
+                 key = ElGamal.construct(d['key'])
+                 pt = key.decrypt((d['ct1'], d['ct2']))
+-                self.assertEquals(pt, d['pt'])
++                self.assertEqual(pt, d['pt'])
+ 
+     def test_signing(self):
+         for tv in self.tvs:
+@@ -122,8 +122,8 @@ class ElGamalTest(unittest.TestCase):
+                 d = self.convert_tv(tv, as_longs)
+                 key = ElGamal.construct(d['key'])
+                 sig1, sig2 = key.sign(d['h'], d['k'])
+-                self.assertEquals(sig1, d['sig1'])
+-                self.assertEquals(sig2, d['sig2'])
++                self.assertEqual(sig1, d['sig1'])
++                self.assertEqual(sig2, d['sig2'])
+ 
+     def test_verification(self):
+         for tv in self.tvs:
+@@ -132,17 +132,17 @@ class ElGamalTest(unittest.TestCase):
+                 key = ElGamal.construct(d['key'])
+                 # Positive test
+                 res = key.verify( d['h'], (d['sig1'],d['sig2']) )
+-                self.failUnless(res)
++                self.assertTrue(res)
+                 # Negative test
+                 res = key.verify( d['h'], (d['sig1']+1,d['sig2']) )
+-                self.failIf(res)
++                self.assertFalse(res)
+ 
+     def convert_tv(self, tv, as_longs=0):
+         """Convert a test vector from textual form (hexadecimal ascii
+         to either integers or byte strings."""
+         key_comps = 'p','g','y','x'
+         tv2 = {}
+-        for c in tv.keys():
++        for c in list(tv.keys()):
+             tv2[c] = a2b_hex(tv[c])
+             if as_longs or c in key_comps or c in ('sig1','sig2'):
+                 tv2[c] = bytes_to_long(tv2[c])
+@@ -163,41 +163,41 @@ class ElGamalTest(unittest.TestCase):
+     def _check_private_key(self, elgObj):
+ 
+         # Check capabilities
+-        self.failUnless(elgObj.has_private())
+-        self.failUnless(elgObj.can_sign())
+-        self.failUnless(elgObj.can_encrypt())
++        self.assertTrue(elgObj.has_private())
++        self.assertTrue(elgObj.can_sign())
++        self.assertTrue(elgObj.can_encrypt())
+ 
+         # Sanity check key data
+-        self.failUnless(1<elgObj.g<(elgObj.p-1))
+-        self.assertEquals(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
+-        self.failUnless(1<elgObj.x<(elgObj.p-1))
+-        self.assertEquals(pow(elgObj.g, elgObj.x, elgObj.p), elgObj.y)
++        self.assertTrue(1<elgObj.g<(elgObj.p-1))
++        self.assertEqual(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
++        self.assertTrue(1<elgObj.x<(elgObj.p-1))
++        self.assertEqual(pow(elgObj.g, elgObj.x, elgObj.p), elgObj.y)
+ 
+     def _check_public_key(self, elgObj):
+ 
+         # Check capabilities
+-        self.failIf(elgObj.has_private())
+-        self.failUnless(elgObj.can_sign())
+-        self.failUnless(elgObj.can_encrypt())
++        self.assertFalse(elgObj.has_private())
++        self.assertTrue(elgObj.can_sign())
++        self.assertTrue(elgObj.can_encrypt())
+ 
+         # Sanity check key data
+-        self.failUnless(1<elgObj.g<(elgObj.p-1))
+-        self.assertEquals(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
++        self.assertTrue(1<elgObj.g<(elgObj.p-1))
++        self.assertEqual(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
+ 
+     def _exercise_primitive(self, elgObj):
+         # Test encryption/decryption
+         plaintext = b("Test")
+-        ciphertext = elgObj.encrypt(plaintext, 123456789L)
++        ciphertext = elgObj.encrypt(plaintext, 123456789)
+         plaintextP = elgObj.decrypt(ciphertext)
+-        self.assertEquals(plaintext, plaintextP)
++        self.assertEqual(plaintext, plaintextP)
+ 
+         # Test signature/verification
+-        signature = elgObj.sign(plaintext, 987654321L)
++        signature = elgObj.sign(plaintext, 987654321)
+         elgObj.verify(plaintext, signature)
+ 
+     def _exercise_public_primitive(self, elgObj):
+         plaintext = b("Test")
+-        ciphertext = elgObj.encrypt(plaintext, 123456789L)
++        ciphertext = elgObj.encrypt(plaintext, 123456789)
+ 
+ def get_tests(config={}):
+     tests = []
+--- lib/Crypto/SelfTest/PublicKey/test_importKey.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/SelfTest/PublicKey/test_importKey.py
+@@ -20,8 +20,8 @@
+ # SOFTWARE.
+ # ===================================================================
+ 
+-from __future__ import nested_scopes
+ 
++
+ __revision__ = "$Id$"
+ 
+ import unittest
+@@ -42,7 +42,7 @@ def der2pem(der, text='PUBLIC'):
+ 
+ class ImportKeyTests(unittest.TestCase):
+     # 512-bit RSA key generated with openssl
+-    rsaKeyPEM = u'''-----BEGIN RSA PRIVATE KEY-----
++    rsaKeyPEM = '''-----BEGIN RSA PRIVATE KEY-----
+ MIIBOwIBAAJBAL8eJ5AKoIsjURpcEoGubZMxLD7+kT+TLr7UkvEtFrRhDDKMtuII
+ q19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQJACUSDEp8RTe32ftq8IwG8
+ Wojl5mAd1wFiIOrZ/Uv8b963WJOJiuQcVN29vxU5+My9GPZ7RA3hrDBEAoHUDPrI
+@@ -53,7 +53,7 @@ n0CnZCJ6IZYqSt0H5N7+Q+2Ro64nuwV/OSQfM6sBwQ==
+ -----END RSA PRIVATE KEY-----'''
+ 
+     # As above, but this is actually an unencrypted PKCS#8 key
+-    rsaKeyPEM8 = u'''-----BEGIN PRIVATE KEY-----
++    rsaKeyPEM8 = '''-----BEGIN PRIVATE KEY-----
+ MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAvx4nkAqgiyNRGlwS
+ ga5tkzEsPv6RP5MuvtSS8S0WtGEMMoy24girX0WsvilQgzKY8xIsGfeEkt7fQPDj
+ wZAzhQIDAQABAkAJRIMSnxFN7fZ+2rwjAbxaiOXmYB3XAWIg6tn9S/xv3rdYk4mK
+@@ -68,7 +68,7 @@ BX85JB8zqwHB
+     rsaKeyEncryptedPEM=(
+             
+         # With DES and passphrase 'test'
+-        ('test', u'''-----BEGIN RSA PRIVATE KEY-----
++        ('test', '''-----BEGIN RSA PRIVATE KEY-----
+ Proc-Type: 4,ENCRYPTED
+ DEK-Info: DES-CBC,AF8F9A40BD2FA2FC
+ 
+@@ -83,7 +83,7 @@ dysKznQ6P+IoqML1WxAID4aGRMWka+uArOJ148Rbj9s=
+         "\xAF\x8F\x9A\x40\xBD\x2F\xA2\xFC"),
+ 
+         # With Triple-DES and passphrase 'rocking'
+-        ('rocking', u'''-----BEGIN RSA PRIVATE KEY-----
++        ('rocking', '''-----BEGIN RSA PRIVATE KEY-----
+ Proc-Type: 4,ENCRYPTED
+ DEK-Info: DES-EDE3-CBC,C05D6C07F7FC02F6
+ 
+@@ -98,7 +98,7 @@ YSxC7qDQIT/RECvV3+oQKEcmpEujn45wAnkTi12BH30=
+         "\xC0\x5D\x6C\x07\xF7\xFC\x02\xF6"),
+     )
+ 
+-    rsaPublicKeyPEM = u'''-----BEGIN PUBLIC KEY-----
++    rsaPublicKeyPEM = '''-----BEGIN PUBLIC KEY-----
+ MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAL8eJ5AKoIsjURpcEoGubZMxLD7+kT+T
+ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4UCAwEAAQ==
+ -----END PUBLIC KEY-----'''
+@@ -144,21 +144,21 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4
+     03010001
+     '''.replace(" ",""))
+ 
+-    n = long('BF 1E 27 90 0A A0 8B 23 51 1A 5C 12 81 AE 6D 93 31 2C 3E FE 91 3F 93 2E BE D4 92 F1 2D 16 B4 61 0C 32 8C B6 E2 08 AB 5F 45 AC BE 29 50 83 32 98 F3 12 2C 19 F7 84 92 DE DF 40 F0 E3 C1 90 33 85'.replace(" ",""),16)
+-    e = 65537L
+-    d = long('09 44 83 12 9F 11 4D ED F6 7E DA BC 23 01 BC 5A 88 E5 E6 60 1D D7 01 62 20 EA D9 FD 4B FC 6F DE B7 58 93 89 8A E4 1C 54 DD BD BF 15 39 F8 CC BD 18 F6 7B 44 0D E1 AC 30 44 02 81 D4 0C FA C8 39'.replace(" ",""),16)
+-    p = long('00 F2 0F 2F 3E 1D A6 18 83 F6 29 80 92 2B D8 DF 54 5C E4 07 C7 26 24 11 03 B5 E2 C5 37 23 12 4A 23'.replace(" ",""),16)
+-    q = long('00 CA 1F E9 24 79 2C FC C9 6B FA B7 4F 34 4A 68 B4 18 DF 57 83 38 06 48 06 00 0F E2 A5 C9 9A 02 37'.replace(" ",""),16)
++    n = int('BF 1E 27 90 0A A0 8B 23 51 1A 5C 12 81 AE 6D 93 31 2C 3E FE 91 3F 93 2E BE D4 92 F1 2D 16 B4 61 0C 32 8C B6 E2 08 AB 5F 45 AC BE 29 50 83 32 98 F3 12 2C 19 F7 84 92 DE DF 40 F0 E3 C1 90 33 85'.replace(" ",""),16)
++    e = 65537
++    d = int('09 44 83 12 9F 11 4D ED F6 7E DA BC 23 01 BC 5A 88 E5 E6 60 1D D7 01 62 20 EA D9 FD 4B FC 6F DE B7 58 93 89 8A E4 1C 54 DD BD BF 15 39 F8 CC BD 18 F6 7B 44 0D E1 AC 30 44 02 81 D4 0C FA C8 39'.replace(" ",""),16)
++    p = int('00 F2 0F 2F 3E 1D A6 18 83 F6 29 80 92 2B D8 DF 54 5C E4 07 C7 26 24 11 03 B5 E2 C5 37 23 12 4A 23'.replace(" ",""),16)
++    q = int('00 CA 1F E9 24 79 2C FC C9 6B FA B7 4F 34 4A 68 B4 18 DF 57 83 38 06 48 06 00 0F E2 A5 C9 9A 02 37'.replace(" ",""),16)
+ 
+     # This is q^{-1} mod p). fastmath and slowmath use pInv (p^{-1}
+     # mod q) instead!
+-    qInv = long('00 BD 9F 40 A7 64 22 7A 21 96 2A 4A DD 07 E4 DE FE 43 ED 91 A3 AE 27 BB 05 7F 39 24 1F 33 AB 01 C1'.replace(" ",""),16)
++    qInv = int('00 BD 9F 40 A7 64 22 7A 21 96 2A 4A DD 07 E4 DE FE 43 ED 91 A3 AE 27 BB 05 7F 39 24 1F 33 AB 01 C1'.replace(" ",""),16)
+     pInv = inverse(p,q)
+ 
+     def testImportKey1(self):
+         """Verify import of RSAPrivateKey DER SEQUENCE"""
+         key = self.rsa.importKey(self.rsaKeyDER)
+-        self.failUnless(key.has_private())
++        self.assertTrue(key.has_private())
+         self.assertEqual(key.n, self.n)
+         self.assertEqual(key.e, self.e)
+         self.assertEqual(key.d, self.d)
+@@ -168,7 +168,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4
+     def testImportKey2(self):
+         """Verify import of SubjectPublicKeyInfo DER SEQUENCE"""
+         key = self.rsa.importKey(self.rsaPublicKeyDER)
+-        self.failIf(key.has_private())
++        self.assertFalse(key.has_private())
+         self.assertEqual(key.n, self.n)
+         self.assertEqual(key.e, self.e)
+ 
+@@ -228,7 +228,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4
+         """Verify import of encrypted PrivateKeyInfo DER SEQUENCE"""
+         for t in self.rsaKeyEncryptedPEM:
+             key = self.rsa.importKey(t[1], t[0])
+-            self.failUnless(key.has_private())
++            self.assertTrue(key.has_private())
+             self.assertEqual(key.n, self.n)
+             self.assertEqual(key.e, self.e)
+             self.assertEqual(key.d, self.d)
+@@ -238,7 +238,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4
+     def testImportKey9(self):
+         """Verify import of unencrypted PrivateKeyInfo DER SEQUENCE"""
+         key = self.rsa.importKey(self.rsaKeyDER8)
+-        self.failUnless(key.has_private())
++        self.assertTrue(key.has_private())
+         self.assertEqual(key.n, self.n)
+         self.assertEqual(key.e, self.e)
+         self.assertEqual(key.d, self.d)
+@@ -248,7 +248,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4
+     def testImportKey10(self):
+         """Verify import of unencrypted PrivateKeyInfo DER SEQUENCE, encoded with PEM"""
+         key = self.rsa.importKey(self.rsaKeyPEM8)
+-        self.failUnless(key.has_private())
++        self.assertTrue(key.has_private())
+         self.assertEqual(key.n, self.n)
+         self.assertEqual(key.e, self.e)
+         self.assertEqual(key.d, self.d)
+@@ -301,7 +301,7 @@ Lr7UkvEtFrRhDDKMtuIIq19FrL4pUIMymPMSLBn3hJLe30Dw48GQM4
+     def testExportKey4(self):
+         key = self.rsa.construct([self.n, self.e, self.d, self.p, self.q, self.pInv])
+         # Tuple with index #1 is encrypted with 3DES
+-        t = map(b,self.rsaKeyEncryptedPEM[1])
++        t = list(map(b,self.rsaKeyEncryptedPEM[1]))
+         # Force the salt being used when exporting
+         key._randfunc = lambda N: (t[2]*divmod(N+len(t[2]),len(t[2]))[0])[:N]
+         pemKey = key.exportKey("PEM", t[0])
+--- lib/Crypto/SelfTest/PublicKey/test_RSA.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/SelfTest/PublicKey/test_RSA.py
+@@ -78,7 +78,7 @@ class RSATest(unittest.TestCase):
+         e2 53 72 98 ca 2a 8f 59 46 f8 e5 fd 09 1d bd cb
+     """
+ 
+-    e = 0x11L    # public exponent
++    e = 0x11    # public exponent
+ 
+     prime_factor = """
+         c9 7f b1 f0 27 f4 53 f6 34 12 33 ea aa d1 d9 35
+@@ -172,9 +172,9 @@ class RSATest(unittest.TestCase):
+ 
+     def test_factoring(self):
+         rsaObj = self.rsa.construct([self.n, self.e, self.d])
+-        self.failUnless(rsaObj.p==self.p or rsaObj.p==self.q)
+-        self.failUnless(rsaObj.q==self.p or rsaObj.q==self.q)
+-        self.failUnless(rsaObj.q*rsaObj.p == self.n)
++        self.assertTrue(rsaObj.p==self.p or rsaObj.p==self.q)
++        self.assertTrue(rsaObj.q==self.p or rsaObj.q==self.q)
++        self.assertTrue(rsaObj.q*rsaObj.p == self.n)
+ 
+         self.assertRaises(ValueError, self.rsa.construct, [self.n, self.e, self.n-1])
+ 
+--- lib/Crypto/SelfTest/Random/Fortuna/test_FortunaAccumulator.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/SelfTest/Random/Fortuna/test_FortunaAccumulator.py
+@@ -79,17 +79,17 @@ class FortunaAccumulatorTests(unittest.TestCase):
+         self.assertEqual(FortunaAccumulator.which_pools(7), [0])
+         self.assertEqual(FortunaAccumulator.which_pools(8), [0, 1, 2, 3])
+         for i in range(1, 32):
+-            self.assertEqual(FortunaAccumulator.which_pools(2L**i-1), [0])
+-            self.assertEqual(FortunaAccumulator.which_pools(2L**i), range(i+1))
+-            self.assertEqual(FortunaAccumulator.which_pools(2L**i+1), [0])
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**31), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**32), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**33), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**34), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**35), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**36), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**64), range(32))
+-        self.assertEqual(FortunaAccumulator.which_pools(2L**128), range(32))
++            self.assertEqual(FortunaAccumulator.which_pools(2**i-1), [0])
++            self.assertEqual(FortunaAccumulator.which_pools(2**i), list(range(i+1)))
++            self.assertEqual(FortunaAccumulator.which_pools(2**i+1), [0])
++        self.assertEqual(FortunaAccumulator.which_pools(2**31), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**32), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**33), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**34), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**35), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**36), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**64), list(range(32)))
++        self.assertEqual(FortunaAccumulator.which_pools(2**128), list(range(32)))
+ 
+     def test_accumulator(self):
+         """FortunaAccumulator.FortunaAccumulator"""
+--- lib/Crypto/SelfTest/Util/test_asn1.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/SelfTest/Util/test_asn1.py
+@@ -35,86 +35,86 @@ class DerObjectTests(unittest.TestCase):
+ 	def testObjEncode1(self):
+ 		# No payload
+ 		der = DerObject(b('\x33'))
+-		self.assertEquals(der.encode(), b('\x33\x00'))
++		self.assertEqual(der.encode(), b('\x33\x00'))
+ 		# Small payload
+ 		der.payload = b('\x45')
+-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
++		self.assertEqual(der.encode(), b('\x33\x01\x45'))
+ 		# Invariant
+-		self.assertEquals(der.encode(), b('\x33\x01\x45'))
++		self.assertEqual(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'))
++		self.assertEqual(der.encode(), b('\x33\x01\x45'))
+ 
+ 	def testObjEncode2(self):
+ 		# Known types
+ 		der = DerObject('SEQUENCE')
+-		self.assertEquals(der.encode(), b('\x30\x00'))
++		self.assertEqual(der.encode(), b('\x30\x00'))
+ 		der = DerObject('BIT STRING')
+-		self.assertEquals(der.encode(), b('\x03\x00'))
++		self.assertEqual(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))		
++		self.assertEqual(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)
++		self.assertEqual(der.payload, b("\x01\x02"))
++		self.assertEqual(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)
++		self.assertEqual(der.payload, b("1")*128)
++		self.assertEqual(der.typeTag, 0x22)
+ 
+ class DerSequenceTests(unittest.TestCase):
+ 
+ 	def testEncode1(self):
+ 		# Empty sequence
+ 		der = DerSequence()
+-		self.assertEquals(der.encode(), b('0\x00'))
+-		self.failIf(der.hasOnlyInts())
++		self.assertEqual(der.encode(), b('0\x00'))
++		self.assertFalse(der.hasOnlyInts())
+ 		# One single-byte integer (zero)
+ 		der.append(0)
+-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
+-		self.failUnless(der.hasOnlyInts())
++		self.assertEqual(der.encode(), b('0\x03\x02\x01\x00'))
++		self.assertTrue(der.hasOnlyInts())
+ 		# Invariant
+-		self.assertEquals(der.encode(), b('0\x03\x02\x01\x00'))
++		self.assertEqual(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'))
++		self.assertEqual(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'))
++		self.assertEqual(len(der),1)
++		self.assertEqual(der[0],1)
++		self.assertEqual(der[-1],1)
++		self.assertEqual(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'))
++		self.assertEqual(len(der),1)
++		self.assertEqual(der[0],1)
++		self.assertEqual(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'))
++		der.append(0x180)
++		self.assertEqual(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')+
++		self.assertEqual(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')+
+@@ -138,31 +138,31 @@ class DerSequenceTests(unittest.TestCase):
+ 	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'))
++		der.append(0xFF)
++		self.assertEqual(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(0x180)
++		der.append(0xFF)
++		self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x02\x02\x00\xff'))
++		self.assertTrue(der.hasOnlyInts())
+ 		#
+ 		der.append(0x01)
+ 		der[1:] = [9,8]
+-		self.assertEquals(len(der),3)
++		self.assertEqual(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'))
++		self.assertEqual(der.encode(), b('0\x0A\x02\x02\x01\x80\x02\x01\x09\x02\x01\x08'))
+ 
+ 	def testEncode6(self):
+ 		# One integer and another type (no matter what it is)
+ 		der = DerSequence()
+-		der.append(0x180L)
++		der.append(0x180)
+ 		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())
++		self.assertEqual(der.encode(), b('0\x08\x02\x02\x01\x80\x00\x02\x00\x00'))
++		self.assertFalse(der.hasOnlyInts())
+ 
+ 	####
+ 
+@@ -170,29 +170,29 @@ class DerSequenceTests(unittest.TestCase):
+ 		# Empty sequence
+ 		der = DerSequence()
+ 		der.decode(b('0\x00'))
+-		self.assertEquals(len(der),0)
++		self.assertEqual(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)
++		self.assertEqual(len(der),1)
++		self.assertEqual(der[0],0)
+ 		# Invariant
+ 		der.decode(b('0\x03\x02\x01\x00'))
+-		self.assertEquals(len(der),1)
+-		self.assertEquals(der[0],0)
++		self.assertEqual(len(der),1)
++		self.assertEqual(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)
++		self.assertEqual(len(der),1)
++		self.assertEqual(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)
++		self.assertEqual(len(der),1)
++		self.assertEqual(der[0],0x180)
+ 
+ 	def testDecode4(self):
+ 		# One very long integer
+@@ -217,40 +217,40 @@ class DerSequenceTests(unittest.TestCase):
+ 		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)
++		self.assertEqual(len(der),1)
++		self.assertEqual(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)
++		self.assertEqual(len(der),1)
++		self.assertEqual(der[0],0xFF)
+ 
+ 	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)
++		self.assertEqual(len(der),2)
++		self.assertEqual(der[0],0x180)
++		self.assertEqual(der[1],0xFF)
+ 
+ 	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'))
++		self.assertEqual(len(der),3)
++		self.assertEqual(der[0],0x180)
++		self.assertEqual(der[1],b('\x24\x02\xb6\x63'))
++		self.assertEqual(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.assertEqual(len(der),2)
++		self.assertEqual(der[0],b('\x24\x02\xb6\x63'))
++		self.assertEqual(der[1],b('\x12\x00'))
+ 
+ 	def testErrDecode1(self):
+ 		# Not a sequence
+--- lib/Crypto/SelfTest/Util/test_number.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/SelfTest/Util/test_number.py
+@@ -73,19 +73,19 @@ class MiscTests(unittest.TestCase):
+         for b in range(3, 1+129, 3):    # 3, 6, ... , 129
+             self.assertEqual(0, number.ceil_shift(0, b))
+ 
+-            n = 1L
+-            while n <= 2L**(b+2):
+-                (q, r) = divmod(n-1, 2L**b)
++            n = 1
++            while n <= 2**(b+2):
++                (q, r) = divmod(n-1, 2**b)
+                 expected = q + int(not not r)
+                 self.assertEqual((n-1, b, expected),
+                                  (n-1, b, number.ceil_shift(n-1, b)))
+ 
+-                (q, r) = divmod(n, 2L**b)
++                (q, r) = divmod(n, 2**b)
+                 expected = q + int(not not r)
+                 self.assertEqual((n, b, expected),
+                                  (n, b, number.ceil_shift(n, b)))
+ 
+-                (q, r) = divmod(n+1, 2L**b)
++                (q, r) = divmod(n+1, 2**b)
+                 expected = q + int(not not r)
+                 self.assertEqual((n+1, b, expected),
+                                  (n+1, b, number.ceil_shift(n+1, b)))
+@@ -184,9 +184,9 @@ class MiscTests(unittest.TestCase):
+             n += 1
+ 
+         for e in range(16, 1+64, 2):
+-            self.assertRaises(ValueError, number.exact_log2, 2L**e-1)
+-            self.assertEqual(e, number.exact_log2(2L**e))
+-            self.assertRaises(ValueError, number.exact_log2, 2L**e+1)
++            self.assertRaises(ValueError, number.exact_log2, 2**e-1)
++            self.assertEqual(e, number.exact_log2(2**e))
++            self.assertRaises(ValueError, number.exact_log2, 2**e+1)
+ 
+     def test_exact_div(self):
+         """Util.number.exact_div"""
+@@ -235,20 +235,20 @@ class MiscTests(unittest.TestCase):
+         bits = 512
+         x = number.getStrongPrime(bits)
+         self.assertNotEqual(x % 2, 0)
+-        self.assertEqual(x > (1L << bits-1)-1, 1)
+-        self.assertEqual(x < (1L << bits), 1)
++        self.assertEqual(x > (1 << bits-1)-1, 1)
++        self.assertEqual(x < (1 << bits), 1)
+         e = 2**16+1
+         x = number.getStrongPrime(bits, e)
+         self.assertEqual(number.GCD(x-1, e), 1)
+         self.assertNotEqual(x % 2, 0)
+-        self.assertEqual(x > (1L << bits-1)-1, 1)
+-        self.assertEqual(x < (1L << bits), 1)
++        self.assertEqual(x > (1 << bits-1)-1, 1)
++        self.assertEqual(x < (1 << bits), 1)
+         e = 2**16+2
+         x = number.getStrongPrime(bits, e)
+         self.assertEqual(number.GCD((x-1)>>1, e), 1)
+         self.assertNotEqual(x % 2, 0)
+-        self.assertEqual(x > (1L << bits-1)-1, 1)
+-        self.assertEqual(x < (1L << bits), 1)
++        self.assertEqual(x > (1 << bits-1)-1, 1)
++        self.assertEqual(x < (1 << bits), 1)
+ 
+     def test_isPrime(self):
+         """Util.number.isPrime"""
+@@ -258,28 +258,28 @@ class MiscTests(unittest.TestCase):
+         self.assertEqual(number.isPrime(2), True)
+         self.assertEqual(number.isPrime(3), True)
+         self.assertEqual(number.isPrime(4), False)
+-        self.assertEqual(number.isPrime(2L**1279-1), True)
+-        self.assertEqual(number.isPrime(-(2L**1279-1)), False)     # Regression test: negative numbers should not be prime
++        self.assertEqual(number.isPrime(2**1279-1), True)
++        self.assertEqual(number.isPrime(-(2**1279-1)), False)     # Regression test: negative numbers should not be prime
+         # test some known gmp pseudo-primes taken from
+         # http://www.trnicely.net/misc/mpzspsp.html
+         for composite in (43 * 127 * 211, 61 * 151 * 211, 15259 * 30517,
+-                          346141L * 692281L, 1007119L * 2014237L, 3589477L * 7178953L,
+-                          4859419L * 9718837L, 2730439L * 5460877L,
+-                          245127919L * 490255837L, 963939391L * 1927878781L,
+-                          4186358431L * 8372716861L, 1576820467L * 3153640933L):
+-            self.assertEqual(number.isPrime(long(composite)), False)
++                          346141 * 692281, 1007119 * 2014237, 3589477 * 7178953,
++                          4859419 * 9718837, 2730439 * 5460877,
++                          245127919 * 490255837, 963939391 * 1927878781,
++                          4186358431 * 8372716861, 1576820467 * 3153640933):
++            self.assertEqual(number.isPrime(int(composite)), False)
+ 
+     def test_size(self):
+         self.assertEqual(number.size(2),2)
+         self.assertEqual(number.size(3),2)
+         self.assertEqual(number.size(0xa2),8)
+         self.assertEqual(number.size(0xa2ba40),8*3)
+-        self.assertEqual(number.size(0xa2ba40ee07e3b2bd2f02ce227f36a195024486e49c19cb41bbbdfbba98b22b0e577c2eeaffa20d883a76e65e394c69d4b3c05a1e8fadda27edb2a42bc000fe888b9b32c22d15add0cd76b3e7936e19955b220dd17d4ea904b1ec102b2e4de7751222aa99151024c7cb41cc5ea21d00eeb41f7c800834d2c6e06bce3bce7ea9a5L), 1024)
++        self.assertEqual(number.size(0xa2ba40ee07e3b2bd2f02ce227f36a195024486e49c19cb41bbbdfbba98b22b0e577c2eeaffa20d883a76e65e394c69d4b3c05a1e8fadda27edb2a42bc000fe888b9b32c22d15add0cd76b3e7936e19955b220dd17d4ea904b1ec102b2e4de7751222aa99151024c7cb41cc5ea21d00eeb41f7c800834d2c6e06bce3bce7ea9a5), 1024)
+ 
+     def test_negative_number_roundtrip_mpzToLongObj_longObjToMPZ(self):
+         """Test that mpzToLongObj and longObjToMPZ (internal functions) roundtrip negative numbers correctly."""
+-        n = -100000000000000000000000000000000000L
+-        e = 2L
++        n = -100000000000000000000000000000000000
++        e = 2
+         k = number._fastmath.rsa_construct(n, e)
+         self.assertEqual(n, k.n)
+         self.assertEqual(e, k.e)
+--- lib/Crypto/Util/_number_new.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/Util/_number_new.py
+@@ -37,11 +37,11 @@ def ceil_shift(n, b):
+     This is done by right-shifting n by b bits and incrementing the result by 1
+     if any '1' bits were shifted out.
+     """
+-    if not isinstance(n, (int, long)) or not isinstance(b, (int, long)):
++    if not isinstance(n, int) or not isinstance(b, int):
+         raise TypeError("unsupported operand type(s): %r and %r" % (type(n).__name__, type(b).__name__))
+ 
+     assert n >= 0 and b >= 0    # I haven't tested or even thought about negative values
+-    mask = (1L << b) - 1
++    mask = (1 << b) - 1
+     if n & mask:
+         return (n >> b) + 1
+     else:
+@@ -50,7 +50,7 @@ def ceil_shift(n, b):
+ def ceil_div(a, b):
+     """Return ceil(a / b) without performing any floating-point operations."""
+ 
+-    if not isinstance(a, (int, long)) or not isinstance(b, (int, long)):
++    if not isinstance(a, int) or not isinstance(b, int):
+         raise TypeError("unsupported operand type(s): %r and %r" % (type(a).__name__, type(b).__name__))
+ 
+     (q, r) = divmod(a, b)
+@@ -60,7 +60,7 @@ def ceil_div(a, b):
+         return q
+ 
+ def floor_div(a, b):
+-    if not isinstance(a, (int, long)) or not isinstance(b, (int, long)):
++    if not isinstance(a, int) or not isinstance(b, int):
+         raise TypeError("unsupported operand type(s): %r and %r" % (type(a).__name__, type(b).__name__))
+ 
+     (q, r) = divmod(a, b)
+@@ -72,10 +72,10 @@ def exact_log2(num):
+     If no such integer exists, this function raises ValueError.
+     """
+ 
+-    if not isinstance(num, (int, long)):
++    if not isinstance(num, int):
+         raise TypeError("unsupported operand type: %r" % (type(num).__name__,))
+ 
+-    n = long(num)
++    n = int(num)
+     if n <= 0:
+         raise ValueError("cannot compute logarithm of non-positive number")
+ 
+@@ -87,7 +87,7 @@ def exact_log2(num):
+         n >>= 1
+     i -= 1
+ 
+-    assert num == (1L << i)
++    assert num == (1 << i)
+     return i
+ 
+ def exact_div(p, d, allow_divzero=False):
+@@ -101,7 +101,7 @@ def exact_div(p, d, allow_divzero=False):
+     unless allow_divzero is true (default: False).
+     """
+ 
+-    if not isinstance(p, (int, long)) or not isinstance(d, (int, long)):
++    if not isinstance(p, int) or not isinstance(d, int):
+         raise TypeError("unsupported operand type(s): %r and %r" % (type(p).__name__, type(d).__name__))
+ 
+     if d == 0 and allow_divzero:
+--- lib/Crypto/Util/number.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/Util/number.py
+@@ -32,7 +32,7 @@ import math
+ import sys
+ from Crypto.Util.py3compat import *
+ 
+-bignum = long
++bignum = int
+ try:
+     from Crypto.PublicKey import _fastmath
+ except ImportError:
+@@ -57,7 +57,7 @@ if _fastmath is not None and not _fastmath.HAVE_DECL_M
+     _warn("Not using mpz_powm_sec.  You should rebuild using libgmp >= 5 to avoid timing attack vulnerability.", PowmInsecureWarning)
+ 
+ # New functions
+-from _number_new import *
++from ._number_new import *
+ 
+ # Commented out and replaced with faster versions below
+ ## def long2str(n):
+@@ -136,7 +136,7 @@ def getRandomNBitInteger(N, randfunc=None):
+     the future.
+     """
+     value = getRandomInteger (N-1, randfunc)
+-    value |= 2L ** (N-1)                # Ensure high bit is set
++    value |= 2 ** (N-1)                # Ensure high bit is set
+     assert size(value) >= N
+     return value
+ 
+@@ -153,8 +153,8 @@ def inverse(u, v):
+     """inverse(u:long, v:long):long
+     Return the inverse of u mod v.
+     """
+-    u3, v3 = long(u), long(v)
+-    u1, v1 = 1L, 0L
++    u3, v3 = int(u), int(v)
++    u1, v1 = 1, 0
+     while v3 > 0:
+         q=divmod(u3, v3)[0]
+         u1, v1 = v1, u1 - v1*q
+@@ -208,7 +208,7 @@ def _rabinMillerTest(n, rounds, randfunc=None):
+ 
+     tested = []
+     # we need to do at most n-2 rounds.
+-    for i in xrange (min (rounds, n-2)):
++    for i in range (min (rounds, n-2)):
+         # randomly choose a < n and make sure it hasn't been tested yet
+         a = getRandomRange (2, n, randfunc)
+         while a in tested:
+@@ -219,7 +219,7 @@ def _rabinMillerTest(n, rounds, randfunc=None):
+         if z == 1 or z == n_1:
+             continue
+         composite = 1
+-        for r in xrange (b):
++        for r in range (b):
+             z = (z * z) % n
+             if z == 1:
+                 return 0
+@@ -261,7 +261,7 @@ def getStrongPrime(N, e=0, false_positive_prob=1e-6, r
+ 
+     # Use the accelerator if available
+     if _fastmath is not None:
+-        return _fastmath.getStrongPrime(long(N), long(e), false_positive_prob,
++        return _fastmath.getStrongPrime(int(N), int(e), false_positive_prob,
+             randfunc)
+ 
+     if (N < 512) or ((N % 128) != 0):
+@@ -275,9 +275,9 @@ def getStrongPrime(N, e=0, false_positive_prob=1e-6, r
+     x = (N - 512) >> 7;
+     # We need to approximate the sqrt(2) in the lower_bound by an integer
+     # expression because floating point math overflows with these numbers
+-    lower_bound = divmod(14142135623730950489L * (2L ** (511 + 128*x)),
+-                         10000000000000000000L)[0]
+-    upper_bound = (1L << (512 + 128*x)) - 1
++    lower_bound = divmod(14142135623730950489 * (2 ** (511 + 128*x)),
++                         10000000000000000000)[0]
++    upper_bound = (1 << (512 + 128*x)) - 1
+     # Randomly choose X in calculated range
+     X = getRandomRange (lower_bound, upper_bound, randfunc)
+ 
+@@ -291,7 +291,7 @@ def getStrongPrime(N, e=0, false_positive_prob=1e-6, r
+         # sieve the field
+         for prime in sieve_base:
+             offset = y % prime
+-            for j in xrange ((prime - offset) % prime, len (field), prime):
++            for j in range ((prime - offset) % prime, len (field), prime):
+                 field[j] = 1
+ 
+         # look for suitable p[i] starting at y
+@@ -347,7 +347,7 @@ def getStrongPrime(N, e=0, false_positive_prob=1e-6, r
+         X += increment
+ 		# abort when X has more bits than requested
+ 		# TODO: maybe we shouldn't abort but rather start over.
+-        if X >= 1L << N:
++        if X >= 1 << N:
+             raise RuntimeError ("Couln't find prime in field. "
+                                 "Developer: Increase field_size")
+     return X
+@@ -365,7 +365,7 @@ def isPrime(N, false_positive_prob=1e-6, randfunc=None
+     If randfunc is omitted, then Random.new().read is used.
+     """
+     if _fastmath is not None:
+-        return _fastmath.isPrime(long(N), false_positive_prob, randfunc)
++        return _fastmath.isPrime(int(N), false_positive_prob, randfunc)
+ 
+     if N < 3 or N & 1 == 0:
+         return N == 2
+@@ -394,10 +394,10 @@ def long_to_bytes(n, blocksize=0):
+     """
+     # after much testing, this algorithm was deemed to be the fastest
+     s = b('')
+-    n = long(n)
++    n = int(n)
+     pack = struct.pack
+     while n > 0:
+-        s = pack('>I', n & 0xffffffffL) + s
++        s = pack('>I', n & 0xffffffff) + s
+         n = n >> 32
+     # strip off leading zeros
+     for i in range(len(s)):
+@@ -420,7 +420,7 @@ def bytes_to_long(s):
+ 
+     This is (essentially) the inverse of long_to_bytes().
+     """
+-    acc = 0L
++    acc = 0
+     unpack = struct.unpack
+     length = len(s)
+     if length % 4:
+--- lib/Crypto/Util/RFC1751.py.orig	2012-05-24 12:55:30 UTC
++++ lib/Crypto/Util/RFC1751.py
+@@ -29,6 +29,7 @@ __revision__ = "$Id$"
+ 
+ import binascii
+ from Crypto.Util.py3compat import *
++from functools import reduce
+ 
+ binary={0:'0000', 1:'0001', 2:'0010', 3:'0011', 4:'0100', 5:'0101',
+         6:'0110', 7:'0111', 8:'1000', 9:'1001', 10:'1010', 11:'1011',
+@@ -36,8 +37,8 @@ binary={0:'0000', 1:'0001', 2:'0010', 3:'0011', 4:'010
+ 
+ def _key2bin(s):
+     "Convert a key into a string of binary digits"
+-    kl=map(lambda x: bord(x), s)
+-    kl=map(lambda x: binary[x>>4]+binary[x&15], kl)
++    kl=[bord(x) for x in s]
++    kl=[binary[x>>4]+binary[x&15] for x in kl]
+     return ''.join(kl)
+ 
+ def _extract(key, start, length):
+@@ -95,7 +96,7 @@ def english_to_key (s):
+         p=0
+         for i in range(0, 64, 2): p=p+_extract(skbin, i, 2)
+         if (p&3) != _extract(skbin, 64, 2):
+-            raise ValueError, "Parity error in resulting key"
++            raise ValueError("Parity error in resulting key")
+         key=key+subkey[0:8]
+     return key
+ 
+@@ -352,13 +353,13 @@ if __name__=='__main__':
+            ]
+ 
+     for key, words in data:
+-        print 'Trying key', key
++        print('Trying key', key)
+         key=binascii.a2b_hex(key)
+         w2=key_to_english(key)
+         if w2!=words:
+-            print 'key_to_english fails on key', repr(key), ', producing', str(w2)
++            print('key_to_english fails on key', repr(key), ', producing', str(w2))
+         k2=english_to_key(words)
+         if k2!=key:
+-            print 'english_to_key fails on key', repr(key), ', producing', repr(k2)
++            print('english_to_key fails on key', repr(key), ', producing', repr(k2))
+ 
+ 
diff --git a/security/py-pycrypto/files/patch-lib__Crypto__SelfTest__Util__test_number.py b/security/py-pycrypto/files/patch-lib__Crypto__SelfTest__Util__test_number.py
index f6ed6d268da4..439f1b8e0624 100644
--- a/security/py-pycrypto/files/patch-lib__Crypto__SelfTest__Util__test_number.py
+++ b/security/py-pycrypto/files/patch-lib__Crypto__SelfTest__Util__test_number.py
@@ -1,6 +1,6 @@
---- ./lib/Crypto/SelfTest/Util/test_number.py.orig	2012-10-03 16:03:52.000000000 +1000
-+++ ./lib/Crypto/SelfTest/Util/test_number.py	2012-10-03 16:04:01.000000000 +1000
-@@ -276,6 +276,11 @@
+--- lib/Crypto/SelfTest/Util/test_number.py.orig	2013-10-14 21:38:10 UTC
++++ lib/Crypto/SelfTest/Util/test_number.py
+@@ -276,6 +276,11 @@ class MiscTests(unittest.TestCase):
          self.assertEqual(number.size(0xa2ba40),8*3)
          self.assertEqual(number.size(0xa2ba40ee07e3b2bd2f02ce227f36a195024486e49c19cb41bbbdfbba98b22b0e577c2eeaffa20d883a76e65e394c69d4b3c05a1e8fadda27edb2a42bc000fe888b9b32c22d15add0cd76b3e7936e19955b220dd17d4ea904b1ec102b2e4de7751222aa99151024c7cb41cc5ea21d00eeb41f7c800834d2c6e06bce3bce7ea9a5L), 1024)
  
@@ -12,7 +12,7 @@
      def test_negative_number_roundtrip_mpzToLongObj_longObjToMPZ(self):
          """Test that mpzToLongObj and longObjToMPZ (internal functions) roundtrip negative numbers correctly."""
          n = -100000000000000000000000000000000000L
-@@ -286,7 +291,21 @@
+@@ -286,7 +291,21 @@ class MiscTests(unittest.TestCase):
  
  def get_tests(config={}):
      from Crypto.SelfTest.st_common import list_test_cases
diff --git a/security/py-pycrypto/files/patch-setup.py b/security/py-pycrypto/files/patch-setup.py
index dc0e8867a937..5cc99bb52080 100644
--- a/security/py-pycrypto/files/patch-setup.py
+++ b/security/py-pycrypto/files/patch-setup.py
@@ -1,6 +1,6 @@
---- ./setup.py.orig	2012-10-03 15:57:50.000000000 +1000
-+++ ./setup.py	2012-10-03 15:57:50.000000000 +1000
-@@ -136,6 +136,7 @@
+--- setup.py.orig	2013-10-14 21:38:10 UTC
++++ setup.py
+@@ -136,6 +136,7 @@ class PCTBuildExt (build_ext):
                  # especially helps the DES modules.
                  self.__add_compiler_option("-O3")
                  self.__add_compiler_option("-fomit-frame-pointer")