/*

 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <jni.h>

#include <libsoftcrypto.h>

#include "nativeCrypto.h"

#include "nativeFunc.h"

/*

 * Dumps out byte array in hex with and name and length info

 */

void printBytes(char* header, unsigned char* bytes, int len) {

  int i;

  printf("%s", header);

  printf("len=%d {", len);

  for (i = 0; i < len; i++) {

    if (i > 0) printf(":");

    printf("%02X", bytes[i]);

  }

  printf("}\n");

}

/*

 * Throws java.lang.OutOfMemoryError

 */

void throwOutOfMemoryError(JNIEnv *env, const char *msg)

{

  jclass jExClass = (*env)->FindClass(env, "java/lang/OutOfMemoryError");

  if (jExClass != 0) /* Otherwise an exception has already been thrown */ {

    (*env)->ThrowNew(env, jExClass, msg);

  }

  /* free the local ref */

  (*env)->DeleteLocalRef(env, jExClass);

}

    return JNI_VERSION_1_4;

}

/*

 * Class:     com_oracle_security_ucrypto_UcryptoProvider

 * Method:    loadLibraries

 * Signature: ()[Z

 */

JNIEXPORT jbooleanArray JNICALL Java_com_oracle_security_ucrypto_UcryptoProvider_loadLibraries

(JNIEnv *env, jclass jcls) {

  jbooleanArray jResult;

  jboolean *result;

  jResult = (*env)->NewBooleanArray(env, 2);

  if (jResult != NULL) {

    result = loadNative();

    (*env)->SetBooleanArrayRegion(env, jResult, 0, 2, result);

    free(result);

  }

  return jResult;

}

/*

 * Class:     com_oracle_security_ucrypto_UcryptoProvider

 * Method:    getMechList

 * Signature: ()Ljava/lang/String;

 */

JNIEXPORT jstring JNICALL Java_com_oracle_security_ucrypto_UcryptoProvider_getMechList

(JNIEnv *env, jclass jcls) {

  jstring jResult;

  char* result;

  int length;

  jResult = NULL;

  if (ftab->ucryptoVersion != NULL && ftab->ucryptoGetMechList != NULL) {

      length = (*ftab->ucryptoGetMechList)(NULL);

      if (DEBUG) printf("mech list length: %d\n", length);

      result = malloc(length);

      if (result == NULL) {

        throwOutOfMemoryError(env, NULL);

        return NULL;

      }

      length = (*ftab->ucryptoGetMechList)(result);

      if (DEBUG) printf("mech list: %s\n", result);

      jResult = (*env)->NewStringUTF(env, result);

      free(result);

  } else {

      // version 0 on Solaris 10

      result = "CRYPTO_AES_ECB,CRYPTO_AES_CBC,CRYPTO_AES_CFB128,";

      jResult = (*env)->NewStringUTF(env, result);

  }

  return jResult;

}

/*

 * Utility function for throwing a UcryptoException when rv is not CRYPTO_OK(0)

 */

void throwUCExceptionUsingRV(JNIEnv *env, int rv) {

  jclass jExClass;

  jmethodID jConstructor;

  jthrowable jException;

  if ((*env)->ExceptionCheck(env)) return;

  jExClass = (*env)->FindClass(env, "com/oracle/security/ucrypto/UcryptoException");

  /* if jExClass is NULL, an exception has already been thrown */

  if (jExClass != NULL) {

    jConstructor = (*env)->GetMethodID(env, jExClass, "<init>", "(I)V");

    if (jConstructor != NULL) {

      jException = (jthrowable) (*env)->NewObject(env, jExClass, jConstructor, rv);

      if (jException != NULL) {

        (*env)->Throw(env, jException);

      }

    }

  }

  /* free the local ref */

  (*env)->DeleteLocalRef(env, jExClass);

}

/*

 * Utility function for duplicating a byte array from jbyteArray

 * If anything went wrong, no memory will be allocated.

 * NOTE: caller is responsible for freeing the allocated memory

 * once this method returned successfully.

 */

jbyte* getBytes(JNIEnv *env, jbyteArray bytes, int offset, int len) {

  jbyte* result = NULL;

  if (!(*env)->ExceptionCheck(env)) {

    result = (jbyte*) calloc(len, sizeof(char));

    if (result == NULL) {

      throwOutOfMemoryError(env, NULL);

      return NULL;

    }

    (*env)->GetByteArrayRegion(env, bytes, offset, len, result);

    if ((*env)->ExceptionCheck(env)) {

        // free allocated memory if error occurred

        free(result);

        return NULL;

    }

  }

  return result;

}

int

