/*

 * 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.

 */

/*

 * pkcs11wrapper.c

 * 18.05.2001

 *

 * This is the implementation of the native functions of the Java to PKCS#11 interface.

 * All function use some helper functions to convert the JNI types to PKCS#11 types.

 *

 * @author Karl Scheibelhofer <Karl.Scheibelhofer@iaik.at>

 * @author Martin Schlaeffer <schlaeff@sbox.tugraz.at>

 */

#include "pkcs11wrapper.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "sun_security_pkcs11_wrapper_PKCS11.h"

/* declare file private functions */

CK_VOID_PTR jMechParamToCKMechParamPtrSlow(JNIEnv *env, jobject jParam,

        CK_MECHANISM_TYPE ckMech, CK_ULONG *ckpLength);

/*

 * converts a CK_DATE pointer into a Java CK_DATE Object.

 *

 * @param env - used to call JNI funktions to create the new Java object

 * @param ckpValue - the pointer to the CK_DATE structure

 * @return - the new Java CK_DATE object

 */

jobject ckDatePtrToJDateObject(JNIEnv *env, const CK_DATE *ckpDate)

{

    jclass jDateClass;

    jmethodID jCtrId;

    jobject jDateObject;

    jcharArray jYear;

    jcharArray jMonth;

    jcharArray jDay;

    /* load CK_DATE class */

    jDateClass = (*env)->FindClass(env, CLASS_DATE);

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

    /* load CK_DATE constructor */

    jCtrId = (*env)->GetMethodID(env, jDateClass, "<init>", "([C[C[C)V");

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

    /* prep all fields */

    jYear = ckCharArrayToJCharArray(env, (CK_CHAR_PTR)(ckpDate->year), 4);

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

    jMonth = ckCharArrayToJCharArray(env, (CK_CHAR_PTR)(ckpDate->month), 2);

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

    jDay = ckCharArrayToJCharArray(env, (CK_CHAR_PTR)(ckpDate->day), 2);

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

    /* create new CK_DATE object */

    jDateObject =

      (*env)->NewObject(env, jDateClass, jCtrId, jYear, jMonth, jDay);

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

    /* free local references */

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

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

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

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

    return jDateObject ;

}

/*

 * converts a CK_VERSION pointer into a Java CK_VERSION Object.

 *

 * @param env - used to call JNI funktions to create the new Java object

 * @param ckpVersion - the pointer to the CK_VERSION structure

 * @return the new Java CK_VERSION object

 */

jobject ckVersionPtrToJVersion(JNIEnv *env, const CK_VERSION_PTR ckpVersion)

{

    jclass jVersionClass;

    jmethodID jCtrId;

    jobject jVersionObject;

    jint jMajor;

    jint jMinor;

    /* load CK_VERSION class */

    jVersionClass = (*env)->FindClass(env, CLASS_VERSION);

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

    /* load CK_VERSION constructor */

    jCtrId = (*env)->GetMethodID(env, jVersionClass, "<init>", "(II)V");

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

    /* prep both fields */

    jMajor = ckpVersion->major;

    jMinor = ckpVersion->minor;

    /* create new CK_VERSION object */

    jVersionObject =

      (*env)->NewObject(env, jVersionClass, jCtrId, jMajor, jMinor);

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

    /* free local references */

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

    return jVersionObject ;

}

/*

 * converts a CK_SESSION_INFO pointer into a Java CK_SESSION_INFO Object.

 *

 * @param env - used to call JNI funktions to create the new Java object

 * @param ckpSessionInfo - the pointer to the CK_SESSION_INFO structure

 * @return the new Java CK_SESSION_INFO object

 */

jobject ckSessionInfoPtrToJSessionInfo(JNIEnv *env, const CK_SESSION_INFO_PTR ckpSessionInfo)

