【windows环境 PKCS11库Demo 用于劫持PKCS11库并打印参数】

最新推荐文章于 2024-06-10 09:48:29 发布
最新推荐文章于 2024-06-10 09:48:29 发布
阅读量849 收藏 3
点赞数 2
文章标签： 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43368574/article/details/123555705
版权

windows环境 PKCS11库Demo 用于劫持PKCS11库并打印参数

背景

PKCS(Public—Key Cryptography Standards)是著名的RSA实验室为提供公钥加密技术的互操作性而发布的一系列可供参照的标准。

最近在对新版本签名控件（包含交易签名、证书下载更新等功能）添加支持PKCS11标准时， 遇到这种问题场景，银行客户手中有一款老版本的客户端软件可以调用某UK厂商的PKCS11库进行签名、下载证书等操作，但由于该UKey厂商已经倒闭，所以新版本签名控件在集成该UKey类型时没有UK厂商的支持，根据标准的PKCS11文档中调用该PKCS11库并没有得到期望的响应，所以想通过DLL劫持的方式，捕捉一下银行客户老版本客户端调用UK厂商的PKCS11库传入的什么参数。

PKCS11函数表

我想到最快的方式就是去Github去找一下有没有类似的PKCS11Demo，果然是有的，根据自己的需要，每个函数只需要进行打印需要的参数，然后调用UKey厂商真实PKCS11库即可，需要注意的是C_GetFunctionList 需要返回自己库的函数表。

链接: link.

我把自己的库上传资源，如果有遇到类似问题的可以下载参考；
环境：Windows10 + VS2010
有问题 可以添加我的QQ 942098061
HKB_DFTX_pkcs11.cpp.

// HKB_DFTX_pkcs11.cpp : 定义 DLL 应用程序的导出函数。
//
#include "stdafx.h"
#include "cryptoki.h"
//#include "pkcs11.h"
#include <string.h>
#include "Utility.h"
/* SPDX-License-Identifier: BSD-2-Clause */

//#include "cryptoki.h"


//自定义信息
HMODULE m_hInstLib;
CK_FUNCTION_LIST_PTR p11;
typedef CK_RV(*C_GETFUNCTIONLIST)(CK_FUNCTION_LIST_PTR_PTR ppFunctionList);

#define DATA_TYPE_STRING     0
#define DATA_TYPE_LONG       1
#define DATA_TYPE_BOOL       2
///

