开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
cryptool.cpp
资源名称：pkcs11.rar　[点击查看]
上传用户：filter2008
上传日期：2013-02-01
资源大小：101k
文件大小：21k
源码类别：

CA认证

开发平台：

C/C++

cryptool.cpp：源码内容
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <memory.h>
  5. #include <errno.h>
  6. #include <string.h>
  7. #include<windows.h>
  8. #include <wincrypt.h>
  9. #include <time.h>
  10. #include "cryptool.h"
  14. #define CK_API      __stdcall
  15. typedef void *      SYS_HANDLE;
  16. typedef int ( CK_API *CK_PFUNCTION)();
  17. SYS_HANDLE dllPtr;
  18. int traceLevel=0;
  19. bool initializeDone=false;
  24. CK_RV init(CK_FUNCTION_LIST_PTR CK_PTR pFunctionList){
  25.    CK_RV rc;             // Return Code
  26.    CK_C_GetFunctionList    pFuncList;
  28.    /* Open the PKCS11 API shared library*/
  29.    int l = 50;
  30.    char buf[50 + 1];
  31.    int rl;
  32.    rl = GetPrivateProfileString( SECTION_PKCS_NAME, KEY_PKCS_NAME ,"",(char *) buf, 51,CSP_PKCS11_INI);
  33.    if(rl==0)
  34.    return CKR_CANCEL;
  36.    dllPtr = LoadLibrary(buf);
  37.    if (!dllPtr) {
  38.    return CKR_CANCEL;
  39.    }
  40.    
  42.    // Get the list of the PKCS11 functions this token supports 
  43.    pFuncList = (CK_C_GetFunctionList)GetProcAddress((HINSTANCE)dllPtr,(LPCSTR)"C_GetFunctionList");
  44.    if (!pFuncList) {
  45.       rc = errno;
  46.       return rc;
  47.    }
  49.    //pFuncList(&FunctionPtr);
  50.    (*pFuncList)(pFunctionList);
  51.    rc=initialize(*pFunctionList,NULL_PTR);
  52.    if (rc != CKR_OK) {
  53.       cleanup(*pFunctionList);
  54.   return CKR_CANCEL;
  55.    }
  56.    initializeDone=true;
  57.    
  59.    return CKR_OK;
  61. }
  63. /*
  64. %--------------------------------------------------------------------------
  65. % cleanup
  66. %
  67. % R鬺e : cleanup est utilis閑 pour lib閞er la dll PKCS
  68. %  
  69. %
  70. % Param鑤res d'entr閑 :
  71. % IN 
  72. %  
  73. % Valeur retourn閑 : TRUE si l'op閞ation s'est bien pass閑
  74. % FALSE sinon 
  75. %---------------------------------------------------------------------------
  76. */
  78. CK_RV cleanup(CK_FUNCTION_LIST_PTR pFunctionList){
  79.    CK_RV rc=CKR_OK;  // Return Code
  81.    /* To clean up we will free the slot list we create, call the Finalize
  82.     * routine for PKCS11 and close the dynamically linked library */
  83.    if(initializeDone){
  84.        initializeDone=false;
  85.        rc = pFunctionList->C_Finalize(NULL);
  86.        if(rc!=CKR_OK)
  87.      return rc;
  88.    }
  90.    return CKR_OK;
  91. }
  93. /*
  94. %--------------------------------------------------------------------------
  95. % initialize
  96. %
  97. % R鬺e : initialize est utilis閑 pour initialiser la dll PKCS
  98. %  
  99. %
  100. % Param鑤res d'entr閑 :
  101. % IN 
  102. %  
  103. % Valeur retourn閑 : TRUE si l'op閞ation s'est bien pass閑
  104. % FALSE sinon 
  105. %---------------------------------------------------------------------------
  106. */
  109. CK_RV initialize(CK_FUNCTION_LIST_PTR pFunctionList, char * pReserved) {
  110. CK_RV rv=CKR_OK;
  111. CK_C_INITIALIZE_ARGS initArgs;
  113. if (pReserved!=NULL_PTR) {
  114. initArgs.CreateMutex=NULL_PTR;
  115. initArgs.DestroyMutex=NULL_PTR;
  116. initArgs.LockMutex=NULL_PTR;
  117. initArgs.UnlockMutex=NULL_PTR;
  118. initArgs.flags=0;
  119. initArgs.pReserved=pReserved;
  120. }
  122. rv = (*pFunctionList->C_Initialize)(pReserved==NULL_PTR?NULL_PTR:&initArgs);
  124. return rv;
  125. }
  131. CK_BBOOL isPrivKeySupportSign(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPrivKey)
  132. {
  133. CK_RV rv=CKR_OK;
  134. CK_BBOOL bbool;
  136.    
  138. CK_ATTRIBUTE templateAttr [] = 
  139. {
  140. {CKA_SIGN,&bbool,sizeof(CK_BBOOL)}
  141. };
  143. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hPrivKey,templateAttr,1);
  144.   
  145. return bbool;
  146. }
  148. CK_RV getKeyFromX509Cert(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phKey, 
  149.   CK_OBJECT_HANDLE hCert,
  150.   CK_OBJECT_CLASS keyClass, int occurence)
  151. {
  152. CK_RV rv=CKR_OK;
  153. CK_ULONG keyIdLen=256; 
  154. CK_ULONG subjectLen=256;
  155. CK_ULONG keyListLen=10;
  156. CK_OBJECT_HANDLE_PTR phKeyList = (CK_OBJECT_HANDLE_PTR)malloc(keyListLen*sizeof(CK_OBJECT_HANDLE));
  157. CK_BYTE_PTR subject = NULL;
  158. CK_ULONG nbAttribut=0;
  159. CK_BYTE_PTR keyId = NULL;
  160.     CK_ATTRIBUTE KeyTemplate[] = {
  161. {CKA_CLASS,&keyClass,sizeof(keyClass)},
  162. {CKA_ID,keyId,keyIdLen},
  163. {CKA_SUBJECT,subject,subjectLen}
  164. };
  166.     if ( phKeyList == NULL)
  167.     {
  168.         return CKR_HOST_MEMORY;
  169.     }
  171. rv = getX509KeyId(pFunctionList, hSession, hCert, NULL_PTR, &keyIdLen);
  172. if (rv!=CKR_OK) {
  173. free(phKeyList);
  174. return rv;
  175. }
  176. keyId = (CK_BYTE_PTR) malloc(keyIdLen*sizeof(CK_BYTE));
  177.     if ( keyId == NULL)
  178.     {
  179. free(phKeyList);
  180.         return CKR_HOST_MEMORY;
  181.     }
  182. rv = getX509KeyId(pFunctionList, hSession, hCert, keyId, &keyIdLen);
  183. if (rv!=CKR_OK) {
  184. free(phKeyList);
  185.     free(keyId);
  186. return rv;
  187. }
  188.     
  189. nbAttribut=2;
  190. if (keyClass==CKO_PRIVATE_KEY) {
  191. rv = getX509Subject(pFunctionList, hSession, hCert, NULL_PTR, &subjectLen);
  192. if (rv!=CKR_OK) {
  194. }
  195. else
  196. {
  197. subject = (CK_BYTE_PTR) malloc(subjectLen*sizeof(CK_BYTE));
  198. if ( subject == NULL)
  199. {
  201. }
  202. else
  203. {
  204. rv = getX509Subject(pFunctionList, hSession, hCert, subject, &subjectLen);
  205. /* DREN le 10/12/2002: Au cas ou le subject n'existerait pas ou
  206. serait faux ( ne commencant pas par 0x30 ASN1) ce n'est pas une erreur!
  207. if (rv!=CKR_OK) */
  208. if (rv!=CKR_OK || subject [0] != 'x30')
  209. {
  210. /*
  211. free(phKeyList);
  212.     free(keyId);
  213. free(subject);
  214. return rv; */
  215. /* DREN le 10/12/2002: Fin */
  216. }
  218. else
  219. {
  221. nbAttribut=3;
  222. KeyTemplate[2].type = CKA_SUBJECT;
  223. KeyTemplate[2].pValue = subject;
  224. KeyTemplate[2].ulValueLen = subjectLen;
  225. }
  226. }
  227. }
  228. }
  230.     KeyTemplate[0].type = CKA_CLASS;
  231.     KeyTemplate[0].pValue = &keyClass;
  232.     KeyTemplate[0].ulValueLen = sizeof(keyClass);
  233.     KeyTemplate[1].type = CKA_ID;
  234.     KeyTemplate[1].pValue = keyId;
  235.     KeyTemplate[1].ulValueLen = keyIdLen;
  237.     rv = (*pFunctionList->C_FindObjectsInit)(hSession,KeyTemplate,nbAttribut);
  239. if (rv == CKR_OK)
  240. {
  241. CK_ULONG ulObjectCount=keyListLen;
  243. int index = 0;
  244. while (1) 
  245. {
  246.            
  247. rv = (*pFunctionList->C_FindObjects)(hSession,phKeyList,keyListLen, &ulObjectCount);
  248.             if ( (rv != CKR_OK) || (ulObjectCount == 0) ) break;
  249. if (index == occurence) {
  250. *phKey=phKeyList[index];
  251. /*CK_ULONG keySubjectLen=256;
  252. CK_BYTE_PTR keySubject = (CK_BYTE_PTR) malloc(keySubjectLen);
  253. memset(keySubject, 0, keySubjectLen);
  254. rv = getKeySubject(hSession, *phKey, keySubject, &keySubjectLen);
  255. free(keySubject);*/
  256. break;
  257. }
  258. index ++;
  259. }
  260. rv = (*pFunctionList->C_FindObjectsFinal)(hSession);
  261. if (ulObjectCount == 0)
  262. rv=-1;
  263. } else {
  265. }
  267. free(phKeyList);
  268.     if ( keyId != NULL)
  269.      free(keyId);
  270.     if ( subject != NULL)
  271.     free(subject);
  272. return rv;
  273. }
  276. CK_RV getX509KeyId(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
  277.  CK_BYTE_PTR keyId, CK_ULONG_PTR plenKeyId
  278.   )
  279. {
  280. CK_RV rv=CKR_OK;
  282.     
  283. CK_ATTRIBUTE templateAttr[] = 
  284. {
  285. {CKA_ID,keyId,*plenKeyId}
  286. };
  288. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
  289. *plenKeyId=templateAttr[0].ulValueLen;
  290. return rv;
  291. }
  294. CK_RV getX509Subject(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
  295.    CK_BYTE_PTR subject, CK_ULONG_PTR pSubjectLen
  296.   )
  297. {
  298. CK_RV rv=CKR_OK;
  300.     
  302. CK_ATTRIBUTE templateAttr [] = 
  303. {
  304. {CKA_SUBJECT,subject,*pSubjectLen}
  305. };
  307. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
  308. *pSubjectLen=templateAttr[0].ulValueLen;
  310. return rv;
  311. }
  313. CK_RV getX509Label(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
  314.    CK_BYTE_PTR label, CK_ULONG_PTR plabelLen
  315.   )
  316. {
  317. CK_RV rv=CKR_OK;
  319. CK_ATTRIBUTE templateAttr [] = 
  320. {
  321. {CKA_LABEL,label,*plabelLen}
  322. };
  324. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
  325. *plabelLen=templateAttr[0].ulValueLen;
  327. return rv;
  328. }
  331. CK_RV getX509Issuer(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
  332.    CK_BYTE_PTR issuer, CK_ULONG_PTR pIssuerLen)
  333. {
  334. CK_RV rv=CKR_OK;
  336.     
  338. CK_ATTRIBUTE templateAttr [] = 
  339. {
  340. {CKA_ISSUER,issuer,*pIssuerLen}
  341. };
  343. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
  344. *pIssuerLen=templateAttr[0].ulValueLen;
  346. return rv;
  347. }
  350. CK_RV login(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_CHAR_PTR pinCode, CK_ULONG len)
  351. {
  352. CK_RV rv=CKR_OK;
  354. //trying to log using pin number
  355. rv = (*pFunctionList->C_Login)(hSession,CKU_USER,pinCode,len);
  356.    
  357. if (rv == CKR_OK)
  358. {
  359.         
  360. return rv;
  361. }
  363. return rv;
  364. }
  366. CK_RV logout(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession)
  367. {
  368. CK_RV rv=CKR_OK;
  370.     
  371. rv = (*pFunctionList->C_Logout)(hSession);
  372. return rv;
  373. }
  377. CK_RV getAllX509CertificateList(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phCertList, CK_ULONG_PTR pCertListSize)
  378. /* DREN le 11/07/2002 : Fin */
  379. {
  380. CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  381. CK_CERTIFICATE_TYPE certType = CKC_X_509;
  383. CK_ATTRIBUTE certTemplate[] = {
  384. {CKA_CLASS,&certClass,sizeof(certClass)},
  385. {CKA_CERTIFICATE_TYPE,&certType,sizeof(certType)}
  386. };
  389. return getCertListFromAttr(pFunctionList, hSession, certTemplate, sizeof(certTemplate)/sizeof(CK_ATTRIBUTE), phCertList, pCertListSize);
  390. }
  394. CK_RV getCertListFromAttr(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pCertTemplate, CK_ULONG certTemplateSize, CK_OBJECT_HANDLE_PTR phCertList, CK_ULONG_PTR pCertListSize)
  395. {
  396. CK_RV rv=CKR_OK;
  398. rv = (*pFunctionList->C_FindObjectsInit)(hSession,pCertTemplate,certTemplateSize);
  399. if (rv == CKR_OK)
  400. {
  401. rv = (*pFunctionList->C_FindObjects)(hSession,phCertList,*pCertListSize, pCertListSize);
  402.         
  403. if ( (rv != CKR_OK) || (*pCertListSize == 0) )
  405. if (*pCertListSize == 0)
  406. rv=-1;
  407. rv = (*pFunctionList->C_FindObjectsFinal)(hSession);
  409. }
  411. return rv;
  412. }
  416. CK_RV getPrivateKeyFromX509Cert(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phKey, CK_OBJECT_HANDLE hCert)
  417. {
  418. return getKeyFromX509Cert(pFunctionList, hSession,phKey, hCert, CKO_PRIVATE_KEY,0);
  419. }
  421. CK_RV getPublicKeyFromX509Cert(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phKey, CK_OBJECT_HANDLE hCert)
  422. {
  423. return getKeyFromX509Cert(pFunctionList, hSession,phKey, hCert, CKO_PUBLIC_KEY,0);
  424. }
  427. CK_RV getKeyType(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey,
  428.  CK_KEY_TYPE * keyType)
  429. {
  430. CK_RV rv=CKR_OK;
  432. CK_ATTRIBUTE templateAttr [] = 
  433. {
  434. {CKA_KEY_TYPE,keyType,sizeof(CK_KEY_TYPE)}
  435. };
  437. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hKey,templateAttr,1);
  439. return rv;
  440. }
  443. CK_RV getSlotListWithToken(CK_FUNCTION_LIST_PTR pFunctionList, CK_SLOT_ID_PTR tokenInSlotList, CK_ULONG_PTR pTokenInSlotListSize)
  445. {
  446. CK_RV rv=CKR_OK;
  447. CK_ULONG ulCount;
  448. CK_SLOT_ID_PTR pSlotList;
  449. CK_SLOT_INFO slotInfo;
  450. int i = 0;
  453. rv = (*pFunctionList->C_GetSlotList)(FALSE,NULL_PTR,&ulCount);
  454. if ( (rv== CKR_OK) && (ulCount>0))
  455. {
  456. //Get slot list
  457. pSlotList = (CK_SLOT_ID_PTR) malloc(ulCount*sizeof(CK_SLOT_ID));
  458. rv = (*pFunctionList->C_GetSlotList)(FALSE,pSlotList,&ulCount);
  460. if (rv == CKR_OK)
  461. {
  462. for (unsigned int j=0; j<min(ulCount,*pTokenInSlotListSize); j++) {
  463. //Get slot information for slotId
  464. rv = (*pFunctionList->C_GetSlotInfo)(pSlotList[j], &slotInfo);
  465. if ((rv == CKR_OK)&&((slotInfo.flags & CKF_TOKEN_PRESENT) != 0)) {
  466. tokenInSlotList[i] = pSlotList[j];
  467. i++;
  468. }
  469. }
  470. }
  471. free(pSlotList);
  472. }
  473. *pTokenInSlotListSize=i;
  474. return rv;
  475. }
  478. CK_RV openSession(CK_FUNCTION_LIST_PTR pFunctionList, CK_SLOT_ID slotId, CK_SESSION_HANDLE_PTR phSession)
  479. {
  480. CK_RV rv=CKR_OK;
  482. //open session with token
  483. rv = (*pFunctionList->C_OpenSession)(slotId,CKF_SERIAL_SESSION,NULL_PTR,NULL_PTR,phSession);
  485. return rv;
  486. }
  487. CK_RV closeSession(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession)
  488. {
  489. CK_RV rv=CKR_OK;
  491.     
  492. rv = (*pFunctionList->C_CloseSession)(hSession);
  493. return rv;
  494. }
  497. CK_RV getX509Value(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,
  498.  CK_BYTE_PTR value, CK_ULONG_PTR plenValue
  499.   )
  500. {
  501. CK_RV rv=CKR_OK;
  503.     if ( getTraceLevel() > 1)
  504.      TRACE_local(__LINE__,"getX509Value():");
  506. CK_ATTRIBUTE templateAttr [] = 
  507. {
  508. {CKA_VALUE,value,*plenValue}
  509. };
  511. rv = (*pFunctionList->C_GetAttributeValue)(hSession,hCert,templateAttr,1);
  512. *plenValue=templateAttr[0].ulValueLen;
  513.     if ( getTraceLevel() > 1)
  514.      TRACE_local(__LINE__,"C_GetAttributeValue()=0x%x",rv);
  515. return rv;
  517. }
  519. CK_RV getSlotList(CK_FUNCTION_LIST_PTR pFunctionList, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pSlotListSize)
  520. {
  522. CK_RV rv= (*pFunctionList->C_GetSlotList)(FALSE,pSlotList,pSlotListSize);
  523. return rv;
  524. }
  526. CK_RV waitForSlotEvent(CK_FUNCTION_LIST_PTR pFunctionList, CK_SLOT_ID_PTR pSlotId)
  527. {
  528. CK_RV rv=CKR_OK;
  530. CK_FLAGS flags = 0;
  534. rv = (*pFunctionList->C_WaitForSlotEvent)(flags, pSlotId, NULL_PTR);
  536. return rv;
  537. }
  539. bool propCertChain(CK_FUNCTION_LIST_PTR pFunctionList, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hCert,unsigned char * valuecert,unsigned long valuecertLen){
  541. HCERTSTORE hCertStore = NULL;
  542. PCCERT_CONTEXT pCertContext,pDesiredCert;
  543. HCRYPTPROV     hProv;
  544. bool root=FALSE;
  545. CK_BYTE_PTR pSubject;
  546. CK_ULONG subjectLen=0;
  547. CK_BYTE_PTR pIssuer;
  548. CK_ULONG issuerLen=0;
  549. CK_RV rv=CKR_OK;
  551. TRACE_local(__LINE__,"propCertChain : BEGIN",NULL);
  552. /* on r閏up鑢e le subject name*/
  553. rv =  getX509Subject(pFunctionList, hSession, hCert,NULL_PTR, &subjectLen);
  554. if (rv!=CKR_OK)
  555. return false;
  556. pSubject=(CK_BYTE_PTR) malloc(subjectLen*sizeof(CK_BYTE));
  557. rv =  getX509Subject( pFunctionList, hSession, hCert,pSubject, &subjectLen);
  558. if(rv!=CKR_OK)
  559. {
  560. free(pSubject);
  561. return false;
  562. }
  563. TRACE_local(__LINE__,"pSubject : %s",pSubject);
  564. /* on r閏up鑢e l'issuer name*/
  565. rv =  getX509Issuer(pFunctionList, hSession, hCert,NULL_PTR, &issuerLen);
  566. if (rv!=CKR_OK){
  567. free(pSubject);
  568. return false;
  569. }
  570. pIssuer=(CK_BYTE_PTR) malloc(issuerLen*sizeof(CK_BYTE));
  571. rv = getX509Issuer( pFunctionList, hSession, hCert,pIssuer, &issuerLen);
  572. if(rv!=CKR_OK)
  573. {
  574. free(pIssuer);
  575. free(pSubject);
  576. return false;
  577. }
  578. TRACE_local(__LINE__,"pIssuer : %s",pIssuer);
  579. if(memcmp(pIssuer,pSubject,issuerLen)==0)
  580. root=true;
  582. free(pSubject);
  583. free(pIssuer);
  585. if (RCRYPT_FAILED(CryptAcquireContext(&hProv,NULL,NULL,PROV_RSA_FULL,CRYPT_VERIFYCONTEXT )))
  586. {
  587. DWORD dw=GetLastError();
  588. TRACE_local(__LINE__,"CryptAcquireContext ERROR: %d",dw);
  589.     return false;
  590. }
  591.    // Open the user's specified store for writing.
  592.    //
  593. if(root)
  594. hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_W,
  595.                                  0,
  596.                                  hProv,
  597.                                  CERT_STORE_NO_CRYPT_RELEASE_FLAG |
  598.                                  CERT_SYSTEM_STORE_CURRENT_USER,
  599.                                  L"Root");
  602. else
  603. hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM_W,
  604.                                  0,
  605.                                  hProv,
  606.                                  CERT_STORE_NO_CRYPT_RELEASE_FLAG |
  607.                                  CERT_SYSTEM_STORE_CURRENT_USER,
  608.                                  L"CA");
  610. if (NULL == hCertStore){
  611. TRACE_local(__LINE__,"CertOpenStore FAILED  ",NULL);
  612. return false;
  613. }
  615.  
  616.   //
  617.   // Build certificate context for this certificate.
  618.   //
  619.   pCertContext = CertCreateCertificateContext(X509_ASN_ENCODING,
  620.                                                   valuecert,
  621.                                                   valuecertLen);
  622.   if (pCertContext == NULL)
  623.   {
  624. TRACE_local(__LINE__,"CertCreateCertificateContext FAILED  ",NULL);
  625.       return false;
  626.   }
  628. if(pDesiredCert=CertFindCertificateInStore(
  629.       hCertStore,
  630. X509_ASN_ENCODING,
  631. 0,          
  632.       CERT_FIND_EXISTING,       
  633.       pCertContext,       
  634.       NULL))
  635. {
  636. TRACE_local(__LINE__,"propCertChain CERTIFICATE ALREADY INSTALLED TRUE",NULL);
  637. if (pCertContext != NULL)
  638. CertFreeCertificateContext(pCertContext);
  639. CryptReleaseContext(hProv,0);
  640. if (hCertStore != NULL)
  641. CertCloseStore(hCertStore, CERT_CLOSE_STORE_FORCE_FLAG);
  642. return true;
  643. }
  646.  //
  647.   // Put the cert in the store!
  648.   //
  649.   if (!CertAddCertificateContextToStore(hCertStore,
  650.                                         pCertContext,
  651.                                         CERT_STORE_ADD_REPLACE_EXISTING,
  652.                                         // or CERT_STORE_ADD_NEW
  653.                                         NULL))
  654.   {
  655. TRACE_local(__LINE__,"CertAddCertificateContextToStore FAILED  ",NULL);
  656.     return false;
  657.   }
  658.   if (pCertContext != NULL)
  659.   {
  660.      CertFreeCertificateContext(pCertContext);
  661.   }
  663. CryptReleaseContext(hProv,0);
  665.   if (hCertStore != NULL)
  666.   {
  667.      CertCloseStore(hCertStore, CERT_CLOSE_STORE_FORCE_FLAG);
  668.   }
  669. TRACE_local(__LINE__,"propCertChain : TRUE",NULL);
  670. return true;
  671. }
  675. /*
  676. %--------------------------------------------------------------------------
  677. % propCert
  678. %
  679. % R鬺e : La fonction propCert est utilis閑 pour ins閞er des certificats
  680. %  vers CAPI