{

    jclass jSessionInfoClass;

    jmethodID jCtrId;

    jobject jSessionInfoObject;

    jlong jSlotID;

    jlong jState;

    jlong jFlags;

    jlong jDeviceError;

    /* load CK_SESSION_INFO class */

    jSessionInfoClass = (*env)->FindClass(env, CLASS_SESSION_INFO);

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

    /* load CK_SESSION_INFO constructor */

    jCtrId = (*env)->GetMethodID(env, jSessionInfoClass, "<init>", "(JJJJ)V");

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

    /* prep all fields */

    jSlotID = ckULongToJLong(ckpSessionInfo->slotID);

    jState = ckULongToJLong(ckpSessionInfo->state);

    jFlags = ckULongToJLong(ckpSessionInfo->flags);

    jDeviceError = ckULongToJLong(ckpSessionInfo->ulDeviceError);

    /* create new CK_SESSION_INFO object */

    jSessionInfoObject =

      (*env)->NewObject(env, jSessionInfoClass, jCtrId, jSlotID, jState,

                        jFlags, jDeviceError);

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

    /* free local references */

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

    return jSessionInfoObject ;

}

/*

 * converts a CK_ATTRIBUTE pointer into a Java CK_ATTRIBUTE Object.

 *

 * @param env - used to call JNI funktions to create the new Java object

 * @param ckpAttribute - the pointer to the CK_ATTRIBUTE structure

 * @return the new Java CK_ATTRIBUTE object

 */

jobject ckAttributePtrToJAttribute(JNIEnv *env, const CK_ATTRIBUTE_PTR ckpAttribute)

{

    jclass jAttributeClass;

    jmethodID jCtrId;

    jobject jAttributeObject;

    jlong jType;

    jobject jPValue = NULL;

    jAttributeClass = (*env)->FindClass(env, CLASS_ATTRIBUTE);

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

    /* load CK_INFO constructor */

    jCtrId = (*env)->GetMethodID(env, jAttributeClass, "<init>", "(JLjava/lang/Object;)V");

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

    /* prep both fields */

    jType = ckULongToJLong(ckpAttribute->type);

    jPValue = ckAttributeValueToJObject(env, ckpAttribute);

    if ((*env)->ExceptionCheck(env)) { return NULL; }

    /* create new CK_ATTRIBUTE object */

    jAttributeObject =

      (*env)->NewObject(env, jAttributeClass, jCtrId, jType, jPValue);

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

    /* free local references */

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

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

    return jAttributeObject;

}

/*

 * converts a Java CK_VERSION object into a CK_VERSION pointer

 *

 * @param env - used to call JNI funktions to get the values out of the Java object

 * @param jVersion - the Java CK_VERSION object to convert

 * @return pointer to the new CK_VERSION structure

 */

CK_VERSION_PTR

jVersionToCKVersionPtr(JNIEnv *env, jobject jVersion)

{

    CK_VERSION_PTR ckpVersion;

    jclass jVersionClass;

    jfieldID jFieldID;

    jbyte jMajor, jMinor;

    if (jVersion == NULL) {

        return NULL;

    }

    // retrieve java values

    jVersionClass = (*env)->GetObjectClass(env, jVersion);

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

    jFieldID = (*env)->GetFieldID(env, jVersionClass, "major", "B");

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

    jMajor = (*env)->GetByteField(env, jVersion, jFieldID);

    jFieldID = (*env)->GetFieldID(env, jVersionClass, "minor", "B");

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

    jMinor = (*env)->GetByteField(env, jVersion, jFieldID);

    // allocate memory for CK_VERSION pointer

    ckpVersion = (CK_VERSION_PTR) calloc(1, sizeof(CK_VERSION));

    if (ckpVersion == NULL) {

        throwOutOfMemoryError(env, 0);

        return NULL;

    }

    // populate using java values

    ckpVersion->major = jByteToCKByte(jMajor);

    ckpVersion->minor = jByteToCKByte(jMinor);

    return ckpVersion;

}

/*

 * converts a Java CK_DATE object into a CK_DATE pointer

 *

 * @param env - used to call JNI functions to get the values out of the Java object

 * @param jDate - the Java CK_DATE object to convert

 * @return pointer to the new CK_DATE structure

 */

CK_DATE * jDateObjectToCKDatePtr(JNIEnv *env, jobject jDate)