void PRINT_CK_ATTRIBUTE (CK_ATTRIBUTE_PTR templ)
{
	CK_ATTRIBUTE_TYPE type =templ->type;
	std::wstring wstrtype = L"";
	std::wstring wstrValue = L"";
	std::wstring wstrtemp = L"";
	int nDataType = DATA_TYPE_STRING;

	switch(type)
	{
	case CKA_CLASS:
		wstrtype = L"CKA_CLASS";
		nDataType = DATA_TYPE_LONG;
		break;
	case CKA_TOKEN:
		wstrtype = L"CKA_TOKEN";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_CERTIFICATE_TYPE:
		wstrtype = L"CKA_CERTIFICATE_TYPE";
		nDataType = DATA_TYPE_LONG;
		break;
	case CKA_SUBJECT:
		wstrtype = L"CKA_SUBJECT";
		nDataType = DATA_TYPE_STRING;
		break;
	case CKA_ID:
		wstrtype = L"CKA_ID";
		nDataType = DATA_TYPE_STRING;
		break;
	case CKA_VALUE:
		wstrtype = L"CKA_VALUE";
		nDataType = DATA_TYPE_STRING;
		break;
	case CKA_PRIVATE:
		wstrtype = L"CKA_PRIVATE";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_KEY_TYPE:
		wstrtype = L"CKA_KEY_TYPE";
		nDataType = DATA_TYPE_LONG;
		break;
	case CKA_ENCRYPT:
		wstrtype = L"CKA_ENCRYPT";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_VERIFY:
		wstrtype = L"CKA_VERIFY";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_WRAP:
		wstrtype = L"CKA_WRAP";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_MODULUS_BITS:
		wstrtype = L"CKA_MODULUS_BITS";
		nDataType = DATA_TYPE_LONG;
		break;
	case CKA_PUBLIC_EXPONENT:
		wstrtype = L"CKA_PUBLIC_EXPONENT";
		nDataType = DATA_TYPE_STRING;
		break;
	case CKA_SENSITIVE:
		wstrtype = L"CKA_SENSITIVE";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_DECRYPT:
		wstrtype = L"CKA_DECRYPT";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_SIGN:
		wstrtype = L"CKA_TOKEN";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_UNWRAP:
		wstrtype = L"CKA_UNWRAP";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_DERIVE:
		wstrtype = L"CKA_DERIVE";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_VERIFY_RECOVER:
		wstrtype = L"CKA_VERIFY_RECOVER";
		nDataType = DATA_TYPE_BOOL;
		break;
	case CKA_LABEL:
		wstrtype = L"CKA_LABEL";
		nDataType = DATA_TYPE_STRING;
		break;
	case CKA_ISSUER:
		wstrtype = L"CKA_ISSUER";
		nDataType = DATA_TYPE_STRING;
		break;
	case CKA_SERIAL_NUMBER:
		wstrtype = L"CKA_SERIAL_NUMBER";
		nDataType = DATA_TYPE_STRING;
		break;
	default :
		wstrtemp = CUtility::b64encode_to_wstring((unsigned char*)templ->pValue, templ->ulValueLen);
		PRINT_INFO(L"Default type = 0x%.8X,Value = %s",type, wstrtemp.c_str());
		return;
	}

	std::wstring wstrDataType = L"";
	switch(nDataType)
	{
	case DATA_TYPE_STRING:
		wstrDataType = L"string";
		wstrtemp = CUtility::b64encode_to_wstring((unsigned char*)templ->pValue, templ->ulValueLen);
		PRINT_INFO(L"type = %s, DataType = %s, Value = %s",wstrtype.c_str(),wstrDataType.c_str(), wstrtemp.c_str());
		break;
	case DATA_TYPE_LONG:
		wstrDataType = L"unsigned long int";
		PRINT_INFO(L"type = %s, DataType = %s, Value = 0x%.8X",wstrtype.c_str(),wstrDataType.c_str(),*((CK_ULONG *)templ->pValue));
		break;
	case DATA_TYPE_BOOL:
		wstrDataType = L"bool";
		if (*((CK_BBOOL *)templ->pValue) == TRUE)
			wstrValue = L"TRUE";
		else
			wstrValue = L"FALSE";
		PRINT_INFO(L"type = %s, DataType = %s, Value = %s",wstrtype.c_str(),wstrDataType.c_str(),wstrValue.c_str());
		break;
	default :
		PRINT_INFO(L"nDataType not found");
	}
}


__declspec(dllexport) CK_RV C_Initialize (void *init_args) {

	PRINT_INFO(L"-----***------");

	CK_RV rv;

	TCHAR buf[MAX_PATH] = {'\0'};
	WCHAR* p11path = L"";
	::GetModuleFileName( NULL, buf, MAX_PATH);
	p11path = buf;
	WCHAR* p11name = L"\\HKB_DFTX_pkcs11.dll";
	wcscpy(p11path+wcslen(p11path),p11name);

	m_hInstLib = LoadLibrary(TEXT("D:\\p11lib\\HKB_DFTX_pkcs11.dll"));
	//m_hInstLib = LoadLibrary(TEXT("D:\\p11lib\\HKB_Enterprise_Jansh_2.1.dll"));
	if (!m_hInstLib) 
		return -1;

	C_GETFUNCTIONLIST pfC_GetFunctionList = (C_GETFUNCTIONLIST) GetProcAddress(m_hInstLib, "C_GetFunctionList"); 
	if (!pfC_GetFunctionList) 
	{
		FreeLibrary(m_hInstLib);
		m_hInstLib = NULL;
		return -2;
	}

	rv = pfC_GetFunctionList(&p11);
	if (rv != CKR_OK)
	{
		FreeLibrary(m_hInstLib);
		m_hInstLib = NULL;
		return -3;
	}

	rv = pfC_GetFunctionList(&p11);
	if (rv != CKR_OK)
	{
		FreeLibrary(m_hInstLib);
		m_hInstLib = NULL;
		return -3;
	}

	rv = p11->C_Initialize(init_args);
	if(rv != CKR_OK && rv != CKR_CRYPTOKI_ALREADY_INITIALIZED)
	{
		p11 = NULL;
		return rv;
	}

	return rv;
}

