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
71void 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 */
81jobject 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 */
127jobject 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 */
165jobject 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 */
208jobject 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 */
248CK_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 */
293CK_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 */
418CK_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 */
468CK_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 */
525CK_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 */
585CK_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 */
708void 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 */
748void 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 */
812jobject 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 */
964void 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
980void 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);
1136            return;
1137        }
1138
1139        /* get length and pointer of parameter */
1140        *ckpLength = sizeof(CK_RSA_PKCS_OAEP_PARAMS);
1141        *ckpParamPtr = ckpParam;
1142        return;
1143    }
1144
1145    jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS);
1146    if (jPbeParamsClass == NULL) { return; }
1147    if ((*env)->IsInstanceOf(env, jParam, jPbeParamsClass)) {
1148        /*
1149         * CK_PBE_PARAMS
1150         */
1151        CK_PBE_PARAMS_PTR ckpParam;
1152
1153        ckpParam = (CK_PBE_PARAMS_PTR) malloc(sizeof(CK_PBE_PARAMS));
1154        if (ckpParam == NULL) {
1155            throwOutOfMemoryError(env, 0);
1156            return;
1157        }
1158
1159        /* convert jParameter to CKParameter */
1160        *ckpParam = jPbeParamToCKPbeParam(env, jParam);
1161        if ((*env)->ExceptionCheck(env)) {
1162            free(ckpParam);
1163            return;
1164        }
1165
1166        /* get length and pointer of parameter */
1167        *ckpLength = sizeof(CK_PBE_PARAMS);
1168        *ckpParamPtr = ckpParam;
1169        return;
1170    }
1171
1172    jPkcs5Pbkd2ParamsClass = (*env)->FindClass(env, CLASS_PKCS5_PBKD2_PARAMS);
1173    if (jPkcs5Pbkd2ParamsClass == NULL) { return; }
1174    if ((*env)->IsInstanceOf(env, jParam, jPkcs5Pbkd2ParamsClass)) {
1175        /*
1176         * CK_PKCS5_PBKD2_PARAMS
1177         */
1178        CK_PKCS5_PBKD2_PARAMS_PTR ckpParam;
1179
1180        ckpParam = (CK_PKCS5_PBKD2_PARAMS_PTR) malloc(sizeof(CK_PKCS5_PBKD2_PARAMS));
1181        if (ckpParam == NULL) {
1182            throwOutOfMemoryError(env, 0);
1183            return;
1184        }
1185
1186        /* convert jParameter to CKParameter */
1187        *ckpParam = jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(env, jParam);
1188        if ((*env)->ExceptionCheck(env)) {
1189            free(ckpParam);
1190            return;
1191        }
1192
1193        /* get length and pointer of parameter */
1194        *ckpLength = sizeof(CK_PKCS5_PBKD2_PARAMS);
1195        *ckpParamPtr = ckpParam;
1196        return;
1197    }
1198
1199    jRsaPkcsPssParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_PSS_PARAMS);
1200    if (jRsaPkcsPssParamsClass == NULL) { return; }
1201    if ((*env)->IsInstanceOf(env, jParam, jRsaPkcsPssParamsClass)) {
1202        /*
1203         * CK_RSA_PKCS_PSS_PARAMS
1204         */
1205        CK_RSA_PKCS_PSS_PARAMS_PTR ckpParam;
1206
1207        ckpParam = (CK_RSA_PKCS_PSS_PARAMS_PTR) malloc(sizeof(CK_RSA_PKCS_PSS_PARAMS));
1208        if (ckpParam == NULL) {
1209            throwOutOfMemoryError(env, 0);
1210            return;
1211        }
1212
1213        /* convert jParameter to CKParameter */
1214        *ckpParam = jRsaPkcsPssParamToCKRsaPkcsPssParam(env, jParam);
1215        if ((*env)->ExceptionCheck(env)) {
1216            free(ckpParam);
1217            return;
1218        }
1219
1220        /* get length and pointer of parameter */
1221        *ckpLength = sizeof(CK_RSA_PKCS_PSS_PARAMS);
1222        *ckpParamPtr = ckpParam;
1223        return;
1224    }
1225
1226    jEcdh1DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH1_DERIVE_PARAMS);
1227    if (jEcdh1DeriveParamsClass == NULL) { return; }
1228    if ((*env)->IsInstanceOf(env, jParam, jEcdh1DeriveParamsClass)) {
1229        /*
1230         * CK_ECDH1_DERIVE_PARAMS
1231         */
1232        CK_ECDH1_DERIVE_PARAMS_PTR ckpParam;
1233
1234        ckpParam = (CK_ECDH1_DERIVE_PARAMS_PTR) malloc(sizeof(CK_ECDH1_DERIVE_PARAMS));
1235        if (ckpParam == NULL) {
1236            throwOutOfMemoryError(env, 0);
1237            return;
1238        }
1239
1240        /* convert jParameter to CKParameter */
1241        *ckpParam = jEcdh1DeriveParamToCKEcdh1DeriveParam(env, jParam);
1242        if ((*env)->ExceptionCheck(env)) {
1243            free(ckpParam);
1244            return;
1245        }
1246
1247        /* get length and pointer of parameter */
1248        *ckpLength = sizeof(CK_ECDH1_DERIVE_PARAMS);
1249        *ckpParamPtr = ckpParam;
1250        return;
1251    }
1252
1253    jEcdh2DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH2_DERIVE_PARAMS);
1254    if (jEcdh2DeriveParamsClass == NULL) { return; }
1255    if ((*env)->IsInstanceOf(env, jParam, jEcdh2DeriveParamsClass)) {
1256        /*
1257         * CK_ECDH2_DERIVE_PARAMS
1258         */
1259        CK_ECDH2_DERIVE_PARAMS_PTR ckpParam;
1260
1261        ckpParam = (CK_ECDH2_DERIVE_PARAMS_PTR) malloc(sizeof(CK_ECDH2_DERIVE_PARAMS));
1262        if (ckpParam == NULL) {
1263            throwOutOfMemoryError(env, 0);
1264            return;
1265        }
1266
1267        /* convert jParameter to CKParameter */
1268        *ckpParam = jEcdh2DeriveParamToCKEcdh2DeriveParam(env, jParam);
1269        if ((*env)->ExceptionCheck(env)) {
1270            free(ckpParam);
1271            return;
1272        }
1273
1274        /* get length and pointer of parameter */
1275        *ckpLength = sizeof(CK_ECDH2_DERIVE_PARAMS);
1276        *ckpParamPtr = ckpParam;
1277        return;
1278    }
1279
1280    jX942Dh1DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH1_DERIVE_PARAMS);
1281    if (jX942Dh1DeriveParamsClass == NULL) { return; }
1282    if ((*env)->IsInstanceOf(env, jParam, jX942Dh1DeriveParamsClass)) {
1283        /*
1284         * CK_X9_42_DH1_DERIVE_PARAMS
1285         */
1286        CK_X9_42_DH1_DERIVE_PARAMS_PTR ckpParam;
1287
1288        ckpParam = (CK_X9_42_DH1_DERIVE_PARAMS_PTR) malloc(sizeof(CK_X9_42_DH1_DERIVE_PARAMS));
1289        if (ckpParam == NULL) {
1290            throwOutOfMemoryError(env, 0);
1291            return;
1292        }
1293
1294        /* convert jParameter to CKParameter */
1295        *ckpParam = jX942Dh1DeriveParamToCKX942Dh1DeriveParam(env, jParam);
1296        if ((*env)->ExceptionCheck(env)) {
1297            free(ckpParam);
1298            return;
1299        }
1300
1301        /* get length and pointer of parameter */
1302        *ckpLength = sizeof(CK_X9_42_DH1_DERIVE_PARAMS);
1303        *ckpParamPtr = ckpParam;
1304        return;
1305    }
1306
1307    jX942Dh2DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH2_DERIVE_PARAMS);
1308    if (jX942Dh2DeriveParamsClass == NULL) { return; }
1309    if ((*env)->IsInstanceOf(env, jParam, jX942Dh2DeriveParamsClass)) {
1310        /*
1311         * CK_X9_42_DH2_DERIVE_PARAMS
1312         */
1313        CK_X9_42_DH2_DERIVE_PARAMS_PTR ckpParam;
1314
1315        ckpParam = (CK_X9_42_DH2_DERIVE_PARAMS_PTR) malloc(sizeof(CK_X9_42_DH2_DERIVE_PARAMS));
1316        if (ckpParam == NULL) {
1317            throwOutOfMemoryError(env, 0);
1318            return;
1319        }
1320
1321        /* convert jParameter to CKParameter */
1322        *ckpParam = jX942Dh2DeriveParamToCKX942Dh2DeriveParam(env, jParam);
1323        if ((*env)->ExceptionCheck(env)) {
1324            free(ckpParam);
1325            return;
1326        }
1327
1328        /* get length and pointer of parameter */
1329        *ckpLength = sizeof(CK_X9_42_DH2_DERIVE_PARAMS);
1330        *ckpParamPtr = ckpParam;
1331        return;
1332    }
1333
1334    /* if everything faild up to here */
1335    /* try if the parameter is a primitive Java type */
1336    jObjectToPrimitiveCKObjectPtrPtr(env, jParam, ckpParamPtr, ckpLength);
1337    /* *ckpParamPtr = jObjectToCKVoidPtr(jParam); */
1338    /* *ckpLength = 1; */
1339
1340    TRACE0("FINISHED\n");
1341}
1342
1343
1344/* the mechanism parameter convertion functions: */
1345
1346/*
1347 * converts the Java CK_RSA_PKCS_OAEP_PARAMS object to a CK_RSA_PKCS_OAEP_PARAMS structure
1348 *
1349 * @param env - used to call JNI funktions to get the Java classes and objects
1350 * @param jParam - the Java CK_RSA_PKCS_OAEP_PARAMS object to convert
1351 * @return - the new CK_RSA_PKCS_OAEP_PARAMS structure
1352 */
1353CK_RSA_PKCS_OAEP_PARAMS jRsaPkcsOaepParamToCKRsaPkcsOaepParam(JNIEnv *env, jobject jParam)
1354{
1355    jclass jRsaPkcsOaepParamsClass;
1356    CK_RSA_PKCS_OAEP_PARAMS ckParam;
1357    jfieldID fieldID;
1358    jlong jHashAlg, jMgf, jSource;
1359    jobject jSourceData;
1360    CK_BYTE_PTR ckpByte;
1361    memset(&ckParam, 0, sizeof(CK_RSA_PKCS_OAEP_PARAMS));
1362
1363    /* get hashAlg */
1364    jRsaPkcsOaepParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_OAEP_PARAMS);
1365    if (jRsaPkcsOaepParamsClass == NULL) { return ckParam; }
1366    fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "hashAlg", "J");
1367    if (fieldID == NULL) { return ckParam; }
1368    jHashAlg = (*env)->GetLongField(env, jParam, fieldID);
1369
1370    /* get mgf */
1371    fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "mgf", "J");
1372    if (fieldID == NULL) { return ckParam; }
1373    jMgf = (*env)->GetLongField(env, jParam, fieldID);
1374
1375    /* get source */
1376    fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "source", "J");
1377    if (fieldID == NULL) { return ckParam; }
1378    jSource = (*env)->GetLongField(env, jParam, fieldID);
1379
1380    /* get sourceData and sourceDataLength */
1381    fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "pSourceData", "[B");
1382    if (fieldID == NULL) { return ckParam; }
1383    jSourceData = (*env)->GetObjectField(env, jParam, fieldID);
1384
1385    /* populate java values */
1386    ckParam.hashAlg = jLongToCKULong(jHashAlg);
1387    ckParam.mgf = jLongToCKULong(jMgf);
1388    ckParam.source = jLongToCKULong(jSource);
1389    jByteArrayToCKByteArray(env, jSourceData, & ckpByte, &(ckParam.ulSourceDataLen));
1390    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1391    ckParam.pSourceData = (CK_VOID_PTR) ckpByte;
1392
1393    return ckParam ;
1394}
1395
1396/*
1397 * converts the Java CK_PBE_PARAMS object to a CK_PBE_PARAMS structure
1398 *
1399 * @param env - used to call JNI funktions to get the Java classes and objects
1400 * @param jParam - the Java CK_PBE_PARAMS object to convert
1401 * @return - the new CK_PBE_PARAMS structure
1402 */
1403CK_PBE_PARAMS jPbeParamToCKPbeParam(JNIEnv *env, jobject jParam)
1404{
1405    jclass jPbeParamsClass;
1406    CK_PBE_PARAMS ckParam;
1407    jfieldID fieldID;
1408    jlong jIteration;
1409    jobject jInitVector, jPassword, jSalt;
1410    CK_ULONG ckTemp;
1411    memset(&ckParam, 0, sizeof(CK_PBE_PARAMS));
1412
1413    /* get pInitVector */
1414    jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS);
1415    if (jPbeParamsClass == NULL) { return ckParam; }
1416    fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pInitVector", "[C");
1417    if (fieldID == NULL) { return ckParam; }
1418    jInitVector = (*env)->GetObjectField(env, jParam, fieldID);
1419
1420    /* get pPassword and ulPasswordLength */
1421    fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pPassword", "[C");
1422    if (fieldID == NULL) { return ckParam; }
1423    jPassword = (*env)->GetObjectField(env, jParam, fieldID);
1424
1425    /* get pSalt and ulSaltLength */
1426    fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pSalt", "[C");
1427    if (fieldID == NULL) { return ckParam; }
1428    jSalt = (*env)->GetObjectField(env, jParam, fieldID);
1429
1430    /* get ulIteration */
1431    fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "ulIteration", "J");
1432    if (fieldID == NULL) { return ckParam; }
1433    jIteration = (*env)->GetLongField(env, jParam, fieldID);
1434
1435    /* populate java values */
1436    ckParam.ulIteration = jLongToCKULong(jIteration);
1437    jCharArrayToCKCharArray(env, jInitVector, &(ckParam.pInitVector), &ckTemp);
1438    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1439    jCharArrayToCKCharArray(env, jPassword, &(ckParam.pPassword), &(ckParam.ulPasswordLen));
1440    if ((*env)->ExceptionCheck(env)) {
1441        free(ckParam.pInitVector);
1442        return ckParam;
1443    }
1444    jCharArrayToCKCharArray(env, jSalt, &(ckParam.pSalt), &(ckParam.ulSaltLen));
1445    if ((*env)->ExceptionCheck(env)) {
1446        free(ckParam.pInitVector);
1447        free(ckParam.pPassword);
1448        return ckParam;
1449    }
1450
1451    return ckParam ;
1452}
1453
1454/*
1455 * Copy back the initialization vector from the native structure to the
1456 * Java object. This is only used for CKM_PBE_* mechanisms and their
1457 * CK_PBE_PARAMS parameters.
1458 *
1459 */
1460void copyBackPBEInitializationVector(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism)
1461{
1462    jclass jMechanismClass, jPbeParamsClass;
1463    CK_PBE_PARAMS *ckParam;
1464    jfieldID fieldID;
1465    CK_MECHANISM_TYPE ckMechanismType;
1466    jlong jMechanismType;
1467    jobject jParameter;
1468    jobject jInitVector;
1469    jint jInitVectorLength;
1470    CK_CHAR_PTR initVector;
1471    int i;
1472    jchar* jInitVectorChars;
1473
1474    /* get mechanism */
1475    jMechanismClass = (*env)->FindClass(env, CLASS_MECHANISM);
1476    if (jMechanismClass == NULL) { return; }
1477    fieldID = (*env)->GetFieldID(env, jMechanismClass, "mechanism", "J");
1478    if (fieldID == NULL) { return; }
1479    jMechanismType = (*env)->GetLongField(env, jMechanism, fieldID);
1480    ckMechanismType = jLongToCKULong(jMechanismType);
1481    if (ckMechanismType != ckMechanism->mechanism) {
1482        /* we do not have maching types, this should not occur */
1483        return;
1484    }
1485
1486    jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS);
1487    if (jPbeParamsClass == NULL) { return; }
1488    ckParam = (CK_PBE_PARAMS *) ckMechanism->pParameter;
1489    if (ckParam != NULL_PTR) {
1490        initVector = ckParam->pInitVector;
1491        if (initVector != NULL_PTR) {
1492            /* get pParameter */
1493            fieldID = (*env)->GetFieldID(env, jMechanismClass, "pParameter", "Ljava/lang/Object;");
1494            if (fieldID == NULL) { return; }
1495            jParameter = (*env)->GetObjectField(env, jMechanism, fieldID);
1496            fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pInitVektor", "[C");
1497            if (fieldID == NULL) { return; }
1498            jInitVector = (*env)->GetObjectField(env, jParameter, fieldID);
1499
1500            if (jInitVector != NULL) {
1501                jInitVectorLength = (*env)->GetArrayLength(env, jInitVector);
1502                jInitVectorChars = (*env)->GetCharArrayElements(env, jInitVector, NULL);
1503                if (jInitVectorChars == NULL) { return; }
1504
1505                /* copy the chars to the Java buffer */
1506                for (i=0; i < jInitVectorLength; i++) {
1507                    jInitVectorChars[i] = ckCharToJChar(initVector[i]);
1508                }
1509                /* copy back the Java buffer to the object */
1510                (*env)->ReleaseCharArrayElements(env, jInitVector, jInitVectorChars, 0);
1511            }
1512        }
1513    }
1514}
1515
1516/*
1517 * converts the Java CK_PKCS5_PBKD2_PARAMS object to a CK_PKCS5_PBKD2_PARAMS structure
1518 *
1519 * @param env - used to call JNI funktions to get the Java classes and objects
1520 * @param jParam - the Java CK_PKCS5_PBKD2_PARAMS object to convert
1521 * @return - the new CK_PKCS5_PBKD2_PARAMS structure
1522 */
1523CK_PKCS5_PBKD2_PARAMS jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(JNIEnv *env, jobject jParam)
1524{
1525    jclass jPkcs5Pbkd2ParamsClass;
1526    CK_PKCS5_PBKD2_PARAMS ckParam;
1527    jfieldID fieldID;
1528    jlong jSaltSource, jIteration, jPrf;
1529    jobject jSaltSourceData, jPrfData;
1530    memset(&ckParam, 0, sizeof(CK_PKCS5_PBKD2_PARAMS));
1531
1532    /* get saltSource */
1533    jPkcs5Pbkd2ParamsClass = (*env)->FindClass(env, CLASS_PKCS5_PBKD2_PARAMS);
1534    if (jPkcs5Pbkd2ParamsClass == NULL) { return ckParam; }
1535    fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "saltSource", "J");
1536    if (fieldID == NULL) { return ckParam; }
1537    jSaltSource = (*env)->GetLongField(env, jParam, fieldID);
1538
1539    /* get pSaltSourceData */
1540    fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "pSaltSourceData", "[B");
1541    if (fieldID == NULL) { return ckParam; }
1542    jSaltSourceData = (*env)->GetObjectField(env, jParam, fieldID);
1543
1544    /* get iterations */
1545    fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "iterations", "J");
1546    if (fieldID == NULL) { return ckParam; }
1547    jIteration = (*env)->GetLongField(env, jParam, fieldID);
1548
1549    /* get prf */
1550    fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "prf", "J");
1551    if (fieldID == NULL) { return ckParam; }
1552    jPrf = (*env)->GetLongField(env, jParam, fieldID);
1553
1554    /* get pPrfData and ulPrfDataLength in byte */
1555    fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "pPrfData", "[B");
1556    if (fieldID == NULL) { return ckParam; }
1557    jPrfData = (*env)->GetObjectField(env, jParam, fieldID);
1558
1559    /* populate java values */
1560    ckParam.saltSource = jLongToCKULong(jSaltSource);
1561    jByteArrayToCKByteArray(env, jSaltSourceData, (CK_BYTE_PTR *) &(ckParam.pSaltSourceData), &(ckParam.ulSaltSourceDataLen));
1562    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1563    ckParam.iterations = jLongToCKULong(jIteration);
1564    ckParam.prf = jLongToCKULong(jPrf);
1565    jByteArrayToCKByteArray(env, jPrfData, (CK_BYTE_PTR *) &(ckParam.pPrfData), &(ckParam.ulPrfDataLen));
1566    if ((*env)->ExceptionCheck(env)) {
1567        free(ckParam.pSaltSourceData);
1568        return ckParam;
1569    }
1570
1571    return ckParam ;
1572}
1573
1574/*
1575 * converts the Java CK_RSA_PKCS_PSS_PARAMS object to a CK_RSA_PKCS_PSS_PARAMS structure
1576 *
1577 * @param env - used to call JNI funktions to get the Java classes and objects
1578 * @param jParam - the Java CK_RSA_PKCS_PSS_PARAMS object to convert
1579 * @return - the new CK_RSA_PKCS_PSS_PARAMS structure
1580 */
1581CK_RSA_PKCS_PSS_PARAMS jRsaPkcsPssParamToCKRsaPkcsPssParam(JNIEnv *env, jobject jParam)
1582{
1583    jclass jRsaPkcsPssParamsClass;
1584    CK_RSA_PKCS_PSS_PARAMS ckParam;
1585    jfieldID fieldID;
1586    jlong jHashAlg, jMgf, jSLen;
1587    memset(&ckParam, 0, sizeof(CK_RSA_PKCS_PSS_PARAMS));
1588
1589    /* get hashAlg */
1590    jRsaPkcsPssParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_PSS_PARAMS);
1591    if (jRsaPkcsPssParamsClass == NULL) { return ckParam; }
1592    fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "hashAlg", "J");
1593    if (fieldID == NULL) { return ckParam; }
1594    jHashAlg = (*env)->GetLongField(env, jParam, fieldID);
1595
1596    /* get mgf */
1597    fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "mgf", "J");
1598    if (fieldID == NULL) { return ckParam; }
1599    jMgf = (*env)->GetLongField(env, jParam, fieldID);
1600
1601    /* get sLen */
1602    fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "sLen", "J");
1603    if (fieldID == NULL) { return ckParam; }
1604    jSLen = (*env)->GetLongField(env, jParam, fieldID);
1605
1606    /* populate java values */
1607    ckParam.hashAlg = jLongToCKULong(jHashAlg);
1608    ckParam.mgf = jLongToCKULong(jMgf);
1609    ckParam.sLen = jLongToCKULong(jSLen);
1610
1611    return ckParam ;
1612}
1613
1614/*
1615 * converts the Java CK_ECDH1_DERIVE_PARAMS object to a CK_ECDH1_DERIVE_PARAMS structure
1616 *
1617 * @param env - used to call JNI funktions to get the Java classes and objects
1618 * @param jParam - the Java CK_ECDH1_DERIVE_PARAMS object to convert
1619 * @return - the new CK_ECDH1_DERIVE_PARAMS structure
1620 */
1621CK_ECDH1_DERIVE_PARAMS jEcdh1DeriveParamToCKEcdh1DeriveParam(JNIEnv *env, jobject jParam)
1622{
1623    jclass jEcdh1DeriveParamsClass;
1624    CK_ECDH1_DERIVE_PARAMS ckParam;
1625    jfieldID fieldID;
1626    jlong jLong;
1627    jobject jSharedData, jPublicData;
1628    memset(&ckParam, 0, sizeof(CK_ECDH1_DERIVE_PARAMS));
1629
1630    /* get kdf */
1631    jEcdh1DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH1_DERIVE_PARAMS);
1632    if (jEcdh1DeriveParamsClass == NULL) { return ckParam; }
1633    fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "kdf", "J");
1634    if (fieldID == NULL) { return ckParam; }
1635    jLong = (*env)->GetLongField(env, jParam, fieldID);
1636    ckParam.kdf = jLongToCKULong(jLong);
1637
1638    /* get pSharedData and ulSharedDataLen */
1639    fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "pSharedData", "[B");
1640    if (fieldID == NULL) { return ckParam; }
1641    jSharedData = (*env)->GetObjectField(env, jParam, fieldID);
1642
1643    /* get pPublicData and ulPublicDataLen */
1644    fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "pPublicData", "[B");
1645    if (fieldID == NULL) { return ckParam; }
1646    jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
1647
1648    /* populate java values */
1649    ckParam.kdf = jLongToCKULong(jLong);
1650    jByteArrayToCKByteArray(env, jSharedData, &(ckParam.pSharedData), &(ckParam.ulSharedDataLen));
1651    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1652    jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen));
1653    if ((*env)->ExceptionCheck(env)) {
1654        free(ckParam.pSharedData);
1655        return ckParam;
1656    }
1657
1658    return ckParam ;
1659}
1660
1661/*
1662 * converts the Java CK_ECDH2_DERIVE_PARAMS object to a CK_ECDH2_DERIVE_PARAMS structure
1663 *
1664 * @param env - used to call JNI funktions to get the Java classes and objects
1665 * @param jParam - the Java CK_ECDH2_DERIVE_PARAMS object to convert
1666 * @return - the new CK_ECDH2_DERIVE_PARAMS structure
1667 */
1668CK_ECDH2_DERIVE_PARAMS jEcdh2DeriveParamToCKEcdh2DeriveParam(JNIEnv *env, jobject jParam)
1669{
1670    jclass jEcdh2DeriveParamsClass;
1671    CK_ECDH2_DERIVE_PARAMS ckParam;
1672    jfieldID fieldID;
1673    jlong jKdf, jPrivateDataLen, jPrivateData;
1674    jobject jSharedData, jPublicData, jPublicData2;
1675    memset(&ckParam, 0, sizeof(CK_ECDH2_DERIVE_PARAMS));
1676
1677    /* get kdf */
1678    jEcdh2DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH2_DERIVE_PARAMS);
1679    if (jEcdh2DeriveParamsClass == NULL) { return ckParam; }
1680    fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "kdf", "J");
1681    if (fieldID == NULL) { return ckParam; }
1682    jKdf = (*env)->GetLongField(env, jParam, fieldID);
1683
1684    /* get pSharedData and ulSharedDataLen */
1685    fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pSharedData", "[B");
1686    if (fieldID == NULL) { return ckParam; }
1687    jSharedData = (*env)->GetObjectField(env, jParam, fieldID);
1688
1689    /* get pPublicData and ulPublicDataLen */
1690    fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pPublicData", "[B");
1691    if (fieldID == NULL) { return ckParam; }
1692    jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
1693
1694    /* get ulPrivateDataLen */
1695    fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "ulPrivateDataLen", "J");
1696    if (fieldID == NULL) { return ckParam; }
1697    jPrivateDataLen = (*env)->GetLongField(env, jParam, fieldID);
1698
1699    /* get hPrivateData */
1700    fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "hPrivateData", "J");
1701    if (fieldID == NULL) { return ckParam; }
1702    jPrivateData = (*env)->GetLongField(env, jParam, fieldID);
1703
1704    /* get pPublicData2 and ulPublicDataLen2 */
1705    fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pPublicData2", "[B");
1706    if (fieldID == NULL) { return ckParam; }
1707    jPublicData2 = (*env)->GetObjectField(env, jParam, fieldID);
1708
1709    /* populate java values */
1710    ckParam.kdf = jLongToCKULong(jKdf);
1711    jByteArrayToCKByteArray(env, jSharedData, &(ckParam.pSharedData), &(ckParam.ulSharedDataLen));
1712    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1713    jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen));
1714    if ((*env)->ExceptionCheck(env)) {
1715        free(ckParam.pSharedData);
1716        return ckParam;
1717    }
1718    ckParam.ulPrivateDataLen = jLongToCKULong(jPrivateDataLen);
1719    ckParam.hPrivateData = jLongToCKULong(jPrivateData);
1720    jByteArrayToCKByteArray(env, jPublicData2, &(ckParam.pPublicData2), &(ckParam.ulPublicDataLen2));
1721    if ((*env)->ExceptionCheck(env)) {
1722        free(ckParam.pSharedData);
1723        free(ckParam.pPublicData);
1724        return ckParam;
1725    }
1726    return ckParam ;
1727}
1728
1729/*
1730 * converts the Java CK_X9_42_DH1_DERIVE_PARAMS object to a CK_X9_42_DH1_DERIVE_PARAMS structure
1731 *
1732 * @param env - used to call JNI funktions to get the Java classes and objects
1733 * @param jParam - the Java CK_X9_42_DH1_DERIVE_PARAMS object to convert
1734 * @return - the new CK_X9_42_DH1_DERIVE_PARAMS structure
1735 */
1736CK_X9_42_DH1_DERIVE_PARAMS jX942Dh1DeriveParamToCKX942Dh1DeriveParam(JNIEnv *env, jobject jParam)
1737{
1738    jclass jX942Dh1DeriveParamsClass;
1739    CK_X9_42_DH1_DERIVE_PARAMS ckParam;
1740    jfieldID fieldID;
1741    jlong jKdf;
1742    jobject jOtherInfo, jPublicData;
1743    memset(&ckParam, 0, sizeof(CK_X9_42_DH1_DERIVE_PARAMS));
1744
1745    /* get kdf */
1746    jX942Dh1DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH1_DERIVE_PARAMS);
1747    if (jX942Dh1DeriveParamsClass == NULL) { return ckParam; }
1748    fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "kdf", "J");
1749    if (fieldID == NULL) { return ckParam; }
1750    jKdf = (*env)->GetLongField(env, jParam, fieldID);
1751
1752    /* get pOtherInfo and ulOtherInfoLen */
1753    fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "pOtherInfo", "[B");
1754    if (fieldID == NULL) { return ckParam; }
1755    jOtherInfo = (*env)->GetObjectField(env, jParam, fieldID);
1756
1757    /* get pPublicData and ulPublicDataLen */
1758    fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "pPublicData", "[B");
1759    if (fieldID == NULL) { return ckParam; }
1760    jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
1761
1762    /* populate java values */
1763    ckParam.kdf = jLongToCKULong(jKdf);
1764    jByteArrayToCKByteArray(env, jOtherInfo, &(ckParam.pOtherInfo), &(ckParam.ulOtherInfoLen));
1765    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1766    jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen));
1767    if ((*env)->ExceptionCheck(env)) {
1768        free(ckParam.pOtherInfo);
1769        return ckParam;
1770    }
1771
1772    return ckParam ;
1773}
1774
1775/*
1776 * converts the Java CK_X9_42_DH2_DERIVE_PARAMS object to a CK_X9_42_DH2_DERIVE_PARAMS structure
1777 *
1778 * @param env - used to call JNI funktions to get the Java classes and objects
1779 * @param jParam - the Java CK_X9_42_DH2_DERIVE_PARAMS object to convert
1780 * @return - the new CK_X9_42_DH2_DERIVE_PARAMS structure
1781 */
1782CK_X9_42_DH2_DERIVE_PARAMS jX942Dh2DeriveParamToCKX942Dh2DeriveParam(JNIEnv *env, jobject jParam)
1783{
1784    jclass jX942Dh2DeriveParamsClass;
1785    CK_X9_42_DH2_DERIVE_PARAMS ckParam;
1786    jfieldID fieldID;
1787    jlong jKdf, jPrivateDataLen, jPrivateData;
1788    jobject jOtherInfo, jPublicData, jPublicData2;
1789    memset(&ckParam, 0, sizeof(CK_X9_42_DH2_DERIVE_PARAMS));
1790
1791    /* get kdf */
1792    jX942Dh2DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH2_DERIVE_PARAMS);
1793    if (jX942Dh2DeriveParamsClass == NULL) { return ckParam; }
1794    fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "kdf", "J");
1795    if (fieldID == NULL) { return ckParam; }
1796    jKdf = (*env)->GetLongField(env, jParam, fieldID);
1797
1798    /* get pOtherInfo and ulOtherInfoLen */
1799    fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pOtherInfo", "[B");
1800    if (fieldID == NULL) { return ckParam; }
1801    jOtherInfo = (*env)->GetObjectField(env, jParam, fieldID);
1802
1803    /* get pPublicData and ulPublicDataLen */
1804    fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pPublicData", "[B");
1805    if (fieldID == NULL) { return ckParam; }
1806    jPublicData = (*env)->GetObjectField(env, jParam, fieldID);
1807
1808    /* get ulPrivateDataLen */
1809    fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "ulPrivateDataLen", "J");
1810    if (fieldID == NULL) { return ckParam; }
1811    jPrivateDataLen = (*env)->GetLongField(env, jParam, fieldID);
1812
1813    /* get hPrivateData */
1814    fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "hPrivateData", "J");
1815    if (fieldID == NULL) { return ckParam; }
1816    jPrivateData = (*env)->GetLongField(env, jParam, fieldID);
1817
1818    /* get pPublicData2 and ulPublicDataLen2 */
1819    fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pPublicData2", "[B");
1820    if (fieldID == NULL) { return ckParam; }
1821    jPublicData2 = (*env)->GetObjectField(env, jParam, fieldID);
1822
1823    /* populate java values */
1824    ckParam.kdf = jLongToCKULong(jKdf);
1825    jByteArrayToCKByteArray(env, jOtherInfo, &(ckParam.pOtherInfo), &(ckParam.ulOtherInfoLen));
1826    if ((*env)->ExceptionCheck(env)) { return ckParam; }
1827    jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen));
1828    if ((*env)->ExceptionCheck(env)) {
1829        free(ckParam.pOtherInfo);
1830        return ckParam;
1831    }
1832    ckParam.ulPrivateDataLen = jLongToCKULong(jPrivateDataLen);
1833    ckParam.hPrivateData = jLongToCKULong(jPrivateData);
1834    jByteArrayToCKByteArray(env, jPublicData2, &(ckParam.pPublicData2), &(ckParam.ulPublicDataLen2));
1835    if ((*env)->ExceptionCheck(env)) {
1836        free(ckParam.pOtherInfo);
1837        free(ckParam.pPublicData);
1838        return ckParam;
1839    }
1840
1841    return ckParam ;
1842}
1843