/*

 * Portions Copyright 2003-2005 Sun Microsystems, Inc.  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 */

void jMechanismParameterToCKMechanismParameterSlow(JNIEnv *env, jobject jParam, CK_VOID_PTR *ckpParamPtr, CK_ULONG *ckpLength);

/*

 * converts a pointer to a CK_DATE structure 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);

    assert(jDateClass != 0);

    /* load CK_DATE constructor */

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

    assert(jCtrId != 0);

    /* prep all fields */

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

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

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

    /* create new CK_DATE object */

    jDateObject =

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

    assert(jDateObject != 0);

    /* free local references */

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

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

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

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

    return jDateObject ;

}

/*

 * converts a pointer to a CK_VERSION structure 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);

    assert(jVersionClass != 0);

    /* load CK_VERSION constructor */

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

    assert(jCtrId != 0);

    /* prep both fields */

    jMajor = ckpVersion->major;

    jMinor = ckpVersion->minor;

    /* create new CK_VERSION object */

    jVersionObject =

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

    assert(jVersionObject != 0);

    /* free local references */

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

    return jVersionObject ;

}

/*

 * converts a pointer to a CK_SESSION_INFO structure 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);

    assert(jSessionInfoClass != 0);

    /* load CK_SESSION_INFO constructor */

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

    assert(jCtrId != 0);

    /* 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);

    assert(jSessionInfoObject != 0);

    /* free local references */

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

    return jSessionInfoObject ;

}

/*

 * converts a pointer to a CK_ATTRIBUTE structure 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);

    assert(jAttributeClass != 0);

    /* load CK_INFO constructor */

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

    assert(jCtrId != 0);

    /* prep both fields */

    jType = ckULongToJLong(ckpAttribute->type);

    jPValue = ckAttributeValueToJObject(env, ckpAttribute);

    /* create new CK_ATTRIBUTE object */

    jAttributeObject =

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

    assert(jAttributeObject != 0);

    /* free local references */

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

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

    return jAttributeObject;

}

/*

 * converts a Java CK_VERSION object into a pointer to a CK_VERSION structure

 *

 * @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 - the 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;

    }

    /* allocate memory for CK_VERSION pointer */

    ckpVersion = (CK_VERSION_PTR) malloc(sizeof(CK_VERSION));

    /* get CK_VERSION class */

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

    assert(jVersionClass != 0);

    /* get Major */

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

    assert(jFieldID != 0);

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

    ckpVersion->major = jByteToCKByte(jMajor);

    /* get Minor */

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

    assert(jFieldID != 0);

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

    ckpVersion->minor = jByteToCKByte(jMinor);

    return ckpVersion ;

}

/*

 * converts a Java CK_DATE object into a pointer to a CK_DATE structure

 *

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

 * @param jVersion - the Java CK_DATE object to convert

 * @return - the pointer to the new CK_DATE structure

 */

CK_DATE * jDateObjectPtrToCKDatePtr(JNIEnv *env, jobject jDate)

{

    CK_DATE * ckpDate;

    CK_ULONG ckLength;

    jclass jDateClass;

    jfieldID jFieldID;

    jobject jYear, jMonth, jDay;

    jchar *jTempChars;

    CK_ULONG i;

    /* allocate memory for CK_DATE pointer */

    ckpDate = (CK_DATE *) malloc(sizeof(CK_DATE));

    /* get CK_DATE class */

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

    assert(jDateClass != 0);

    /* get Year */

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

    assert(jFieldID != 0);

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

    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*) malloc((ckLength) * sizeof(jchar));

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

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

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

        }

        free(jTempChars);

    }

    /* get Month */

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

    assert(jFieldID != 0);

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

    if (jMonth == NULL) {

        ckpDate->month[0] = 0;

        ckpDate->month[1] = 0;

    } else {

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

        jTempChars = (jchar*) malloc((ckLength) * sizeof(jchar));

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

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

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

        }

        free(jTempChars);

    }

    /* get Day */

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

    assert(jFieldID != 0);

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

    if (jDay == NULL) {

        ckpDate->day[0] = 0;

        ckpDate->day[1] = 0;

    } else {

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

        jTempChars = (jchar*) malloc((ckLength) * sizeof(jchar));

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

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

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

        }

        free(jTempChars);

    }

    return ckpDate ;

}

/*

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

    TRACE0("\nDEBUG: jAttributeToCKAttribute");

    /* get CK_ATTRIBUTE class */

    TRACE0(", getting attribute object class");

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

    assert(jAttributeClass != 0);

    /* get type */

    TRACE0(", getting type field");

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

    assert(jFieldID != 0);

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

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

    /* get pValue */

    TRACE0(", getting pValue field");

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

    assert(jFieldID != 0);

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

    jObjectToPrimitiveCKObjectPtrPtr(env, jPValue, &(ckAttribute.pValue), &(ckAttribute.ulValueLen));

    TRACE0("\nFINISHED\n");

    return ckAttribute ;

}

/*

 * converts the Java CK_SSL3_MASTER_KEY_DERIVE_PARAMS object to a

 * CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure

 *

 * @param env - used to call JNI funktions to get the Java classes and objects

 * @param jParam - the Java CK_SSL3_MASTER_KEY_DERIVE_PARAMS object to convert

 * @return - the new CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure

 */

