/*

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

 */

/* Copyright  (c) 2002 Graz University of Technology. All rights reserved.

 *

 * Redistribution and use in  source and binary forms, with or without

 * modification, are permitted  provided that the following conditions are met:

 *

 * 1. Redistributions of  source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *

 * 2. Redistributions in  binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *

 * 3. The end-user documentation included with the redistribution, if any, must

 *    include the following acknowledgment:

 *

 *    "This product includes software developed by IAIK of Graz University of

 *     Technology."

 *

 *    Alternately, this acknowledgment may appear in the software itself, if

 *    and wherever such third-party acknowledgments normally appear.

 *

 * 4. The names "Graz University of Technology" and "IAIK of Graz University of

 *    Technology" must not be used to endorse or promote products derived from

 *    this software without prior written permission.

 *

 * 5. Products derived from this software may not be called

 *    "IAIK PKCS Wrapper", nor may "IAIK" appear in their name, without prior

 *    written permission of Graz University of Technology.

 *

 *  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED

 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 *  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE LICENSOR BE

 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,

 *  OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,

 *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

 *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 *  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 *  POSSIBILITY  OF SUCH DAMAGE.

 */

#include "pkcs11wrapper.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

/* declare file private functions */

ModuleData * getModuleEntry(JNIEnv *env, jobject pkcs11Implementation);

int isModulePresent(JNIEnv *env, jobject pkcs11Implementation);

void removeAllModuleEntries(JNIEnv *env);

/* ************************************************************************** */

/* Functions for keeping track of currently active and loaded modules         */

/* ************************************************************************** */

/*

 * Create a new object for locking.

 */

jobject createLockObject(JNIEnv *env) {

    jclass jObjectClass;

    jobject jLockObject;

    jmethodID jConstructor;

    jObjectClass = (*env)->FindClass(env, "java/lang/Object");

    if (jObjectClass == NULL) { return NULL; }

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

    if (jConstructor == NULL) { return NULL; }

    jLockObject = (*env)->NewObject(env, jObjectClass, jConstructor);

    if (jLockObject == NULL) { return NULL; }

    jLockObject = (*env)->NewGlobalRef(env, jLockObject);

    return jLockObject ;

}

/*

 * Create a new object for locking.

 */

void destroyLockObject(JNIEnv *env, jobject jLockObject) {

    if (jLockObject != NULL) {

        (*env)->DeleteGlobalRef(env, jLockObject);

    }

}

/*

 * Add the given pkcs11Implementation object to the list of present modules.

 * Attach the given data to the entry. If the given pkcs11Implementation is

 * already in the lsit, just override its old module data with the new one.

 * None of the arguments can be NULL. If one of the arguments is NULL, this

 * function does nothing.

 */

void putModuleEntry(JNIEnv *env, jobject pkcs11Implementation, ModuleData *moduleData) {

    if (pkcs11Implementation == NULL_PTR) {

        return ;

    }

    if (moduleData == NULL) {

        return ;

    }

    (*env)->SetLongField(env, pkcs11Implementation, pNativeDataID, ptr_to_jlong(moduleData));

}

/*

 * Get the module data of the entry for the given pkcs11Implementation. Returns

 * NULL, if the pkcs11Implementation is not in the list.

 */

ModuleData * getModuleEntry(JNIEnv *env, jobject pkcs11Implementation) {

    jlong jData;

    if (pkcs11Implementation == NULL) {

        return NULL;

    }

    jData = (*env)->GetLongField(env, pkcs11Implementation, pNativeDataID);

    return (ModuleData*)jlong_to_ptr(jData);

}

CK_FUNCTION_LIST_PTR getFunctionList(JNIEnv *env, jobject pkcs11Implementation) {

    ModuleData *moduleData;

    CK_FUNCTION_LIST_PTR ckpFunctions;

    moduleData = getModuleEntry(env, pkcs11Implementation);

    if (moduleData == NULL) {

        throwDisconnectedRuntimeException(env);

        return NULL;

    }

    ckpFunctions = moduleData->ckFunctionListPtr;

    return ckpFunctions;

}