__declspec(dllexport) CK_RV C_Finalize (void *pReserved) {
	PRINT_INFO(L"-----***------");
	CK_RV rv =  p11->C_Finalize(pReserved);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetInfo (CK_INFO *info) {
	PRINT_INFO(L"-----***------");
	CK_RV rv =  p11->C_GetInfo(info);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetFunctionList (CK_FUNCTION_LIST **ppFunctionList) {
	PRINT_INFO(L"-----***------");

	//CUtility::InitLog();

	CK_FUNCTION_LIST_PTR function_list;
	//CK_FUNCTION_LIST* function_list;
	function_list = new CK_FUNCTION_LIST;
	function_list->version.major = 2;
	function_list->version.minor = 4;
	function_list->C_CancelFunction = C_CancelFunction;
	function_list->C_CloseAllSessions = C_CloseAllSessions;
	function_list->C_CloseSession = C_CloseSession;
	function_list->C_CopyObject = C_CopyObject;
	function_list->C_CreateObject = C_CreateObject;
	function_list->C_Decrypt = C_Decrypt;
	function_list->C_DecryptDigestUpdate = C_DecryptDigestUpdate;
	function_list->C_DecryptFinal = C_DecryptFinal;
	function_list->C_DecryptInit = C_DecryptInit;
	function_list->C_DecryptUpdate = C_DecryptUpdate;
	function_list->C_DecryptVerifyUpdate = C_DecryptVerifyUpdate;
	function_list->C_DeriveKey = C_DeriveKey;
	function_list->C_DestroyObject = C_DestroyObject;
	function_list->C_Digest = C_Digest;
	function_list->C_DigestEncryptUpdate = C_DigestEncryptUpdate;
	function_list->C_DigestFinal = C_DigestFinal;
	function_list->C_DigestInit = C_DigestInit;
	function_list->C_DigestKey = C_DigestKey;
	function_list->C_DigestUpdate = C_DigestUpdate;
	function_list->C_Encrypt = C_Encrypt;
	function_list->C_EncryptFinal = C_EncryptFinal;
	function_list->C_EncryptInit = C_EncryptInit;
	function_list->C_EncryptUpdate = C_EncryptUpdate;
	function_list->C_Finalize = C_Finalize;
	function_list->C_FindObjects = C_FindObjects;
	function_list->C_FindObjectsFinal = C_FindObjectsFinal;
	function_list->C_FindObjectsInit = C_FindObjectsInit;
	function_list->C_GenerateKey = C_GenerateKey;
	function_list->C_GenerateKeyPair = C_GenerateKeyPair;
	function_list->C_GenerateRandom = C_GenerateRandom;
	function_list->C_GetAttributeValue = C_GetAttributeValue;
	function_list->C_GetFunctionList = C_GetFunctionList;
	function_list->C_GetFunctionStatus = C_GetFunctionStatus;
	function_list->C_GetInfo = C_GetInfo;
	function_list->C_GetMechanismInfo = C_GetMechanismInfo;
	function_list->C_GetMechanismList = C_GetMechanismList;
	function_list->C_GetObjectSize = C_GetObjectSize;
	function_list->C_GetOperationState = C_GetOperationState;
	function_list->C_GetSessionInfo = C_GetSessionInfo;
	function_list->C_GetSlotInfo = C_GetSlotInfo;
	function_list->C_GetSlotList = C_GetSlotList;
	function_list->C_GetTokenInfo = C_GetTokenInfo;
	function_list->C_Initialize = C_Initialize;
	function_list->C_InitPIN = C_InitPIN;
	function_list->C_InitToken = C_InitToken;
	function_list->C_Login = C_Login;
	function_list->C_Logout = C_Logout;
	function_list->C_OpenSession = C_OpenSession;
	function_list->C_SeedRandom = C_SeedRandom;
	function_list->C_SetAttributeValue = C_SetAttributeValue;
	function_list->C_SetOperationState = C_SetOperationState;
	function_list->C_SetPIN = C_SetPIN;
	function_list->C_Sign = C_Sign;
	function_list->C_SignEncryptUpdate = C_SignEncryptUpdate;
	function_list->C_SignFinal = C_SignFinal;
	function_list->C_SignInit = C_SignInit;
	function_list->C_SignRecover = C_SignRecover;
	function_list->C_SignRecoverInit = C_SignRecoverInit;
	function_list->C_SignUpdate = C_SignUpdate;
	function_list->C_UnwrapKey = C_UnwrapKey;
	function_list->C_Verify = C_Verify;
	function_list->C_VerifyFinal = C_VerifyFinal;
	function_list->C_VerifyInit = C_VerifyInit;
	function_list->C_VerifyRecover = C_VerifyRecover;
	function_list->C_VerifyRecoverInit = C_VerifyRecoverInit;
	function_list->C_VerifyUpdate = C_VerifyUpdate;
	function_list->C_WaitForSlotEvent = C_WaitForSlotEvent;
	function_list->C_WrapKey = C_WrapKey;

	*ppFunctionList=function_list;
	return CKR_OK;
}

__declspec(dllexport) CK_RV C_GetSlotList (CK_BYTE token_present, CK_SLOT_ID *slot_list, CK_ULONG_PTR count) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetSlotList(token_present,  slot_list, count);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetSlotInfo (CK_SLOT_ID slotID, CK_SLOT_INFO *info) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetSlotInfo(slotID,  info);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetTokenInfo (CK_SLOT_ID slotID, CK_TOKEN_INFO *info) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetTokenInfo(slotID,  info);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_WaitForSlotEvent (CK_FLAGS flags, CK_SLOT_ID *slot, void *pReserved) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_WaitForSlotEvent ( flags,  slot, pReserved);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetMechanismList (CK_SLOT_ID slotID, CK_MECHANISM_TYPE *mechanism_list, CK_ULONG_PTR count) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetMechanismList( slotID, mechanism_list,  count);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetMechanismInfo (CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO *info) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetMechanismInfo( slotID, type,  info);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_InitToken (CK_SLOT_ID slotID, CK_BYTE_PTR pin, CK_ULONG pin_len, CK_BYTE_PTR label) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_InitToken( slotID, pin, pin_len, label);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_InitPIN (CK_SESSION_HANDLE session, CK_UTF8CHAR_PTR pin, CK_ULONG pin_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_InitPIN( session, pin, pin_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SetPIN (CK_SESSION_HANDLE session, CK_UTF8CHAR_PTR old_pin, CK_ULONG old_len, CK_UTF8CHAR_PTR new_pin, CK_ULONG new_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SetPIN( session, old_pin, old_len, new_pin, new_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_OpenSession (CK_SLOT_ID slotID, CK_FLAGS flags, void *application, CK_NOTIFY notify, CK_SESSION_HANDLE *session) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_OpenSession( slotID, flags, application, notify, session);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_CloseSession (CK_SESSION_HANDLE session) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_CloseSession(session);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_CloseAllSessions (CK_SLOT_ID slotID) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_CloseAllSessions(slotID);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetSessionInfo (CK_SESSION_HANDLE session, CK_SESSION_INFO *info) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetSessionInfo(session, info );
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetOperationState (CK_SESSION_HANDLE session, CK_BYTE_PTR operation_state, CK_ULONG_PTR operation_state_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetOperationState(session, operation_state, operation_state_len );
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SetOperationState (CK_SESSION_HANDLE session, CK_BYTE_PTR operation_state, CK_ULONG operation_state_len, CK_OBJECT_HANDLE encryption_key, CK_OBJECT_HANDLE authentiation_key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SetOperationState(session, operation_state, operation_state_len , encryption_key ,authentiation_key );
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Login (CK_SESSION_HANDLE session, CK_USER_TYPE user_type, CK_BYTE_PTR pin, CK_ULONG pin_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_Login(session, user_type, pin , pin_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Logout (CK_SESSION_HANDLE session) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_Logout(session);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_CreateObject (CK_SESSION_HANDLE session, CK_ATTRIBUTE *templ, CK_ULONG count, CK_OBJECT_HANDLE *object) {
	
	MessageBoxA(NULL,"C_CreateObject","",MB_OK);

	PRINT_INFO(L"------ Start ------,count = %d",count);
	for (int i = 0; i<count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"------ End ------");
	CK_RV rv = p11->C_CreateObject(session,templ,count,object);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_CopyObject (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ATTRIBUTE *templ, CK_ULONG count, CK_OBJECT_HANDLE *new_object) {
	PRINT_INFO(L"------ Start ------,count = %d",count);
	for (int i = 0; i<count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"------ End ------");
	CK_RV rv = p11->C_CopyObject(session,object,templ,count,new_object);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DestroyObject (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DestroyObject(session,object);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetObjectSize (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ULONG_PTR size) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetObjectSize(session,object,size);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetAttributeValue (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR templ, CK_ULONG count) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetAttributeValue(session,object,templ,count);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SetAttributeValue (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE object, CK_ATTRIBUTE_PTR templ, CK_ULONG count) {

	PRINT_INFO(L"----- C_SetAttributeValue - Start ------,count = %d",count);
	for (int i = 0; i<count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"----- C_SetAttributeValue - End ------");

	CK_RV rv = p11->C_SetAttributeValue(session,object,templ,count);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_FindObjectsInit (CK_SESSION_HANDLE session, CK_ATTRIBUTE *templ, CK_ULONG count) {

	PRINT_INFO(L"------ Start ------,count = %d",count);
	for (int i = 0; i<count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"------ End ------");

	CK_RV rv = p11->C_FindObjectsInit(session,templ,count);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_FindObjects (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE *object, CK_ULONG max_object_count, CK_ULONG_PTR object_count) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_FindObjects(session,object,max_object_count,object_count);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_FindObjectsFinal (CK_SESSION_HANDLE session) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_FindObjectsFinal(session);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_EncryptInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_EncryptInit(session,mechanism,key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Encrypt (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR encrypted_data, CK_ULONG_PTR encrypted_data_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_Encrypt(session,data,data_len,encrypted_data,encrypted_data_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_EncryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR encrypted_part, CK_ULONG_PTR encrypted_part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_EncryptUpdate(session,part,part_len,encrypted_part,encrypted_part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_EncryptFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR last_encrypted_part, CK_ULONG_PTR last_encrypted_part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_EncryptFinal(session,last_encrypted_part,last_encrypted_part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DecryptInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DecryptInit(session,mechanism,key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Decrypt (CK_SESSION_HANDLE session, CK_BYTE_PTR encrypted_data, CK_ULONG encrypted_data_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_Decrypt(session,encrypted_data, encrypted_data_len, data, data_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DecryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR encrypted_part, CK_ULONG encrypted_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DecryptUpdate(session,encrypted_part, encrypted_part_len, part, part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DecryptFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR last_part, CK_ULONG_PTR last_part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DecryptFinal(session,last_part, last_part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DigestInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DigestInit(session, mechanism);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Digest (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR digest, CK_ULONG_PTR digest_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_Digest(session, data, data_len, digest, digest_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DigestUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DigestUpdate(session, part, part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DigestKey (CK_SESSION_HANDLE session, CK_OBJECT_HANDLE key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DigestKey(session, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DigestFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR digest, CK_ULONG_PTR digest_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DigestFinal(session, digest, digest_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SignInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE key) {

	PRINT_INFO(L"------ Start ------");
	std::wstring wstrDataType = L"";
	std::wstring wstrtemp = L"";
	CK_MECHANISM_TYPE nmechanism = mechanism->mechanism;
	switch(nmechanism)
	{
	case CKM_SHA1_RSA_PKCS:
		wstrDataType = L"CKM_SHA1_RSA_PKCS";
		break;
	case CKM_SHA256_RSA_PKCS:
		wstrDataType = L"CKM_SHA256_RSA_PKCS";
		break;
	case CKM_MD5_RSA_PKCS:
		wstrDataType = L"CKM_MD5_RSA_PKCS";
		break;
	default :
		PRINT_INFO(L"nmechanism type = 0x%.8X",nmechanism);
	}

	if (mechanism->ulParameterLen > 0)
	{
		wstrtemp = CUtility::b64encode_to_wstring((unsigned char*)mechanism->pParameter, mechanism->ulParameterLen);
		PRINT_INFO(L"mechanism type = %s, Value = %s",wstrDataType.c_str(),wstrtemp.c_str());
	} 
	else
	{
		PRINT_INFO(L"mechanism type = %s,",wstrDataType.c_str());
	}

	PRINT_INFO(L"------ End ------");
	CK_RV rv = p11->C_SignInit(session, mechanism, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Sign (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) {
	
	PRINT_INFO(L"------ Start ------");
	std::wstring wstrtemp = L"";
	wstrtemp = CUtility::b64encode_to_wstring((unsigned char*)data, data_len);
	PRINT_INFO(L"data = %s",wstrtemp.c_str());

	CK_RV rv = p11->C_Sign(session, data, data_len, signature, signature_len);

	wstrtemp = CUtility::b64encode_to_wstring((unsigned char*)signature, *signature_len);
	PRINT_INFO(L"signature = %s",wstrtemp.c_str());

	PRINT_INFO(L"------ End ------");
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SignUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SignUpdate(session, part, part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SignFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SignFinal(session, signature, signature_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SignRecoverInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SignRecoverInit(session, mechanism, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SignRecover (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG_PTR signature_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SignRecover(session, data, data_len,  signature,  signature_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_VerifyInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_VerifyInit(session, mechanism, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_Verify (CK_SESSION_HANDLE session, CK_BYTE_PTR data, CK_ULONG data_len, CK_BYTE_PTR signature, CK_ULONG signature_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_Verify(session, data, data_len, signature, signature_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_VerifyUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_VerifyUpdate(session, part, part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_VerifyFinal (CK_SESSION_HANDLE session, CK_BYTE_PTR signature, CK_ULONG signature_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_VerifyFinal(session, signature, signature_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_VerifyRecoverInit (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE key) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_VerifyRecoverInit(session, mechanism, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_VerifyRecover (CK_SESSION_HANDLE session, CK_BYTE_PTR signature, CK_ULONG signature_len, CK_BYTE_PTR data, CK_ULONG_PTR data_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_VerifyRecover(session, signature, signature_len, data, data_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DigestEncryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR encrypted_part, CK_ULONG_PTR encrypted_part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DigestEncryptUpdate(session,  part,  part_len,  encrypted_part,  encrypted_part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DecryptDigestUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR encrypted_part, CK_ULONG encrypted_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DecryptDigestUpdate(session, encrypted_part,  encrypted_part_len, part, part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SignEncryptUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR part, CK_ULONG part_len, CK_BYTE_PTR encrypted_part, CK_ULONG_PTR encrypted_part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SignEncryptUpdate(session,  part,  part_len,  encrypted_part,  encrypted_part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DecryptVerifyUpdate (CK_SESSION_HANDLE session, CK_BYTE_PTR encrypted_part, CK_ULONG encrypted_part_len, CK_BYTE_PTR part, CK_ULONG_PTR part_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_DecryptVerifyUpdate(session, encrypted_part,  encrypted_part_len, part, part_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GenerateKey (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_ATTRIBUTE *templ, CK_ULONG count, CK_OBJECT_HANDLE *key) {

	PRINT_INFO(L"------ Start ------,count = %d",count);
	for (int i = 0; i<count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"------ End ------");
	CK_RV rv = p11->C_GenerateKey(session, mechanism, templ, count, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GenerateKeyPair (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_ATTRIBUTE *public_key_template, CK_ULONG public_key_attribute_count, CK_ATTRIBUTE *private_key_template, CK_ULONG private_key_attribute_count, CK_OBJECT_HANDLE *public_key, CK_OBJECT_HANDLE *private_key) {
	
	PRINT_INFO(L"------ Start ------");

	PRINT_INFO(L"------ public_key_template ------,count = %d",public_key_attribute_count);
	for (int i = 0; i<public_key_attribute_count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&public_key_template[i]);
	}
	PRINT_INFO(L"------ public_key_template ---end---");

	PRINT_INFO(L"------ private_key_template ------,count = %d",private_key_attribute_count);
	for (int i = 0; i<private_key_attribute_count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&private_key_template[i]);
	}
	PRINT_INFO(L"------ private_key_template ---end---");

	PRINT_INFO(L"------ End ------");

	CK_RV rv = p11->C_GenerateKeyPair(session, mechanism, public_key_template, public_key_attribute_count, private_key_template, private_key_attribute_count,public_key, private_key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_WrapKey (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE wrapping_key, CK_OBJECT_HANDLE key, CK_BYTE_PTR wrapped_key, CK_ULONG_PTR wrapped_key_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_WrapKey(session, mechanism, wrapping_key, key, wrapped_key, wrapped_key_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_UnwrapKey (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE unwrapping_key, CK_BYTE_PTR wrapped_key, CK_ULONG wrapped_key_len, CK_ATTRIBUTE *templ, CK_ULONG attribute_count, CK_OBJECT_HANDLE *key) {
	PRINT_INFO(L"------ Start ------,count = %d",attribute_count);
	for (int i = 0; i<attribute_count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"------ End ------");
	CK_RV rv = p11->C_UnwrapKey(session, mechanism, unwrapping_key, wrapped_key, wrapped_key_len, templ, attribute_count, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_DeriveKey (CK_SESSION_HANDLE session, CK_MECHANISM *mechanism, CK_OBJECT_HANDLE base_key, CK_ATTRIBUTE *templ, CK_ULONG attribute_count, CK_OBJECT_HANDLE *key) {
	PRINT_INFO(L"------ Start ------,count = %d",attribute_count);
	for (int i = 0; i<attribute_count; i++)
	{
		PRINT_INFO(L"parameter %d",i+1);

		PRINT_CK_ATTRIBUTE(&templ[i]);
	}
	PRINT_INFO(L"------ End ------");
	CK_RV rv = p11->C_DeriveKey(session, mechanism, base_key, templ, attribute_count, key);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_SeedRandom (CK_SESSION_HANDLE session, CK_BYTE_PTR seed, CK_ULONG seed_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_SeedRandom(session, seed, seed_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GenerateRandom (CK_SESSION_HANDLE session, CK_BYTE_PTR random_data, CK_ULONG random_len) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GenerateRandom(session, random_data, random_len);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_GetFunctionStatus (CK_SESSION_HANDLE session) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_GetFunctionStatus(session);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}

__declspec(dllexport) CK_RV C_CancelFunction (CK_SESSION_HANDLE session) {
	PRINT_INFO(L"-----***------");
	CK_RV rv = p11->C_CancelFunction(session);
	if (rv != CKR_OK)
	{
		PRINT_INFO(L"Error = 0x%.8X", (unsigned int)rv);
	}
	return rv;
}
蒙牛hia
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PKCS#11数据加密国际标准解读-对象
安当加密
12-13 691
PKCS#11标准解读-对象，此为第三篇，介绍对象和属性。 PKCS#11是使用非常普遍的密码设备接口，在实际应用中，国密的密码设备应用接口规范GMT0018与之作用相同，在技术体系架构中处于类似的位置。 在密码产品的开发中，按照PKCS#11或者GMT0018接口规范提供相应的接口封装，应用程序无需改动或者微小改动就可以更换底层密码设备。 PKCS#11的标准内容比较多，v2-20版本有400页，相应的，PKCS#11的标准解读，将按照概念及常用接口、角色、会话、对象、机制分别进行，最后介绍应用的调
Pkcs11Interop:非托管PKCS＃11库的托管.NET包装器
05-24
Pkcs11Interop是用C＃编写的托管库，它将PKCS＃11 API的全部功能带到.NET环境。 它加载加密设备供应商提供的非托管PKCS＃11库，并使.NET应用程序可以访问其功能。 下图显示了.NET应用程序中Pkcs11Interop库的典型...
PKCS11标准（中文版）
03-03
这是PKCS #11 v2.11密码令牌接口标准，详细描述了PKCS11的各种技术概念和开发标准，主要提供给开发人员，用于系统的设计、开发。
pkcs#11测试源码
08-28
pkcs#11测试demo对pkcs#11普遍功能进行测试
探索Graphene——强大的PKCS11接口库
最新发布
gitblog_00054的博客
06-10 426
探索Graphene——强大的PKCS#11接口库 项目地址:https://gitcode.com/PeculiarVentures/graphene 项目介绍 Graphene是一款精心设计的Node.js库，专为与PKCS#11（也称为CryptoKI或PKCS11）硬件加密设备交互提供便利。无论是智能卡还是硬件安全模块(HSM)，它都能以简洁而高效的方式管理这些设备。通过它的API，开发者...
pkcs#11标准中文文档
01-29
关于pkcs#11标准库接口的中文文档，很详细，对于初学者要使用pkcs#11标准接口来说，非常有用。
PKCS#11
qmkemail
11-16 506
原文 http://www.iteye.com/problems/6228   配置环境：JDK5.0，支持标准PKCS#11的设备（包括Smartcard，加密卡等等），支持PKCS#11的系统（WINDOWS/LINUX /UNIX等），以及设备供应商提供的标准PKCS#11接口。（注：PKCS#11接口只是一个动态库文件，其中封装了PKCS#11标准函数，在不同 的平台上其格式不同，...
libp11:PKCS#11 包装库
08-05
libp11 提供了一个更高级别（与 PKCS#11 库相比）的接口来访问 PKCS#11 对象。 它旨在与使用 OpenSSL 的应用程序集成。 OpenSSL 库的 pkcs11 引擎插件允许以半透明的方式访问 PKCS#11 模块。 该项目的 wiki 页面...
pkcs11商密demo
02-20
PKCS#11，全称为Public-Key Cryptography ...总之，"pkcs11商密demo"是理解并应用PKCS#11接口的一个重要学习资源，它揭示了如何利用硬件安全设备保护商业秘密，提供了一种安全且高效的数据加密和身份验证方案。
tpm2-pkcs11:TPM2硬件的PKCS＃11接口
04-06
tpm2-pkcs11 PKCS＃11是一种公共密钥加密标准，它定义了一种从令牌/设备（例如硬件安全模块（HSM），智能卡等）访问加密服务的标准方法。在此项目中，我们打算使用TPM2设备作为加密方法令牌。入门-如何建造-如何配置...
PKCS11导入证书.rar_pkcs11_PKCS11示例_源码
10-04
PKCS11，全称Public Key Cryptography Standards #11，是RSA安全公司制定的一套标准，用于定义加密硬件（如智能卡、硬件安全模块HSM）与软件应用程序之间的接口。这个标准允许软件应用程序透明地使用加密硬件进行...
PKCS11读取UKEY例子
08-26
PKCS11读取UKEY例子，学习PKCS11最好的代码
pkcs11头文件
05-25
2.1版本pkcs11头文件，包括需要在win32下定义的一些宏，win32平台下亲测可用
PKCS11_INC
11-28
编译TrueCrypt 7.1.0 Source 所需的三个PKCS头文件
PKCS11 标准 开发接口文档
01-24
PKCS11接口标准的官方文档，包含了其接口的定义以及使用方法等
JDK5.0环境下配置PKCS#11
春暖花开
06-10 762
针对PKCS#11的初学者介绍如何在JDK5.0环境中配置PKCS#11,具体的编程方法可以关注我的下一篇文章，或者参考PKCS#11手册以及SUN MicroSystem公司关于PKCS#11的手册。 需要的环境：         JDK5.0版本已经可以支持对PKCS#11的操作，这里就介绍一下如何实现在JDK5.0环境下配置PKCS#11，并且根据不同的操作系统提供相应的解决方案。     
PKCS#11的应用--USBKEY
weixin_33895657的博客
07-19 183
ssl是一个安全协议，为互联网应用提供了安全，数字证书被证明能够带来比单纯的密码或者指纹，瞳孔认证之类的方式更安全的保护，可是如此安全的机制需要一个安全的基层平台，事实证明计算机并不是一个足够安全的平台，计算机好比公共汽车，而操作系统以及C库的调用规范或者安全级别的设计被视为道德，众做周知道德不是强制的，它只在遵守它的实体中间起作用，比如堆栈的使用提供了强有力的安全机制和性能...
开源opensc的子工程pkcs11-engine在windows平台下编译 .
求索
01-09 4246
根据网上一位前辈写的： 开源opensc工程windows平台下编译，自己结合实际项目中的操作记录下来。至于接口的编写下一篇文章会来介绍。 在Google上搜了一下opensc的简介，没有，算了还是自己说吧。 opensc官方网站http://www.opensc-project.org/ 工程简介：对于智能卡的访问，opensc工程提供了一套库和工具。opensc重点放在了卡片的密码
PKCS#11标准解读-Cryptoki库如何工作（4）
好习惯成就伟大
04-25 1045
此为完结篇，介绍Cryptoki库如何工作。 PKCS#11是使用非常普遍的密码设备接口，在实际应用中，国密的密码设备应用接口规范GMT0018与之作用相同，在技术体系架构中处于类似的位置。 在密码产品的开发中，按照PKCS#11或者GMT0018接口规范提供相应的接口封装，应用程序无需改动或者微小改动就可以更换底层密码设备。 PKCS#11的标准内容比较多，v2-20版本有400页，相应的，PKCS#11的标准解读，将按照概念及常用接口、角色、会话、对象、机制分别进行，最后介绍应用的调用流程，串起各
加载pkcs11库失败怎么解决
08-02
1. 确保PKCS11库文件存在：检查PKCS11库文件是否存在于指定的路径中，并确保文件名和路径正确。可以尝试重新下载最新版本的PKCS11库文件并替换旧文件。 2. 修改操作系统环境变量：有些PKCS11库需要将其路径添加到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值