{

    CK_DATE * ckpDate = NULL;

    CK_ULONG ckLength;

    jclass jDateClass;

    jfieldID jFieldID;

    jobject jYear, jMonth, jDay;

    jchar *jTempChars = NULL;

    CK_ULONG i;

    if (jDate == NULL) {

        return NULL;

    }

    // retrieve java values

    jDateClass = (*env)->FindClass(env, CLASS_DATE);

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

    jFieldID = (*env)->GetFieldID(env, jDateClass, "year", "[C");

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

    jYear = (*env)->GetObjectField(env, jDate, jFieldID);

    jFieldID = (*env)->GetFieldID(env, jDateClass, "month", "[C");

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

    jMonth = (*env)->GetObjectField(env, jDate, jFieldID);

    jFieldID = (*env)->GetFieldID(env, jDateClass, "day", "[C");

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

    jDay = (*env)->GetObjectField(env, jDate, jFieldID);

    // allocate memory for CK_DATE pointer

    ckpDate = (CK_DATE *) calloc(1, sizeof(CK_DATE));

    if (ckpDate == NULL) {

        throwOutOfMemoryError(env, 0);

        return NULL;

    }

    // populate using java values

    if (jYear == NULL) {

        ckpDate->year[0] = 0;

        ckpDate->year[1] = 0;

        ckpDate->year[2] = 0;

        ckpDate->year[3] = 0;

    } else {

        ckLength = (*env)->GetArrayLength(env, jYear);

        jTempChars = (jchar*) calloc(ckLength, sizeof(jchar));

        if (jTempChars == NULL) {

            throwOutOfMemoryError(env, 0);

            goto cleanup;

        }

        (*env)->GetCharArrayRegion(env, jYear, 0, ckLength, jTempChars);

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

            goto cleanup;

        }

        for (i = 0; (i < ckLength) && (i < 4) ; i++) {

            ckpDate->year[i] = jCharToCKChar(jTempChars[i]);

        }

        free(jTempChars);

    }

    if (jMonth == NULL) {

        ckpDate->month[0] = 0;

        ckpDate->month[1] = 0;

    } else {

        ckLength = (*env)->GetArrayLength(env, jMonth);

        jTempChars = (jchar*) calloc(ckLength, sizeof(jchar));

        if (jTempChars == NULL) {

            throwOutOfMemoryError(env, 0);

            goto cleanup;

        }

        (*env)->GetCharArrayRegion(env, jMonth, 0, ckLength, jTempChars);

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

            goto cleanup;

        }

        for (i = 0; (i < ckLength) && (i < 2) ; i++) {

            ckpDate->month[i] = jCharToCKChar(jTempChars[i]);

        }

        free(jTempChars);

    }

    if (jDay == NULL) {

        ckpDate->day[0] = 0;

        ckpDate->day[1] = 0;

    } else {

        ckLength = (*env)->GetArrayLength(env, jDay);

        jTempChars = (jchar*) calloc(ckLength, sizeof(jchar));

        if (jTempChars == NULL) {

            throwOutOfMemoryError(env, 0);

            goto cleanup;

        }

        (*env)->GetCharArrayRegion(env, jDay, 0, ckLength, jTempChars);

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

            goto cleanup;

        }

        for (i = 0; (i < ckLength) && (i < 2) ; i++) {

            ckpDate->day[i] = jCharToCKChar(jTempChars[i]);

        }

        free(jTempChars);

    }

    return ckpDate;

cleanup:

    free(jTempChars);

    free(ckpDate);

    return NULL;

}

/*

 * converts a Java CK_ATTRIBUTE object into a CK_ATTRIBUTE structure

 *

 * @param env - used to call JNI funktions to get the values out of the Java object

 * @param jAttribute - the Java CK_ATTRIBUTE object to convert

 * @return the new CK_ATTRIBUTE structure

 */

CK_ATTRIBUTE jAttributeToCKAttribute(JNIEnv *env, jobject jAttribute)

