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

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

CA认证

开发平台：

C/C++

pkcs.cpp：源码内容
  1. /****************************************************************************
  2. * library : pkcs_csp.dll
  3. * Purpose : It is a cryptographic service provider which is an independent 
  4. * software module that actually performs cryptography algorithms for 
  5. * authentication, encoding, and encryption.
  6. * This DLL can be interfaced on any PKCS#11 module.  
  7. *
  8. * Copyright (C) 2003 Ilex Syst鑝es Informatiques
  9. *
  10. * This library is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU Lesser General Public
  12. * License as published by the Free Software Foundation; either
  13. * version 2.1 of the License, or (at your option) any later version.
  14. *
  15. * This library is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. * Lesser General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU Lesser General Public
  21. * License along with this library; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23. *
  24. * Contact :
  25. * Ilex 
  26. * 51 boulevard Voltaire
  27. * 92600 Asni鑢es-sur-Seine
  28. * pkizy@ilex.fr
  29. *
  30. * Author: Delouvrier Antoine
  31. *
  32. *******************************************************************************/
  34. /*
  35. %----------------------------------------------------------------------------
  36. % PROJECT : CSP_PKCS
  37. %
  38. % MODULE : pkcs
  39. %
  40. % VERSION : 1.00
  41. %
  42. % FILE : pkcs.cpp
  43. %
  44. % cryptool: class giving access functions PKCS#11
  45. %----------------------------------------------------------------------------
  46. % Version 1.00
  47. % 
  48. % CPX-31/03/2003-Creation
  49. %----------------------------------------------------------------------------
  50. */ 
  52. /*
  53. % Libraries ANSI or system
  54. %------------------------------
  55. */
  56. #include <windows.h>
  57. #include <stdlib.h>
  58. #include <errno.h>
  59. #include <stdio.h>
  61. /*
  62. % HEADER Files include
  63. %-----------------------
  64. */
  65. #include "handlecontainer.h"
  66. #include "pkcs.h"
  67. #include "resource.h"
  70. /*
  71. % Macros
  72. %-------
  73. */
  75. #define      idCtrl(w,l)    (LOWORD(w))
  78. TableOfHandle Pkcs::table_Containers;
  79. CK_FUNCTION_LIST_PTR Pkcs::pFunctionList;
  82. extern bool already_initialized;
  83. extern int  pkcsInitialized;
  86. BOOL CALLBACK DialogProc(HWND hWnd, UINT wMsgID, WPARAM wParam, LPARAM lParam);
  87. CK_RV getCodePorteur(unsigned char * pCodePorteur, CK_ULONG codePorteurLen);
  88. char getchar(char val);
  92. CK_CHAR  g_strPwd[MAX_PIN_LEN] = "CANCEL";
  93. extern "C" HINSTANCE g_hModule;
  97. Pkcs::Pkcs() 
  98. {
  99. }
  102. /*
  103. %--------------------------------------------------------------------------
  104. % Initialize
  105. %
  106. % Initialize is used to tinitialize the dll PKCS#11
  107. %  
  108. %
  109. % return : TRUE if the operation occurred well, FALSE if not
  110. %---------------------------------------------------------------------------
  111. */
  112. BOOL Pkcs::Initialize()
  113. {
  115.     CK_RV rv=0;      
  116. pFunctionList=NULL;
  117. TRACE(__LINE__,"Pkcs::Initialize BEGIN",NULL);    
  119.     /* Load the PKCS11 library */
  120.     rv= init(&pFunctionList);
  121. if (rv!=CKR_OK){
  122. TRACE(__LINE__,"Pkcs::Initialize FALSE",NULL);    
  123. return FALSE;
  124. }
  125. TRACE(__LINE__,"Pkcs::Initialize TRUE",NULL);    
  127. return TRUE;
  128. }
  130. /*
  131. %--------------------------------------------------------------------------
  132. % FreePkcs
  133. %
  134. % FreePkcs is used to release the dll PKCS#11
  135. %  
  136. %
  137. % return : TRUE if the operation occurred well, FALSE if not
  138. %---------------------------------------------------------------------------
  139. */
  141. BOOL Pkcs::FreePkcs()
  142. {
  143. TRACE(__LINE__,"Pkcs::FreePkcs BEGIN",NULL);    
  144. CK_RV rv=0; 
  146. // The sessions of all the containers are closed
  147. int i = START;
  148. table_Containers.Lock();
  149. PKCSContainer * pCnt;
  151. do
  152. {
  153. pCnt = (PKCSContainer*)table_Containers.GetNext(i);
  154. if(pCnt==NULL)
  155. break;
  156. pCnt->Delete();
  157. table_Containers.RemoveEntry(pCnt);
  158. } while(pCnt);
  159. table_Containers.Unlock();
  161. i = START;
  162. HandleContainer *phandleContainer;
  163. HandleContainer::handles_Container.Lock();
  164. do
  165. {
  166. phandleContainer= (HandleContainer*)((HandleContainer::handles_Container).GetNext(i));
  167. if(phandleContainer==NULL)
  168. break;
  169. delete phandleContainer;
  170. } while(phandleContainer);
  171. (HandleContainer::handles_Container).Unlock();
  174. if(!already_initialized){
  175. TRACE(__LINE__,"CleanUP PKCS#11 ",NULL );
  176. rv=cleanup(pFunctionList);
  177. if (rv!=CKR_OK)
  178. return FALSE;
  179. TRACE(__LINE__,"CleanUP OK PKCS#11 ",NULL );
  180. return TRUE;
  181. }
  182. TRACE(__LINE__,"NOT CleanUP ",NULL );
  183. return TRUE;
  184. }
  187. /*
  188. %--------------------------------------------------------------------------
  189. % FreeContainer
  190. %
  191. % FreeContainer is used to free the container
  192. %  
  193. %
  194. % return : TRUE if the operation occurred well, FALSE if not
  195. %---------------------------------------------------------------------------
  196. */
  198. BOOL Pkcs::FreeContainer()
  199. {
  200. TRACE(__LINE__,"FreeContainer ",NULL );
  201. CK_RV rv=0; 
  203. // The sessions of all the containers are closed
  204. int i = START;
  205. table_Containers.Lock();
  206. PKCSContainer * pCnt;
  208. do
  209. {
  210. pCnt = (PKCSContainer*)table_Containers.GetNext(i);
  211. if(pCnt==NULL)
  212. break;
  213. pCnt->Delete();
  214. table_Containers.RemoveEntry(pCnt);
  215. delete pCnt;
  216. } while(pCnt);
  217. table_Containers.Unlock();
  219. i = START;
  220. HandleContainer *phandleContainer;
  221. HandleContainer::handles_Container.Lock();
  222. do
  223. {
  224. phandleContainer= (HandleContainer*)((HandleContainer::handles_Container).GetNext(i));
  225. if(phandleContainer==NULL)
  226. break;
  227. delete phandleContainer;
  228. } while(phandleContainer);
  229. (HandleContainer::handles_Container).Unlock();
  231. TRACE(__LINE__,"Pkcs::FreeContainer TRUE",NULL);    
  232. return TRUE;
  233. }
  236. /*
  237. %--------------------------------------------------------------------------
  238. % CreateContainerTable
  239. %
  240. % CreateContainerTable is used to create a tablecontainer with initialization
  241. %  
  242. %
  243. % return : TRUE if the operation occurred well, FALSE if not
  244. %---------------------------------------------------------------------------
  245. */
  246. BOOL Pkcs::CreateContainerTable(){
  249. TRACE(__LINE__,"PKCS CreateContainerTable BEGIN",NULL );
  250. CK_RV rv=0;                   // Return Code
  251. CK_ULONG tokenIndex=0;
  252. CK_ULONG tokenInSlotListSize = 256;
  253. CK_SLOT_ID_PTR tokenInSlotList = (CK_SLOT_ID_PTR)malloc(tokenInSlotListSize*sizeof(CK_SLOT_ID));
  255. CK_SESSION_HANDLE hSession;
  256.  
  258. CK_ULONG certListSize = 256;
  259. CK_OBJECT_HANDLE_PTR phCertList = (CK_OBJECT_HANDLE_PTR) malloc(certListSize*sizeof(CK_OBJECT_HANDLE));
  262. CK_BYTE_PTR  curSubject=NULL;
  263. CK_ULONG    curSubjectLen=512;
  265. CK_ULONG keyIdLen=256; 
  266. CK_BYTE_PTR keyId = NULL;
  268. /* One recovers all the slots having tokens */
  269. rv = getSlotListWithToken(Pkcs::pFunctionList, tokenInSlotList, &tokenInSlotListSize);
  270. if (rv!=CKR_OK){
  271. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  272. free(tokenInSlotList);
  273. free(phCertList);
  274. return FALSE;
  275. }
  277. /* one traverses all the tokens */
  278. for ( tokenIndex = 0; tokenIndex < tokenInSlotListSize ; tokenIndex++)
  279.     {
  280.         rv=CKR_OK;
  282. /* One opens a session for each token */
  283. if (openSession(Pkcs::pFunctionList, tokenInSlotList[tokenIndex],&hSession)==CKR_OK)
  284.     {
  286. certListSize=256;
  287. rv = getAllX509CertificateList(pFunctionList, hSession, phCertList, &certListSize);
  289. /* one courses the list of the certificates available on this token */
  290. for (CK_ULONG j=0; j<certListSize; j++)
  291. {
  292. /* If the certificate has no public Key, we consider that it is certificate chain */
  293. CK_OBJECT_HANDLE hKey;
  294. rv=getPublicKeyFromX509Cert(pFunctionList,hSession,&hKey,phCertList[j]);
  295. if(rv!=CKR_OK)
  296. continue;
  298. /* one creates the name of the container */
  299. char containerName[256]="";
  300. char curSubjectContainer[101]="";
  301. char keyIdContainer[101]="";
  302. rv =  getX509Subject( pFunctionList, hSession, phCertList[j],NULL_PTR, &curSubjectLen);
  303. if (rv!=CKR_OK)
  304. {
  305. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  306. free(tokenInSlotList);
  307. free(phCertList);
  308. return FALSE;
  309. }
  310. curSubject=(CK_BYTE_PTR) malloc(curSubjectLen*sizeof(CK_BYTE));
  311. if (curSubject == NULL)
  312. {
  313. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  314. free(tokenInSlotList);
  315. free(phCertList);
  316. return FALSE;
  317. }
  318. rv =  getX509Subject( pFunctionList, hSession, phCertList[j],curSubject, &curSubjectLen);
  320. if (rv == CKR_OK)
  321. {
  322. int i=0;
  323. for ( CK_ULONG j=0; j < min(curSubjectLen,(strlen(curSubjectContainer)-1)); j++)
  324. {
  325. /*if ( (unsigned)curSubject[j] > 0x20 && (unsigned)curSubject[j] < 0x7F)
  326. {
  327. curSubjectContainer[i]=curSubject[j];
  328. i++;
  329. }*/
  330. curSubjectContainer[i]=getchar(curSubject[j]);
  331. i++;
  333. }
  334. curSubjectContainer[i]=0;
  335. }
  336. else
  337. {
  338. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  339. free(tokenInSlotList);
  340. free(curSubject);
  341. free(phCertList);
  342. return FALSE;
  343. }
  345. rv = getX509KeyId(pFunctionList, hSession,  phCertList[j], NULL_PTR, &keyIdLen);
  346. if (rv!=CKR_OK) 
  347. {
  348. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  349. free(tokenInSlotList);
  350. free(curSubject);
  351. free(phCertList);
  352. return FALSE;
  353. }
  355. keyId = (CK_BYTE_PTR) malloc(keyIdLen*sizeof(CK_BYTE));
  356. if ( keyId == NULL)
  357. {
  358. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  359. free(tokenInSlotList);
  360. free(curSubject);
  361. free(phCertList);
  362. return FALSE;
  363. }
  364. rv = getX509KeyId(pFunctionList, hSession, phCertList[j], keyId, &keyIdLen);
  365. if (rv == CKR_OK)
  366. {
  367. for ( CK_ULONG j=0; j < min(keyIdLen,(strlen(keyIdContainer)-1)); j++)
  368. {
  369. //keyIdContainer[j]=keyId[j];
  370. keyIdContainer[j]=getchar(keyId[j]);
  371. }
  372. keyIdContainer[j]=0;
  374. }
  375. else
  376. {
  377. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  378. free(tokenInSlotList);
  379. free(curSubject);
  380. free(keyId);
  381. free(phCertList);
  382. return FALSE;
  383. }
  384. strcpy(containerName,curSubjectContainer);
  385. strcat( containerName,keyIdContainer);
  386. TRACE(__LINE__," Pkcs containerName to be added: %s", containerName );
  387. PKCSContainer* pContainer = NULL;
  388. /* one creates the container object */
  389. pContainer=new PKCSContainer();
  390. if(!pContainer->Initialize(pFunctionList,tokenInSlotList[tokenIndex],hSession,phCertList[j],curSubject,curSubjectLen,keyId,keyIdLen,containerName))
  391. {
  392. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  393. delete pContainer;
  394. free(tokenInSlotList);
  395. free(curSubject);
  396. free(keyId);
  397. free(phCertList);
  398. return FALSE;
  399. }
  401. /* one adds this container to the table of the containers*/
  402. if(!table_Containers.AddEntry(pContainer))
  403. {
  404. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  405. delete pContainer;
  406. free(tokenInSlotList);
  407. free(curSubject);
  408. free(keyId);
  409. free(phCertList);
  410. return FALSE;
  411. }
  413. }
  414. if(curSubject){
  415. free(curSubject);
  416. curSubject=NULL_PTR;
  417. }
  418. if(keyId){
  419. free(keyId);
  420. keyId=NULL_PTR;
  421. }
  423. }
  424. else
  425. {
  426. TRACE(__LINE__,"PKCS CreateContainerTable FALSE",NULL );
  427. if(tokenInSlotList)
  428. free(tokenInSlotList);
  429. if(phCertList)
  430. free(phCertList);
  431. return FALSE;
  432. }
  434.   
  435. }
  436. if(tokenInSlotList)
  437. free(tokenInSlotList);
  438. if(phCertList)
  439. free(phCertList);
  440. TRACE(__LINE__,"PKCS CreateContainerTable TRUE",NULL );
  441. return TRUE;
  447. }
  450. /*
  451. %--------------------------------------------------------------------------
  452. % ~Pkcs()
  453. %
  454. % ~Pkcs() est le destructor
  455. %---------------------------------------------------------------------------
  456. */
  457. Pkcs::~Pkcs()
  458. {
  460. }
  465. /*
  466. %--------------------------------------------------------------------------
  467. % VerifyContainerExistance
  468. %
  469. % VerifyContainerExistance checks the existance container
  470. %  
  471. %
  472. % Parameters of entry :
  473. % IN container The required container
  474. %  
  475. % return : TRUE if the operation occurred well, FALSE if not
  476. %---------------------------------------------------------------------------
  477. */
  478. BOOL Pkcs::VerifyContainerExistance(PKCSContainer* container)
  479. {
  480. TRACE(__LINE__,"VerifyContainerExistance",NULL );
  481. return table_Containers.VerifyEntry(container);
  483. }
  485. /*
  486. %--------------------------------------------------------------------------
  487. % GetContainer
  488. %
  489. % GetContainer is used to recover a container starting from its name 
  490. %        in the table container_table
  491. %  
  492. %
  493. % Parameters of entry :
  494. % IN szContainerName the name of the required container
  495. %  
  496. % return : the container
  497. %---------------------------------------------------------------------------
  498. */
  500. PKCSContainer* Pkcs::GetContainer(const CHAR IN * szContainerName)
  501. {
  502. TRACE(__LINE__,"Pkcs::GetContainer",NULL );
  503. if(!szContainerName)
  504. return NULL;
  506. int iCookie = START;
  507. table_Containers.Lock();
  508. PKCSContainer * pCnt;
  510. /*One seeks the Container with the good name*/
  511. do
  512. {
  513. pCnt = (PKCSContainer*)table_Containers.GetNext(iCookie);
  514. } while(pCnt && strcmp(pCnt->GetName(), szContainerName) != 0);
  515. table_Containers.Unlock();
  517. return pCnt;
  519. }
  522. /*
  523. %--------------------------------------------------------------------------
  524. % DoSign
  525. %
  526. % DoSign is used to sign data.  Two calls are carried out to DoSign 
  527. % the first call, in order to recover the size with alouer for the signature
  528. % the second call, in order to really carry out the signature
  529. %  
  530. %
  531. % Parameters of entry :
  532. % IN pContainer the container to be used
  533. % IN pbyHashLen length of the data to be signed
  534. % IN pbyHash data to be signed
  535. % IN dwKeySpec type of key to be used
  536. % OUT pbySignature signed data
  537. % OUT pdwSigLen length of the signed data
  538. % IN g_strPwd pine code to use to reach the key private
  539. %  
  540. % return : TRUE if the operation occurred well, FALSE if not
  541. %---------------------------------------------------------------------------
  542. */
  544. BOOL Pkcs::DoSign(PKCSContainer* pContainer, unsigned long pbyHashLen, LPBYTE pbyHash,DWORD dwKeySpec, LPBYTE pbySignature, LPDWORD pdwSigLen)
  545. {
  547. CK_RV rv = CKR_OK;
  548. CK_OBJECT_HANDLE hPrivKey=NULL;
  549. CK_TOKEN_INFO tokenInfo;
  550. CK_BYTE_PTR signature=NULL;
  551. bool bret;
  552. bool correctPin=false;
  553. TRACE(__LINE__,"Pkcs::DoSign BEGIN",NULL );
  554. CK_SESSION_INFO info;
  556. /* one loggs */
  557. /* Are we already logged */
  558. rv=((pContainer->GetpFunctionList())->C_GetSessionInfo)(pContainer->GethSession(),&info);
  559. if(rv!=CKR_OK)
  560. return FALSE;
  561. if(info.state!= CKS_RW_USER_FUNCTIONS && info.state!= CKS_RO_USER_FUNCTIONS)
  562. {
  564. do
  565. {
  566. unsigned char * codepin=(unsigned char *)malloc(MAX_PIN_LEN);
  567. CK_ULONG codepinLen=MAX_PIN_LEN;
  568. rv=getCodePorteur(codepin,codepinLen);
  569. if(rv!=CKR_OK){
  570. free(codepin);
  571. TRACE(__LINE__,"Pkcs::DoSign Cancel of code pin",NULL );
  572. return FALSE;
  573. }
  574. rv = login(pContainer->GetpFunctionList(),  pContainer->GethSession(),codepin,strlen((const char *)codepin));
  575. if(rv==CKR_OK)
  576. {
  577. correctPin=true;
  578. }
  579. memset(codepin,0,codepinLen);
  580. if(rv==CKR_PIN_INCORRECT)
  581. {
  583. rv =((pContainer->GetpFunctionList())->C_GetTokenInfo)(pContainer->GetslotID(), &tokenInfo);
  584. if ((rv == CKR_OK)&&((tokenInfo.flags & CKF_USER_PIN_FINAL_TRY)))
  585. {
  586. rv=getCodePorteur(codepin,codepinLen);
  587. if(rv!=CKR_OK){
  588. free(codepin);
  589. TRACE(__LINE__,"DoSign::Decrypt Cancel of code pin",NULL );
  590. return FALSE;
  591. }
  592. rv = login(pContainer->GetpFunctionList(),  pContainer->GethSession(),codepin,strlen((const char *)codepin));
  593. if(rv!=CKR_OK) 
  594. {
  595. free(codepin);
  596. TRACE(__LINE__,"Pkcs::DoSign FALSE",NULL );
  597. return FALSE;
  598. }
  599. free(codepin);
  600. break;
  601. }
  602. else if(rv != CKR_OK)
  603. {
  604. free(codepin);
  605. TRACE(__LINE__,"Pkcs::DoSign FALSE",NULL );
  606. return FALSE;
  607. }
  608. }
  609. if((rv!=CKR_OK)&&(rv!=CKR_PIN_INCORRECT))
  610. {
  611. free(codepin);
  612. TRACE(__LINE__,"Pkcs::DoSign FALSE",NULL );
  613. return FALSE;
  614. }
  618. }while(!correctPin);
  619. }
  621. /* Recovery of the private key */
  622. rv = getPrivateKeyFromX509Cert(pContainer->GetpFunctionList(),pContainer->GethSession(), &hPrivKey, pContainer->Gethcert());
  623. if (rv!=CKR_OK) {
  624. TRACE(__LINE__,"Pkcs::DoSign FALSE",NULL );
  625. return FALSE;
  626. }
  628. /* If one invites CPSign the first time in order to recover the size to allow for the signature */
  629. if(!pbySignature)
  630. {
  631. /*CK_BYTE_PTR defaultSignature=(CK_BYTE_PTR)malloc(256*sizeof(CK_BYTE));
  632. CK_ULONG defaultSignatureLength=256;*/
  633. rv = sign(pContainer->GetpFunctionList(),pContainer->GethSession(),hPrivKey, (CK_BYTE_PTR)pbyHash,pbyHashLen,NULL_PTR/*defaultSignature*/,(CK_ULONG_PTR)pdwSigLen/*&defaultSignatureLength*/,1);
  634. if(rv!=CKR_OK){
  635. TRACE(__LINE__,"Pkcs::DoSign FALSE",NULL );
  636. free(signature);
  637. return FALSE;
  638. }
  639. //*pdwSigLen=defaultSignatureLength;
  640. }
  641. /* Recovery of the signature */
  642. else
  643. {
  644. /* real signature */
  645. signature=(CK_BYTE_PTR)malloc((*pdwSigLen)*sizeof(CK_BYTE));
  646. rv = sign(pContainer->GetpFunctionList(),pContainer->GethSession(),hPrivKey, (CK_BYTE_PTR)pbyHash,pbyHashLen,(CK_BYTE_PTR)signature,(CK_ULONG_PTR)pdwSigLen,1);
  647. if(rv!=CKR_OK){
  648. TRACE(__LINE__,"Pkcs::DoSign FALSE",NULL );
  649. free(signature);
  650. return FALSE;
  651. }
  653. /* Inversion of the block signature because CAPI awaits a turned over block*/
  654. int i,j;
  655. for (i=(*pdwSigLen)-1, j=0; i > j; --i, ++j)
  656. {
  657. CK_BYTE bTmp = signature[i];
  658. signature[i] = signature[j];
  659. signature[j] = bTmp;
  660. }
  661. memcpy(pbySignature,signature,*pdwSigLen);
  663. }
  665. if(signature)
  666. free(signature);
  667. bret=TRUE;
  668. TRACE(__LINE__,"Pkcs::DoSign TRUE",NULL );
  669. return bret;
  672. }
  675. /*
  676. %--------------------------------------------------------------------------
  677. % Decrypt
  678. %
  679. % Decrypt is used to decipher data
  680. %  
  681. %
  682. % Parameters of entry :
  683. % IN hPubKey handle on the container to use to decipher
  684. % IN pbySource data to be deciphered
  685. % IN wSourceLength length of data to be deciphered
  686. % OUT pbyDestination deciphered data
  687. % OUT pwDestinationLen length of deciphered data
  688. % IN pass pine code to use to reach the key private
  689. %  
  690. % return : TRUE if the operation occurred well, FALSE if not
  691. %---------------------------------------------------------------------------
  692. */
  694. BOOL Pkcs::Decrypt(HCRYPTKEY hPubKey, BYTE* pbySource, DWORD wSourceLength, BYTE* pbyDestination, DWORD* pwDestinationLen)
  695. {
  697. CK_RV rv = CKR_OK;
  698. CK_TOKEN_INFO tokenInfo;
  699. bool correctPin=false;
  700. TRACE(__LINE__,"Pkcs::Decrypt BEGIN",NULL );
  701. if(!Pkcs::VerifyContainerExistance((PKCSContainer*) hPubKey)){
  702. TRACE(__LINE__,"Pkcs::Decrypt FALSE",NULL );
  703. return FALSE;
  704. }
  706. CK_SESSION_INFO info;
  708. /* one loggs */
  709. /* Are we already logged */
  710. rv=((((PKCSContainer*) hPubKey)->GetpFunctionList())->C_GetSessionInfo)(((PKCSContainer*) hPubKey)->GethSession(),&info);
  711. if(rv!=CKR_OK)
  712. return FALSE;
  713. if(info.state!= CKS_RW_USER_FUNCTIONS && info.state!= CKS_RO_USER_FUNCTIONS)
  714. {
  716. /* we logg  */
  717. do
  718. {
  719. unsigned char * codepin=(unsigned char *)malloc(MAX_PIN_LEN);
  720. CK_ULONG codepinLen=MAX_PIN_LEN;
  721. rv=getCodePorteur(codepin,codepinLen);
  722. if(rv!=CKR_OK){
  723. free(codepin);
  724. TRACE(__LINE__,"Pkcs::Decrypt Cancel of code pin",NULL );
  725. return FALSE;
  726. }
  727. rv = login(((PKCSContainer*) hPubKey)->GetpFunctionList(), ((PKCSContainer*) hPubKey)->GethSession(),codepin,strlen((const char *)codepin));
  728. if(rv==CKR_OK)
  729. {
  730. correctPin=true;
  731. }
  732. memset(codepin,0,codepinLen);
  733. if(rv==CKR_PIN_INCORRECT)
  734. {
  736. rv =((((PKCSContainer*) hPubKey)->GetpFunctionList())->C_GetTokenInfo)(((PKCSContainer*) hPubKey)->GetslotID(), &tokenInfo);
  737. if ((rv == CKR_OK)&&((tokenInfo.flags & CKF_USER_PIN_FINAL_TRY)))
  738. {
  739. rv=getCodePorteur(codepin,codepinLen);
  740. if(rv!=CKR_OK){
  741. free(codepin);
  742. TRACE(__LINE__,"Pkcs::Decrypt Cancel of code pin",NULL );
  743. return FALSE;
  744. }
  745. rv = login(((PKCSContainer*) hPubKey)->GetpFunctionList(), ((PKCSContainer*) hPubKey)->GethSession(),codepin,strlen((const char *)codepin));
  746. if(rv!=CKR_OK) 
  747. {
  748. free(codepin);
  749. TRACE(__LINE__,"Pkcs::Decrypt FALSE",NULL );
  750. return FALSE;
  751. }
  752. free(codepin);
  753. break;
  754. }
  755. else if(rv != CKR_OK)
  756. {
  757. free(codepin);
  758. TRACE(__LINE__,"Pkcs::Decrypt FALSE",NULL );
  759. return FALSE;
  760. }
  761. }
  762. if((rv!=CKR_OK)&&(rv!=CKR_PIN_INCORRECT))
  763. {
  764. free(codepin);
  765. TRACE(__LINE__,"Pkcs::Decrypt FALSE",NULL );
  766. return FALSE;
  767. }
  771. }while(!correctPin);
  772. }
  775. /* one recovers a handle on the private key */
  776. CK_OBJECT_HANDLE hPrivKey=NULL;
  777. rv = getPrivateKeyFromX509Cert(((PKCSContainer*)hPubKey)->GetpFunctionList(), ((PKCSContainer*)hPubKey)->GethSession(), &hPrivKey, ((PKCSContainer*)hPubKey)->Gethcert());
  778. if (rv!=CKR_OK) {
  779. TRACE(__LINE__,"Pkcs::Decrypt FALSE",NULL );
  780. return FALSE;
  781. }
  784. /* the data are deciphered */
  785. rv=decrypt(((PKCSContainer*)hPubKey)->GetpFunctionList(), ((PKCSContainer*)hPubKey)->GethSession(), hPrivKey, (CK_BYTE_PTR) pbySource, (CK_ULONG_PTR)&wSourceLength,(CK_BYTE_PTR)pbyDestination,(CK_ULONG_PTR)pwDestinationLen);
  786. if (rv!=CKR_OK) {
  787. TRACE(__LINE__,"Pkcs::Decrypt FALSE",NULL );
  788. return FALSE;
  789. }
  791. TRACE(__LINE__,"Pkcs::Decrypt TRUE",NULL );
  792. return TRUE;
  793. }
  795. CK_RV getCodePorteur(unsigned char * pCodePorteur, CK_ULONG codePorteurLen) {
  796. CK_RV rv=CKR_OK;
  798. if (pCodePorteur==NULL) {
  799. rv=CKR_ARGUMENTS_BAD;
  800. return rv;
  801. }
  802. // get the pin code
  803. DialogBox(g_hModule, MAKEINTRESOURCE(IDD_PWD), NULL, DialogProc);
  805. if (!strcmp((const char*)g_strPwd,"CANCEL")){
  806. memset(g_strPwd,0,sizeof(g_strPwd));
  807. rv=CKR_CANCEL;
  808. return rv;
  809. }
  810. memcpy(pCodePorteur, g_strPwd, codePorteurLen);
  811. memset(g_strPwd,0,sizeof(g_strPwd));
  812. return rv;
  813. }
  815. /*
  816. %--------------------------------------------------------------------------
  817. % DialogProc
  818. %
  819. % return : TRUE if the operation occurred well, FALSE if not
  820. %---------------------------------------------------------------------------
  821. */
  823. BOOL CALLBACK DialogProc(
  824.     HWND hwndDlg,         /* handle to dialog box*/
  825.     UINT uMsg,      /* message*/
  826.     WPARAM wParam,      /* first message parameter*/
  827.     LPARAM lParam       /* second message parameter*/
  828.    )
  829. {
  830.   switch( uMsg )
  831.   {
  832. case WM_INITDIALOG:
  833. break;
  834. case WM_COMMAND:
  835. switch ( idCtrl(wParam, lParam) )
  836. {
  837. case IDOK:
  838. // memorisation du mot de passe
  839. GetDlgItemText(hwndDlg,IDC_PWD,(char *)g_strPwd,30);
  840. EndDialog(hwndDlg, idCtrl(wParam, lParam));
  841. return TRUE;
  842. case IDCANCEL:
  843. strncpy((char *)g_strPwd,"CANCEL",6);
  844. EndDialog(hwndDlg, idCtrl(wParam, lParam));
  845. return TRUE;
  847. }
  848. return TRUE;
  849. break;
  850.   }
  851.   return FALSE;
  852. }
  855. char getchar(char val){
  856. int valMod=val&0x0F;
  857. char temp;
  858. if(valMod<=9)
  859. temp='0'+valMod;
  860. else
  861. temp='A'+(valMod-0xA);
  863. return temp;
  866. }