/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_GetOperationState * Signature: (J)[B * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @return jbyteArray jState CK_BYTE_PTR pOperationState * CK_ULONG_PTR pulOperationStateLen */ JNIEXPORT jbyteArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetOperationState (JNIEnv *env, jobject obj, jlong jSessionHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_BYTE_PTR ckpState; CK_ULONG ckStateLength; jbyteArray jState = NULL; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); rv = (*ckpFunctions->C_GetOperationState)(ckSessionHandle, NULL_PTR, &ckStateLength); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return NULL ; } ckpState = (CK_BYTE_PTR) malloc(ckStateLength); if (ckpState == NULL) { JNU_ThrowOutOfMemoryError(env, 0); return NULL; } rv = (*ckpFunctions->C_GetOperationState)(ckSessionHandle, ckpState, &ckStateLength); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jState = ckByteArrayToJByteArray(env, ckpState, ckStateLength); } free(ckpState); return jState ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_Digest * Signature: (J[BII[BII)I * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jData CK_BYTE_PTR pData * CK_ULONG ulDataLen * @return jbyteArray jDigest CK_BYTE_PTR pDigest * CK_ULONG_PTR pulDigestLen */ JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestSingle (JNIEnv *env, jobject obj, jlong jSessionHandle, jobject jMechanism, jbyteArray jIn, jint jInOfs, jint jInLen, jbyteArray jDigest, jint jDigestOfs, jint jDigestLen) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_BYTE_PTR bufP; CK_BYTE BUF[MAX_STACK_BUFFER_LEN]; CK_BYTE DIGESTBUF[MAX_DIGEST_LEN]; CK_ULONG ckDigestLength = min(MAX_DIGEST_LEN, jDigestLen); CK_MECHANISM ckMechanism; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0; } ckSessionHandle = jLongToCKULong(jSessionHandle); jMechanismToCKMechanism(env, jMechanism, &ckMechanism); if ((*env)->ExceptionCheck(env)) { return 0; } rv = (*ckpFunctions->C_DigestInit)(ckSessionHandle, &ckMechanism); if (ckMechanism.pParameter != NULL_PTR) { free(ckMechanism.pParameter); } if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return 0; } if (jInLen <= MAX_STACK_BUFFER_LEN) { bufP = BUF; } else { /* always use single part op, even for large data */ bufP = (CK_BYTE_PTR) malloc((size_t)jInLen); if (bufP == NULL) { JNU_ThrowOutOfMemoryError(env, 0); return 0; } } (*env)->GetByteArrayRegion(env, jIn, jInOfs, jInLen, (jbyte *)bufP); if ((*env)->ExceptionCheck(env)) { if (bufP != BUF) { free(bufP); } return 0; } rv = (*ckpFunctions->C_Digest)(ckSessionHandle, bufP, jInLen, DIGESTBUF, &ckDigestLength); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { (*env)->SetByteArrayRegion(env, jDigest, jDigestOfs, ckDigestLength, (jbyte *)DIGESTBUF); } if (bufP != BUF) { free(bufP); } return ckDigestLength; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_SignUpdate * Signature: (J[BII)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jPart CK_BYTE_PTR pPart * CK_ULONG ulPartLen */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignUpdate (JNIEnv *env, jobject obj, jlong jSessionHandle, jlong directIn, jbyteArray jIn, jint jInOfs, jint jInLen) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_BYTE_PTR bufP; CK_BYTE BUF[MAX_STACK_BUFFER_LEN]; jsize bufLen; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); if (directIn != 0) { rv = (*ckpFunctions->C_SignUpdate)(ckSessionHandle, (CK_BYTE_PTR) jlong_to_ptr(directIn), jInLen); ckAssertReturnValueOK(env, rv); return; } if (jInLen <= MAX_STACK_BUFFER_LEN) { bufLen = MAX_STACK_BUFFER_LEN; bufP = BUF; } else { bufLen = min(MAX_HEAP_BUFFER_LEN, jInLen); bufP = (CK_BYTE_PTR) malloc((size_t)bufLen); if (bufP == NULL) { throwOutOfMemoryError(env, 0); return; } } while (jInLen > 0) { jsize chunkLen = min(bufLen, jInLen); (*env)->GetByteArrayRegion(env, jIn, jInOfs, chunkLen, (jbyte *)bufP); if ((*env)->ExceptionCheck(env)) { if (bufP != BUF) { free(bufP); } return; } rv = (*ckpFunctions->C_SignUpdate)(ckSessionHandle, bufP, chunkLen); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { if (bufP != BUF) { free(bufP); } return; } jInOfs += chunkLen; jInLen -= chunkLen; } if (bufP != BUF) { free(bufP); } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_Sign * Signature: (J[B)[B * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jData CK_BYTE_PTR pData * CK_ULONG ulDataLen * @return jbyteArray jSignature CK_BYTE_PTR pSignature * CK_ULONG_PTR pulSignatureLen */ JNIEXPORT jbyteArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1Sign (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jData) { CK_SESSION_HANDLE ckSessionHandle; CK_BYTE_PTR ckpData = NULL_PTR; CK_BYTE_PTR ckpSignature; CK_ULONG ckDataLength; CK_ULONG ckSignatureLength = 0; jbyteArray jSignature; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); jByteArrayToCKByteArray(env, jData, &ckpData, &ckDataLength); /* START standard code */ /* first determine the length of the signature */ rv = (*ckpFunctions->C_Sign)(ckSessionHandle, ckpData, ckDataLength, NULL_PTR, &ckSignatureLength); if(ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return NULL ; } ckpSignature = (CK_BYTE_PTR) malloc(ckSignatureLength * sizeof(CK_BYTE)); /* now get the signature */ rv = (*ckpFunctions->C_Sign)(ckSessionHandle, ckpData, ckDataLength, ckpSignature, &ckSignatureLength); /* END standard code */ /* START workaround code for operation abort bug in pkcs#11 of Datakey and iButton */ /* ckpSignature = (CK_BYTE_PTR) malloc(256 * sizeof(CK_BYTE)); rv = (*ckpFunctions->C_Sign)(ckSessionHandle, ckpData, ckDataLength, ckpSignature, &ckSignatureLength); if (rv == CKR_BUFFER_TOO_SMALL) { free(ckpSignature); ckpSignature = (CK_BYTE_PTR) malloc(ckSignatureLength * sizeof(CK_BYTE)); rv = (*ckpFunctions->C_Sign)(ckSessionHandle, ckpData, ckDataLength, ckpSignature, &ckSignatureLength); } */ /* END workaround code */ jSignature = ckByteArrayToJByteArray(env, ckpSignature, ckSignatureLength); free(ckpData); free(ckpSignature); if(ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return NULL ; } return jSignature ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_SignFinal * Signature: (J)[B * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @return jbyteArray jSignature CK_BYTE_PTR pSignature * CK_ULONG_PTR pulSignatureLen */ JNIEXPORT jbyteArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1SignFinal (JNIEnv *env, jobject obj, jlong jSessionHandle, jint jExpectedLength) { CK_SESSION_HANDLE ckSessionHandle; jbyteArray jSignature = NULL; CK_RV rv; CK_BYTE BUF[MAX_STACK_BUFFER_LEN]; CK_BYTE_PTR bufP = BUF; CK_ULONG ckSignatureLength = MAX_STACK_BUFFER_LEN; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); if ((jExpectedLength > 0) && (jExpectedLength < ckSignatureLength)) { ckSignatureLength = jExpectedLength; } rv = (*ckpFunctions->C_SignFinal)(ckSessionHandle, bufP, &ckSignatureLength); if (rv == CKR_BUFFER_TOO_SMALL) { bufP = (CK_BYTE_PTR) malloc(ckSignatureLength); rv = (*ckpFunctions->C_SignFinal)(ckSessionHandle, bufP, &ckSignatureLength); } if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jSignature = ckByteArrayToJByteArray(env, bufP, ckSignatureLength); } if (bufP != BUF) { free(bufP); } return jSignature; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_FindObjectsInit * Signature: (J[Lsun/security/pkcs11/wrapper/CK_ATTRIBUTE;)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jobjectArray jTemplate CK_ATTRIBUTE_PTR pTemplate * CK_ULONG ulCount */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1FindObjectsInit (JNIEnv *env, jobject obj, jlong jSessionHandle, jobjectArray jTemplate) { CK_SESSION_HANDLE ckSessionHandle; CK_ATTRIBUTE_PTR ckpAttributes = NULL_PTR; CK_ULONG ckAttributesLength; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } TRACE0("DEBUG: C_FindObjectsInit"); TRACE1(", hSession=%u", jSessionHandle); TRACE1(", pTemplate=%p", jTemplate); TRACE0(" ... "); ckSessionHandle = jLongToCKULong(jSessionHandle); jAttributeArrayToCKAttributeArray(env, jTemplate, &ckpAttributes, &ckAttributesLength); if ((*env)->ExceptionCheck(env)) { return; } rv = (*ckpFunctions->C_FindObjectsInit)(ckSessionHandle, ckpAttributes, ckAttributesLength); freeCKAttributeArray(ckpAttributes, ckAttributesLength); TRACE0("FINISHED\n"); if(ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_FindObjects * Signature: (JJ)[J * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jlong jMaxObjectCount CK_ULONG ulMaxObjectCount * @return jlongArray jObjectHandleArray CK_OBJECT_HANDLE_PTR phObject * CK_ULONG_PTR pulObjectCount */ JNIEXPORT jlongArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1FindObjects (JNIEnv *env, jobject obj, jlong jSessionHandle, jlong jMaxObjectCount) { CK_RV rv; CK_SESSION_HANDLE ckSessionHandle; CK_ULONG ckMaxObjectLength; CK_OBJECT_HANDLE_PTR ckpObjectHandleArray; CK_ULONG ckActualObjectCount; jlongArray jObjectHandleArray = NULL; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); ckMaxObjectLength = jLongToCKULong(jMaxObjectCount); ckpObjectHandleArray = (CK_OBJECT_HANDLE_PTR) malloc(sizeof(CK_OBJECT_HANDLE) * ckMaxObjectLength); if (ckpObjectHandleArray == NULL) { throwOutOfMemoryError(env, 0); return NULL; } rv = (*ckpFunctions->C_FindObjects)(ckSessionHandle, ckpObjectHandleArray, ckMaxObjectLength, &ckActualObjectCount); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jObjectHandleArray = ckULongArrayToJLongArray(env, ckpObjectHandleArray, ckActualObjectCount); } free(ckpObjectHandleArray); return jObjectHandleArray ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_CreateObject * Signature: (J[Lsun/security/pkcs11/wrapper/CK_ATTRIBUTE;)J * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jobjectArray jTemplate CK_ATTRIBUTE_PTR pTemplate * CK_ULONG ulCount * @return jlong jObjectHandle CK_OBJECT_HANDLE_PTR phObject */ JNIEXPORT jlong JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1CreateObject (JNIEnv *env, jobject obj, jlong jSessionHandle, jobjectArray jTemplate) { CK_SESSION_HANDLE ckSessionHandle; CK_OBJECT_HANDLE ckObjectHandle; CK_ATTRIBUTE_PTR ckpAttributes = NULL_PTR; CK_ULONG ckAttributesLength; jlong jObjectHandle = 0L; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0L; } ckSessionHandle = jLongToCKULong(jSessionHandle); jAttributeArrayToCKAttributeArray(env, jTemplate, &ckpAttributes, &ckAttributesLength); if ((*env)->ExceptionCheck(env)) { return 0L; } rv = (*ckpFunctions->C_CreateObject)(ckSessionHandle, ckpAttributes, ckAttributesLength, &ckObjectHandle); jObjectHandle = ckULongToJLong(ckObjectHandle); freeCKAttributeArray(ckpAttributes, ckAttributesLength); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return 0L ; } return jObjectHandle ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_GenerateRandom * Signature: (J[B)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jRandomData CK_BYTE_PTR pRandomData * CK_ULONG ulRandomDataLen */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GenerateRandom (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jRandomData) { CK_SESSION_HANDLE ckSessionHandle; jbyte *jRandomBuffer; jlong jRandomBufferLength; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); jRandomBufferLength = (*env)->GetArrayLength(env, jRandomData); jRandomBuffer = (*env)->GetByteArrayElements(env, jRandomData, NULL); if (jRandomBuffer == NULL) { return; } rv = (*ckpFunctions->C_GenerateRandom)(ckSessionHandle, (CK_BYTE_PTR) jRandomBuffer, jLongToCKULong(jRandomBufferLength)); /* copy back generated bytes */ (*env)->ReleaseByteArrayElements(env, jRandomData, jRandomBuffer, 0); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_Verify * Signature: (J[B[B)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jData CK_BYTE_PTR pData * CK_ULONG ulDataLen * @param jbyteArray jSignature CK_BYTE_PTR pSignature * CK_ULONG_PTR pulSignatureLen */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1Verify (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jData, jbyteArray jSignature) { CK_SESSION_HANDLE ckSessionHandle; CK_BYTE_PTR ckpData = NULL_PTR; CK_BYTE_PTR ckpSignature = NULL_PTR; CK_ULONG ckDataLength; CK_ULONG ckSignatureLength; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); jByteArrayToCKByteArray(env, jData, &ckpData, &ckDataLength); if ((*env)->ExceptionCheck(env)) { return; } jByteArrayToCKByteArray(env, jSignature, &ckpSignature, &ckSignatureLength); if ((*env)->ExceptionCheck(env)) { free(ckpData); return; } /* verify the signature */ rv = (*ckpFunctions->C_Verify)(ckSessionHandle, ckpData, ckDataLength, ckpSignature, ckSignatureLength); free(ckpData); free(ckpSignature); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_SetOperationState * Signature: (J[BJJ)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jOperationState CK_BYTE_PTR pOperationState * CK_ULONG ulOperationStateLen * @param jlong jEncryptionKeyHandle CK_OBJECT_HANDLE hEncryptionKey * @param jlong jAuthenticationKeyHandle CK_OBJECT_HANDLE hAuthenticationKey */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1SetOperationState (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jOperationState, jlong jEncryptionKeyHandle, jlong jAuthenticationKeyHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_BYTE_PTR ckpState = NULL_PTR; CK_ULONG ckStateLength; CK_OBJECT_HANDLE ckEncryptionKeyHandle; CK_OBJECT_HANDLE ckAuthenticationKeyHandle; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); jByteArrayToCKByteArray(env, jOperationState, &ckpState, &ckStateLength); if ((*env)->ExceptionCheck(env)) { return; } ckEncryptionKeyHandle = jLongToCKULong(jEncryptionKeyHandle); ckAuthenticationKeyHandle = jLongToCKULong(jAuthenticationKeyHandle); rv = (*ckpFunctions->C_SetOperationState)(ckSessionHandle, ckpState, ckStateLength, ckEncryptionKeyHandle, ckAuthenticationKeyHandle); free(ckpState); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_VerifyRecoverInit * Signature: (JLsun/security/pkcs11/wrapper/CK_MECHANISM;J)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jobject jMechanism CK_MECHANISM_PTR pMechanism * @return jlong jKeyHandle CK_OBJECT_HANDLE hKey */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyRecoverInit (JNIEnv *env, jobject obj, jlong jSessionHandle, jobject jMechanism, jlong jKeyHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_MECHANISM ckMechanism; CK_OBJECT_HANDLE ckKeyHandle; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); jMechanismToCKMechanism(env, jMechanism, &ckMechanism); if ((*env)->ExceptionCheck(env)) { return; } ckKeyHandle = jLongToCKULong(jKeyHandle); rv = (*ckpFunctions->C_VerifyRecoverInit)(ckSessionHandle, &ckMechanism, ckKeyHandle); if (ckMechanism.pParameter != NULL_PTR) { free(ckMechanism.pParameter); } if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_CloseAllSessions * Signature: (J)V * Parametermapping: *PKCS11* * @param jlong jSlotID CK_SLOT_ID slotID */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1CloseAllSessions (JNIEnv *env, jobject obj, jlong jSlotID) { CK_SLOT_ID ckSlotID; CK_RV rv; #ifndef NO_CALLBACKS NotifyEncapsulation *notifyEncapsulation; jobject jApplicationData; #endif /* NO_CALLBACKS */ CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSlotID = jLongToCKULong(jSlotID); rv = (*ckpFunctions->C_CloseAllSessions)(ckSlotID); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } #ifndef NO_CALLBACKS /* Remove all notify callback helper objects. */ while ((notifyEncapsulation = removeFirstNotifyEntry(env)) != NULL) { /* there was a notify object used with this session, now dump the * encapsulation object */ (*env)->DeleteGlobalRef(env, notifyEncapsulation->jNotifyObject); jApplicationData = notifyEncapsulation->jApplicationData; if (jApplicationData != NULL) { (*env)->DeleteGlobalRef(env, jApplicationData); } free(notifyEncapsulation); } #endif /* NO_CALLBACKS */ }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_CloseSession * Signature: (J)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1CloseSession (JNIEnv *env, jobject obj, jlong jSessionHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; #ifndef NO_CALLBACKS NotifyEncapsulation *notifyEncapsulation; jobject jApplicationData; #endif /* NO_CALLBACKS */ CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); rv = (*ckpFunctions->C_CloseSession)(ckSessionHandle); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } #ifndef NO_CALLBACKS notifyEncapsulation = removeNotifyEntry(env, ckSessionHandle); if (notifyEncapsulation != NULL) { /* there was a notify object used with this session, now dump the * encapsulation object */ (*env)->DeleteGlobalRef(env, notifyEncapsulation->jNotifyObject); jApplicationData = notifyEncapsulation->jApplicationData; if (jApplicationData != NULL) { (*env)->DeleteGlobalRef(env, jApplicationData); } free(notifyEncapsulation); } #endif /* NO_CALLBACKS */ }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_GenerateKey * Signature: (JLsun/security/pkcs11/wrapper/CK_MECHANISM;[Lsun/security/pkcs11/wrapper/CK_ATTRIBUTE;)J * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jobject jMechanism CK_MECHANISM_PTR pMechanism * @param jobjectArray jTemplate CK_ATTRIBUTE_PTR pTemplate * CK_ULONG ulCount * @return jlong jKeyHandle CK_OBJECT_HANDLE_PTR phKey */ JNIEXPORT jlong JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GenerateKey (JNIEnv *env, jobject obj, jlong jSessionHandle, jobject jMechanism, jobjectArray jTemplate) { CK_SESSION_HANDLE ckSessionHandle; CK_MECHANISM ckMechanism; CK_ATTRIBUTE_PTR ckpAttributes = NULL_PTR; CK_ULONG ckAttributesLength; CK_OBJECT_HANDLE ckKeyHandle = 0; jlong jKeyHandle = 0L; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0L; } ckSessionHandle = jLongToCKULong(jSessionHandle); jMechanismToCKMechanism(env, jMechanism, &ckMechanism); if ((*env)->ExceptionCheck(env)) { return 0L ; } jAttributeArrayToCKAttributeArray(env, jTemplate, &ckpAttributes, &ckAttributesLength); if ((*env)->ExceptionCheck(env)) { if (ckMechanism.pParameter != NULL_PTR) { free(ckMechanism.pParameter); } return 0L; } rv = (*ckpFunctions->C_GenerateKey)(ckSessionHandle, &ckMechanism, ckpAttributes, ckAttributesLength, &ckKeyHandle); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jKeyHandle = ckULongToJLong(ckKeyHandle); /* cheack, if we must give a initialization vector back to Java */ switch (ckMechanism.mechanism) { case CKM_PBE_MD2_DES_CBC: case CKM_PBE_MD5_DES_CBC: case CKM_PBE_MD5_CAST_CBC: case CKM_PBE_MD5_CAST3_CBC: case CKM_PBE_MD5_CAST128_CBC: /* case CKM_PBE_MD5_CAST5_CBC: the same as CKM_PBE_MD5_CAST128_CBC */ case CKM_PBE_SHA1_CAST128_CBC: /* case CKM_PBE_SHA1_CAST5_CBC: the same as CKM_PBE_SHA1_CAST128_CBC */ /* we must copy back the initialization vector to the jMechanism object */ copyBackPBEInitializationVector(env, &ckMechanism, jMechanism); break; } } if (ckMechanism.pParameter != NULL_PTR) { free(ckMechanism.pParameter); } freeCKAttributeArray(ckpAttributes, ckAttributesLength); return jKeyHandle ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_VerifyRecover * Signature: (J[BII[BII)I * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jSignature CK_BYTE_PTR pSignature * CK_ULONG ulSignatureLen * @return jbyteArray jData CK_BYTE_PTR pData * CK_ULONG_PTR pulDataLen */ JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1VerifyRecover (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jIn, jint jInOfs, jint jInLen, jbyteArray jOut, jint jOutOfs, jint jOutLen) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_BYTE INBUF[MAX_STACK_BUFFER_LEN]; CK_BYTE OUTBUF[MAX_STACK_BUFFER_LEN]; CK_BYTE_PTR inBufP; CK_BYTE_PTR outBufP = OUTBUF; CK_ULONG ckDataLength = MAX_STACK_BUFFER_LEN; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0; } ckSessionHandle = jLongToCKULong(jSessionHandle); if (jInLen <= MAX_STACK_BUFFER_LEN) { inBufP = INBUF; } else { inBufP = (CK_BYTE_PTR) malloc((size_t)jInLen); if (inBufP == NULL) { throwOutOfMemoryError(env, 0); return 0; } } (*env)->GetByteArrayRegion(env, jIn, jInOfs, jInLen, (jbyte *)inBufP); if ((*env)->ExceptionCheck(env)) { if (inBufP != INBUF) { free(inBufP); } return 0; } rv = (*ckpFunctions->C_VerifyRecover)(ckSessionHandle, inBufP, jInLen, outBufP, &ckDataLength); /* re-alloc larger buffer if it fits into our Java buffer */ if ((rv == CKR_BUFFER_TOO_SMALL) && (ckDataLength <= jIntToCKULong(jOutLen))) { outBufP = (CK_BYTE_PTR) malloc(ckDataLength); if (outBufP == NULL) { if (inBufP != INBUF) { free(inBufP); } throwOutOfMemoryError(env, 0); return 0; } rv = (*ckpFunctions->C_VerifyRecover)(ckSessionHandle, inBufP, jInLen, outBufP, &ckDataLength); } if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { (*env)->SetByteArrayRegion(env, jOut, jOutOfs, ckDataLength, (jbyte *)outBufP); } if (inBufP != INBUF) { free(inBufP); } if (outBufP != OUTBUF) { free(outBufP); } return ckDataLength; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_Decrypt * Signature: (J[BII[BII)I * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jEncryptedData CK_BYTE_PTR pEncryptedData * CK_ULONG ulEncryptedDataLen * @return jbyteArray jData CK_BYTE_PTR pData * CK_ULONG_PTR pulDataLen */ JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1Decrypt (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jIn, jint jInOfs, jint jInLen, jbyteArray jOut, jint jOutOfs, jint jOutLen) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_BYTE IBUF[MAX_STACK_BUFFER_LEN]; CK_BYTE OBUF[MAX_STACK_BUFFER_LEN]; CK_BYTE_PTR inBufP; CK_BYTE_PTR outBufP; CK_ULONG ckPartLen; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0; } ckSessionHandle = jLongToCKULong(jSessionHandle); if (jInLen > MAX_STACK_BUFFER_LEN) { inBufP = (CK_BYTE_PTR)malloc((size_t)jInLen); } else { inBufP = IBUF; } (*env)->GetByteArrayRegion(env, jIn, jInOfs, jInLen, (jbyte *)inBufP); ckPartLen = jOutLen; if (jOutLen > MAX_STACK_BUFFER_LEN) { outBufP = (CK_BYTE_PTR)malloc((size_t)jOutLen); } else { outBufP = OBUF; } rv = (*ckpFunctions->C_Decrypt)(ckSessionHandle, inBufP, jInLen, outBufP, &ckPartLen); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { if (ckPartLen > 0) { (*env)->SetByteArrayRegion(env, jOut, jOutOfs, ckPartLen, (jbyte *)outBufP); } } if (inBufP != IBUF) { free(inBufP); } if (outBufP != OBUF) { free(outBufP); } return ckPartLen; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_FindObjectsFinal * Signature: (J)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1FindObjectsFinal (JNIEnv *env, jobject obj, jlong jSessionHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); rv = (*ckpFunctions->C_FindObjectsFinal)(ckSessionHandle); if(ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_DigestEncryptUpdate * Signature: (J[B)[B * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jPart CK_BYTE_PTR pPart * CK_ULONG ulPartLen * @return jbyteArray jEncryptedPart CK_BYTE_PTR pEncryptedPart * CK_ULONG_PTR pulEncryptedPartLen */ JNIEXPORT jbyteArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestEncryptUpdate (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jPart) { CK_SESSION_HANDLE ckSessionHandle; CK_BYTE_PTR ckpPart = NULL_PTR, ckpEncryptedPart; CK_ULONG ckPartLength, ckEncryptedPartLength = 0; jbyteArray jEncryptedPart = NULL; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); jByteArrayToCKByteArray(env, jPart, &ckpPart, &ckPartLength); if ((*env)->ExceptionCheck(env)) { return NULL; } rv = (*ckpFunctions->C_DigestEncryptUpdate)(ckSessionHandle, ckpPart, ckPartLength, NULL_PTR, &ckEncryptedPartLength); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { free(ckpPart); return NULL; } ckpEncryptedPart = (CK_BYTE_PTR) malloc(ckEncryptedPartLength * sizeof(CK_BYTE)); if (ckpEncryptedPart == NULL) { free(ckpPart); JNU_ThrowOutOfMemoryError(env, 0); return NULL; } rv = (*ckpFunctions->C_DigestEncryptUpdate)(ckSessionHandle, ckpPart, ckPartLength, ckpEncryptedPart, &ckEncryptedPartLength); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jEncryptedPart = ckByteArrayToJByteArray(env, ckpEncryptedPart, ckEncryptedPartLength); } free(ckpPart); free(ckpEncryptedPart); return jEncryptedPart ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_CancelFunction * Signature: (J)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1CancelFunction (JNIEnv *env, jobject obj, jlong jSessionHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); /* C_GetFunctionStatus should always return CKR_FUNCTION_NOT_PARALLEL */ rv = (*ckpFunctions->C_CancelFunction)(ckSessionHandle); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_WrapKey * Signature: (JLsun/security/pkcs11/wrapper/CK_MECHANISM;JJ)[B * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jobject jMechanism CK_MECHANISM_PTR pMechanism * @param jlong jWrappingKeyHandle CK_OBJECT_HANDLE hWrappingKey * @param jlong jKeyHandle CK_OBJECT_HANDLE hKey * @return jbyteArray jWrappedKey CK_BYTE_PTR pWrappedKey * CK_ULONG_PTR pulWrappedKeyLen */ JNIEXPORT jbyteArray JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1WrapKey (JNIEnv *env, jobject obj, jlong jSessionHandle, jobject jMechanism, jlong jWrappingKeyHandle, jlong jKeyHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_MECHANISM ckMechanism; CK_OBJECT_HANDLE ckWrappingKeyHandle; CK_OBJECT_HANDLE ckKeyHandle; jbyteArray jWrappedKey = NULL; CK_RV rv; CK_BYTE BUF[MAX_STACK_BUFFER_LEN]; CK_BYTE_PTR ckpWrappedKey = BUF; CK_ULONG ckWrappedKeyLength = MAX_STACK_BUFFER_LEN; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); jMechanismToCKMechanism(env, jMechanism, &ckMechanism); if ((*env)->ExceptionCheck(env)) { return NULL; } ckWrappingKeyHandle = jLongToCKULong(jWrappingKeyHandle); ckKeyHandle = jLongToCKULong(jKeyHandle); rv = (*ckpFunctions->C_WrapKey)(ckSessionHandle, &ckMechanism, ckWrappingKeyHandle, ckKeyHandle, ckpWrappedKey, &ckWrappedKeyLength); if (rv == CKR_BUFFER_TOO_SMALL) { ckpWrappedKey = (CK_BYTE_PTR) malloc(ckWrappedKeyLength); if (ckpWrappedKey == NULL) { if (ckMechanism.pParameter != NULL_PTR) { free(ckMechanism.pParameter); } throwOutOfMemoryError(env, 0); return NULL; } rv = (*ckpFunctions->C_WrapKey)(ckSessionHandle, &ckMechanism, ckWrappingKeyHandle, ckKeyHandle, ckpWrappedKey, &ckWrappedKeyLength); } if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jWrappedKey = ckByteArrayToJByteArray(env, ckpWrappedKey, ckWrappedKeyLength); } if (ckpWrappedKey != BUF) { free(ckpWrappedKey); } if (ckMechanism.pParameter != NULL_PTR) { free(ckMechanism.pParameter); } return jWrappedKey ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_EncryptFinal * Signature: (J[BII)I * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @return jbyteArray jLastEncryptedPart CK_BYTE_PTR pLastEncryptedDataPart * CK_ULONG_PTR pulLastEncryptedDataPartLen */ JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1EncryptFinal (JNIEnv *env, jobject obj, jlong jSessionHandle, jlong directOut, jbyteArray jOut, jint jOutOfs, jint jOutLen) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_BYTE BUF[MAX_STACK_BUFFER_LEN]; CK_BYTE_PTR outBufP; CK_ULONG ckLastEncryptedPartLen; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0; } ckSessionHandle = jLongToCKULong(jSessionHandle); ckLastEncryptedPartLen = jOutLen; if (directOut != 0) { outBufP = (CK_BYTE_PTR)(directOut + jOutOfs); } else { // output length should always be less than MAX_STACK_BUFFER_LEN outBufP = BUF; } //printf("EF: outBufP=%i\n", outBufP); rv = (*ckpFunctions->C_EncryptFinal)(ckSessionHandle, outBufP, &ckLastEncryptedPartLen); //printf("EF: ckLastEncryptedPartLen=%i", ckLastEncryptedPartLen); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { if (directOut == 0 && ckLastEncryptedPartLen > 0) { (*env)->SetByteArrayRegion(env, jOut, jOutOfs, ckLastEncryptedPartLen, (jbyte *)outBufP); } } if (directOut == 0 && outBufP != BUF) { free(outBufP); } return ckLastEncryptedPartLen; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_GetSessionInfo * Signature: (J)Lsun/security/pkcs11/wrapper/CK_SESSION_INFO; * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @return jobject jSessionInfo CK_SESSION_INFO_PTR pInfo */ JNIEXPORT jobject JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetSessionInfo (JNIEnv *env, jobject obj, jlong jSessionHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_SESSION_INFO ckSessionInfo; jobject jSessionInfo=NULL; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return NULL; } ckSessionHandle = jLongToCKULong(jSessionHandle); rv = (*ckpFunctions->C_GetSessionInfo)(ckSessionHandle, &ckSessionInfo); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { jSessionInfo = ckSessionInfoPtrToJSessionInfo(env, &ckSessionInfo); } return jSessionInfo ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_DigestFinal * Signature: (J[BII)I * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @return jbyteArray jDigest CK_BYTE_PTR pDigest * CK_ULONG_PTR pulDigestLen */ JNIEXPORT jint JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1DigestFinal (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jDigest, jint jDigestOfs, jint jDigestLen) { CK_SESSION_HANDLE ckSessionHandle; CK_RV rv; CK_BYTE BUF[MAX_DIGEST_LEN]; CK_ULONG ckDigestLength = min(MAX_DIGEST_LEN, jDigestLen); CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0; } ckSessionHandle = jLongToCKULong(jSessionHandle); rv = (*ckpFunctions->C_DigestFinal)(ckSessionHandle, BUF, &ckDigestLength); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { (*env)->SetByteArrayRegion(env, jDigest, jDigestOfs, ckDigestLength, (jbyte *)BUF); } return ckDigestLength; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_SeedRandom * Signature: (J[B)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jbyteArray jSeed CK_BYTE_PTR pSeed * CK_ULONG ulSeedLen */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1SeedRandom (JNIEnv *env, jobject obj, jlong jSessionHandle, jbyteArray jSeed) { CK_SESSION_HANDLE ckSessionHandle; CK_BYTE_PTR ckpSeed = NULL_PTR; CK_ULONG ckSeedLength; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); jByteArrayToCKByteArray(env, jSeed, &ckpSeed, &ckSeedLength); rv = (*ckpFunctions->C_SeedRandom)(ckSessionHandle, ckpSeed, ckSeedLength); free(ckpSeed); if(ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_GetObjectSize * Signature: (JJ)J * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jlong jObjectHandle CK_OBJECT_HANDLE hObject * @return jlong jObjectSize CK_ULONG_PTR pulSize */ JNIEXPORT jlong JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetObjectSize (JNIEnv *env, jobject obj, jlong jSessionHandle, jlong jObjectHandle) { CK_SESSION_HANDLE ckSessionHandle; CK_OBJECT_HANDLE ckObjectHandle; CK_ULONG ckObjectSize; jlong jObjectSize = 0L; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0L; } ckSessionHandle = jLongToCKULong(jSessionHandle); ckObjectHandle = jLongToCKULong(jObjectHandle); rv = (*ckpFunctions->C_GetObjectSize)(ckSessionHandle, ckObjectHandle, &ckObjectSize); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return 0L ; } jObjectSize = ckULongToJLong(ckObjectSize); return jObjectSize ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_Login * Signature: (JJ[C)V * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jlong jUserType CK_USER_TYPE userType * @param jcharArray jPin CK_CHAR_PTR pPin * CK_ULONG ulPinLen */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1Login (JNIEnv *env, jobject obj, jlong jSessionHandle, jlong jUserType, jcharArray jPin) { CK_SESSION_HANDLE ckSessionHandle; CK_USER_TYPE ckUserType; CK_CHAR_PTR ckpPinArray = NULL_PTR; CK_ULONG ckPinLength; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } ckSessionHandle = jLongToCKULong(jSessionHandle); ckUserType = jLongToCKULong(jUserType); jCharArrayToCKCharArray(env, jPin, &ckpPinArray, &ckPinLength); if ((*env)->ExceptionCheck(env)) { return; } rv = (*ckpFunctions->C_Login)(ckSessionHandle, ckUserType, ckpPinArray, ckPinLength); free(ckpPinArray); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_OpenSession * Signature: (JJLjava/lang/Object;Lsun/security/pkcs11/wrapper/CK_NOTIFY;)J * Parametermapping: *PKCS11* * @param jlong jSlotID CK_SLOT_ID slotID * @param jlong jFlags CK_FLAGS flags * @param jobject jApplication CK_VOID_PTR pApplication * @param jobject jNotify CK_NOTIFY Notify * @return jlong jSessionHandle CK_SESSION_HANDLE_PTR phSession */ JNIEXPORT jlong JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1OpenSession (JNIEnv *env, jobject obj, jlong jSlotID, jlong jFlags, jobject jApplication, jobject jNotify) { CK_SESSION_HANDLE ckSessionHandle; CK_SLOT_ID ckSlotID; CK_FLAGS ckFlags; CK_VOID_PTR ckpApplication; CK_NOTIFY ckNotify; jlong jSessionHandle; CK_RV rv; #ifndef NO_CALLBACKS NotifyEncapsulation *notifyEncapsulation = NULL; #endif /* NO_CALLBACKS */ CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return 0L; } ckSlotID = jLongToCKULong(jSlotID); ckFlags = jLongToCKULong(jFlags); #ifndef NO_CALLBACKS if (jNotify != NULL) { notifyEncapsulation = (NotifyEncapsulation *) malloc(sizeof(NotifyEncapsulation)); if (notifyEncapsulation == NULL) { JNU_ThrowOutOfMemoryError(env, 0); return 0L; } notifyEncapsulation->jApplicationData = (jApplication != NULL) ? (*env)->NewGlobalRef(env, jApplication) : NULL; notifyEncapsulation->jNotifyObject = (*env)->NewGlobalRef(env, jNotify); ckpApplication = notifyEncapsulation; ckNotify = (CK_NOTIFY) ¬ifyCallback; } else { ckpApplication = NULL_PTR; ckNotify = NULL_PTR; } #else ckpApplication = NULL_PTR; ckNotify = NULL_PTR; #endif /* NO_CALLBACKS */ TRACE0("DEBUG: C_OpenSession"); TRACE1(", slotID=%u", ckSlotID); TRACE1(", flags=%x", ckFlags); TRACE0(" ... "); rv = (*ckpFunctions->C_OpenSession)(ckSlotID, ckFlags, ckpApplication, ckNotify, &ckSessionHandle); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { #ifndef NO_CALLBACKS if (notifyEncapsulation != NULL) { if (notifyEncapsulation->jApplicationData != NULL) { (*env)->DeleteGlobalRef(env, jApplication); } (*env)->DeleteGlobalRef(env, jNotify); free(notifyEncapsulation); } #endif /* NO_CALLBACKS */ return 0L; } TRACE0("got session"); TRACE1(", SessionHandle=%u", ckSessionHandle); TRACE0(" ... "); jSessionHandle = ckULongToJLong(ckSessionHandle); #ifndef NO_CALLBACKS if (notifyEncapsulation != NULL) { /* store the notifyEncapsulation to enable later cleanup */ putNotifyEntry(env, ckSessionHandle, notifyEncapsulation); } #endif /* NO_CALLBACKS */ TRACE0("FINISHED\n"); return jSessionHandle ; }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: C_GetAttributeValue * Signature: (JJ[Lsun/security/pkcs11/wrapper/CK_ATTRIBUTE;)[Lsun/security/pkcs11/wrapper/CK_ATTRIBUTE; * Parametermapping: *PKCS11* * @param jlong jSessionHandle CK_SESSION_HANDLE hSession * @param jlong jObjectHandle CK_OBJECT_HANDLE hObject * @param jobjectArray jTemplate CK_ATTRIBUTE_PTR pTemplate * CK_ULONG ulCount */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_C_1GetAttributeValue (JNIEnv *env, jobject obj, jlong jSessionHandle, jlong jObjectHandle, jobjectArray jTemplate) { CK_SESSION_HANDLE ckSessionHandle; CK_OBJECT_HANDLE ckObjectHandle; CK_ATTRIBUTE_PTR ckpAttributes = NULL_PTR; CK_ULONG ckAttributesLength; CK_ULONG ckBufferLength; CK_ULONG i; jobject jAttribute; CK_RV rv; CK_FUNCTION_LIST_PTR ckpFunctions = getFunctionList(env, obj); if (ckpFunctions == NULL) { return; } TRACE0("DEBUG: C_GetAttributeValue"); TRACE1(", hSession=%u", jSessionHandle); TRACE1(", hObject=%u", jObjectHandle); TRACE1(", pTemplate=%p", jTemplate); TRACE0(" ... "); ckSessionHandle = jLongToCKULong(jSessionHandle); ckObjectHandle = jLongToCKULong(jObjectHandle); TRACE1("jAttributeArrayToCKAttributeArray now with jTemplate = %d", jTemplate); jAttributeArrayToCKAttributeArray(env, jTemplate, &ckpAttributes, &ckAttributesLength); if ((*env)->ExceptionCheck(env)) { return; } TRACE2("DEBUG: jAttributeArrayToCKAttributeArray finished with ckpAttribute = %d, Length = %d\n", ckpAttributes, ckAttributesLength); /* first set all pValue to NULL, to get the needed buffer length */ for(i = 0; i < ckAttributesLength; i++) { if (ckpAttributes[i].pValue != NULL_PTR) { free(ckpAttributes[i].pValue); ckpAttributes[i].pValue = NULL_PTR; } } rv = (*ckpFunctions->C_GetAttributeValue)(ckSessionHandle, ckObjectHandle, ckpAttributes, ckAttributesLength); if (ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { free(ckpAttributes); return ; } /* now, the ulValueLength field of each attribute should hold the exact buffer length needed * allocate the needed buffers accordingly */ for (i = 0; i < ckAttributesLength; i++) { ckBufferLength = sizeof(CK_BYTE) * ckpAttributes[i].ulValueLen; ckpAttributes[i].pValue = (void *) malloc(ckBufferLength); if (ckpAttributes[i].pValue == NULL) { freeCKAttributeArray(ckpAttributes, i); throwOutOfMemoryError(env, 0); return; } ckpAttributes[i].ulValueLen = ckBufferLength; } /* now get the attributes with all values */ rv = (*ckpFunctions->C_GetAttributeValue)(ckSessionHandle, ckObjectHandle, ckpAttributes, ckAttributesLength); if (ckAssertReturnValueOK(env, rv) == CK_ASSERT_OK) { /* copy back the values to the Java attributes */ for (i = 0; i < ckAttributesLength; i++) { jAttribute = ckAttributePtrToJAttribute(env, &(ckpAttributes[i])); if (jAttribute == NULL) { freeCKAttributeArray(ckpAttributes, ckAttributesLength); return; } (*env)->SetObjectArrayElement(env, jTemplate, i, jAttribute); if ((*env)->ExceptionCheck(env)) { freeCKAttributeArray(ckpAttributes, ckAttributesLength); return; } } } freeCKAttributeArray(ckpAttributes, ckAttributesLength); TRACE0("FINISHED\n"); }
/* * Class: sun_security_pkcs11_wrapper_PKCS11 * Method: connect * Signature: (Ljava/lang/String;)V */ JNIEXPORT void JNICALL Java_sun_security_pkcs11_wrapper_PKCS11_connect (JNIEnv *env, jobject obj, jstring jPkcs11ModulePath, jstring jGetFunctionList) { void *hModule; char *error; CK_C_GetFunctionList C_GetFunctionList; CK_RV rv; ModuleData *moduleData; jobject globalPKCS11ImplementationReference; char *systemErrorMessage; char *exceptionMessage; const char *getFunctionListStr; const char *libraryNameStr = (*env)->GetStringUTFChars(env, jPkcs11ModulePath, 0); TRACE1("DEBUG: connect to PKCS#11 module: %s ... ", libraryNameStr); /* * Load the PKCS #11 DLL */ dlerror(); /* clear any old error message not fetched */ #ifdef DEBUG hModule = dlopen(libraryNameStr, RTLD_NOW); #else hModule = dlopen(libraryNameStr, RTLD_LAZY); #endif /* DEBUG */ if (hModule == NULL) { systemErrorMessage = dlerror(); exceptionMessage = (char *) malloc(sizeof(char) * (strlen(systemErrorMessage) + strlen(libraryNameStr) + 1)); strcpy(exceptionMessage, systemErrorMessage); strcat(exceptionMessage, libraryNameStr); throwIOException(env, exceptionMessage); (*env)->ReleaseStringUTFChars(env, jPkcs11ModulePath, libraryNameStr); free(exceptionMessage); return; } /* * Get function pointer to C_GetFunctionList */ dlerror(); /* clear any old error message not fetched */ // with the old JAR file jGetFunctionList is null, temporarily check for that if (jGetFunctionList != NULL) { getFunctionListStr = (*env)->GetStringUTFChars(env, jGetFunctionList, 0); C_GetFunctionList = (CK_C_GetFunctionList) dlsym(hModule, getFunctionListStr); (*env)->ReleaseStringUTFChars(env, jGetFunctionList, getFunctionListStr); } if (C_GetFunctionList == NULL) { throwIOException(env, "ERROR: C_GetFunctionList == NULL"); return; } else if ( (systemErrorMessage = dlerror()) != NULL ){ throwIOException(env, systemErrorMessage); return; } /* * Get function pointers to all PKCS #11 functions */ moduleData = (ModuleData *) malloc(sizeof(ModuleData)); moduleData->hModule = hModule; moduleData->applicationMutexHandler = NULL; rv = (C_GetFunctionList)(&(moduleData->ckFunctionListPtr)); globalPKCS11ImplementationReference = (*env)->NewGlobalRef(env, obj); putModuleEntry(env, globalPKCS11ImplementationReference, moduleData); (*env)->ReleaseStringUTFChars(env, jPkcs11ModulePath, libraryNameStr); TRACE0("FINISHED\n"); if(ckAssertReturnValueOK(env, rv) != CK_ASSERT_OK) { return; } }