{

    CK_ATTRIBUTE ckAttribute;

    jclass jAttributeClass;

    jfieldID jFieldID;

    jlong jType;

    jobject jPValue;

    memset(&ckAttribute, 0, sizeof(CK_ATTRIBUTE));

    // TBD: what if jAttribute == NULL?!

    TRACE0("\nDEBUG: jAttributeToCKAttribute");

    /* get CK_ATTRIBUTE class */

    TRACE0(", getting attribute object class");

    jAttributeClass = (*env)->GetObjectClass(env, jAttribute);

    if (jAttributeClass == NULL) { return ckAttribute; }

    /* get type */

    TRACE0(", getting type field");

    jFieldID = (*env)->GetFieldID(env, jAttributeClass, "type", "J");

    if (jFieldID == NULL) { return ckAttribute; }

    jType = (*env)->GetLongField(env, jAttribute, jFieldID);

    TRACE1(", type=0x%lX", jType);

    /* get pValue */

    TRACE0(", getting pValue field");

    jFieldID = (*env)->GetFieldID(env, jAttributeClass, "pValue", "Ljava/lang/Object;");

    if (jFieldID == NULL) { return ckAttribute; }

    jPValue = (*env)->GetObjectField(env, jAttribute, jFieldID);

    TRACE1(", pValue=%p", jPValue);

    ckAttribute.type = jLongToCKULong(jType);

    TRACE0(", converting pValue to primitive object");

    /* convert the Java pValue object to a CK-type pValue pointer */

    ckAttribute.pValue = jObjectToPrimitiveCKObjectPtr(env, jPValue, &(ckAttribute.ulValueLen));

    TRACE0("\nDEBUG: jAttributeToCKAttribute FINISHED\n");

    return ckAttribute ;

}

void masterKeyDeriveParamToCKMasterKeyDeriveParam(JNIEnv *env, jobject jParam,

        jclass masterKeyDeriveParamClass,

        CK_VERSION_PTR* cKMasterKeyDeriveParamVersion,

        CK_SSL3_RANDOM_DATA* cKMasterKeyDeriveParamRandomInfo) {

    jfieldID fieldID;

    jclass jSsl3RandomDataClass;

    jobject jRandomInfo, jRIClientRandom, jRIServerRandom, jVersion;

    // retrieve java values

    fieldID = (*env)->GetFieldID(env, masterKeyDeriveParamClass, "RandomInfo",

            "Lsun/security/pkcs11/wrapper/CK_SSL3_RANDOM_DATA;");

    if (fieldID == NULL) { return; }

    jRandomInfo = (*env)->GetObjectField(env, jParam, fieldID);

    jSsl3RandomDataClass = (*env)->FindClass(env, CLASS_SSL3_RANDOM_DATA);

    if (jSsl3RandomDataClass == NULL) { return; }

    fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pClientRandom", "[B");

    if (fieldID == NULL) { return; }

    jRIClientRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID);

    fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pServerRandom", "[B");

    if (fieldID == NULL) { return; }

    jRIServerRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID);

    fieldID = (*env)->GetFieldID(env, masterKeyDeriveParamClass, "pVersion",

            "Lsun/security/pkcs11/wrapper/CK_VERSION;");

    if (fieldID == NULL) { return; }

    jVersion = (*env)->GetObjectField(env, jParam, fieldID);

    // populate using java values

    *cKMasterKeyDeriveParamVersion = jVersionToCKVersionPtr(env, jVersion);

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

    jByteArrayToCKByteArray(env, jRIClientRandom,

            &(cKMasterKeyDeriveParamRandomInfo->pClientRandom),

            &(cKMasterKeyDeriveParamRandomInfo->ulClientRandomLen));

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

        goto cleanup;

    }

    jByteArrayToCKByteArray(env, jRIServerRandom,

            &(cKMasterKeyDeriveParamRandomInfo->pServerRandom),

            &(cKMasterKeyDeriveParamRandomInfo->ulServerRandomLen));

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

        goto cleanup;

    }

    return;

cleanup:

    free(*cKMasterKeyDeriveParamVersion);

    free(cKMasterKeyDeriveParamRandomInfo->pClientRandom);

    cKMasterKeyDeriveParamRandomInfo->ulClientRandomLen = 0L;

    free(cKMasterKeyDeriveParamRandomInfo->pServerRandom);

    cKMasterKeyDeriveParamRandomInfo->ulServerRandomLen = 0L;

    // explicitly set to NULL to ensure no double free possible

    *cKMasterKeyDeriveParamVersion = NULL;

    cKMasterKeyDeriveParamRandomInfo->pClientRandom = NULL;

    cKMasterKeyDeriveParamRandomInfo->pServerRandom = NULL;

}

/*