hawq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cjcjame...@apache.org
Subject [62/80] [abbrv] incubator-hawq git commit: HAWQ-863. Add python module pycrypto
Date Wed, 29 Jun 2016 01:21:20 GMT
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/2c87cdcb/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
new file mode 100644
index 0000000..9d50563
--- /dev/null
+++ b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/number.py
@@ -0,0 +1,201 @@
+#
+#   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/2c87cdcb/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
new file mode 100644
index 0000000..467501c
--- /dev/null
+++ b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/randpool.py
@@ -0,0 +1,421 @@
+#
+#  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/2c87cdcb/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
new file mode 100644
index 0000000..7b23e9f
--- /dev/null
+++ b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test.py
@@ -0,0 +1,453 @@
+#
+#   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/2c87cdcb/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
new file mode 100644
index 0000000..320c132
--- /dev/null
+++ b/tools/bin/pythonSrc/pycrypto-2.0.1/Util/test/prime_speed.py
@@ -0,0 +1,24 @@
+
+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/2c87cdcb/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
new file mode 100644
index 0000000..2324ae8
--- /dev/null
+++ b/tools/bin/pythonSrc/pycrypto-2.0.1/__init__.py
@@ -0,0 +1,25 @@
+
+"""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/2c87cdcb/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
new file mode 100644
index 0000000..7e90235
--- /dev/null
+++ b/tools/bin/pythonSrc/pycrypto-2.0.1/setup.py
@@ -0,0 +1,168 @@
+#! /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