hawq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r...@apache.org
Subject [6/8] incubator-hawq git commit: HAWQ-926. Remove pycrypto from HAWQ source code
Date Thu, 14 Jul 2016 09:09:58 GMT
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ac031357/tools/bin/pythonSrc/pycrypto-2.0.1/Util/number.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/number.py b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/number.py
deleted file mode 100644
index 9d50563..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/number.py
+++ /dev/null
@@ -1,201 +0,0 @@
-#
-#   number.py : Number-theoretic functions
-#
-#  Part of the Python Cryptography Toolkit
-#
-# Distribute and use freely; there are no restrictions on further
-# dissemination and usage except those imposed by the laws of your
-# country of residence.  This software is provided "as is" without
-# warranty of fitness for use or suitability for any purpose, express
-# or implied. Use at your own risk or not at all.
-#
-
-__revision__ = "$Id: number.py,v 1.13 2003/04/04 18:21:07 akuchling Exp $"
-
-bignum = long
-try:
-    from Crypto.PublicKey import _fastmath
-except ImportError:
-    _fastmath = None
-
-# Commented out and replaced with faster versions below
-## def long2str(n):
-##     s=''
-##     while n>0:
-##         s=chr(n & 255)+s
-##         n=n>>8
-##     return s
-
-## import types
-## def str2long(s):
-##     if type(s)!=types.StringType: return s   # Integers will be left alone
-##     return reduce(lambda x,y : x*256+ord(y), s, 0L)
-
-def size (N):
-    """size(N:long) : int
-    Returns the size of the number N in bits.
-    """
-    bits, power = 0,1L
-    while N >= power:
-        bits += 1
-        power = power << 1
-    return bits
-
-def getRandomNumber(N, randfunc):
-    """getRandomNumber(N:int, randfunc:callable):long
-    Return an N-bit random number."""
-
-    S = randfunc(N/8)
-    odd_bits = N % 8
-    if odd_bits != 0:
-        char = ord(randfunc(1)) >> (8-odd_bits)
-        S = chr(char) + S
-    value = bytes_to_long(S)
-    value |= 2L ** (N-1)                # Ensure high bit is set
-    assert size(value) >= N
-    return value
-
-def GCD(x,y):
-    """GCD(x:long, y:long): long
-    Return the GCD of x and y.
-    """
-    x = abs(x) ; y = abs(y)
-    while x > 0:
-        x, y = y % x, x
-    return y
-
-def inverse(u, v):
-    """inverse(u:long, u:long):long
-    Return the inverse of u mod v.
-    """
-    u3, v3 = long(u), long(v)
-    u1, v1 = 1L, 0L
-    while v3 > 0:
-        q=u3 / v3
-        u1, v1 = v1, u1 - v1*q
-        u3, v3 = v3, u3 - v3*q
-    while u1<0:
-        u1 = u1 + v
-    return u1
-
-# Given a number of bits to generate and a random generation function,
-# find a prime number of the appropriate size.
-
-def getPrime(N, randfunc):
-    """getPrime(N:int, randfunc:callable):long
-    Return a random N-bit prime number.
-    """
-
-    number=getRandomNumber(N, randfunc) | 1
-    while (not isPrime(number)):
-        number=number+2
-    return number
-
-def isPrime(N):
-    """isPrime(N:long):bool
-    Return true if N is prime.
-    """
-    if N == 1:
-        return 0
-    if N in sieve:
-        return 1
-    for i in sieve:
-        if (N % i)==0:
-            return 0
-
-    # Use the accelerator if available
-    if _fastmath is not None:
-        return _fastmath.isPrime(N)
-
-    # Compute the highest bit that's set in N
-    N1 = N - 1L
-    n = 1L
-    while (n<N):
-        n=n<<1L
-    n = n >> 1L
-
-    # Rabin-Miller test
-    for c in sieve[:7]:
-        a=long(c) ; d=1L ; t=n
-        while (t):  # Iterate over the bits in N1
-            x=(d*d) % N
-            if x==1L and d!=1L and d!=N1:
-                return 0  # Square root of 1 found
-            if N1 & t:
-                d=(x*a) % N
-            else:
-                d=x
-            t = t >> 1L
-        if d!=1L:
-            return 0
-    return 1
-
-# Small primes used for checking primality; these are all the primes
-# less than 256.  This should be enough to eliminate most of the odd
-# numbers before needing to do a Rabin-Miller test at all.
-
-sieve=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
-       61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
-       131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193,
-       197, 199, 211, 223, 227, 229, 233, 239, 241, 251]
-
-# Improved conversion functions contributed by Barry Warsaw, after
-# careful benchmarking
-
-import struct
-
-def long_to_bytes(n, blocksize=0):
-    """long_to_bytes(n:long, blocksize:int) : string
-    Convert a long integer to a byte string.
-
-    If optional blocksize is given and greater than zero, pad the front of the
-    byte string with binary zeros so that the length is a multiple of
-    blocksize.
-    """
-    # after much testing, this algorithm was deemed to be the fastest
-    s = ''
-    n = long(n)
-    pack = struct.pack
-    while n > 0:
-        s = pack('>I', n & 0xffffffffL) + s
-        n = n >> 32
-    # strip off leading zeros
-    for i in range(len(s)):
-        if s[i] != '\000':
-            break
-    else:
-        # only happens when n == 0
-        s = '\000'
-        i = 0
-    s = s[i:]
-    # add back some pad bytes.  this could be done more efficiently w.r.t. the
-    # de-padding being done above, but sigh...
-    if blocksize > 0 and len(s) % blocksize:
-        s = (blocksize - len(s) % blocksize) * '\000' + s
-    return s
-
-def bytes_to_long(s):
-    """bytes_to_long(string) : long
-    Convert a byte string to a long integer.
-
-    This is (essentially) the inverse of long_to_bytes().
-    """
-    acc = 0L
-    unpack = struct.unpack
-    length = len(s)
-    if length % 4:
-        extra = (4 - length % 4)
-        s = '\000' * extra + s
-        length = length + extra
-    for i in range(0, length, 4):
-        acc = (acc << 32) + unpack('>I', s[i:i+4])[0]
-    return acc
-
-# For backwards compatibility...
-import warnings
-def long2str(n, blocksize=0):
-    warnings.warn("long2str() has been replaced by long_to_bytes()")
-    return long_to_bytes(n, blocksize)
-def str2long(s):
-    warnings.warn("str2long() has been replaced by bytes_to_long()")
-    return bytes_to_long(s)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ac031357/tools/bin/pythonSrc/pycrypto-2.0.1/Util/randpool.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/randpool.py b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/randpool.py
deleted file mode 100644
index 467501c..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/randpool.py
+++ /dev/null
@@ -1,421 +0,0 @@
-#
-#  randpool.py : Cryptographically strong random number generation
-#
-# Part of the Python Cryptography Toolkit
-#
-# Distribute and use freely; there are no restrictions on further
-# dissemination and usage except those imposed by the laws of your
-# country of residence.  This software is provided "as is" without
-# warranty of fitness for use or suitability for any purpose, express
-# or implied. Use at your own risk or not at all.
-#
-
-__revision__ = "$Id: randpool.py,v 1.14 2004/05/06 12:56:54 akuchling Exp $"
-
-import time, array, types, warnings, os.path
-from Crypto.Util.number import long_to_bytes
-try:
-    import Crypto.Util.winrandom as winrandom
-except:
-    winrandom = None
-
-STIRNUM = 3
-
-class RandomPool:
-    """randpool.py : Cryptographically strong random number generation.
-
-    The implementation here is similar to the one in PGP.  To be
-    cryptographically strong, it must be difficult to determine the RNG's
-    output, whether in the future or the past.  This is done by using
-    a cryptographic hash function to "stir" the random data.
-
-    Entropy is gathered in the same fashion as PGP; the highest-resolution
-    clock around is read and the data is added to the random number pool.
-    A conservative estimate of the entropy is then kept.
-
-    If a cryptographically secure random source is available (/dev/urandom
-    on many Unixes, Windows CryptGenRandom on most Windows), then use
-    it.
-
-    Instance Attributes:
-    bits : int
-      Maximum size of pool in bits
-    bytes : int
-      Maximum size of pool in bytes
-    entropy : int
-      Number of bits of entropy in this pool.
-
-    Methods:
-    add_event([s]) : add some entropy to the pool
-    get_bytes(int) : get N bytes of random data
-    randomize([N]) : get N bytes of randomness from external source
-    """
-
-
-    def __init__(self, numbytes = 160, cipher=None, hash=None):
-        if hash is None:
-            from Crypto.Hash import SHA as hash
-
-        # The cipher argument is vestigial; it was removed from
-        # version 1.1 so RandomPool would work even in the limited
-        # exportable subset of the code
-        if cipher is not None:
-            warnings.warn("'cipher' parameter is no longer used")
-
-        if isinstance(hash, types.StringType):
-            # ugly hack to force __import__ to give us the end-path module
-            hash = __import__('Crypto.Hash.'+hash,
-                              None, None, ['new'])
-            warnings.warn("'hash' parameter should now be a hashing module")
-
-        self.bytes = numbytes
-        self.bits = self.bytes*8
-        self.entropy = 0
-        self._hash = hash
-
-        # Construct an array to hold the random pool,
-        # initializing it to 0.
-        self._randpool = array.array('B', [0]*self.bytes)
-
-        self._event1 = self._event2 = 0
-        self._addPos = 0
-        self._getPos = hash.digest_size
-        self._lastcounter=time.time()
-        self.__counter = 0
-
-        self._measureTickSize()        # Estimate timer resolution
-        self._randomize()
-
-    def _updateEntropyEstimate(self, nbits):
-        self.entropy += nbits
-        if self.entropy < 0:
-            self.entropy = 0
-        elif self.entropy > self.bits:
-            self.entropy = self.bits
-
-    def _randomize(self, N = 0, devname = '/dev/urandom'):
-        """_randomize(N, DEVNAME:device-filepath)
-        collects N bits of randomness from some entropy source (e.g.,
-        /dev/urandom on Unixes that have it, Windows CryptoAPI
-        CryptGenRandom, etc)
-        DEVNAME is optional, defaults to /dev/urandom.  You can change it
-        to /dev/random if you want to block till you get enough
-        entropy.
-        """
-        data = ''
-        if N <= 0:
-            nbytes = int((self.bits - self.entropy)/8+0.5)
-        else:
-            nbytes = int(N/8+0.5)
-        if winrandom:
-            # Windows CryptGenRandom provides random data.
-            data = winrandom.new().get_bytes(nbytes)
-        elif os.path.exists(devname):
-            # Many OSes support a /dev/urandom device
-            try:
-                f=open(devname)
-                data=f.read(nbytes)
-                f.close()
-            except IOError, (num, msg):
-                if num!=2: raise IOError, (num, msg)
-                # If the file wasn't found, ignore the error
-        if data:
-            self._addBytes(data)
-            # Entropy estimate: The number of bits of
-            # data obtained from the random source.
-            self._updateEntropyEstimate(8*len(data))
-        self.stir_n()                   # Wash the random pool
-
-    def randomize(self, N=0):
-        """randomize(N:int)
-        use the class entropy source to get some entropy data.
-        This is overridden by KeyboardRandomize().
-        """
-        return self._randomize(N)
-
-    def stir_n(self, N = STIRNUM):
-        """stir_n(N)
-        stirs the random pool N times
-        """
-        for i in xrange(N):
-            self.stir()
-
-    def stir (self, s = ''):
-        """stir(s:string)
-        Mix up the randomness pool.  This will call add_event() twice,
-        but out of paranoia the entropy attribute will not be
-        increased.  The optional 's' parameter is a string that will
-        be hashed with the randomness pool.
-        """
-
-        entropy=self.entropy            # Save inital entropy value
-        self.add_event()
-
-        # Loop over the randomness pool: hash its contents
-        # along with a counter, and add the resulting digest
-        # back into the pool.
-        for i in range(self.bytes / self._hash.digest_size):
-            h = self._hash.new(self._randpool)
-            h.update(str(self.__counter) + str(i) + str(self._addPos) + s)
-            self._addBytes( h.digest() )
-            self.__counter = (self.__counter + 1) & 0xFFFFffffL
-
-        self._addPos, self._getPos = 0, self._hash.digest_size
-        self.add_event()
-
-        # Restore the old value of the entropy.
-        self.entropy=entropy
-
-
-    def get_bytes (self, N):
-        """get_bytes(N:int) : string
-        Return N bytes of random data.
-        """
-
-        s=''
-        i, pool = self._getPos, self._randpool
-        h=self._hash.new()
-        dsize = self._hash.digest_size
-        num = N
-        while num > 0:
-            h.update( self._randpool[i:i+dsize] )
-            s = s + h.digest()
-            num = num - dsize
-            i = (i + dsize) % self.bytes
-            if i<dsize:
-                self.stir()
-                i=self._getPos
-
-        self._getPos = i
-        self._updateEntropyEstimate(- 8*N)
-        return s[:N]
-
-
-    def add_event(self, s=''):
-        """add_event(s:string)
-        Add an event to the random pool.  The current time is stored
-        between calls and used to estimate the entropy.  The optional
-        's' parameter is a string that will also be XORed into the pool.
-        Returns the estimated number of additional bits of entropy gain.
-        """
-        event = time.time()*1000
-        delta = self._noise()
-        s = (s + long_to_bytes(event) +
-             4*chr(0xaa) + long_to_bytes(delta) )
-        self._addBytes(s)
-        if event==self._event1 and event==self._event2:
-            # If events are coming too closely together, assume there's
-            # no effective entropy being added.
-            bits=0
-        else:
-            # Count the number of bits in delta, and assume that's the entropy.
-            bits=0
-            while delta:
-                delta, bits = delta>>1, bits+1
-            if bits>8: bits=8
-
-        self._event1, self._event2 = event, self._event1
-
-        self._updateEntropyEstimate(bits)
-        return bits
-
-    # Private functions
-    def _noise(self):
-        # Adds a bit of noise to the random pool, by adding in the
-        # current time and CPU usage of this process.
-        # The difference from the previous call to _noise() is taken
-        # in an effort to estimate the entropy.
-        t=time.time()
-        delta = (t - self._lastcounter)/self._ticksize*1e6
-        self._lastcounter = t
-        self._addBytes(long_to_bytes(long(1000*time.time())))
-        self._addBytes(long_to_bytes(long(1000*time.clock())))
-        self._addBytes(long_to_bytes(long(1000*time.time())))
-        self._addBytes(long_to_bytes(long(delta)))
-
-        # Reduce delta to a maximum of 8 bits so we don't add too much
-        # entropy as a result of this call.
-        delta=delta % 0xff
-        return int(delta)
-
-
-    def _measureTickSize(self):
-        # _measureTickSize() tries to estimate a rough average of the
-        # resolution of time that you can see from Python.  It does
-        # this by measuring the time 100 times, computing the delay
-        # between measurements, and taking the median of the resulting
-        # list.  (We also hash all the times and add them to the pool)
-        interval = [None] * 100
-        h = self._hash.new(`(id(self),id(interval))`)
-
-        # Compute 100 differences
-        t=time.time()
-        h.update(`t`)
-        i = 0
-        j = 0
-        while i < 100:
-            t2=time.time()
-            h.update(`(i,j,t2)`)
-            j += 1
-            delta=int((t2-t)*1e6)
-            if delta:
-                interval[i] = delta
-                i += 1
-                t=t2
-
-        # Take the median of the array of intervals
-        interval.sort()
-        self._ticksize=interval[len(interval)/2]
-        h.update(`(interval,self._ticksize)`)
-        # mix in the measurement times and wash the random pool
-        self.stir(h.digest())
-
-    def _addBytes(self, s):
-        "XOR the contents of the string S into the random pool"
-        i, pool = self._addPos, self._randpool
-        for j in range(0, len(s)):
-            pool[i]=pool[i] ^ ord(s[j])
-            i=(i+1) % self.bytes
-        self._addPos = i
-
-    # Deprecated method names: remove in PCT 2.1 or later.
-    def getBytes(self, N):
-        warnings.warn("getBytes() method replaced by get_bytes()",
-                      DeprecationWarning)
-        return self.get_bytes(N)
-
-    def addEvent (self, event, s=""):
-        warnings.warn("addEvent() method replaced by add_event()",
-                      DeprecationWarning)
-        return self.add_event(s + str(event))
-
-class PersistentRandomPool (RandomPool):
-    def __init__ (self, filename=None, *args, **kwargs):
-        RandomPool.__init__(self, *args, **kwargs)
-        self.filename = filename
-        if filename:
-            try:
-                # the time taken to open and read the file might have
-                # a little disk variability, modulo disk/kernel caching...
-                f=open(filename, 'rb')
-                self.add_event()
-                data = f.read()
-                self.add_event()
-                # mix in the data from the file and wash the random pool
-                self.stir(data)
-                f.close()
-            except IOError:
-                # Oh, well; the file doesn't exist or is unreadable, so
-                # we'll just ignore it.
-                pass
-
-    def save(self):
-        if self.filename == "":
-            raise ValueError, "No filename set for this object"
-        # wash the random pool before save, provides some forward secrecy for
-        # old values of the pool.
-        self.stir_n()
-        f=open(self.filename, 'wb')
-        self.add_event()
-        f.write(self._randpool.tostring())
-        f.close()
-        self.add_event()
-        # wash the pool again, provide some protection for future values
-        self.stir()
-
-# non-echoing Windows keyboard entry
-_kb = 0
-if not _kb:
-    try:
-        import msvcrt
-        class KeyboardEntry:
-            def getch(self):
-                c = msvcrt.getch()
-                if c in ('\000', '\xe0'):
-                    # function key
-                    c += msvcrt.getch()
-                return c
-            def close(self, delay = 0):
-                if delay:
-                    time.sleep(delay)
-                    while msvcrt.kbhit():
-                        msvcrt.getch()
-        _kb = 1
-    except:
-        pass
-
-# non-echoing Posix keyboard entry
-if not _kb:
-    try:
-        import termios
-        class KeyboardEntry:
-            def __init__(self, fd = 0):
-                self._fd = fd
-                self._old = termios.tcgetattr(fd)
-                new = termios.tcgetattr(fd)
-                new[3]=new[3] & ~termios.ICANON & ~termios.ECHO
-                termios.tcsetattr(fd, termios.TCSANOW, new)
-            def getch(self):
-                termios.tcflush(0, termios.TCIFLUSH) # XXX Leave this in?
-                return os.read(self._fd, 1)
-            def close(self, delay = 0):
-                if delay:
-                    time.sleep(delay)
-                    termios.tcflush(self._fd, termios.TCIFLUSH)
-                termios.tcsetattr(self._fd, termios.TCSAFLUSH, self._old)
-        _kb = 1
-    except:
-        pass
-
-class KeyboardRandomPool (PersistentRandomPool):
-    def __init__(self, *args, **kwargs):
-        PersistentRandomPool.__init__(self, *args, **kwargs)
-
-    def randomize(self, N = 0):
-        "Adds N bits of entropy to random pool.  If N is 0, fill up pool."
-        import os, string, time
-        if N <= 0:
-            bits = self.bits - self.entropy
-        else:
-            bits = N*8
-        if bits == 0:
-            return
-        print bits,'bits of entropy are now required.  Please type on the keyboard'
-        print 'until enough randomness has been accumulated.'
-        kb = KeyboardEntry()
-        s=''    # We'll save the characters typed and add them to the pool.
-        hash = self._hash
-        e = 0
-        try:
-            while e < bits:
-                temp=str(bits-e).rjust(6)
-                os.write(1, temp)
-                s=s+kb.getch()
-                e += self.add_event(s)
-                os.write(1, 6*chr(8))
-            self.add_event(s+hash.new(s).digest() )
-        finally:
-            kb.close()
-        print '\n\007 Enough.  Please wait a moment.\n'
-        self.stir_n()   # wash the random pool.
-        kb.close(4)
-
-if __name__ == '__main__':
-    pool = RandomPool()
-    print 'random pool entropy', pool.entropy, 'bits'
-    pool.add_event('something')
-    print `pool.get_bytes(100)`
-    import tempfile, os
-    fname = tempfile.mktemp()
-    pool = KeyboardRandomPool(filename=fname)
-    print 'keyboard random pool entropy', pool.entropy, 'bits'
-    pool.randomize()
-    print 'keyboard random pool entropy', pool.entropy, 'bits'
-    pool.randomize(128)
-    pool.save()
-    saved = open(fname, 'rb').read()
-    print 'saved', `saved`
-    print 'pool ', `pool._randpool.tostring()`
-    newpool = PersistentRandomPool(fname)
-    print 'persistent random pool entropy', pool.entropy, 'bits'
-    os.remove(fname)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ac031357/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test.py b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test.py
deleted file mode 100644
index 7b23e9f..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test.py
+++ /dev/null
@@ -1,453 +0,0 @@
-#
-#   test.py : Functions used for testing the modules
-#
-#  Part of the Python Cryptography Toolkit
-#
-# Distribute and use freely; there are no restrictions on further
-# dissemination and usage except those imposed by the laws of your
-# country of residence.  This software is provided "as is" without
-# warranty of fitness for use or suitability for any purpose, express
-# or implied. Use at your own risk or not at all.
-#
-
-__revision__ = "$Id: test.py,v 1.16 2004/08/13 22:24:18 akuchling Exp $"
-
-import binascii
-import string
-import testdata
-
-from Crypto.Cipher import *
-
-def die(string):
-    import sys
-    print '***ERROR: ', string
-#    sys.exit(0)   # Will default to continuing onward...
-
-def print_timing (size, delta, verbose):
-    if verbose:
-        if delta == 0:
-            print 'Unable to measure time -- elapsed time too small'
-        else:
-            print '%.2f K/sec' % (size/delta)
-            
-def exerciseBlockCipher(cipher, verbose):
-    import string, time
-    try:
-        ciph = eval(cipher)
-    except NameError:
-        print cipher, 'module not available'
-        return None
-    print cipher+ ':'
-    str='1'                             # Build 128K of test data
-    for i in xrange(0, 17):
-        str=str+str
-    if ciph.key_size==0: ciph.key_size=16
-    password = 'password12345678Extra text for password'[0:ciph.key_size]
-    IV = 'Test IV Test IV Test IV Test'[0:ciph.block_size]
-
-    if verbose: print '  ECB mode:',
-    obj=ciph.new(password, ciph.MODE_ECB)
-    if obj.block_size != ciph.block_size:
-        die("Module and cipher object block_size don't match")
-
-    text='1234567812345678'[0:ciph.block_size]
-    c=obj.encrypt(text)
-    if (obj.decrypt(c)!=text): die('Error encrypting "'+text+'"')
-    text='KuchlingKuchling'[0:ciph.block_size]
-    c=obj.encrypt(text)
-    if (obj.decrypt(c)!=text): die('Error encrypting "'+text+'"')
-    text='NotTodayNotEver!'[0:ciph.block_size]
-    c=obj.encrypt(text)
-    if (obj.decrypt(c)!=text): die('Error encrypting "'+text+'"')
-
-    start=time.time()
-    s=obj.encrypt(str)
-    s2=obj.decrypt(s)
-    end=time.time()
-    if (str!=s2):
-        die('Error in resulting plaintext from ECB mode')
-    print_timing(256, end-start, verbose)
-    del obj
-
-    if verbose: print '  CFB mode:',
-    obj1=ciph.new(password, ciph.MODE_CFB, IV)
-    obj2=ciph.new(password, ciph.MODE_CFB, IV)
-    start=time.time()
-    ciphertext=obj1.encrypt(str[0:65536])
-    plaintext=obj2.decrypt(ciphertext)
-    end=time.time()
-    if (plaintext!=str[0:65536]):
-        die('Error in resulting plaintext from CFB mode')
-    print_timing(64, end-start, verbose)
-    del obj1, obj2
-
-    if verbose: print '  CBC mode:',
-    obj1=ciph.new(password, ciph.MODE_CBC, IV)
-    obj2=ciph.new(password, ciph.MODE_CBC, IV)
-    start=time.time()
-    ciphertext=obj1.encrypt(str)
-    plaintext=obj2.decrypt(ciphertext)
-    end=time.time()
-    if (plaintext!=str):
-        die('Error in resulting plaintext from CBC mode')
-    print_timing(256, end-start, verbose)
-    del obj1, obj2
-
-    if verbose: print '  PGP mode:',
-    obj1=ciph.new(password, ciph.MODE_PGP, IV)
-    obj2=ciph.new(password, ciph.MODE_PGP, IV)
-    start=time.time()
-    ciphertext=obj1.encrypt(str)
-    plaintext=obj2.decrypt(ciphertext)
-    end=time.time()
-    if (plaintext!=str):
-        die('Error in resulting plaintext from PGP mode')
-    print_timing(256, end-start, verbose)
-    del obj1, obj2
-
-    if verbose: print '  OFB mode:',
-    obj1=ciph.new(password, ciph.MODE_OFB, IV)
-    obj2=ciph.new(password, ciph.MODE_OFB, IV)
-    start=time.time()
-    ciphertext=obj1.encrypt(str)
-    plaintext=obj2.decrypt(ciphertext)
-    end=time.time()
-    if (plaintext!=str):
-        die('Error in resulting plaintext from OFB mode')
-    print_timing(256, end-start, verbose)
-    del obj1, obj2
-
-    def counter(length=ciph.block_size):
-        return length * 'a'
-
-    if verbose: print '  CTR mode:',
-    obj1=ciph.new(password, ciph.MODE_CTR, counter=counter)
-    obj2=ciph.new(password, ciph.MODE_CTR, counter=counter)
-    start=time.time()
-    ciphertext=obj1.encrypt(str)
-    plaintext=obj2.decrypt(ciphertext)
-    end=time.time()
-    if (plaintext!=str):
-        die('Error in resulting plaintext from CTR mode')
-    print_timing(256, end-start, verbose)
-    del obj1, obj2
-
-    # Test the IV handling
-    if verbose: print '  Testing IV handling'
-    obj1=ciph.new(password, ciph.MODE_CBC, IV)
-    plaintext='Test'*(ciph.block_size/4)*3
-    ciphertext1=obj1.encrypt(plaintext)
-    obj1.IV=IV
-    ciphertext2=obj1.encrypt(plaintext)
-    if ciphertext1!=ciphertext2:
-        die('Error in setting IV')
-
-    # Test keyword arguments
-    obj1=ciph.new(key=password)
-    obj1=ciph.new(password, mode=ciph.MODE_CBC)
-    obj1=ciph.new(mode=ciph.MODE_CBC, key=password)
-    obj1=ciph.new(IV=IV, mode=ciph.MODE_CBC, key=password)
-
-    return ciph
-
-def exerciseStreamCipher(cipher, verbose):
-    import string, time
-    try:
-        ciph = eval(cipher)
-    except (NameError):
-        print cipher, 'module not available'
-        return None
-    print cipher + ':',
-    str='1'                             # Build 128K of test data
-    for i in xrange(0, 17):
-        str=str+str
-    key_size = ciph.key_size or 16
-    password = 'password12345678Extra text for password'[0:key_size]
-
-    obj1=ciph.new(password)
-    obj2=ciph.new(password)
-    if obj1.block_size != ciph.block_size:
-        die("Module and cipher object block_size don't match")
-    if obj1.key_size != ciph.key_size:
-        die("Module and cipher object key_size don't match")
-
-    text='1234567812345678Python'
-    c=obj1.encrypt(text)
-    if (obj2.decrypt(c)!=text): die('Error encrypting "'+text+'"')
-    text='B1FF I2 A R3A11Y |<00L D00D!!!!!'
-    c=obj1.encrypt(text)
-    if (obj2.decrypt(c)!=text): die('Error encrypting "'+text+'"')
-    text='SpamSpamSpamSpamSpamSpamSpamSpamSpam'
-    c=obj1.encrypt(text)
-    if (obj2.decrypt(c)!=text): die('Error encrypting "'+text+'"')
-
-    start=time.time()
-    s=obj1.encrypt(str)
-    str=obj2.decrypt(s)
-    end=time.time()
-    print_timing(256, end-start, verbose)
-    del obj1, obj2
-
-    return ciph
-
-def TestStreamModules(args=['arc4', 'XOR'], verbose=1):
-    import sys, string
-    args=map(string.lower, args)
-
-    if 'arc4' in args:
-        # Test ARC4 stream cipher
-        arc4=exerciseStreamCipher('ARC4', verbose)
-        if (arc4!=None):
-                for entry in testdata.arc4:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=arc4.new(key)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('ARC4 failed on entry '+`entry`)
-
-    if 'xor' in args:
-        # Test XOR stream cipher
-        XOR=exerciseStreamCipher('XOR', verbose)
-        if (XOR!=None):
-                for entry in testdata.xor:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=XOR.new(key)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('XOR failed on entry '+`entry`)
-
-
-def TestBlockModules(args=['aes', 'arc2', 'des', 'blowfish', 'cast', 'des3',
-                           'idea', 'rc5'],
-                     verbose=1):
-    import string
-    args=map(string.lower, args)
-    if 'aes' in args:
-        ciph=exerciseBlockCipher('AES', verbose)        # AES
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.aes:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, ciph.MODE_ECB)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('AES failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-
-                for entry in testdata.aes_modes:
-                    mode, key, plain, cipher, kw = entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, mode, **kw)
-                    obj2=ciph.new(key, mode, **kw)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('AES encrypt failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-
-                    plain2=obj2.decrypt(ciphertext)
-                    if plain2!=plain:
-                        die('AES decrypt failed on entry '+`entry`)
-                        for i in plain2:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-
-
-    if 'arc2' in args:
-        ciph=exerciseBlockCipher('ARC2', verbose)           # Alleged RC2
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.arc2:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, ciph.MODE_ECB)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('ARC2 failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        print
-
-    if 'blowfish' in args:
-        ciph=exerciseBlockCipher('Blowfish',verbose)# Bruce Schneier's Blowfish cipher
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.blowfish:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, ciph.MODE_ECB)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('Blowfish failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-
-    if 'cast' in args:
-        ciph=exerciseBlockCipher('CAST', verbose)        # CAST-128
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.cast:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, ciph.MODE_ECB)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('CAST failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-
-                if 0:
-                    # The full-maintenance test; it requires 4 million encryptions,
-                    # and correspondingly is quite time-consuming.  I've disabled
-                    # it; it's faster to compile block/cast.c with -DTEST and run
-                    # the resulting program.
-                    a = b = '\x01\x23\x45\x67\x12\x34\x56\x78\x23\x45\x67\x89\x34\x56\x78\x9A'
-
-                    for i in range(0, 1000000):
-                        obj = cast.new(b, cast.MODE_ECB)
-                        a = obj.encrypt(a[:8]) + obj.encrypt(a[-8:])
-                        obj = cast.new(a, cast.MODE_ECB)
-                        b = obj.encrypt(b[:8]) + obj.encrypt(b[-8:])
-
-                    if a!="\xEE\xA9\xD0\xA2\x49\xFD\x3B\xA6\xB3\x43\x6F\xB8\x9D\x6D\xCA\x92":
-                        if verbose: print 'CAST test failed: value of "a" doesn\'t match'
-                    if b!="\xB2\xC9\x5E\xB0\x0C\x31\xAD\x71\x80\xAC\x05\xB8\xE8\x3D\x69\x6E":
-                        if verbose: print 'CAST test failed: value of "b" doesn\'t match'
-
-    if 'des' in args:
-        # Test/benchmark DES block cipher
-        des=exerciseBlockCipher('DES', verbose)
-        if (des!=None):
-            # Various tests taken from the DES library packaged with Kerberos V4
-            obj=des.new(binascii.a2b_hex('0123456789abcdef'), des.MODE_ECB)
-            s=obj.encrypt('Now is t')
-            if (s!=binascii.a2b_hex('3fa40e8a984d4815')):
-                die('DES fails test 1')
-            obj=des.new(binascii.a2b_hex('08192a3b4c5d6e7f'), des.MODE_ECB)
-            s=obj.encrypt('\000\000\000\000\000\000\000\000')
-            if (s!=binascii.a2b_hex('25ddac3e96176467')):
-                die('DES fails test 2')
-            obj=des.new(binascii.a2b_hex('0123456789abcdef'), des.MODE_CBC,
-                        binascii.a2b_hex('1234567890abcdef'))
-            s=obj.encrypt("Now is the time for all ")
-            if (s!=binascii.a2b_hex('e5c7cdde872bf27c43e934008c389c0f683788499a7c05f6')):
-                die('DES fails test 3')
-            obj=des.new(binascii.a2b_hex('0123456789abcdef'), des.MODE_CBC,
-                        binascii.a2b_hex('fedcba9876543210'))
-            s=obj.encrypt("7654321 Now is the time for \000\000\000\000")
-            if (s!=binascii.a2b_hex("ccd173ffab2039f4acd8aefddfd8a1eb468e91157888ba681d269397f7fe62b4")):
-                die('DES fails test 4')
-            del obj,s
-
-            # R. Rivest's test: see http://theory.lcs.mit.edu/~rivest/destest.txt
-            x=binascii.a2b_hex('9474B8E8C73BCA7D')
-            for i in range(0, 16):
-                obj=des.new(x, des.MODE_ECB)
-                if (i & 1): x=obj.decrypt(x)
-                else: x=obj.encrypt(x)
-            if x!=binascii.a2b_hex('1B1A2DDB4C642438'):
-                die("DES fails Rivest's test")
-
-            if verbose: print '  Verifying against test suite...'
-            for entry in testdata.des:
-                key,plain,cipher=entry
-                key=binascii.a2b_hex(key)
-                plain=binascii.a2b_hex(plain)
-                cipher=binascii.a2b_hex(cipher)
-                obj=des.new(key, des.MODE_ECB)
-                ciphertext=obj.encrypt(plain)
-                if (ciphertext!=cipher):
-                    die('DES failed on entry '+`entry`)
-            for entry in testdata.des_cbc:
-                key, iv, plain, cipher=entry
-                key, iv, cipher=binascii.a2b_hex(key),binascii.a2b_hex(iv),binascii.a2b_hex(cipher)
-                obj1=des.new(key, des.MODE_CBC, iv)
-                obj2=des.new(key, des.MODE_CBC, iv)
-                ciphertext=obj1.encrypt(plain)
-                if (ciphertext!=cipher):
-                    die('DES CBC mode failed on entry '+`entry`)
-
-    if 'des3' in args:
-        ciph=exerciseBlockCipher('DES3', verbose)        # Triple DES
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.des3:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, ciph.MODE_ECB)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('DES3 failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-                for entry in testdata.des3_cbc:
-                    key, iv, plain, cipher=entry
-                    key, iv, cipher=binascii.a2b_hex(key),binascii.a2b_hex(iv),binascii.a2b_hex(cipher)
-                    obj1=ciph.new(key, ciph.MODE_CBC, iv)
-                    obj2=ciph.new(key, ciph.MODE_CBC, iv)
-                    ciphertext=obj1.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('DES3 CBC mode failed on entry '+`entry`)
-
-    if 'idea' in args:
-        ciph=exerciseBlockCipher('IDEA', verbose)       # IDEA block cipher
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.idea:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key, ciph.MODE_ECB)
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('IDEA failed on entry '+`entry`)
-
-    if 'rc5' in args:
-        # Ronald Rivest's RC5 algorithm
-        ciph=exerciseBlockCipher('RC5', verbose)
-        if (ciph!=None):
-                if verbose: print '  Verifying against test suite...'
-                for entry in testdata.rc5:
-                    key,plain,cipher=entry
-                    key=binascii.a2b_hex(key)
-                    plain=binascii.a2b_hex(plain)
-                    cipher=binascii.a2b_hex(cipher)
-                    obj=ciph.new(key[4:], ciph.MODE_ECB,
-                                 version =ord(key[0]),
-                                 word_size=ord(key[1]),
-                                 rounds  =ord(key[2]) )
-                    ciphertext=obj.encrypt(plain)
-                    if (ciphertext!=cipher):
-                        die('RC5 failed on entry '+`entry`)
-                        for i in ciphertext:
-                            if verbose: print hex(ord(i)),
-                        if verbose: print
-
-
-

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ac031357/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test/prime_speed.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test/prime_speed.py b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test/prime_speed.py
deleted file mode 100644
index 320c132..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test/prime_speed.py
+++ /dev/null
@@ -1,24 +0,0 @@
-
-import time
-from Crypto.Util import number
-
-# Test of prime-generation speed
-
-# This randfunc is deterministic, so we should always find the same primes.
-chars = ''.join(map(chr, range(255, 0, -1)))
-def randfunc (N):
-    s = ''
-    while len(s)<N:
-        s += chars
-    return s[:N]
-
-def main ():
-    for i in range(128, 2049, 128):
-        s = time.time()
-        N = number.getPrime(i, randfunc)
-        e = time.time()
-        N = str(N)
-        print '%5i' % i, '%-7.03fsec' % (e-s), N[:10] + '...' + N[-10:]
-
-if __name__ == '__main__':
-    main()

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ac031357/tools/bin/pythonSrc/pycrypto-2.0.1/__init__.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/__init__.py b/tools/bin/pythonSrc/pycrypto-2.0.1/__init__.py
deleted file mode 100644
index 2324ae8..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/__init__.py
+++ /dev/null
@@ -1,25 +0,0 @@
-
-"""Python Cryptography Toolkit
-
-A collection of cryptographic modules implementing various algorithms
-and protocols.
-
-Subpackages:
-Crypto.Cipher             Secret-key encryption algorithms (AES, DES, ARC4)
-Crypto.Hash               Hashing algorithms (MD5, SHA, HMAC)
-Crypto.Protocol           Cryptographic protocols (Chaffing, all-or-nothing
-                          transform).   This package does not contain any
-                          network protocols.
-Crypto.PublicKey          Public-key encryption and signature algorithms
-                          (RSA, DSA)
-Crypto.Util               Various useful modules and functions (long-to-string
-                          conversion, random number generation, number
-                          theoretic functions)
-"""
-
-__all__ = ['Cipher', 'Hash', 'Protocol', 'PublicKey', 'Util']
-
-__version__ = '2.0.1'
-__revision__ = "$Id: __init__.py,v 1.12 2005/06/14 01:20:22 akuchling Exp $"
-
-

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/ac031357/tools/bin/pythonSrc/pycrypto-2.0.1/setup.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/setup.py b/tools/bin/pythonSrc/pycrypto-2.0.1/setup.py
deleted file mode 100644
index 7e90235..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/setup.py
+++ /dev/null
@@ -1,168 +0,0 @@
-#! /usr/bin/env python
-
-__revision__ = "$Id: setup.py,v 1.30 2005/06/14 01:20:22 akuchling Exp $"
-
-from distutils import core
-from distutils.core import Extension
-from distutils.command.build_ext import build_ext
-from distutils import sysconfig
-from distutils.sysconfig import get_python_lib
-import os, sys
-
-if sys.version[0:1] == '1':
-    raise RuntimeError, ("The Python Cryptography Toolkit requires "
-                         "Python 2.x to build.")
-
-if sys.platform == 'win32':
-    HTONS_LIBS = ['ws2_32']
-    plat_ext = [
-                Extension("Crypto.Util.winrandom",
-                          libraries = HTONS_LIBS + ['advapi32'],
-                          include_dirs=['src/'],
-                          sources=["src/winrand.c"])
-               ]
-else:
-    HTONS_LIBS = []
-    plat_ext = []
-
-# Functions for finding libraries and files, copied from Python's setup.py.
-
-def find_file(filename, std_dirs, paths):
-    """Searches for the directory where a given file is located,
-    and returns a possibly-empty list of additional directories, or None
-    if the file couldn't be found at all.
-
-    'filename' is the name of a file, such as readline.h or libcrypto.a.
-    'std_dirs' is the list of standard system directories; if the
-        file is found in one of them, no additional directives are needed.
-    'paths' is a list of additional locations to check; if the file is
-        found in one of them, the resulting list will contain the directory.
-    """
-
-    # Check the standard locations
-    for dir in std_dirs:
-        f = os.path.join(dir, filename)
-        if os.path.exists(f): return []
-
-    # Check the additional directories
-    for dir in paths:
-        f = os.path.join(dir, filename)
-        if os.path.exists(f):
-            return [dir]
-
-    # Not found anywhere
-    return None
-
-def find_library_file(compiler, libname, std_dirs, paths):
-    filename = compiler.library_filename(libname, lib_type='shared')
-    result = find_file(filename, std_dirs, paths)
-    if result is not None: return result
-
-    filename = compiler.library_filename(libname, lib_type='static')
-    result = find_file(filename, std_dirs, paths)
-    return result
-
-class PCTBuildExt (build_ext):
-    def build_extensions(self):
-        self.extensions += [
-            # Hash functions
-            Extension("Crypto.Hash.MD4",
-                      include_dirs=['src/'],
-                      sources=["src/MD4.c"]),
-            Extension("Crypto.Hash.RIPEMD",
-                      include_dirs=['src/'],
-                      sources=["src/RIPEMD.c"],
-                      libraries=HTONS_LIBS),
-            Extension("Crypto.Hash.SHA256",
-                      include_dirs=['src/'],
-                      sources=["src/SHA256.c"]),
-
-            # Block encryption algorithms
-            Extension("Crypto.Cipher.AES",
-                      include_dirs=['src/'],
-                      sources=["src/AES.c"]),
-            Extension("Crypto.Cipher.ARC2",
-                      include_dirs=['src/'],
-                      sources=["src/ARC2.c"]),
-            Extension("Crypto.Cipher.Blowfish",
-                      include_dirs=['src/'],
-                      sources=["src/Blowfish.c"]),
-            Extension("Crypto.Cipher.CAST",
-                      include_dirs=['src/'],
-                      sources=["src/CAST.c"]),
-            Extension("Crypto.Cipher.DES",
-                      include_dirs=['src/'],
-                      sources=["src/DES.c"]),
-            Extension("Crypto.Cipher.DES3",
-                      include_dirs=['src/'],
-                      sources=["src/DES3.c"]),
-            Extension("Crypto.Cipher.IDEA",
-                      include_dirs=['src/'],
-                      sources=["src/IDEA.c"],
-                      libraries=HTONS_LIBS),
-            Extension("Crypto.Cipher.RC5",
-                      include_dirs=['src/'],
-                      sources=["src/RC5.c"]),
-
-            # Stream ciphers
-            Extension("Crypto.Cipher.ARC4",
-                      include_dirs=['src/'],
-                      sources=["src/ARC4.c"]),
-            Extension("Crypto.Cipher.XOR",
-                      include_dirs=['src/'],
-                      sources=["src/XOR.c"]),
-            ]
-
-        # Detect which modules should be compiled
-        self.detect_modules()
-        build_ext.build_extensions(self)
-
-    def detect_modules (self):
-        self.compiler.library_dirs =  self.compiler.library_dirs + [ get_python_lib(1,1) + '/..' ]
-        lib_dirs = self.compiler.library_dirs + ['/lib', '/usr/lib']
-        print lib_dirs
-        inc_dirs = self.compiler.include_dirs + ['/usr/include']
-        exts = []
-        if (self.compiler.find_library_file(lib_dirs, 'gmp')):
-            exts.append(Extension("Crypto.PublicKey._fastmath",
-                                  include_dirs=['src/'],
-                                  libraries=['gmp'],
-                                  sources=["src/_fastmath.c"]))
-        self.extensions += exts
-
-kw = {'name':"pycrypto",
-      'version':"2.0.1",
-      'description':"Cryptographic modules for Python.",
-      'author':"A.M. Kuchling",
-      'author_email':"amk@amk.ca",
-      'url':"http://www.amk.ca/python/code/crypto",
-
-      'cmdclass' : {'build_ext':PCTBuildExt},
-      'packages' : ["Crypto", "Crypto.Hash", "Crypto.Cipher", "Crypto.Util",
-                  "Crypto.Protocol", "Crypto.PublicKey"],
-      'package_dir' : { "Crypto":"." },
-      # One module is defined here, because build_ext won't be
-      # called unless there's at least one extension module defined.
-      'ext_modules':[Extension("Crypto.Hash.MD2",
-                             include_dirs=['src/'],
-                             sources=["src/MD2.c"])],
-     }
-
-# If we're running Python 2.3, add extra information
-if hasattr(core, 'setup_keywords'):
-    if 'classifiers' in core.setup_keywords:
-        kw['classifiers'] = [
-          'Development Status :: 4 - Beta',
-          'License :: Public Domain',
-          'Intended Audience :: Developers',
-          'Operating System :: Unix',
-          'Operating System :: Microsoft :: Windows',
-          'Operating System :: MacOS :: MacOS X',
-          'Topic :: Security :: Cryptography',
-          ]
-    if 'download_url' in core.setup_keywords:
-        kw['download_url'] = ('http://www.amk.ca/files/python/crypto/'
-                              '%s-%s.tar.gz' % (kw['name'], kw['version']) )
-
-core.setup(**kw)
-


Mime
View raw message