/*

 * Returns 1, if the given pkcs11Implementation is in the list.

 * 0, otherwise.

 */

int isModulePresent(JNIEnv *env, jobject pkcs11Implementation) {

    int present;

    ModuleData *moduleData = getModuleEntry(env, pkcs11Implementation);

    present = (moduleData != NULL) ? 1 : 0;

    return present ;

}

/*

 * Removes the entry for the given pkcs11Implementation from the list. Returns

 * the module's data, after the node was removed. If this function returns NULL

 * the pkcs11Implementation was not in the list.

 */

ModuleData * removeModuleEntry(JNIEnv *env, jobject pkcs11Implementation) {

    ModuleData *moduleData = getModuleEntry(env, pkcs11Implementation);

    if (moduleData == NULL) {

        return NULL;

    }

    (*env)->SetLongField(env, pkcs11Implementation, pNativeDataID, 0);

    return moduleData;

}

/*

 * Removes all present entries from the list of modules and frees all

 * associated resources. This function is used for clean-up.

 */

void removeAllModuleEntries(JNIEnv *env) {

    /* XXX empty */

}

/* ************************************************************************** */

/* Below there follow the helper functions to support conversions between     */

/* Java and Cryptoki types                                                    */

/* ************************************************************************** */

/*

 * function to convert a PKCS#11 return value into a PKCS#11Exception

 *

 * This function generates a PKCS#11Exception with the returnValue as the errorcode

 * if the returnValue is not CKR_OK. The functin returns 0, if the returnValue is

 * CKR_OK. Otherwise, it returns the returnValue as a jLong.

 *

 * @param env - used to call JNI funktions and to get the Exception class

 * @param returnValue - of the PKCS#11 function

 */

jlong ckAssertReturnValueOK(JNIEnv *env, CK_RV returnValue)

{

    jclass jPKCS11ExceptionClass;

    jmethodID jConstructor;

    jthrowable jPKCS11Exception;

    jlong jErrorCode = 0L;

    if (returnValue != CKR_OK) {

        jErrorCode = ckULongToJLong(returnValue);

        jPKCS11ExceptionClass = (*env)->FindClass(env, CLASS_PKCS11EXCEPTION);

        if (jPKCS11ExceptionClass != NULL) {

            jConstructor = (*env)->GetMethodID(env, jPKCS11ExceptionClass, "<init>", "(J)V");

            if (jConstructor != NULL) {

                jPKCS11Exception = (jthrowable) (*env)->NewObject(env, jPKCS11ExceptionClass, jConstructor, jErrorCode);

                if (jPKCS11Exception != NULL) {

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

                }

            }

        }

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

    }

    return jErrorCode ;

}

/*

 * Throws a Java Exception by name

 */

void throwByName(JNIEnv *env, const char *name, const char *msg)

{

    jclass cls = (*env)->FindClass(env, name);

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

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

}

/*

 * Throws java.lang.OutOfMemoryError

 */

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

{

    throwByName(env, "java/lang/OutOfMemoryError", msg);

}

/*

 * Throws java.lang.NullPointerException

 */

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

{

    throwByName(env, "java/lang/NullPointerException", msg);

}

/*

 * Throws java.io.IOException

 */

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

{

    throwByName(env, "java/io/IOException", msg);

}

/*

 * This function simply throws a PKCS#11RuntimeException with the given

 * string as its message.

 *

 * @param env Used to call JNI funktions and to get the Exception class.

 * @param jmessage The message string of the Exception object.

 */

void throwPKCS11RuntimeException(JNIEnv *env, const char *message)

{

    throwByName(env, CLASS_PKCS11RUNTIMEEXCEPTION, message);

}

/*

 * This function simply throws a PKCS#11RuntimeException. The message says that

 * the object is not connected to the module.

 *

 * @param env Used to call JNI funktions and to get the Exception class.

 */

void throwDisconnectedRuntimeException(JNIEnv *env)

{

    throwPKCS11RuntimeException(env, "This object is not connected to a module.");

}

