cryptool.cpp

PKCS#11的微软CSP实现源码

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <errno.h>
#include <string.h>
#include<windows.h>
#include <wincrypt.h>
#include <time.h>
#include "cryptool.h"



#define CK_API      __stdcall
typedef void *      SYS_HANDLE;
typedef int ( CK_API *CK_PFUNCTION)();
SYS_HANDLE dllPtr;
int traceLevel=0;
bool initializeDone=false;




CK_RV init(CK_FUNCTION_LIST_PTR CK_PTR pFunctionList){
   CK_RV rc;             // Return Code
   CK_C_GetFunctionList    pFuncList;

   /* Open the PKCS11 API shared library*/
   int l = 50;
   char buf[50 + 1];
   int rl;
   rl = GetPrivateProfileString( SECTION_PKCS_NAME, KEY_PKCS_NAME ,"",(char *) buf, 51,CSP_PKCS11_INI);
   if(rl==0)
	   return CKR_CANCEL;

   dllPtr = LoadLibrary(buf);
   if (!dllPtr) {
	   return CKR_CANCEL;
   }
   

   // Get the list of the PKCS11 functions this token supports 
   pFuncList = (CK_C_GetFunctionList)GetProcAddress((HINSTANCE)dllPtr,(LPCSTR)"C_GetFunctionList");
   if (!pFuncList) {
      rc = errno;
      return rc;
   }

   //pFuncList(&FunctionPtr);
   (*pFuncList)(pFunctionList);
   rc=initialize(*pFunctionList,NULL_PTR);
   if (rc != CKR_OK) {
      cleanup(*pFunctionList);
	  return CKR_CANCEL;
   }
   initializeDone=true;
   

   return CKR_OK;

}

/*
%--------------------------------------------------------------------------
% cleanup
%
% R鬺e : cleanup est utilis閑 pour lib閞er la dll PKCS
%		 
%
% Param鑤res d'entr閑 :
%						IN 
%  
% Valeur retourn閑 :	TRUE si l'op閞ation s'est bien pass閑
%						FALSE sinon 
%---------------------------------------------------------------------------
*/

CK_RV cleanup(CK_FUNCTION_LIST_PTR pFunctionList){
   CK_RV rc=CKR_OK;  // Return Code

   /* To clean up we will free the slot list we create, call the Finalize
    * routine for PKCS11 and close the dynamically linked library */
   if(initializeDone){
       initializeDone=false;
       rc = pFunctionList->C_Finalize(NULL);
       if(rc!=CKR_OK)
	     return rc;
   }

   return CKR_OK;
}

/*
%--------------------------------------------------------------------------
% initialize
%
% R鬺e : initialize est utilis閑 pour initialiser la dll PKCS
%		 
%
% Param鑤res d'entr閑 :
%						IN 
%  
% Valeur retourn閑 :	TRUE si l'op閞ation s'est bien pass閑
%						FALSE sinon 
%---------------------------------------------------------------------------
*/


CK_RV initialize(CK_FUNCTION_LIST_PTR pFunctionList, char * pReserved) {
	CK_RV rv=CKR_OK;
	CK_C_INITIALIZE_ARGS initArgs;

	if (pReserved!=NULL_PTR) {
		initArgs.CreateMutex=NULL_PTR;
		initArgs.DestroyMutex=NULL_PTR;
		initArgs.LockMutex=NULL_PTR;
		initArgs.UnlockMutex=NULL_PTR;
		initArgs.flags=0;
		initArgs.pReserved=pReserved;
	}
	
	rv = (*pFunctionList->C_Initialize)(pReserved==NULL_PTR?NULL_PTR:&initArgs);

	return rv;
}





CK_BBOOL isPrivKeySupportSign(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPrivKey)
{
	CK_RV rv=CKR_OK;
	CK_BBOOL bbool;

   
	
	CK_ATTRIBUTE templateAttr [] = 
	{
		{CKA_SIGN,&bbool,sizeof(CK_BBOOL)}
	};

	rv = (*pFunctionList->C_GetAttributeValue)(hSession,hPrivKey,templateAttr,1);
  
	return bbool;
}