CK_SSL3_MASTER_KEY_DERIVE_PARAMS jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(JNIEnv *env, jobject jParam)

{

    // XXX don't return structs

    // XXX prefetch class and field ids

    jclass jSsl3MasterKeyDeriveParamsClass = (*env)->FindClass(env, CLASS_SSL3_MASTER_KEY_DERIVE_PARAMS);

    CK_SSL3_MASTER_KEY_DERIVE_PARAMS ckParam;

    jfieldID fieldID;

    jobject jObject;

    jclass jSsl3RandomDataClass;

    jobject jRandomInfo;

    /* get RandomInfo */

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

    fieldID = (*env)->GetFieldID(env, jSsl3MasterKeyDeriveParamsClass, "RandomInfo", "Lsun/security/pkcs11/wrapper/CK_SSL3_RANDOM_DATA;");

    assert(fieldID != 0);

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

    /* get pClientRandom and ulClientRandomLength out of RandomInfo */

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

    assert(fieldID != 0);

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

    jByteArrayToCKByteArray(env, jObject, &(ckParam.RandomInfo.pClientRandom), &(ckParam.RandomInfo.ulClientRandomLen));

    /* get pServerRandom and ulServerRandomLength out of RandomInfo */

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

    assert(fieldID != 0);

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

    jByteArrayToCKByteArray(env, jObject, &(ckParam.RandomInfo.pServerRandom), &(ckParam.RandomInfo.ulServerRandomLen));

    /* get pVersion */

    fieldID = (*env)->GetFieldID(env, jSsl3MasterKeyDeriveParamsClass, "pVersion",  "Lsun/security/pkcs11/wrapper/CK_VERSION;");

    assert(fieldID != 0);

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

    ckParam.pVersion = jVersionToCKVersionPtr(env, jObject);

    return ckParam ;

}

/*

 * converts the Java CK_TLS_PRF_PARAMS object to a CK_TLS_PRF_PARAMS structure

 */

CK_TLS_PRF_PARAMS jTlsPrfParamsToCKTlsPrfParam(JNIEnv *env, jobject jParam)

{

    jclass jTlsPrfParamsClass = (*env)->FindClass(env, CLASS_TLS_PRF_PARAMS);

    CK_TLS_PRF_PARAMS ckParam;

    jfieldID fieldID;

    jobject jObject;

    fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pSeed", "[B");

    assert(fieldID != 0);

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

    jByteArrayToCKByteArray(env, jObject, &(ckParam.pSeed), &(ckParam.ulSeedLen));

    fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pLabel", "[B");

    assert(fieldID != 0);

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

    jByteArrayToCKByteArray(env, jObject, &(ckParam.pLabel), &(ckParam.ulLabelLen));

    ckParam.pulOutputLen = malloc(sizeof(CK_ULONG));

    fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pOutput", "[B");

    assert(fieldID != 0);

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

    jByteArrayToCKByteArray(env, jObject, &(ckParam.pOutput), ckParam.pulOutputLen);

    return ckParam ;

}

/*

 * converts the Java CK_SSL3_KEY_MAT_PARAMS object to a CK_SSL3_KEY_MAT_PARAMS structure

 *

 * @param env - used to call JNI funktions to get the Java classes and objects

 * @param jParam - the Java CK_SSL3_KEY_MAT_PARAMS object to convert

 * @return - the new CK_SSL3_KEY_MAT_PARAMS structure

 */

CK_SSL3_KEY_MAT_PARAMS jSsl3KeyMatParamToCKSsl3KeyMatParam(JNIEnv *env, jobject jParam)

{

    // XXX don't return structs

    // XXX prefetch class and field ids

    jclass jSsl3KeyMatParamsClass = (*env)->FindClass(env, CLASS_SSL3_KEY_MAT_PARAMS);

    CK_SSL3_KEY_MAT_PARAMS ckParam;

    jfieldID fieldID;

    jlong jLong;

    jboolean jBoolean;

    jobject jObject;

    jobject jRandomInfo;

    jobject jReturnedKeyMaterial;

    jclass jSsl3RandomDataClass;

    jclass jSsl3KeyMatOutClass;

    CK_ULONG ckTemp;

    /* get ulMacSizeInBits */

    fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "ulMacSizeInBits", "J");

    assert(fieldID != 0);

    jLong = (*env)->GetLongField(env, jParam, fieldID);

    ckParam.ulMacSizeInBits = jLongToCKULong(jLong);

    /* get ulKeySizeInBits */

    fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "ulKeySizeInBits", "J");

    assert(fieldID != 0);

    jLong = (*env)->GetLongField(env, jParam, fieldID);

    ckParam.ulKeySizeInBits = jLongToCKULong(jLong);

    /* get ulIVSizeInBits */

    fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "ulIVSizeInBits", "J");

    assert(fieldID != 0);

    jLong = (*env)->GetLongField(env, jParam, fieldID);

    ckParam.ulIVSizeInBits = jLongToCKULong(jLong);

    /* get bIsExport */

    fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "bIsExport", "Z");

    assert(fieldID != 0);

    jBoolean = (*env)->GetBooleanField(env, jParam, fieldID);