/* This function frees the specified CK_ATTRIBUTE array.

 *

 * @param attrPtr pointer to the to-be-freed CK_ATTRIBUTE array.

 * @param len the length of the array

 */

void freeCKAttributeArray(CK_ATTRIBUTE_PTR attrPtr, int len) {

    if (attrPtr != NULL) {

        int i;

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

            if (attrPtr[i].pValue != NULL_PTR) {

                free(attrPtr[i].pValue);

            }

        }

        free(attrPtr);

    }

}

/* This function frees the specified CK_MECHANISM_PTR pointer and its

 * pParameter including mechanism-specific memory allocations.

 *

 * @param mechPtr pointer to the to-be-freed CK_MECHANISM structure.

 */

void freeCKMechanismPtr(CK_MECHANISM_PTR mechPtr) {

     void *tmp;

     CK_SSL3_MASTER_KEY_DERIVE_PARAMS *sslMkdTmp;

     CK_SSL3_KEY_MAT_PARAMS* sslKmTmp;

     CK_TLS12_MASTER_KEY_DERIVE_PARAMS *tlsMkdTmp;

     CK_TLS12_KEY_MAT_PARAMS* tlsKmTmp;

     if (mechPtr != NULL) {

         TRACE2("DEBUG freeCKMechanismPtr: free pMech %p (mech 0x%lX)\n",

                 mechPtr,  mechPtr->mechanism);

         if (mechPtr->pParameter != NULL) {

             tmp = mechPtr->pParameter;

             switch (mechPtr->mechanism) {

                 case CKM_AES_GCM:

                     if (mechPtr->ulParameterLen == sizeof(CK_GCM_PARAMS_NO_IVBITS)) {

                         TRACE0("[ GCM_PARAMS w/o ulIvBits ]\n");

                         free(((CK_GCM_PARAMS_NO_IVBITS*)tmp)->pIv);

                         free(((CK_GCM_PARAMS_NO_IVBITS*)tmp)->pAAD);

                     } else if (mechPtr->ulParameterLen == sizeof(CK_GCM_PARAMS)) {

                         TRACE0("[ GCM_PARAMS ]\n");

                         free(((CK_GCM_PARAMS*)tmp)->pIv);

                         free(((CK_GCM_PARAMS*)tmp)->pAAD);

                     }

                     break;

                 case CKM_AES_CCM:

                     TRACE0("[ CK_CCM_PARAMS ]\n");

                     free(((CK_CCM_PARAMS*)tmp)->pNonce);

                     free(((CK_CCM_PARAMS*)tmp)->pAAD);

                     break;

                 case CKM_TLS_PRF:

                 case CKM_NSS_TLS_PRF_GENERAL:

                     TRACE0("[ CK_TLS_PRF_PARAMS ]\n");

                     free(((CK_TLS_PRF_PARAMS*)tmp)->pSeed);

                     free(((CK_TLS_PRF_PARAMS*)tmp)->pLabel);

                     free(((CK_TLS_PRF_PARAMS*)tmp)->pulOutputLen);

                     free(((CK_TLS_PRF_PARAMS*)tmp)->pOutput);

                     break;

                 case CKM_SSL3_MASTER_KEY_DERIVE:

                 case CKM_TLS_MASTER_KEY_DERIVE:

                 case CKM_SSL3_MASTER_KEY_DERIVE_DH:

                 case CKM_TLS_MASTER_KEY_DERIVE_DH:

                     sslMkdTmp = tmp;

                     TRACE0("[ CK_SSL3_MASTER_KEY_DERIVE_PARAMS ]\n");

                     free(sslMkdTmp->RandomInfo.pClientRandom);

                     free(sslMkdTmp->RandomInfo.pServerRandom);

                     free(sslMkdTmp->pVersion);

                     break;

                 case CKM_SSL3_KEY_AND_MAC_DERIVE:

                 case CKM_TLS_KEY_AND_MAC_DERIVE:

                     sslKmTmp = tmp;

                     TRACE0("[ CK_SSL3_KEY_MAT_PARAMS ]\n");

                     free(sslKmTmp->RandomInfo.pClientRandom);

                     free(sslKmTmp->RandomInfo.pServerRandom);

                     if (sslKmTmp->pReturnedKeyMaterial != NULL) {

                         free(sslKmTmp->pReturnedKeyMaterial->pIVClient);

                         free(sslKmTmp->pReturnedKeyMaterial->pIVServer);

                         free(sslKmTmp->pReturnedKeyMaterial);

                     }

                     break;

                 case CKM_TLS12_MASTER_KEY_DERIVE:

                 case CKM_TLS12_MASTER_KEY_DERIVE_DH:

                     tlsMkdTmp = tmp;

                     TRACE0("[ CK_TLS12_MASTER_KEY_DERIVE_PARAMS ]\n");

                     free(tlsMkdTmp->RandomInfo.pClientRandom);

                     free(tlsMkdTmp->RandomInfo.pServerRandom);

                     free(tlsMkdTmp->pVersion);

                     break;

                 case CKM_TLS12_KEY_AND_MAC_DERIVE:

                     tlsKmTmp = tmp;

                     TRACE0("[ CK_TLS12_KEY_MAT_PARAMS ]\n");

                     free(tlsKmTmp->RandomInfo.pClientRandom);

                     free(tlsKmTmp->RandomInfo.pServerRandom);

                     if (tlsKmTmp->pReturnedKeyMaterial != NULL) {

                         free(tlsKmTmp->pReturnedKeyMaterial->pIVClient);

                         free(tlsKmTmp->pReturnedKeyMaterial->pIVServer);

                         free(tlsKmTmp->pReturnedKeyMaterial);

                     }

                     break;

                 case CKM_ECDH1_DERIVE:

                 case CKM_ECDH1_COFACTOR_DERIVE:

                     TRACE0("[ CK_ECDH1_DERIVE_PARAMS ]\n");

                     free(((CK_ECDH1_DERIVE_PARAMS *)tmp)->pSharedData);

                     free(((CK_ECDH1_DERIVE_PARAMS *)tmp)->pPublicData);

                     break;

                 case CKM_TLS_MAC:

                 case CKM_AES_CTR:

                 case CKM_RSA_PKCS_PSS:

                 case CKM_CAMELLIA_CTR:

                     // params do not contain pointers

                     break;

                 default:

                     // currently unsupported mechs by SunPKCS11 provider

                     // CKM_RSA_PKCS_OAEP, CKM_ECMQV_DERIVE,

                     // CKM_X9_42_*, CKM_KEA_DERIVE, CKM_RC2_*, CKM_RC5_*,

                     // CKM_SKIPJACK_*, CKM_KEY_WRAP_SET_OAEP, CKM_PKCS5_PBKD2,

                     // PBE mechs, WTLS mechs, CMS mechs,

                     // CKM_EXTRACT_KEY_FROM_KEY, CKM_OTP, CKM_KIP,

                     // CKM_DSA_PARAMETER_GEN?, CKM_GOSTR3410_*

                     // CK_any_CBC_ENCRYPT_DATA?

                     TRACE0("ERROR: UNSUPPORTED CK_MECHANISM\n");

                     break;

             }

             TRACE1("\t=> freed param %p\n", tmp);

             free(tmp);

         } else {

             TRACE0("\t=> param NULL\n");

         }

         free(mechPtr);

         TRACE0("FINISHED\n");

     }

}

