1 /* 2 * Copyright (c) 2003, 2011, 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 478 /* get RandomInfo */ 479 jSsl3MasterKeyDeriveParamsClass = (*env)->FindClass(env, CLASS_SSL3_MASTER_KEY_DERIVE_PARAMS); 480 if (jSsl3MasterKeyDeriveParamsClass == NULL) { return ckParam; } 481 fieldID = (*env)->GetFieldID(env, jSsl3MasterKeyDeriveParamsClass, "RandomInfo", "Lsun/security/pkcs11/wrapper/CK_SSL3_RANDOM_DATA;"); 482 if (fieldID == NULL) { return ckParam; } 483 jRandomInfo = (*env)->GetObjectField(env, jParam, fieldID); 484 485 /* get pClientRandom and ulClientRandomLength out of RandomInfo */ 486 jSsl3RandomDataClass = (*env)->FindClass(env, CLASS_SSL3_RANDOM_DATA); 487 if (jSsl3RandomDataClass == NULL) { return ckParam; } 488 fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pClientRandom", "[B"); 489 if (fieldID == NULL) { return ckParam; } 490 jRIClientRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID); 491 492 /* get pServerRandom and ulServerRandomLength out of RandomInfo */ 493 fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pServerRandom", "[B"); 494 if (fieldID == NULL) { return ckParam; } 495 jRIServerRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID); 496 497 /* get pVersion */ 498 fieldID = (*env)->GetFieldID(env, jSsl3MasterKeyDeriveParamsClass, "pVersion", "Lsun/security/pkcs11/wrapper/CK_VERSION;"); 499 if (fieldID == NULL) { return ckParam; } 500 jVersion = (*env)->GetObjectField(env, jParam, fieldID); 501 502 /* populate java values */ 503 ckParam.pVersion = jVersionToCKVersionPtr(env, jVersion); 504 if ((*env)->ExceptionCheck(env)) { return ckParam; } 505 jByteArrayToCKByteArray(env, jRIClientRandom, &(ckParam.RandomInfo.pClientRandom), &(ckParam.RandomInfo.ulClientRandomLen)); 506 if ((*env)->ExceptionCheck(env)) { 507 free(ckParam.pVersion); 508 return ckParam; 509 } 510 jByteArrayToCKByteArray(env, jRIServerRandom, &(ckParam.RandomInfo.pServerRandom), &(ckParam.RandomInfo.ulServerRandomLen)); 511 if ((*env)->ExceptionCheck(env)) { 512 free(ckParam.pVersion); 513 free(ckParam.RandomInfo.pClientRandom); 514 return ckParam; 515 } 516 517 return ckParam ; 518 } 519 520 521 /* 522 * converts the Java CK_TLS_PRF_PARAMS object to a CK_TLS_PRF_PARAMS structure 523 */ 524 CK_TLS_PRF_PARAMS jTlsPrfParamsToCKTlsPrfParam(JNIEnv *env, jobject jParam) 525 { 526 jclass jTlsPrfParamsClass; 527 CK_TLS_PRF_PARAMS ckParam; 528 jfieldID fieldID; 529 jobject jSeed, jLabel, jOutput; 530 531 // TBD: what if jParam == NULL?! 532 533 /* get pSeed */ 534 jTlsPrfParamsClass = (*env)->FindClass(env, CLASS_TLS_PRF_PARAMS); 535 if (jTlsPrfParamsClass == NULL) { return ckParam; } 536 fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pSeed", "[B"); 537 if (fieldID == NULL) { return ckParam; } 538 jSeed = (*env)->GetObjectField(env, jParam, fieldID); 539 540 /* get pLabel */ 541 fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pLabel", "[B"); 542 if (fieldID == NULL) { return ckParam; } 543 jLabel = (*env)->GetObjectField(env, jParam, fieldID); 544 545 /* get pOutput */ 546 fieldID = (*env)->GetFieldID(env, jTlsPrfParamsClass, "pOutput", "[B"); 547 if (fieldID == NULL) { return ckParam; } 548 jOutput = (*env)->GetObjectField(env, jParam, fieldID); 549 550 /* populate java values */ 551 jByteArrayToCKByteArray(env, jSeed, &(ckParam.pSeed), &(ckParam.ulSeedLen)); 552 if ((*env)->ExceptionCheck(env)) { return ckParam; } 553 jByteArrayToCKByteArray(env, jLabel, &(ckParam.pLabel), &(ckParam.ulLabelLen)); 554 if ((*env)->ExceptionCheck(env)) { 555 free(ckParam.pSeed); 556 return ckParam; 557 } 558 ckParam.pulOutputLen = malloc(sizeof(CK_ULONG)); 559 if (ckParam.pulOutputLen == NULL) { 560 free(ckParam.pSeed); 561 free(ckParam.pLabel); 562 throwOutOfMemoryError(env, 0); 563 return ckParam; 564 } 565 jByteArrayToCKByteArray(env, jOutput, &(ckParam.pOutput), ckParam.pulOutputLen); 566 if ((*env)->ExceptionCheck(env)) { 567 free(ckParam.pSeed); 568 free(ckParam.pLabel); 569 free(ckParam.pulOutputLen); 570 return ckParam; 571 } 572 573 return ckParam ; 574 } 575 576 /* 577 * converts the Java CK_SSL3_KEY_MAT_PARAMS object to a CK_SSL3_KEY_MAT_PARAMS structure 578 * 579 * @param env - used to call JNI funktions to get the Java classes and objects 580 * @param jParam - the Java CK_SSL3_KEY_MAT_PARAMS object to convert 581 * @return - the new CK_SSL3_KEY_MAT_PARAMS structure 582 */ 583 CK_SSL3_KEY_MAT_PARAMS jSsl3KeyMatParamToCKSsl3KeyMatParam(JNIEnv *env, jobject jParam) 584 { 585 // XXX don't return structs 586 // XXX prefetch class and field ids 587 jclass jSsl3KeyMatParamsClass, jSsl3RandomDataClass, jSsl3KeyMatOutClass; 588 CK_SSL3_KEY_MAT_PARAMS ckParam; 589 jfieldID fieldID; 590 jlong jMacSizeInBits, jKeySizeInBits, jIVSizeInBits; 591 jboolean jIsExport; 592 jobject jRandomInfo, jRIClientRandom, jRIServerRandom; 593 jobject jReturnedKeyMaterial, jRMIvClient, jRMIvServer; 594 CK_ULONG ckTemp; 595 596 /* get ulMacSizeInBits */ 597 jSsl3KeyMatParamsClass = (*env)->FindClass(env, CLASS_SSL3_KEY_MAT_PARAMS); 598 if (jSsl3KeyMatParamsClass == NULL) { return ckParam; } 599 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "ulMacSizeInBits", "J"); 600 if (fieldID == NULL) { return ckParam; } 601 jMacSizeInBits = (*env)->GetLongField(env, jParam, fieldID); 602 603 /* get ulKeySizeInBits */ 604 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "ulKeySizeInBits", "J"); 605 if (fieldID == NULL) { return ckParam; } 606 jKeySizeInBits = (*env)->GetLongField(env, jParam, fieldID); 607 608 /* get ulIVSizeInBits */ 609 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "ulIVSizeInBits", "J"); 610 if (fieldID == NULL) { return ckParam; } 611 jIVSizeInBits = (*env)->GetLongField(env, jParam, fieldID); 612 613 /* get bIsExport */ 614 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "bIsExport", "Z"); 615 if (fieldID == NULL) { return ckParam; } 616 jIsExport = (*env)->GetBooleanField(env, jParam, fieldID); 617 618 /* get RandomInfo */ 619 jSsl3RandomDataClass = (*env)->FindClass(env, CLASS_SSL3_RANDOM_DATA); 620 if (jSsl3RandomDataClass == NULL) { return ckParam; } 621 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "RandomInfo", "Lsun/security/pkcs11/wrapper/CK_SSL3_RANDOM_DATA;"); 622 if (fieldID == NULL) { return ckParam; } 623 jRandomInfo = (*env)->GetObjectField(env, jParam, fieldID); 624 625 /* get pClientRandom and ulClientRandomLength out of RandomInfo */ 626 fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pClientRandom", "[B"); 627 if (fieldID == NULL) { return ckParam; } 628 jRIClientRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID); 629 630 /* get pServerRandom and ulServerRandomLength out of RandomInfo */ 631 fieldID = (*env)->GetFieldID(env, jSsl3RandomDataClass, "pServerRandom", "[B"); 632 if (fieldID == NULL) { return ckParam; } 633 jRIServerRandom = (*env)->GetObjectField(env, jRandomInfo, fieldID); 634 635 /* get pReturnedKeyMaterial */ 636 jSsl3KeyMatOutClass = (*env)->FindClass(env, CLASS_SSL3_KEY_MAT_OUT); 637 if (jSsl3KeyMatOutClass == NULL) { return ckParam; } 638 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatParamsClass, "pReturnedKeyMaterial", "Lsun/security/pkcs11/wrapper/CK_SSL3_KEY_MAT_OUT;"); 639 if (fieldID == NULL) { return ckParam; } 640 jReturnedKeyMaterial = (*env)->GetObjectField(env, jParam, fieldID); 641 642 /* get pIVClient out of pReturnedKeyMaterial */ 643 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatOutClass, "pIVClient", "[B"); 644 if (fieldID == NULL) { return ckParam; } 645 jRMIvClient = (*env)->GetObjectField(env, jReturnedKeyMaterial, fieldID); 646 647 /* get pIVServer out of pReturnedKeyMaterial */ 648 fieldID = (*env)->GetFieldID(env, jSsl3KeyMatOutClass, "pIVServer", "[B"); 649 if (fieldID == NULL) { return ckParam; } 650 jRMIvServer = (*env)->GetObjectField(env, jReturnedKeyMaterial, fieldID); 651 652 /* populate java values */ 653 ckParam.ulMacSizeInBits = jLongToCKULong(jMacSizeInBits); 654 ckParam.ulKeySizeInBits = jLongToCKULong(jKeySizeInBits); 655 ckParam.ulIVSizeInBits = jLongToCKULong(jIVSizeInBits); 656 ckParam.bIsExport = jBooleanToCKBBool(jIsExport); 657 jByteArrayToCKByteArray(env, jRIClientRandom, &(ckParam.RandomInfo.pClientRandom), &(ckParam.RandomInfo.ulClientRandomLen)); 658 if ((*env)->ExceptionCheck(env)) { return ckParam; } 659 jByteArrayToCKByteArray(env, jRIServerRandom, &(ckParam.RandomInfo.pServerRandom), &(ckParam.RandomInfo.ulServerRandomLen)); 660 if ((*env)->ExceptionCheck(env)) { 661 free(ckParam.RandomInfo.pClientRandom); 662 return ckParam; 663 } 664 /* allocate memory for pRetrunedKeyMaterial */ 665 ckParam.pReturnedKeyMaterial = (CK_SSL3_KEY_MAT_OUT_PTR) malloc(sizeof(CK_SSL3_KEY_MAT_OUT)); 666 if (ckParam.pReturnedKeyMaterial == NULL) { 667 free(ckParam.RandomInfo.pClientRandom); 668 free(ckParam.RandomInfo.pServerRandom); 669 throwOutOfMemoryError(env, 0); 670 return ckParam; 671 } 672 673 // the handles are output params only, no need to fetch them from Java 674 ckParam.pReturnedKeyMaterial->hClientMacSecret = 0; 675 ckParam.pReturnedKeyMaterial->hServerMacSecret = 0; 676 ckParam.pReturnedKeyMaterial->hClientKey = 0; 677 ckParam.pReturnedKeyMaterial->hServerKey = 0; 678 679 jByteArrayToCKByteArray(env, jRMIvClient, &(ckParam.pReturnedKeyMaterial->pIVClient), &ckTemp); 680 if ((*env)->ExceptionCheck(env)) { 681 free(ckParam.RandomInfo.pClientRandom); 682 free(ckParam.RandomInfo.pServerRandom); 683 free(ckParam.pReturnedKeyMaterial); 684 return ckParam; 685 } 686 jByteArrayToCKByteArray(env, jRMIvServer, &(ckParam.pReturnedKeyMaterial->pIVServer), &ckTemp); 687 if ((*env)->ExceptionCheck(env)) { 688 free(ckParam.RandomInfo.pClientRandom); 689 free(ckParam.RandomInfo.pServerRandom); 690 free(ckParam.pReturnedKeyMaterial->pIVClient); 691 free(ckParam.pReturnedKeyMaterial); 692 return ckParam; 693 } 694 695 return ckParam ; 696 } 697 698 /* 699 * converts the Java CK_AES_CTR_PARAMS object to a CK_AES_CTR_PARAMS structure 700 * 701 * @param env - used to call JNI funktions to get the Java classes and objects 702 * @param jParam - the Java CK_AES_CTR_PARAMS object to convert 703 * @param ckpParam - pointer to the new CK_AES_CTR_PARAMS structure 704 */ 705 void jAesCtrParamsToCKAesCtrParam(JNIEnv *env, jobject jParam, 706 CK_AES_CTR_PARAMS_PTR ckpParam) { 707 jclass jAesCtrParamsClass; 708 jfieldID fieldID; 709 jlong jCounterBits; 710 jobject jCb; 711 CK_BYTE_PTR ckBytes; 712 CK_ULONG ckTemp; 713 714 /* get ulCounterBits */ 715 jAesCtrParamsClass = (*env)->FindClass(env, CLASS_AES_CTR_PARAMS); 716 if (jAesCtrParamsClass == NULL) { return; } 717 fieldID = (*env)->GetFieldID(env, jAesCtrParamsClass, "ulCounterBits", "J"); 718 if (fieldID == NULL) { return; } 719 jCounterBits = (*env)->GetLongField(env, jParam, fieldID); 720 721 /* get cb */ 722 fieldID = (*env)->GetFieldID(env, jAesCtrParamsClass, "cb", "[B"); 723 if (fieldID == NULL) { return; } 724 jCb = (*env)->GetObjectField(env, jParam, fieldID); 725 726 /* populate java values */ 727 ckpParam->ulCounterBits = jLongToCKULong(jCounterBits); 728 jByteArrayToCKByteArray(env, jCb, &ckBytes, &ckTemp); 729 if ((*env)->ExceptionCheck(env)) { return; } 730 if (ckTemp != 16) { 731 TRACE1("ERROR: WRONG CTR IV LENGTH %d", ckTemp); 732 } else { 733 memcpy(ckpParam->cb, ckBytes, ckTemp); 734 free(ckBytes); 735 } 736 } 737 738 /* 739 * converts a Java CK_MECHANISM object into a CK_MECHANISM structure 740 * 741 * @param env - used to call JNI funktions to get the values out of the Java object 742 * @param jMechanism - the Java CK_MECHANISM object to convert 743 * @return - the new CK_MECHANISM structure 744 */ 745 void jMechanismToCKMechanism(JNIEnv *env, jobject jMechanism, CK_MECHANISM_PTR ckMechanismPtr) 746 { 747 jlong jMechanismType = (*env)->GetLongField(env, jMechanism, mech_mechanismID); 748 jobject jParameter = (*env)->GetObjectField(env, jMechanism, mech_pParameterID); 749 750 (*ckMechanismPtr).mechanism = jLongToCKULong(jMechanismType); 751 752 /* convert the specific Java mechanism parameter object to a pointer to a CK-type mechanism 753 * structure 754 */ 755 if (jParameter == NULL) { 756 (*ckMechanismPtr).pParameter = NULL; 757 (*ckMechanismPtr).ulParameterLen = 0; 758 } else { 759 jMechanismParameterToCKMechanismParameter(env, jParameter, &(*ckMechanismPtr).pParameter, &(*ckMechanismPtr).ulParameterLen); 760 } 761 } 762 763 /* 764 * the following functions convert Attribute and Mechanism value pointers 765 * 766 * jobject ckAttributeValueToJObject(JNIEnv *env, 767 * const CK_ATTRIBUTE_PTR ckpAttribute); 768 * 769 * void jObjectToPrimitiveCKObjectPtrPtr(JNIEnv *env, 770 * jobject jObject, 771 * CK_VOID_PTR *ckpObjectPtr, 772 * CK_ULONG *pLength); 773 * 774 * void jMechanismParameterToCKMechanismParameter(JNIEnv *env, 775 * jobject jParam, 776 * CK_VOID_PTR *ckpParamPtr, 777 * CK_ULONG *ckpLength); 778 * 779 * These functions are used if a PKCS#11 mechanism or attribute structure gets 780 * convertet to a Java attribute or mechanism object or vice versa. 781 * 782 * ckAttributeValueToJObject converts a PKCS#11 attribute value pointer to a Java 783 * object depending on the type of the Attribute. A PKCS#11 attribute value can 784 * be a CK_ULONG, CK_BYTE[], CK_CHAR[], big integer, CK_BBOOL, CK_UTF8CHAR[], 785 * CK_DATE or CK_FLAGS that gets converted to a corresponding Java object. 786 * 787 * jObjectToPrimitiveCKObjectPtrPtr is used by jAttributeToCKAttributePtr for 788 * converting the Java attribute value to a PKCS#11 attribute value pointer. 789 * For now only primitive datatypes and arrays of primitive datatypes can get 790 * converted. Otherwise this function throws a PKCS#11Exception with the 791 * errorcode CKR_VENDOR_DEFINED. 792 * 793 * jMechanismParameterToCKMechanismParameter converts a Java mechanism parameter 794 * to a PKCS#11 mechanism parameter. First this function determines what mechanism 795 * parameter the Java object is, then it allocates the memory for the new PKCS#11 796 * structure and calls the corresponding function to convert the Java object to 797 * a PKCS#11 mechanism parameter structure. 798 */ 799 800 /* 801 * converts the pValue of a CK_ATTRIBUTE structure into a Java Object by checking the type 802 * of the attribute. 803 * 804 * @param env - used to call JNI funktions to create the new Java object 805 * @param ckpAttribute - the pointer to the CK_ATTRIBUTE structure that contains the type 806 * and the pValue to convert 807 * @return - the new Java object of the CK-type pValue 808 */ 809 jobject ckAttributeValueToJObject(JNIEnv *env, const CK_ATTRIBUTE_PTR ckpAttribute) 810 { 811 jint jValueLength; 812 jobject jValueObject = NULL; 813 814 jValueLength = ckULongToJInt(ckpAttribute->ulValueLen); 815 816 if ((jValueLength <= 0) || (ckpAttribute->pValue == NULL)) { 817 return NULL ; 818 } 819 820 switch(ckpAttribute->type) { 821 case CKA_CLASS: 822 /* value CK_OBJECT_CLASS, defacto a CK_ULONG */ 823 case CKA_KEY_TYPE: 824 /* value CK_KEY_TYPE, defacto a CK_ULONG */ 825 case CKA_CERTIFICATE_TYPE: 826 /* value CK_CERTIFICATE_TYPE, defacto a CK_ULONG */ 827 case CKA_HW_FEATURE_TYPE: 828 /* value CK_HW_FEATURE_TYPE, defacto a CK_ULONG */ 829 case CKA_MODULUS_BITS: 830 case CKA_VALUE_BITS: 831 case CKA_VALUE_LEN: 832 case CKA_KEY_GEN_MECHANISM: 833 case CKA_PRIME_BITS: 834 case CKA_SUB_PRIME_BITS: 835 /* value CK_ULONG */ 836 jValueObject = ckULongPtrToJLongObject(env, (CK_ULONG*) ckpAttribute->pValue); 837 break; 838 839 /* can be CK_BYTE[],CK_CHAR[] or big integer; defacto always CK_BYTE[] */ 840 case CKA_VALUE: 841 case CKA_OBJECT_ID: 842 case CKA_SUBJECT: 843 case CKA_ID: 844 case CKA_ISSUER: 845 case CKA_SERIAL_NUMBER: 846 case CKA_OWNER: 847 case CKA_AC_ISSUER: 848 case CKA_ATTR_TYPES: 849 case CKA_ECDSA_PARAMS: 850 /* CKA_EC_PARAMS is the same, these two are equivalent */ 851 case CKA_EC_POINT: 852 case CKA_PRIVATE_EXPONENT: 853 case CKA_PRIME_1: 854 case CKA_PRIME_2: 855 case CKA_EXPONENT_1: 856 case CKA_EXPONENT_2: 857 case CKA_COEFFICIENT: 858 /* value CK_BYTE[] */ 859 jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength); 860 break; 861 862 case CKA_RESET_ON_INIT: 863 case CKA_HAS_RESET: 864 case CKA_TOKEN: 865 case CKA_PRIVATE: 866 case CKA_MODIFIABLE: 867 case CKA_DERIVE: 868 case CKA_LOCAL: 869 case CKA_ENCRYPT: 870 case CKA_VERIFY: 871 case CKA_VERIFY_RECOVER: 872 case CKA_WRAP: 873 case CKA_SENSITIVE: 874 case CKA_SECONDARY_AUTH: 875 case CKA_DECRYPT: 876 case CKA_SIGN: 877 case CKA_SIGN_RECOVER: 878 case CKA_UNWRAP: 879 case CKA_EXTRACTABLE: 880 case CKA_ALWAYS_SENSITIVE: 881 case CKA_NEVER_EXTRACTABLE: 882 case CKA_TRUSTED: 883 /* value CK_BBOOL */ 884 jValueObject = ckBBoolPtrToJBooleanObject(env, (CK_BBOOL*) ckpAttribute->pValue); 885 break; 886 887 case CKA_LABEL: 888 case CKA_APPLICATION: 889 /* value RFC 2279 (UTF-8) string */ 890 jValueObject = ckUTF8CharArrayToJCharArray(env, (CK_UTF8CHAR*) ckpAttribute->pValue, jValueLength); 891 break; 892 893 case CKA_START_DATE: 894 case CKA_END_DATE: 895 /* value CK_DATE */ 896 jValueObject = ckDatePtrToJDateObject(env, (CK_DATE*) ckpAttribute->pValue); 897 break; 898 899 case CKA_MODULUS: 900 case CKA_PUBLIC_EXPONENT: 901 case CKA_PRIME: 902 case CKA_SUBPRIME: 903 case CKA_BASE: 904 /* value big integer, i.e. CK_BYTE[] */ 905 jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength); 906 break; 907 908 case CKA_AUTH_PIN_FLAGS: 909 jValueObject = ckULongPtrToJLongObject(env, (CK_ULONG*) ckpAttribute->pValue); 910 /* value FLAGS, defacto a CK_ULONG */ 911 break; 912 913 case CKA_VENDOR_DEFINED: 914 /* we make a CK_BYTE[] out of this */ 915 jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength); 916 break; 917 918 // Netscape trust attributes 919 case CKA_NETSCAPE_TRUST_SERVER_AUTH: 920 case CKA_NETSCAPE_TRUST_CLIENT_AUTH: 921 case CKA_NETSCAPE_TRUST_CODE_SIGNING: 922 case CKA_NETSCAPE_TRUST_EMAIL_PROTECTION: 923 /* value CK_ULONG */ 924 jValueObject = ckULongPtrToJLongObject(env, (CK_ULONG*) ckpAttribute->pValue); 925 break; 926 927 default: 928 /* we make a CK_BYTE[] out of this */ 929 jValueObject = ckByteArrayToJByteArray(env, (CK_BYTE*) ckpAttribute->pValue, jValueLength); 930 break; 931 } 932 933 return jValueObject ; 934 } 935 936 /* 937 * the following functions convert a Java mechanism parameter object to a PKCS#11 938 * mechanism parameter structure 939 * 940 * CK_<Param>_PARAMS j<Param>ParamToCK<Param>Param(JNIEnv *env, 941 * jobject jParam); 942 * 943 * These functions get a Java object, that must be the right Java mechanism 944 * object and they return the new PKCS#11 mechanism parameter structure. 945 * Every field of the Java object is retrieved, gets converted to a corresponding 946 * PKCS#11 type and is set in the new PKCS#11 structure. 947 */ 948 949 /* 950 * converts the given Java mechanism parameter to a CK mechanism parameter structure 951 * and store the length in bytes in the length variable. 952 * The memory of *ckpParamPtr has to be freed after use! 953 * 954 * @param env - used to call JNI funktions to get the Java classes and objects 955 * @param jParam - the Java mechanism parameter object to convert 956 * @param ckpParamPtr - the reference of the new pointer to the new CK mechanism parameter 957 * structure 958 * @param ckpLength - the reference of the length in bytes of the new CK mechanism parameter 959 * structure 960 */ 961 void jMechanismParameterToCKMechanismParameter(JNIEnv *env, jobject jParam, CK_VOID_PTR *ckpParamPtr, CK_ULONG *ckpLength) 962 { 963 if (jParam == NULL) { 964 *ckpParamPtr = NULL; 965 *ckpLength = 0; 966 } else if ((*env)->IsInstanceOf(env, jParam, jByteArrayClass)) { 967 jByteArrayToCKByteArray(env, jParam, (CK_BYTE_PTR *)ckpParamPtr, ckpLength); 968 } else if ((*env)->IsInstanceOf(env, jParam, jLongClass)) { 969 *ckpParamPtr = jLongObjectToCKULongPtr(env, jParam); 970 *ckpLength = sizeof(CK_ULONG); 971 } else { 972 TRACE0("\nSLOW PATH jMechanismParameterToCKMechanismParameter\n"); 973 jMechanismParameterToCKMechanismParameterSlow(env, jParam, ckpParamPtr, ckpLength); 974 } 975 } 976 977 void jMechanismParameterToCKMechanismParameterSlow(JNIEnv *env, jobject jParam, CK_VOID_PTR *ckpParamPtr, CK_ULONG *ckpLength) 978 { 979 /* get all Java mechanism parameter classes */ 980 jclass jVersionClass, jSsl3MasterKeyDeriveParamsClass, jSsl3KeyMatParamsClass; 981 jclass jTlsPrfParamsClass, jAesCtrParamsClass, jRsaPkcsOaepParamsClass; 982 jclass jPbeParamsClass, jPkcs5Pbkd2ParamsClass, jRsaPkcsPssParamsClass; 983 jclass jEcdh1DeriveParamsClass, jEcdh2DeriveParamsClass; 984 jclass jX942Dh1DeriveParamsClass, jX942Dh2DeriveParamsClass; 985 TRACE0("\nDEBUG: jMechanismParameterToCKMechanismParameter"); 986 987 /* most common cases, i.e. NULL/byte[]/long, are already handled by 988 * jMechanismParameterToCKMechanismParameter before calling this method. 989 */ 990 jVersionClass = (*env)->FindClass(env, CLASS_VERSION); 991 if (jVersionClass == NULL) { return; } 992 if ((*env)->IsInstanceOf(env, jParam, jVersionClass)) { 993 /* 994 * CK_VERSION used by CKM_SSL3_PRE_MASTER_KEY_GEN 995 */ 996 CK_VERSION_PTR ckpParam; 997 998 /* convert jParameter to CKParameter */ 999 ckpParam = jVersionToCKVersionPtr(env, jParam); 1000 1001 /* get length and pointer of parameter */ 1002 *ckpLength = sizeof(CK_VERSION); 1003 *ckpParamPtr = ckpParam; 1004 return; 1005 } 1006 1007 jSsl3MasterKeyDeriveParamsClass = (*env)->FindClass(env, CLASS_SSL3_MASTER_KEY_DERIVE_PARAMS); 1008 if (jSsl3MasterKeyDeriveParamsClass == NULL) { return; } 1009 if ((*env)->IsInstanceOf(env, jParam, jSsl3MasterKeyDeriveParamsClass)) { 1010 /* 1011 * CK_SSL3_MASTER_KEY_DERIVE_PARAMS 1012 */ 1013 CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR ckpParam; 1014 1015 ckpParam = (CK_SSL3_MASTER_KEY_DERIVE_PARAMS_PTR) malloc(sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS)); 1016 if (ckpParam == NULL) { 1017 throwOutOfMemoryError(env, 0); 1018 return; 1019 } 1020 1021 /* convert jParameter to CKParameter */ 1022 *ckpParam = jSsl3MasterKeyDeriveParamToCKSsl3MasterKeyDeriveParam(env, jParam); 1023 if ((*env)->ExceptionCheck(env)) { 1024 free(ckpParam); 1025 return; 1026 } 1027 1028 /* get length and pointer of parameter */ 1029 *ckpLength = sizeof(CK_SSL3_MASTER_KEY_DERIVE_PARAMS); 1030 *ckpParamPtr = ckpParam; 1031 return; 1032 } 1033 1034 jSsl3KeyMatParamsClass = (*env)->FindClass(env, CLASS_SSL3_KEY_MAT_PARAMS); 1035 if (jSsl3KeyMatParamsClass == NULL) { return; } 1036 if ((*env)->IsInstanceOf(env, jParam, jSsl3KeyMatParamsClass)) { 1037 /* 1038 * CK_SSL3_KEY_MAT_PARAMS 1039 */ 1040 CK_SSL3_KEY_MAT_PARAMS_PTR ckpParam; 1041 1042 ckpParam = (CK_SSL3_KEY_MAT_PARAMS_PTR) malloc(sizeof(CK_SSL3_KEY_MAT_PARAMS)); 1043 if (ckpParam == NULL) { 1044 throwOutOfMemoryError(env, 0); 1045 return; 1046 } 1047 1048 /* convert jParameter to CKParameter */ 1049 *ckpParam = jSsl3KeyMatParamToCKSsl3KeyMatParam(env, jParam); 1050 if ((*env)->ExceptionCheck(env)) { 1051 free(ckpParam); 1052 return; 1053 } 1054 1055 /* get length and pointer of parameter */ 1056 *ckpLength = sizeof(CK_SSL3_KEY_MAT_PARAMS); 1057 *ckpParamPtr = ckpParam; 1058 return; 1059 } 1060 1061 jTlsPrfParamsClass = (*env)->FindClass(env, CLASS_TLS_PRF_PARAMS); 1062 if (jTlsPrfParamsClass == NULL) { return; } 1063 if ((*env)->IsInstanceOf(env, jParam, jTlsPrfParamsClass)) { 1064 /* 1065 * CK_TLS_PRF_PARAMS 1066 */ 1067 CK_TLS_PRF_PARAMS_PTR ckpParam; 1068 1069 ckpParam = (CK_TLS_PRF_PARAMS_PTR) malloc(sizeof(CK_TLS_PRF_PARAMS)); 1070 if (ckpParam == NULL) { 1071 throwOutOfMemoryError(env, 0); 1072 return; 1073 } 1074 1075 /* convert jParameter to CKParameter */ 1076 *ckpParam = jTlsPrfParamsToCKTlsPrfParam(env, jParam); 1077 if ((*env)->ExceptionCheck(env)) { 1078 free(ckpParam); 1079 return; 1080 } 1081 1082 /* get length and pointer of parameter */ 1083 *ckpLength = sizeof(CK_TLS_PRF_PARAMS); 1084 *ckpParamPtr = ckpParam; 1085 return; 1086 } 1087 1088 jAesCtrParamsClass = (*env)->FindClass(env, CLASS_AES_CTR_PARAMS); 1089 if (jAesCtrParamsClass == NULL) { return; } 1090 if ((*env)->IsInstanceOf(env, jParam, jAesCtrParamsClass)) { 1091 /* 1092 * CK_AES_CTR_PARAMS 1093 */ 1094 CK_AES_CTR_PARAMS_PTR ckpParam; 1095 1096 ckpParam = (CK_AES_CTR_PARAMS_PTR) malloc(sizeof(CK_AES_CTR_PARAMS)); 1097 if (ckpParam == NULL) { 1098 throwOutOfMemoryError(env, 0); 1099 return; 1100 } 1101 1102 /* convert jParameter to CKParameter */ 1103 jAesCtrParamsToCKAesCtrParam(env, jParam, ckpParam); 1104 if ((*env)->ExceptionCheck(env)) { 1105 free(ckpParam); 1106 return; 1107 } 1108 1109 /* get length and pointer of parameter */ 1110 *ckpLength = sizeof(CK_AES_CTR_PARAMS); 1111 *ckpParamPtr = ckpParam; 1112 return; 1113 } 1114 1115 jRsaPkcsOaepParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_OAEP_PARAMS); 1116 if (jRsaPkcsOaepParamsClass == NULL) { return; } 1117 if ((*env)->IsInstanceOf(env, jParam, jRsaPkcsOaepParamsClass)) { 1118 /* 1119 * CK_RSA_PKCS_OAEP_PARAMS 1120 */ 1121 CK_RSA_PKCS_OAEP_PARAMS_PTR ckpParam; 1122 1123 ckpParam = (CK_RSA_PKCS_OAEP_PARAMS_PTR) malloc(sizeof(CK_RSA_PKCS_OAEP_PARAMS)); 1124 if (ckpParam == NULL) { 1125 throwOutOfMemoryError(env, 0); 1126 return; 1127 } 1128 1129 /* convert jParameter to CKParameter */ 1130 *ckpParam = jRsaPkcsOaepParamToCKRsaPkcsOaepParam(env, jParam); 1131 if ((*env)->ExceptionCheck(env)) { 1132 free(ckpParam); 1133 return; 1134 } 1135 1136 /* get length and pointer of parameter */ 1137 *ckpLength = sizeof(CK_RSA_PKCS_OAEP_PARAMS); 1138 *ckpParamPtr = ckpParam; 1139 return; 1140 } 1141 1142 jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS); 1143 if (jPbeParamsClass == NULL) { return; } 1144 if ((*env)->IsInstanceOf(env, jParam, jPbeParamsClass)) { 1145 /* 1146 * CK_PBE_PARAMS 1147 */ 1148 CK_PBE_PARAMS_PTR ckpParam; 1149 1150 ckpParam = (CK_PBE_PARAMS_PTR) malloc(sizeof(CK_PBE_PARAMS)); 1151 if (ckpParam == NULL) { 1152 throwOutOfMemoryError(env, 0); 1153 return; 1154 } 1155 1156 /* convert jParameter to CKParameter */ 1157 *ckpParam = jPbeParamToCKPbeParam(env, jParam); 1158 if ((*env)->ExceptionCheck(env)) { 1159 free(ckpParam); 1160 return; 1161 } 1162 1163 /* get length and pointer of parameter */ 1164 *ckpLength = sizeof(CK_PBE_PARAMS); 1165 *ckpParamPtr = ckpParam; 1166 return; 1167 } 1168 1169 jPkcs5Pbkd2ParamsClass = (*env)->FindClass(env, CLASS_PKCS5_PBKD2_PARAMS); 1170 if (jPkcs5Pbkd2ParamsClass == NULL) { return; } 1171 if ((*env)->IsInstanceOf(env, jParam, jPkcs5Pbkd2ParamsClass)) { 1172 /* 1173 * CK_PKCS5_PBKD2_PARAMS 1174 */ 1175 CK_PKCS5_PBKD2_PARAMS_PTR ckpParam; 1176 1177 ckpParam = (CK_PKCS5_PBKD2_PARAMS_PTR) malloc(sizeof(CK_PKCS5_PBKD2_PARAMS)); 1178 if (ckpParam == NULL) { 1179 throwOutOfMemoryError(env, 0); 1180 return; 1181 } 1182 1183 /* convert jParameter to CKParameter */ 1184 *ckpParam = jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(env, jParam); 1185 if ((*env)->ExceptionCheck(env)) { 1186 free(ckpParam); 1187 return; 1188 } 1189 1190 /* get length and pointer of parameter */ 1191 *ckpLength = sizeof(CK_PKCS5_PBKD2_PARAMS); 1192 *ckpParamPtr = ckpParam; 1193 return; 1194 } 1195 1196 jRsaPkcsPssParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_PSS_PARAMS); 1197 if (jRsaPkcsPssParamsClass == NULL) { return; } 1198 if ((*env)->IsInstanceOf(env, jParam, jRsaPkcsPssParamsClass)) { 1199 /* 1200 * CK_RSA_PKCS_PSS_PARAMS 1201 */ 1202 CK_RSA_PKCS_PSS_PARAMS_PTR ckpParam; 1203 1204 ckpParam = (CK_RSA_PKCS_PSS_PARAMS_PTR) malloc(sizeof(CK_RSA_PKCS_PSS_PARAMS)); 1205 if (ckpParam == NULL) { 1206 throwOutOfMemoryError(env, 0); 1207 return; 1208 } 1209 1210 /* convert jParameter to CKParameter */ 1211 *ckpParam = jRsaPkcsPssParamToCKRsaPkcsPssParam(env, jParam); 1212 if ((*env)->ExceptionCheck(env)) { 1213 free(ckpParam); 1214 return; 1215 } 1216 1217 /* get length and pointer of parameter */ 1218 *ckpLength = sizeof(CK_RSA_PKCS_PSS_PARAMS); 1219 *ckpParamPtr = ckpParam; 1220 return; 1221 } 1222 1223 jEcdh1DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH1_DERIVE_PARAMS); 1224 if (jEcdh1DeriveParamsClass == NULL) { return; } 1225 if ((*env)->IsInstanceOf(env, jParam, jEcdh1DeriveParamsClass)) { 1226 /* 1227 * CK_ECDH1_DERIVE_PARAMS 1228 */ 1229 CK_ECDH1_DERIVE_PARAMS_PTR ckpParam; 1230 1231 ckpParam = (CK_ECDH1_DERIVE_PARAMS_PTR) malloc(sizeof(CK_ECDH1_DERIVE_PARAMS)); 1232 if (ckpParam == NULL) { 1233 throwOutOfMemoryError(env, 0); 1234 return; 1235 } 1236 1237 /* convert jParameter to CKParameter */ 1238 *ckpParam = jEcdh1DeriveParamToCKEcdh1DeriveParam(env, jParam); 1239 if ((*env)->ExceptionCheck(env)) { 1240 free(ckpParam); 1241 return; 1242 } 1243 1244 /* get length and pointer of parameter */ 1245 *ckpLength = sizeof(CK_ECDH1_DERIVE_PARAMS); 1246 *ckpParamPtr = ckpParam; 1247 return; 1248 } 1249 1250 jEcdh2DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH2_DERIVE_PARAMS); 1251 if (jEcdh2DeriveParamsClass == NULL) { return; } 1252 if ((*env)->IsInstanceOf(env, jParam, jEcdh2DeriveParamsClass)) { 1253 /* 1254 * CK_ECDH2_DERIVE_PARAMS 1255 */ 1256 CK_ECDH2_DERIVE_PARAMS_PTR ckpParam; 1257 1258 ckpParam = (CK_ECDH2_DERIVE_PARAMS_PTR) malloc(sizeof(CK_ECDH2_DERIVE_PARAMS)); 1259 if (ckpParam == NULL) { 1260 throwOutOfMemoryError(env, 0); 1261 return; 1262 } 1263 1264 /* convert jParameter to CKParameter */ 1265 *ckpParam = jEcdh2DeriveParamToCKEcdh2DeriveParam(env, jParam); 1266 if ((*env)->ExceptionCheck(env)) { 1267 free(ckpParam); 1268 return; 1269 } 1270 1271 /* get length and pointer of parameter */ 1272 *ckpLength = sizeof(CK_ECDH2_DERIVE_PARAMS); 1273 *ckpParamPtr = ckpParam; 1274 return; 1275 } 1276 1277 jX942Dh1DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH1_DERIVE_PARAMS); 1278 if (jX942Dh1DeriveParamsClass == NULL) { return; } 1279 if ((*env)->IsInstanceOf(env, jParam, jX942Dh1DeriveParamsClass)) { 1280 /* 1281 * CK_X9_42_DH1_DERIVE_PARAMS 1282 */ 1283 CK_X9_42_DH1_DERIVE_PARAMS_PTR ckpParam; 1284 1285 ckpParam = (CK_X9_42_DH1_DERIVE_PARAMS_PTR) malloc(sizeof(CK_X9_42_DH1_DERIVE_PARAMS)); 1286 if (ckpParam == NULL) { 1287 throwOutOfMemoryError(env, 0); 1288 return; 1289 } 1290 1291 /* convert jParameter to CKParameter */ 1292 *ckpParam = jX942Dh1DeriveParamToCKX942Dh1DeriveParam(env, jParam); 1293 if ((*env)->ExceptionCheck(env)) { 1294 free(ckpParam); 1295 return; 1296 } 1297 1298 /* get length and pointer of parameter */ 1299 *ckpLength = sizeof(CK_X9_42_DH1_DERIVE_PARAMS); 1300 *ckpParamPtr = ckpParam; 1301 return; 1302 } 1303 1304 jX942Dh2DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH2_DERIVE_PARAMS); 1305 if (jX942Dh2DeriveParamsClass == NULL) { return; } 1306 if ((*env)->IsInstanceOf(env, jParam, jX942Dh2DeriveParamsClass)) { 1307 /* 1308 * CK_X9_42_DH2_DERIVE_PARAMS 1309 */ 1310 CK_X9_42_DH2_DERIVE_PARAMS_PTR ckpParam; 1311 1312 ckpParam = (CK_X9_42_DH2_DERIVE_PARAMS_PTR) malloc(sizeof(CK_X9_42_DH2_DERIVE_PARAMS)); 1313 if (ckpParam == NULL) { 1314 throwOutOfMemoryError(env, 0); 1315 return; 1316 } 1317 1318 /* convert jParameter to CKParameter */ 1319 *ckpParam = jX942Dh2DeriveParamToCKX942Dh2DeriveParam(env, jParam); 1320 if ((*env)->ExceptionCheck(env)) { 1321 free(ckpParam); 1322 return; 1323 } 1324 1325 /* get length and pointer of parameter */ 1326 *ckpLength = sizeof(CK_X9_42_DH2_DERIVE_PARAMS); 1327 *ckpParamPtr = ckpParam; 1328 return; 1329 } 1330 1331 /* if everything faild up to here */ 1332 /* try if the parameter is a primitive Java type */ 1333 jObjectToPrimitiveCKObjectPtrPtr(env, jParam, ckpParamPtr, ckpLength); 1334 /* *ckpParamPtr = jObjectToCKVoidPtr(jParam); */ 1335 /* *ckpLength = 1; */ 1336 1337 TRACE0("FINISHED\n"); 1338 } 1339 1340 1341 /* the mechanism parameter convertion functions: */ 1342 1343 /* 1344 * converts the Java CK_RSA_PKCS_OAEP_PARAMS object to a CK_RSA_PKCS_OAEP_PARAMS structure 1345 * 1346 * @param env - used to call JNI funktions to get the Java classes and objects 1347 * @param jParam - the Java CK_RSA_PKCS_OAEP_PARAMS object to convert 1348 * @return - the new CK_RSA_PKCS_OAEP_PARAMS structure 1349 */ 1350 CK_RSA_PKCS_OAEP_PARAMS jRsaPkcsOaepParamToCKRsaPkcsOaepParam(JNIEnv *env, jobject jParam) 1351 { 1352 jclass jRsaPkcsOaepParamsClass; 1353 CK_RSA_PKCS_OAEP_PARAMS ckParam; 1354 jfieldID fieldID; 1355 jlong jHashAlg, jMgf, jSource; 1356 jobject jSourceData; 1357 CK_BYTE_PTR ckpByte; 1358 1359 /* get hashAlg */ 1360 jRsaPkcsOaepParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_OAEP_PARAMS); 1361 if (jRsaPkcsOaepParamsClass == NULL) { return ckParam; } 1362 fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "hashAlg", "J"); 1363 if (fieldID == NULL) { return ckParam; } 1364 jHashAlg = (*env)->GetLongField(env, jParam, fieldID); 1365 1366 /* get mgf */ 1367 fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "mgf", "J"); 1368 if (fieldID == NULL) { return ckParam; } 1369 jMgf = (*env)->GetLongField(env, jParam, fieldID); 1370 1371 /* get source */ 1372 fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "source", "J"); 1373 if (fieldID == NULL) { return ckParam; } 1374 jSource = (*env)->GetLongField(env, jParam, fieldID); 1375 1376 /* get sourceData and sourceDataLength */ 1377 fieldID = (*env)->GetFieldID(env, jRsaPkcsOaepParamsClass, "pSourceData", "[B"); 1378 if (fieldID == NULL) { return ckParam; } 1379 jSourceData = (*env)->GetObjectField(env, jParam, fieldID); 1380 1381 /* populate java values */ 1382 ckParam.hashAlg = jLongToCKULong(jHashAlg); 1383 ckParam.mgf = jLongToCKULong(jMgf); 1384 ckParam.source = jLongToCKULong(jSource); 1385 jByteArrayToCKByteArray(env, jSourceData, & ckpByte, &(ckParam.ulSourceDataLen)); 1386 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1387 ckParam.pSourceData = (CK_VOID_PTR) ckpByte; 1388 1389 return ckParam ; 1390 } 1391 1392 /* 1393 * converts the Java CK_PBE_PARAMS object to a CK_PBE_PARAMS structure 1394 * 1395 * @param env - used to call JNI funktions to get the Java classes and objects 1396 * @param jParam - the Java CK_PBE_PARAMS object to convert 1397 * @return - the new CK_PBE_PARAMS structure 1398 */ 1399 CK_PBE_PARAMS jPbeParamToCKPbeParam(JNIEnv *env, jobject jParam) 1400 { 1401 jclass jPbeParamsClass; 1402 CK_PBE_PARAMS ckParam; 1403 jfieldID fieldID; 1404 jlong jIteration; 1405 jobject jInitVector, jPassword, jSalt; 1406 CK_ULONG ckTemp; 1407 1408 /* get pInitVector */ 1409 jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS); 1410 if (jPbeParamsClass == NULL) { return ckParam; } 1411 fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pInitVector", "[C"); 1412 if (fieldID == NULL) { return ckParam; } 1413 jInitVector = (*env)->GetObjectField(env, jParam, fieldID); 1414 1415 /* get pPassword and ulPasswordLength */ 1416 fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pPassword", "[C"); 1417 if (fieldID == NULL) { return ckParam; } 1418 jPassword = (*env)->GetObjectField(env, jParam, fieldID); 1419 1420 /* get pSalt and ulSaltLength */ 1421 fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pSalt", "[C"); 1422 if (fieldID == NULL) { return ckParam; } 1423 jSalt = (*env)->GetObjectField(env, jParam, fieldID); 1424 1425 /* get ulIteration */ 1426 fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "ulIteration", "J"); 1427 if (fieldID == NULL) { return ckParam; } 1428 jIteration = (*env)->GetLongField(env, jParam, fieldID); 1429 1430 /* populate java values */ 1431 ckParam.ulIteration = jLongToCKULong(jIteration); 1432 jCharArrayToCKCharArray(env, jInitVector, &(ckParam.pInitVector), &ckTemp); 1433 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1434 jCharArrayToCKCharArray(env, jPassword, &(ckParam.pPassword), &(ckParam.ulPasswordLen)); 1435 if ((*env)->ExceptionCheck(env)) { 1436 free(ckParam.pInitVector); 1437 return ckParam; 1438 } 1439 jCharArrayToCKCharArray(env, jSalt, &(ckParam.pSalt), &(ckParam.ulSaltLen)); 1440 if ((*env)->ExceptionCheck(env)) { 1441 free(ckParam.pInitVector); 1442 free(ckParam.pPassword); 1443 return ckParam; 1444 } 1445 1446 return ckParam ; 1447 } 1448 1449 /* 1450 * Copy back the initialization vector from the native structure to the 1451 * Java object. This is only used for CKM_PBE_* mechanisms and their 1452 * CK_PBE_PARAMS parameters. 1453 * 1454 */ 1455 void copyBackPBEInitializationVector(JNIEnv *env, CK_MECHANISM *ckMechanism, jobject jMechanism) 1456 { 1457 jclass jMechanismClass, jPbeParamsClass; 1458 CK_PBE_PARAMS *ckParam; 1459 jfieldID fieldID; 1460 CK_MECHANISM_TYPE ckMechanismType; 1461 jlong jMechanismType; 1462 jobject jParameter; 1463 jobject jInitVector; 1464 jint jInitVectorLength; 1465 CK_CHAR_PTR initVector; 1466 int i; 1467 jchar* jInitVectorChars; 1468 1469 /* get mechanism */ 1470 jMechanismClass = (*env)->FindClass(env, CLASS_MECHANISM); 1471 if (jMechanismClass == NULL) { return; } 1472 fieldID = (*env)->GetFieldID(env, jMechanismClass, "mechanism", "J"); 1473 if (fieldID == NULL) { return; } 1474 jMechanismType = (*env)->GetLongField(env, jMechanism, fieldID); 1475 ckMechanismType = jLongToCKULong(jMechanismType); 1476 if (ckMechanismType != ckMechanism->mechanism) { 1477 /* we do not have maching types, this should not occur */ 1478 return; 1479 } 1480 1481 jPbeParamsClass = (*env)->FindClass(env, CLASS_PBE_PARAMS); 1482 if (jPbeParamsClass == NULL) { return; } 1483 ckParam = (CK_PBE_PARAMS *) ckMechanism->pParameter; 1484 if (ckParam != NULL_PTR) { 1485 initVector = ckParam->pInitVector; 1486 if (initVector != NULL_PTR) { 1487 /* get pParameter */ 1488 fieldID = (*env)->GetFieldID(env, jMechanismClass, "pParameter", "Ljava/lang/Object;"); 1489 if (fieldID == NULL) { return; } 1490 jParameter = (*env)->GetObjectField(env, jMechanism, fieldID); 1491 fieldID = (*env)->GetFieldID(env, jPbeParamsClass, "pInitVektor", "[C"); 1492 if (fieldID == NULL) { return; } 1493 jInitVector = (*env)->GetObjectField(env, jParameter, fieldID); 1494 1495 if (jInitVector != NULL) { 1496 jInitVectorLength = (*env)->GetArrayLength(env, jInitVector); 1497 jInitVectorChars = (*env)->GetCharArrayElements(env, jInitVector, NULL); 1498 if (jInitVectorChars == NULL) { return; } 1499 1500 /* copy the chars to the Java buffer */ 1501 for (i=0; i < jInitVectorLength; i++) { 1502 jInitVectorChars[i] = ckCharToJChar(initVector[i]); 1503 } 1504 /* copy back the Java buffer to the object */ 1505 (*env)->ReleaseCharArrayElements(env, jInitVector, jInitVectorChars, 0); 1506 } 1507 } 1508 } 1509 } 1510 1511 /* 1512 * converts the Java CK_PKCS5_PBKD2_PARAMS object to a CK_PKCS5_PBKD2_PARAMS structure 1513 * 1514 * @param env - used to call JNI funktions to get the Java classes and objects 1515 * @param jParam - the Java CK_PKCS5_PBKD2_PARAMS object to convert 1516 * @return - the new CK_PKCS5_PBKD2_PARAMS structure 1517 */ 1518 CK_PKCS5_PBKD2_PARAMS jPkcs5Pbkd2ParamToCKPkcs5Pbkd2Param(JNIEnv *env, jobject jParam) 1519 { 1520 jclass jPkcs5Pbkd2ParamsClass; 1521 CK_PKCS5_PBKD2_PARAMS ckParam; 1522 jfieldID fieldID; 1523 jlong jSaltSource, jIteration, jPrf; 1524 jobject jSaltSourceData, jPrfData; 1525 1526 /* get saltSource */ 1527 jPkcs5Pbkd2ParamsClass = (*env)->FindClass(env, CLASS_PKCS5_PBKD2_PARAMS); 1528 if (jPkcs5Pbkd2ParamsClass == NULL) { return ckParam; } 1529 fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "saltSource", "J"); 1530 if (fieldID == NULL) { return ckParam; } 1531 jSaltSource = (*env)->GetLongField(env, jParam, fieldID); 1532 1533 /* get pSaltSourceData */ 1534 fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "pSaltSourceData", "[B"); 1535 if (fieldID == NULL) { return ckParam; } 1536 jSaltSourceData = (*env)->GetObjectField(env, jParam, fieldID); 1537 1538 /* get iterations */ 1539 fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "iterations", "J"); 1540 if (fieldID == NULL) { return ckParam; } 1541 jIteration = (*env)->GetLongField(env, jParam, fieldID); 1542 1543 /* get prf */ 1544 fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "prf", "J"); 1545 if (fieldID == NULL) { return ckParam; } 1546 jPrf = (*env)->GetLongField(env, jParam, fieldID); 1547 1548 /* get pPrfData and ulPrfDataLength in byte */ 1549 fieldID = (*env)->GetFieldID(env, jPkcs5Pbkd2ParamsClass, "pPrfData", "[B"); 1550 if (fieldID == NULL) { return ckParam; } 1551 jPrfData = (*env)->GetObjectField(env, jParam, fieldID); 1552 1553 /* populate java values */ 1554 ckParam.saltSource = jLongToCKULong(jSaltSource); 1555 jByteArrayToCKByteArray(env, jSaltSourceData, (CK_BYTE_PTR *) &(ckParam.pSaltSourceData), &(ckParam.ulSaltSourceDataLen)); 1556 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1557 ckParam.iterations = jLongToCKULong(jIteration); 1558 ckParam.prf = jLongToCKULong(jPrf); 1559 jByteArrayToCKByteArray(env, jPrfData, (CK_BYTE_PTR *) &(ckParam.pPrfData), &(ckParam.ulPrfDataLen)); 1560 if ((*env)->ExceptionCheck(env)) { 1561 free(ckParam.pSaltSourceData); 1562 return ckParam; 1563 } 1564 1565 return ckParam ; 1566 } 1567 1568 /* 1569 * converts the Java CK_RSA_PKCS_PSS_PARAMS object to a CK_RSA_PKCS_PSS_PARAMS structure 1570 * 1571 * @param env - used to call JNI funktions to get the Java classes and objects 1572 * @param jParam - the Java CK_RSA_PKCS_PSS_PARAMS object to convert 1573 * @return - the new CK_RSA_PKCS_PSS_PARAMS structure 1574 */ 1575 CK_RSA_PKCS_PSS_PARAMS jRsaPkcsPssParamToCKRsaPkcsPssParam(JNIEnv *env, jobject jParam) 1576 { 1577 jclass jRsaPkcsPssParamsClass; 1578 CK_RSA_PKCS_PSS_PARAMS ckParam; 1579 jfieldID fieldID; 1580 jlong jHashAlg, jMgf, jSLen; 1581 memset(&ckParam, 0, sizeof(CK_RSA_PKCS_PSS_PARAMS)); 1582 1583 /* get hashAlg */ 1584 jRsaPkcsPssParamsClass = (*env)->FindClass(env, CLASS_RSA_PKCS_PSS_PARAMS); 1585 if (jRsaPkcsPssParamsClass == NULL) { return ckParam; } 1586 fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "hashAlg", "J"); 1587 if (fieldID == NULL) { return ckParam; } 1588 jHashAlg = (*env)->GetLongField(env, jParam, fieldID); 1589 1590 /* get mgf */ 1591 fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "mgf", "J"); 1592 if (fieldID == NULL) { return ckParam; } 1593 jMgf = (*env)->GetLongField(env, jParam, fieldID); 1594 1595 /* get sLen */ 1596 fieldID = (*env)->GetFieldID(env, jRsaPkcsPssParamsClass, "sLen", "J"); 1597 if (fieldID == NULL) { return ckParam; } 1598 jSLen = (*env)->GetLongField(env, jParam, fieldID); 1599 1600 /* populate java values */ 1601 ckParam.hashAlg = jLongToCKULong(jHashAlg); 1602 ckParam.mgf = jLongToCKULong(jMgf); 1603 ckParam.sLen = jLongToCKULong(jSLen); 1604 1605 return ckParam ; 1606 } 1607 1608 /* 1609 * converts the Java CK_ECDH1_DERIVE_PARAMS object to a CK_ECDH1_DERIVE_PARAMS structure 1610 * 1611 * @param env - used to call JNI funktions to get the Java classes and objects 1612 * @param jParam - the Java CK_ECDH1_DERIVE_PARAMS object to convert 1613 * @return - the new CK_ECDH1_DERIVE_PARAMS structure 1614 */ 1615 CK_ECDH1_DERIVE_PARAMS jEcdh1DeriveParamToCKEcdh1DeriveParam(JNIEnv *env, jobject jParam) 1616 { 1617 jclass jEcdh1DeriveParamsClass; 1618 CK_ECDH1_DERIVE_PARAMS ckParam; 1619 jfieldID fieldID; 1620 jlong jLong; 1621 jobject jSharedData, jPublicData; 1622 memset(&ckParam, 0, sizeof(CK_ECDH1_DERIVE_PARAMS)); 1623 1624 /* get kdf */ 1625 jEcdh1DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH1_DERIVE_PARAMS); 1626 if (jEcdh1DeriveParamsClass == NULL) { return ckParam; } 1627 fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "kdf", "J"); 1628 if (fieldID == NULL) { return ckParam; } 1629 jLong = (*env)->GetLongField(env, jParam, fieldID); 1630 ckParam.kdf = jLongToCKULong(jLong); 1631 1632 /* get pSharedData and ulSharedDataLen */ 1633 fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "pSharedData", "[B"); 1634 if (fieldID == NULL) { return ckParam; } 1635 jSharedData = (*env)->GetObjectField(env, jParam, fieldID); 1636 1637 /* get pPublicData and ulPublicDataLen */ 1638 fieldID = (*env)->GetFieldID(env, jEcdh1DeriveParamsClass, "pPublicData", "[B"); 1639 if (fieldID == NULL) { return ckParam; } 1640 jPublicData = (*env)->GetObjectField(env, jParam, fieldID); 1641 1642 /* populate java values */ 1643 ckParam.kdf = jLongToCKULong(jLong); 1644 jByteArrayToCKByteArray(env, jSharedData, &(ckParam.pSharedData), &(ckParam.ulSharedDataLen)); 1645 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1646 jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen)); 1647 if ((*env)->ExceptionCheck(env)) { 1648 free(ckParam.pSharedData); 1649 return ckParam; 1650 } 1651 1652 return ckParam ; 1653 } 1654 1655 /* 1656 * converts the Java CK_ECDH2_DERIVE_PARAMS object to a CK_ECDH2_DERIVE_PARAMS structure 1657 * 1658 * @param env - used to call JNI funktions to get the Java classes and objects 1659 * @param jParam - the Java CK_ECDH2_DERIVE_PARAMS object to convert 1660 * @return - the new CK_ECDH2_DERIVE_PARAMS structure 1661 */ 1662 CK_ECDH2_DERIVE_PARAMS jEcdh2DeriveParamToCKEcdh2DeriveParam(JNIEnv *env, jobject jParam) 1663 { 1664 jclass jEcdh2DeriveParamsClass; 1665 CK_ECDH2_DERIVE_PARAMS ckParam; 1666 jfieldID fieldID; 1667 jlong jKdf, jPrivateDataLen, jPrivateData; 1668 jobject jSharedData, jPublicData, jPublicData2; 1669 memset(&ckParam, 0, sizeof(CK_ECDH2_DERIVE_PARAMS)); 1670 1671 /* get kdf */ 1672 jEcdh2DeriveParamsClass = (*env)->FindClass(env, CLASS_ECDH2_DERIVE_PARAMS); 1673 if (jEcdh2DeriveParamsClass == NULL) { return ckParam; } 1674 fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "kdf", "J"); 1675 if (fieldID == NULL) { return ckParam; } 1676 jKdf = (*env)->GetLongField(env, jParam, fieldID); 1677 1678 /* get pSharedData and ulSharedDataLen */ 1679 fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pSharedData", "[B"); 1680 if (fieldID == NULL) { return ckParam; } 1681 jSharedData = (*env)->GetObjectField(env, jParam, fieldID); 1682 1683 /* get pPublicData and ulPublicDataLen */ 1684 fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pPublicData", "[B"); 1685 if (fieldID == NULL) { return ckParam; } 1686 jPublicData = (*env)->GetObjectField(env, jParam, fieldID); 1687 1688 /* get ulPrivateDataLen */ 1689 fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "ulPrivateDataLen", "J"); 1690 if (fieldID == NULL) { return ckParam; } 1691 jPrivateDataLen = (*env)->GetLongField(env, jParam, fieldID); 1692 1693 /* get hPrivateData */ 1694 fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "hPrivateData", "J"); 1695 if (fieldID == NULL) { return ckParam; } 1696 jPrivateData = (*env)->GetLongField(env, jParam, fieldID); 1697 1698 /* get pPublicData2 and ulPublicDataLen2 */ 1699 fieldID = (*env)->GetFieldID(env, jEcdh2DeriveParamsClass, "pPublicData2", "[B"); 1700 if (fieldID == NULL) { return ckParam; } 1701 jPublicData2 = (*env)->GetObjectField(env, jParam, fieldID); 1702 1703 /* populate java values */ 1704 ckParam.kdf = jLongToCKULong(jKdf); 1705 jByteArrayToCKByteArray(env, jSharedData, &(ckParam.pSharedData), &(ckParam.ulSharedDataLen)); 1706 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1707 jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen)); 1708 if ((*env)->ExceptionCheck(env)) { 1709 free(ckParam.pSharedData); 1710 return ckParam; 1711 } 1712 ckParam.ulPrivateDataLen = jLongToCKULong(jPrivateDataLen); 1713 ckParam.hPrivateData = jLongToCKULong(jPrivateData); 1714 jByteArrayToCKByteArray(env, jPublicData2, &(ckParam.pPublicData2), &(ckParam.ulPublicDataLen2)); 1715 if ((*env)->ExceptionCheck(env)) { 1716 free(ckParam.pSharedData); 1717 free(ckParam.pPublicData); 1718 return ckParam; 1719 } 1720 return ckParam ; 1721 } 1722 1723 /* 1724 * converts the Java CK_X9_42_DH1_DERIVE_PARAMS object to a CK_X9_42_DH1_DERIVE_PARAMS structure 1725 * 1726 * @param env - used to call JNI funktions to get the Java classes and objects 1727 * @param jParam - the Java CK_X9_42_DH1_DERIVE_PARAMS object to convert 1728 * @return - the new CK_X9_42_DH1_DERIVE_PARAMS structure 1729 */ 1730 CK_X9_42_DH1_DERIVE_PARAMS jX942Dh1DeriveParamToCKX942Dh1DeriveParam(JNIEnv *env, jobject jParam) 1731 { 1732 jclass jX942Dh1DeriveParamsClass; 1733 CK_X9_42_DH1_DERIVE_PARAMS ckParam; 1734 jfieldID fieldID; 1735 jlong jKdf; 1736 jobject jOtherInfo, jPublicData; 1737 1738 /* get kdf */ 1739 jX942Dh1DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH1_DERIVE_PARAMS); 1740 if (jX942Dh1DeriveParamsClass == NULL) { return ckParam; } 1741 fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "kdf", "J"); 1742 if (fieldID == NULL) { return ckParam; } 1743 jKdf = (*env)->GetLongField(env, jParam, fieldID); 1744 1745 /* get pOtherInfo and ulOtherInfoLen */ 1746 fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "pOtherInfo", "[B"); 1747 if (fieldID == NULL) { return ckParam; } 1748 jOtherInfo = (*env)->GetObjectField(env, jParam, fieldID); 1749 1750 /* get pPublicData and ulPublicDataLen */ 1751 fieldID = (*env)->GetFieldID(env, jX942Dh1DeriveParamsClass, "pPublicData", "[B"); 1752 if (fieldID == NULL) { return ckParam; } 1753 jPublicData = (*env)->GetObjectField(env, jParam, fieldID); 1754 1755 /* populate java values */ 1756 ckParam.kdf = jLongToCKULong(jKdf); 1757 jByteArrayToCKByteArray(env, jOtherInfo, &(ckParam.pOtherInfo), &(ckParam.ulOtherInfoLen)); 1758 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1759 jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen)); 1760 if ((*env)->ExceptionCheck(env)) { 1761 free(ckParam.pOtherInfo); 1762 return ckParam; 1763 } 1764 1765 return ckParam ; 1766 } 1767 1768 /* 1769 * converts the Java CK_X9_42_DH2_DERIVE_PARAMS object to a CK_X9_42_DH2_DERIVE_PARAMS structure 1770 * 1771 * @param env - used to call JNI funktions to get the Java classes and objects 1772 * @param jParam - the Java CK_X9_42_DH2_DERIVE_PARAMS object to convert 1773 * @return - the new CK_X9_42_DH2_DERIVE_PARAMS structure 1774 */ 1775 CK_X9_42_DH2_DERIVE_PARAMS jX942Dh2DeriveParamToCKX942Dh2DeriveParam(JNIEnv *env, jobject jParam) 1776 { 1777 jclass jX942Dh2DeriveParamsClass; 1778 CK_X9_42_DH2_DERIVE_PARAMS ckParam; 1779 jfieldID fieldID; 1780 jlong jKdf, jPrivateDataLen, jPrivateData; 1781 jobject jOtherInfo, jPublicData, jPublicData2; 1782 1783 /* get kdf */ 1784 jX942Dh2DeriveParamsClass = (*env)->FindClass(env, CLASS_X9_42_DH2_DERIVE_PARAMS); 1785 if (jX942Dh2DeriveParamsClass == NULL) { return ckParam; } 1786 fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "kdf", "J"); 1787 if (fieldID == NULL) { return ckParam; } 1788 jKdf = (*env)->GetLongField(env, jParam, fieldID); 1789 1790 /* get pOtherInfo and ulOtherInfoLen */ 1791 fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pOtherInfo", "[B"); 1792 if (fieldID == NULL) { return ckParam; } 1793 jOtherInfo = (*env)->GetObjectField(env, jParam, fieldID); 1794 1795 /* get pPublicData and ulPublicDataLen */ 1796 fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pPublicData", "[B"); 1797 if (fieldID == NULL) { return ckParam; } 1798 jPublicData = (*env)->GetObjectField(env, jParam, fieldID); 1799 1800 /* get ulPrivateDataLen */ 1801 fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "ulPrivateDataLen", "J"); 1802 if (fieldID == NULL) { return ckParam; } 1803 jPrivateDataLen = (*env)->GetLongField(env, jParam, fieldID); 1804 1805 /* get hPrivateData */ 1806 fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "hPrivateData", "J"); 1807 if (fieldID == NULL) { return ckParam; } 1808 jPrivateData = (*env)->GetLongField(env, jParam, fieldID); 1809 1810 /* get pPublicData2 and ulPublicDataLen2 */ 1811 fieldID = (*env)->GetFieldID(env, jX942Dh2DeriveParamsClass, "pPublicData2", "[B"); 1812 if (fieldID == NULL) { return ckParam; } 1813 jPublicData2 = (*env)->GetObjectField(env, jParam, fieldID); 1814 1815 /* populate java values */ 1816 ckParam.kdf = jLongToCKULong(jKdf); 1817 jByteArrayToCKByteArray(env, jOtherInfo, &(ckParam.pOtherInfo), &(ckParam.ulOtherInfoLen)); 1818 if ((*env)->ExceptionCheck(env)) { return ckParam; } 1819 jByteArrayToCKByteArray(env, jPublicData, &(ckParam.pPublicData), &(ckParam.ulPublicDataLen)); 1820 if ((*env)->ExceptionCheck(env)) { 1821 free(ckParam.pOtherInfo); 1822 return ckParam; 1823 } 1824 ckParam.ulPrivateDataLen = jLongToCKULong(jPrivateDataLen); 1825 ckParam.hPrivateData = jLongToCKULong(jPrivateData); 1826 jByteArrayToCKByteArray(env, jPublicData2, &(ckParam.pPublicData2), &(ckParam.ulPublicDataLen2)); 1827 if ((*env)->ExceptionCheck(env)) { 1828 free(ckParam.pOtherInfo); 1829 free(ckParam.pPublicData); 1830 return ckParam; 1831 } 1832 1833 return ckParam ; 1834 }