You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hawq.apache.org by rl...@apache.org on 2016/07/14 09:09:58 UTC
[6/8] incubator-hawq git commit: HAWQ-926. Remove pycrypto from HAWQ
source code
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)
-