/* This function replaces the CK_GCM_PARAMS_NO_IVBITS structure associated

 * with the specified CK_MECHANISM structure with CK_GCM_PARAMS

 * structure.

 *

 * @param mechPtr pointer to the CK_MECHANISM structure containing

 * the to-be-converted CK_GCM_PARAMS_NO_IVBITS structure.

 * @return pointer to the CK_MECHANISM structure containing the

 * converted CK_GCM_PARAMS structure or NULL if no conversion took place.

 */

CK_MECHANISM_PTR updateGCMParams(JNIEnv *env, CK_MECHANISM_PTR mechPtr) {

    CK_GCM_PARAMS* pGcmParams2 = NULL;

    CK_GCM_PARAMS_NO_IVBITS* pParams = NULL;

    if ((mechPtr->mechanism == CKM_AES_GCM) &&

            (mechPtr->pParameter != NULL_PTR) &&

            (mechPtr->ulParameterLen == sizeof(CK_GCM_PARAMS_NO_IVBITS))) {

        pGcmParams2 = calloc(1, sizeof(CK_GCM_PARAMS));

        if (pGcmParams2 == NULL) {

            throwOutOfMemoryError(env, 0);

            return NULL;

        }

        pParams = (CK_GCM_PARAMS_NO_IVBITS*) mechPtr->pParameter;

        pGcmParams2->pIv = pParams->pIv;

        pGcmParams2->ulIvLen = pParams->ulIvLen;

        pGcmParams2->ulIvBits = (pGcmParams2->ulIvLen << 3);

        pGcmParams2->pAAD = pParams->pAAD;

        pGcmParams2->ulAADLen = pParams->ulAADLen;

        pGcmParams2->ulTagBits = pParams->ulTagBits;

        TRACE1("DEBUG updateGCMParams: pMech %p\n", mechPtr);

        TRACE2("\t=> GCM param w/o ulIvBits %p => GCM param %p\n", pParams,

                pGcmParams2);

        free(pParams);

        mechPtr->pParameter = pGcmParams2;

        mechPtr->ulParameterLen = sizeof(CK_GCM_PARAMS);

        return mechPtr;

    } else {

        TRACE0("DEBUG updateGCMParams: no conversion done\n");

    }

    return NULL;

}

