hawq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r...@apache.org
Subject [09/15] incubator-hawq git commit: HAWQ-926. Remove pycrypto from HAWQ source code
Date Mon, 18 Jul 2016 10:12:33 GMT
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/src/block_template.c
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/src/block_template.c b/tools/bin/pythonSrc/pycrypto-2.0.1/src/block_template.c
deleted file mode 100644
index 5a922ca..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/src/block_template.c
+++ /dev/null
@@ -1,753 +0,0 @@
-
-/* -*- C -*- */
-/*
- *  block_template.c : Generic framework for block encryption algorithms
- *
- * 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. 
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef _HAVE_STDC_HEADERS
-#include <string.h>
-#endif
-
-#include "Python.h"
-#include "modsupport.h" 
-
-/* Cipher operation modes */
-
-#define MODE_ECB 1
-#define MODE_CBC 2
-#define MODE_CFB 3
-#define MODE_PGP 4
-#define MODE_OFB 5
-#define MODE_CTR 6
-
-#define _STR(x) #x
-#define _XSTR(x) _STR(x)
-#define _PASTE(x,y) x##y
-#define _PASTE2(x,y) _PASTE(x,y)
-#define _MODULE_NAME _PASTE2(init,MODULE_NAME)
-#define _MODULE_STRING _XSTR(MODULE_NAME)
-
-typedef struct 
-{
-	PyObject_HEAD 
-	int mode, count, segment_size;
-	unsigned char IV[BLOCK_SIZE], oldCipher[BLOCK_SIZE];
-	PyObject *counter;
-	block_state st;
-} ALGobject;
-
-staticforward PyTypeObject ALGtype;
-
-#define is_ALGobject(v)		((v)->ob_type == &ALGtype)
-
-static ALGobject *
-newALGobject(void)
-{
-	ALGobject * new;
-	new = PyObject_New(ALGobject, &ALGtype);
-	new->mode = MODE_ECB;
-	new->counter = NULL;
-	return new;
-}
-
-static void
-ALGdealloc(PyObject *ptr)
-{		
-	ALGobject *self = (ALGobject *)ptr;
-
-	/* Overwrite the contents of the object */
-	Py_XDECREF(self->counter);
-	self->counter = NULL;
-	memset(self->IV, 0, BLOCK_SIZE);
-	memset(self->oldCipher, 0, BLOCK_SIZE);
-	memset((char*)&(self->st), 0, sizeof(block_state));
-	self->mode = self->count = self->segment_size = 0;
-	PyObject_Del(ptr);
-}
-
-
-static char ALGnew__doc__[] = 
-"new(key, [mode], [IV]): Return a new " _MODULE_STRING " encryption object.";
-
-static char *kwlist[] = {"key", "mode", "IV", "counter", "segment_size",
-#ifdef PCT_RC5_MODULE
-			 "version", "word_size", "rounds",
-#endif
-			 NULL};
-
-static ALGobject *
-ALGnew(PyObject *self, PyObject *args, PyObject *kwdict)
-{
-	unsigned char *key, *IV;
-	ALGobject * new=NULL;
-	int keylen, IVlen=0, mode=MODE_ECB, segment_size=0;
-	PyObject *counter = NULL;
-#ifdef PCT_RC5_MODULE
-	int version = 0x10, word_size = 32, rounds = 16; /*XXX default rounds? */
-#endif 
-	/* Set default values */
-	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s#|is#Oi"
-#ifdef PCT_RC5_MODULE
-					 "iii"
-#endif 
-					 , kwlist,
-					 &key, &keylen, &mode, &IV, &IVlen,
-					 &counter, &segment_size
-#ifdef PCT_RC5_MODULE
-					 , &version, &word_size, &rounds
-#endif
-		)) 
-	{
-		return NULL;
-	}
-
-	if (KEY_SIZE!=0 && keylen!=KEY_SIZE)
-	{
-		PyErr_Format(PyExc_ValueError, 
-			     "Key must be %i bytes long, not %i",
-			     KEY_SIZE, keylen);
-		return NULL;
-	}
-	if (KEY_SIZE==0 && keylen==0)
-	{
-		PyErr_SetString(PyExc_ValueError, 
-				"Key cannot be the null string");
-		return NULL;
-	}
-	if (IVlen != BLOCK_SIZE && IVlen != 0)
-	{
-		PyErr_Format(PyExc_ValueError, 
-			     "IV must be %i bytes long", BLOCK_SIZE);
-		return NULL;
-	}
-	if (mode<MODE_ECB || mode>MODE_CTR) 
-	{
-		PyErr_Format(PyExc_ValueError, 
-			     "Unknown cipher feedback mode %i",
-			     mode);
-		return NULL;
-	}
-
-	/* Mode-specific checks */
-	if (mode == MODE_CFB) {
-		if (segment_size == 0) segment_size = 8;
-		if (segment_size < 1 || segment_size > BLOCK_SIZE*8) {
-			PyErr_Format(PyExc_ValueError, 
-				     "segment_size must be multiple of 8 "
-				     "between 1 and %i", BLOCK_SIZE);
-		}
-	}
-
-	if (mode == MODE_CTR) {
-		if (!PyCallable_Check(counter)) {
-			PyErr_SetString(PyExc_ValueError, 
-					"'counter' parameter must be a callable object");
-		}
-	} else {
-		if (counter != NULL) {
-			PyErr_SetString(PyExc_ValueError, 
-					"'counter' parameter only useful with CTR mode");
-		}
-	}
-
-	/* Cipher-specific checks */
-#ifdef PCT_RC5_MODULE
-	if (version!=0x10) {
-		PyErr_Format(PyExc_ValueError,
-			     "RC5: Bad RC5 algorithm version: %i",
-			     version);
-		return NULL;
-	}
-	if (word_size!=16 && word_size!=32) {
-		PyErr_Format(PyExc_ValueError,
-			     "RC5: Unsupported word size: %i",
-			     word_size);
-		return NULL;
-	}
-	if (rounds<0 || 255<rounds) {
-		PyErr_Format(PyExc_ValueError,
-			     "RC5: rounds must be between 0 and 255, not %i",
-			     rounds);
-		return NULL;
-	}
-#endif
-
-	/* Copy parameters into object */
-	new = newALGobject();
-	new->segment_size = segment_size;
-	new->counter = counter;
-	Py_XINCREF(counter);
-#ifdef PCT_RC5_MODULE
-	new->st.version = version;
-	new->st.word_size = word_size;
-	new->st.rounds = rounds;
-#endif
-
-	block_init(&(new->st), key, keylen);
-	if (PyErr_Occurred())
-	{
-		Py_DECREF(new);
-		return NULL;
-	}
-	memset(new->IV, 0, BLOCK_SIZE);
-	memset(new->oldCipher, 0, BLOCK_SIZE);
-	memcpy(new->IV, IV, IVlen);
-	new->mode = mode;
-	new->count=8;
-	return new;
-}
-
-static char ALG_Encrypt__doc__[] =
-"Encrypt the provided string of binary data.";
-
-static PyObject *
-ALG_Encrypt(ALGobject *self, PyObject *args)
-{
-	unsigned char *buffer, *str;
-	unsigned char temp[BLOCK_SIZE];
-	int i, j, len;
-	PyObject *result;
-  
-	if (!PyArg_Parse(args, "s#", &str, &len))
-		return NULL;
-	if (len==0)			/* Handle empty string */
-	{
-		return PyString_FromStringAndSize(NULL, 0);
-	}
-	if ( (len % BLOCK_SIZE) !=0 && 
-	     (self->mode!=MODE_CFB) && (self->mode!=MODE_PGP))
-	{
-		PyErr_Format(PyExc_ValueError, 
-			     "Input strings must be "
-			     "a multiple of %i in length",
-			     BLOCK_SIZE);
-		return NULL;
-	}
-	if (self->mode == MODE_CFB && 
-	    (len % (self->segment_size/8) !=0)) {
-		PyErr_Format(PyExc_ValueError, 
-			     "Input strings must be a multiple of "
-			     "the segment size %i in length",
-			     self->segment_size/8);
-		return NULL;
-	}
-
-	buffer=malloc(len);
-	if (buffer==NULL) 
-	{
-		PyErr_SetString(PyExc_MemoryError, 
-				"No memory available in "
-				_MODULE_STRING " encrypt");
-		return NULL;
-	}
-	switch(self->mode)
-	{
-	case(MODE_ECB):      
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			block_encrypt(&(self->st), str+i, buffer+i);
-		}
-		break;
-
-	case(MODE_CBC):      
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			for(j=0; j<BLOCK_SIZE; j++)
-			{
-				temp[j]=str[i+j]^self->IV[j];
-			}
-			block_encrypt(&(self->st), temp, buffer+i);
-			memcpy(self->IV, buffer+i, BLOCK_SIZE);
-		}
-		break;
-
-	case(MODE_CFB):      
-		for(i=0; i<len; i+=self->segment_size/8) 
-		{
-			block_encrypt(&(self->st), self->IV, temp);
-			for (j=0; j<self->segment_size/8; j++) {
-				buffer[i+j] = str[i+j] ^ temp[j];
-			}
-			if (self->segment_size == BLOCK_SIZE * 8) {
-				/* s == b: segment size is identical to 
-				   the algorithm block size */
-				memcpy(self->IV, buffer + i, BLOCK_SIZE);
-			}
-			else if ((self->segment_size % 8) == 0) {
-				int sz = self->segment_size/8;
-				memmove(self->IV, self->IV + sz, 
-					BLOCK_SIZE-sz);
-				memcpy(self->IV + BLOCK_SIZE - sz, buffer + i,
-				       sz);
-			}
-			else {
-				/* segment_size is not a multiple of 8; 
-				   currently this can't happen */
-			}
-		}
-		break;
-
-	case(MODE_PGP):
-		if (len<=BLOCK_SIZE-self->count) 
-		{			
-			/* If less than one block, XOR it in */
-			for(i=0; i<len; i++) 
-				buffer[i] = self->IV[self->count+i] ^= str[i];
-			self->count += len;
-		}
-		else 
-		{
-			int j;
-			for(i=0; i<BLOCK_SIZE-self->count; i++) 
-				buffer[i] = self->IV[self->count+i] ^= str[i];
-			self->count=0;
-			for(; i<len-BLOCK_SIZE; i+=BLOCK_SIZE) 
-			{
-				block_encrypt(&(self->st), self->oldCipher, 
-					      self->IV);
-				for(j=0; j<BLOCK_SIZE; j++)
-					buffer[i+j] = self->IV[j] ^= str[i+j];
-			}
-			/* Do the remaining 1 to BLOCK_SIZE bytes */
-			block_encrypt(&(self->st), self->oldCipher, self->IV);
-			self->count=len-i;
-			for(j=0; j<len-i; j++) 
-			{
-				buffer[i+j] = self->IV[j] ^= str[i+j];
-			}
-		}
-		break;
-
-	case(MODE_OFB):
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			block_encrypt(&(self->st), self->IV, temp);
-			memcpy(self->IV, temp, BLOCK_SIZE);
-			for(j=0; j<BLOCK_SIZE; j++)
-			{
-				buffer[i+j] = str[i+j] ^ temp[j];
-			}
-		}      
-		break;
-
-	case(MODE_CTR):
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			PyObject *ctr = PyObject_CallObject(self->counter, NULL);
-			if (ctr == NULL) {
-				free(buffer);
-				return NULL;
-			}
-			if (!PyString_Check(ctr))
-			{
-				PyErr_SetString(PyExc_TypeError, 
-						"CTR counter function didn't return a string");
-				Py_DECREF(ctr);
-				free(buffer);
-				return NULL;
-			}
-			if (PyString_Size(ctr) != BLOCK_SIZE) {
-				PyErr_Format(PyExc_TypeError, 
-					     "CTR counter function returned "
-					     "string not of length %i",
-					     BLOCK_SIZE);
-				Py_DECREF(ctr);
-				free(buffer);
-				return NULL;
-			}
-			block_encrypt(&(self->st), PyString_AsString(ctr), 
-				      temp);
-			Py_DECREF(ctr);
-			for(j=0; j<BLOCK_SIZE; j++)
-			{
-				buffer[i+j] = str[i+j]^temp[j];
-			}
-		}
-		break;
-
-	default:
-		PyErr_Format(PyExc_SystemError, 
-			     "Unknown ciphertext feedback mode %i; "
-			     "this shouldn't happen",
-			     self->mode);
-		free(buffer);
-		return NULL;
-	}
-	result=PyString_FromStringAndSize(buffer, len);
-	free(buffer);
-	return(result);
-}
-
-static char ALG_Decrypt__doc__[] =
-"decrypt(string): Decrypt the provided string of binary data.";
-
-
-static PyObject *
-ALG_Decrypt(ALGobject *self, PyObject *args)
-{
-	unsigned char *buffer, *str;
-	unsigned char temp[BLOCK_SIZE];
-	int i, j, len;
-	PyObject *result;
-  
-	if (!PyArg_Parse(args, "s#", &str, &len))
-		return NULL;
-	if (len==0)			/* Handle empty string */
-	{
-		return PyString_FromStringAndSize(NULL, 0);
-	}
-	if ( (len % BLOCK_SIZE) !=0 && 
-	     (self->mode!=MODE_CFB && self->mode!=MODE_PGP))
-	{
-		PyErr_Format(PyExc_ValueError, 
-			     "Input strings must be "
-			     "a multiple of %i in length",
-			     BLOCK_SIZE);
-		return NULL;
-	}
-	if (self->mode == MODE_CFB && 
-	    (len % (self->segment_size/8) !=0)) {
-		PyErr_Format(PyExc_ValueError, 
-			     "Input strings must be a multiple of "
-			     "the segment size %i in length",
-			     self->segment_size/8);
-		return NULL;
-	}
-	buffer=malloc(len);
-	if (buffer==NULL) 
-	{
-		PyErr_SetString(PyExc_MemoryError, 
-				"No memory available in " _MODULE_STRING
-				" decrypt");
-		return NULL;
-	}
-	switch(self->mode)
-	{
-	case(MODE_ECB):      
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			block_decrypt(&(self->st), str+i, buffer+i);
-		}
-		break;
-
-	case(MODE_CBC):      
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			memcpy(self->oldCipher, self->IV, BLOCK_SIZE);
-			block_decrypt(&(self->st), str+i, temp);
-			for(j=0; j<BLOCK_SIZE; j++) 
-			{
-				buffer[i+j]=temp[j]^self->IV[j];
-				self->IV[j]=str[i+j];
-			}
-		}
-		break;
-
-	case(MODE_CFB):      
-		for(i=0; i<len; i+=self->segment_size/8) 
-		{
-			block_encrypt(&(self->st), self->IV, temp);
-			for (j=0; j<self->segment_size/8; j++) {
-				buffer[i+j] = str[i+j]^temp[j];
-			}
-			if (self->segment_size == BLOCK_SIZE * 8) {
-				/* s == b: segment size is identical to 
-				   the algorithm block size */
-				memcpy(self->IV, str + i, BLOCK_SIZE);
-			}
-			else if ((self->segment_size % 8) == 0) {
-				int sz = self->segment_size/8;
-				memmove(self->IV, self->IV + sz, 
-					BLOCK_SIZE-sz);
-				memcpy(self->IV + BLOCK_SIZE - sz, str + i, 
-				       sz);
-			}
-			else {
-				/* segment_size is not a multiple of 8; 
-				   currently this can't happen */
-			}
-		}
-		break;
-
-	case(MODE_PGP):
-		if (len<=BLOCK_SIZE-self->count) 
-		{			
-                        /* If less than one block, XOR it in */
-			unsigned char t;
-			for(i=0; i<len; i++)
-			{
-				t=self->IV[self->count+i];
-				buffer[i] = t ^ (self->IV[self->count+i] = str[i]);
-			}
-			self->count += len;
-		}
-		else 
-		{
-			int j;
-			unsigned char t;
-			for(i=0; i<BLOCK_SIZE-self->count; i++) 
-			{
-				t=self->IV[self->count+i];
-				buffer[i] = t ^ (self->IV[self->count+i] = str[i]);
-			}
-			self->count=0;
-			for(; i<len-BLOCK_SIZE; i+=BLOCK_SIZE) 
-			{
-				block_encrypt(&(self->st), self->oldCipher, self->IV);
-				for(j=0; j<BLOCK_SIZE; j++)
-				{
-					t=self->IV[j];
-					buffer[i+j] = t ^ (self->IV[j] = str[i+j]);
-				}
-			}
-			/* Do the remaining 1 to BLOCK_SIZE bytes */
-			block_encrypt(&(self->st), self->oldCipher, self->IV);
-			self->count=len-i;
-			for(j=0; j<len-i; j++) 
-			{
-				t=self->IV[j];
-				buffer[i+j] = t ^ (self->IV[j] = str[i+j]);
-			}
-		}
-		break;
-
-	case (MODE_OFB):
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			block_encrypt(&(self->st), self->IV, temp);
-			memcpy(self->IV, temp, BLOCK_SIZE);
-			for(j=0; j<BLOCK_SIZE; j++)
-			{
-				buffer[i+j] = str[i+j] ^ self->IV[j];
-			}
-		}      
-		break;
-
-	case (MODE_CTR):
-		for(i=0; i<len; i+=BLOCK_SIZE) 
-		{
-			PyObject *ctr = PyObject_CallObject(self->counter, NULL);
-			if (ctr == NULL) {
-				free(buffer);
-				return NULL;
-			}
-			if (!PyString_Check(ctr))
-			{
-				PyErr_SetString(PyExc_TypeError, 
-						"CTR counter function didn't return a string");
-				Py_DECREF(ctr);
-				free(buffer);
-				return NULL;
-			}
-			if (PyString_Size(ctr) != BLOCK_SIZE) {
-				PyErr_SetString(PyExc_TypeError, 
-						"CTR counter function returned string of incorrect length");
-				Py_DECREF(ctr);
-				free(buffer);
-				return NULL;
-			}
-			block_encrypt(&(self->st), PyString_AsString(ctr), temp);
-			Py_DECREF(ctr);
-			for(j=0; j<BLOCK_SIZE; j++)
-			{
-				buffer[i+j] = str[i+j]^temp[j];
-			}
-		}
-		break;
-
-	default:
-		PyErr_Format(PyExc_SystemError, 
-			     "Unknown ciphertext feedback mode %i; "
-			     "this shouldn't happen",
-			     self->mode);
-		free(buffer);
-		return NULL;
-	}
-	result=PyString_FromStringAndSize(buffer, len);
-	free(buffer);
-	return(result);
-}
-
-static char ALG_Sync__doc__[] =
-"sync(): For objects using the PGP feedback mode, this method modifies "
-"the IV, synchronizing it with the preceding ciphertext.";
-
-static PyObject *
-ALG_Sync(ALGobject *self, PyObject *args)
-{
-	if (!PyArg_ParseTuple(args, "")) {
-		return NULL;
-	}
-
-	if (self->mode!=MODE_PGP) 
-	{
-		PyErr_SetString(PyExc_SystemError, "sync() operation not defined for "
-				"this feedback mode");
-		return NULL;
-	}
-	
-	if (self->count!=8) 
-	{
-		memmove(self->IV+BLOCK_SIZE-self->count, self->IV, 
-			self->count);
-		memcpy(self->IV, self->oldCipher+self->count, 
-		       BLOCK_SIZE-self->count);
-		self->count=8;
-	}
-	Py_INCREF(Py_None);
-	return Py_None;
-}
-
-#if 0
-void PrintState(self, msg)
-     ALGobject *self;
-     char * msg;
-{
-  int count;
-  
-  printf("%sing: %i IV ", msg, (int)self->count);
-  for(count=0; count<8; count++) printf("%i ", self->IV[count]);
-  printf("\noldCipher:");
-  for(count=0; count<8; count++) printf("%i ", self->oldCipher[count]);
-  printf("\n");
-}
-#endif
-
-
-/* ALG object methods */
-
-static PyMethodDef ALGmethods[] =
-{
- {"encrypt", (PyCFunction) ALG_Encrypt, 0, ALG_Encrypt__doc__},
- {"decrypt", (PyCFunction) ALG_Decrypt, 0, ALG_Decrypt__doc__},
- {"sync", (PyCFunction) ALG_Sync, METH_VARARGS, ALG_Sync__doc__},
- {NULL, NULL}			/* sentinel */
-};
-
-
-static int
-ALGsetattr(PyObject *ptr, char *name, PyObject *v)
-{
-  ALGobject *self=(ALGobject *)ptr;
-  if (strcmp(name, "IV") != 0) 
-    {
-      PyErr_Format(PyExc_AttributeError,
-		   "non-existent block cipher object attribute '%s'",
-		   name);
-      return -1;
-    }
-  if (v==NULL)
-    {
-      PyErr_SetString(PyExc_AttributeError,
-		      "Can't delete IV attribute of block cipher object");
-      return -1;
-    }
-  if (!PyString_Check(v))
-    {
-      PyErr_SetString(PyExc_TypeError,
-		      "IV attribute of block cipher object must be string");
-      return -1;
-    }
-  if (PyString_Size(v)!=BLOCK_SIZE) 
-    {
-      PyErr_Format(PyExc_ValueError, 
-		   _MODULE_STRING " IV must be %i bytes long",
-		   BLOCK_SIZE);
-      return -1;
-    }
-  memcpy(self->IV, PyString_AsString(v), BLOCK_SIZE);
-  return 0;
-}
-
-static PyObject *
-ALGgetattr(PyObject *s, char *name)
-{
-  ALGobject *self = (ALGobject*)s;
-  if (strcmp(name, "IV") == 0) 
-    {
-      return(PyString_FromStringAndSize(self->IV, BLOCK_SIZE));
-    }
-  if (strcmp(name, "mode") == 0)
-     {
-       return(PyInt_FromLong((long)(self->mode)));
-     }
-  if (strcmp(name, "block_size") == 0)
-     {
-       return PyInt_FromLong(BLOCK_SIZE);
-     }
-  if (strcmp(name, "key_size") == 0)
-     {
-       return PyInt_FromLong(KEY_SIZE);
-     }
- return Py_FindMethod(ALGmethods, (PyObject *) self, name);
-}
-
-/* List of functions defined in the module */
-
-static struct PyMethodDef modulemethods[] =
-{
- {"new", (PyCFunction) ALGnew, METH_VARARGS|METH_KEYWORDS, ALGnew__doc__},
- {NULL, NULL}			/* sentinel */
-};
-
-static PyTypeObject ALGtype =
-{
-	PyObject_HEAD_INIT(NULL)
-	0,				/*ob_size*/
-	_MODULE_STRING,		/*tp_name*/
-	sizeof(ALGobject),	/*tp_size*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	ALGdealloc,	/*tp_dealloc*/
-	0,				/*tp_print*/
-	ALGgetattr,	/*tp_getattr*/
-	ALGsetattr,    /*tp_setattr*/
-	0,			/*tp_compare*/
-	(reprfunc) 0,			/*tp_repr*/
-	0,				/*tp_as_number*/
-};
-
-/* Initialization function for the module */
-
-#if PYTHON_API_VERSION < 1011
-#define PyModule_AddIntConstant(m,n,v) {PyObject *o=PyInt_FromLong(v); \
-           if (o!=NULL) \
-             {PyDict_SetItemString(PyModule_GetDict(m),n,o); Py_DECREF(o);}}
-#endif
-
-void
-_MODULE_NAME (void)
-{
-	PyObject *m;
-
-	ALGtype.ob_type = &PyType_Type;
-
-	/* Create the module and add the functions */
-	m = Py_InitModule("Crypto.Cipher." _MODULE_STRING, modulemethods);
-
-	PyModule_AddIntConstant(m, "MODE_ECB", MODE_ECB);
-	PyModule_AddIntConstant(m, "MODE_CBC", MODE_CBC);
-	PyModule_AddIntConstant(m, "MODE_CFB", MODE_CFB);
-	PyModule_AddIntConstant(m, "MODE_PGP", MODE_PGP);
-	PyModule_AddIntConstant(m, "MODE_OFB", MODE_OFB);
-	PyModule_AddIntConstant(m, "MODE_CTR", MODE_CTR);
-	PyModule_AddIntConstant(m, "block_size", BLOCK_SIZE);
-	PyModule_AddIntConstant(m, "key_size", KEY_SIZE);
-
-	/* Check for errors */
-	if (PyErr_Occurred())
-		Py_FatalError("can't initialize module " _MODULE_STRING);
-}
-

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/src/cast5.c
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/src/cast5.c b/tools/bin/pythonSrc/pycrypto-2.0.1/src/cast5.c
deleted file mode 100644
index 0843b98..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/src/cast5.c
+++ /dev/null
@@ -1,437 +0,0 @@
-/*
-   These are the S-boxes for CAST5 as given in RFC 2144.
-*/
-
-
-static const uint32 S1[256] = {
-0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f,
-0x9c004dd3, 0x6003e540, 0xcf9fc949, 0xbfd4af27, 0x88bbbdb5,
-0xe2034090, 0x98d09675, 0x6e63a0e0, 0x15c361d2, 0xc2e7661d,
-0x22d4ff8e, 0x28683b6f, 0xc07fd059, 0xff2379c8, 0x775f50e2,
-0x43c340d3, 0xdf2f8656, 0x887ca41a, 0xa2d2bd2d, 0xa1c9e0d6,
-0x346c4819, 0x61b76d87, 0x22540f2f, 0x2abe32e1, 0xaa54166b,
-0x22568e3a, 0xa2d341d0, 0x66db40c8, 0xa784392f, 0x004dff2f,
-0x2db9d2de, 0x97943fac, 0x4a97c1d8, 0x527644b7, 0xb5f437a7,
-0xb82cbaef, 0xd751d159, 0x6ff7f0ed, 0x5a097a1f, 0x827b68d0,
-0x90ecf52e, 0x22b0c054, 0xbc8e5935, 0x4b6d2f7f, 0x50bb64a2,
-0xd2664910, 0xbee5812d, 0xb7332290, 0xe93b159f, 0xb48ee411,
-0x4bff345d, 0xfd45c240, 0xad31973f, 0xc4f6d02e, 0x55fc8165,
-0xd5b1caad, 0xa1ac2dae, 0xa2d4b76d, 0xc19b0c50, 0x882240f2,
-0x0c6e4f38, 0xa4e4bfd7, 0x4f5ba272, 0x564c1d2f, 0xc59c5319,
-0xb949e354, 0xb04669fe, 0xb1b6ab8a, 0xc71358dd, 0x6385c545,
-0x110f935d, 0x57538ad5, 0x6a390493, 0xe63d37e0, 0x2a54f6b3,
-0x3a787d5f, 0x6276a0b5, 0x19a6fcdf, 0x7a42206a, 0x29f9d4d5,
-0xf61b1891, 0xbb72275e, 0xaa508167, 0x38901091, 0xc6b505eb,
-0x84c7cb8c, 0x2ad75a0f, 0x874a1427, 0xa2d1936b, 0x2ad286af,
-0xaa56d291, 0xd7894360, 0x425c750d, 0x93b39e26, 0x187184c9,
-0x6c00b32d, 0x73e2bb14, 0xa0bebc3c, 0x54623779, 0x64459eab,
-0x3f328b82, 0x7718cf82, 0x59a2cea6, 0x04ee002e, 0x89fe78e6,
-0x3fab0950, 0x325ff6c2, 0x81383f05, 0x6963c5c8, 0x76cb5ad6,
-0xd49974c9, 0xca180dcf, 0x380782d5, 0xc7fa5cf6, 0x8ac31511,
-0x35e79e13, 0x47da91d0, 0xf40f9086, 0xa7e2419e, 0x31366241,
-0x051ef495, 0xaa573b04, 0x4a805d8d, 0x548300d0, 0x00322a3c,
-0xbf64cddf, 0xba57a68e, 0x75c6372b, 0x50afd341, 0xa7c13275,
-0x915a0bf5, 0x6b54bfab, 0x2b0b1426, 0xab4cc9d7, 0x449ccd82,
-0xf7fbf265, 0xab85c5f3, 0x1b55db94, 0xaad4e324, 0xcfa4bd3f,
-0x2deaa3e2, 0x9e204d02, 0xc8bd25ac, 0xeadf55b3, 0xd5bd9e98,
-0xe31231b2, 0x2ad5ad6c, 0x954329de, 0xadbe4528, 0xd8710f69,
-0xaa51c90f, 0xaa786bf6, 0x22513f1e, 0xaa51a79b, 0x2ad344cc,
-0x7b5a41f0, 0xd37cfbad, 0x1b069505, 0x41ece491, 0xb4c332e6,
-0x032268d4, 0xc9600acc, 0xce387e6d, 0xbf6bb16c, 0x6a70fb78,
-0x0d03d9c9, 0xd4df39de, 0xe01063da, 0x4736f464, 0x5ad328d8,
-0xb347cc96, 0x75bb0fc3, 0x98511bfb, 0x4ffbcc35, 0xb58bcf6a,
-0xe11f0abc, 0xbfc5fe4a, 0xa70aec10, 0xac39570a, 0x3f04442f,
-0x6188b153, 0xe0397a2e, 0x5727cb79, 0x9ceb418f, 0x1cacd68d,
-0x2ad37c96, 0x0175cb9d, 0xc69dff09, 0xc75b65f0, 0xd9db40d8,
-0xec0e7779, 0x4744ead4, 0xb11c3274, 0xdd24cb9e, 0x7e1c54bd,
-0xf01144f9, 0xd2240eb1, 0x9675b3fd, 0xa3ac3755, 0xd47c27af,
-0x51c85f4d, 0x56907596, 0xa5bb15e6, 0x580304f0, 0xca042cf1,
-0x011a37ea, 0x8dbfaadb, 0x35ba3e4a, 0x3526ffa0, 0xc37b4d09,
-0xbc306ed9, 0x98a52666, 0x5648f725, 0xff5e569d, 0x0ced63d0,
-0x7c63b2cf, 0x700b45e1, 0xd5ea50f1, 0x85a92872, 0xaf1fbda7,
-0xd4234870, 0xa7870bf3, 0x2d3b4d79, 0x42e04198, 0x0cd0ede7,
-0x26470db8, 0xf881814c, 0x474d6ad7, 0x7c0c5e5c, 0xd1231959,
-0x381b7298, 0xf5d2f4db, 0xab838653, 0x6e2f1e23, 0x83719c9e,
-0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c,
-0xe1e696ff, 0xb141ab08, 0x7cca89b9, 0x1a69e783, 0x02cc4843,
-0xa2f7c579, 0x429ef47d, 0x427b169c, 0x5ac9f049, 0xdd8f0f00,
-0x5c8165bf };
-
-static const uint32 S2[256] = {
-0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a,
-0xeec5207a, 0x55889c94, 0x72fc0651, 0xada7ef79, 0x4e1d7235,
-0xd55a63ce, 0xde0436ba, 0x99c430ef, 0x5f0c0794, 0x18dcdb7d,
-0xa1d6eff3, 0xa0b52f7b, 0x59e83605, 0xee15b094, 0xe9ffd909,
-0xdc440086, 0xef944459, 0xba83ccb3, 0xe0c3cdfb, 0xd1da4181,
-0x3b092ab1, 0xf997f1c1, 0xa5e6cf7b, 0x01420ddb, 0xe4e7ef5b,
-0x25a1ff41, 0xe180f806, 0x1fc41080, 0x179bee7a, 0xd37ac6a9,
-0xfe5830a4, 0x98de8b7f, 0x77e83f4e, 0x79929269, 0x24fa9f7b,
-0xe113c85b, 0xacc40083, 0xd7503525, 0xf7ea615f, 0x62143154,
-0x0d554b63, 0x5d681121, 0xc866c359, 0x3d63cf73, 0xcee234c0,
-0xd4d87e87, 0x5c672b21, 0x071f6181, 0x39f7627f, 0x361e3084,
-0xe4eb573b, 0x602f64a4, 0xd63acd9c, 0x1bbc4635, 0x9e81032d,
-0x2701f50c, 0x99847ab4, 0xa0e3df79, 0xba6cf38c, 0x10843094,
-0x2537a95e, 0xf46f6ffe, 0xa1ff3b1f, 0x208cfb6a, 0x8f458c74,
-0xd9e0a227, 0x4ec73a34, 0xfc884f69, 0x3e4de8df, 0xef0e0088,
-0x3559648d, 0x8a45388c, 0x1d804366, 0x721d9bfd, 0xa58684bb,
-0xe8256333, 0x844e8212, 0x128d8098, 0xfed33fb4, 0xce280ae1,
-0x27e19ba5, 0xd5a6c252, 0xe49754bd, 0xc5d655dd, 0xeb667064,
-0x77840b4d, 0xa1b6a801, 0x84db26a9, 0xe0b56714, 0x21f043b7,
-0xe5d05860, 0x54f03084, 0x066ff472, 0xa31aa153, 0xdadc4755,
-0xb5625dbf, 0x68561be6, 0x83ca6b94, 0x2d6ed23b, 0xeccf01db,
-0xa6d3d0ba, 0xb6803d5c, 0xaf77a709, 0x33b4a34c, 0x397bc8d6,
-0x5ee22b95, 0x5f0e5304, 0x81ed6f61, 0x20e74364, 0xb45e1378,
-0xde18639b, 0x881ca122, 0xb96726d1, 0x8049a7e8, 0x22b7da7b,
-0x5e552d25, 0x5272d237, 0x79d2951c, 0xc60d894c, 0x488cb402,
-0x1ba4fe5b, 0xa4b09f6b, 0x1ca815cf, 0xa20c3005, 0x8871df63,
-0xb9de2fcb, 0x0cc6c9e9, 0x0beeff53, 0xe3214517, 0xb4542835,
-0x9f63293c, 0xee41e729, 0x6e1d2d7c, 0x50045286, 0x1e6685f3,
-0xf33401c6, 0x30a22c95, 0x31a70850, 0x60930f13, 0x73f98417,
-0xa1269859, 0xec645c44, 0x52c877a9, 0xcdff33a6, 0xa02b1741,
-0x7cbad9a2, 0x2180036f, 0x50d99c08, 0xcb3f4861, 0xc26bd765,
-0x64a3f6ab, 0x80342676, 0x25a75e7b, 0xe4e6d1fc, 0x20c710e6,
-0xcdf0b680, 0x17844d3b, 0x31eef84d, 0x7e0824e4, 0x2ccb49eb,
-0x846a3bae, 0x8ff77888, 0xee5d60f6, 0x7af75673, 0x2fdd5cdb,
-0xa11631c1, 0x30f66f43, 0xb3faec54, 0x157fd7fa, 0xef8579cc,
-0xd152de58, 0xdb2ffd5e, 0x8f32ce19, 0x306af97a, 0x02f03ef8,
-0x99319ad5, 0xc242fa0f, 0xa7e3ebb0, 0xc68e4906, 0xb8da230c,
-0x80823028, 0xdcdef3c8, 0xd35fb171, 0x088a1bc8, 0xbec0c560,
-0x61a3c9e8, 0xbca8f54d, 0xc72feffa, 0x22822e99, 0x82c570b4,
-0xd8d94e89, 0x8b1c34bc, 0x301e16e6, 0x273be979, 0xb0ffeaa6,
-0x61d9b8c6, 0x00b24869, 0xb7ffce3f, 0x08dc283b, 0x43daf65a,
-0xf7e19798, 0x7619b72f, 0x8f1c9ba4, 0xdc8637a0, 0x16a7d3b1,
-0x9fc393b7, 0xa7136eeb, 0xc6bcc63e, 0x1a513742, 0xef6828bc,
-0x520365d6, 0x2d6a77ab, 0x3527ed4b, 0x821fd216, 0x095c6e2e,
-0xdb92f2fb, 0x5eea29cb, 0x145892f5, 0x91584f7f, 0x5483697b,
-0x2667a8cc, 0x85196048, 0x8c4bacea, 0x833860d4, 0x0d23e0f9,
-0x6c387e8a, 0x0ae6d249, 0xb284600c, 0xd835731d, 0xdcb1c647,
-0xac4c56ea, 0x3ebd81b3, 0x230eabb0, 0x6438bc87, 0xf0b5b1fa,
-0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589,
-0xa345415e, 0x5c038323, 0x3e5d3bb9, 0x43d79572, 0x7e6dd07c,
-0x06dfdf1e, 0x6c6cc4ef, 0x7160a539, 0x73bfbe70, 0x83877605,
-0x4523ecf1 };
-
-static const uint32 S3[256] = {
-0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff,
-0x369fe44b, 0x8c1fc644, 0xaececa90, 0xbeb1f9bf, 0xeefbcaea,
-0xe8cf1950, 0x51df07ae, 0x920e8806, 0xf0ad0548, 0xe13c8d83,
-0x927010d5, 0x11107d9f, 0x07647db9, 0xb2e3e4d4, 0x3d4f285e,
-0xb9afa820, 0xfade82e0, 0xa067268b, 0x8272792e, 0x553fb2c0,
-0x489ae22b, 0xd4ef9794, 0x125e3fbc, 0x21fffcee, 0x825b1bfd,
-0x9255c5ed, 0x1257a240, 0x4e1a8302, 0xbae07fff, 0x528246e7,
-0x8e57140e, 0x3373f7bf, 0x8c9f8188, 0xa6fc4ee8, 0xc982b5a5,
-0xa8c01db7, 0x579fc264, 0x67094f31, 0xf2bd3f5f, 0x40fff7c1,
-0x1fb78dfc, 0x8e6bd2c1, 0x437be59b, 0x99b03dbf, 0xb5dbc64b,
-0x638dc0e6, 0x55819d99, 0xa197c81c, 0x4a012d6e, 0xc5884a28,
-0xccc36f71, 0xb843c213, 0x6c0743f1, 0x8309893c, 0x0feddd5f,
-0x2f7fe850, 0xd7c07f7e, 0x02507fbf, 0x5afb9a04, 0xa747d2d0,
-0x1651192e, 0xaf70bf3e, 0x58c31380, 0x5f98302e, 0x727cc3c4,
-0x0a0fb402, 0x0f7fef82, 0x8c96fdad, 0x5d2c2aae, 0x8ee99a49,
-0x50da88b8, 0x8427f4a0, 0x1eac5790, 0x796fb449, 0x8252dc15,
-0xefbd7d9b, 0xa672597d, 0xada840d8, 0x45f54504, 0xfa5d7403,
-0xe83ec305, 0x4f91751a, 0x925669c2, 0x23efe941, 0xa903f12e,
-0x60270df2, 0x0276e4b6, 0x94fd6574, 0x927985b2, 0x8276dbcb,
-0x02778176, 0xf8af918d, 0x4e48f79e, 0x8f616ddf, 0xe29d840e,
-0x842f7d83, 0x340ce5c8, 0x96bbb682, 0x93b4b148, 0xef303cab,
-0x984faf28, 0x779faf9b, 0x92dc560d, 0x224d1e20, 0x8437aa88,
-0x7d29dc96, 0x2756d3dc, 0x8b907cee, 0xb51fd240, 0xe7c07ce3,
-0xe566b4a1, 0xc3e9615e, 0x3cf8209d, 0x6094d1e3, 0xcd9ca341,
-0x5c76460e, 0x00ea983b, 0xd4d67881, 0xfd47572c, 0xf76cedd9,
-0xbda8229c, 0x127dadaa, 0x438a074e, 0x1f97c090, 0x081bdb8a,
-0x93a07ebe, 0xb938ca15, 0x97b03cff, 0x3dc2c0f8, 0x8d1ab2ec,
-0x64380e51, 0x68cc7bfb, 0xd90f2788, 0x12490181, 0x5de5ffd4,
-0xdd7ef86a, 0x76a2e214, 0xb9a40368, 0x925d958f, 0x4b39fffa,
-0xba39aee9, 0xa4ffd30b, 0xfaf7933b, 0x6d498623, 0x193cbcfa,
-0x27627545, 0x825cf47a, 0x61bd8ba0, 0xd11e42d1, 0xcead04f4,
-0x127ea392, 0x10428db7, 0x8272a972, 0x9270c4a8, 0x127de50b,
-0x285ba1c8, 0x3c62f44f, 0x35c0eaa5, 0xe805d231, 0x428929fb,
-0xb4fcdf82, 0x4fb66a53, 0x0e7dc15b, 0x1f081fab, 0x108618ae,
-0xfcfd086d, 0xf9ff2889, 0x694bcc11, 0x236a5cae, 0x12deca4d,
-0x2c3f8cc5, 0xd2d02dfe, 0xf8ef5896, 0xe4cf52da, 0x95155b67,
-0x494a488c, 0xb9b6a80c, 0x5c8f82bc, 0x89d36b45, 0x3a609437,
-0xec00c9a9, 0x44715253, 0x0a874b49, 0xd773bc40, 0x7c34671c,
-0x02717ef6, 0x4feb5536, 0xa2d02fff, 0xd2bf60c4, 0xd43f03c0,
-0x50b4ef6d, 0x07478cd1, 0x006e1888, 0xa2e53f55, 0xb9e6d4bc,
-0xa2048016, 0x97573833, 0xd7207d67, 0xde0f8f3d, 0x72f87b33,
-0xabcc4f33, 0x7688c55d, 0x7b00a6b0, 0x947b0001, 0x570075d2,
-0xf9bb88f8, 0x8942019e, 0x4264a5ff, 0x856302e0, 0x72dbd92b,
-0xee971b69, 0x6ea22fde, 0x5f08ae2b, 0xaf7a616d, 0xe5c98767,
-0xcf1febd2, 0x61efc8c2, 0xf1ac2571, 0xcc8239c2, 0x67214cb8,
-0xb1e583d1, 0xb7dc3e62, 0x7f10bdce, 0xf90a5c38, 0x0ff0443d,
-0x606e6dc6, 0x60543a49, 0x5727c148, 0x2be98a1d, 0x8ab41738,
-0x20e1be24, 0xaf96da0f, 0x68458425, 0x99833be5, 0x600d457d,
-0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31,
-0x9c305a00, 0x52bce688, 0x1b03588a, 0xf7baefd5, 0x4142ed9c,
-0xa4315c11, 0x83323ec5, 0xdfef4636, 0xa133c501, 0xe9d3531c,
-0xee353783 };
-
-static const uint32 S4[256] = {
-0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb,
-0x64ad8c57, 0x85510443, 0xfa020ed1, 0x7e287aff, 0xe60fb663,
-0x095f35a1, 0x79ebf120, 0xfd059d43, 0x6497b7b1, 0xf3641f63,
-0x241e4adf, 0x28147f5f, 0x4fa2b8cd, 0xc9430040, 0x0cc32220,
-0xfdd30b30, 0xc0a5374f, 0x1d2d00d9, 0x24147b15, 0xee4d111a,
-0x0fca5167, 0x71ff904c, 0x2d195ffe, 0x1a05645f, 0x0c13fefe,
-0x081b08ca, 0x05170121, 0x80530100, 0xe83e5efe, 0xac9af4f8,
-0x7fe72701, 0xd2b8ee5f, 0x06df4261, 0xbb9e9b8a, 0x7293ea25,
-0xce84ffdf, 0xf5718801, 0x3dd64b04, 0xa26f263b, 0x7ed48400,
-0x547eebe6, 0x446d4ca0, 0x6cf3d6f5, 0x2649abdf, 0xaea0c7f5,
-0x36338cc1, 0x503f7e93, 0xd3772061, 0x11b638e1, 0x72500e03,
-0xf80eb2bb, 0xabe0502e, 0xec8d77de, 0x57971e81, 0xe14f6746,
-0xc9335400, 0x6920318f, 0x081dbb99, 0xffc304a5, 0x4d351805,
-0x7f3d5ce3, 0xa6c866c6, 0x5d5bcca9, 0xdaec6fea, 0x9f926f91,
-0x9f46222f, 0x3991467d, 0xa5bf6d8e, 0x1143c44f, 0x43958302,
-0xd0214eeb, 0x022083b8, 0x3fb6180c, 0x18f8931e, 0x281658e6,
-0x26486e3e, 0x8bd78a70, 0x7477e4c1, 0xb506e07c, 0xf32d0a25,
-0x79098b02, 0xe4eabb81, 0x28123b23, 0x69dead38, 0x1574ca16,
-0xdf871b62, 0x211c40b7, 0xa51a9ef9, 0x0014377b, 0x041e8ac8,
-0x09114003, 0xbd59e4d2, 0xe3d156d5, 0x4fe876d5, 0x2f91a340,
-0x557be8de, 0x00eae4a7, 0x0ce5c2ec, 0x4db4bba6, 0xe756bdff,
-0xdd3369ac, 0xec17b035, 0x06572327, 0x99afc8b0, 0x56c8c391,
-0x6b65811c, 0x5e146119, 0x6e85cb75, 0xbe07c002, 0xc2325577,
-0x893ff4ec, 0x5bbfc92d, 0xd0ec3b25, 0xb7801ab7, 0x8d6d3b24,
-0x20c763ef, 0xc366a5fc, 0x9c382880, 0x0ace3205, 0xaac9548a,
-0xeca1d7c7, 0x041afa32, 0x1d16625a, 0x6701902c, 0x9b757a54,
-0x31d477f7, 0x9126b031, 0x36cc6fdb, 0xc70b8b46, 0xd9e66a48,
-0x56e55a79, 0x026a4ceb, 0x52437eff, 0x2f8f76b4, 0x0df980a5,
-0x8674cde3, 0xedda04eb, 0x17a9be04, 0x2c18f4df, 0xb7747f9d,
-0xab2af7b4, 0xefc34d20, 0x2e096b7c, 0x1741a254, 0xe5b6a035,
-0x213d42f6, 0x2c1c7c26, 0x61c2f50f, 0x6552daf9, 0xd2c231f8,
-0x25130f69, 0xd8167fa2, 0x0418f2c8, 0x001a96a6, 0x0d1526ab,
-0x63315c21, 0x5e0a72ec, 0x49bafefd, 0x187908d9, 0x8d0dbd86,
-0x311170a7, 0x3e9b640c, 0xcc3e10d7, 0xd5cad3b6, 0x0caec388,
-0xf73001e1, 0x6c728aff, 0x71eae2a1, 0x1f9af36e, 0xcfcbd12f,
-0xc1de8417, 0xac07be6b, 0xcb44a1d8, 0x8b9b0f56, 0x013988c3,
-0xb1c52fca, 0xb4be31cd, 0xd8782806, 0x12a3a4e2, 0x6f7de532,
-0x58fd7eb6, 0xd01ee900, 0x24adffc2, 0xf4990fc5, 0x9711aac5,
-0x001d7b95, 0x82e5e7d2, 0x109873f6, 0x00613096, 0xc32d9521,
-0xada121ff, 0x29908415, 0x7fbb977f, 0xaf9eb3db, 0x29c9ed2a,
-0x5ce2a465, 0xa730f32c, 0xd0aa3fe8, 0x8a5cc091, 0xd49e2ce7,
-0x0ce454a9, 0xd60acd86, 0x015f1919, 0x77079103, 0xdea03af6,
-0x78a8565e, 0xdee356df, 0x21f05cbe, 0x8b75e387, 0xb3c50651,
-0xb8a5c3ef, 0xd8eeb6d2, 0xe523be77, 0xc2154529, 0x2f69efdf,
-0xafe67afb, 0xf470c4b2, 0xf3e0eb5b, 0xd6cc9876, 0x39e4460c,
-0x1fda8538, 0x1987832f, 0xca007367, 0xa99144f8, 0x296b299e,
-0x492fc295, 0x9266beab, 0xb5676e69, 0x9bd3ddda, 0xdf7e052f,
-0xdb25701c, 0x1b5e51ee, 0xf65324e6, 0x6afce36c, 0x0316cc04,
-0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979,
-0x932bcdf6, 0xb657c34d, 0x4edfd282, 0x7ae5290c, 0x3cb9536b,
-0x851e20fe, 0x9833557e, 0x13ecf0b0, 0xd3ffb372, 0x3f85c5c1,
-0x0aef7ed2 };
-
-static const uint32 S5[256] = {
-0x7ec90c04, 0x2c6e74b9, 0x9b0e66df, 0xa6337911, 0xb86a7fff,
-0x1dd358f5, 0x44dd9d44, 0x1731167f, 0x08fbf1fa, 0xe7f511cc,
-0xd2051b00, 0x735aba00, 0x2ab722d8, 0x386381cb, 0xacf6243a,
-0x69befd7a, 0xe6a2e77f, 0xf0c720cd, 0xc4494816, 0xccf5c180,
-0x38851640, 0x15b0a848, 0xe68b18cb, 0x4caadeff, 0x5f480a01,
-0x0412b2aa, 0x259814fc, 0x41d0efe2, 0x4e40b48d, 0x248eb6fb,
-0x8dba1cfe, 0x41a99b02, 0x1a550a04, 0xba8f65cb, 0x7251f4e7,
-0x95a51725, 0xc106ecd7, 0x97a5980a, 0xc539b9aa, 0x4d79fe6a,
-0xf2f3f763, 0x68af8040, 0xed0c9e56, 0x11b4958b, 0xe1eb5a88,
-0x8709e6b0, 0xd7e07156, 0x4e29fea7, 0x6366e52d, 0x02d1c000,
-0xc4ac8e05, 0x9377f571, 0x0c05372a, 0x578535f2, 0x2261be02,
-0xd642a0c9, 0xdf13a280, 0x74b55bd2, 0x682199c0, 0xd421e5ec,
-0x53fb3ce8, 0xc8adedb3, 0x28a87fc9, 0x3d959981, 0x5c1ff900,
-0xfe38d399, 0x0c4eff0b, 0x062407ea, 0xaa2f4fb1, 0x4fb96976,
-0x90c79505, 0xb0a8a774, 0xef55a1ff, 0xe59ca2c2, 0xa6b62d27,
-0xe66a4263, 0xdf65001f, 0x0ec50966, 0xdfdd55bc, 0x29de0655,
-0x911e739a, 0x17af8975, 0x32c7911c, 0x89f89468, 0x0d01e980,
-0x524755f4, 0x03b63cc9, 0x0cc844b2, 0xbcf3f0aa, 0x87ac36e9,
-0xe53a7426, 0x01b3d82b, 0x1a9e7449, 0x64ee2d7e, 0xcddbb1da,
-0x01c94910, 0xb868bf80, 0x0d26f3fd, 0x9342ede7, 0x04a5c284,
-0x636737b6, 0x50f5b616, 0xf24766e3, 0x8eca36c1, 0x136e05db,
-0xfef18391, 0xfb887a37, 0xd6e7f7d4, 0xc7fb7dc9, 0x3063fcdf,
-0xb6f589de, 0xec2941da, 0x26e46695, 0xb7566419, 0xf654efc5,
-0xd08d58b7, 0x48925401, 0xc1bacb7f, 0xe5ff550f, 0xb6083049,
-0x5bb5d0e8, 0x87d72e5a, 0xab6a6ee1, 0x223a66ce, 0xc62bf3cd,
-0x9e0885f9, 0x68cb3e47, 0x086c010f, 0xa21de820, 0xd18b69de,
-0xf3f65777, 0xfa02c3f6, 0x407edac3, 0xcbb3d550, 0x1793084d,
-0xb0d70eba, 0x0ab378d5, 0xd951fb0c, 0xded7da56, 0x4124bbe4,
-0x94ca0b56, 0x0f5755d1, 0xe0e1e56e, 0x6184b5be, 0x580a249f,
-0x94f74bc0, 0xe327888e, 0x9f7b5561, 0xc3dc0280, 0x05687715,
-0x646c6bd7, 0x44904db3, 0x66b4f0a3, 0xc0f1648a, 0x697ed5af,
-0x49e92ff6, 0x309e374f, 0x2cb6356a, 0x85808573, 0x4991f840,
-0x76f0ae02, 0x083be84d, 0x28421c9a, 0x44489406, 0x736e4cb8,
-0xc1092910, 0x8bc95fc6, 0x7d869cf4, 0x134f616f, 0x2e77118d,
-0xb31b2be1, 0xaa90b472, 0x3ca5d717, 0x7d161bba, 0x9cad9010,
-0xaf462ba2, 0x9fe459d2, 0x45d34559, 0xd9f2da13, 0xdbc65487,
-0xf3e4f94e, 0x176d486f, 0x097c13ea, 0x631da5c7, 0x445f7382,
-0x175683f4, 0xcdc66a97, 0x70be0288, 0xb3cdcf72, 0x6e5dd2f3,
-0x20936079, 0x459b80a5, 0xbe60e2db, 0xa9c23101, 0xeba5315c,
-0x224e42f2, 0x1c5c1572, 0xf6721b2c, 0x1ad2fff3, 0x8c25404e,
-0x324ed72f, 0x4067b7fd, 0x0523138e, 0x5ca3bc78, 0xdc0fd66e,
-0x75922283, 0x784d6b17, 0x58ebb16e, 0x44094f85, 0x3f481d87,
-0xfcfeae7b, 0x77b5ff76, 0x8c2302bf, 0xaaf47556, 0x5f46b02a,
-0x2b092801, 0x3d38f5f7, 0x0ca81f36, 0x52af4a8a, 0x66d5e7c0,
-0xdf3b0874, 0x95055110, 0x1b5ad7a8, 0xf61ed5ad, 0x6cf6e479,
-0x20758184, 0xd0cefa65, 0x88f7be58, 0x4a046826, 0x0ff6f8f3,
-0xa09c7f70, 0x5346aba0, 0x5ce96c28, 0xe176eda3, 0x6bac307f,
-0x376829d2, 0x85360fa9, 0x17e3fe2a, 0x24b79767, 0xf5a96b20,
-0xd6cd2595, 0x68ff1ebf, 0x7555442c, 0xf19f06be, 0xf9e0659a,
-0xeeb9491d, 0x34010718, 0xbb30cab8, 0xe822fe15, 0x88570983,
-0x750e6249, 0xda627e55, 0x5e76ffa8, 0xb1534546, 0x6d47de08,
-0xefe9e7d4 };
-
-static const uint32 S6[256] = {
-0xf6fa8f9d, 0x2cac6ce1, 0x4ca34867, 0xe2337f7c, 0x95db08e7,
-0x016843b4, 0xeced5cbc, 0x325553ac, 0xbf9f0960, 0xdfa1e2ed,
-0x83f0579d, 0x63ed86b9, 0x1ab6a6b8, 0xde5ebe39, 0xf38ff732,
-0x8989b138, 0x33f14961, 0xc01937bd, 0xf506c6da, 0xe4625e7e,
-0xa308ea99, 0x4e23e33c, 0x79cbd7cc, 0x48a14367, 0xa3149619,
-0xfec94bd5, 0xa114174a, 0xeaa01866, 0xa084db2d, 0x09a8486f,
-0xa888614a, 0x2900af98, 0x01665991, 0xe1992863, 0xc8f30c60,
-0x2e78ef3c, 0xd0d51932, 0xcf0fec14, 0xf7ca07d2, 0xd0a82072,
-0xfd41197e, 0x9305a6b0, 0xe86be3da, 0x74bed3cd, 0x372da53c,
-0x4c7f4448, 0xdab5d440, 0x6dba0ec3, 0x083919a7, 0x9fbaeed9,
-0x49dbcfb0, 0x4e670c53, 0x5c3d9c01, 0x64bdb941, 0x2c0e636a,
-0xba7dd9cd, 0xea6f7388, 0xe70bc762, 0x35f29adb, 0x5c4cdd8d,
-0xf0d48d8c, 0xb88153e2, 0x08a19866, 0x1ae2eac8, 0x284caf89,
-0xaa928223, 0x9334be53, 0x3b3a21bf, 0x16434be3, 0x9aea3906,
-0xefe8c36e, 0xf890cdd9, 0x80226dae, 0xc340a4a3, 0xdf7e9c09,
-0xa694a807, 0x5b7c5ecc, 0x221db3a6, 0x9a69a02f, 0x68818a54,
-0xceb2296f, 0x53c0843a, 0xfe893655, 0x25bfe68a, 0xb4628abc,
-0xcf222ebf, 0x25ac6f48, 0xa9a99387, 0x53bddb65, 0xe76ffbe7,
-0xe967fd78, 0x0ba93563, 0x8e342bc1, 0xe8a11be9, 0x4980740d,
-0xc8087dfc, 0x8de4bf99, 0xa11101a0, 0x7fd37975, 0xda5a26c0,
-0xe81f994f, 0x9528cd89, 0xfd339fed, 0xb87834bf, 0x5f04456d,
-0x22258698, 0xc9c4c83b, 0x2dc156be, 0x4f628daa, 0x57f55ec5,
-0xe2220abe, 0xd2916ebf, 0x4ec75b95, 0x24f2c3c0, 0x42d15d99,
-0xcd0d7fa0, 0x7b6e27ff, 0xa8dc8af0, 0x7345c106, 0xf41e232f,
-0x35162386, 0xe6ea8926, 0x3333b094, 0x157ec6f2, 0x372b74af,
-0x692573e4, 0xe9a9d848, 0xf3160289, 0x3a62ef1d, 0xa787e238,
-0xf3a5f676, 0x74364853, 0x20951063, 0x4576698d, 0xb6fad407,
-0x592af950, 0x36f73523, 0x4cfb6e87, 0x7da4cec0, 0x6c152daa,
-0xcb0396a8, 0xc50dfe5d, 0xfcd707ab, 0x0921c42f, 0x89dff0bb,
-0x5fe2be78, 0x448f4f33, 0x754613c9, 0x2b05d08d, 0x48b9d585,
-0xdc049441, 0xc8098f9b, 0x7dede786, 0xc39a3373, 0x42410005,
-0x6a091751, 0x0ef3c8a6, 0x890072d6, 0x28207682, 0xa9a9f7be,
-0xbf32679d, 0xd45b5b75, 0xb353fd00, 0xcbb0e358, 0x830f220a,
-0x1f8fb214, 0xd372cf08, 0xcc3c4a13, 0x8cf63166, 0x061c87be,
-0x88c98f88, 0x6062e397, 0x47cf8e7a, 0xb6c85283, 0x3cc2acfb,
-0x3fc06976, 0x4e8f0252, 0x64d8314d, 0xda3870e3, 0x1e665459,
-0xc10908f0, 0x513021a5, 0x6c5b68b7, 0x822f8aa0, 0x3007cd3e,
-0x74719eef, 0xdc872681, 0x073340d4, 0x7e432fd9, 0x0c5ec241,
-0x8809286c, 0xf592d891, 0x08a930f6, 0x957ef305, 0xb7fbffbd,
-0xc266e96f, 0x6fe4ac98, 0xb173ecc0, 0xbc60b42a, 0x953498da,
-0xfba1ae12, 0x2d4bd736, 0x0f25faab, 0xa4f3fceb, 0xe2969123,
-0x257f0c3d, 0x9348af49, 0x361400bc, 0xe8816f4a, 0x3814f200,
-0xa3f94043, 0x9c7a54c2, 0xbc704f57, 0xda41e7f9, 0xc25ad33a,
-0x54f4a084, 0xb17f5505, 0x59357cbe, 0xedbd15c8, 0x7f97c5ab,
-0xba5ac7b5, 0xb6f6deaf, 0x3a479c3a, 0x5302da25, 0x653d7e6a,
-0x54268d49, 0x51a477ea, 0x5017d55b, 0xd7d25d88, 0x44136c76,
-0x0404a8c8, 0xb8e5a121, 0xb81a928a, 0x60ed5869, 0x97c55b96,
-0xeaec991b, 0x29935913, 0x01fdb7f1, 0x088e8dfa, 0x9ab6f6f5,
-0x3b4cbf9f, 0x4a5de3ab, 0xe6051d35, 0xa0e1d855, 0xd36b4cf1,
-0xf544edeb, 0xb0e93524, 0xbebb8fbd, 0xa2d762cf, 0x49c92f54,
-0x38b5f331, 0x7128a454, 0x48392905, 0xa65b1db8, 0x851c97bd,
-0xd675cf2f };
-
-static const uint32 S7[256] = {
-0x85e04019, 0x332bf567, 0x662dbfff, 0xcfc65693, 0x2a8d7f6f,
-0xab9bc912, 0xde6008a1, 0x2028da1f, 0x0227bce7, 0x4d642916,
-0x18fac300, 0x50f18b82, 0x2cb2cb11, 0xb232e75c, 0x4b3695f2,
-0xb28707de, 0xa05fbcf6, 0xcd4181e9, 0xe150210c, 0xe24ef1bd,
-0xb168c381, 0xfde4e789, 0x5c79b0d8, 0x1e8bfd43, 0x4d495001,
-0x38be4341, 0x913cee1d, 0x92a79c3f, 0x089766be, 0xbaeeadf4,
-0x1286becf, 0xb6eacb19, 0x2660c200, 0x7565bde4, 0x64241f7a,
-0x8248dca9, 0xc3b3ad66, 0x28136086, 0x0bd8dfa8, 0x356d1cf2,
-0x107789be, 0xb3b2e9ce, 0x0502aa8f, 0x0bc0351e, 0x166bf52a,
-0xeb12ff82, 0xe3486911, 0xd34d7516, 0x4e7b3aff, 0x5f43671b,
-0x9cf6e037, 0x4981ac83, 0x334266ce, 0x8c9341b7, 0xd0d854c0,
-0xcb3a6c88, 0x47bc2829, 0x4725ba37, 0xa66ad22b, 0x7ad61f1e,
-0x0c5cbafa, 0x4437f107, 0xb6e79962, 0x42d2d816, 0x0a961288,
-0xe1a5c06e, 0x13749e67, 0x72fc081a, 0xb1d139f7, 0xf9583745,
-0xcf19df58, 0xbec3f756, 0xc06eba30, 0x07211b24, 0x45c28829,
-0xc95e317f, 0xbc8ec511, 0x38bc46e9, 0xc6e6fa14, 0xbae8584a,
-0xad4ebc46, 0x468f508b, 0x7829435f, 0xf124183b, 0x821dba9f,
-0xaff60ff4, 0xea2c4e6d, 0x16e39264, 0x92544a8b, 0x009b4fc3,
-0xaba68ced, 0x9ac96f78, 0x06a5b79a, 0xb2856e6e, 0x1aec3ca9,
-0xbe838688, 0x0e0804e9, 0x55f1be56, 0xe7e5363b, 0xb3a1f25d,
-0xf7debb85, 0x61fe033c, 0x16746233, 0x3c034c28, 0xda6d0c74,
-0x79aac56c, 0x3ce4e1ad, 0x51f0c802, 0x98f8f35a, 0x1626a49f,
-0xeed82b29, 0x1d382fe3, 0x0c4fb99a, 0xbb325778, 0x3ec6d97b,
-0x6e77a6a9, 0xcb658b5c, 0xd45230c7, 0x2bd1408b, 0x60c03eb7,
-0xb9068d78, 0xa33754f4, 0xf430c87d, 0xc8a71302, 0xb96d8c32,
-0xebd4e7be, 0xbe8b9d2d, 0x7979fb06, 0xe7225308, 0x8b75cf77,
-0x11ef8da4, 0xe083c858, 0x8d6b786f, 0x5a6317a6, 0xfa5cf7a0,
-0x5dda0033, 0xf28ebfb0, 0xf5b9c310, 0xa0eac280, 0x08b9767a,
-0xa3d9d2b0, 0x79d34217, 0x021a718d, 0x9ac6336a, 0x2711fd60,
-0x438050e3, 0x069908a8, 0x3d7fedc4, 0x826d2bef, 0x4eeb8476,
-0x488dcf25, 0x36c9d566, 0x28e74e41, 0xc2610aca, 0x3d49a9cf,
-0xbae3b9df, 0xb65f8de6, 0x92aeaf64, 0x3ac7d5e6, 0x9ea80509,
-0xf22b017d, 0xa4173f70, 0xdd1e16c3, 0x15e0d7f9, 0x50b1b887,
-0x2b9f4fd5, 0x625aba82, 0x6a017962, 0x2ec01b9c, 0x15488aa9,
-0xd716e740, 0x40055a2c, 0x93d29a22, 0xe32dbf9a, 0x058745b9,
-0x3453dc1e, 0xd699296e, 0x496cff6f, 0x1c9f4986, 0xdfe2ed07,
-0xb87242d1, 0x19de7eae, 0x053e561a, 0x15ad6f8c, 0x66626c1c,
-0x7154c24c, 0xea082b2a, 0x93eb2939, 0x17dcb0f0, 0x58d4f2ae,
-0x9ea294fb, 0x52cf564c, 0x9883fe66, 0x2ec40581, 0x763953c3,
-0x01d6692e, 0xd3a0c108, 0xa1e7160e, 0xe4f2dfa6, 0x693ed285,
-0x74904698, 0x4c2b0edd, 0x4f757656, 0x5d393378, 0xa132234f,
-0x3d321c5d, 0xc3f5e194, 0x4b269301, 0xc79f022f, 0x3c997e7e,
-0x5e4f9504, 0x3ffafbbd, 0x76f7ad0e, 0x296693f4, 0x3d1fce6f,
-0xc61e45be, 0xd3b5ab34, 0xf72bf9b7, 0x1b0434c0, 0x4e72b567,
-0x5592a33d, 0xb5229301, 0xcfd2a87f, 0x60aeb767, 0x1814386b,
-0x30bcc33d, 0x38a0c07d, 0xfd1606f2, 0xc363519b, 0x589dd390,
-0x5479f8e6, 0x1cb8d647, 0x97fd61a9, 0xea7759f4, 0x2d57539d,
-0x569a58cf, 0xe84e63ad, 0x462e1b78, 0x6580f87e, 0xf3817914,
-0x91da55f4, 0x40a230f3, 0xd1988f35, 0xb6e318d2, 0x3ffa50bc,
-0x3d40f021, 0xc3c0bdae, 0x4958c24c, 0x518f36b2, 0x84b1d370,
-0x0fedce83, 0x878ddada, 0xf2a279c7, 0x94e01be8, 0x90716f4b,
-0x954b8aa3 };
-
-static const uint32 S8[256] = {
-0xe216300d, 0xbbddfffc, 0xa7ebdabd, 0x35648095, 0x7789f8b7,
-0xe6c1121b, 0x0e241600, 0x052ce8b5, 0x11a9cfb0, 0xe5952f11,
-0xece7990a, 0x9386d174, 0x2a42931c, 0x76e38111, 0xb12def3a,
-0x37ddddfc, 0xde9adeb1, 0x0a0cc32c, 0xbe197029, 0x84a00940,
-0xbb243a0f, 0xb4d137cf, 0xb44e79f0, 0x049eedfd, 0x0b15a15d,
-0x480d3168, 0x8bbbde5a, 0x669ded42, 0xc7ece831, 0x3f8f95e7,
-0x72df191b, 0x7580330d, 0x94074251, 0x5c7dcdfa, 0xabbe6d63,
-0xaa402164, 0xb301d40a, 0x02e7d1ca, 0x53571dae, 0x7a3182a2,
-0x12a8ddec, 0xfdaa335d, 0x176f43e8, 0x71fb46d4, 0x38129022,
-0xce949ad4, 0xb84769ad, 0x965bd862, 0x82f3d055, 0x66fb9767,
-0x15b80b4e, 0x1d5b47a0, 0x4cfde06f, 0xc28ec4b8, 0x57e8726e,
-0x647a78fc, 0x99865d44, 0x608bd593, 0x6c200e03, 0x39dc5ff6,
-0x5d0b00a3, 0xae63aff2, 0x7e8bd632, 0x70108c0c, 0xbbd35049,
-0x2998df04, 0x980cf42a, 0x9b6df491, 0x9e7edd53, 0x06918548,
-0x58cb7e07, 0x3b74ef2e, 0x522fffb1, 0xd24708cc, 0x1c7e27cd,
-0xa4eb215b, 0x3cf1d2e2, 0x19b47a38, 0x424f7618, 0x35856039,
-0x9d17dee7, 0x27eb35e6, 0xc9aff67b, 0x36baf5b8, 0x09c467cd,
-0xc18910b1, 0xe11dbf7b, 0x06cd1af8, 0x7170c608, 0x2d5e3354,
-0xd4de495a, 0x64c6d006, 0xbcc0c62c, 0x3dd00db3, 0x708f8f34,
-0x77d51b42, 0x264f620f, 0x24b8d2bf, 0x15c1b79e, 0x46a52564,
-0xf8d7e54e, 0x3e378160, 0x7895cda5, 0x859c15a5, 0xe6459788,
-0xc37bc75f, 0xdb07ba0c, 0x0676a3ab, 0x7f229b1e, 0x31842e7b,
-0x24259fd7, 0xf8bef472, 0x835ffcb8, 0x6df4c1f2, 0x96f5b195,
-0xfd0af0fc, 0xb0fe134c, 0xe2506d3d, 0x4f9b12ea, 0xf215f225,
-0xa223736f, 0x9fb4c428, 0x25d04979, 0x34c713f8, 0xc4618187,
-0xea7a6e98, 0x7cd16efc, 0x1436876c, 0xf1544107, 0xbedeee14,
-0x56e9af27, 0xa04aa441, 0x3cf7c899, 0x92ecbae6, 0xdd67016d,
-0x151682eb, 0xa842eedf, 0xfdba60b4, 0xf1907b75, 0x20e3030f,
-0x24d8c29e, 0xe139673b, 0xefa63fb8, 0x71873054, 0xb6f2cf3b,
-0x9f326442, 0xcb15a4cc, 0xb01a4504, 0xf1e47d8d, 0x844a1be5,
-0xbae7dfdc, 0x42cbda70, 0xcd7dae0a, 0x57e85b7a, 0xd53f5af6,
-0x20cf4d8c, 0xcea4d428, 0x79d130a4, 0x3486ebfb, 0x33d3cddc,
-0x77853b53, 0x37effcb5, 0xc5068778, 0xe580b3e6, 0x4e68b8f4,
-0xc5c8b37e, 0x0d809ea2, 0x398feb7c, 0x132a4f94, 0x43b7950e,
-0x2fee7d1c, 0x223613bd, 0xdd06caa2, 0x37df932b, 0xc4248289,
-0xacf3ebc3, 0x5715f6b7, 0xef3478dd, 0xf267616f, 0xc148cbe4,
-0x9052815e, 0x5e410fab, 0xb48a2465, 0x2eda7fa4, 0xe87b40e4,
-0xe98ea084, 0x5889e9e1, 0xefd390fc, 0xdd07d35b, 0xdb485694,
-0x38d7e5b2, 0x57720101, 0x730edebc, 0x5b643113, 0x94917e4f,
-0x503c2fba, 0x646f1282, 0x7523d24a, 0xe0779695, 0xf9c17a8f,
-0x7a5b2121, 0xd187b896, 0x29263a4d, 0xba510cdf, 0x81f47c9f,
-0xad1163ed, 0xea7b5965, 0x1a00726e, 0x11403092, 0x00da6d77,
-0x4a0cdd61, 0xad1f4603, 0x605bdfb0, 0x9eedc364, 0x22ebe6a8,
-0xcee7d28a, 0xa0e736a0, 0x5564a6b9, 0x10853209, 0xc7eb8f37,
-0x2de705ca, 0x8951570f, 0xdf09822b, 0xbd691a6c, 0xaa12e4f2,
-0x87451c0f, 0xe0f6a27a, 0x3ada4819, 0x4cf1764f, 0x0d771c2b,
-0x67cdb156, 0x350d8384, 0x5938fa0f, 0x42399ef3, 0x36997b07,
-0x0e84093d, 0x4aa93e61, 0x8360d87b, 0x1fa98b0c, 0x1149382c,
-0xe97625a5, 0x0614d1b7, 0x0e25244b, 0x0c768347, 0x589e8d82,
-0x0d2059d1, 0xa466bb1e, 0xf8da0a82, 0x04f19130, 0xba6e4ec0,
-0x99265164, 0x1ee7230d, 0x50b2ad80, 0xeaee6801, 0x8db2a283,
-0xea8bf59e };
-

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/src/hash_template.c
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/src/hash_template.c b/tools/bin/pythonSrc/pycrypto-2.0.1/src/hash_template.c
deleted file mode 100644
index 6662dd5..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/src/hash_template.c
+++ /dev/null
@@ -1,248 +0,0 @@
-/*
- *  hash_template.c : Generic framework for hash function extension modules
- *
- * 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. 
- *
- */
-  
-/* Basic object type */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#ifdef _HAVE_STDC_HEADERS
-#include <string.h>
-#endif
-
-#define _STR(x) #x
-#define _XSTR(x) _STR(x)
-#define _PASTE(x,y) x##y
-#define _PASTE2(x,y) _PASTE(x,y)
-#define _MODULE_NAME _PASTE2(init,MODULE_NAME)
-#define _MODULE_STRING _XSTR(MODULE_NAME)
-
-typedef struct {
-	PyObject_HEAD
-	hash_state st;
-} ALGobject;
-
-staticforward PyTypeObject ALGtype;
-
-#define is_ALGobject(v) ((v)->ob_type == &ALGtype)
-
-static ALGobject *
-newALGobject(void)
-{
-	ALGobject *new;
-
-	new = PyObject_New(ALGobject, &ALGtype);
-	return new;
-}
-
-/* Internal methods for a hashing object */
-
-static void
-ALG_dealloc(PyObject *ptr)
-{
-	ALGobject *self = (ALGobject *)ptr;
-
-	/* Overwrite the contents of the object */
-	memset((char*)&(self->st), 0, sizeof(hash_state));
-	PyObject_Del(ptr);
-}
-
-
-/* External methods for a hashing object */
-
-static char ALG_copy__doc__[] = 
-"copy(): Return a copy of the hashing object.";
-
-static PyObject *
-ALG_copy(ALGobject *self, PyObject *args)
-{
-	ALGobject *newobj;
-
-	if (!PyArg_ParseTuple(args, "")) {
-		return NULL;
-	}
-	
-	if ( (newobj = newALGobject())==NULL)
-		return NULL;
-
-	hash_copy(&(self->st), &(newobj->st));
-	return((PyObject *)newobj); 
-}
-
-static char ALG_digest__doc__[] = 
-"digest(): Return the digest value as a string of binary data.";
-
-static PyObject *
-ALG_digest(ALGobject *self, PyObject *args)
-{
-	if (!PyArg_ParseTuple(args, ""))
-		return NULL;
-
-	return (PyObject *)hash_digest(&(self->st));
-}
-
-static char ALG_hexdigest__doc__[] = 
-"hexdigest(): Return the digest value as a string of hexadecimal digits.";
-
-static PyObject *
-ALG_hexdigest(ALGobject *self, PyObject *args)
-{
-	PyObject *value, *retval;
-	unsigned char *raw_digest, *hex_digest;
-	int i, j, size;
-
-	if (!PyArg_ParseTuple(args, ""))
-		return NULL;
-
-	/* Get the raw (binary) digest value */
-	value = (PyObject *)hash_digest(&(self->st));
-	size = PyString_Size(value);
-	raw_digest = PyString_AsString(value);
-
-	/* Create a new string */
-	retval = PyString_FromStringAndSize(NULL, size * 2 );
-	hex_digest = PyString_AsString(retval);
-
-	/* Make hex version of the digest */
-	for(i=j=0; i<size; i++)	
-	{
-		char c;
-		c = raw_digest[i] / 16; c = (c>9) ? c+'a'-10 : c + '0';
-		hex_digest[j++] = c;
-		c = raw_digest[i] % 16; c = (c>9) ? c+'a'-10 : c + '0';
-		hex_digest[j++] = c;
-	}	
-	Py_DECREF(value);
-	return retval;
-}
-
-static char ALG_update__doc__[] = 
-"update(string): Update this hashing object's state with the provided string.";
-
-static PyObject *
-ALG_update(ALGobject *self, PyObject *args)
-{
-	unsigned char *cp;
-	int len;
-
-	if (!PyArg_ParseTuple(args, "s#", &cp, &len))
-		return NULL;
-
-	hash_update(&(self->st), cp, len);
-
-	Py_INCREF(Py_None);
-	return Py_None;
-}
-
-static PyMethodDef ALG_methods[] = {
-	{"copy", (PyCFunction)ALG_copy, METH_VARARGS, ALG_copy__doc__},
-	{"digest", (PyCFunction)ALG_digest, METH_VARARGS, ALG_digest__doc__},
-	{"hexdigest", (PyCFunction)ALG_hexdigest, METH_VARARGS, 
-	 ALG_hexdigest__doc__},
-	{"update", (PyCFunction)ALG_update, METH_VARARGS, ALG_update__doc__},
-	{NULL,			NULL}		/* sentinel */
-};
-
-static PyObject *
-ALG_getattr(PyObject *self, char *name)
-{
-	if (strcmp(name, "digest_size")==0)
-		return PyInt_FromLong(DIGEST_SIZE);
-	
-	return Py_FindMethod(ALG_methods, self, name);
-}
-
-static PyTypeObject ALGtype = {
-	PyObject_HEAD_INIT(NULL)
-	0,			/*ob_size*/
-	_MODULE_STRING,			/*tp_name*/
-	sizeof(ALGobject),	/*tp_size*/
-	0,			/*tp_itemsize*/
-	/* methods */
-	ALG_dealloc, /*tp_dealloc*/
-	0,			/*tp_print*/
-	ALG_getattr, /*tp_getattr*/
-	0,			/*tp_setattr*/
-	0,			/*tp_compare*/
-	0,			/*tp_repr*/
-        0,			/*tp_as_number*/
-};
-
-
-/* The single module-level function: new() */
-
-static char ALG_new__doc__[] =
-"new([string]): Return a new " _MODULE_STRING 
-" hashing object.  An optional string "
-"argument may be provided; if present, this string will be "
-"automatically hashed into the initial state of the object."; 
-
-static PyObject *
-ALG_new(PyObject *self, PyObject *args)
-{
-        ALGobject *new;
-	unsigned char *cp = NULL;
-	int len;
-	
-	if ((new = newALGobject()) == NULL)
-		return NULL;
-
-	if (!PyArg_ParseTuple(args, "|s#",
-			      &cp, &len)) {
-	        Py_DECREF(new);
-		return NULL;
-	}
-
-        hash_init(&(new->st));
-
-	if (PyErr_Occurred()) {
-		Py_DECREF(new); 
-		return NULL;
-	}
-	if (cp)
-		hash_update(&(new->st), cp, len);
-
-	return (PyObject *)new;
-}
-
-
-/* List of functions exported by this module */
-
-static struct PyMethodDef ALG_functions[] = {
-	{"new", (PyCFunction)ALG_new, METH_VARARGS, ALG_new__doc__},
-	{NULL,			NULL}		 /* Sentinel */
-};
-
-
-/* Initialize this module. */
-
-#if PYTHON_API_VERSION < 1011
-#define PyModule_AddIntConstant(m,n,v) {PyObject *o=PyInt_FromLong(v); \
-           if (o!=NULL) \
-             {PyDict_SetItemString(PyModule_GetDict(m),n,o); Py_DECREF(o);}}
-#endif
-
-void
-_MODULE_NAME (void)
-{
-	PyObject *m;
-
-	ALGtype.ob_type = &PyType_Type;
-	m = Py_InitModule("Crypto.Hash." _MODULE_STRING, ALG_functions);
-
-	/* Add some symbolic constants to the module */
-	PyModule_AddIntConstant(m, "digest_size", DIGEST_SIZE);
-
-	/* Check for errors */
-	if (PyErr_Occurred())
-		Py_FatalError("can't initialize module " 
-                              _MODULE_STRING);
-}

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/src/stream_template.c
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/src/stream_template.c b/tools/bin/pythonSrc/pycrypto-2.0.1/src/stream_template.c
deleted file mode 100644
index 71d125c..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/src/stream_template.c
+++ /dev/null
@@ -1,248 +0,0 @@
-/* -*- C -*- */
-
-/*
- *  stream_template.c : Generic framework for stream ciphers
- *
- * 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. 
- *
- */
-
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef _HAVE_STDC_HEADERS
-#include <string.h>
-#endif
-
-#include "Python.h"
-#include "modsupport.h"
-
-#define _STR(x) #x
-#define _XSTR(x) _STR(x)
-#define _PASTE(x,y) x##y
-#define _PASTE2(x,y) _PASTE(x,y)
-#define _MODULE_NAME _PASTE2(init,MODULE_NAME)
-#define _MODULE_STRING _XSTR(MODULE_NAME)
-
-        /*
-	 *
-	 * Python interface
-	 *
-	 */
-
-typedef struct 
-{
-	PyObject_HEAD 
-	stream_state st;
-} ALGobject;
-
-staticforward PyTypeObject ALGtype;
-
-#define is_ALGobject(v)		((v)->ob_type == &ALGtype)
-
-static ALGobject *
-newALGobject(void)
-{
-	ALGobject * new;
-	new = PyObject_New(ALGobject, &ALGtype);
-	return new;
-}
-
-static void
-ALGdealloc(PyObject *ptr)
-{
-	ALGobject *self = (ALGobject *)ptr;
-
-	/* Overwrite the contents of the object */
-	memset((char*)&(self->st), 0, sizeof(stream_state));
-	PyObject_Del(ptr);
-}
-
-static char ALGnew__doc__[] = 
-"Return a new " _MODULE_STRING " encryption object.";
-
-static char *kwlist[] = {"key", NULL};
-
-static ALGobject *
-ALGnew(PyObject *self, PyObject *args, PyObject *kwdict)
-{
-	unsigned char *key;
-	ALGobject * new;
-	int keylen;
-
-	new = newALGobject();
-	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "s#", kwlist, 
-					 &key, &keylen))
-	{
-		Py_DECREF(new);
-		return NULL;
-	}
-
-	if (KEY_SIZE!=0 && keylen != KEY_SIZE)
-	{
-		PyErr_SetString(PyExc_ValueError, 
-				_MODULE_STRING " key must be "
-				"KEY_SIZE bytes long");
-		return NULL;
-	}
-	if (KEY_SIZE== 0 && keylen == 0)
-	{
-		PyErr_SetString(PyExc_ValueError, 
-				_MODULE_STRING " key cannot be "
-				"the null string (0 bytes long)");
-		return NULL;
-	}
-	stream_init(&(new->st), key, keylen);
-	if (PyErr_Occurred())
-	{
-		Py_DECREF(new);
-		return NULL;
-	}
-	return new;
-}
-
-static char ALG_Encrypt__doc__[] =
-"Decrypt the provided string of binary data.";
-
-static PyObject *
-ALG_Encrypt(ALGobject *self, PyObject *args)
-{
-	unsigned char *buffer, *str;
-	int len;
-	PyObject *result;
-
-	if (!PyArg_Parse(args, "s#", &str, &len))
-		return NULL;
-	if (len == 0)			/* Handle empty string */
-	{
-		return PyString_FromStringAndSize(NULL, 0);
-	}
-	buffer = malloc(len);
-	if (buffer == NULL)
-	{
-		PyErr_SetString(PyExc_MemoryError, "No memory available in "
-				_MODULE_STRING " encrypt");
-		return NULL;
-	}
-	memcpy(buffer, str, len);
-	stream_encrypt(&(self->st), buffer, len);
-	result = PyString_FromStringAndSize(buffer, len);
-	free(buffer);
-	return (result);
-}
-
-static char ALG_Decrypt__doc__[] =
-"decrypt(string): Decrypt the provided string of binary data.";
-
-static PyObject *
-ALG_Decrypt(ALGobject *self, PyObject *args)
-{
-	char *buffer, *str;
-	int len;
-	PyObject *result;
-
-	if (!PyArg_Parse(args, "s#", &str, &len))
-		return NULL;
-	if (len == 0)			/* Handle empty string */
-	{
-		return PyString_FromStringAndSize(NULL, 0);
-	}
-	buffer = malloc(len);
-	if (buffer == NULL)
-	{
-		PyErr_SetString(PyExc_MemoryError, "No memory available in "
-				_MODULE_STRING " decrypt");
-		return NULL;
-	}
-	memcpy(buffer, str, len);
-	stream_decrypt(&(self->st), buffer, len);
-	result = PyString_FromStringAndSize(buffer, len);
-	free(buffer);
-	return (result);
-}
-
-/* ALGobject methods */
-
-static PyMethodDef ALGmethods[] =
-{
-	{"encrypt", (PyCFunction) ALG_Encrypt, 0, ALG_Encrypt__doc__},
-	{"decrypt", (PyCFunction) ALG_Decrypt, 0, ALG_Decrypt__doc__},
-	{NULL, NULL}			/* sentinel */
-};
-
-static PyObject *
-ALGgetattr(PyObject *self, char *name)
-{
-	if (strcmp(name, "block_size") == 0)
-	{
-		return PyInt_FromLong(BLOCK_SIZE);
-	}
-	if (strcmp(name, "key_size") == 0)
-	{
-		return PyInt_FromLong(KEY_SIZE);
-	}
-	return Py_FindMethod(ALGmethods, self, name);
-}
-
-
-/* List of functions defined in the module */
-
-static struct PyMethodDef modulemethods[] =
-{
-	{"new", (PyCFunction) ALGnew, 
-	 METH_VARARGS|METH_KEYWORDS, ALGnew__doc__},
-	{NULL, NULL}			/* sentinel */
-};
-
-static PyTypeObject ALGtype =
-{
-	PyObject_HEAD_INIT(NULL)
-	0,				/*ob_size*/
-	_MODULE_STRING,		/*tp_name*/
-	sizeof(ALGobject),	/*tp_size*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	ALGdealloc,	/*tp_dealloc*/
-	0,				/*tp_print*/
-	ALGgetattr,	/*tp_getattr*/
-	0,		/*tp_setattr*/
-	0,			/*tp_compare*/
-	0,			/*tp_repr*/
-	0,				/*tp_as_number*/
-};
-
-/* Initialization function for the module */
-
-#if PYTHON_API_VERSION < 1011
-#define PyModule_AddIntConstant(m,n,v) {PyObject *o=PyInt_FromLong(v); \
-           if (o!=NULL) \
-             {PyDict_SetItemString(PyModule_GetDict(m),n,o); Py_DECREF(o);}}
-#endif
-
-void
-_MODULE_NAME (void)
-{
-	PyObject *m, *d, *x;
-
-	ALGtype.ob_type = &PyType_Type;
-	/* Create the module and add the functions */
-	m = Py_InitModule("Crypto.Cipher." _MODULE_STRING, modulemethods);
-
-	/* Add some symbolic constants to the module */
-	d = PyModule_GetDict(m);
-	x = PyString_FromString(_MODULE_STRING ".error");
-	PyDict_SetItemString(d, "error", x);
-
-	PyModule_AddIntConstant(m, "block_size", BLOCK_SIZE);
-	PyModule_AddIntConstant(m, "key_size", KEY_SIZE);
-
-	/* Check for errors */
-	if (PyErr_Occurred())
-		Py_FatalError("can't initialize module " _MODULE_STRING);
-}

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/src/winrand.c
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/src/winrand.c b/tools/bin/pythonSrc/pycrypto-2.0.1/src/winrand.c
deleted file mode 100644
index 8c82bd4..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/src/winrand.c
+++ /dev/null
@@ -1,366 +0,0 @@
-/* -*- C -*- */
-/*
- * Uses Windows CryptoAPI CryptGenRandom to get random bytes.
- * The "new" method returns an object, whose "get_bytes" method
- * can be called repeatedly to get random bytes, seeded by the
- * OS.  See the description in the comment at the end.
- * 
- * If you have the Intel Security Driver header files (icsp4ms.h)
- * for their hardware random number generator in the 810 and 820 chipsets,
- * then define HAVE_INTEL_RNG.
- *
- * 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. 
- *
- */
-
-/* Author: Mark Moraes */
-
-#include "Python.h"
-
-#ifdef MS_WIN32
-
-#define _WIN32_WINNT 0x400
-#define WINSOCK
-
-#include <windows.h>
-#include <wincrypt.h>
-
-#ifdef HAVE_INTEL_RNG
-# include "icsp4ms.h"
-#else
-# define PROV_INTEL_SEC 22
-# define INTEL_DEF_PROV "Intel Hardware Cryptographic Service Provider"
-#endif
-
-/* To-Do: store provider name and type for print/repr? */
-typedef struct
-{
-    PyObject_HEAD
-    HCRYPTPROV hcp;
-} WRobject;
-
-staticforward PyTypeObject WRtype;
-
-#define is_WRobject(v) ((v)->ob_type == &WRtype)
-
-static void
-WRdealloc(PyObject *ptr)
-{		
-	WRobject *o = (WRobject *)ptr;
-
-	if (! is_WRobject(ptr)) {
-		PyErr_Format(PyExc_TypeError,
-		    "WinRandom trying to dealloc non-WinRandom object");
-		return;
-	}
-	if (! CryptReleaseContext(o->hcp, 0)) {
-		PyErr_Format(PyExc_SystemError,
-			     "CryptReleaseContext failed, error 0x%x",
-			     GetLastError());
-		return;
-	}
-	/* Overwrite the contents of the object */
-	o->hcp = 0;
-	PyObject_Del(ptr);
-}
-
-static char winrandom__doc__[] =
-"new([provider], [provtype]): Returns an object handle to Windows\n\
-CryptoAPI that can be used to access a cryptographically strong\n\
-pseudo-random generator that uses OS-gathered entropy.\n\
-Provider is a string that specifies the Cryptographic Service Provider\n\
-to use, default is the default OS CSP.\n\
-provtype is an integer specifying the provider type to use, default\n\
-is 1 (PROV_RSA_FULL)";
-
-static char WR_get_bytes__doc__[] =
-"get_bytes(nbytes, [userdata]]): Returns nbytes of random data\n\
-from Windows CryptGenRandom.\n\
-userdata is a string with any additional entropic data that the\n\
-user wishes to provide.";
-
-static WRobject *
-winrandom_new(PyObject *self, PyObject *args, PyObject *kwdict)
-{
-	HCRYPTPROV hcp = 0;
-	WRobject *res;
-	char *provname = NULL;
-	int provtype = PROV_RSA_FULL;
-	static char *kwlist[] = { "provider", "provtype", NULL};
-	
-	if (!PyArg_ParseTupleAndKeywords(args, kwdict, "|si", kwlist,
-					 &provname, &provtype)) {
-		return NULL;
-	}
-	if (! CryptAcquireContext(&hcp, NULL, (LPCTSTR) provname,
-				  (DWORD) provtype, 0)) {
-		PyErr_Format(PyExc_SystemError,
-			     "CryptAcquireContext for provider \"%s\" type %i failed, error 0x%x",
-			     provname? provname : "(null)", provtype,
-			     GetLastError());
-		return NULL;
-	}
-	res = PyObject_New(WRobject, &WRtype);
-	res->hcp = hcp;
-	return res;
-}
-
-static PyObject *
-WR_get_bytes(WRobject *self, PyObject *args)
-{
-	HCRYPTPROV hcp = 0;
-	int n, nbytes, len = 0;
-	PyObject *res;
-	char *buf, *str = NULL;
-	
-	if (! is_WRobject(self)) {
-		PyErr_Format(PyExc_TypeError,
-		    "WinRandom trying to get_bytes with non-WinRandom object");
-		return NULL;
-	}
-	if (!PyArg_ParseTuple(args, "i|s#", &n, &str, &len)) {
-		return NULL;
-	}
-	if (n <= 0) {
-		PyErr_SetString(PyExc_ValueError, "nbytes must be positive number");
-		return NULL;
-	}
-	/* Just in case char != BYTE, or userdata > desired result */
-	nbytes = (((n > len) ? n : len) * sizeof(char)) / sizeof(BYTE) + 1;
-	if ((buf = (char *) PyMem_Malloc(nbytes)) == NULL)
-	    return PyErr_NoMemory();
-	if (len > 0)
-		memcpy(buf, str, len);
-	/*
-	 * if userdata > desired result, we end up getting
-	 * more bytes than we really needed to return.  No
-	 * easy way to avoid that: we prefer that
-	 * CryptGenRandom does the distillation of userdata
-	 * down to entropy, rather than trying to do it
-	 * ourselves.  Since the extra bytes presumably come
-	 * from an RC4 stream, they should be relatively
-	 * cheap.
-	 */
-	if (! CryptGenRandom(self->hcp, (DWORD) nbytes, (BYTE *) buf)) {
-		PyErr_Format(PyExc_SystemError,
-			     "CryptGenRandom failed, error 0x%x",
-			     GetLastError());
-		PyMem_Free(buf);
-		return NULL;
-	}
-	res = PyString_FromStringAndSize(buf, n);
-	PyMem_Free(buf);
-	return res;
-}
-
-/* WinRandom object methods */
-
-static PyMethodDef WRmethods[] =
-{
-	{"get_bytes", (PyCFunction) WR_get_bytes, METH_VARARGS,
-		WR_get_bytes__doc__},
-	{NULL, NULL}			/* sentinel */
-};
-
-/* winrandom module methods */
-
-static PyMethodDef WR_mod_methods[] = {
-        {"new", (PyCFunction) winrandom_new, METH_VARARGS|METH_KEYWORDS,
-		winrandom__doc__},
-	{NULL,      NULL}        /* Sentinel */
-};
-
-
-static PyObject *
-WRgetattr(PyObject *s, char *name)
-{
-	WRobject *self = (WRobject*)s;
-	if (! is_WRobject(self)) {
-		PyErr_Format(PyExc_TypeError,
-		    "WinRandom trying to getattr with non-WinRandom object");
-		return NULL;
-	}
-	if (strcmp(name, "hcp") == 0)
-		return PyInt_FromLong((long) self->hcp);
-	return Py_FindMethod(WRmethods, (PyObject *) self, name);
-}
-
-static PyTypeObject WRtype =
-{
-	PyObject_HEAD_INIT(NULL)
-	0,			/*ob_size*/
-	"winrandom.WinRandom",	/*tp_name*/
-	sizeof(WRobject),	/*tp_size*/
-	0,			/*tp_itemsize*/
-	/* methods */
-	WRdealloc,		/*tp_dealloc*/
-	0,			/*tp_print*/
-	WRgetattr,		/*tp_getattr*/
-};
-
-void
-initwinrandom()
-{
-	PyObject *m;
-	WRtype.ob_type = &PyType_Type;
-	m = Py_InitModule("winrandom", WR_mod_methods);
-
-	/* define Windows CSP Provider Types */
-#ifdef PROV_RSA_FULL
-	PyModule_AddIntConstant(m, "PROV_RSA_FULL", PROV_RSA_FULL);
-#endif
-#ifdef PROV_RSA_SIG
-	PyModule_AddIntConstant(m, "PROV_RSA_SIG", PROV_RSA_SIG);
-#endif
-#ifdef PROV_DSS
-	PyModule_AddIntConstant(m, "PROV_DSS", PROV_DSS);
-#endif
-#ifdef PROV_FORTEZZA
-	PyModule_AddIntConstant(m, "PROV_FORTEZZA", PROV_FORTEZZA);
-#endif
-#ifdef PROV_MS_EXCHANGE
-	PyModule_AddIntConstant(m, "PROV_MS_EXCHANGE", PROV_MS_EXCHANGE);
-#endif
-#ifdef PROV_SSL
-	PyModule_AddIntConstant(m, "PROV_SSL", PROV_SSL);
-#endif
-#ifdef PROV_RSA_SCHANNEL
-	PyModule_AddIntConstant(m, "PROV_RSA_SCHANNEL", PROV_RSA_SCHANNEL);
-#endif
-#ifdef PROV_DSS_DH
-	PyModule_AddIntConstant(m, "PROV_DSS_DH", PROV_DSS_DH);
-#endif
-#ifdef PROV_EC_ECDSA_SIG
-	PyModule_AddIntConstant(m, "PROV_EC_ECDSA_SIG", PROV_EC_ECDSA_SIG);
-#endif
-#ifdef PROV_EC_ECNRA_SIG
-	PyModule_AddIntConstant(m, "PROV_EC_ECNRA_SIG", PROV_EC_ECNRA_SIG);
-#endif
-#ifdef PROV_EC_ECDSA_FULL
-	PyModule_AddIntConstant(m, "PROV_EC_ECDSA_FULL", PROV_EC_ECDSA_FULL);
-#endif
-#ifdef PROV_EC_ECNRA_FULL
-	PyModule_AddIntConstant(m, "PROV_EC_ECNRA_FULL", PROV_EC_ECNRA_FULL);
-#endif
-#ifdef PROV_SPYRUS_LYNKS
-	PyModule_AddIntConstant(m, "PROV_SPYRUS_LYNKS", PROV_SPYRUS_LYNKS);
-#endif
-#ifdef PROV_INTEL_SEC
-	PyModule_AddIntConstant(m, "PROV_INTEL_SEC", PROV_INTEL_SEC);
-#endif
-
-	/* Define Windows CSP Provider Names */
-#ifdef MS_DEF_PROV
-	PyModule_AddStringConstant(m, "MS_DEF_PROV", MS_DEF_PROV);
-#endif
-#ifdef MS_ENHANCED_PROV
-	PyModule_AddStringConstant(m, "MS_ENHANCED_PROV", MS_ENHANCED_PROV);
-#endif
-#ifdef MS_DEF_RSA_SIG_PROV
-	PyModule_AddStringConstant(m, "MS_DEF_RSA_SIG_PROV",
-				   MS_DEF_RSA_SIG_PROV);
-#endif
-#ifdef MS_DEF_RSA_SCHANNEL_PROV
-	PyModule_AddStringConstant(m, "MS_DEF_RSA_SCHANNEL_PROV",
-				   MS_DEF_RSA_SCHANNEL_PROV);
-#endif
-#ifdef MS_ENHANCED_RSA_SCHANNEL_PROV
-	PyModule_AddStringConstant(m, "MS_ENHANCED_RSA_SCHANNEL_PROV",
-				   MS_ENHANCED_RSA_SCHANNEL_PROV);
-#endif
-#ifdef MS_DEF_DSS_PROV
-	PyModule_AddStringConstant(m, "MS_DEF_DSS_PROV", MS_DEF_DSS_PROV);
-#endif
-#ifdef MS_DEF_DSS_DH_PROV
-	PyModule_AddStringConstant(m, "MS_DEF_DSS_DH_PROV",
-				   MS_DEF_DSS_DH_PROV);
-#endif
-#ifdef INTEL_DEF_PROV
-	PyModule_AddStringConstant(m, "INTEL_DEF_PROV", INTEL_DEF_PROV);
-#endif
-
-	if (PyErr_Occurred())
-		Py_FatalError("can't initialize module winrandom");
-}
-
-/*
-
-CryptGenRandom usage is described in
-http://msdn.microsoft.com/library/en-us/security/security/cryptgenrandom.asp
-and many associated pages on Windows Cryptographic Service
-Providers, which say:
-
-	With Microsoft CSPs, CryptGenRandom uses the same
-	random number generator used by other security
-	components. This allows numerous processes to
-	contribute to a system-wide seed. CryptoAPI stores
-	an intermediate random seed with every user. To form
-	the seed for the random number generator, a calling
-	application supplies bits it might havefor instance,
-	mouse or keyboard timing inputthat are then added to
-	both the stored seed and various system data and
-	user data such as the process ID and thread ID, the
-	system clock, the system time, the system counter,
-	memory status, free disk clusters, the hashed user
-	environment block. This result is SHA-1 hashed, and
-	the output is used to seed an RC4 stream, which is
-	then used as the random stream and used to update
-	the stored seed.
-
-The only other detailed description I've found of the
-sources of randomness for CryptGenRandom is this excerpt
-from a posting
-http://www.der-keiler.de/Newsgroups/comp.security.ssh/2002-06/0169.html
-
-From: Jon McClelland (dowot69@hotmail.com) 
-Date: 06/12/02 
-... 
- 
-Windows, call a function such as CryptGenRandom, which has two of 
-the properties of a good random number generator, unpredictability and 
-even value distribution. This function, declared in Wincrypt.h, is 
-available on just about every Windows platform, including Windows 95 
-with Internet Explorer 3.02 or later, Windows 98, Windows Me, Windows 
-CE v3, Windows NT 4, Windows 2000, and Windows XP. 
- 
-CryptGenRandom gets its randomness, also known as entropy, from many 
-sources in Windows 2000, including the following: 
-The current process ID (GetCurrentProcessID). 
-The current thread ID (GetCurrentThreadID). 
-The ticks since boot (GetTickCount). 
-The current time (GetLocalTime). 
-Various high-precision performance counters (QueryPerformanceCounter). 
-A Message Digest 4 (MD4) hash of the user's environment block, which 
-includes username, computer name, and search path. 
- 
-High-precision internal CPU counters, such as RDTSC, RDMSR, RDPMC (x86 
-only-more information about these counters is at 
-developer.intel.com/software/idap/resources/technical_collateral/pentiumii/RDTSCPM1.HTM 
-<http://developer.intel.com>). 
- 
-Low-level system information, such as idle time, kernel time, 
-interrupt times, commit limit, page read count, cache read count, 
-nonpaged pool allocations, alignment fixup count, operating system 
-lookaside information. 
- 
-Such information is added to a buffer, which is hashed using MD4 and 
-used as the key to modify a buffer, using RC4, provided by the user. 
-(Refer to the CryptGenRandom documentation in the Platform SDK for 
-more information about the user-provided buffer.) Hence, if the user 
-provides additional data in the buffer, this is used as an element in 
-the witches brew to generate the random data. The result is a 
-cryptographically random number generator. 
-Also, note that if you plan to sell your software to the United States 
-federal government, you'll need to use FIPS 140-1-approved algorithms. 
-The default versions of CryptGenRandom in Microsoft Windows CE v3, 
-Windows 95, Windows 98, Windows Me, Windows 2000, and Windows XP are 
-FIPS-approved. Obviously FIPS-140 compliance is necessary but not 
-sufficient to provide a properly secure source of random data. 
- 
-*/
-
-#endif /* MS_WIN32 */

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test.py
deleted file mode 100644
index c5ed061..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test.py
+++ /dev/null
@@ -1,38 +0,0 @@
-#
-# Test script for the Python Cryptography Toolkit.
-#
-
-__revision__ = "$Id: test.py,v 1.7 2002/07/11 14:31:19 akuchling Exp $"
-
-import os, sys
-
-
-# Add the build directory to the front of sys.path
-from distutils.util import get_platform
-s = "build/lib.%s-%.3s" % (get_platform(), sys.version)
-s = os.path.join(os.getcwd(), s)
-sys.path.insert(0, s)
-s = os.path.join(os.getcwd(), 'test')
-sys.path.insert(0, s)
-
-from Crypto.Util import test
-
-args = sys.argv[1:]
-quiet = "--quiet" in args
-if quiet: args.remove('--quiet')
-
-if not quiet:
-    print '\nStream Ciphers:'
-    print '==============='
-
-if args: test.TestStreamModules(args, verbose= not quiet)
-else: test.TestStreamModules(verbose= not quiet)
-
-if not quiet:
-    print '\nBlock Ciphers:'
-    print '=============='
-
-if args: test.TestBlockModules(args, verbose= not quiet)
-else: test.TestBlockModules(verbose= not quiet)
-
-

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/template
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/template b/tools/bin/pythonSrc/pycrypto-2.0.1/test/template
deleted file mode 100644
index dce6c9b..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/template
+++ /dev/null
@@ -1,26 +0,0 @@
-#
-# Test script for Crypto.XXX
-#
-
-__revision__ = "$Id: template,v 1.1 2002/05/17 13:31:48 akuchling Exp $"
-
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-
-tested_modules = [ "Crypto.XXX" ]
-
-class XXXTest (TestScenario):
-
-    def setup (self):
-	pass
-
-    def shutdown (self):
-	pass
-
-    def check_ (self):
-        ""
-        pass
-
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_chaffing.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_chaffing.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_chaffing.py
deleted file mode 100644
index a9d0296..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_chaffing.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#
-# Test script for Crypto.XXX
-#
-
-__revision__ = "$Id: test_chaffing.py,v 1.2 2003/02/28 15:23:59 akuchling Exp $"
-
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-from Crypto.Protocol import Chaffing
-
-tested_modules = [ "Crypto.Protocol.Chaffing" ]
-
-text = """\
-When in the Course of human events, it becomes necessary for one people to
-dissolve the political bands which have connected them with another, and to
-assume among the powers of the earth, the separate and equal station to which
-the Laws of Nature and of Nature's God entitle them, a decent respect to the
-opinions of mankind requires that they should declare the causes which impel
-them to the separation.
-
-We hold these truths to be self-evident, that all men are created equal, that
-they are endowed by their Creator with certain unalienable Rights, that among
-these are Life, Liberty, and the pursuit of Happiness. That to secure these
-rights, Governments are instituted among Men, deriving their just powers from
-the consent of the governed. That whenever any Form of Government becomes
-destructive of these ends, it is the Right of the People to alter or to
-abolish it, and to institute new Government, laying its foundation on such
-principles and organizing its powers in such form, as to them shall seem most
-likely to effect their Safety and Happiness.
-"""
-
-class ChaffingTest (TestScenario):
-
-    def setup (self):
-        pass
-
-    def shutdown (self):
-        pass
-
-    def check_chaffing (self):
-        "Simple tests of chaffing and winnowing"
-        self.test_stmt('Chaffing.Chaff()')
-        self.test_stmt('Chaffing.Chaff(0.5, 1)')
-        self.test_exc('Chaffing.Chaff(factor=-1)', ValueError)
-        self.test_exc('Chaffing.Chaff(blocksper=-1)', ValueError)
-
-        data = [(1, 'data1', 'data1'), (2, 'data2', 'data2')]
-        c = Chaffing.Chaff(1.0, 1)
-        self.test_stmt('c.chaff(data)')
-        chaff = c.chaff(data)
-        self.test_val('len(chaff)', 4)
-
-        c = Chaffing.Chaff(0.0, 1)
-        chaff = c.chaff(data)
-        self.test_val('len(chaff)', 2)
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_hashes.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_hashes.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_hashes.py
deleted file mode 100644
index 9163079..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_hashes.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#
-# Test script for Crypto.Util.randpool.
-#
-
-__revision__ = "$Id: test_hashes.py,v 1.4 2004/08/13 22:23:12 akuchling Exp $"
-
-import time, string, binascii
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-
-from Crypto.Hash import *
-import testdata
-
-tested_modules = [ "Crypto.Hash.MD2", "Crypto.Hash.MD4", "Crypto.Hash.MD5",
-                   "Crypto.Hash.RIPEMD", "Crypto.Hash.SHA", "Crypto.Hash.SHA256"]
-
-class HashTest (TestScenario):
-
-    def setup (self):
-        teststr='1'                             # Build 128K of test data
-        for i in xrange(0, 17):
-            teststr=teststr+teststr
-        self.str_128k = teststr
-
-    def shutdown (self):
-        del self.str_128k
-
-    def compare(self, hash_mod, strg, hex_result):
-        result = binascii.a2b_hex(hex_result)
-        obj = hash_mod.new(strg)
-        s1 = obj.digest()
-
-        # Check that the right hash result is produced
-        self.test_val('s1', result)
-
-        # Check that .hexdigest() produces the same output
-        self.test_val('obj.hexdigest()', hex_result)
-
-        # Test second hashing, and copying of a hashing object
-        self.test_val('obj.digest()', result)
-        self.test_val('obj.copy().digest()', result)
-
-
-    def run_test_suite (self, hash_mod, test_vectors):
-        for text, digest in test_vectors:
-            self.compare(hash_mod, text, digest)
-
-    def benchmark (self, hash_mod):
-        obj = hash_mod.new()
-        start=time.time()
-        s=obj.update(self.str_128k)
-        end=time.time()
-        delta = end-start
-        print hash_mod.__name__, ':', 
-        if delta == 0:
-            print 'Unable to measure time -- elapsed time too small'
-        else:
-            print '%.2f K/sec' % (128/(end-start))
-
-    def check_md2 (self):
-        "MD2 module"
-        self.run_test_suite(MD2, testdata.md2)
-        self.benchmark(MD2)
-
-    def check_md4 (self):
-        "MD4 module"
-        self.run_test_suite(MD4, testdata.md4)
-        self.benchmark(MD4)
-
-    def check_md5 (self):
-        "MD5 module"
-        self.run_test_suite(MD5, testdata.md5)
-        self.benchmark(MD5)
-
-    def check_ripemd (self):
-        "RIPEMD module"
-        self.run_test_suite(RIPEMD, testdata.ripemd)
-        self.benchmark(RIPEMD)
-
-    def check_sha (self):
-        "SHA module"
-        self.run_test_suite(SHA, testdata.sha)
-        self.benchmark(SHA)
-
-    def check_sha256 (self):
-        "SHA256 module"
-        self.run_test_suite(SHA256,testdata.sha256)
-        self.benchmark(SHA256)
-
-# class HashTest
-
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_number.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_number.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_number.py
deleted file mode 100644
index 776d33e..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_number.py
+++ /dev/null
@@ -1,85 +0,0 @@
-#
-# Test script for Crypto.Util.number.
-#
-
-__revision__ = "$Id: test_number.py,v 1.4 2003/04/04 18:21:35 akuchling Exp $"
-
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-from Crypto.Util import number
-
-tested_modules = [ "Crypto.Util.number" ]
-
-class NumberTest (TestScenario):
-
-    def setup (self):
-        pass
-
-    def shutdown (self):
-        pass
-
-    def check_getRandomNumber (self):
-        "Check generation of N-bit random numbers"
-        def f(N):
-            return '\xff' * N
-
-        self.test_val('number.getRandomNumber(1, f)', 1)
-        self.test_val('number.getRandomNumber(4, f)', 15)
-        self.test_val('number.getRandomNumber(8, f)', 255)
-        self.test_val('number.getRandomNumber(12, f)', 4095)
-        self.test_val('number.getRandomNumber(16, f)', 65535)
-
-    def check_GCD (self):
-        "Check GCD computation"
-        self.test_val('number.GCD(1, 5)', 1)
-        self.test_val('number.GCD(2, 6)', 2)
-        self.test_val('number.GCD(16, 12)', 4)
-
-    def check_inverse (self):
-        "Check computation of inverses"
-        self.test_val('number.inverse(9, 10)', 9)
-        self.test_val('number.inverse(1, 2)', 1)
-        self.test_val('number.inverse(529, 10502)', 3097)
-
-    def check_getPrime (self):
-        "Check generation of primes"
-        def f(n):
-            return '\xff' * n
-        self.test_val('number.getPrime(1, f)', 3)
-        self.test_val('number.getPrime(2, f)', 3)
-        self.test_val('number.getPrime(8, f)', 257)
-        self.test_val('number.getPrime(75, f)', 37778931862957161709601L)
-
-    def check_isPrime (self):
-        "Check verification of primes"
-        self.test_bool('number.isPrime(1)', want_true=0)
-        self.test_bool('number.isPrime(2)')
-        self.test_bool('number.isPrime(3)')
-        self.test_bool('number.isPrime(4)', want_true=0)
-        self.test_bool('number.isPrime(37778931862957161709601L)')
-        self.test_bool('number.isPrime(37778931862957161709603L)',
-                       want_true=0)
-
-    def check_longbytes (self):
-        "Check conversion between bytes and integers"
-        self.test_val('number.long_to_bytes(1)', '\x01')
-        self.test_val('number.long_to_bytes(1, 2)', '\x00\x01')
-        self.test_val('number.long_to_bytes(511)', '\x01\xff')
-
-        self.test_val('number.bytes_to_long("\x01")', 1)
-        self.test_val('number.bytes_to_long("\xff\x01")', 0xff01)
-        self.test_val('number.bytes_to_long("\x12\x34\x01")', 0x123401)
-
-    def check_size (self):
-        "Check measurement of number sizes"
-        self.test_val('number.size(1)', 1)
-        self.test_val('number.size(15)', 4)
-        self.test_val('number.size(255)', 8)
-        self.test_val('number.size(256)', 9)
-
-
-# class NumberTest
-
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_publickey.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_publickey.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_publickey.py
deleted file mode 100644
index 83fdea7..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_publickey.py
+++ /dev/null
@@ -1,122 +0,0 @@
-#
-# Test script for Crypto.Util.PublicKey.
-#
-
-__revision__ = "$Id: test_publickey.py,v 1.7 2003/04/04 19:38:28 akuchling Exp $"
-
-import sys, cPickle
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-from Crypto.PublicKey import *
-from Crypto.Util.randpool import RandomPool
-from Crypto.Util import number
-
-tested_modules = [ "Crypto.PublicKey.RSA", "Crypto.PublicKey.DSA",
-                   "Crypto.PublicKey.ElGamal", "Crypto.PublicKey.qNEW"]
-
-class PublicKeyTest (TestScenario):
-
-    def setup (self):
-        # Set up a random pool; we won't bother to actually fill it with
-        # entropy from the keyboard
-        self.pool = RandomPool(384)
-        self.pool.stir()
-
-    def shutdown (self):
-        del self.pool
-
-    def testkey (self, key, randfunc, verbose=0):
-        plaintext="Hello"
-        # Generate maximum-size plaintext
-        maxplain = (key.size() // 8) * '\377'
-
-        if key.can_encrypt():
-            if verbose: print '  Encryption/decryption test'
-            K=number.getPrime(10, randfunc)
-            ciphertext=key.encrypt(plaintext, K)
-            self.test_val('key.decrypt(ciphertext)', plaintext)
-            ciphertext=key.encrypt(maxplain, K)
-            self.test_val('key.decrypt(ciphertext)', maxplain)
-
-        if key.can_sign():
-            if verbose: print '  Signature test'
-            K=number.getPrime(30, randfunc)
-            signature=key.sign(plaintext, K)
-            self.test_bool('key.verify(plaintext, signature)')
-            self.test_bool('key.verify(plaintext[:-1], signature)',
-                           want_true=0)
-
-            # Change a single bit in the plaintext
-            badtext=plaintext[:-3]+chr( 1 ^ ord(plaintext[-3]) )+plaintext[-3:]
-            self.test_bool('key.verify(badtext, signature)', want_true=0)
-
-            if verbose: print '  Removing private key data'
-            pubonly=key.publickey()
-            self.test_bool('pubonly.verify(plaintext, signature)')
-
-        # Test blinding
-        if key.can_blind():
-            if verbose: print '  Blinding test'
-            K=number.getPrime(30, randfunc)
-            B="garbage"
-            blindedtext=key.blind(plaintext, B)
-            signature=key.sign(blindedtext, K)
-            unblindedsignature=(key.unblind(signature[0], B),)
-            self.test_bool('key.verify(plaintext, unblindedsignature)')
-            self.test_val('key.sign(plaintext, K)', unblindedsignature)
-
-            # Change a single bit in the blinding factor
-            badB=B[:-3]+chr( 1 ^ ord(B[-3]) )+B[-3:]
-            badunblindedsignature=(key.unblind(signature[0], badB),)
-            self.test_false('key.verify(badtext, badunblindedsignature)')
-
-            badblindedtext=key.blind(plaintext, badB)
-            badsignature=key.sign(blindedtext, K)
-            badunblindedsignature2=(key.unblind(signature[0], B),)
-            self.test_false('key.verify(badtext, badunblindedsignature2)')
-
-
-    def exercise (self, randfunc, pk_mod, verbose=0):
-        N=256                           # Key size, measured in bits
-
-        key=pk_mod.generate(N, randfunc)
-
-        if verbose:
-            print ' Key data:'
-            for field in key.keydata:
-                print "  ", field, ':', hex(getattr(key,field))
-
-        if verbose: print " Testing newly generated key"
-        self.testkey(key, randfunc, verbose)
-        if verbose: print " Testing pickled/unpickled key"
-        import pickle
-        s = pickle.dumps(key) ; key2 = pickle.loads(s)
-        self.testkey(key2, randfunc, verbose)
-
-        if verbose: print " Testing cPickled key"
-        s = cPickle.dumps(key) ; key2 = cPickle.loads(s)
-        self.testkey(key2, randfunc, verbose)
-        if verbose: print
-
-
-    def check_rsa(self):
-        "Check RSA algorithm"
-        self.exercise(self.pool.get_bytes, RSA)
-
-    def check_dsa(self):
-        "Check DSA algorithm"
-        self.exercise(self.pool.get_bytes, DSA)
-
-    def check_elgamal(self):
-        "Check ElGamal algorithm"
-        self.exercise(self.pool.get_bytes, ElGamal)
-
-    def check_qnew(self):
-        "Check qNEW algorithm"
-        self.exercise(self.pool.get_bytes, qNEW)
-
-# class PublicKeyTest
-
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_randpool.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_randpool.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_randpool.py
deleted file mode 100644
index f1cb6a5..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_randpool.py
+++ /dev/null
@@ -1,48 +0,0 @@
-#
-# Test script for Crypto.Util.randpool.
-#
-
-__revision__ = "$Id: test_randpool.py,v 1.3 2003/02/28 15:24:01 akuchling Exp $"
-
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-from Crypto.Hash import SHA
-from Crypto.Util import randpool
-
-tested_modules = [ "Crypto.Util.randpool" ]
-
-class RandomPoolTest (TestScenario):
-
-    def setup (self):
-        self.pool = randpool.RandomPool(160, hash=SHA)
-
-    def shutdown (self):
-        del self.pool
-
-    def check_init (self):
-        "Check initial state"
-        self.test_val('self.pool.entropy', self.pool.bits)
-
-    def check_get_bytes (self):
-        "Check retrieving of bytes from the pool"
-        start_entropy = self.pool.entropy
-        self.test_bool('self.pool.entropy > 0')
-
-        # Draw out half of the pool's entropy
-        size = self.pool.entropy / 8 / 2
-        self.test_stmt('self.pool.get_bytes(size)')
-        self.test_val('self.pool.entropy', start_entropy - size*8)
-
-        # Draw out the rest of the pool's entropy
-        self.test_stmt('self.pool.get_bytes(size)')
-        self.test_val('self.pool.entropy', 0)
-
-        # Remove yet more data; entropy stays at zero
-        self.test_stmt('self.pool.get_bytes(size)')
-        self.test_val('self.pool.entropy', 0)
-
-# class RandomPoolTest
-
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/b0d16155/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_rfc1751.py
----------------------------------------------------------------------
diff --git a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_rfc1751.py b/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_rfc1751.py
deleted file mode 100644
index c86fb4c..0000000
--- a/tools/bin/pythonSrc/pycrypto-2.0.1/test/test_rfc1751.py
+++ /dev/null
@@ -1,45 +0,0 @@
-#
-# Test script for Crypto.Util.randpool.
-#
-
-__revision__ = "$Id: test_rfc1751.py,v 1.3 2003/02/28 15:24:01 akuchling Exp $"
-
-import binascii
-from sancho.unittest import TestScenario, parse_args, run_scenarios
-from Crypto.Util import RFC1751
-
-tested_modules = [ "Crypto.Util.RFC1751" ]
-
-test_data = [('EB33F77EE73D4053', 'TIDE ITCH SLOW REIN RULE MOT'),
-             ('CCAC2AED591056BE4F90FD441C534766',
-              'RASH BUSH MILK LOOK BAD BRIM AVID GAFF BAIT ROT POD LOVE'),
-             ('EFF81F9BFBC65350920CDD7416DE8009',
-              'TROD MUTE TAIL WARM CHAR KONG HAAG CITY BORE O TEAL AWL')
-             ]
-
-class RFC1751Test (TestScenario):
-
-    def setup (self):
-        pass
-
-    def shutdown (self):
-        pass
-
-    def check_k2e (self):
-        "Check converting keys to English"
-        for key, words in test_data:
-            key=binascii.a2b_hex(key)
-            self.test_val('RFC1751.key_to_english(key)', words)
-
-    def check_e2k (self):
-        "Check converting English strings to keys"
-        for key, words in test_data:
-            key=binascii.a2b_hex(key)
-            self.test_val('RFC1751.english_to_key(words)', key)
-
-# class RFC1751Test
-
-
-if __name__ == "__main__":
-    (scenarios, options) = parse_args()
-    run_scenarios(scenarios, options)



Mime
View raw message