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

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

CA认证

开发平台：

C/C++

handlecontainer.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 : HandleContainer
  39. %
  40. % VERSION : 1.00
  41. %
  42. % FILE : HandleContainer.cpp
  43. %
  44. % this Class allows to manage a container. When an application obtains a context
  45. % on a container it is this class which deals with thereafter all the entrance
  46. % points of the DLL for this specific container. The entrance points are redirected to 
  47. % PKCS#11 functions or to Microsoft Provider functions.
  48. %----------------------------------------------------------------------------
  49. % Version 1.00
  50. % 
  51. % CPX-31/03/2003-Creation
  52. %----------------------------------------------------------------------------
  53. % You can find wincrypt.h in the CSPDK which is downloadable at the adress :
  54. % http://www.microsoft.com/downloads/details.aspx?FamilyId=0F436C75-2304-42BB-B81A-BA0C2C47BAC2&displaylang=en
  56. */ 
  59. /*
  60. % Libraries ANSI or system
  61. %------------------------------
  62. */
  64. #include <windows.h>
  65. #include <stdio.h>
  66. #include "assert.h"
  69. /*
  70. % HEADER Files include
  71. %-----------------------
  72. */
  73. #include "handlecontainer.h"
  74. #include "csp_pkcs_const.h"
  75. #include "resource.h"
  79. #define CONTAINER_NAME TEXT("PKCS_CSP")
  81. extern "C" extern HINSTANCE g_hModule;
  83. typedef struct SessionKeyHeader
  84. {
  85. BLOBHEADER blobHeader;
  86. ALG_ID algid;
  87. } SessionKeyHeader, *pSessionKeyHeader;
  90. //Initialization of static member variable
  91. TableOfHandle HandleContainer::handles_Container;
  93. /*
  94. %--------------------------------------------------------------------------
  95. % HandleContainer()
  96. %
  97. % R鬺e : HandleContainer() is the constructor of the class handlecontainer
  98. %
  99. %---------------------------------------------------------------------------
  100. */
  101. HandleContainer::HandleContainer() 
  102. {
  103. }
  105. /*
  106. %--------------------------------------------------------------------------
  107. % ~HandleContainer()
  108. %
  109. % destructor 
  110. %---------------------------------------------------------------------------
  111. */
  113. HandleContainer::~HandleContainer()
  114. {
  115. TRACE(__LINE__,"~HandleContainer() ",NULL);
  116. handles_Container.RemoveEntry(this);
  118. }
  120. /*
  121. %--------------------------------------------------------------------------
  122. % Initialize
  123. %
  124. % R鬺e : Initialize est utilis閑 pour initialiser l'objet handlecontainer
  125. %
  126. % Parameters of entry  :
  127. % IN pszContainer Name of the container
  128. % IN dwFlags Value of a flag of the type(CRYPT_VERIFYCONTEXTCRYPT_NEWKEYSET),according to this value one can or not to make certain operations on the container
  129. % IN pVTable Pointer on a VTableProvStruc structure containing a list of functions callback provided by the operating software for the use of the CSP.
  130. %  
  131. % return : TRUE if the operation occurred well, FALSE if not
  132. %---------------------------------------------------------------------------
  133. */
  135. BOOL HandleContainer::CreateHandleContainer(const CHAR IN * const pszContainer,const DWORD IN dwFlags, PVTableProvStruc IN pVTable)
  136. {
  137. TRACE(__LINE__,"HandleContainer::CreateHandleContainer BEGIN : %d %d %d",pszContainer,dwFlags,pVTable);
  140. if(!AcquireMicrosoftContext()){
  141. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  142. return FALSE;
  143. }
  146. if((dwFlags & CRYPT_MACHINE_KEYSET) == CRYPT_MACHINE_KEYSET)
  147. {
  148. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  149. SetLastError(NTE_BAD_FLAGS);
  150. return FALSE;
  151. }
  152. if((dwFlags & CRYPT_VERIFYCONTEXT) == CRYPT_VERIFYCONTEXT){
  153. if(!handles_Container.AddEntry(this))
  154. {
  155. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  156. SetLastError(NTE_NO_MEMORY);
  157. return FALSE;
  158. }
  159. TRACE(__LINE__,"HandleContainer::CreateHandleContainer TRUE : %d %d %d",pszContainer,dwFlags,pVTable);
  160. return TRUE;
  161. }
  162. if((dwFlags & CRYPT_NEWKEYSET) == CRYPT_NEWKEYSET)
  163. {
  164. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  165. SetLastError(NTE_EXISTS);
  166. return FALSE;
  168. }
  169. else if((dwFlags&CRYPT_DELETEKEYSET) == CRYPT_DELETEKEYSET)
  170. {
  171. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  172. SetLastError(NTE_BAD_KEYSET);
  173. return FALSE;
  175. }
  176. else 
  177. {
  178. currentPContainer = Pkcs::GetContainer(pszContainer);
  179. if(!currentPContainer)
  180. {
  181. /* If the table of the containers do not exist or if it must change to release that of front*/
  182. Pkcs::FreeContainer();
  183. /* recreate a table*/
  184. Pkcs::CreateContainerTable();
  185. currentPContainer = Pkcs::GetContainer(pszContainer);
  186. int ret;
  187. while(!currentPContainer){
  188. ret=MessageBox(NULL,"Please insert the card corresponding to the selected certificate.","Insert your card",MB_OKCANCEL|MB_ICONQUESTION|MB_SYSTEMMODAL);
  189. if(ret==IDCANCEL){
  190. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  191. SetLastError(NTE_BAD_KEYSET);
  192. return FALSE;
  193. }
  194. /* If the table of the containers do not exist or if it must change to release that of front*/
  195. Pkcs::FreeContainer();
  196. /* recreate a table*/
  197. Pkcs::CreateContainerTable();
  198. currentPContainer = Pkcs::GetContainer(pszContainer);
  199. }
  202. }
  203. }
  205. if(!handles_Container.AddEntry(this))
  206. {
  207. TRACE(__LINE__,"HandleContainer::CreateHandleContainer ERROR : %d %d %d",pszContainer,dwFlags,pVTable);
  208. SetLastError(NTE_NO_MEMORY);
  209. return FALSE;
  210. }
  213. TRACE(__LINE__,"HandleContainer::CreateHandleContainer TRUE : %d %d %d",pszContainer,dwFlags,pVTable);
  214. return TRUE;
  215. }
  219. /*
  220. %--------------------------------------------------------------------------
  221. % AcquireMicrosoftContext
  222. %
  223. % AcquireMicrosoftContext is used to acquire a context to a microsoft provider 
  224. %  
  225. %
  226. % return : TRUE if the operation occurred well, FALSE if not
  227. %---------------------------------------------------------------------------
  228. */
  229. BOOL HandleContainer::AcquireMicrosoftContext()
  230. {
  231. CHAR szProviderName[MAX_PATH] = {0};
  233. /* Try first with enhanced provider , if it fails , try with base provider */
  234. strcpy(szProviderName,MS_ENHANCED_PROV);
  236. if(CryptAcquireContext(&microsoft_Provider, CONTAINER_NAME, szProviderName, PROV_RSA_FULL, CRYPT_NEWKEYSET))
  237. {
  238. return TRUE;
  239. }
  240. /* if the container already exists, try to open it */
  241. if(NTE_EXISTS == GetLastError())
  242. {
  243. if(CryptAcquireContext(&microsoft_Provider, CONTAINER_NAME, szProviderName, PROV_RSA_FULL,0))
  244. {
  245. return TRUE;
  246. }
  247. }
  248. /* the Enhanded provider is not found , try the base provider    */
  249. strcpy(szProviderName, MS_DEF_PROV);
  250. if(CryptAcquireContext(&microsoft_Provider, CONTAINER_NAME, szProviderName, PROV_RSA_FULL, CRYPT_NEWKEYSET))
  251. {
  252. return TRUE;
  253. }
  254. /* if the container already exists, try to open it */
  255. if(NTE_EXISTS == GetLastError())
  256. {
  257. if(CryptAcquireContext(&microsoft_Provider, CONTAINER_NAME, szProviderName, PROV_RSA_FULL, 0))
  258. {
  259. return TRUE;
  260. }
  261. }
  263. microsoft_Provider = NULL;
  264. return FALSE;
  265. }
  270. /*
  271. %--------------------------------------------------------------------------
  272. % VerifyHandleContainer
  273. %
  274. % VerifyHandleContainer allows to check the existence of a context
  275. %
  276. % Parameters of entry  :
  277. % IN handleContainer handle to verify
  278. %  
  279. % return : TRUE if the operation occurred well, FALSE if not
  280. %---------------------------------------------------------------------------
  281. */
  282. bool HandleContainer::VerifyHandleContainer(HandleContainer* handleContainer)
  283. {
  284. TRACE(__LINE__,"HandleContainer::VerifyHandleContainer : %d ",handleContainer);
  285. return handles_Container.VerifyEntry(handleContainer);
  287. }
  289. /*
  290. %--------------------------------------------------------------------------
  291. % CreateHash
  292. %
  293. % CreateHash is used to return a handle on the creation of a hash object: 
  294. % managed by Provider Microsoft
  295. %
  296. % Parameters of entry  :
  297. % IN Algid - Algorithm used for the hashing
  298. % IN hKey - If the type of hash algorithm is a keyed hash, such as the HMAC or MAC algorithm, the key for the hash is passed in this parameter. For nonkeyed algorithms, this parameter must be set to zero 
  299. % IN dwFlags - not used
  300. % OUT phHash - address to which one copies the handle hashed object
  301. %  
  302. % return : TRUE if the operation occurred well, FALSE if not
  303. %---------------------------------------------------------------------------
  304. */
  305. BOOL HandleContainer::CreateHash(ALG_ID Algid, HCRYPTKEY hCryptKey, DWORD dwFlags, HCRYPTHASH* phHash)
  306. {
  307. TRACE(__LINE__,"HandleContainer::CreateHash ",NULL);
  308. return CryptCreateHash(microsoft_Provider,Algid, hCryptKey, dwFlags, phHash);
  309. }
  312. /*
  313. %--------------------------------------------------------------------------
  314. % DestroyHash
  315. %
  316. % DestroyHash is used to destroy a hash object:  managed by Provider Microsoft
  317. %
  318. % Parameters of entry  :
  319. % IN hHash - Handle on a hash object to be destroyed
  320. %  
  321. % return : TRUE if the operation occurred well, FALSE if not
  322. %---------------------------------------------------------------------------
  323. */
  325. BOOL HandleContainer::DestroyHash(HCRYPTHASH hHash)
  326. {
  327. TRACE(__LINE__,"HandleContainer::DestroyHash ",NULL);
  328. return CryptDestroyHash(hHash);
  329. }
  332. /*
  333. %--------------------------------------------------------------------------
  334. % GetHashParam
  335. %
  336. % GetHashParam seeks data about the operations of a hash object.  The actual
  337. % value of the hashing can be obtained by using this function: 
  338. % managed by Provider Microsoft
  339. %
  340. % Parameters of entry  :
  341. % IN hHash - Handle on a hashed object
  342. % IN ulParametre  - value of the parameter
  343. % IN pulDataLen   - Length of the parameter pucData 
  344. % IN ulFlags - Values of the flag 
  345. %
  346. % Parameters of exit :
  347. % OUT pucData - Address to which the function copies the data corresponding to the ulParametre
  348. %  
  349. % return : TRUE if the operation occurred well, FALSE if not
  350. %---------------------------------------------------------------------------
  351. */
  352. BOOL HandleContainer::GetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE* pbData, DWORD*pdwDataLen, DWORD dwFlags)
  353. {
  354. TRACE(__LINE__,"HandleContainer::GetHashParam ",NULL);
  355. return CryptGetHashParam(hHash, dwParam, pbData, pdwDataLen, dwFlags);
  356. }
  359. /*
  360. %--------------------------------------------------------------------------
  361. % HashData
  362. %
  363. % HashData is used to carry out a hashing starting from a handle on a hash object:
  364. % managed by Provider Microsoft
  365. %
  366. % Parameters of entry  :
  367. % IN hHash - Handle on a hashed object
  368. % IN pbData - address containing the data to be hashed
  369. % IN cbDataLen - length in bytes of the data to be hashed
  370. % IN dwFlags - not used
  371. %  
  372. % return : TRUE if the operation occurred well, FALSE if not
  373. %---------------------------------------------------------------------------
  374. */
  375. BOOL HandleContainer::HashData(HCRYPTHASH hHash, CONST BYTE* pbData, DWORD dwDatalen, DWORD dwFlags)
  376. {
  377. TRACE(__LINE__,"HandleContainer::HashData ",NULL);
  378. return CryptHashData(hHash, pbData, dwDatalen, dwFlags);
  379. }
  385. /*
  386. %--------------------------------------------------------------------------
  387. % SetHashParam
  388. %
  389. % SetHashParam adapts the operations to the customer requirements of the hashed data: 
  390. % managed by Provider Microsoft
  391. %
  392. % Parameters of entry  :
  393. % IN hHash - Handle on a hash object
  394. % IN ulParametre  - value of the parameter
  395. % IN pucData - Pointer on data corresponding to the last ulParametre   
  396. % IN ulFlags - Values of the flag 
  397. %
  398. % return : TRUE if the operation occurred well, FALSE if not
  399. %---------------------------------------------------------------------------
  400. */
  401. BOOL HandleContainer::SetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE*pbData, DWORD dwFlags)
  402. {
  403. TRACE(__LINE__,"HandleContainer::SetHashParam ",NULL);
  404. return CryptSetHashParam(hHash,dwParam,pbData,dwFlags);
  405. }
  408. BOOL HandleContainer::GetProvParam(DWORD dwParam, BYTE* pbData, DWORD* pdwDataLen, DWORD dwFlags)
  409. {
  411. switch(dwParam)
  412. {
  413. case PP_ENUMALGS:
  414. TRACE(__LINE__,"HandleContainer::CryptGetProvParam  PP_ENUMALGS",NULL);
  415. return CryptGetProvParam(microsoft_Provider, PP_ENUMALGS, pbData, pdwDataLen, dwFlags);
  416. case PP_ENUMALGS_EX:
  417. TRACE(__LINE__,"HandleContainer::CryptGetProvParam  PP_ENUMALGS_EX",NULL);
  418. return CryptGetProvParam(microsoft_Provider, PP_ENUMALGS_EX, pbData, pdwDataLen, dwFlags);
  419. case PP_PROVTYPE :
  420. TRACE(__LINE__,"HandleContainer::CryptGetProvParam  PP_PROVTYPE",NULL);
  421. return FALSE;
  422. default:
  423. SetLastError(NTE_BAD_TYPE);
  424. return FALSE;
  425. }
  426. return FALSE;
  427. }
  430. /*
  431. %--------------------------------------------------------------------------
  432. % Encrypt
  433. %
  434. % Encrypt is used to cipher  data:  managed by Provider Microsoft
  435. %
  436. % Parameters of entry  :
  437. %             IN  hKey -  Handle on a key of session used for coding
  438. % IN hHash - Handle on a hash object if one wants to carry out a hash data before coding
  439. % IN Final - Boolean allowing to know if it is the last part to be ciphered
  440. % IN dwFlags - not used
  441. % INOUT pbData - data to be ciphered
  442. % INOUT pdwDataLen - length of  data to be ciphered
  443. % IN dwBufLen - length of the data pbData in bytes
  444. %  
  445. % return : TRUE if the operation occurred well, FALSE if not
  446. %---------------------------------------------------------------------------
  447. */
  448. BOOL HandleContainer::Encrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE* pbData, DWORD*pdwDataLen, DWORD dwBufLen)
  449. {
  450. TRACE(__LINE__,"HandleContainer::Encrypt ",NULL);
  451. return CryptEncrypt(hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
  452. }
  455. /*
  456. %--------------------------------------------------------------------------
  457. % Decrypt
  458. %
  459. % Decrypt is used to decipher data:  managed by Provider Microsoft
  460. %
  461. % Parameters of entry  :
  462. %             IN  hKey -  Handle on a key of session used for the deciphering
  463. % IN hHash - Handle on a hash object if one wants to carry out a hash data after the deciphering
  464. % IN Final - Boolean allowing to know if it is the last part to be deciphered
  465. % IN dwFlags - not used
  466. % INOUT pbData -data to be  deciphereddata deciphered
  467. % INOUT pdwDataLen -length of data to be  deciphereddata deciphered
  468. %  
  469. % return : TRUE if the operation occurred well, FALSE if not
  470. %---------------------------------------------------------------------------
  471. */
  472. BOOL HandleContainer::Decrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE*pbData, DWORD*pdwDataLen)
  473. {
  474. TRACE(__LINE__,"HandleContainer::Decrypt ",NULL);
  475. return CryptDecrypt(hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
  477. }
  480. /*
  481. %--------------------------------------------------------------------------
  482. % SignHash
  483. %
  484. % SignHash is used to carry out the signature of one starting from a handle on a hash object.
  485. %
  486. % Parameters of entry  :
  487. % IN hHash - Handle on the hash object to be signed
  488. % IN dwKeySpec -type of key to use to sign(AT_KEYEXCHANGEAT_SIGNATURE)
  489. % IN szDescription - not used
  490. % IN dwFlags - not used
  491. % OUT pbSignature - pointer on the signed data
  492. % OUT pdwSigLen - address of a DWORD containing the length of the signed data
  493. %  
  494. % return : TRUE if the operation occurred well, FALSE if not
  495. %---------------------------------------------------------------------------
  496. */
  497. BOOL HandleContainer::SignHash(HCRYPTHASH hHash, DWORD dwKeySpec, LPCWSTR sDescription, DWORD dwFlags, BYTE*pbSignature, DWORD* pdwSigLen)
  498. {
  500. TRACE(__LINE__,"HandleContainer::SignHash BEGIN ",NULL);
  502. ALG_ID algidHash;
  503. unsigned long dwBufferLen;
  505. LPBYTE pbyHash = NULL;
  506. unsigned long dwHashLen;
  507. const BYTE * pbyOID = NULL;
  508. unsigned long dwOIDLen = 0;
  509. BOOL bRet = FALSE;
  511. dwBufferLen = sizeof(algidHash);
  512. if(!CryptGetHashParam(hHash, HP_ALGID, (LPBYTE)&algidHash, &dwBufferLen, 0))
  513. {
  514. TRACE(__LINE__,"HandleContainer::SignHash FALSE ",NULL);
  515. SetLastError(NTE_BAD_HASH);
  516. return FALSE;
  517. }
  519. dwBufferLen = sizeof(dwHashLen);
  520. if(!CryptGetHashParam(hHash, HP_HASHSIZE, (LPBYTE)&dwHashLen, &dwBufferLen, 0))
  521. {
  522. TRACE(__LINE__,"HandleContainer::SignHash FALSE ",NULL);
  523. SetLastError(NTE_BAD_HASH);
  524. return FALSE;
  525. }
  527. switch(algidHash)
  528. {
  529. case CALG_SSL3_SHAMD5:
  530. dwOIDLen = 0;
  531. break;
  532. case CALG_MD2:
  533. pbyOID = &derEncodedMD2[0];
  534. dwOIDLen = sizeof(derEncodedMD2);
  535. break;
  536. case CALG_MD5:
  537. pbyOID = &derEncodedMD5[0];
  538. dwOIDLen = sizeof(derEncodedMD5);
  539. break;
  540. case CALG_SHA1:
  541. pbyOID = &derEncodedSHA1[0];
  542. dwOIDLen = sizeof(derEncodedSHA1);
  543. break;
  544. default:
  545. SetLastError(NTE_BAD_ALGID);
  546. return FALSE;
  547. }
  549. pbyHash = new BYTE[dwHashLen + dwOIDLen];
  550. if(!pbyHash)
  551. {
  552. TRACE(__LINE__,"HandleContainer::SignHash FALSE ",NULL);
  553. SetLastError(NTE_FAIL);
  554. return FALSE;
  555. }
  557. if(pbyOID)
  558. memcpy(pbyHash, pbyOID, dwOIDLen);
  561. if(!CryptGetHashParam(hHash, HP_HASHVAL, pbyHash+dwOIDLen, &dwHashLen, 0))
  562. {
  563. TRACE(__LINE__,"HandleContainer::SignHash FALSE ",NULL);
  564. SetLastError(NTE_BAD_HASH);
  565. if(pbyHash)
  566. free(pbyHash);
  567. return FALSE;
  568. }
  570. if(!Pkcs::DoSign(currentPContainer,dwHashLen + dwOIDLen, pbyHash, dwKeySpec,pbSignature,pdwSigLen))
  571. {
  572. TRACE(__LINE__,"HandleContainer::SignHash FALSE ",NULL);
  573. SetLastError(NTE_FAIL);
  574. if(pbyHash)
  575. free(pbyHash);
  576. return FALSE;
  577. }
  578. TRACE(__LINE__,"HandleContainer::SignHash TRUE ",NULL);
  579. return TRUE;
  581. }
  584. /*
  585. %--------------------------------------------------------------------------
  586. % VerifySignature
  587. %
  588. % VerifySignature is used to check a signature: managed by Provider Microsoft
  589. %
  590. % Parameters of entry  :
  591. % IN hHash - Handle on a hash object to be checked
  592. % IN pbSignature - buffer containing the signature
  593. % IN dwSigLen - length in bytes of the signature
  594. % IN hPubKey - Handle on the public key with used to check the signature
  595. % IN sDescription - not used
  596. % IN dwFlags - not used
  597. %  
  598. % return : TRUE if the operation occurred well, FALSE if not
  599. %---------------------------------------------------------------------------
  600. */
  601. BOOL HandleContainer::VerifySignature(HCRYPTHASH hHash, CONST BYTE* pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey,LPCTSTR sDescription, DWORD dwFlags)
  602. {
  603. TRACE(__LINE__,"HandleContainer::VerifySignature ",NULL);
  604. return CryptVerifySignature(hHash, pbSignature, dwSigLen, hPubKey,sDescription, dwFlags);
  605. }
  611. /*
  612. %--------------------------------------------------------------------------
  613. % DestroyKey
  614. %
  615. % The DestroyKey function releases the handle referred by the parameter hKey:  managed by Provider Microsoft
  616. %
  617. % Parameters of entry  :
  618. % IN phKey - Handle on the key
  619. %  
  620. % return : TRUE if the operation occurred well, FALSE if not
  621. %---------------------------------------------------------------------------
  622. */
  623. BOOL HandleContainer::DestroyKey(HCRYPTKEY hKey)
  624. {
  625. TRACE(__LINE__,"HandleContainer::DestroyKey ",NULL);
  626. return CryptDestroyKey(hKey);
  627. }
  630. /*
  631. %--------------------------------------------------------------------------
  632. % ImportKey
  633. %
  634. % ImportKey import keys of a "Keyblob" towards a container of key
  635. %
  636. % Parameters of entry  :
  637. %             IN  pbData -  data of "Keyblob"
  638. % IN  dwDataLen -  length of data
  639. % IN  hPubKey -  Handle on a key public of exchange of the user recipient
  640. %                 IN  dwFlags -  Flags values
  641. %
  642. % Parameters of exit  :
  643. % OUT phKey - Address to which the function copies the handle key to be imported
  644. %  
  645. % return : TRUE if the operation occurred well, FALSE if not
  646. %---------------------------------------------------------------------------
  647. */
  648. BOOL HandleContainer::ImportKey(BYTE* pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY* phKey)
  649. {
  652. DWORD i,j;
  653. HCRYPTPROV hProv_m = 0;
  654. HCRYPTKEY hPubPrivKey = 0;
  655.     BOOL fResult;
  657. TRACE(__LINE__,"HandleContainer::ImportKey BEGIN ",NULL);
  658.    
  659. if(!pbData)
  660. {
  661. TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  662. SetLastError(NTE_FAIL);
  663. return FALSE;
  664. }
  666. /*If it's a PUBLICKEYBLOB import it into the base provider.*/
  667. pSessionKeyHeader pskh = (pSessionKeyHeader)pbData;
  668. if(PUBLICKEYBLOB == pskh->blobHeader.bType || !hPubKey)
  669. return CryptImportKey(microsoft_Provider, pbData, dwDataLen, hPubKey, dwFlags, phKey);
  671. /*If it's not a SIMPLEBLOB we don't know what to do with it.*/
  672. if(SIMPLEBLOB != pskh->blobHeader.bType)
  673. {
  674. TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  675. SetLastError(NTE_BAD_TYPE);
  676. return FALSE;
  677. }
  678. /*We only know how to deal with RSA keys.*/
  679. if(CALG_RSA_KEYX != pskh->algid)
  680. {
  681. TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  682. SetLastError(NTE_BAD_TYPE);
  683. return FALSE;
  684. }
  686. BOOL bRet = FALSE;
  688. //Wrapped blob size.
  689. DWORD wEncryptedDataLength = (DWORD)(dwDataLen - sizeof(SessionKeyHeader));
  690. BYTE* pKeySource = pbData + sizeof(SessionKeyHeader);
  691. BYTE* pbyDecryptedData = new BYTE[wEncryptedDataLength];
  692. DWORD wDecryptedDataLength = wEncryptedDataLength;
  694. if(!pbyDecryptedData)
  695. {
  696. TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  697. SetLastError(NTE_FAIL);
  698. if(pbyDecryptedData)
  699. delete [] pbyDecryptedData;
  700. return FALSE;
  701. }
  703. /*reversal of the block pKeySource */
  705. for (i=wEncryptedDataLength-1, j=0; i > j; --i, ++j)
  706. {
  707. BYTE bTmp = pKeySource[i];
  708. pKeySource[i] = pKeySource[j];
  709. pKeySource[j] = bTmp;
  710. }
  714. if(!Pkcs::Decrypt(hPubKey, pKeySource, wEncryptedDataLength, pbyDecryptedData, &wDecryptedDataLength))
  715. {
  716. TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  717. SetLastError(NTE_BAD_ALGID);
  718. if(pbyDecryptedData)
  719. delete [] pbyDecryptedData;
  720. return FALSE;
  721. }
  722. LPTSTR MicroProvider;
  724. // Try to create new container
  725. if(pskh->blobHeader.aiKeyAlg==CALG_RC2 && wDecryptedDataLength==5)
  726. MicroProvider="Microsoft Base Cryptographic Provider v1.0";
  727. else
  728. MicroProvider="Microsoft Enhanced Cryptographic Provider v1.0";
  729.     
  730. fResult =CreatePrivateExponentOneKey(MicroProvider, PROV_RSA_FULL,
  731.                                             "importKey", AT_KEYEXCHANGE, 
  732.                                             &hProv_m, &hPubPrivKey);
  733. if(!fResult)
  734.     {
  735.        TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  736.    SetLastError(NTE_FAIL);
  737.    if(pbyDecryptedData)
  738. delete [] pbyDecryptedData;
  739.    return FALSE;
  740.        
  741.     }
  743.  // Import this key and get an HCRYPTKEY handle
  744.      if (!ImportPlainSessionBlob(hProv_m, hPubPrivKey,pskh->blobHeader.aiKeyAlg , pbyDecryptedData, wDecryptedDataLength, phKey))
  745.      {
  746. TRACE(__LINE__,"HandleContainer::ImportKey FALSE ",NULL);
  747. SetLastError(NTE_FAIL);
  748. if(pbyDecryptedData)
  749. delete [] pbyDecryptedData;
  750.     return FALSE;
  751.      }
  753.  
  754. bRet = TRUE;
  755.     if(pbyDecryptedData)
  756. delete [] pbyDecryptedData;
  757. TRACE(__LINE__,"HandleContainer::ImportKey TRUE ",NULL);
  758. return bRet;
  759. }
  764. /*
  765. %--------------------------------------------------------------------------
  766. % GetKeyParam
  767. %
  768. % GetKeyParam seeks the data which govern the operations of a key:  manage by Provider Microsoft
  769. %
  770. % Parameters of entry  :
  771. % IN hKey     - Handle on the key
  772. % IN ulParametre  - value of parameter
  773. % IN pulDataLen   - length of the parameter pucData 
  774. % IN ulFlags - values of the flag 
  775. %
  776. % Parameters of exit  :
  777. % OUT pucData - Address to which the function copies the data corresponding to the ulFlags
  778. %  
  779. % return : TRUE if the operation occurred well, FALSE if not
  780. %---------------------------------------------------------------------------
  781. */
  782. BOOL HandleContainer::GetKeyParam(HCRYPTKEY hKey, DWORD dwParam, BYTE* pbData, DWORD* pdwDataLen, DWORD dwFlags)
  783. {
  784. TRACE(__LINE__,"HandleContainer::GetKeyParam",NULL);
  785. return CryptGetKeyParam(hKey, dwParam, pbData, pdwDataLen, dwFlags);
  786. }
  789. /*
  790. %--------------------------------------------------------------------------
  791. % SetKeyParam
  792. %
  793. % SetKeyParam adapt the operations to the customer requirements of a key:  
  794. % manage by Provider Microsoft
  795. %
  796. % Parameters of entry  :
  797. % IN hKey     - Handle on a key
  798. % IN ulParametre  - value of the parameter
  799. % IN pucData - Pointer containing the data which correspond to the value 
  800. %                                         of parameter dwParam
  801. % IN ulFlags - Values of the flag (not used)
  802. %
  803. % return : TRUE if the operation occurred well, FALSE if not
  804. %---------------------------------------------------------------------------
  805. */
  806. BOOL HandleContainer::SetKeyParam(HCRYPTKEY hKey, DWORD dwParam,CONST BYTE*pbData, DWORD dwFlags)
  807. {
  808. TRACE(__LINE__,"HandleContainer::SetKeyParam",NULL);
  809. return CryptSetKeyParam(hKey, dwParam, pbData, dwFlags);
  810. }
  813. /*
  814. %--------------------------------------------------------------------------
  815. % GetUserKey
  816. %
  817. % GetUserKey is used to return a handle on the pair of key of the user
  818. %
  819. % Parameters of entry  :
  820. % IN dwKeySpec - desired type of key (AT_KEYEXCHANGEAT_SIGNATURE)
  821. % OUT phUserKey - address to which is copied the handle desired key
  822. %  
  823. % return : TRUE if the operation occurred well, FALSE if not
  824. %---------------------------------------------------------------------------
  825. */
  826. BOOL HandleContainer::GetUserKey(DWORD dwKeySpec, HCRYPTKEY* phUserKey)
  827. {
  828. TRACE(__LINE__,"HandleContainer::GetUserKey BEGIN",NULL);
  829.    if(!(currentPContainer->GetUserKey(dwKeySpec,phUserKey)))
  830.    {
  831.    TRACE(__LINE__,"HandleContainer::GetUserKey FALSE",NULL);
  832.    SetLastError(NTE_NO_KEY);
  833.        return FALSE;
  834.    }
  835.    TRACE(__LINE__,"HandleContainer::GetUserKey TRUE",NULL);
  836.    return TRUE;
  837. }
  839. /*
  840. %--------------------------------------------------------------------------
  841. % CreatePrivateExponentOneKey
  842. %
  843. % CreatePrivateExponentOneKey is used to create a key private which carries
  844. % out during coding the identity
  845. %
  846. % Parameters of entry  :
  847. % IN szProvider Name of provider
  848. % IN dwProvType
  849. % IN szContainer Name of container
  850. % IN dwKeySpec type of key
  851. % IN hProv handle to the provider
  852. % IN hPrivateKey handle to the private key
  853. %
  854. %  
  855. % return : TRUE if the operation occurred well, FALSE if not
  856. %---------------------------------------------------------------------------
  857. */
  859. BOOL HandleContainer::CreatePrivateExponentOneKey(LPTSTR szProvider,DWORD dwProvType,LPTSTR szContainer,DWORD dwKeySpec,HCRYPTPROV *hProv,HCRYPTKEY *hPrivateKey)
  860. {
  861.    BOOL fReturn = FALSE;
  862.    BOOL fResult;
  863.    int n;
  864.    LPBYTE keyblob = NULL;
  865.    DWORD dwkeyblob;
  866.    DWORD dwBitLen;
  867.    BYTE *ptr;
  868.    TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey BEGIN",NULL);
  870.    __try
  871.    {
  872.       *hProv = 0;
  873.       *hPrivateKey = 0;
  875.       if ((dwKeySpec != AT_KEYEXCHANGE) && (dwKeySpec != AT_SIGNATURE))  __leave;
  877.       // Try to create new container
  878.       fResult = CryptAcquireContext(hProv, szContainer, szProvider, 
  879.                                     dwProvType, CRYPT_NEWKEYSET);
  880.       if (!fResult)
  881.       {
  882.          // If the container exists, open it
  883.          if (GetLastError() == NTE_EXISTS)
  884.          {
  885.             fResult = CryptAcquireContext(hProv, szContainer, szProvider, dwProvType, 0);
  886.             if (!fResult)
  887.             {
  888.   TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  889.                // No good, leave
  890.                __leave;
  891.             }
  892.          }
  893.          else
  894.          {
  895. TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  896.             // No good, leave
  897.             __leave;
  898.          }
  899.       }
  901.       // Generate the private key
  902.       fResult = CryptGenKey(*hProv, dwKeySpec, CRYPT_EXPORTABLE, hPrivateKey);
  903.       if (!fResult){
  904.   TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  905. __leave;
  906.   }
  908.       // Export the private key, we'll convert it to a private
  909.       // exponent of one key
  910.       fResult = CryptExportKey(*hPrivateKey, 0, PRIVATEKEYBLOB, 0, NULL, &dwkeyblob);
  911.       if (!fResult){
  912. TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  913.   __leave;  
  914.   }
  916.       keyblob = (LPBYTE)LocalAlloc(LPTR, dwkeyblob);
  917.       if (!keyblob){
  918. TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  919.   __leave;
  920.   }
  922.       fResult = CryptExportKey(*hPrivateKey, 0, PRIVATEKEYBLOB, 0, keyblob, &dwkeyblob);
  923.       if (!fResult){
  924. TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  925.   __leave;
  926.   }
  929.       CryptDestroyKey(*hPrivateKey);
  930.       *hPrivateKey = 0;
  932.       // Get the bit length of the key
  933.       memcpy(&dwBitLen, &keyblob[12], 4);      
  935.       // Modify the Exponent in Key BLOB format
  936.       // Key BLOB format is documented in SDK
  938.       // Convert pubexp in rsapubkey to 1
  939.       ptr = &keyblob[16];
  940.       for (n = 0; n < 4; n++)
  941.       {
  942.          if (n == 0) ptr[n] = 1;
  943.          else ptr[n] = 0;
  944.       }
  946.       // Skip pubexp
  947.       ptr += 4;
  948.       // Skip modulus, prime1, prime2
  949.       ptr += (dwBitLen/8);
  950.       ptr += (dwBitLen/16);
  951.       ptr += (dwBitLen/16);
  953.       // Convert exponent1 to 1
  954.       for (n = 0; n < (dwBitLen/16); n++)
  955.       {
  956.          if (n == 0) ptr[n] = 1;
  957.          else ptr[n] = 0;
  958.       }
  960.       // Skip exponent1
  961.       ptr += (dwBitLen/16);
  963.       // Convert exponent2 to 1
  964.       for (n = 0; n < (dwBitLen/16); n++)
  965.       {
  966.          if (n == 0) ptr[n] = 1;
  967.          else ptr[n] = 0;
  968.       }
  970.       // Skip exponent2, coefficient
  971.       ptr += (dwBitLen/16);
  972.       ptr += (dwBitLen/16);
  974.       // Convert privateExponent to 1
  975.       for (n = 0; n < (dwBitLen/8); n++)
  976.       {
  977.          if (n == 0) ptr[n] = 1;
  978.          else ptr[n] = 0;
  979.       }
  980.       
  981.       // Import the exponent-of-one private key.      
  982.       if (!CryptImportKey(*hProv, keyblob, dwkeyblob, 0, 0, hPrivateKey))
  983.       {   
  984. TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey FALSE",NULL);
  985.          __leave;
  986.       }
  987.       TRACE(__LINE__,"HandleContainer::CreatePrivateExponentOneKey TRUE",NULL);
  988.       fReturn = TRUE;
  989.    }
  990.    __finally
  991.    {
  992.       if (keyblob) LocalFree(keyblob);
  994.       if (!fReturn)
  995.       {
  996.          if (*hPrivateKey) CryptDestroyKey(*hPrivateKey);
  997.          if (*hProv) CryptReleaseContext(*hProv, 0);
  998.       }
  999.    }
  1001.    return fReturn;
  1002. }
  1005. /*
  1006. %--------------------------------------------------------------------------
  1007. % ImportPlainSessionBlob
  1008. %
  1009. % ImportPlainSessionBlob is used to import a key of session in light in a provider
  1010. % microsoft
  1011. %
  1012. % Parameters of entry  :
  1013. % IN hProv handle to the provider
  1014. % IN hPrivateKey handle to the private key
  1015. % IN dwAlgId Algo ID
  1016. % IN pbKeyMaterial key
  1017. % IN dwKeyMaterial length of the key
  1018. % IN handle to the sessionKey
  1019. %  
  1020. % return : TRUE if the operation occurred well, FALSE if not
  1021. %---------------------------------------------------------------------------
  1022. */
  1023. BOOL HandleContainer::ImportPlainSessionBlob(HCRYPTPROV hProv,
  1024.                             HCRYPTKEY hPrivateKey,
  1025.                             ALG_ID dwAlgId,
  1026.                             LPBYTE pbKeyMaterial ,
  1027.                             DWORD dwKeyMaterial ,
  1028.                             HCRYPTKEY *hSessionKey)
  1029. {
  1030.    BOOL fResult;   
  1031.    BOOL fReturn = FALSE;
  1032.    BOOL fFound = FALSE;
  1033.    LPBYTE pbSessionBlob = NULL;
  1034.    DWORD dwSessionBlob, dwSize, n;
  1035.    DWORD dwPublicKeySize;
  1036.    DWORD dwProvSessionKeySize;
  1037.    ALG_ID dwPrivKeyAlg;
  1038.    LPBYTE pbPtr; 
  1039.    DWORD dwFlags = CRYPT_FIRST;
  1040.    PROV_ENUMALGS_EX ProvEnum;
  1041.    HCRYPTKEY hTempKey = 0;
  1044.   TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob BEGIN",NULL);
  1046.    __try
  1047.    {
  1048.       // Double check to see if this provider supports this algorithm
  1049.       // and key size
  1050.       do
  1051.       {        
  1052.          dwSize = sizeof(ProvEnum);
  1053.          fResult = CryptGetProvParam(hProv, PP_ENUMALGS_EX, (LPBYTE)&ProvEnum,
  1054.                                      &dwSize, dwFlags);
  1055.          if (!fResult) break;
  1057.          dwFlags = 0;
  1059.          if (ProvEnum.aiAlgid == dwAlgId) fFound = TRUE;
  1060.                                      
  1061.       } while (!fFound);
  1063.       if (!fFound){
  1064. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1065.   __leave;
  1066.   }
  1068.       // We have to get the key size(including padding)
  1069.       // from an HCRYPTKEY handle.  PP_ENUMALGS_EX contains
  1070.       // the key size without the padding so we can't use it.
  1071.   if(dwAlgId==CALG_RC2 && dwKeyMaterial==5)
  1072.   {
  1073.   fResult = CryptGenKey(hProv, dwAlgId, CRYPT_NO_SALT, &hTempKey);
  1074.   if (!fResult){
  1075.    TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1076.   __leave;
  1077.   }
  1078.   }
  1079.   else
  1080.   {
  1081.   fResult = CryptGenKey(hProv, dwAlgId, 0, &hTempKey);
  1082.   if (!fResult){
  1083. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1084.   __leave;
  1085.   }
  1086.   }
  1088.       /*fResult = CryptGenKey(hProv, dwAlgId, 0, &hTempKey);
  1089.       if (!fResult){
  1090. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1091.   __leave;
  1092.   }*/
  1093.       dwSize = sizeof(DWORD);
  1094.       fResult = CryptGetKeyParam(hTempKey, KP_KEYLEN, (LPBYTE)&dwProvSessionKeySize,
  1095.                                  &dwSize, 0);
  1096.       if (!fResult){
  1097. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1098.   __leave;
  1099.   }      
  1100.       CryptDestroyKey(hTempKey);
  1101.       hTempKey = 0;
  1103.       // Our key is too big, leave
  1104.       if ((dwKeyMaterial * 8) > dwProvSessionKeySize){
  1105. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1106.   __leave;
  1107.   }
  1109.       // Get private key's algorithm
  1110.       dwSize = sizeof(ALG_ID);
  1111.       fResult = CryptGetKeyParam(hPrivateKey, KP_ALGID, (LPBYTE)&dwPrivKeyAlg, &dwSize, 0);
  1112.       if (!fResult){
  1113. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1114.   __leave;
  1115.   }
  1117.       // Get private key's length in bits
  1118.       dwSize = sizeof(DWORD);
  1119.       fResult = CryptGetKeyParam(hPrivateKey, KP_KEYLEN, (LPBYTE)&dwPublicKeySize, &dwSize, 0);
  1120.       if (!fResult){
  1121. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1122.   __leave;
  1123.   }
  1125.       // calculate Simple blob's length
  1126.       dwSessionBlob = (dwPublicKeySize/8) + sizeof(ALG_ID) + sizeof(BLOBHEADER);
  1128.       // allocate simple blob buffer
  1129.       pbSessionBlob = (LPBYTE)LocalAlloc(LPTR, dwSessionBlob);
  1130.       if (!pbSessionBlob) {
  1131. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1132.   __leave;
  1133.   }
  1135.       pbPtr = pbSessionBlob;
  1137.       // SIMPLEBLOB Format is documented in SDK
  1138.       // Copy header to buffer
  1139.       ((BLOBHEADER *)pbPtr)->bType = SIMPLEBLOB;
  1140.       ((BLOBHEADER *)pbPtr)->bVersion = 2;
  1141.       ((BLOBHEADER *)pbPtr)->reserved = 0;
  1142.       ((BLOBHEADER *)pbPtr)->aiKeyAlg = dwAlgId;
  1143.       pbPtr += sizeof(BLOBHEADER);
  1145.       // Copy private key algorithm to buffer
  1146.       *((DWORD *)pbPtr) = dwPrivKeyAlg;
  1147.       pbPtr += sizeof(ALG_ID);
  1149.   
  1150.       // Place the key material in reverse order
  1151.       for (n = 0; n < dwKeyMaterial; n++)
  1152.       {
  1153.          pbPtr[n] = pbKeyMaterial[dwKeyMaterial-n-1];
  1154.       }
  1155.   
  1156.  
  1158.       // 3 is for the first reserved byte after the key material + the 2 reserved bytes at the end.
  1159.       dwSize = dwSessionBlob - (sizeof(ALG_ID) + sizeof(BLOBHEADER) + dwKeyMaterial+ 3);
  1160.       pbPtr +=dwKeyMaterial+1;
  1162.       // Generate random data for the rest of the buffer
  1163.       // (except that last two bytes)
  1164.       fResult = CryptGenRandom(hProv, dwSize, pbPtr);
  1165.       if (!fResult){
  1166. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1167.   __leave;
  1168.   }
  1170.       for (n = 0; n < dwSize; n++)
  1171.       {
  1172.          if (pbPtr[n] == 0) pbPtr[n] = 1;
  1173.       }
  1175.       pbSessionBlob[dwSessionBlob - 2] = 2;
  1177.   if(dwAlgId==CALG_RC2 && dwKeyMaterial==5)
  1178.   {
  1179.   TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob CALG RC2 40 Bits",NULL);
  1181.       fResult = CryptImportKey(hProv, pbSessionBlob , dwSessionBlob, 
  1182.                                hPrivateKey, CRYPT_EXPORTABLE|CRYPT_NO_SALT, hSessionKey);
  1183.   if (!fResult) {
  1184.    TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1185.   __leave;
  1186. }
  1187.   }
  1188.   else{
  1189.       fResult = CryptImportKey(hProv, pbSessionBlob , dwSessionBlob, 
  1190.                                hPrivateKey, CRYPT_EXPORTABLE, hSessionKey);
  1191.   if (!fResult) {
  1192.    TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1193.   __leave;
  1194. }
  1195.   }
  1198.      /*fResult = CryptImportKey(hProv, pbSessionBlob , dwSessionBlob, 
  1199.                                hPrivateKey, CRYPT_EXPORTABLE, hSessionKey);
  1200.       if (!fResult) {
  1201. TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob FALSE",NULL);
  1202.   __leave;
  1203.   }*/
  1205.   TRACE(__LINE__,"HandleContainer::ImportPlainSessionBlob TRUE",NULL);
  1206.       fReturn = TRUE;           
  1207.    }
  1208.    __finally
  1209.    {
  1210.       if (hTempKey) CryptDestroyKey(hTempKey);
  1211.       if (pbSessionBlob) LocalFree(pbSessionBlob);
  1212.    }
  1213.    
  1214.    return fReturn;
  1215. }
  1218. /*
  1219. %--------------------------------------------------------------------------
  1220. % ExportPlainSessionBlob
  1221. %
  1222. % ExportPlainSessionBlob is used to export a key of session in light
  1223. %
  1224. % Parameters of entry  :
  1225. % IN hPublicKey handle to the public key
  1226. % IN hSessionKey handle to the session key
  1227. % IN pbKeyMaterial key
  1228. % IN dwKeyMaterial length of the key
  1229. %  
  1230. % return : TRUE if the operation occurred well, FALSE if not
  1231. %---------------------------------------------------------------------------
  1232. */
  1233. BOOL HandleContainer::ExportPlainSessionBlob(HCRYPTKEY hPublicKey,
  1234.                             HCRYPTKEY hSessionKey,
  1235.                             LPBYTE *pbKeyMaterial ,
  1236.                             DWORD *dwKeyMaterial )
  1237. {
  1238.    BOOL fReturn = FALSE;
  1239.    BOOL fResult;
  1240.    DWORD dwSize, n;
  1241.    LPBYTE pbSessionBlob = NULL;
  1242.    DWORD dwSessionBlob;
  1243.    LPBYTE pbPtr;
  1245.    __try
  1246.    {
  1247.       *pbKeyMaterial  = NULL;
  1248.       *dwKeyMaterial  = 0;
  1250.       fResult = CryptExportKey(hSessionKey, hPublicKey, SIMPLEBLOB,
  1251.                                0, NULL, &dwSessionBlob );
  1252.       if (!fResult) __leave;
  1254.       pbSessionBlob  = (LPBYTE)LocalAlloc(LPTR, dwSessionBlob );
  1255.       if (!pbSessionBlob) __leave;
  1257.       fResult = CryptExportKey(hSessionKey, hPublicKey, SIMPLEBLOB,
  1258.                                0, pbSessionBlob , &dwSessionBlob );
  1259.       if (!fResult) __leave;
  1261.       // Get session key size in bits
  1262.       dwSize = sizeof(DWORD);
  1263.       fResult = CryptGetKeyParam(hSessionKey, KP_KEYLEN, (LPBYTE)dwKeyMaterial, &dwSize, 0);
  1264.       if (!fResult) __leave;
  1266.       // Get the number of bytes and allocate buffer
  1267.       *dwKeyMaterial /= 8;
  1268.       *pbKeyMaterial = (LPBYTE)LocalAlloc(LPTR, *dwKeyMaterial);
  1269.       if (!*pbKeyMaterial) __leave;
  1271.       // Skip the header
  1272.       pbPtr = pbSessionBlob;
  1273.       pbPtr += sizeof(BLOBHEADER);
  1274.       pbPtr += sizeof(ALG_ID);
  1276.       // We are at the beginning of the key
  1277.       // but we need to start at the end since 
  1278.       // it's reversed
  1279.       pbPtr += (*dwKeyMaterial - 1);
  1280.       
  1281.       // Copy the raw key into our return buffer      
  1282.       for (n = 0; n < *dwKeyMaterial; n++)
  1283.       {
  1284.          (*pbKeyMaterial)[n] = *pbPtr;
  1285.          pbPtr--;
  1286.       }      
  1287.       
  1288.       fReturn = TRUE;
  1289.    }
  1290.    __finally
  1291.    {
  1292.       if (pbSessionBlob) LocalFree(pbSessionBlob);
  1294.       if ((!fReturn) && (*pbKeyMaterial ))
  1295.       {
  1296.          LocalFree(*pbKeyMaterial );
  1297.          *pbKeyMaterial  = NULL;
  1298.          *dwKeyMaterial  = 0;
  1299.       }
  1300.    }
  1302.    return fReturn;
  1303. }