commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From x..@apache.org
Subject [2/8] commons-crypto git commit: CRYPTO-7: Rename source code in Chimera to Apache name space
Date Fri, 22 Apr 2016 05:18:30 GMT
http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/main/native/org/apache/commons/crypto/random/OpensslSecureRandomNative.c
----------------------------------------------------------------------
diff --git a/src/main/native/org/apache/commons/crypto/random/OpensslSecureRandomNative.c b/src/main/native/org/apache/commons/crypto/random/OpensslSecureRandomNative.c
new file mode 100644
index 0000000..404697f
--- /dev/null
+++ b/src/main/native/org/apache/commons/crypto/random/OpensslSecureRandomNative.c
@@ -0,0 +1,335 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "org_apache_commons_crypto_random.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef UNIX
+#include <pthread.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#endif
+
+#ifdef WINDOWS
+#include <windows.h>
+#endif
+ 
+#include "OpensslSecureRandomNative.h"
+
+#ifdef UNIX
+static void * (*dlsym_CRYPTO_malloc) (int, const char *, int);
+static void (*dlsym_CRYPTO_free) (void *);
+static int (*dlsym_CRYPTO_num_locks) (void);
+static void (*dlsym_CRYPTO_set_locking_callback) (void (*)());
+static void (*dlsym_CRYPTO_set_id_callback) (unsigned long (*)());
+static void (*dlsym_ENGINE_load_rdrand) (void);
+static ENGINE * (*dlsym_ENGINE_by_id) (const char *);
+static int (*dlsym_ENGINE_init) (ENGINE *);
+static int (*dlsym_ENGINE_set_default) (ENGINE *, unsigned int);
+static int (*dlsym_ENGINE_finish) (ENGINE *);
+static int (*dlsym_ENGINE_free) (ENGINE *);
+static void (*dlsym_ENGINE_cleanup) (void);
+static int (*dlsym_RAND_bytes) (unsigned char *, int);
+static unsigned long (*dlsym_ERR_get_error) (void);
+#endif
+
+#ifdef WINDOWS
+typedef void * (__cdecl *__dlsym_CRYPTO_malloc) (int, const char *, int);
+typedef void (__cdecl *__dlsym_CRYPTO_free) (void *);
+typedef int (__cdecl *__dlsym_CRYPTO_num_locks) (void);
+typedef void (__cdecl *__dlsym_CRYPTO_set_locking_callback)  \
+              (void (*)(int, int, char *, int);
+typedef void (__cdecl *__dlsym_ENGINE_load_rdrand) (void);
+typedef ENGINE * (__cdecl *__dlsym_ENGINE_by_id) (const char *);
+typedef int (__cdecl *__dlsym_ENGINE_init) (ENGINE *);
+typedef int (__cdecl *__dlsym_ENGINE_set_default) (ENGINE *, unsigned int);
+typedef int (__cdecl *__dlsym_ENGINE_finish) (ENGINE *);
+typedef int (__cdecl *__dlsym_ENGINE_free) (ENGINE *);
+typedef void (__cdecl *__dlsym_ENGINE_cleanup) (void);
+typedef int (__cdecl *__dlsym_RAND_bytes) (unsigned char *, int);
+typedef unsigned long (__cdecl *__dlsym_ERR_get_error) (void);
+static __dlsym_CRYPTO_malloc dlsym_CRYPTO_malloc;
+static __dlsym_CRYPTO_free dlsym_CRYPTO_free;
+static __dlsym_CRYPTO_num_locks dlsym_CRYPTO_num_locks;
+static __dlsym_CRYPTO_set_locking_callback dlsym_CRYPTO_set_locking_callback;
+static __dlsym_ENGINE_load_rdrand dlsym_ENGINE_load_rdrand;
+static __dlsym_ENGINE_by_id dlsym_ENGINE_by_id;
+static __dlsym_ENGINE_init dlsym_ENGINE_init;
+static __dlsym_ENGINE_set_default dlsym_ENGINE_set_default;
+static __dlsym_ENGINE_finish dlsym_ENGINE_finish;
+static __dlsym_ENGINE_free dlsym_ENGINE_free;
+static __dlsym_ENGINE_cleanup dlsym_ENGINE_cleanup;
+static __dlsym_RAND_bytes dlsym_RAND_bytes;
+static __dlsym_ERR_get_error dlsym_ERR_get_error;
+#endif
+
+static ENGINE * openssl_rand_init(void);
+static void openssl_rand_clean(ENGINE *eng, int clean_locks);
+static int openssl_rand_bytes(unsigned char *buf, int num);
+
+JNIEXPORT void JNICALL Java_org_apache_commons_crypto_random_OpensslSecureRandomNative_initSR
+    (JNIEnv *env, jclass clazz)
+{
+  char msg[1000];
+#ifdef UNIX
+  void *openssl = dlopen(CHIMERA_OPENSSL_LIBRARY, RTLD_LAZY | RTLD_GLOBAL);
+#endif
+
+#ifdef WINDOWS
+  HMODULE openssl = LoadLibrary(CHIMERA_OPENSSL_LIBRARY);
+#endif
+
+  if (!openssl) {
+    snprintf(msg, sizeof(msg), "Cannot load %s (%s)!", CHIMERA_OPENSSL_LIBRARY,  \
+        dlerror());
+    THROW(env, "java/lang/UnsatisfiedLinkError", msg);
+    return;
+  }
+
+#ifdef UNIX
+  dlerror();  // Clear any existing error
+  LOAD_DYNAMIC_SYMBOL(dlsym_CRYPTO_malloc, env, openssl, "CRYPTO_malloc");
+  LOAD_DYNAMIC_SYMBOL(dlsym_CRYPTO_free, env, openssl, "CRYPTO_free");
+  LOAD_DYNAMIC_SYMBOL(dlsym_CRYPTO_num_locks, env, openssl, "CRYPTO_num_locks");
+  LOAD_DYNAMIC_SYMBOL(dlsym_CRYPTO_set_locking_callback,  \
+                      env, openssl, "CRYPTO_set_locking_callback");
+  LOAD_DYNAMIC_SYMBOL(dlsym_CRYPTO_set_id_callback, env,  \
+                      openssl, "CRYPTO_set_id_callback");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_load_rdrand, env,  \
+                      openssl, "ENGINE_load_rdrand");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_by_id, env, openssl, "ENGINE_by_id");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_init, env, openssl, "ENGINE_init");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_set_default, env,  \
+                      openssl, "ENGINE_set_default");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_finish, env, openssl, "ENGINE_finish");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_free, env, openssl, "ENGINE_free");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ENGINE_cleanup, env, openssl, "ENGINE_cleanup");
+  LOAD_DYNAMIC_SYMBOL(dlsym_RAND_bytes, env, openssl, "RAND_bytes");
+  LOAD_DYNAMIC_SYMBOL(dlsym_ERR_get_error, env, openssl, "ERR_get_error");
+#endif
+
+#ifdef WINDOWS
+  LOAD_DYNAMIC_SYMBOL(__dlsym_CRYPTO_malloc, dlsym_CRYPTO_malloc,  \
+                      env, openssl, "CRYPTO_malloc");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_CRYPTO_free, dlsym_CRYPTO_free,  \
+                      env, openssl, "CRYPTO_free");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_CRYPTO_num_locks, dlsym_CRYPTO_num_locks,  \
+                      env, openssl, "CRYPTO_num_locks");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_CRYPTO_set_locking_callback,  \
+                      dlsym_CRYPTO_set_locking_callback,  \
+                      env, openssl, "CRYPTO_set_locking_callback");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_load_rdrand, dlsym_ENGINE_load_rdrand,  \
+                      env, openssl, "ENGINE_load_rdrand");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_by_id, dlsym_ENGINE_by_id,  \
+                      env, openssl, "ENGINE_by_id");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_init, dlsym_ENGINE_init,  \
+                      env, openssl, "ENGINE_init");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_set_default, dlsym_ENGINE_set_default,  \
+                      env, openssl, "ENGINE_set_default");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_finish, dlsym_ENGINE_finish,  \
+                      env, openssl, "ENGINE_finish");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_free, dlsym_ENGINE_free,  \
+                      env, openssl, "ENGINE_free");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ENGINE_cleanup, dlsym_ENGINE_cleanup,  \
+                      env, openssl, "ENGINE_cleanup");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_RAND_bytes, dlsym_RAND_bytes,  \
+                      env, openssl, "RAND_bytes");
+  LOAD_DYNAMIC_SYMBOL(__dlsym_ERR_get_error, dlsym_ERR_get_error,  \
+                      env, openssl, "ERR_get_error");
+#endif
+
+  openssl_rand_init();
+}
+
+JNIEXPORT jboolean JNICALL Java_org_apache_commons_crypto_random_OpensslSecureRandomNative_nextRandBytes___3B
+    (JNIEnv *env, jobject object, jbyteArray bytes)
+{
+  if (NULL == bytes) {
+    THROW(env, "java/lang/NullPointerException", "Buffer cannot be null.");
+    return JNI_FALSE;
+  }
+  jbyte *b = (*env)->GetByteArrayElements(env, bytes, NULL);
+  if (NULL == b) {
+    THROW(env, "java/lang/InternalError", "Cannot get bytes array.");
+    return JNI_FALSE;
+  }
+  int b_len = (*env)->GetArrayLength(env, bytes);
+  int ret = openssl_rand_bytes((unsigned char *)b, b_len);
+  (*env)->ReleaseByteArrayElements(env, bytes, b, 0);
+  
+  if (1 != ret) {
+    return JNI_FALSE;
+  }
+  return JNI_TRUE;
+}
+
+/**
+ * To ensure thread safety for random number generators, we need to call 
+ * CRYPTO_set_locking_callback.
+ * http://wiki.openssl.org/index.php/Random_Numbers
+ * Example: crypto/threads/mttest.c
+ */
+
+#ifdef WINDOWS
+static void windows_locking_callback(int mode, int type, char *file, int line);
+static HANDLE *lock_cs;
+
+static void locks_setup(void)
+{
+  int i;
+  lock_cs = dlsym_CRYPTO_malloc(dlsym_CRYPTO_num_locks() * sizeof(HANDLE),  \
+      __FILE__, __LINE__);
+
+  for (i = 0; i < dlsym_CRYPTO_num_locks(); i++) {
+    lock_cs[i] = CreateMutex(NULL, FALSE, NULL);
+  }
+  dlsym_CRYPTO_set_locking_callback((void (*)(int, int, char *, int))  \
+      windows_locking_callback);
+  /* id callback defined */
+}
+
+static void locks_cleanup(void)
+{
+  int i;
+  dlsym_CRYPTO_set_locking_callback(NULL);
+
+  for (i = 0; i < dlsym_CRYPTO_num_locks(); i++) {
+    CloseHandle(lock_cs[i]);
+  }
+  dlsym_CRYPTO_free(lock_cs);
+}
+
+static void windows_locking_callback(int mode, int type, char *file, int line)
+{
+  UNUSED(file), UNUSED(line);
+  
+  if (mode & CRYPTO_LOCK) {
+    WaitForSingleObject(lock_cs[type], INFINITE);
+  } else {
+    ReleaseMutex(lock_cs[type]);
+  }
+}
+#endif /* WINDOWS */
+
+#ifdef UNIX
+static void pthreads_locking_callback(int mode, int type, char *file, int line);
+static unsigned long pthreads_thread_id(void);
+static pthread_mutex_t *lock_cs;
+
+static void locks_setup(void)
+{
+  int i;
+  lock_cs = dlsym_CRYPTO_malloc(dlsym_CRYPTO_num_locks() *  \
+      sizeof(pthread_mutex_t), __FILE__, __LINE__);
+
+  for (i = 0; i < dlsym_CRYPTO_num_locks(); i++) {
+    pthread_mutex_init(&(lock_cs[i]), NULL);
+  }
+  
+  dlsym_CRYPTO_set_id_callback((unsigned long (*)())pthreads_thread_id);
+  dlsym_CRYPTO_set_locking_callback((void (*)())pthreads_locking_callback);
+}
+
+static void locks_cleanup(void)
+{
+  int i;
+  dlsym_CRYPTO_set_locking_callback(NULL);
+  
+  for (i = 0; i < dlsym_CRYPTO_num_locks(); i++) {
+    pthread_mutex_destroy(&(lock_cs[i]));
+  }
+  
+  dlsym_CRYPTO_free(lock_cs);
+}
+
+static void pthreads_locking_callback(int mode, int type, char *file, int line)
+{
+  UNUSED(file), UNUSED(line);
+  
+  if (mode & CRYPTO_LOCK) {
+    pthread_mutex_lock(&(lock_cs[type]));
+  } else {
+    pthread_mutex_unlock(&(lock_cs[type]));
+  }
+}
+
+static unsigned long pthreads_thread_id(void)
+{
+  return (unsigned long)syscall(SYS_gettid);
+}
+
+#endif /* UNIX */
+
+/**
+ * If using an Intel chipset with RDRAND, the high-performance hardware
+ * random number generator will be used.
+ */
+static ENGINE * openssl_rand_init(void)
+{
+  locks_setup();
+  
+  dlsym_ENGINE_load_rdrand();
+  ENGINE *eng = dlsym_ENGINE_by_id("rdrand");
+  
+  int ret = -1;
+  do {
+    if (NULL == eng) {
+      break;
+    }
+    
+    int rc = dlsym_ENGINE_init(eng);
+    if (0 == rc) {
+      break;
+    }
+    
+    rc = dlsym_ENGINE_set_default(eng, ENGINE_METHOD_RAND);
+    if (0 == rc) {
+      break;
+    }
+  
+    ret = 0;
+  } while(0);
+  
+  if (ret == -1) {
+    openssl_rand_clean(eng, 0);
+  }
+  
+  return eng;
+}
+
+static void openssl_rand_clean(ENGINE *eng, int clean_locks)
+{
+  if (NULL != eng) {
+    dlsym_ENGINE_finish(eng);
+    dlsym_ENGINE_free(eng);
+  }
+    
+  dlsym_ENGINE_cleanup();
+  if (clean_locks) {
+    locks_cleanup();
+  }
+}
+
+static int openssl_rand_bytes(unsigned char *buf, int num)
+{
+  return dlsym_RAND_bytes(buf, num);
+}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/main/native/org/apache/commons/crypto/random/org_apache_commons_crypto_random.h
----------------------------------------------------------------------
diff --git a/src/main/native/org/apache/commons/crypto/random/org_apache_commons_crypto_random.h b/src/main/native/org/apache/commons/crypto/random/org_apache_commons_crypto_random.h
new file mode 100644
index 0000000..7adb060
--- /dev/null
+++ b/src/main/native/org/apache/commons/crypto/random/org_apache_commons_crypto_random.h
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#ifndef ORG_APACHE_COMMONS_CRYPTO_RANDOM_H
+#define ORG_APACHE_COMMONS_CRYPTO_RANDOM_H
+
+#include "org_apache_commons_crypto.h"
+
+#ifdef UNIX
+#include <dlfcn.h>
+#include "config.h"
+#endif
+
+#ifdef WINDOWS
+#include "winutils.h"
+#endif
+
+#define UNUSED(x) ((void)(x))
+
+#include <openssl/crypto.h>
+#include <openssl/engine.h>
+#include <openssl/rand.h>
+#include <openssl/err.h>
+
+#endif //ORG_APACHE_COMMONS_CRYPTO_RANDOM_H

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/cipher/AbstractCipherTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/cipher/AbstractCipherTest.java b/src/test/java/com/intel/chimera/cipher/AbstractCipherTest.java
deleted file mode 100644
index bc69464..0000000
--- a/src/test/java/com/intel/chimera/cipher/AbstractCipherTest.java
+++ /dev/null
@@ -1,242 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.cipher;
-
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.security.GeneralSecurityException;
-import java.security.SecureRandom;
-import java.util.Properties;
-import java.util.Random;
-import javax.xml.bind.DatatypeConverter;
-
-import com.intel.chimera.conf.ConfigurationKeys;
-import com.intel.chimera.utils.ReflectionUtils;
-import com.intel.chimera.utils.Utils;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-public abstract class AbstractCipherTest {
-
-  // data
-  public static final int BYTEBUFFER_SIZE = 1000;
-  public String[] cipherTests = null;
-  Properties props = null;
-  String cipherClass = null;
-  CipherTransformation[] transformations = null;
-
-  // cipher
-  static final byte[] KEY = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-      0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16};
-  static final byte[] IV = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-      0x07, 0x08, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
-  Cipher enc, dec;
-
-  @Before
-  public void setup() {
-    init();
-    Utils.checkNotNull(cipherClass);
-    Utils.checkNotNull(transformations);
-    props = new Properties();
-    props.setProperty(ConfigurationKeys.CHIMERA_CRYPTO_CIPHER_CLASSES_KEY,
-        cipherClass);
-  }
-
-  protected abstract void init() ;
-
-  @Test
-  public void cryptoTest() throws GeneralSecurityException, IOException {
-    for (CipherTransformation tran : transformations) {
-      /** uses the small data set in {@link TestData} */
-      cipherTests = TestData.getTestData(tran);
-      for (int i = 0; i != cipherTests.length; i += 5) {
-        byte[] key = DatatypeConverter.parseHexBinary(cipherTests[i + 1]);
-        byte[] iv = DatatypeConverter.parseHexBinary(cipherTests[i + 2]);
-
-        byte[] inputBytes = DatatypeConverter.parseHexBinary(cipherTests[i + 3]);
-        byte[] outputBytes = DatatypeConverter.parseHexBinary(cipherTests[i + 4]);
-
-        ByteBuffer inputBuffer = ByteBuffer.allocateDirect(inputBytes.length);
-        ByteBuffer outputBuffer = ByteBuffer.allocateDirect(outputBytes.length);
-        inputBuffer.put(inputBytes);
-        inputBuffer.flip();
-        outputBuffer.put(outputBytes);
-        outputBuffer.flip();
-
-        byteBufferTest(tran,key, iv, inputBuffer, outputBuffer);
-        byteArrayTest(tran, key, iv, inputBytes, outputBytes);
-      }
-
-      /** uses randomly generated big data set */
-      byteArrayTest(tran, KEY, IV);
-    }
-  }
-
-  private void byteBufferTest(CipherTransformation transformation, byte[] key,
-                              byte[] iv,
-                                ByteBuffer input, ByteBuffer output) throws
-      GeneralSecurityException, IOException {
-    ByteBuffer decResult = ByteBuffer.allocateDirect(BYTEBUFFER_SIZE);
-    ByteBuffer encResult = ByteBuffer.allocateDirect(BYTEBUFFER_SIZE);
-    Cipher enc, dec;
-
-    enc = getCipher(transformation);
-    dec = getCipher(transformation);
-
-    try {
-      enc.init(Cipher.ENCRYPT_MODE, key, iv);
-    } catch (Exception e) {
-      Assert.fail("AES failed initialisation - " + e.toString());
-    }
-
-    try {
-      dec.init(Cipher.DECRYPT_MODE, key, iv);
-    } catch (Exception e) {
-      Assert.fail("AES failed initialisation - " + e.toString());
-    }
-
-    //
-    // encryption pass
-    //
-    enc.doFinal(input, encResult);
-    input.flip();
-    encResult.flip();
-    if (!output.equals(encResult)) {
-      byte[] b = new byte[output.remaining()];
-      output.get(b);
-      byte[] c = new byte[encResult.remaining()];
-      encResult.get(c);
-      Assert.fail("AES failed encryption - expected " + new String(
-          DatatypeConverter
-              .printHexBinary(b)) + " got " + new String(
-          DatatypeConverter.printHexBinary(c)));
-    }
-
-    //
-    // decryption pass
-    //
-    dec.doFinal(encResult, decResult);
-    decResult.flip();
-
-    if (!input.equals(decResult)) {
-      byte[] inArray = new byte[input.remaining()];
-      byte[] decResultArray = new byte[decResult.remaining()];
-      input.get(inArray);
-      decResult.get(decResultArray);
-      Assert.fail();
-    }
-  }
-
-  /** test byte array whose data is planned in {@link TestData} */
-  private void byteArrayTest(CipherTransformation transformation, byte[] key,
-      byte[] iv, byte[] input, byte[] output) throws GeneralSecurityException {
-    resetCipher(transformation, key, iv);
-    int blockSize = transformation.getAlgorithmBlockSize();
-
-    byte[] temp = new byte[input.length + blockSize];
-    int n = enc.doFinal(input, 0, input.length, temp, 0);
-    byte[] cipherText = new byte[n];
-    System.arraycopy(temp, 0, cipherText, 0, n);
-    Assert.assertArrayEquals("byte array encryption error.", output, cipherText);
-
-    temp = new byte[cipherText.length + blockSize];
-    int m = dec.doFinal(cipherText, 0, cipherText.length, temp, 0);
-    byte[] plainText = new byte[m];
-    System.arraycopy(temp, 0, plainText, 0, m);
-    Assert.assertArrayEquals("byte array decryption error.", input, plainText);
-  }
-
-  /** test byte array whose data is randomly generated */
-  private void byteArrayTest(CipherTransformation transformation, byte[] key,
-      byte[] iv) throws GeneralSecurityException {
-    int blockSize = transformation.getAlgorithmBlockSize();
-
-    // AES_CBC_NOPADDING only accepts data whose size is the multiple of block size
-    int[] dataLenList = (transformation == CipherTransformation.AES_CBC_NOPADDING)
-        ? new int[] {10 * 1024} : new int[] {10 * 1024, 10 * 1024 - 3};
-    for (int dataLen : dataLenList) {
-      byte[] plainText = new byte[dataLen];
-      Random random = new SecureRandom();
-      random.nextBytes(plainText);
-      byte[] cipherText = new byte[dataLen + blockSize];
-
-      // check update method with inputs whose sizes are the multiple of block size or not
-      int[] bufferLenList = new int[] {2 * 1024 - 128, 2 * 1024 - 125};
-      for (int bufferLen : bufferLenList) {
-        resetCipher(transformation, key, iv);
-        
-        int offset = 0;
-        // encrypt (update + doFinal) the data
-        int cipherPos = 0;
-        for (int i = 0; i < dataLen / bufferLen; i ++) {
-          cipherPos += enc.update(plainText, offset, bufferLen, cipherText, cipherPos);
-          offset += bufferLen;
-        }
-        cipherPos += enc.doFinal(plainText, offset, dataLen % bufferLen, cipherText, cipherPos);
-
-        offset = 0;
-        // decrypt (update + doFinal) the data
-        byte[] realPlainText = new byte[cipherPos + blockSize];
-        int plainPos = 0;
-        for (int i = 0; i < cipherPos / bufferLen; i ++) {
-          plainPos += dec.update(cipherText, offset, bufferLen, realPlainText, plainPos);
-          offset += bufferLen;
-        }
-        plainPos += dec.doFinal(cipherText, offset, cipherPos % bufferLen, realPlainText, plainPos);
-
-        // verify
-        Assert.assertEquals("random byte array length changes after transformation",
-            dataLen, plainPos);
-
-        byte[] shrinkPlainText = new byte[plainPos];
-        System.arraycopy(realPlainText, 0, shrinkPlainText, 0, plainPos);
-        Assert.assertArrayEquals("random byte array contents changes after transformation",
-            plainText, shrinkPlainText);
-      }
-    }
-  }
-
-  private void resetCipher(CipherTransformation transformation, byte[] key, byte[] iv) {
-    enc = getCipher(transformation);
-    dec = getCipher(transformation);
-
-    try {
-      enc.init(Cipher.ENCRYPT_MODE, key, iv);
-    } catch (Exception e) {
-      Assert.fail("AES failed initialisation - " + e.toString());
-    }
-
-    try {
-      dec.init(Cipher.DECRYPT_MODE, key, iv);
-    } catch (Exception e) {
-      Assert.fail("AES failed initialisation - " + e.toString());
-    }
-  }
-
-  private Cipher getCipher(CipherTransformation transformation) {
-    try {
-      return (Cipher) ReflectionUtils
-          .newInstance(ReflectionUtils.getClassByName(cipherClass), props,
-              transformation);
-    } catch (ClassNotFoundException e) {
-      throw new RuntimeException(e);
-    }
-
-  }
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/cipher/JceCipherTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/cipher/JceCipherTest.java b/src/test/java/com/intel/chimera/cipher/JceCipherTest.java
deleted file mode 100644
index 1c67c54..0000000
--- a/src/test/java/com/intel/chimera/cipher/JceCipherTest.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.intel.chimera.cipher;
-
-public class JceCipherTest extends AbstractCipherTest {
-
-  @Override
-  public void init() {
-    transformations = new CipherTransformation[]{
-        CipherTransformation.AES_CBC_NOPADDING,
-        CipherTransformation.AES_CBC_PKCS5PADDING,
-        CipherTransformation.AES_CTR_NOPADDING};
-    cipherClass = JceCipher.class.getName();
-  }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/cipher/OpensslCipherTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/cipher/OpensslCipherTest.java b/src/test/java/com/intel/chimera/cipher/OpensslCipherTest.java
deleted file mode 100644
index eae4c2c..0000000
--- a/src/test/java/com/intel/chimera/cipher/OpensslCipherTest.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.intel.chimera.cipher;
-
-import java.nio.ByteBuffer;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import javax.crypto.NoSuchPaddingException;
-import javax.crypto.ShortBufferException;
-
-import org.junit.Assert;
-import org.junit.Assume;
-import org.junit.Test;
-
-public class OpensslCipherTest extends AbstractCipherTest {
-
-  @Override
-  public void init() {
-    transformations = new CipherTransformation[]{
-        CipherTransformation.AES_CBC_NOPADDING,
-        CipherTransformation.AES_CBC_PKCS5PADDING,
-        CipherTransformation.AES_CTR_NOPADDING};
-    cipherClass = OpensslCipher.class.getName();
-  }
-
-  @Test(expected = NoSuchAlgorithmException.class, timeout=120000)
-  public void testInvalidAlgorithm() throws Exception {
-    Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-
-    try {
-      Openssl cipher = Openssl.getInstance("AES2/CTR/NoPadding");
-      Assert.fail("Should specify correct algorithm.");
-    } catch (NoSuchAlgorithmException e) {
-      Assert.assertTrue(e.getMessage().contains("Doesn't support algorithm: AES2 and mode: CTR"));
-      throw e;
-    }
-  }
-
-  @Test(expected = NoSuchPaddingException.class, timeout=120000)
-  public void testInvalidPadding() throws Exception {
-    Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-
-    try {
-      Openssl cipher = Openssl.getInstance("AES/CTR/NoPadding2");
-      Assert.fail("Should specify correct padding.");
-    } catch (NoSuchPaddingException e) {
-      Assert.assertTrue(e.getMessage().contains("Doesn't support padding: NoPadding2"));
-      throw e;
-    }
-  }
-
-  @Test(expected = NoSuchAlgorithmException.class, timeout=120000)
-  public void testInvalidMode() throws Exception {
-    try {
-      Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-      Openssl cipher = Openssl.getInstance("AES/CTR2/NoPadding");
-      Assert.fail("java.security.NoSuchAlgorithmException should be thrown.");
-    } catch (NoSuchAlgorithmException e) {
-      Assert.assertTrue(e.getMessage().contains("Doesn't support algorithm: AES and mode: CTR2"));
-      throw e;
-    }
-  }
-
-  @Test(timeout=120000)
-  public void testUpdateArguments() throws Exception {
-    Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-    Openssl cipher = Openssl.getInstance(CipherTransformation.AES_CTR_NOPADDING.getName());
-    Assert.assertNotNull(cipher);
-
-    cipher.init(Openssl.ENCRYPT_MODE, KEY, IV);
-
-    // Require direct buffers
-    ByteBuffer input = ByteBuffer.allocate(1024);
-    ByteBuffer output = ByteBuffer.allocate(1024);
-
-    try {
-      cipher.update(input, output);
-      Assert.fail("Input and output buffer should be direct buffer.");
-    } catch (IllegalArgumentException e) {
-      Assert.assertTrue(e.getMessage().contains("Direct buffers are required"));
-    }
-
-    // Output buffer length should be sufficient to store output data
-    input = ByteBuffer.allocateDirect(1024);
-    output = ByteBuffer.allocateDirect(1000);
-    try {
-      cipher.update(input, output);
-      Assert.fail("Output buffer length should be sufficient " +
-          "to store output data");
-    } catch (ShortBufferException e) {
-      Assert.assertTrue(e.getMessage().contains("Output buffer is not sufficient"));
-    }
-  }
-
-  @Test(timeout=120000)
-  public void testDoFinalArguments() throws Exception {
-    Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-    Openssl cipher = Openssl.getInstance(CipherTransformation.AES_CTR_NOPADDING.getName());
-    Assert.assertNotNull(cipher);
-
-    cipher.init(Openssl.ENCRYPT_MODE, KEY, IV);
-
-    // Require direct buffer
-    ByteBuffer output = ByteBuffer.allocate(1024);
-
-    try {
-      cipher.doFinal(output);
-      Assert.fail("Output buffer should be direct buffer.");
-    } catch (IllegalArgumentException e) {
-      Assert.assertTrue(e.getMessage().contains("Direct buffer is required"));
-    }
-  }
-
-  @Test(expected = InvalidKeyException.class, timeout=120000)
-  public void testInvalidKey() throws Exception {
-    Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-    Openssl cipher = Openssl.getInstance(CipherTransformation.AES_CTR_NOPADDING.getName());
-    Assert.assertNotNull(cipher);
-
-    final byte[] invalidKey = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-            0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x11};
-    try {
-      cipher.init(Openssl.ENCRYPT_MODE, invalidKey, IV);
-      Assert.fail("java.security.InvalidKeyException should be thrown.");
-    } catch (Exception e) {
-      Assert.assertTrue(e.getMessage().contains("Invalid key length."));
-      throw e;
-    }
-  }
-
-  @Test(expected = InvalidAlgorithmParameterException.class, timeout=120000)
-  public void testInvalidIV() throws Exception {
-    Assume.assumeTrue(Openssl.getLoadingFailureReason() == null);
-    Openssl cipher = Openssl.getInstance(CipherTransformation.AES_CTR_NOPADDING.getName());
-    Assert.assertNotNull(cipher);
-
-    final byte[] invalidIV = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
-            0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x11};
-    try {
-      cipher.init(Openssl.ENCRYPT_MODE, KEY, invalidIV);
-      Assert.fail("java.security.InvalidAlgorithmParameterException should be thrown.");
-    } catch (Exception e) {
-      Assert.assertTrue(e.getMessage().contains("Wrong IV length."));
-      throw e;
-    }
-  }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/cipher/TestData.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/cipher/TestData.java b/src/test/java/com/intel/chimera/cipher/TestData.java
deleted file mode 100644
index 322ef17..0000000
--- a/src/test/java/com/intel/chimera/cipher/TestData.java
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.cipher;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public class TestData {
-
-  private static String[] CBCNoPaddingTests = {
-      /*
-       * key_len,key,iv,plainText,cipherText
-       */
-      "128",
-      "2b7e151628aed2a6abf7158809cf4f3c",
-      "000102030405060708090a0b0c0d0e0f",
-      "6bc1bee22e409f96e93d7e117393172a",
-      "7649abac8119b246cee98e9b12e9197d",
-
-      "128",
-      "2b7e151628aed2a6abf7158809cf4f3c",
-      "7649ABAC8119B246CEE98E9B12E9197D",
-      "ae2d8a571e03ac9c9eb76fac45af8e51",
-      "5086cb9b507219ee95db113a917678b2",
-
-      "192",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d7",
-      "9CFC4E967EDB808D679F777BC6702C7D",
-      "30c81c46a35ce411e5fbc1191a0a52ef",
-      "78C57E3F543A18F472756DAC2F018523",
-
-      "192",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d7",
-      "39F23369A9D9BACFA530E26304231461",
-      "f69f2445df4f9b17ad2b417be66c3710",
-      "79ECA9610F0B9AAFB8C7C2D655047A41",
-
-      "256",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
-      "000102030405060708090a0b0c0d0e0f",
-      "6bc1bee22e409f96e93d7e117393172a",
-      "f58c4c04d6e5f1ba779eabfb5f7bfbd6",
-
-      "256",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
-      "F58C4C04D6E5F1BA779EABFB5F7BFBD6",
-      "ae2d8a571e03ac9c9eb76fac45af8e51",
-      "9cfc4e967edb808d679f777bc6702c7d"
-  };
-
-  private static String[] CBCPKCS5PaddingTests = {
-      /*
-       * key_len,key,iv,plainText,cipherText
-       */
-      //Test#0 for input of 6 bytes
-      "128",
-      "ac5800ac3cb59c7c14f36019e43b44fe",
-      "f013ce1ec901b5b60a85a986b3b72eba",
-      "f6cee5ff28fd",
-      "e8a846fd9718507371604504d4ca1ac7",
-
-      //Test#0 for input of 15 bytes
-      "128",
-      "0784fa652e733cb699f250b0df2c4b41",
-      "106519760fb3ef97e1ccea073b27122d",
-      "6842455a2992c2e5193056a5524075",
-      "56a8e0c3ee3315f913693c0ca781e917",
-
-      //Test#0 for input of 16 bytes
-      "128",
-      "04952c3fcf497a4d449c41e8730c5d9a",
-      "53549bf7d5553b727458c1abaf0ba167",
-      "c9a44f6f75e98ddbca7332167f5c45e3",
-      "7fa290322ca7a1a04b61a1147ff20fe66fde58510a1d0289d11c0ddf6f4decfd",
-
-      //Test#0 for input of 32 bytes
-      "128",
-      "2ae7081caebe54909820620a44a60a0f",
-      "fc5e783fbe7be12f58b1f025d82ada50",
-      "1ba93ee6f83752df47909585b3f28e56693f89e169d3093eee85175ea3a46cd3",
-      "7944957a99e473e2c07eb496a83ec4e55db2fb44ebdd42bb611e0def29b23a73ac37eb0f4f5d86f090f3ddce3980425a",
-
-      //Test#0 for input of 33 bytes
-      "128",
-      "898be9cc5004ed0fa6e117c9a3099d31",
-      "9dea7621945988f96491083849b068df",
-      "0397f4f6820b1f9386f14403be5ac16e50213bd473b4874b9bcbf5f318ee686b1d",
-      "e232cd6ef50047801ee681ec30f61d53cfd6b0bca02fd03c1b234baa10ea82ac9dab8b960926433a19ce6dea08677e34"};
-
-  private static String[] cipherCTRTests = {
-      /*
-       * key_len,key,iv,plainText,cipherText
-       */
-      "128",
-      "2b7e151628aed2a6abf7158809cf4f3c",
-      "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
-      "6bc1bee22e409f96e93d7e117393172a",
-      "874d6191b620e3261bef6864990db6ce",
-
-      "128",
-      "2b7e151628aed2a6abf7158809cf4f3c",
-      "f0f1f2f3f4f5f6f7f8f9fafbfcfdff00",
-      "ae2d8a571e03ac9c9eb76fac45af8e51",
-      "9806f66b7970fdff8617187bb9fffdff",
-
-      //Test for input of 15 bytes
-      "128",
-      "2b7e151628aed2a6abf7158809cf4f3c",
-      "f0f1f2f3f4f5f6f7f8f9fafbfcfdff01",
-      "30c81c46a35ce411e5fbc1191a0a52",
-      "5ae4df3edbd5d35e5b4f09020db03e",
-
-      "256",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
-      "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
-      "6bc1bee22e409f96e93d7e117393172a",
-      "601ec313775789a5b7a7f504bbf3d228",
-
-      "256",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
-      "f0f1f2f3f4f5f6f7f8f9fafbfcfdff00",
-      "ae2d8a571e03ac9c9eb76fac45af8e51",
-      "f443e3ca4d62b59aca84e990cacaf5c5",
-
-      //Test for input of 15 bytes
-      "256",
-      "603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
-      "f0f1f2f3f4f5f6f7f8f9fafbfcfdff01",
-      "30c81c46a35ce411e5fbc1191a0a52",
-      "2b0930daa23de94ce87017ba2d8498" };
-
-    private static Map<CipherTransformation, String[]> testData =
-        new HashMap<CipherTransformation, String[]>();
-
-    static {
-        testData.put(CipherTransformation.AES_CBC_NOPADDING, CBCNoPaddingTests);
-        testData.put(CipherTransformation.AES_CBC_PKCS5PADDING,
-            CBCPKCS5PaddingTests);
-        testData.put(CipherTransformation.AES_CTR_NOPADDING, cipherCTRTests);
-    }
-
-    public static String[] getTestData(CipherTransformation transformation) {
-        return testData.get(transformation);
-    }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/random/AbstractRandomTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/random/AbstractRandomTest.java b/src/test/java/com/intel/chimera/random/AbstractRandomTest.java
deleted file mode 100644
index f6ee70c..0000000
--- a/src/test/java/com/intel/chimera/random/AbstractRandomTest.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.random;
-
-import java.io.IOException;
-import java.util.Arrays;
-
-import org.junit.Test;
-
-public abstract class AbstractRandomTest {
-
-  public abstract SecureRandom getSecureRandom() throws IOException;
-
-  @Test(timeout=120000)
-  public void testRandomBytes() throws Exception {
-    SecureRandom random = getSecureRandom();
-    // len = 16
-    checkRandomBytes(random, 16);
-    // len = 32
-    checkRandomBytes(random, 32);
-    // len = 128
-    checkRandomBytes(random, 128);
-    // len = 256
-    checkRandomBytes(random, 256);
-    random.close();
-  }
-
-  /**
-   * Test will timeout if secure random implementation always returns a
-   * constant value.
-   */
-  private void checkRandomBytes(SecureRandom random, int len) {
-    byte[] bytes = new byte[len];
-    byte[] bytes1 = new byte[len];
-    random.nextBytes(bytes);
-    random.nextBytes(bytes1);
-
-    while (Arrays.equals(bytes, bytes1)) {
-      random.nextBytes(bytes1);
-    }
-  }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/random/TestJavaSecureRandom.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/random/TestJavaSecureRandom.java b/src/test/java/com/intel/chimera/random/TestJavaSecureRandom.java
deleted file mode 100644
index 154e884..0000000
--- a/src/test/java/com/intel/chimera/random/TestJavaSecureRandom.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.random;
-
-import java.io.IOException;
-import java.util.Properties;
-
-import com.intel.chimera.conf.ConfigurationKeys;
-import static junit.framework.Assert.fail;
-
-public class TestJavaSecureRandom extends AbstractRandomTest {
-
-  @Override
-  public SecureRandom getSecureRandom() throws IOException {
-    Properties props = new Properties();
-    props.setProperty(ConfigurationKeys.CHIMERA_CRYPTO_SECURE_RANDOM_CLASSES_KEY,
-        JavaSecureRandom.class.getName());
-    SecureRandom random = SecureRandomFactory.getSecureRandom(props);
-    if ( !(random instanceof JavaSecureRandom)) {
-      fail("The SecureRandom should be: " + JavaSecureRandom.class.getName());
-    }
-    return random;
-  }
-
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/random/TestOpensslSecureRandom.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/random/TestOpensslSecureRandom.java b/src/test/java/com/intel/chimera/random/TestOpensslSecureRandom.java
deleted file mode 100644
index 07edca5..0000000
--- a/src/test/java/com/intel/chimera/random/TestOpensslSecureRandom.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.random;
-
-import java.io.IOException;
-import java.util.Properties;
-
-import com.intel.chimera.conf.ConfigurationKeys;
-import static junit.framework.Assert.fail;
-
-public class TestOpensslSecureRandom extends AbstractRandomTest {
-
-  @Override
-  public SecureRandom getSecureRandom() throws IOException {
-    Properties props = new Properties();
-    props.setProperty(ConfigurationKeys.CHIMERA_CRYPTO_SECURE_RANDOM_CLASSES_KEY,
-        OpensslSecureRandom.class.getName());
-    SecureRandom random = SecureRandomFactory.getSecureRandom(props);
-    if ( !(random instanceof OpensslSecureRandom)) {
-      fail("The SecureRandom should be: " + OpensslSecureRandom.class.getName());
-    }
-    return random;
-  }
-
-}
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/random/TestOsSecureRandom.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/random/TestOsSecureRandom.java b/src/test/java/com/intel/chimera/random/TestOsSecureRandom.java
deleted file mode 100644
index 2eb9bf1..0000000
--- a/src/test/java/com/intel/chimera/random/TestOsSecureRandom.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.random;
-
-import java.io.IOException;
-import java.util.Properties;
-
-public class TestOsSecureRandom extends AbstractRandomTest{
-
-  @Override
-  public SecureRandom getSecureRandom() throws IOException {
-    return new OsSecureRandom(new Properties());
-  }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/stream/AbstractCryptoStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/stream/AbstractCryptoStreamTest.java b/src/test/java/com/intel/chimera/stream/AbstractCryptoStreamTest.java
deleted file mode 100644
index 2512366..0000000
--- a/src/test/java/com/intel/chimera/stream/AbstractCryptoStreamTest.java
+++ /dev/null
@@ -1,456 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.stream;
-
-import java.io.BufferedInputStream;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.nio.ByteBuffer;
-import java.nio.channels.Channels;
-import java.nio.channels.ReadableByteChannel;
-import java.security.SecureRandom;
-import java.util.Properties;
-import java.util.Random;
-
-import com.intel.chimera.cipher.Cipher;
-import com.intel.chimera.cipher.CipherTransformation;
-import com.intel.chimera.cipher.JceCipher;
-import com.intel.chimera.cipher.Openssl;
-import com.intel.chimera.cipher.OpensslCipher;
-import com.intel.chimera.utils.ReflectionUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-public abstract class AbstractCryptoStreamTest {
-  private static final Log LOG= LogFactory.getLog(AbstractCryptoStreamTest.class);
-
-  private final int dataLen = 20000;
-  private byte[] data = new byte[dataLen];
-  private byte[] encData;
-  private Properties props = new Properties();
-  protected byte[] key = new byte[16];
-  private byte[] iv = new byte[16];
-  private int count = 10000;
-  protected static int defaultBufferSize = 8192;
-  protected static int smallBufferSize = 1024;
-
-  private final String jceCipherClass = JceCipher.class.getName();
-  private final String opensslCipherClass = OpensslCipher.class.getName();
-  protected CipherTransformation transformation;
-
-  public abstract void setUp() throws IOException;
-
-  @Before
-  public void before() throws IOException {
-    Random random = new SecureRandom();
-    random.nextBytes(data);
-    random.nextBytes(key);
-    random.nextBytes(iv);
-    setUp();
-    prepareData();
-  }
-
-  /** Test skip. */
-  @Test(timeout=120000)
-  public void testSkip() throws Exception {
-    doSkipTest(jceCipherClass, false);
-    doSkipTest(opensslCipherClass, false);
-
-    doSkipTest(jceCipherClass, true);
-    doSkipTest(opensslCipherClass, true);
-  }
-
-  /** Test byte buffer read with different buffer size. */
-  @Test(timeout=120000)
-  public void testByteBufferRead() throws Exception {
-    doByteBufferRead(jceCipherClass, false);
-    doByteBufferRead(opensslCipherClass, false);
-
-    doByteBufferRead(jceCipherClass, true);
-    doByteBufferRead(opensslCipherClass, true);
-  }
-
-  /** Test byte buffer write. */
-  @Test(timeout=120000)
-  public void testByteBufferWrite() throws Exception {
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    doByteBufferWrite(jceCipherClass, baos, false);
-    doByteBufferWrite(opensslCipherClass, baos, false);
-
-    doByteBufferWrite(jceCipherClass, baos, true);
-    doByteBufferWrite(opensslCipherClass, baos, true);
-  }
-
-  private void doSkipTest(String cipherClass, boolean withChannel) throws IOException {
-    InputStream in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), defaultBufferSize, iv, withChannel);
-    byte[] result = new byte[dataLen];
-    int n1 = readAll(in, result, 0, dataLen / 3);
-
-    long skipped = in.skip(dataLen / 3);
-    int n2 = readAll(in, result, 0, dataLen);
-
-    Assert.assertEquals(dataLen, n1 + skipped + n2);
-    byte[] readData = new byte[n2];
-    System.arraycopy(result, 0, readData, 0, n2);
-    byte[] expectedData = new byte[n2];
-    System.arraycopy(data, dataLen - n2, expectedData, 0, n2);
-    Assert.assertArrayEquals(readData, expectedData);
-
-    try {
-      skipped = in.skip(-3);
-      Assert.fail("Skip Negative length should fail.");
-    } catch (IllegalArgumentException e) {
-      Assert.assertTrue(e.getMessage().contains("Negative skip length"));
-    }
-
-    // Skip after EOF
-    skipped = in.skip(3);
-    Assert.assertEquals(skipped, 0);
-
-    in.close();
-  }
-
-  private void doByteBufferRead(String cipherClass, boolean withChannel) throws Exception {
-    // Default buffer size, initial buffer position is 0
-    InputStream in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), defaultBufferSize, iv, withChannel);
-    ByteBuffer buf = ByteBuffer.allocate(dataLen + 100);
-    byteBufferReadCheck(in, buf, 0);
-    in.close();
-
-    // Default buffer size, initial buffer position is not 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), defaultBufferSize, iv, withChannel);
-    buf.clear();
-    byteBufferReadCheck(in, buf, 11);
-    in.close();
-
-    // Small buffer size, initial buffer position is 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), smallBufferSize, iv, withChannel);
-    buf.clear();
-    byteBufferReadCheck(in, buf, 0);
-    in.close();
-
-    // Small buffer size, initial buffer position is not 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), smallBufferSize, iv, withChannel);
-    buf.clear();
-    byteBufferReadCheck(in, buf, 11);
-    in.close();
-
-    // Direct buffer, default buffer size, initial buffer position is 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), defaultBufferSize, iv, withChannel);
-    buf = ByteBuffer.allocateDirect(dataLen + 100);
-    byteBufferReadCheck(in, buf, 0);
-    in.close();
-
-    // Direct buffer, default buffer size, initial buffer position is not 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), defaultBufferSize, iv, withChannel);
-    buf.clear();
-    byteBufferReadCheck(in, buf, 11);
-    in.close();
-
-    // Direct buffer, small buffer size, initial buffer position is 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), smallBufferSize, iv, withChannel);
-    buf.clear();
-    byteBufferReadCheck(in, buf, 0);
-    in.close();
-
-    // Direct buffer, small buffer size, initial buffer position is not 0
-    in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), smallBufferSize, iv, withChannel);
-    buf.clear();
-    byteBufferReadCheck(in, buf, 11);
-    in.close();
-  }
-
-  private void doByteBufferWrite(String cipherClass, ByteArrayOutputStream baos,
-                                 boolean withChannel)
-      throws Exception {
-    baos.reset();
-    CryptoOutputStream out =
-        getCryptoOutputStream(baos, getCipher(cipherClass), defaultBufferSize,
-            iv, withChannel);
-    ByteBuffer buf = ByteBuffer.allocateDirect(dataLen / 2);
-    buf.put(data, 0, dataLen / 2);
-    buf.flip();
-    int n1 = out.write(buf);
-
-    buf.clear();
-    buf.put(data, n1, dataLen / 3);
-    buf.flip();
-    int n2 = out.write(buf);
-
-    buf.clear();
-    buf.put(data, n1 + n2, dataLen - n1 - n2);
-    buf.flip();
-    int n3 = out.write(buf);
-
-    Assert.assertEquals(dataLen, n1 + n2 + n3);
-
-    out.flush();
-
-    InputStream in = getCryptoInputStream(new ByteArrayInputStream(encData),
-        getCipher(cipherClass), defaultBufferSize, iv, withChannel);
-    buf = ByteBuffer.allocate(dataLen + 100);
-    byteBufferReadCheck(in, buf, 0);
-    in.close();
-  }
-
-  private void byteBufferReadCheck(InputStream in, ByteBuffer buf,
-      int bufPos) throws Exception {
-    buf.position(bufPos);
-    int n = ((ReadableByteChannel) in).read(buf);
-    Assert.assertEquals(bufPos + n, buf.position());
-    byte[] readData = new byte[n];
-    buf.rewind();
-    buf.position(bufPos);
-    buf.get(readData);
-    byte[] expectedData = new byte[n];
-    System.arraycopy(data, 0, expectedData, 0, n);
-    Assert.assertArrayEquals(readData, expectedData);
-  }
-
-  private void prepareData() throws IOException {
-    Cipher cipher = null;
-    try {
-      cipher = (Cipher)ReflectionUtils.newInstance(
-          ReflectionUtils.getClassByName(jceCipherClass), props, transformation);
-    } catch (ClassNotFoundException cnfe) {
-      throw new IOException("Illegal crypto cipher!");
-    }
-
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    OutputStream out = new CryptoOutputStream(baos, cipher, defaultBufferSize, key, iv);
-    out.write(data);
-    out.flush();
-    out.close();
-    encData = baos.toByteArray();
-  }
-
-  protected CryptoInputStream getCryptoInputStream(ByteArrayInputStream bais,
-                                                   Cipher cipher,
-                                                   int bufferSize, byte[] iv,
-                                                   boolean withChannel) throws
-      IOException {
-    if (withChannel) {
-      return new CryptoInputStream(Channels.newChannel(bais), cipher,
-          bufferSize, key, iv);
-    } else {
-      return new CryptoInputStream(bais, cipher, bufferSize, key, iv);
-    }
-  }
-
-  protected CryptoOutputStream getCryptoOutputStream(ByteArrayOutputStream baos,
-                                                   Cipher cipher,
-                                                   int bufferSize, byte[] iv,
-                                                   boolean withChannel) throws
-      IOException {
-    if (withChannel) {
-      return new CryptoOutputStream(Channels.newChannel(baos), cipher,
-          bufferSize, key, iv);
-    } else {
-      return new CryptoOutputStream(baos, cipher, bufferSize, key, iv);
-    }
-  }
-
-  private int readAll(InputStream in, byte[] b, int offset, int len)
-      throws IOException {
-    int n = 0;
-    int total = 0;
-    while (n != -1) {
-      total += n;
-      if (total >= len) {
-        break;
-      }
-      n = in.read(b, offset + total, len - total);
-    }
-
-    return total;
-  }
-
-  protected Cipher getCipher(String cipherClass) throws IOException {
-    try {
-      return (Cipher)ReflectionUtils.newInstance(
-          ReflectionUtils.getClassByName(cipherClass), props, transformation);
-    } catch (ClassNotFoundException cnfe) {
-      throw new IOException("Illegal crypto cipher!");
-    }
-  }
-
-  @Test
-  public void testReadWrite() throws Exception {
-    Assert.assertEquals(null, Openssl.getLoadingFailureReason());
-    doReadWriteTest(0, jceCipherClass, jceCipherClass, iv);
-    doReadWriteTest(0, opensslCipherClass, opensslCipherClass, iv);
-    doReadWriteTest(count, jceCipherClass, jceCipherClass, iv);
-    doReadWriteTest(count, opensslCipherClass, opensslCipherClass, iv);
-    doReadWriteTest(count, jceCipherClass, opensslCipherClass, iv);
-    doReadWriteTest(count, opensslCipherClass, jceCipherClass, iv);
-    // Overflow test, IV: xx xx xx xx xx xx xx xx ff ff ff ff ff ff ff ff
-    for(int i = 0; i < 8; i++) {
-      iv[8 + i] = (byte) 0xff;
-    }
-    doReadWriteTest(count, jceCipherClass, jceCipherClass, iv);
-    doReadWriteTest(count, opensslCipherClass, opensslCipherClass, iv);
-    doReadWriteTest(count, jceCipherClass, opensslCipherClass, iv);
-    doReadWriteTest(count, opensslCipherClass, jceCipherClass, iv);
-  }
-
-  private void doReadWriteTest(int count, String encCipherClass,
-                               String decCipherClass, byte[] iv) throws IOException {
-    doReadWriteTestForInputStream(count, encCipherClass, decCipherClass, iv);
-    doReadWriteTestForReadableByteChannel(count, encCipherClass, decCipherClass,
-        iv);
-  }
-
-  private void doReadWriteTestForInputStream(int count, String encCipherClass,
-                                             String decCipherClass, byte[] iv) throws IOException {
-    Cipher encCipher = getCipher(encCipherClass);
-    LOG.debug("Created a cipher object of type: " + encCipherClass);
-
-    // Generate data
-    SecureRandom random = new SecureRandom();
-    byte[] originalData = new byte[count];
-    byte[] decryptedData = new byte[count];
-    random.nextBytes(originalData);
-    LOG.debug("Generated " + count + " records");
-
-    // Encrypt data
-    ByteArrayOutputStream encryptedData = new ByteArrayOutputStream();
-    CryptoOutputStream out =
-        getCryptoOutputStream(encryptedData, encCipher, defaultBufferSize, iv,
-            false);
-    out.write(originalData, 0, originalData.length);
-    out.flush();
-    out.close();
-    LOG.debug("Finished encrypting data");
-
-    Cipher decCipher = getCipher(decCipherClass);
-    LOG.debug("Created a cipher object of type: " + decCipherClass);
-
-    // Decrypt data
-    CryptoInputStream in = getCryptoInputStream(
-        new ByteArrayInputStream(encryptedData.toByteArray()), decCipher,
-        defaultBufferSize, iv, false);
-
-    // Check
-    int remainingToRead = count;
-    int offset = 0;
-    while (remainingToRead > 0) {
-      int n = in.read(decryptedData, offset, decryptedData.length - offset);
-      if (n >=0) {
-        remainingToRead -= n;
-        offset += n;
-      }
-    }
-
-    Assert.assertArrayEquals("originalData and decryptedData not equal",
-        originalData, decryptedData);
-
-    // Decrypt data byte-at-a-time
-    in = getCryptoInputStream(
-        new ByteArrayInputStream(encryptedData.toByteArray()), decCipher,
-        defaultBufferSize, iv, false);
-
-    // Check
-    DataInputStream originalIn = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(originalData)));
-    int expected;
-    do {
-      expected = originalIn.read();
-      Assert.assertEquals("Decrypted stream read by byte does not match",
-          expected, in.read());
-    } while (expected != -1);
-
-    LOG.debug("SUCCESS! Completed checking " + count + " records");
-  }
-
-  private void doReadWriteTestForReadableByteChannel(int count,
-                                                     String encCipherClass,
-                                                     String decCipherClass,
-                                                     byte[] iv) throws IOException {
-    Cipher encCipher = getCipher(encCipherClass);
-    LOG.debug("Created a cipher object of type: " + encCipherClass);
-
-    // Generate data
-    SecureRandom random = new SecureRandom();
-    byte[] originalData = new byte[count];
-    byte[] decryptedData = new byte[count];
-    random.nextBytes(originalData);
-    LOG.debug("Generated " + count + " records");
-
-    // Encrypt data
-    ByteArrayOutputStream encryptedData = new ByteArrayOutputStream();
-    CryptoOutputStream out =
-        getCryptoOutputStream(encryptedData, encCipher, defaultBufferSize, iv,
-            true);
-    out.write(originalData, 0, originalData.length);
-    out.flush();
-    out.close();
-    LOG.debug("Finished encrypting data");
-
-    Cipher decCipher = getCipher(decCipherClass);
-    LOG.debug("Created a cipher object of type: " + decCipherClass);
-
-    // Decrypt data
-    CryptoInputStream in = getCryptoInputStream(
-        new ByteArrayInputStream(encryptedData.toByteArray()), decCipher,
-        defaultBufferSize, iv, true);
-
-    // Check
-    int remainingToRead = count;
-    int offset = 0;
-    while (remainingToRead > 0) {
-      int n = in.read(decryptedData, offset, decryptedData.length - offset);
-      if (n >=0) {
-        remainingToRead -= n;
-        offset += n;
-      }
-    }
-
-    Assert.assertArrayEquals("originalData and decryptedData not equal",
-        originalData, decryptedData);
-
-    // Decrypt data byte-at-a-time
-    in = getCryptoInputStream(new ByteArrayInputStream(
-        encryptedData.toByteArray()),decCipher,defaultBufferSize,iv,true);
-
-    // Check
-    DataInputStream originalIn = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(originalData)));
-    int expected;
-    do {
-      expected = originalIn.read();
-      Assert.assertEquals("Decrypted stream read by byte does not match",
-          expected, in.read());
-    } while (expected != -1);
-
-    LOG.debug("SUCCESS! Completed checking " + count + " records");
-  }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/stream/CBCNoPaddingCryptoStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/stream/CBCNoPaddingCryptoStreamTest.java b/src/test/java/com/intel/chimera/stream/CBCNoPaddingCryptoStreamTest.java
deleted file mode 100644
index b28922a..0000000
--- a/src/test/java/com/intel/chimera/stream/CBCNoPaddingCryptoStreamTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.stream;
-
-import java.io.IOException;
-
-import com.intel.chimera.cipher.CipherTransformation;
-
-public class CBCNoPaddingCryptoStreamTest extends AbstractCryptoStreamTest {
-
-  public void setUp() throws IOException {
-    transformation = CipherTransformation
-        .AES_CBC_NOPADDING;
-  }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/stream/CBCPKCS5PaddingCryptoStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/stream/CBCPKCS5PaddingCryptoStreamTest.java b/src/test/java/com/intel/chimera/stream/CBCPKCS5PaddingCryptoStreamTest.java
deleted file mode 100644
index ec494a0..0000000
--- a/src/test/java/com/intel/chimera/stream/CBCPKCS5PaddingCryptoStreamTest.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.stream;
-
-import java.io.IOException;
-
-import com.intel.chimera.cipher.CipherTransformation;
-
-public class CBCPKCS5PaddingCryptoStreamTest extends AbstractCryptoStreamTest {
-
-  public void setUp() throws IOException {
-    transformation = CipherTransformation
-        .AES_CBC_PKCS5PADDING;
-  }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/stream/CTRCryptoStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/stream/CTRCryptoStreamTest.java b/src/test/java/com/intel/chimera/stream/CTRCryptoStreamTest.java
deleted file mode 100644
index c46f736..0000000
--- a/src/test/java/com/intel/chimera/stream/CTRCryptoStreamTest.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.stream;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.nio.channels.Channels;
-
-import com.intel.chimera.cipher.Cipher;
-import com.intel.chimera.cipher.CipherTransformation;
-
-public class CTRCryptoStreamTest extends AbstractCryptoStreamTest {
-
-  public void setUp() throws IOException {
-    transformation = CipherTransformation
-        .AES_CTR_NOPADDING;
-  }
-
-  @Override
-  protected CTRCryptoInputStream getCryptoInputStream
-      (ByteArrayInputStream bais, Cipher cipher, int
-      bufferSize,byte[] iv, boolean withChannel)
-      throws IOException {
-    if (withChannel) {
-      return new CTRCryptoInputStream(Channels.newChannel(bais), cipher,
-          bufferSize, key, iv);
-    } else {
-      return new CTRCryptoInputStream(bais, cipher, bufferSize, key, iv);
-    }
-  }
-
-  @Override
-  protected CTRCryptoOutputStream getCryptoOutputStream(ByteArrayOutputStream baos,Cipher cipher, int
-      bufferSize,  byte[] iv, boolean withChannel)
-      throws IOException {
-    if (withChannel) {
-      return new CTRCryptoOutputStream(Channels.newChannel(baos), cipher, bufferSize, key, iv);
-    } else {
-      return new CTRCryptoOutputStream(baos, cipher, bufferSize, key, iv);
-    }
-  }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/stream/CTRNoPaddingCryptoStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/stream/CTRNoPaddingCryptoStreamTest.java b/src/test/java/com/intel/chimera/stream/CTRNoPaddingCryptoStreamTest.java
deleted file mode 100644
index f044cca..0000000
--- a/src/test/java/com/intel/chimera/stream/CTRNoPaddingCryptoStreamTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.stream;
-
-import java.io.IOException;
-
-import com.intel.chimera.cipher.CipherTransformation;
-
-public class CTRNoPaddingCryptoStreamTest extends AbstractCryptoStreamTest {
-
-  public void setUp() throws IOException {
-    transformation = CipherTransformation
-        .AES_CTR_NOPADDING;
-  }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/stream/PositionedCryptoInputStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/stream/PositionedCryptoInputStreamTest.java b/src/test/java/com/intel/chimera/stream/PositionedCryptoInputStreamTest.java
deleted file mode 100644
index eae4272..0000000
--- a/src/test/java/com/intel/chimera/stream/PositionedCryptoInputStreamTest.java
+++ /dev/null
@@ -1,381 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.intel.chimera.stream;
-
-import com.intel.chimera.cipher.Cipher;
-import com.intel.chimera.cipher.CipherTransformation;
-import com.intel.chimera.cipher.JceCipher;
-import com.intel.chimera.cipher.OpensslCipher;
-import com.intel.chimera.stream.input.Input;
-import com.intel.chimera.utils.ReflectionUtils;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.nio.ByteBuffer;
-import java.security.SecureRandom;
-import java.util.Arrays;
-import java.util.Properties;
-import java.util.Random;
-
-public class PositionedCryptoInputStreamTest {
-
-  private final int dataLen = 20000;
-  private byte[] testData = new byte[dataLen];
-  private byte[] encData;
-  private Properties props = new Properties();
-  private byte[] key = new byte[16];
-  private byte[] iv = new byte[16];
-  int bufferSize = 2048;
-  int bufferSizeLess = bufferSize - 1;
-  int bufferSizeMore = bufferSize + 1;
-  int length = 1024;
-  int lengthLess = length - 1;
-  int lengthMore = length + 1;
-
-  private final String jceCipherClass = JceCipher.class.getName();
-  private final String opensslCipherClass = OpensslCipher.class.getName();
-  private CipherTransformation transformation =
-                                CipherTransformation.AES_CTR_NOPADDING;
-
-  @Before
-  public void before() throws IOException {
-    Random random = new SecureRandom();
-    random.nextBytes(testData);
-    random.nextBytes(key);
-    random.nextBytes(iv);
-    prepareData();
-  }
-
-  private void prepareData() throws IOException {
-    Cipher cipher = null;
-    try {
-      cipher = (Cipher)ReflectionUtils.newInstance(
-              ReflectionUtils.getClassByName(jceCipherClass),
-              props, transformation);
-    } catch (ClassNotFoundException cnfe) {
-      throw new IOException("Illegal crypto cipher!");
-    }
-
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    // encryption data
-    OutputStream out = new CryptoOutputStream(baos, cipher, bufferSize, key, iv);
-    out.write(testData);
-    out.flush();
-    out.close();
-    encData = baos.toByteArray();
-  }
-
-  public void setUp() throws IOException {}
-
-  private PositionedCryptoInputStream getCryptoInputStream(Cipher cipher,
-      int bufferSize) throws IOException {
-    return new PositionedCryptoInputStream(new PositionedInputForTest(
-      Arrays.copyOf(encData, encData.length)), cipher, bufferSize, key, iv, 0);
-  }
-
-  @Test
-  public void doTest() throws Exception {
-    testCipher(jceCipherClass);
-    testCipher(opensslCipherClass);
-  }
-
-  private void testCipher(String cipherClass) throws Exception {
-    doPositionedReadTests(cipherClass);
-    doReadFullyTests(cipherClass);
-    doSeekTests(cipherClass);
-    doMultipleReadTest(cipherClass);
-  }
-
-  // when there are multiple positioned read actions and one read action,
-  // they will not interfere each other.
-  private void doMultipleReadTest(String cipherClass) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-    int position = 0;
-    while (in.available() > 0) {
-      ByteBuffer buf = ByteBuffer.allocate(length);
-      byte[] bytes1 = new byte[length];
-      byte[] bytes2 = new byte[lengthLess];
-      // do the read and position read
-      int pn1 = in.read(position, bytes1, 0, length);
-      int n = in.read(buf);
-      int pn2 = in.read(position, bytes2, 0, lengthLess);
-
-      // verify the result
-      if (pn1 > 0) {
-        compareByteArray(testData, position, bytes1, pn1);
-      }
-
-      if (pn2 > 0) {
-        compareByteArray(testData, position, bytes2, pn2);
-      }
-
-      if (n > 0) {
-        compareByteArray(testData, position, buf.array(), n);
-        position += n;
-      } else {
-        break;
-      }
-    }
-    in.close();
-  }
-
-  private void doPositionedReadTests(String cipherClass) throws Exception {
-    // test with different bufferSize when position = 0
-    testPositionedReadLoop(cipherClass, 0, length, bufferSize, dataLen);
-    testPositionedReadLoop(cipherClass, 0, length, bufferSizeLess, dataLen);
-    testPositionedReadLoop(cipherClass, 0, length, bufferSizeMore, dataLen);
-    // test with different position when bufferSize = 2048
-    testPositionedReadLoop(cipherClass, dataLen / 2, length, bufferSize, dataLen);
-    testPositionedReadLoop(cipherClass, dataLen / 2 - 1, length,
-            bufferSizeLess, dataLen);
-    testPositionedReadLoop(cipherClass, dataLen / 2 + 1, length,
-            bufferSizeMore, dataLen);
-    // position = -1 or position = max length, read nothing and return -1
-    testPositionedReadNone(cipherClass, -1, length, bufferSize);
-    testPositionedReadNone(cipherClass, dataLen, length, bufferSize);
-  }
-
-  private void doReadFullyTests(String cipherClass) throws Exception {
-    // test with different bufferSize when position = 0
-    testReadFullyLoop(cipherClass, 0, length, bufferSize, dataLen);
-    testReadFullyLoop(cipherClass, 0, length, bufferSizeLess, dataLen);
-    testReadFullyLoop(cipherClass, 0, length, bufferSizeMore, dataLen);
-    // test with different length when position = 0
-    testReadFullyLoop(cipherClass, 0, length, bufferSize, dataLen);
-    testReadFullyLoop(cipherClass, 0, lengthLess, bufferSize, dataLen);
-    testReadFullyLoop(cipherClass, 0, lengthMore, bufferSize, dataLen);
-    // test read fully failed
-    testReadFullyFailed(cipherClass, -1, length, bufferSize);
-    testReadFullyFailed(cipherClass, dataLen, length, bufferSize);
-    testReadFullyFailed(cipherClass, dataLen - length + 1, length, bufferSize);
-  }
-
-  private void doSeekTests(String cipherClass) throws Exception {
-    // test with different length when position = 0
-    testSeekLoop(cipherClass, 0, length, bufferSize);
-    testSeekLoop(cipherClass, 0, lengthLess, bufferSize);
-    testSeekLoop(cipherClass, 0, lengthMore, bufferSize);
-    // there should be none data read when position = dataLen
-    testSeekLoop(cipherClass, dataLen, length, bufferSize);
-    // test exception when position = -1
-    testSeekFailed(cipherClass, -1, bufferSize);
-  }
-
-  private void testSeekLoop(String cipherClass, int position, int length,
-      int bufferSize) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-    while (in.available() > 0) {
-      in.seek(position);
-      ByteBuffer buf = ByteBuffer.allocate(length);
-      int n = in.read(buf);
-      if (n > 0) {
-        compareByteArray(testData, position, buf.array(), n);
-        position += n;
-      } else {
-        break;
-      }
-    }
-    in.close();
-  }
-
-  // test for the out of index position, eg, -1.
-  private void testSeekFailed(String cipherClass, int position,
-      int bufferSize) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-    try {
-      in.seek(position);
-      Assert.fail("Excepted exception for cannot seek to negative offset.");
-    } catch (IllegalArgumentException iae) {
-    }
-    in.close();
-  }
-
-  private void testPositionedReadLoop(String cipherClass, int position,
-      int length, int bufferSize, int total) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-    // do the position read until the end of data
-    while (position < total) {
-      byte[] bytes = new byte[length];
-      int n = in.read(position, bytes, 0, length);
-      if (n >= 0) {
-        compareByteArray(testData, position, bytes, n);
-        position += n;
-      } else {
-        break;
-      }
-    }
-    in.close();
-  }
-
-  // test for the out of index position, eg, -1.
-  private void testPositionedReadNone(String cipherClass, int position,
-      int length, int bufferSize) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-    byte[] bytes = new byte[length];
-    int n = in.read(position, bytes, 0, length);
-    Assert.assertEquals(n, -1);
-    in.close();
-  }
-
-  private void testReadFullyLoop(String cipherClass,int position,
-      int length, int bufferSize, int total) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-
-    // do the position read full until remain < length
-    while (position + length <= total) {
-      byte[] bytes = new byte[length];
-      in.readFully(position, bytes, 0, length);
-      compareByteArray(testData, position, bytes, length);
-      position += length;
-    }
-
-    in.close();
-  }
-
-  // test for the End of file reached before reading fully
-  private void testReadFullyFailed(String cipherClass, int position,
-      int length, int bufferSize) throws Exception {
-    PositionedCryptoInputStream in = getCryptoInputStream(
-            getCipher(cipherClass), bufferSize);
-    byte[] bytes = new byte[length];
-    try {
-      in.readFully(position, bytes, 0, length);
-      Assert.fail("Excepted EOFException.");
-    } catch (IOException ioe) {
-      // excepted exception
-    }
-    in.close();
-  }
-
-  // compare the data from pos with length and data2 from 0 with length
-  private void compareByteArray(byte[] data1, int pos, byte[] data2, int length) {
-    byte[] expectedData = new byte[length];
-    byte[] realData = new byte[length];
-    // get the expected data with the position and length
-    System.arraycopy(data1, pos, expectedData, 0, length);
-    // get the real data
-    System.arraycopy(data2, 0, realData, 0, length);
-    Assert.assertArrayEquals(expectedData, realData);
-  }
-
-  private Cipher getCipher(String cipherClass) throws IOException {
-    try {
-      return (Cipher)ReflectionUtils.newInstance(
-          ReflectionUtils.getClassByName(cipherClass), props, transformation);
-    } catch (ClassNotFoundException cnfe) {
-      throw new IOException("Illegal crypto cipher!");
-    }
-  }
-
-  class PositionedInputForTest implements Input {
-
-    byte[] data;
-    long pos;
-    long count;
-
-    public PositionedInputForTest(byte[] data) {
-      this.data = data;
-      this.pos = 0;
-      this.count = data.length;
-    }
-
-    @Override
-    public int read(ByteBuffer dst) throws IOException {
-      int remaining = (int)(count - pos);
-      if(remaining <= 0) {
-        return -1;
-      }
-
-      int length = Math.min(dst.remaining(), remaining);
-      dst.put(data, (int)pos, length);
-      pos += length;
-      return length;
-    }
-
-    @Override
-    public long skip(long n) throws IOException {
-      if (n <= 0) {
-        return 0;
-      }
-
-      long remaining = count - pos;
-      if(remaining < n) {
-        n = remaining;
-      }
-      pos += n;
-
-      return n;
-    }
-
-    @Override
-    public int read(long position, byte[] buffer, int offset, int length)
-            throws IOException {
-      if (buffer == null) {
-        throw new NullPointerException();
-      } else if (offset < 0 || length < 0 || length > buffer.length - offset) {
-        throw new IndexOutOfBoundsException();
-      }
-
-      if (position < 0 || position >= count) {
-        return -1;
-      }
-
-      long avail = count - position;
-      if (length > avail) {
-        length = (int)avail;
-      }
-      if (length <= 0) {
-        return 0;
-      }
-      System.arraycopy(data, (int)position, buffer, offset, length);
-      return length;
-    }
-
-    @Override
-    public void seek(long position) throws IOException {
-      if (pos < 0) {
-        throw new IOException("Negative seek offset");
-      } else if (position >= 0 && position < count) {
-        pos = position;
-      } else {
-        // to the end of file
-        pos = count;
-      }
-    }
-
-    @Override
-    public void close() throws IOException {
-    }
-
-    @Override
-    public int available() throws IOException {
-      return (int)(count - pos);
-    }
-  }
-}

http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/4920d272/src/test/java/com/intel/chimera/utils/UtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/com/intel/chimera/utils/UtilsTest.java b/src/test/java/com/intel/chimera/utils/UtilsTest.java
deleted file mode 100644
index 8a905bb..0000000
--- a/src/test/java/com/intel/chimera/utils/UtilsTest.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.intel.chimera.utils;
-
-import junit.framework.Assert;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-public class UtilsTest {
-  @Test
-  public void testSplitOmitEmptyLine() {
-    List<String> clazzNames = Utils.splitClassNames("", ",");
-    Assert.assertEquals(Collections.<String>emptyList(), clazzNames);
-
-    clazzNames = Utils.splitClassNames("a,b", ",");
-    Assert.assertEquals(Arrays.asList("a", "b"), clazzNames);
-    clazzNames = Utils.splitClassNames("a,b,", ",");
-    Assert.assertEquals(Arrays.asList("a", "b"), clazzNames);
-    clazzNames = Utils.splitClassNames("a, b,", ",");
-    Assert.assertEquals(Arrays.asList("a", "b"), clazzNames);
-  }
-}


Mime
View raw message