CipherInit(crypto_ctx_t *context, int encrypt, ucrypto_mech_t mech,

           unsigned char *jKey, int jKeyLen, unsigned char *jIv, int jIvLen,

           int tagLen, unsigned char *jAad, int jAadLen)

{

  int rv = 0;

  void *iv;

  size_t ivLen;

  if (DEBUG) printf("CipherInit: mech %i, key %i(%i), iv %i(%i) tagLen %i, aad %i(%i)\n",

                    mech, jKey, jKeyLen, jIv, jIvLen, tagLen, jAad, jAadLen);

  if (mech == CRYPTO_AES_CTR) {

    ivLen = sizeof(CK_AES_CTR_PARAMS);

    iv = (CK_AES_CTR_PARAMS*) malloc(ivLen);

    if (iv == NULL) return -1;

    ((CK_AES_CTR_PARAMS*)iv)->ulCounterBits = 32;

    memcpy(((CK_AES_CTR_PARAMS*)iv)->cb, jIv, 16);

  } else if (mech == CRYPTO_AES_GCM) {

    ivLen = sizeof(CK_AES_GCM_PARAMS);

    iv = (CK_AES_GCM_PARAMS*) malloc(ivLen);

    if (iv == NULL) return -1;

    ((CK_AES_GCM_PARAMS*)iv)->pIv = (uchar_t *)jIv;

    ((CK_AES_GCM_PARAMS*)iv)->ulIvLen = (ulong_t)jIvLen;

    ((CK_AES_GCM_PARAMS*)iv)->ulIvBits = 96;

    ((CK_AES_GCM_PARAMS*)iv)->pAAD = (uchar_t *)jAad;

    ((CK_AES_GCM_PARAMS*)iv)->ulAADLen = (ulong_t)jAadLen;

    ((CK_AES_GCM_PARAMS*)iv)->ulTagBits = (ulong_t)tagLen;

  } else {

    // normal bytes

    iv = jIv;

    ivLen = jIvLen;

  }

  if (encrypt) {

    rv = (*ftab->ucryptoEncryptInit)(context, mech, jKey, (size_t)jKeyLen, iv, ivLen);

    if (rv != 0 && DEBUG) printf("ucryptoEncryptInit: ret = 0x%x\n", rv);

  } else {

    rv =(*ftab->ucryptoDecryptInit)(context, mech, jKey, (size_t)jKeyLen, iv, ivLen);

    if (rv != 0 && DEBUG) printf("ucryptoDecryptInit: ret = 0x%x\n", rv);

  }

  if (iv != jIv) {

    if (mech == CRYPTO_AES_CTR) {

      free((CK_AES_CTR_PARAMS*)iv);

    } else {

      free((CK_AES_GCM_PARAMS*)iv);

    }

  }

  return rv;

}

int

CipherUpdate(crypto_ctx_t *context, int encrypt, unsigned char *bufIn, int inOfs,

             int inLen, unsigned char *bufOut, int outOfs, int *outLen)

{

  int rv = 0;

  size_t outLength;

  outLength = (size_t) *outLen;

  if (DEBUG) {

    printf("CipherUpdate: Inofs %i, InLen %i, OutOfs %i, OutLen %i\n", inOfs, inLen, outOfs, *outLen);

    printBytes("BufIn=", (unsigned char*)(bufIn+inOfs), inLen);

  }

  if (encrypt) {

    rv = (*ftab->ucryptoEncryptUpdate)(context, (unsigned char*)(bufIn+inOfs), (size_t)inLen, (unsigned char*)(bufOut+outOfs), &outLength);

    if (rv != 0) {

      if (DEBUG) printf("ucryptoEncryptUpdate: ret = 0x%x\n", rv);

    } else {

      *outLen = (int)outLength;

    }

  } else {

    rv = (*ftab->ucryptoDecryptUpdate)(context, (unsigned char*)(bufIn+inOfs), (size_t)inLen, (unsigned char*)(bufOut+outOfs), &outLength);

    if (rv != 0) {

      if (DEBUG) printf("ucryptoDecryptUpdate: ret = 0x%x\n", rv);

    } else {

      if (DEBUG) printBytes("BufOut=", (unsigned char*)(bufOut+outOfs), outLength);

      *outLen = (int)outLength;

    }

  }

  return rv;

}

int

CipherFinal(crypto_ctx_t *context, int encrypt, unsigned char *bufOut, int outOfs, int *outLen)