CK_RV getKeyFromX509Cert(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phKey, 
						  CK_OBJECT_HANDLE hCert,
						  CK_OBJECT_CLASS keyClass, int occurence)
{
	CK_RV rv=CKR_OK;
	CK_ULONG keyIdLen=256; 
	CK_ULONG subjectLen=256;
	CK_ULONG keyListLen=10;
	CK_OBJECT_HANDLE_PTR phKeyList = (CK_OBJECT_HANDLE_PTR)malloc(keyListLen*sizeof(CK_OBJECT_HANDLE));
	CK_BYTE_PTR subject = NULL;
	CK_ULONG nbAttribut=0;
	CK_BYTE_PTR keyId = NULL;
    CK_ATTRIBUTE KeyTemplate[] = {
		{CKA_CLASS,&keyClass,sizeof(keyClass)},
		{CKA_ID,keyId,keyIdLen},
		{CKA_SUBJECT,subject,subjectLen}
	};
	
    if ( phKeyList == NULL)
    {
        return CKR_HOST_MEMORY;
    }

	rv = getX509KeyId(pFunctionList, hSession, hCert, NULL_PTR, &keyIdLen);
	if (rv!=CKR_OK) {
		free(phKeyList);
		return rv;
	}
	keyId = (CK_BYTE_PTR) malloc(keyIdLen*sizeof(CK_BYTE));
    if ( keyId == NULL)
    {
		free(phKeyList);
        return CKR_HOST_MEMORY;
    }
	rv = getX509KeyId(pFunctionList, hSession, hCert, keyId, &keyIdLen);
	if (rv!=CKR_OK) {
		free(phKeyList);
   		free(keyId);
		return rv;
	}
    
	nbAttribut=2;
	if (keyClass==CKO_PRIVATE_KEY) {
		rv = getX509Subject(pFunctionList, hSession, hCert, NULL_PTR, &subjectLen);
		if (rv!=CKR_OK) {

		}
		else
		{
			subject = (CK_BYTE_PTR) malloc(subjectLen*sizeof(CK_BYTE));
			if ( subject == NULL)
			{
	
			}
			else
			{
				rv = getX509Subject(pFunctionList, hSession, hCert, subject, &subjectLen);
		/* DREN le 10/12/2002: Au cas ou le subject n'existerait pas ou
		serait faux ( ne commencant pas par 0x30 ASN1) ce n'est pas une erreur!
				if (rv!=CKR_OK) */
				if (rv!=CKR_OK || subject [0] != '\0x30')
				{
/*
					free(phKeyList);
   					free(keyId);
					free(subject);
					return rv; */
		/* DREN le 10/12/2002: Fin */
				}

				else
				{
					
					nbAttribut=3;
					KeyTemplate[2].type = CKA_SUBJECT;
					KeyTemplate[2].pValue = subject;
					KeyTemplate[2].ulValueLen = subjectLen;
				}
			}
		}
	}

    KeyTemplate[0].type = CKA_CLASS;
    KeyTemplate[0].pValue = &keyClass;
    KeyTemplate[0].ulValueLen = sizeof(keyClass);
    KeyTemplate[1].type = CKA_ID;
    KeyTemplate[1].pValue = keyId;
    KeyTemplate[1].ulValueLen = keyIdLen;

    rv = (*pFunctionList->C_FindObjectsInit)(hSession,KeyTemplate,nbAttribut);

	if (rv == CKR_OK)
	{
		CK_ULONG ulObjectCount=keyListLen;

		int index = 0;
		while (1) 
		{
           
			rv = (*pFunctionList->C_FindObjects)(hSession,phKeyList,keyListLen, &ulObjectCount);
            if ( (rv != CKR_OK) || (ulObjectCount == 0) ) break;
			if (index == occurence) {
				*phKey=phKeyList[index];
				/*CK_ULONG keySubjectLen=256;
				CK_BYTE_PTR keySubject = (CK_BYTE_PTR) malloc(keySubjectLen);
				memset(keySubject, 0, keySubjectLen);
				rv = getKeySubject(hSession, *phKey, keySubject, &keySubjectLen);
				free(keySubject);*/
				break;
			}
			index ++;
		}
		rv = (*pFunctionList->C_FindObjectsFinal)(hSession);
		if (ulObjectCount == 0)
			rv=-1;
	} else {
		
	}

	free(phKeyList);
    if ( keyId != NULL)
    	free(keyId);
    if ( subject != NULL)
	    free(subject);
	return rv;
}


CK_RV getX509KeyId(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
				 CK_BYTE_PTR keyId, CK_ULONG_PTR plenKeyId
				  )
{
	CK_RV rv=CKR_OK;

    
	CK_ATTRIBUTE templateAttr[] = 
	{
		{CKA_ID,keyId,*plenKeyId}
	};

	rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
	*plenKeyId=templateAttr[0].ulValueLen;
	return rv;
}


CK_RV getX509Subject(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
				   CK_BYTE_PTR subject, CK_ULONG_PTR pSubjectLen
				  )
{
	CK_RV rv=CKR_OK;
	
    

	CK_ATTRIBUTE templateAttr [] = 
	{
		{CKA_SUBJECT,subject,*pSubjectLen}
	};

	rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
	*pSubjectLen=templateAttr[0].ulValueLen;
	
	return rv;
}

CK_RV getX509Label(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
				   CK_BYTE_PTR label, CK_ULONG_PTR plabelLen
				  )
{
	CK_RV rv=CKR_OK;

	CK_ATTRIBUTE templateAttr [] = 
	{
		{CKA_LABEL,label,*plabelLen}
	};

	rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
	*plabelLen=templateAttr[0].ulValueLen;
	
	return rv;
}


CK_RV getX509Issuer(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
				   CK_BYTE_PTR issuer, CK_ULONG_PTR pIssuerLen)
{
	CK_RV rv=CKR_OK;
	
    

	CK_ATTRIBUTE templateAttr [] = 
	{
		{CKA_ISSUER,issuer,*pIssuerLen}