/*

 * the following functions convert Java arrays to PKCS#11 array pointers and

 * their array length and vice versa

 *

 * void j<Type>ArrayToCK<Type>Array(JNIEnv *env,

 *                                  const j<Type>Array jArray,

 *                                  CK_<Type>_PTR *ckpArray,

 *                                  CK_ULONG_PTR ckLength);

 *

 * j<Type>Array ck<Type>ArrayToJ<Type>Array(JNIEnv *env,

 *                                          const CK_<Type>_PTR ckpArray,

 *                                          CK_ULONG ckLength);

 *

 * PKCS#11 arrays consist always of a pointer to the beginning of the array and

 * the array length whereas Java arrays carry their array length.

 *

 * The Functions to convert a Java array to a PKCS#11 array are void functions.

 * Their arguments are the Java array object to convert, the reference to the

 * array pointer, where the new PKCS#11 array should be stored and the reference

 * to the array length where the PKCS#11 array length should be stored. These two

 * references must not be NULL_PTR.

 *

 * The functions first obtain the array length of the Java array and then allocate

 * the memory for the PKCS#11 array and set the array length. Then each element

 * gets converted depending on their type. After use the allocated memory of the

 * PKCS#11 array has to be explicitly freed.

 *

 * The Functions to convert a PKCS#11 array to a Java array get the PKCS#11 array

 * pointer and the array length and they return the new Java array object. The

 * Java array does not need to get freed after use.

 */

/*

 * converts a jbooleanArray to a CK_BBOOL array. The allocated memory has to be freed after use!

 *

 * @param env - used to call JNI funktions to get the array informtaion

 * @param jArray - the Java array to convert

 * @param ckpArray - the reference, where the pointer to the new CK_BBOOL array will be stored

 * @param ckpLength - the reference, where the array length will be stored

 */

void jBooleanArrayToCKBBoolArray(JNIEnv *env, const jbooleanArray jArray, CK_BBOOL **ckpArray, CK_ULONG_PTR ckpLength)

{

    jboolean* jpTemp;

    CK_ULONG i;

    if(jArray == NULL) {

        *ckpArray = NULL_PTR;

        *ckpLength = 0L;

        return;

    }

    *ckpLength = (*env)->GetArrayLength(env, jArray);

    jpTemp = (jboolean*) calloc(*ckpLength, sizeof(jboolean));

    if (jpTemp == NULL) {

        throwOutOfMemoryError(env, 0);

        return;

    }

    (*env)->GetBooleanArrayRegion(env, jArray, 0, *ckpLength, jpTemp);

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

        free(jpTemp);