{

  int rv = 0;

  size_t outLength;

  outLength = (size_t)*outLen;

  if (DEBUG) printf("CipherFinal: OutOfs %i, outLen %i\n", outOfs, *outLen);

  if (encrypt) {

    rv = (*ftab->ucryptoEncryptFinal)(context, (unsigned char*)(bufOut+outOfs), &outLength);

    if (rv != 0) {

      if (DEBUG) printf("ucryptoDecryptFinal: ret = 0x%x\n", rv);

    } else {

      if (DEBUG) printBytes("BufOut=", (unsigned char*)(bufOut+outOfs), outLength);

      *outLen = (int)outLength;

    }

  } else {

    rv = (*ftab->ucryptoDecryptFinal)(context, (unsigned char*)(bufOut+outOfs), &outLength);

    if (rv != 0) {

      if (DEBUG) printf("ucryptoDecryptFinal: ret = 0x%x\n", rv);

    } else {

      if (DEBUG) printBytes("BufOut=", (unsigned char*)(bufOut+outOfs), outLength);

      *outLen = (int)outLength;

    }

  }

  return rv;

}

////////////////////////////////////////////////////////

// SPECIAL ENTRIES FOR JVM JNI-BYPASSING OPTIMIZATION

////////////////////////////////////////////////////////

jlong JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeInit(jint mech) {

  void *pContext = NULL;

  switch (mech) {

  case com_oracle_security_ucrypto_NativeDigest_MECH_SHA1:

    pContext = (SHA1_CTX *) malloc(sizeof(SHA1_CTX));

    if (pContext != NULL) {

      (*ftab->sha1Init)((SHA1_CTX *)pContext);

    }

    break;

  case com_oracle_security_ucrypto_NativeDigest_MECH_MD5:

    pContext = (MD5_CTX *) malloc(sizeof(MD5_CTX));

    if (pContext != NULL) {

      (*ftab->md5Init)((MD5_CTX *)pContext);

    }

    break;

  case com_oracle_security_ucrypto_NativeDigest_MECH_SHA256:

    pContext = (SHA2_CTX *) malloc(sizeof(SHA2_CTX));

    if (pContext != NULL) {

      (*ftab->sha2Init)(SHA256, (SHA2_CTX *)pContext);

    }

    break;

  case com_oracle_security_ucrypto_NativeDigest_MECH_SHA384:

    pContext = (SHA2_CTX *) malloc(sizeof(SHA2_CTX));

    if (pContext != NULL) {

      (*ftab->sha2Init)(SHA384, (SHA2_CTX *)pContext);

    }

    break;

  case com_oracle_security_ucrypto_NativeDigest_MECH_SHA512:

    pContext = (SHA2_CTX *) malloc(sizeof(SHA2_CTX));

    if (pContext != NULL) {

      (*ftab->sha2Init)(SHA512, (SHA2_CTX *)pContext);

    }

    break;

  default:

    if (DEBUG) printf("ERROR: Unsupported mech %i\n", mech);

  }

  return (jlong) pContext;

}

jint JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeUpdate

  (jint mech, jlong pContext, int notUsed, unsigned char* in, jint ofs, jint len) {

  if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {

    (*ftab->sha1Update)((SHA1_CTX*)pContext, (unsigned char*)(in+ofs), len);

  } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {

    (*ftab->md5Update)((MD5_CTX*)pContext, (unsigned char*)(in+ofs), len);

  } else { // SHA-2 family

    (*ftab->sha2Update)((SHA2_CTX*)pContext, (unsigned char*)(in+ofs), len);

  }

  return 0;

}

// Do digest and free the context immediately

jint JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeDigest

  (jint mech, jlong pContext, int notUsed, unsigned char* out, jint ofs, jint digestLen) {

  if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {

    (*ftab->sha1Final)((unsigned char*)(out + ofs), (SHA1_CTX *)pContext);

    free((SHA1_CTX *)pContext);

  } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {

    (*ftab->md5Final)((unsigned char*)(out + ofs), (MD5_CTX *)pContext);

    free((MD5_CTX *)pContext);

  } else { // SHA-2 family

    (*ftab->sha2Final)((unsigned char*)(out + ofs), (SHA2_CTX *)pContext);

    free((SHA2_CTX *)pContext);

  }

  return 0;

}

jlong JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeClone

  (jint mech, jlong pContext) {

  void *copy = NULL;

  size_t len = 0;

  if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {

    len = sizeof(SHA1_CTX);

  } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {

    len = sizeof(MD5_CTX);

  } else { // SHA-2 family

    len = sizeof(SHA2_CTX);

  }

  copy = (void*) malloc(len);

  if (copy != NULL) {

    bcopy((void *)pContext, copy, len);

  }

  return (jlong) copy;

}

void JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeFree

  (jint mech, jlong pContext) {

  if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {

    free((SHA1_CTX*) pContext);

  } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {

    free((MD5_CTX*) pContext);

  } else { // SHA-2 family

    free((SHA2_CTX*) pContext);

  }

}

// AES

