1 /*

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

     3  */

     4 

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

     6  *

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

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

     9  *

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

    11  *    this list of conditions and the following disclaimer.

    12  *

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

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

    15  *    and/or other materials provided with the distribution.

    16  *

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

    18  *    include the following acknowledgment:

    19  *

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

    21  *     Technology."

    22  *

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

    24  *    and wherever such third-party acknowledgments normally appear.

    25  *

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

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

    28  *    this software without prior written permission.

    29  *

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

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

    32  *    written permission of Graz University of Technology.

    33  *

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

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

    36  *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

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

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

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

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

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

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

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

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

    45  *  POSSIBILITY  OF SUCH DAMAGE.

    46  */

    47 

    48 /*

    49  * pkcs11wrapper.c

    50  * 18.05.2001

    51  *

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

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

    54  *

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

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

    57  */

    58 

    59 

    60 #include "pkcs11wrapper.h"

    61 

    62 #include <stdio.h>

    63 #include <stdlib.h>

    64 #include <string.h>

    65 #include <assert.h>

    66 

    67 #include "sun_security_pkcs11_wrapper_PKCS11.h"

    68 

    69 /* declare file private functions */

    70 

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

    72 

    73 

    74 /*

    75  * converts a pointer to a CK_DATE structure into a Java CK_DATE Object.

    76  *

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

    78  * @param ckpValue - the pointer to the CK_DATE structure

    79  * @return - the new Java CK_DATE object

    80  */

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

    82 {

    83     jclass jDateClass;

    84     jmethodID jCtrId;

    85     jobject jDateObject;

    86     jcharArray jYear;

    87     jcharArray jMonth;

    88     jcharArray jDay;

    89 

    90     /* load CK_DATE class */

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

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

    93 

    94     /* load CK_DATE constructor */

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

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

    97 

    98     /* prep all fields */

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

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

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

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

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

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

   105 

   106     /* create new CK_DATE object */

   107     jDateObject =

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

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

   110 

   111     /* free local references */

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

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

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

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

   116 

   117     return jDateObject ;

   118 }

   119 

   120 /*

   121  * converts a pointer to a CK_VERSION structure into a Java CK_VERSION Object.

   122  *

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

   124  * @param ckpVersion - the pointer to the CK_VERSION structure

   125  * @return - the new Java CK_VERSION object

   126  */

   127 jobject ckVersionPtrToJVersion(JNIEnv *env, const CK_VERSION_PTR ckpVersion)

   128 {

   129     jclass jVersionClass;

   130     jmethodID jCtrId;

   131     jobject jVersionObject;

   132     jint jMajor;

   133     jint jMinor;

   134 

   135     /* load CK_VERSION class */

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

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

   138 

   139     /* load CK_VERSION constructor */

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

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

   142 

   143     /* prep both fields */

   144     jMajor = ckpVersion->major;

   145     jMinor = ckpVersion->minor;

   146 

   147     /* create new CK_VERSION object */

   148     jVersionObject =

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

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

   151 

   152     /* free local references */

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

   154 

   155     return jVersionObject ;

   156 }

   157 

   158 /*

   159  * converts a pointer to a CK_SESSION_INFO structure into a Java CK_SESSION_INFO Object.

   160  *

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

   162  * @param ckpSessionInfo - the pointer to the CK_SESSION_INFO structure

   163  * @return - the new Java CK_SESSION_INFO object

   164  */

   165 jobject ckSessionInfoPtrToJSessionInfo(JNIEnv *env, const CK_SESSION_INFO_PTR ckpSessionInfo)

   166 {

   167     jclass jSessionInfoClass;

   168     jmethodID jCtrId;

   169     jobject jSessionInfoObject;

   170     jlong jSlotID;

   171     jlong jState;

   172     jlong jFlags;

   173     jlong jDeviceError;

   174 

   175     /* load CK_SESSION_INFO class */

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

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

   178 

   179     /* load CK_SESSION_INFO constructor */

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

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

   182 

   183     /* prep all fields */

   184     jSlotID = ckULongToJLong(ckpSessionInfo->slotID);

   185     jState = ckULongToJLong(ckpSessionInfo->state);

   186     jFlags = ckULongToJLong(ckpSessionInfo->flags);

   187     jDeviceError = ckULongToJLong(ckpSessionInfo->ulDeviceError);

   188 

   189     /* create new CK_SESSION_INFO object */

   190     jSessionInfoObject =

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

   192                         jFlags, jDeviceError);

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

   194 

   195     /* free local references */

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

   197 

   198     return jSessionInfoObject ;

   199 }

   200 

   201 /*

   202  * converts a pointer to a CK_ATTRIBUTE structure into a Java CK_ATTRIBUTE Object.

   203  *

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

   205  * @param ckpAttribute - the pointer to the CK_ATTRIBUTE structure

   206  * @return - the new Java CK_ATTRIBUTE object

   207  */

   208 jobject ckAttributePtrToJAttribute(JNIEnv *env, const CK_ATTRIBUTE_PTR ckpAttribute)

   209 {

   210     jclass jAttributeClass;

   211     jmethodID jCtrId;

   212     jobject jAttributeObject;

   213     jlong jType;

   214     jobject jPValue = NULL;

   215 

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

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

   218 

   219     /* load CK_INFO constructor */

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

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

   222 

   223     /* prep both fields */

   224     jType = ckULongToJLong(ckpAttribute->type);

   225     jPValue = ckAttributeValueToJObject(env, ckpAttribute);

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

   227 

   228     /* create new CK_ATTRIBUTE object */

   229     jAttributeObject =

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

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

   232 

   233     /* free local references */

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

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

   236 

   237     return jAttributeObject;

   238 }

   239 

   240 

   241 /*

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

   243  *

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

   245  * @param jVersion - the Java CK_VERSION object to convert

   246  * @return - the pointer to the new CK_VERSION structure

   247  */

   248 CK_VERSION_PTR jVersionToCKVersionPtr(JNIEnv *env, jobject jVersion)

   249 {

   250     CK_VERSION_PTR ckpVersion;

   251     jclass jVersionClass;

   252     jfieldID jFieldID;

   253     jbyte jMajor, jMinor;

   254 

   255     if (jVersion == NULL) {

   256         return NULL;

   257     }

   258 

   259     /* get CK_VERSION class */

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

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

   262 

   263     /* get Major */

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

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

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

   267 

   268     /* get Minor */

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

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

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

   272 

   273     /* allocate memory for CK_VERSION pointer */

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

   275     if (ckpVersion == NULL) {

   276         throwOutOfMemoryError(env, 0);

   277         return NULL;

   278     }

   279     ckpVersion->major = jByteToCKByte(jMajor);

   280     ckpVersion->minor = jByteToCKByte(jMinor);

   281 

   282     return ckpVersion ;

   283 }

   284 

   285 

   286 /*

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

   288  *

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

   290  * @param jVersion - the Java CK_DATE object to convert

   291  * @return - the pointer to the new CK_DATE structure

   292  */

   293 CK_DATE * jDateObjectPtrToCKDatePtr(JNIEnv *env, jobject jDate)

   294 {

   295     CK_DATE * ckpDate;

   296     CK_ULONG ckLength;

   297     jclass jDateClass;

   298     jfieldID jFieldID;

   299     jobject jYear, jMonth, jDay;

   300     jchar *jTempChars;

   301     CK_ULONG i;

   302 

   303     if (jDate == NULL) {

   304         return NULL;

   305     }

   306 

   307     /* get CK_DATE class */

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

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

   310 

   311     /* get Year */

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

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

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

   315 

   316     /* get Month */

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

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

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

   320 

   321     /* get Day */

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

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

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

   325 

   326     /* allocate memory for CK_DATE pointer */

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

   328     if (ckpDate == NULL) {

   329         throwOutOfMemoryError(env, 0);

   330         return NULL;

   331     }

   332 

   333     if (jYear == NULL) {

   334         ckpDate->year[0] = 0;

   335         ckpDate->year[1] = 0;

   336         ckpDate->year[2] = 0;

   337         ckpDate->year[3] = 0;

   338     } else {

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

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

   341         if (jTempChars == NULL) {

   342             free(ckpDate);

   343             throwOutOfMemoryError(env, 0);

   344             return NULL;

   345         }

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

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

   348             free(ckpDate);

   349             free(jTempChars);

   350             return NULL;

   351         }

   352 

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

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

   355         }

   356         free(jTempChars);

   357     }

   358 

   359     if (jMonth == NULL) {

   360         ckpDate->month[0] = 0;

   361         ckpDate->month[1] = 0;

   362     } else {

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

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

   365         if (jTempChars == NULL) {

   366             free(ckpDate);

   367             throwOutOfMemoryError(env, 0);

   368             return NULL;

   369         }

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

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

   372             free(ckpDate);

   373             free(jTempChars);

   374             return NULL;

   375         }

   376 

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

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

   379         }

   380         free(jTempChars);

   381     }

   382 

   383     if (jDay == NULL) {

   384         ckpDate->day[0] = 0;

   385         ckpDate->day[1] = 0;

   386     } else {

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

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

   389         if (jTempChars == NULL) {

   390             free(ckpDate);

   391             throwOutOfMemoryError(env, 0);

   392             return NULL;

   393         }

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

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

   396             free(ckpDate);

   397             free(jTempChars);

   398             return NULL;

   399         }

   400 

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

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

   403         }

   404         free(jTempChars);

   405     }

   406 

   407     return ckpDate ;

   408 }

   409 

   410 

   411 /*

   412  * converts a Java CK_ATTRIBUTE object into a CK_ATTRIBUTE structure

   413  *

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

   415  * @param jAttribute - the Java CK_ATTRIBUTE object to convert

   416  * @return - the new CK_ATTRIBUTE structure

   417  */

   418 CK_ATTRIBUTE jAttributeToCKAttribute(JNIEnv *env, jobject jAttribute)

   419 {

   420     CK_ATTRIBUTE ckAttribute;

   421     jclass jAttributeClass;

   422     jfieldID jFieldID;

   423     jlong jType;

   424     jobject jPValue;

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

   426 

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

   428 

   429     TRACE0("\nDEBUG: jAttributeToCKAttribute");

   430     /* get CK_ATTRIBUTE class */

   431     TRACE0(", getting attribute object class");

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

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

   434 

   435     /* get type */

   436     TRACE0(", getting type field");

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

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

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

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

   441 

   442     /* get pValue */

   443     TRACE0(", getting pValue field");

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

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

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

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

   448 

   449     ckAttribute.type = jLongToCKULong(jType);

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

   451 

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

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

   454 

   455     TRACE0("\nFINISHED\n");

   456 

   457     return ckAttribute ;

   458 }

   459 

   460 /*

   461  * converts the Java CK_SSL3_MASTER_KEY_DERIVE_PARAMS object to a

   462  * CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure

   463  *

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

   465  * @param jParam - the Java CK_SSL3_MASTER_KEY_DERIVE_PARAMS object to convert

   466  * @return - the new CK_SSL3_MASTER_KEY_DERIVE_PARAMS structure

   467  */

   468 CK_SSL3_MASTER_KEY_DERIVE_PARAMS jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(JNIEnv *env, jobject jParam)

   469 {

   470     // XXX don't return structs

   471     // XXX prefetch class and field ids

   472     jclass jSsl3MasterKeyDeriveParamsClass;

   473     CK_SSL3_MASTER_KEY_DERIVE_PARAMS ckParam;

   474     jfieldID fieldID;

   475     jclass jSsl3RandomDataClass;

   476     jobject jRandomInfo, jRIClientRandom, jRIServerRandom, jVersion;

   477     memset(&ckParam, 0, sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS));

   478 

   479     /* get RandomInfo */

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

   481     if (jSsl3MasterKeyDeriveParamsClass == NULL) { return ckParam; }

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

   483     if (fieldID == NULL) { return ckParam; }

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

   485 

   486     /* get pClientRandom and ulClientRandomLength out of RandomInfo */

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

   488     if (jSsl3RandomDataClass == NULL) { return ckParam; }

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

   490     if (fieldID == NULL) { return ckParam; }

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

   492 

   493     /* get pServerRandom and ulServerRandomLength out of RandomInfo */

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

   495     if (fieldID == NULL) { return ckParam; }

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

   497 

   498     /* get pVersion */

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

   500     if (fieldID == NULL) { return ckParam; }

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

   502 

   503     /* populate java values */

   504     ckParam.pVersion = jVersionToCKVersionPtr(env, jVersion);

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

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

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

   508         free(ckParam.pVersion);

   509         return ckParam;

   510     }

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

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

   513         free(ckParam.pVersion);

   514         free(ckParam.RandomInfo.pClientRandom);

   515         return ckParam;

   516     }

   517 

   518     return ckParam ;

   519 }

   520 

   521 

   522 /*

   523  * converts the Java CK_TLS_PRF_PARAMS object to a CK_TLS_PRF_PARAMS structure

   524  */

   525 CK_TLS_PRF_PARAMS jTlsPrfParamsToCKTlsPrfParam(JNIEnv *env, jobject jParam)

   526 {

   527     jclass jTlsPrfParamsClass;

   528     CK_TLS_PRF_PARAMS ckParam;

   529     jfieldID fieldID;

   530     jobject jSeed, jLabel, jOutput;

   531     memset(&ckParam, 0, sizeof(CK_TLS_PRF_PARAMS));

   532 

   533     // TBD: what if jParam == NULL?!

   534 

   535     /* get pSeed */

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

   537     if (jTlsPrfParamsClass == NULL) { return ckParam; }

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

   539     if (fieldID == NULL) { return ckParam; }

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

   541 

   542     /* get pLabel */

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

   544     if (fieldID == NULL) { return ckParam; }

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

   546 

   547     /* get pOutput */

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

   549     if (fieldID == NULL) { return ckParam; }

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

   551 

   552     /* populate java values */

   553     jByteArrayToCKByteArray(env, jSeed, &(ckParam.pSeed), &(ckParam.ulSeedLen));

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

   555     jByteArrayToCKByteArray(env, jLabel, &(ckParam.pLabel), &(ckParam.ulLabelLen));

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

   557         free(ckParam.pSeed);

   558         return ckParam;

   559     }

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

   561     if (ckParam.pulOutputLen == NULL) {

   562         free(ckParam.pSeed);

   563         free(ckParam.pLabel);

   564         throwOutOfMemoryError(env, 0);

   565         return ckParam;

   566     }

   567     jByteArrayToCKByteArray(env, jOutput, &(ckParam.pOutput), ckParam.pulOutputLen);

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

   569         free(ckParam.pSeed);

   570         free(ckParam.pLabel);

   571         free(ckParam.pulOutputLen);

   572         return ckParam;

   573     }

   574 

   575     return ckParam ;

   576 }

   577 

   578 /*

   579  * converts the Java CK_SSL3_KEY_MAT_PARAMS object to a CK_SSL3_KEY_MAT_PARAMS structure

   580  *

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

   582  * @param jParam - the Java CK_SSL3_KEY_MAT_PARAMS object to convert

   583  * @return - the new CK_SSL3_KEY_MAT_PARAMS structure

   584  */

   585 CK_SSL3_KEY_MAT_PARAMS jSsl3KeyMatParamToCKSsl3KeyMatParam(JNIEnv *env, jobject jParam)

   586 {

   587     // XXX don't return structs

   588     // XXX prefetch class and field ids

   589     jclass jSsl3KeyMatParamsClass, jSsl3RandomDataClass, jSsl3KeyMatOutClass;

   590     CK_SSL3_KEY_MAT_PARAMS ckParam;

   591     jfieldID fieldID;

   592     jlong jMacSizeInBits, jKeySizeInBits, jIVSizeInBits;

   593     jboolean jIsExport;

   594     jobject jRandomInfo, jRIClientRandom, jRIServerRandom;

   595     jobject jReturnedKeyMaterial, jRMIvClient, jRMIvServer;

   596     CK_ULONG ckTemp;

   597     memset(&ckParam, 0, sizeof(CK_SSL3_KEY_MAT_PARAMS));

   598 

   599     /* get ulMacSizeInBits */

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

   601     if (jSsl3KeyMatParamsClass == NULL) { return ckParam; }

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

   603     if (fieldID == NULL) { return ckParam; }

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

   605 

   606     /* get ulKeySizeInBits */

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

   608     if (fieldID == NULL) { return ckParam; }

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

   610 

   611     /* get ulIVSizeInBits */

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

   613     if (fieldID == NULL) { return ckParam; }

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

   615 

   616     /* get bIsExport */

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

   618     if (fieldID == NULL) { return ckParam; }

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

   620 

   621     /* get RandomInfo */

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

   623     if (jSsl3RandomDataClass == NULL) { return ckParam; }

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

   625     if (fieldID == NULL) { return ckParam; }

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

   627 

   628     /* get pClientRandom and ulClientRandomLength out of RandomInfo */

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

   630     if (fieldID == NULL) { return ckParam; }

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

   632 

   633     /* get pServerRandom and ulServerRandomLength out of RandomInfo */

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

   635     if (fieldID == NULL) { return ckParam; }

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

   637 

   638     /* get pReturnedKeyMaterial */

   639     jSsl3KeyMatOutClass = (*env)->FindClass(env, CLASS_SSL3_KEY_MAT_OUT);

   640     if (jSsl3KeyMatOutClass == NULL) { return ckParam; }

   641     fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "pReturnedKeyMaterial",  "Lsun/security/pkcs11/wrapper/CK_SSL3_KEY_MAT_OUT;");

   642     if (fieldID == NULL) { return ckParam; }

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

   644 

   645     /* get pIVClient out of pReturnedKeyMaterial */

   646     fieldID = (*env)->GetFieldID(env, jSsl3KeyMatOutClass, "pIVClient", "[B");

   647     if (fieldID == NULL) { return ckParam; }

   648     jRMIvClient = (*env)->GetObjectField(env, jReturnedKeyMaterial, fieldID);

   649 

   650     /* get pIVServer out of pReturnedKeyMaterial */

   651     fieldID = (*env)->GetFieldID(env, jSsl3KeyMatOutClass, "pIVServer", "[B");

   652     if (fieldID == NULL) { return ckParam; }

   653     jRMIvServer = (*env)->GetObjectField(env, jReturnedKeyMaterial, fieldID);

   654 

   655     /* populate java values */

   656     ckParam.ulMacSizeInBits = jLongToCKULong(jMacSizeInBits);

   657     ckParam.ulKeySizeInBits = jLongToCKULong(jKeySizeInBits);

   658     ckParam.ulIVSizeInBits = jLongToCKULong(jIVSizeInBits);

   659     ckParam.bIsExport = jBooleanToCKBBool(jIsExport);

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

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

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

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

   664         free(ckParam.RandomInfo.pClientRandom);

   665         return ckParam;

   666     }

   667     /* allocate memory for pRetrunedKeyMaterial */

   668     ckParam.pReturnedKeyMaterial = (CK_SSL3_KEY_MAT_OUT_PTR) malloc(sizeof(CK_SSL3_KEY_MAT_OUT));

   669     if (ckParam.pReturnedKeyMaterial == NULL) {

   670         free(ckParam.RandomInfo.pClientRandom);

   671         free(ckParam.RandomInfo.pServerRandom);

   672         throwOutOfMemoryError(env, 0);

   673         return ckParam;

   674     }

   675 

   676     // the handles are output params only, no need to fetch them from Java

   677     ckParam.pReturnedKeyMaterial->hClientMacSecret = 0;

   678     ckParam.pReturnedKeyMaterial->hServerMacSecret = 0;

   679     ckParam.pReturnedKeyMaterial->hClientKey = 0;

   680     ckParam.pReturnedKeyMaterial->hServerKey = 0;

   681 

   682     jByteArrayToCKByteArray(env, jRMIvClient, &(ckParam.pReturnedKeyMaterial->pIVClient), &ckTemp);

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

   684         free(ckParam.RandomInfo.pClientRandom);

   685         free(ckParam.RandomInfo.pServerRandom);

   686         free(ckParam.pReturnedKeyMaterial);

   687         return ckParam;

   688     }

   689     jByteArrayToCKByteArray(env, jRMIvServer, &(ckParam.pReturnedKeyMaterial->pIVServer), &ckTemp);

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

   691         free(ckParam.RandomInfo.pClientRandom);

   692         free(ckParam.RandomInfo.pServerRandom);

   693         free(ckParam.pReturnedKeyMaterial->pIVClient);

   694         free(ckParam.pReturnedKeyMaterial);

   695         return ckParam;

   696     }

   697 

   698     return ckParam ;

   699 }

   700 

   701 /*

   702  * converts the Java CK_AES_CTR_PARAMS object to a CK_AES_CTR_PARAMS structure

   703  *

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

   705  * @param jParam - the Java CK_AES_CTR_PARAMS object to convert

   706  * @param ckpParam - pointer to the new CK_AES_CTR_PARAMS structure

   707  */

   708 void jAesCtrParamsToCKAesCtrParam(JNIEnv *env, jobject jParam,

   709                                   CK_AES_CTR_PARAMS_PTR ckpParam) {

   710     jclass jAesCtrParamsClass;

   711     jfieldID fieldID;

   712     jlong jCounterBits;

   713     jobject jCb;

   714     CK_BYTE_PTR ckBytes;

   715     CK_ULONG ckTemp;

   716 

   717     /* get ulCounterBits */

   718     jAesCtrParamsClass = (*env)->FindClass(env, CLASS_AES_CTR_PARAMS);

   719     if (jAesCtrParamsClass == NULL) { return; }

   720     fieldID = (*env)->GetFieldID(env, jAesCtrParamsClass, "ulCounterBits", "J");

   721     if (fieldID == NULL) { return; }

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

   723 

   724     /* get cb */

   725     fieldID = (*env)->GetFieldID(env, jAesCtrParamsClass, "cb", "[B");

   726     if (fieldID == NULL) { return; }

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

   728 

   729     /* populate java values */

   730     ckpParam->ulCounterBits = jLongToCKULong(jCounterBits);

   731     jByteArrayToCKByteArray(env, jCb, &ckBytes, &ckTemp);

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

   733     if (ckTemp != 16) {

   734         TRACE1("ERROR: WRONG CTR IV LENGTH %d", ckTemp);

   735     } else {

   736         memcpy(ckpParam->cb, ckBytes, ckTemp);

   737         free(ckBytes);

   738     }

   739 }

   740 

   741 /*

   742  * converts a Java CK_MECHANISM object into a CK_MECHANISM structure

   743  *

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

   745  * @param jMechanism - the Java CK_MECHANISM object to convert

   746  * @return - the new CK_MECHANISM structure

   747  */

   748 void jMechanismToCKMechanism(JNIEnv *env, jobject jMechanism, CK_MECHANISM_PTR ckMechanismPtr)

   749 {

   750     jlong jMechanismType = (*env)->GetLongField(env, jMechanism, mech_mechanismID);

   751     jobject jParameter = (*env)->GetObjectField(env, jMechanism, mech_pParameterID);

   752 

   753     (*ckMechanismPtr).mechanism = jLongToCKULong(jMechanismType);

   754 

   755     /* convert the specific Java mechanism parameter object to a pointer to a CK-type mechanism

   756      * structure

   757      */

   758     if (jParameter == NULL) {

   759         (*ckMechanismPtr).pParameter = NULL;

   760         (*ckMechanismPtr).ulParameterLen = 0;

   761     } else {

   762         jMechanismParameterToCKMechanismParameter(env, jParameter, &(*ckMechanismPtr).pParameter, &(*ckMechanismPtr).ulParameterLen);

   763     }

   764 }

   765 

   766 /*

   767  * the following functions convert Attribute and Mechanism value pointers

   768  *

   769  * jobject ckAttributeValueToJObject(JNIEnv *env,

   770  *                                   const CK_ATTRIBUTE_PTR ckpAttribute);

   771  *

   772  * void jObjectToPrimitiveCKObjectPtrPtr(JNIEnv *env,

   773  *                                       jobject jObject,

   774  *                                       CK_VOID_PTR *ckpObjectPtr,

   775  *                                       CK_ULONG *pLength);

   776  *

   777  * void jMechanismParameterToCKMechanismParameter(JNIEnv *env,

   778  *                                                jobject jParam,

   779  *                                                CK_VOID_PTR *ckpParamPtr,

   780  *                                                CK_ULONG *ckpLength);

   781  *

   782  * These functions are used if a PKCS#11 mechanism or attribute structure gets

   783  * convertet to a Java attribute or mechanism object or vice versa.

   784  *

   785  * ckAttributeValueToJObject converts a PKCS#11 attribute value pointer to a Java

   786  * object depending on the type of the Attribute. A PKCS#11 attribute value can

   787  * be a CK_ULONG, CK_BYTE[], CK_CHAR[], big integer, CK_BBOOL, CK_UTF8CHAR[],

   788  * CK_DATE or CK_FLAGS that gets converted to a corresponding Java object.

   789  *

   790  * jObjectToPrimitiveCKObjectPtrPtr is used by jAttributeToCKAttributePtr for

   791  * converting the Java attribute value to a PKCS#11 attribute value pointer.

   792  * For now only primitive datatypes and arrays of primitive datatypes can get

   793  * converted. Otherwise this function throws a PKCS#11Exception with the

   794  * errorcode CKR_VENDOR_DEFINED.

   795  *

   796  * jMechanismParameterToCKMechanismParameter converts a Java mechanism parameter

   797  * to a PKCS#11 mechanism parameter. First this function determines what mechanism

   798  * parameter the Java object is, then it allocates the memory for the new PKCS#11

   799  * structure and calls the corresponding function to convert the Java object to

   800  * a PKCS#11 mechanism parameter structure.

   801  */

   802 

   803 /*

   804  * converts the pValue of a CK_ATTRIBUTE structure into a Java Object by checking the type

   805  * of the attribute.

   806  *

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

   808  * @param ckpAttribute - the pointer to the CK_ATTRIBUTE structure that contains the type

   809  *                       and the pValue to convert

   810  * @return - the new Java object of the CK-type pValue

   811  */

   812 jobject ckAttributeValueToJObject(JNIEnv *env, const CK_ATTRIBUTE_PTR ckpAttribute)

   813 {

   814     jint jValueLength;

   815     jobject jValueObject = NULL;

   816 

   817     jValueLength = ckULongToJInt(ckpAttribute->ulValueLen);

   818 

   819     if ((jValueLength <= 0) || (ckpAttribute->pValue == NULL)) {

   820         return NULL ;

   821     }

   822 

   823     switch(ckpAttribute->type) {

   824         case CKA_CLASS:

   825             /* value CK_OBJECT_CLASS, defacto a CK_ULONG */

   826         case CKA_KEY_TYPE:

   827             /* value CK_KEY_TYPE, defacto a CK_ULONG */

   828         case CKA_CERTIFICATE_TYPE:

   829             /* value CK_CERTIFICATE_TYPE, defacto a CK_ULONG */

   830         case CKA_HW_FEATURE_TYPE:

   831             /* value CK_HW_FEATURE_TYPE, defacto a CK_ULONG */

   832         case CKA_MODULUS_BITS:

   833         case CKA_VALUE_BITS:

   834         case CKA_VALUE_LEN:

   835         case CKA_KEY_GEN_MECHANISM:

   836         case CKA_PRIME_BITS:

   837         case CKA_SUB_PRIME_BITS:

   838             /* value CK_ULONG */

   839             jValueObject = ckULongPtrToJLongObject(env, (CK_ULONG*) ckpAttribute->pValue);

   840             break;

   841 

   842             /* can be CK_BYTE[],CK_CHAR[] or big integer; defacto always CK_BYTE[] */

   843         case CKA_VALUE:

   844         case CKA_OBJECT_ID:

   845         case CKA_SUBJECT:

   846         case CKA_ID:

   847         case CKA_ISSUER:

   848         case CKA_SERIAL_NUMBER:

   849         case CKA_OWNER:

   850         case CKA_AC_ISSUER:

   851         case CKA_ATTR_TYPES:

   852         case CKA_ECDSA_PARAMS:

   853             /* CKA_EC_PARAMS is the same, these two are equivalent */

   854         case CKA_EC_POINT:

   855         case CKA_PRIVATE_EXPONENT:

   856         case CKA_PRIME_1:

   857         case CKA_PRIME_2:

   858         case CKA_EXPONENT_1:

   859         case CKA_EXPONENT_2:

   860         case CKA_COEFFICIENT:

   861             /* value CK_BYTE[] */

   862             jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength);

   863             break;

   864 

   865         case CKA_RESET_ON_INIT:

   866         case CKA_HAS_RESET:

   867         case CKA_TOKEN:

   868         case CKA_PRIVATE:

   869         case CKA_MODIFIABLE:

   870         case CKA_DERIVE:

   871         case CKA_LOCAL:

   872         case CKA_ENCRYPT:

   873         case CKA_VERIFY:

   874         case CKA_VERIFY_RECOVER:

   875         case CKA_WRAP:

   876         case CKA_SENSITIVE:

   877         case CKA_SECONDARY_AUTH:

   878         case CKA_DECRYPT:

   879         case CKA_SIGN:

   880         case CKA_SIGN_RECOVER:

   881         case CKA_UNWRAP:

   882         case CKA_EXTRACTABLE:

   883         case CKA_ALWAYS_SENSITIVE:

   884         case CKA_NEVER_EXTRACTABLE:

   885         case CKA_TRUSTED:

   886             /* value CK_BBOOL */

   887             jValueObject = ckBBoolPtrToJBooleanObject(env, (CK_BBOOL*) ckpAttribute->pValue);

   888             break;

   889 

   890         case CKA_LABEL:

   891         case CKA_APPLICATION:

   892             /* value RFC 2279 (UTF-8) string */

   893             jValueObject = ckUTF8CharArrayToJCharArray(env, (CK_UTF8CHAR*) ckpAttribute->pValue, jValueLength);

   894             break;

   895 

   896         case CKA_START_DATE:

   897         case CKA_END_DATE:

   898             /* value CK_DATE */

   899             jValueObject = ckDatePtrToJDateObject(env, (CK_DATE*) ckpAttribute->pValue);

   900             break;

   901 

   902         case CKA_MODULUS:

   903         case CKA_PUBLIC_EXPONENT:

   904         case CKA_PRIME:

   905         case CKA_SUBPRIME:

   906         case CKA_BASE:

   907             /* value big integer, i.e. CK_BYTE[] */

   908             jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength);

   909             break;

   910 

   911         case CKA_AUTH_PIN_FLAGS:

   912             jValueObject = ckULongPtrToJLongObject(env, (CK_ULONG*) ckpAttribute->pValue);

   913             /* value FLAGS, defacto a CK_ULONG */

   914             break;

   915 

   916         case CKA_VENDOR_DEFINED:

   917             /* we make a CK_BYTE[] out of this */

   918             jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength);

   919             break;

   920 

   921         // Netscape trust attributes

   922         case CKA_NETSCAPE_TRUST_SERVER_AUTH:

   923         case CKA_NETSCAPE_TRUST_CLIENT_AUTH:

   924         case CKA_NETSCAPE_TRUST_CODE_SIGNING:

   925         case CKA_NETSCAPE_TRUST_EMAIL_PROTECTION:

   926             /* value CK_ULONG */

   927             jValueObject = ckULongPtrToJLongObject(env, (CK_ULONG*) ckpAttribute->pValue);

   928             break;

   929 

   930         default:

   931             /* we make a CK_BYTE[] out of this */

   932             jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength);

   933             break;

   934     }

   935 

   936     return jValueObject ;

   937 }

   938 

   939 /*

   940  * the following functions convert a Java mechanism parameter object to a PKCS#11

   941  * mechanism parameter structure

   942  *

   943  * CK_<Param>_PARAMS j<Param>ParamToCK<Param>Param(JNIEnv *env,

   944  *                                                 jobject jParam);

   945  *

   946  * These functions get a Java object, that must be the right Java mechanism

   947  * object and they return the new PKCS#11 mechanism parameter structure.

   948  * Every field of the Java object is retrieved, gets converted to a corresponding

   949  * PKCS#11 type and is set in the new PKCS#11 structure.

   950  */

   951 

   952 /*

   953  * converts the given Java mechanism parameter to a CK mechanism parameter structure

   954  * and store the length in bytes in the length variable.

   955  * The memory of *ckpParamPtr has to be freed after use!

   956  *

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

   958  * @param jParam - the Java mechanism parameter object to convert

   959  * @param ckpParamPtr - the reference of the new pointer to the new CK mechanism parameter

   960  *                      structure

   961  * @param ckpLength - the reference of the length in bytes of the new CK mechanism parameter

   962  *                    structure

   963  */

   964 void jMechanismParameterToCKMechanismParameter(JNIEnv *env, jobject jParam, CK_VOID_PTR *ckpParamPtr, CK_ULONG *ckpLength)

   965 {

   966     if (jParam == NULL) {

   967         *ckpParamPtr = NULL;

   968         *ckpLength = 0;

   969     } else if ((*env)->IsInstanceOf(env, jParam, jByteArrayClass)) {

   970         jByteArrayToCKByteArray(env, jParam, (CK_BYTE_PTR *)ckpParamPtr, ckpLength);

   971     } else if ((*env)->IsInstanceOf(env, jParam, jLongClass)) {

   972         *ckpParamPtr = jLongObjectToCKULongPtr(env, jParam);

   973         *ckpLength = sizeof(CK_ULONG);

   974     } else {

   975         TRACE0("\nSLOW PATH jMechanismParameterToCKMechanismParameter\n");

   976         jMechanismParameterToCKMechanismParameterSlow(env, jParam, ckpParamPtr, ckpLength);

   977     }

   978 }

   979 

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

   981 {

   982     /* get all Java mechanism parameter classes */

   983     jclass jVersionClass, jSsl3MasterKeyDeriveParamsClass, jSsl3KeyMatParamsClass;

   984     jclass jTlsPrfParamsClass, jAesCtrParamsClass, jRsaPkcsOaepParamsClass;

   985     jclass jPbeParamsClass, jPkcs5Pbkd2ParamsClass, jRsaPkcsPssParamsClass;

   986     jclass jEcdh1DeriveParamsClass, jEcdh2DeriveParamsClass;

   987     jclass jX942Dh1DeriveParamsClass, jX942Dh2DeriveParamsClass;

   988     TRACE0("\nDEBUG: jMechanismParameterToCKMechanismParameter");

   989 

   990     /* most common cases, i.e. NULL/byte[]/long, are already handled by

   991      * jMechanismParameterToCKMechanismParameter before calling this method.

   992      */

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

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

   995     if ((*env)->IsInstanceOf(env, jParam, jVersionClass)) {

   996         /*

   997          * CK_VERSION used by CKM_SSL3_PRE_MASTER_KEY_GEN

   998          */

   999         CK_VERSION_PTR ckpParam;

  1000 

  1001         /* convert jParameter to CKParameter */

  1002         ckpParam = jVersionToCKVersionPtr(env, jParam);

  1003 

  1004         /* get length and pointer of parameter */

  1005         *ckpLength = sizeof(CK_VERSION);

  1006         *ckpParamPtr = ckpParam;

  1007         return;

  1008     }

  1009 

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

  1011     if (jSsl3MasterKeyDeriveParamsClass == NULL) { return; }

  1012     if ((*env)->IsInstanceOf(env, jParam, jSsl3MasterKeyDeriveParamsClass)) {

  1013         /*

  1014          * CK_SSL3_MASTER_KEY_DERIVE_PARAMS

  1015          */

  1016         CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR ckpParam;

  1017 

  1018         ckpParam = (CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR) malloc(sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS));

  1019         if (ckpParam == NULL) {

  1020             throwOutOfMemoryError(env, 0);

  1021             return;

  1022         }

  1023 

  1024         /* convert jParameter to CKParameter */

  1025         *ckpParam = jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(env, jParam);

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

  1027             free(ckpParam);

  1028             return;

  1029         }

  1030 

  1031         /* get length and pointer of parameter */

  1032         *ckpLength = sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS);

  1033         *ckpParamPtr = ckpParam;

  1034         return;

  1035     }

  1036 

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

  1038     if (jSsl3KeyMatParamsClass == NULL) { return; }

  1039     if ((*env)->IsInstanceOf(env, jParam, jSsl3KeyMatParamsClass)) {

  1040         /*

  1041          * CK_SSL3_KEY_MAT_PARAMS

  1042          */

  1043         CK_SSL3_KEY_MAT_PARAMS_PTR ckpParam;

  1044 

  1045         ckpParam = (CK_SSL3_KEY_MAT_PARAMS_PTR) malloc(sizeof(CK_SSL3_KEY_MAT_PARAMS));

  1046         if (ckpParam == NULL) {

  1047             throwOutOfMemoryError(env, 0);

  1048             return;

  1049         }

  1050 

  1051         /* convert jParameter to CKParameter */

  1052         *ckpParam = jSsl3KeyMatParamToCKSsl3KeyMatParam(env, jParam);

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

  1054             free(ckpParam);

  1055             return;

  1056         }

  1057 

  1058         /* get length and pointer of parameter */

  1059         *ckpLength = sizeof(CK_SSL3_KEY_MAT_PARAMS);

  1060         *ckpParamPtr = ckpParam;

  1061         return;

  1062     }

  1063 

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

  1065     if (jTlsPrfParamsClass == NULL) { return; }

  1066     if ((*env)->IsInstanceOf(env, jParam, jTlsPrfParamsClass)) {

  1067         /*

  1068          * CK_TLS_PRF_PARAMS

  1069          */

  1070         CK_TLS_PRF_PARAMS_PTR ckpParam;

  1071 

  1072         ckpParam = (CK_TLS_PRF_PARAMS_PTR) malloc(sizeof(CK_TLS_PRF_PARAMS));

  1073         if (ckpParam == NULL) {

  1074             throwOutOfMemoryError(env, 0);

  1075             return;

  1076         }

  1077 

  1078         /* convert jParameter to CKParameter */

  1079         *ckpParam = jTlsPrfParamsToCKTlsPrfParam(env, jParam);

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

  1081             free(ckpParam);

  1082             return;

  1083         }

  1084 

  1085         /* get length and pointer of parameter */

  1086         *ckpLength = sizeof(CK_TLS_PRF_PARAMS);

  1087         *ckpParamPtr = ckpParam;

  1088         return;

  1089     }

  1090 

  1091     jAesCtrParamsClass = (*env)->FindClass(env, CLASS_AES_CTR_PARAMS);

  1092     if (jAesCtrParamsClass == NULL) { return; }

  1093     if ((*env)->IsInstanceOf(env, jParam, jAesCtrParamsClass)) {

  1094         /*

  1095          * CK_AES_CTR_PARAMS

  1096          */

  1097         CK_AES_CTR_PARAMS_PTR ckpParam;

  1098 

  1099         ckpParam = (CK_AES_CTR_PARAMS_PTR) malloc(sizeof(CK_AES_CTR_PARAMS));

  1100         if (ckpParam == NULL) {

  1101             throwOutOfMemoryError(env, 0);

  1102             return;

  1103         }

  1104 

  1105         /* convert jParameter to CKParameter */

  1106         jAesCtrParamsToCKAesCtrParam(env, jParam, ckpParam);

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

  1108             free(ckpParam);

  1109             return;

  1110         }

  1111 

  1112         /* get length and pointer of parameter */

  1113         *ckpLength = sizeof(CK_AES_CTR_PARAMS);

  1114         *ckpParamPtr = ckpParam;

  1115         return;

  1116     }

  1117 

  1118     jRsaPkcsOaepParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_OAEP_PARAMS);

  1119     if (jRsaPkcsOaepParamsClass == NULL) { return; }

  1120     if ((*env)->IsInstanceOf(env, jParam, jRsaPkcsOaepParamsClass)) {

  1121         /*

  1122          * CK_RSA_PKCS_OAEP_PARAMS

  1123          */

  1124         CK_RSA_PKCS_OAEP_PARAMS_PTR ckpParam;

  1125 

  1126         ckpParam = (CK_RSA_PKCS_OAEP_PARAMS_PTR) malloc(sizeof(CK_RSA_PKCS_OAEP_PARAMS));

  1127         if (ckpParam == NULL) {

  1128             throwOutOfMemoryError(env, 0);

  1129             return;

  1130         }

  1131 

  1132         /* convert jParameter to CKParameter */

  1133         *ckpParam = jRsaPkcsOaepParamToCKRsaPkcsOaepParam(env, jParam);

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

  1135             free(ckpParam);