jlong JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeInit

  (jint mech, jboolean encrypt, int keyLen, unsigned char* bufKey,

   int ivLen, unsigned char* bufIv, jint tagLen, int aadLen, unsigned char* bufAad) {

  crypto_ctx_t *context = NULL;

  int rv;

  context = malloc(sizeof(crypto_ctx_t));

  if (context != NULL) {

    rv = CipherInit(context, encrypt, (ucrypto_mech_t) mech, bufKey, keyLen,

                    bufIv, ivLen, tagLen, bufAad, aadLen);

    if (rv) {

      free(context);

      return 0L;

    }

  }

  return (jlong)context;

}

/*

 * Class:     com_oracle_security_ucrypto_NativeCipher

 * Method:    nativeUpdate

 * Signature: (JZ[BII[BI)I

 */

jint JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeUpdate

  (jlong pContext, jboolean encrypt, int notUsed, jbyte* bufIn, jint inOfs, jint inLen,

   int outCapacity, jbyte* bufOut, jint outOfs) {

  crypto_ctx_t *context;

  int rv = 0;

  int outLen = outCapacity - outOfs; // recalculate the real out length

  context = (crypto_ctx_t *) pContext;

  rv = CipherUpdate(context, encrypt, (unsigned char*)bufIn, inOfs, inLen, (unsigned char*)bufOut, outOfs, &outLen);

  if (rv) {

    free(context);

    context = 0;

    return -rv; // use negative value to indicate error!

  }

  return outLen;

}

/*

 * Class:     com_oracle_security_ucrypto_NativeCipher

 * Method:    nativeFinal

 * Signature: (JZ[BI)I

 */

jint JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeFinal

  (jlong pContext, jboolean encrypt, int outLen, jbyte* out, jint outOfs) {

  crypto_ctx_t *context;

  int rv = 0;

  unsigned char* bufOut = (unsigned char*) out;

  context = (crypto_ctx_t *) pContext;

  // Avoid null output buffer to workaround Solaris bug21481818 (fixed in S12)

  if (bufOut == NULL) {

    bufOut = (unsigned char*)(&outLen);

    outLen = 0;

  }

  rv = CipherFinal(context, encrypt, bufOut, outOfs, &outLen);

  free(context);

  if (rv) {

     return -rv; // use negative value to indicate error!

  }

  return outLen;

}

/*

 * Class:     com_oracle_security_ucrypto_NativeDigest

 * Method:    nativeInit

 * Signature: (I)J

 */

JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeInit

  (JNIEnv *env, jclass jcls, jint mech) {

  jlong result = JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeInit(mech);

  if (result == NULL) {

     throwOutOfMemoryError(env, NULL);

  }

  return result;

}

/*

 * Class:     com_oracle_security_ucrypto_NativeDigest

 * Method:    nativeUpdate

 * Signature: (IJ[BII)I

 */

JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeUpdate

  (JNIEnv *env, jclass jcls, jint mech, jlong pContext, jbyteArray jIn, jint jOfs, jint jLen) {

  unsigned char *bufIn;

  bufIn = (unsigned char *) getBytes(env, jIn, jOfs, jLen);

  if (!(*env)->ExceptionCheck(env)) {

    JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeUpdate(mech, pContext, jLen, bufIn, 0, jLen);

    free(bufIn);

  }

  return 0;

}

/*

 * Class:     com_oracle_security_ucrypto_NativeDigest

 * Method:    nativeDigest

 * Signature: (IJ[BII)I

 */

JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeDigest

  (JNIEnv *env, jclass jcls, jint mech, jlong pContext, jbyteArray jOut, jint jOutOfs, jint digestLen) {

  unsigned char *bufOut;

  bufOut = (unsigned char *) malloc(digestLen);

  if (bufOut == NULL) {

    throwOutOfMemoryError(env, NULL);

    return 0;

  }

  JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeDigest(mech, pContext, digestLen, bufOut, 0, digestLen);

  (*env)->SetByteArrayRegion(env, jOut, jOutOfs, digestLen, (jbyte *) bufOut);

  free(bufOut);

  return 0;

}

/*

 * Class:     com_oracle_security_ucrypto_NativeDigest

 * Method:    nativeClone

 * Signature: (IJ)J

 */

JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeClone

  (JNIEnv *env, jclass jcls, jint mech, jlong pContext) {

  return JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeClone(mech, pContext);

}

/*

 * Class:     com_oracle_security_ucrypto_NativeDigest

 * Method:    nativeFree

 * Signature: (IJ)V

 */

JNIEXPORT void JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeFree

  (JNIEnv *env, jclass jcls, jint mech, jlong pContext) {

  JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeFree(mech, pContext);

}