| blob | bfd119f87b5d3d46af48c15a1a7ae3607bc1f0e6 |
1 // This is a part of the Active Template Library.\r
2 // Copyright (C) Microsoft Corporation\r
3 // All rights reserved.\r
4 //\r
5 // This source code is only intended as a supplement to the\r
6 // Active Template Library Reference and related\r
7 // electronic documentation provided with the library.\r
8 // See these sources for detailed information regarding the\r
9 // Active Template Library product.\r
10 \r
11 \r
12 #ifndef __ATLCRYPT_INL__\r
13 #define __ATLCRYPT_INL__\r
14 \r
15 #pragma once\r
16 \r
17 #ifndef __ATLCRYPT_H__\r
18 #error atlcrypt.inl requires atlcrypt.h to be included first\r
19 #endif\r
20 \r
21 \r
22 namespace ATL\r
23 {\r
24 \r
25 inline CCryptProv::CCryptProv( const CCryptProv& prov ) throw()\r
26 {\r
27 m_hProv = prov.m_hProv;\r
28 if (m_hProv)\r
29 AddRef();\r
30 }\r
31 \r
32 inline CCryptProv::CCryptProv( HCRYPTPROV hProv, BOOL bTakeOwnership ) throw()\r
33 {\r
34 m_hProv = hProv;\r
35 if (m_hProv && !bTakeOwnership)\r
36 AddRef();\r
37 }\r
38 \r
39 inline CCryptProv::~CCryptProv() throw()\r
40 {\r
41 Release();\r
42 }\r
43 \r
44 inline CCryptProv& CCryptProv::operator=( const CCryptProv& prov ) throw()\r
45 {\r
46 if(this!=&prov)\r
47 {\r
48 Release();\r
49 \r
50 m_hProv = prov.m_hProv;\r
51 if( m_hProv != NULL )\r
52 {\r
53 AddRef();\r
54 }\r
55 }\r
56 return( *this );\r
57 }\r
58 \r
59 inline HRESULT CCryptProv::AddRef() throw()\r
60 {\r
61 ATLASSUME( m_hProv != NULL );\r
62 \r
63 if (!CryptContextAddRef( m_hProv, NULL, 0))\r
64 {\r
65 return AtlHresultFromLastError();\r
66 }\r
67 return S_OK;\r
68 }\r
69 \r
70 inline void CCryptProv::Attach( HCRYPTPROV hProv, BOOL bTakeOwnership ) throw()\r
71 {\r
72 ATLASSUME( m_hProv == NULL );\r
73 \r
74 m_hProv = hProv;\r
75 if (m_hProv && !bTakeOwnership)\r
76 AddRef();\r
77 }\r
78 \r
79 inline HCRYPTPROV CCryptProv::Detach() throw()\r
80 {\r
81 HCRYPTPROV hProv;\r
82 \r
83 hProv = m_hProv;\r
84 m_hProv = NULL;\r
85 \r
86 return( hProv );\r
87 }\r
88 \r
89 \r
90 inline CCryptProv::CCryptProv() throw() :\r
91 m_hProv( NULL )\r
92 {\r
93 }\r
94 \r
95 inline HRESULT CCryptProv::Release() throw()\r
96 {\r
97 if( m_hProv != NULL )\r
98 {\r
99 if (!CryptReleaseContext( m_hProv, 0 ))\r
100 {\r
101 return AtlHresultFromLastError();\r
102 }\r
103 m_hProv = NULL;\r
104 }\r
105 return S_OK;\r
106 }\r
107 \r
108 inline HRESULT CCryptProv::Initialize(\r
109 DWORD dwProviderType,\r
110 LPCTSTR szContainer,\r
111 LPCTSTR szProvider,\r
112 DWORD dwFlags) throw()\r
113 {\r
114 ATLASSUME(m_hProv == NULL);\r
115 \r
116 if (!CryptAcquireContext(&m_hProv, szContainer, szProvider, dwProviderType, dwFlags))\r
117 {\r
118 return AtlHresultFromLastError();\r
119 }\r
120 else return S_OK;\r
121 }\r
122 \r
123 inline HRESULT CCryptProv::InitVerifyContext(\r
124 DWORD dwProviderType,\r
125 LPCTSTR szProvider,\r
126 DWORD dwFlags) throw()\r
127 {\r
128 ATLASSUME(m_hProv == NULL);\r
129 \r
130 if (!CryptAcquireContext(&m_hProv, NULL, szProvider, dwProviderType, CRYPT_VERIFYCONTEXT | dwFlags))\r
131 {\r
132 return AtlHresultFromLastError();\r
133 }\r
134 else return S_OK;\r
135 }\r
136 \r
137 inline HRESULT CCryptProv::InitCreateKeySet(\r
138 DWORD dwProviderType,\r
139 LPCTSTR szContainer,\r
140 LPCTSTR szProvider, \r
141 DWORD dwFlags) throw()\r
142 {\r
143 ATLASSUME(m_hProv == NULL);\r
144 \r
145 if (!CryptAcquireContext(&m_hProv, szContainer, szProvider, dwProviderType, CRYPT_NEWKEYSET | dwFlags))\r
146 {\r
147 return AtlHresultFromLastError();\r
148 }\r
149 else return S_OK;\r
150 }\r
151 \r
152 inline HRESULT CCryptProv::DeleteKeySet(\r
153 DWORD dwProviderType,\r
154 LPCTSTR szContainer,\r
155 LPCTSTR szProvider,\r
156 DWORD dwFlags) throw()\r
157 {\r
158 HCRYPTPROV hProv = NULL;\r
159 if (!CryptAcquireContext(&hProv, szContainer, szProvider, dwProviderType, CRYPT_DELETEKEYSET | dwFlags))\r
160 {\r
161 return AtlHresultFromLastError();\r
162 }\r
163 else return S_OK;\r
164 }\r
165 \r
166 \r
167 inline HRESULT CCryptProv::Uninitialize() throw()\r
168 {\r
169 ATLASSUME(m_hProv != NULL);\r
170 \r
171 if (!CryptReleaseContext(m_hProv, 0))\r
172 {\r
173 return AtlHresultFromLastError();\r
174 }\r
175 else \r
176 {\r
177 m_hProv = NULL;\r
178 return S_OK;\r
179 }\r
180 }\r
181 \r
182 inline HRESULT CCryptProv::GetParam(DWORD dwParam, BYTE * pbData, DWORD * pdwDataLen, DWORD dwFlags) throw()\r
183 {\r
184 ATLASSUME(m_hProv != NULL);\r
185 \r
186 if (!CryptGetProvParam(m_hProv, dwParam, pbData, pdwDataLen, dwFlags))\r
187 {\r
188 return AtlHresultFromLastError();\r
189 }\r
190 else return S_OK;\r
191 }\r
192 \r
193 inline HRESULT CCryptProv::SetParam( DWORD dwParam, BYTE* pbData, DWORD dwFlags) throw()\r
194 {\r
195 ATLASSUME(m_hProv != NULL);\r
196 \r
197 if (!CryptSetProvParam(m_hProv, dwParam, pbData, dwFlags ))\r
198 {\r
199 return AtlHresultFromLastError();\r
200 }\r
201 else return S_OK;\r
202 }\r
203 \r
204 inline HRESULT CCryptProv::GetName(__out_bcount_part(*pdwLength, *pdwLength) LPSTR szBuf, __inout DWORD * pdwLength) throw()\r
205 {\r
206 return GetParam(PP_NAME, (BYTE *)szBuf, pdwLength);\r
207 }\r
208 \r
209 inline HRESULT CCryptProv::GetContainer(__out_bcount_part(*pdwLength, *pdwLength) LPSTR szBuf, __inout DWORD * pdwLength) throw()\r
210 {\r
211 return GetParam(PP_CONTAINER, (BYTE *)szBuf, pdwLength);\r
212 }\r
213 \r
214 inline HRESULT CCryptProv::GetImpType(DWORD * pdwImpType) throw()\r
215 {\r
216 DWORD dwLength = sizeof(DWORD);\r
217 return GetParam(PP_IMPTYPE, (BYTE *)pdwImpType, &dwLength);\r
218 }\r
219 \r
220 inline HRESULT CCryptProv::GetVersion(DWORD * pdwVersion) throw()\r
221 {\r
222 DWORD dwLength = sizeof(DWORD);\r
223 return GetParam(PP_VERSION, (BYTE *)pdwVersion, &dwLength);\r
224 }\r
225 \r
226 inline HRESULT CCryptProv::GetProvType(DWORD * pdwType) throw()\r
227 {\r
228 DWORD dwLength = sizeof(DWORD);\r
229 return GetParam(PP_PROVTYPE, (BYTE * )pdwType, &dwLength);\r
230 }\r
231 \r
232 inline HRESULT CCryptProv::GetSecurityDesc(SECURITY_INFORMATION * pSecInfo) throw()\r
233 {\r
234 DWORD dwSize = sizeof(SECURITY_INFORMATION);\r
235 return GetParam(PP_KEYSET_SEC_DESCR, (BYTE *)pSecInfo, &dwSize);\r
236 }\r
237 \r
238 inline HRESULT CCryptProv::SetSecurityDesc(SECURITY_INFORMATION SecInfo) throw()\r
239 {\r
240 return SetParam(PP_KEYSET_SEC_DESCR, (BYTE *)&SecInfo);\r
241 }\r
242 \r
243 inline HRESULT CCryptProv::GenRandom(ULONG nLength, BYTE* pbBuffer ) throw()\r
244 {\r
245 ATLASSUME(m_hProv != NULL);\r
246 \r
247 if (!CryptGenRandom( m_hProv, nLength, pbBuffer ))\r
248 {\r
249 return AtlHresultFromLastError();\r
250 }\r
251 \r
252 return S_OK;\r
253 }\r
254 \r
255 inline CCryptHash::CCryptHash() throw() :\r
256 m_hHash( NULL )\r
257 {\r
258 }\r
259 \r
260 inline CCryptHash::CCryptHash( const CCryptHash& hash ) throw()\r
261 {\r
262 m_hHash = hash.Duplicate();\r
263 }\r
264 \r
265 inline CCryptHash::CCryptHash( HCRYPTHASH hHash, BOOL bTakeOwnership ) throw()\r
266 {\r
267 if (bTakeOwnership)\r
268 m_hHash = hHash;\r
269 else\r
270 {\r
271 m_hHash = NULL;\r
272 BOOL bRet = ::CryptDuplicateHash( hHash, NULL, 0, &m_hHash );\r
273 if (!bRet)\r
274 m_hHash = NULL;\r
275 }\r
276 }\r
277 \r
278 inline CCryptHash::~CCryptHash() throw()\r
279 {\r
280 Destroy();\r
281 }\r
282 \r
283 inline void CCryptHash::Attach( HCRYPTHASH hHash, BOOL bTakeOwnership ) throw()\r
284 {\r
285 ATLASSUME( m_hHash == NULL );\r
286 \r
287 if (bTakeOwnership)\r
288 m_hHash = hHash;\r
289 else\r
290 {\r
291 m_hHash = NULL;\r
292 BOOL bRet = ::CryptDuplicateHash( hHash, NULL, 0, &m_hHash );\r
293 if (!bRet)\r
294 m_hHash = NULL;\r
295 }\r
296 }\r
297 \r
298 inline void CCryptHash::Destroy() throw()\r
299 {\r
300 if( m_hHash != NULL )\r
301 {\r
302 BOOL bSuccess;\r
303 \r
304 bSuccess = ::CryptDestroyHash( m_hHash );\r
305 \r
306 // can fail if the cryptographic service provider\r
307 // (managed by CCryptProv) has already been destroyed\r
308 ATLASSERT( bSuccess );\r
309 m_hHash = NULL;\r
310 }\r
311 }\r
312 \r
313 inline HCRYPTHASH CCryptHash::Detach() throw()\r
314 {\r
315 HCRYPTHASH hHash;\r
316 \r
317 hHash = m_hHash;\r
318 m_hHash = NULL;\r
319 \r
320 return hHash;\r
321 }\r
322 \r
323 inline HCRYPTHASH CCryptHash::Duplicate() const throw()\r
324 {\r
325 BOOL bSuccess;\r
326 HCRYPTHASH hHash;\r
327 \r
328 ATLASSUME( m_hHash != NULL );\r
329 \r
330 hHash = NULL;\r
331 bSuccess = ::CryptDuplicateHash( m_hHash, NULL, 0, &hHash );\r
332 if( !bSuccess )\r
333 {\r
334 return NULL;\r
335 }\r
336 \r
337 return hHash;\r
338 }\r
339 \r
340 inline HRESULT CCryptHash::Uninitialize() throw()\r
341 {\r
342 ATLASSUME(m_hHash != NULL);\r
343 \r
344 if (!CryptDestroyHash(m_hHash))\r
345 {\r
346 return AtlHresultFromLastError();\r
347 }\r
348 else \r
349 {\r
350 m_hHash = NULL;\r
351 return S_OK;\r
352 }\r
353 }\r
354 \r
355 inline HRESULT CCryptHash::Detach(HCRYPTHASH * phHash) throw()\r
356 {\r
357 ATLASSERT(phHash);\r
358 if (!phHash)\r
359 return E_INVALIDARG;\r
360 \r
361 *phHash = m_hHash;\r
362 m_hHash = NULL;\r
363 \r
364 return S_OK;\r
365 }\r
366 \r
367 inline HRESULT CCryptHash::AddData(const BYTE * pbData, DWORD dwDataLen, DWORD dwFlags) throw()\r
368 {\r
369 ATLASSUME(m_hHash != NULL);\r
370 \r
371 if (!CryptHashData(m_hHash, pbData, dwDataLen, dwFlags))\r
372 {\r
373 return AtlHresultFromLastError();\r
374 }\r
375 else return S_OK;\r
376 \r
377 }\r
378 \r
379 inline HRESULT CCryptHash::AddString(LPCTSTR szData, DWORD dwFlags) throw()\r
380 {\r
381 return AddData((BYTE *)szData, (DWORD)_tcslen(szData) * sizeof(TCHAR), dwFlags);\r
382 }\r
383 \r
384 inline HRESULT CCryptHash::GetParam(DWORD dwParam, BYTE * pbData, DWORD * pdwDataLen, DWORD dwFlags) throw()\r
385 {\r
386 ATLASSUME(m_hHash != NULL);\r
387 \r
388 if (!CryptGetHashParam(m_hHash, dwParam, pbData, pdwDataLen, dwFlags))\r
389 {\r
390 return AtlHresultFromLastError();\r
391 }\r
392 else return S_OK;\r
393 }\r
394 \r
395 inline HRESULT CCryptHash::SetParam(DWORD dwParam, BYTE * pbData, DWORD dwFlags) throw()\r
396 {\r
397 ATLASSUME(m_hHash != NULL);\r
398 \r
399 if (!CryptSetHashParam(m_hHash, dwParam, pbData, dwFlags))\r
400 {\r
401 return AtlHresultFromLastError();\r
402 }\r
403 else return S_OK;\r
404 }\r
405 \r
406 inline HRESULT CCryptHash::GetAlgId(ALG_ID * pAlgId) throw()\r
407 {\r
408 DWORD dwSize = sizeof(ALG_ID);\r
409 return GetParam(HP_ALGID, (BYTE *)pAlgId, &dwSize);\r
410 }\r
411 \r
412 inline HRESULT CCryptHash::GetSize(DWORD * pdwSize) throw()\r
413 {\r
414 DWORD dwLength = sizeof(DWORD);\r
415 return GetParam(HP_HASHSIZE, (BYTE *)pdwSize, &dwLength);\r
416 }\r
417 \r
418 inline HRESULT CCryptHash::GetValue(BYTE * pBuf, DWORD * pdwSize) throw()\r
419 {\r
420 return GetParam(HP_HASHVAL, pBuf, pdwSize);\r
421 }\r
422 \r
423 inline HRESULT CCryptHash::SetValue(BYTE * pBuf) throw()\r
424 {\r
425 return SetParam(HP_HASHVAL, pBuf);\r
426 }\r
427 \r
428 inline HRESULT CCryptHash::Sign(\r
429 BYTE * pbSignature,\r
430 DWORD * pdwSigLen,\r
431 DWORD dwFlags,\r
432 DWORD dwKeySpec) throw()\r
433 {\r
434 ATLASSUME(m_hHash != NULL);\r
435 \r
436 if (!CryptSignHash(m_hHash, dwKeySpec, NULL, dwFlags, pbSignature, pdwSigLen))\r
437 {\r
438 return AtlHresultFromLastError();\r
439 }\r
440 else return S_OK;\r
441 }\r
442 \r
443 inline HRESULT CCryptHash::VerifySignature(\r
444 const BYTE * pbSignature,\r
445 DWORD dwSigLen,\r
446 CCryptKey &PubKey,\r
447 DWORD dwFlags) throw()\r
448 {\r
449 ATLASSUME(m_hHash != NULL);\r
450 \r
451 if (!CryptVerifySignature(m_hHash, pbSignature, dwSigLen, PubKey.GetHandle(), NULL, dwFlags))\r
452 {\r
453 return AtlHresultFromLastError();\r
454 }\r
455 else return S_OK;\r
456 }\r
457 \r
458 __declspec(selectany) CCryptHash CCryptHash::EmptyHash = CCryptHash();\r
459 __declspec(selectany) CCryptKey CCryptKey::EmptyKey = CCryptKey();\r
460 inline CCryptKey::CCryptKey() throw() :\r
461 m_hKey( NULL )\r
462 {\r
463 }\r
464 \r
465 inline CCryptKey::CCryptKey( const CCryptKey& key ) throw()\r
466 {\r
467 m_hKey = key.Duplicate();\r
468 }\r
469 \r
470 inline CCryptKey::CCryptKey( HCRYPTKEY hKey, BOOL bTakeOwnership ) throw()\r
471 {\r
472 if (bTakeOwnership)\r
473 m_hKey = hKey;\r
474 else\r
475 {\r
476 BOOL bSuccess = ::CryptDuplicateKey( hKey, NULL, 0, &m_hKey );\r
477 if( !bSuccess )\r
478 m_hKey = NULL;\r
479 }\r
480 }\r
481 \r
482 inline CCryptKey::~CCryptKey() throw()\r
483 {\r
484 Destroy();\r
485 }\r
486 \r
487 inline void CCryptKey::Attach( HCRYPTKEY hKey, BOOL bTakeOwnership ) throw()\r
488 {\r
489 ATLASSUME( m_hKey == NULL );\r
490 if (bTakeOwnership)\r
491 m_hKey = hKey;\r
492 else\r
493 {\r
494 BOOL bSuccess = ::CryptDuplicateKey( hKey, NULL, 0, &m_hKey );\r
495 if( !bSuccess )\r
496 m_hKey = NULL;\r
497 }\r
498 }\r
499 \r
500 inline void CCryptKey::Destroy() throw()\r
501 {\r
502 if( m_hKey != NULL )\r
503 {\r
504 BOOL bSuccess;\r
505 \r
506 bSuccess = ::CryptDestroyKey( m_hKey );\r
507 \r
508 // can fail if the cryptographic service provider\r
509 // (managed by CCryptProv) has already been destroyed\r
510 ATLASSERT( bSuccess );\r
511 m_hKey = NULL;\r
512 }\r
513 }\r
514 \r
515 inline HCRYPTKEY CCryptKey::Detach() throw()\r
516 {\r
517 HCRYPTKEY hKey;\r
518 \r
519 hKey = m_hKey;\r
520 m_hKey = NULL;\r
521 \r
522 return( hKey );\r
523 }\r
524 \r
525 inline HCRYPTKEY CCryptKey::Duplicate() const throw()\r
526 {\r
527 BOOL bSuccess;\r
528 \r
529 ATLASSUME( m_hKey != NULL );\r
530 \r
531 HCRYPTKEY hKey = NULL;\r
532 bSuccess = ::CryptDuplicateKey( m_hKey, NULL, 0, &hKey );\r
533 if( !bSuccess )\r
534 return NULL;\r
535 \r
536 return hKey;\r
537 }\r
538 \r
539 inline HRESULT CCryptKey::Uninitialize() throw()\r
540 {\r
541 ATLASSUME(m_hKey != NULL);\r
542 \r
543 if (!CryptDestroyKey(m_hKey))\r
544 {\r
545 return AtlHresultFromLastError();\r
546 }\r
547 else \r
548 {\r
549 m_hKey = NULL;\r
550 return S_OK;\r
551 }\r
552 } \r
553 \r
554 inline HRESULT CCryptKey::Encrypt(\r
555 BOOL final,\r
556 BYTE * pbData,\r
557 DWORD * pdwDataLen,\r
558 DWORD dwBufLen,\r
559 CCryptHash &Hash) throw()\r
560 {\r
561 ATLASSUME(m_hKey != NULL);\r
562 \r
563 if (!::CryptEncrypt(m_hKey, Hash.GetHandle(), final, 0, pbData, pdwDataLen, dwBufLen))\r
564 {\r
565 return AtlHresultFromLastError();\r
566 }\r
567 else return S_OK;\r
568 \r
569 }\r
570 \r
571 inline HRESULT CCryptKey::Decrypt(BOOL final, BYTE * pbData, DWORD * pdwDataLen, CCryptHash &Hash) throw()\r
572 {\r
573 ATLASSUME(m_hKey != NULL);\r
574 \r
575 if (!::CryptDecrypt(m_hKey, Hash.GetHandle(), final, 0, pbData, pdwDataLen))\r
576 {\r
577 return AtlHresultFromLastError();\r
578 }\r
579 else return S_OK;\r
580 }\r
581 \r
582 \r
583 inline HRESULT CCryptKey::Encrypt(\r
584 const BYTE * pbPlainText,\r
585 DWORD dwPlainTextLen,\r
586 BYTE * pbCipherText,\r
587 DWORD * pdwCipherTextLen,\r
588 CCryptHash &Hash) throw()\r
589 {\r
590 ATLASSUME(m_hKey != NULL);\r
591 \r
592 if (*pdwCipherTextLen < dwPlainTextLen)\r
593 return ERROR_MORE_DATA;\r
594 \r
595 Checked::memcpy_s(pbCipherText, dwPlainTextLen, pbPlainText, dwPlainTextLen);\r
596 DWORD dwSize = dwPlainTextLen;\r
597 if (!::CryptEncrypt(m_hKey, Hash.GetHandle(), TRUE, 0, pbCipherText, &dwSize, *pdwCipherTextLen))\r
598 {\r
599 return AtlHresultFromLastError();\r
600 }\r
601 \r
602 *pdwCipherTextLen = dwSize;\r
603 return S_OK;\r
604 \r
605 }\r
606 \r
607 inline HRESULT CCryptKey::Decrypt(\r
608 const BYTE * pbCipherText,\r
609 DWORD dwCipherTextLen,\r
610 BYTE * pbPlainText,\r
611 DWORD * pdwPlainTextLen,\r
612 CCryptHash &Hash) throw()\r
613 {\r
614 ATLASSUME(m_hKey != NULL);\r
615 \r
616 if (*pdwPlainTextLen < dwCipherTextLen)\r
617 return ERROR_MORE_DATA;\r
618 \r
619 Checked::memcpy_s(pbPlainText, dwCipherTextLen, pbCipherText, dwCipherTextLen);\r
620 DWORD dwSize = dwCipherTextLen;\r
621 if (!::CryptDecrypt(m_hKey, Hash.GetHandle(), TRUE, 0, pbPlainText, &dwSize))\r
622 {\r
623 return AtlHresultFromLastError();\r
624 }\r
625 \r
626 *pdwPlainTextLen = dwSize;\r
627 return S_OK;\r
628 }\r
629 \r
630 inline HRESULT CCryptKey::EncryptString(\r
631 LPCTSTR szPlainText,\r
632 BYTE * pbCipherText,\r
633 DWORD * pdwCipherTextLen,\r
634 CCryptHash &Hash) throw()\r
635 {\r
636 DWORD dwSize = ((DWORD)_tcslen(szPlainText) + 1) * sizeof(TCHAR);\r
637 return Encrypt((BYTE *)szPlainText, dwSize, pbCipherText, pdwCipherTextLen, Hash);\r
638 }\r
639 \r
640 inline HRESULT CCryptKey::ExportSimpleBlob(\r
641 CCryptKey &ExpKey,\r
642 DWORD dwFlags,\r
643 BYTE * pbData,\r
644 DWORD * pdwDataLen) throw()\r
645 {\r
646 ATLASSUME(m_hKey != NULL);\r
647 \r
648 if (!CryptExportKey(m_hKey, ExpKey.GetHandle(), SIMPLEBLOB, dwFlags, pbData, pdwDataLen))\r
649 {\r
650 return AtlHresultFromLastError();\r
651 }\r
652 else return S_OK;\r
653 }\r
654 \r
655 inline HRESULT CCryptKey::ExportPublicKeyBlob(\r
656 CCryptKey &ExpKey,\r
657 DWORD dwFlags,\r
658 BYTE * pbData,\r
659 DWORD * pdwDataLen) throw()\r
660 {\r
661 ATLASSUME(m_hKey != NULL);\r
662 \r
663 if (!CryptExportKey(m_hKey, ExpKey.GetHandle(), PUBLICKEYBLOB, dwFlags, pbData, pdwDataLen))\r
664 {\r
665 return AtlHresultFromLastError();\r
666 }\r
667 else return S_OK;\r
668 }\r
669 \r
670 inline HRESULT CCryptKey::ExportPrivateKeyBlob(\r
671 CCryptKey &ExpKey,\r
672 DWORD dwFlags,\r
673 BYTE * pbData,\r
674 DWORD * pdwDataLen) throw()\r
675 {\r
676 ATLASSUME(m_hKey != NULL);\r
677 \r
678 if (!CryptExportKey(m_hKey, ExpKey.GetHandle(), PRIVATEKEYBLOB, dwFlags, pbData, pdwDataLen))\r
679 {\r
680 return AtlHresultFromLastError();\r
681 }\r
682 else return S_OK;\r
683 }\r
684 \r
685 inline HRESULT CCryptKey::GetParam(DWORD dwParam, BYTE * pbData, DWORD * pdwDataLen, DWORD dwFlags) throw()\r
686 {\r
687 ATLASSUME(m_hKey != NULL);\r
688 \r
689 if (!CryptGetKeyParam(m_hKey, dwParam, pbData, pdwDataLen, dwFlags))\r
690 {\r
691 return AtlHresultFromLastError();\r
692 }\r
693 else return S_OK;\r
694 }\r
695 \r
696 inline HRESULT CCryptKey::SetParam(DWORD dwParam, BYTE * pbData, DWORD dwFlags) throw()\r
697 {\r
698 ATLASSUME(m_hKey != NULL);\r
699 \r
700 if (!CryptSetKeyParam(m_hKey, dwParam, pbData, dwFlags))\r
701 {\r
702 return AtlHresultFromLastError();\r
703 }\r
704 else return S_OK;\r
705 }\r
706 \r
707 inline HRESULT CCryptKey::GetAlgId(ALG_ID * pAlgId) throw()\r
708 {\r
709 DWORD dwSize = sizeof(DWORD);\r
710 return GetParam(KP_ALGID, (BYTE *)pAlgId, &dwSize);\r
711 }\r
712 \r
713 inline HRESULT CCryptKey::SetAlgId(ALG_ID AlgId, DWORD dwFlags) throw()\r
714 {\r
715 return SetParam(KP_ALGID, (BYTE *)&AlgId, dwFlags);\r
716 }\r
717 \r
718 inline HRESULT CCryptKey::GetBlockLength(DWORD * pdwBlockLen) throw()\r
719 {\r
720 DWORD dwSize = sizeof(DWORD);\r
721 return GetParam(KP_BLOCKLEN, (BYTE *)pdwBlockLen, &dwSize);\r
722 }\r
723 \r
724 inline HRESULT CCryptKey::GetKeyLength(DWORD * pdwKeyLen) throw()\r
725 {\r
726 DWORD dwSize = sizeof(DWORD);\r
727 return GetParam(KP_KEYLEN, (BYTE *)pdwKeyLen, &dwSize);\r
728 }\r
729 \r
730 inline HRESULT CCryptKey::GetSalt(BYTE * pbSalt, DWORD * pdwLength) throw()\r
731 {\r
732 return GetParam(KP_SALT, pbSalt, pdwLength);\r
733 }\r
734 \r
735 inline HRESULT CCryptKey::SetSalt(BYTE * pbSalt) throw()\r
736 {\r
737 return SetParam(KP_SALT, pbSalt);\r
738 }\r
739 \r
740 inline HRESULT CCryptKey::SetSaltEx(_CRYPTOAPI_BLOB * pBlobSalt) throw()\r
741 {\r
742 return SetParam(KP_SALT_EX, (BYTE *)pBlobSalt);\r
743 }\r
744 \r
745 inline HRESULT CCryptKey::GetPermissions(DWORD * pdwPerms) throw()\r
746 {\r
747 DWORD dwSize = sizeof(DWORD);\r
748 return GetParam(KP_PERMISSIONS, (BYTE *)pdwPerms, &dwSize);\r
749 }\r
750 \r
751 inline HRESULT CCryptKey::SetPermissions(DWORD dwPerms) throw()\r
752 {\r
753 return SetParam(KP_PERMISSIONS, (BYTE *)&dwPerms);\r
754 }\r
755 \r
756 inline HRESULT CCryptKey::GetP(BYTE * pbP, DWORD * pdwLength) throw()\r
757 {\r
758 return GetParam(KP_P, (BYTE *)pbP, pdwLength);\r
759 }\r
760 \r
761 inline HRESULT CCryptKey::SetP(_CRYPTOAPI_BLOB * pBlobP) throw()\r
762 {\r
763 return SetParam(KP_P, (BYTE *)pBlobP);\r
764 }\r
765 \r
766 inline HRESULT CCryptKey::SetP(BYTE * pbP, DWORD dwLength) throw()\r
767 {\r
768 _CRYPTOAPI_BLOB blob = { dwLength, pbP };\r
769 return SetParam(KP_P, (BYTE *)&blob);\r
770 }\r
771 \r
772 inline HRESULT CCryptKey::GetQ(BYTE * pbQ, DWORD * pdwLength) throw()\r
773 {\r
774 return GetParam(KP_Q, (BYTE *)pbQ, pdwLength);\r
775 }\r
776 \r
777 inline HRESULT CCryptKey::SetQ(_CRYPTOAPI_BLOB * pBlobQ) throw()\r
778 {\r
779 return SetParam(KP_Q, (BYTE *)pBlobQ);\r
780 }\r
781 \r
782 inline HRESULT CCryptKey::SetQ(BYTE * pbQ, DWORD dwLength) throw()\r
783 {\r
784 _CRYPTOAPI_BLOB blob = { dwLength, pbQ };\r
785 return SetParam(KP_Q, (BYTE *)&blob);\r
786 }\r
787 \r
788 inline HRESULT CCryptKey::GetG(BYTE * pbG, DWORD * pdwLength) throw()\r
789 {\r
790 return GetParam(KP_G, (BYTE *)pbG, pdwLength);\r
791 }\r
792 \r
793 inline HRESULT CCryptKey::SetG(_CRYPTOAPI_BLOB * pBlobG) throw()\r
794 {\r
795 return SetParam(KP_G, (BYTE *)pBlobG);\r
796 }\r
797 \r
798 inline HRESULT CCryptKey::SetG(BYTE * pbG, DWORD dwLength) throw()\r
799 {\r
800 _CRYPTOAPI_BLOB blob = { dwLength, pbG };\r
801 return SetParam(KP_G, (BYTE *)&blob);\r
802 }\r
803 \r
804 inline HRESULT CCryptKey::SetX() throw()\r
805 {\r
806 return SetParam(KP_X, NULL);\r
807 }\r
808 \r
809 inline HRESULT CCryptKey::GetEffKeyLen(DWORD * pdwEffKeyLen) throw()\r
810 {\r
811 DWORD dwSize = sizeof(DWORD);\r
812 return GetParam(KP_EFFECTIVE_KEYLEN, (BYTE *)pdwEffKeyLen, &dwSize);\r
813 }\r
814 \r
815 inline HRESULT CCryptKey::SetEffKeyLen(DWORD dwEffKeyLen) throw()\r
816 {\r
817 return SetParam(KP_EFFECTIVE_KEYLEN, (BYTE *)&dwEffKeyLen);\r
818 }\r
819 \r
820 inline HRESULT CCryptKey::GetPadding(DWORD * pdwPadding) throw()\r
821 {\r
822 DWORD dwSize = sizeof(DWORD);\r
823 return GetParam(KP_PADDING, (BYTE *)pdwPadding, &dwSize);\r
824 }\r
825 \r
826 inline HRESULT CCryptKey::SetPadding(DWORD dwPadding) throw()\r
827 {\r
828 return SetParam(KP_PADDING, (BYTE *)&dwPadding);\r
829 }\r
830 \r
831 inline HRESULT CCryptKey::GetIV(BYTE * pbIV, DWORD * pdwLength) throw()\r
832 {\r
833 return GetParam(KP_IV, pbIV, pdwLength);\r
834 }\r
835 \r
836 inline HRESULT CCryptKey::SetIV(BYTE * pbIV) throw()\r
837 {\r
838 return SetParam(KP_IV, pbIV);\r
839 }\r
840 \r
841 inline HRESULT CCryptKey::GetMode(DWORD * pdwMode) throw()\r
842 {\r
843 DWORD dwSize = sizeof(DWORD);\r
844 return GetParam(KP_MODE, (BYTE *)pdwMode, &dwSize);\r
845 }\r
846 \r
847 inline HRESULT CCryptKey::SetMode(DWORD dwMode) throw()\r
848 {\r
849 return SetParam(KP_MODE, (BYTE *)&dwMode);\r
850 }\r
851 \r
852 inline HRESULT CCryptKey::GetModeBits(DWORD * pdwModeBits) throw()\r
853 {\r
854 DWORD dwSize = sizeof(DWORD);\r
855 return GetParam(KP_MODE_BITS, (BYTE *)pdwModeBits, &dwSize);\r
856 }\r
857 \r
858 inline HRESULT CCryptKey::SetModeBits(DWORD dwModeBits) throw()\r
859 {\r
860 return SetParam(KP_MODE_BITS, (BYTE *)&dwModeBits);\r
861 }\r
862 \r
863 inline HRESULT CCryptDerivedKey::Initialize(\r
864 CCryptProv &Prov,\r
865 CCryptHash &Hash,\r
866 ALG_ID algid,\r
867 DWORD dwFlags) throw()\r
868 {\r
869 ATLASSUME(m_hKey == NULL);\r
870 \r
871 if (!CryptDeriveKey(Prov.GetHandle(), algid, Hash.GetHandle(), dwFlags, &m_hKey))\r
872 {\r
873 return AtlHresultFromLastError();\r
874 }\r
875 else return S_OK;\r
876 }\r
877 \r
878 inline HRESULT CCryptRandomKey::Initialize(CCryptProv &Prov, ALG_ID algid, DWORD dwFlags) throw()\r
879 {\r
880 ATLASSUME(m_hKey == NULL);\r
881 \r
882 if (!CryptGenKey(Prov.GetHandle(), algid, dwFlags, &m_hKey))\r
883 {\r
884 return AtlHresultFromLastError();\r
885 }\r
886 else return S_OK;\r
887 \r
888 }\r
889 \r
890 inline HRESULT CCryptUserExKey::Initialize(CCryptProv &Prov) throw()\r
891 {\r
892 ATLASSUME(m_hKey == NULL);\r
893 \r
894 if (!CryptGetUserKey(Prov.GetHandle(), AT_KEYEXCHANGE, &m_hKey))\r
895 {\r
896 return AtlHresultFromLastError();\r
897 }\r
898 else return S_OK;\r
899 }\r
900 \r
901 inline HRESULT CCryptUserExKey::Create(CCryptProv &Prov) throw()\r
902 {\r
903 ATLASSUME(m_hKey == NULL);\r
904 \r
905 if (!CryptGenKey(Prov.GetHandle(), AT_KEYEXCHANGE, 0, &m_hKey))\r
906 {\r
907 return AtlHresultFromLastError();\r
908 }\r
909 else return S_OK;\r
910 }\r
911 \r
912 inline HRESULT CCryptUserSigKey::Initialize(CCryptProv &Prov) throw()\r
913 {\r
914 ATLASSUME(m_hKey == NULL);\r
915 \r
916 if (!CryptGetUserKey(Prov.GetHandle(), AT_SIGNATURE, &m_hKey))\r
917 {\r
918 return AtlHresultFromLastError();\r
919 }\r
920 else return S_OK;\r
921 }\r
922 \r
923 inline HRESULT CCryptUserSigKey::Create(CCryptProv &Prov) throw()\r
924 {\r
925 ATLASSUME(m_hKey == NULL);\r
926 \r
927 if (!CryptGenKey(Prov.GetHandle(), AT_SIGNATURE, 0, &m_hKey))\r
928 {\r
929 return AtlHresultFromLastError();\r
930 }\r
931 else return S_OK;\r
932 }\r
933 \r
934 inline HRESULT CCryptImportKey::Initialize(\r
935 CCryptProv &Prov,\r
936 BYTE * pbData,\r
937 DWORD dwDataLen,\r
938 CCryptKey &PubKey,\r
939 DWORD dwFlags) throw()\r
940 {\r
941 ATLASSUME(m_hKey == NULL);\r
942 \r
943 if (!CryptImportKey(Prov.GetHandle(), pbData, dwDataLen, PubKey.GetHandle(), dwFlags, &m_hKey))\r
944 {\r
945 return AtlHresultFromLastError();\r
946 }\r
947 else return S_OK;\r
948 }\r
949 \r
950 inline HRESULT CCryptKeyedHash::Initialize(\r
951 CCryptProv &Prov,\r
952 ALG_ID Algid,\r
953 CCryptKey &Key,\r
954 DWORD dwFlags) throw()\r
955 {\r
956 ATLASSUME(m_hHash == NULL);\r
957 \r
958 if (!CryptCreateHash(Prov.GetHandle(), Algid, Key.GetHandle(), dwFlags, &m_hHash))\r
959 {\r
960 return AtlHresultFromLastError();\r
961 }\r
962 else return S_OK;\r
963 }\r
964 \r
965 inline HRESULT CCryptMD5Hash::Initialize(CCryptProv &Prov, LPCTSTR szText) throw()\r
966 {\r
967 ATLASSUME(m_hHash == NULL);\r
968 \r
969 if (!CryptCreateHash(Prov.GetHandle(), CALG_MD5, 0, 0, &m_hHash))\r
970 {\r
971 return AtlHresultFromLastError();\r
972 }\r
973 \r
974 if (szText!=NULL)\r
975 return AddString(szText);\r
976 else return S_OK;\r
977 }\r
978 \r
979 inline HRESULT CCryptMD4Hash::Initialize(CCryptProv &Prov, LPCTSTR szText) throw()\r
980 {\r
981 ATLASSUME(m_hHash == NULL);\r
982 \r
983 if (!CryptCreateHash(Prov.GetHandle(), CALG_MD4, 0, 0, &m_hHash))\r
984 {\r
985 return AtlHresultFromLastError();\r
986 }\r
987 if (szText!=NULL)\r
988 return AddString(szText);\r
989 else return S_OK;\r
990 }\r
991 \r
992 inline HRESULT CCryptMD2Hash::Initialize(CCryptProv &Prov, LPCTSTR szText) throw()\r
993 {\r
994 ATLASSUME(m_hHash == NULL);\r
995 \r
996 if (!CryptCreateHash(Prov.GetHandle(), CALG_MD2, 0, 0, &m_hHash))\r
997 {\r
998 return AtlHresultFromLastError();\r
999 }\r
1000 if (szText!=NULL)\r
1001 return AddString(szText);\r
1002 else return S_OK;\r
1003 }\r
1004 \r
1005 inline HRESULT CCryptSHAHash::Initialize(CCryptProv &Prov, LPCTSTR szText) throw()\r
1006 {\r
1007 ATLASSUME(m_hHash == NULL);\r
1008 \r
1009 if (!CryptCreateHash(Prov.GetHandle(), CALG_SHA, 0, 0, &m_hHash))\r
1010 {\r
1011 return AtlHresultFromLastError();\r
1012 }\r
1013 if (szText!=NULL)\r
1014 return AddString(szText);\r
1015 else return S_OK;\r
1016 }\r
1017 \r
1018 inline HRESULT CCryptHMACHash::Initialize(CCryptProv &Prov, CCryptKey &Key, LPCTSTR szText) throw()\r
1019 {\r
1020 ATLASSUME(m_hHash == NULL);\r
1021 \r
1022 if (!CryptCreateHash(Prov.GetHandle(), CALG_HMAC, Key.GetHandle(), 0, &m_hHash))\r
1023 {\r
1024 return AtlHresultFromLastError();\r
1025 }\r
1026 if (szText!=NULL)\r
1027 return AddString(szText);\r
1028 else return S_OK;\r
1029 \r
1030 }\r
1031 \r
1032 inline HRESULT CCryptMACHash::Initialize(CCryptProv &Prov, CCryptKey &Key, LPCTSTR szText) throw()\r
1033 {\r
1034 ATLASSUME(m_hHash == NULL);\r
1035 \r
1036 if (!CryptCreateHash(Prov.GetHandle(), CALG_MAC, Key.GetHandle(), 0, &m_hHash))\r
1037 {\r
1038 return AtlHresultFromLastError();\r
1039 }\r
1040 if (szText!=NULL)\r
1041 return AddString(szText);\r
1042 else return S_OK;\r
1043 \r
1044 }\r
1045 \r
1046 inline HRESULT CCryptSSL3SHAMD5Hash::Initialize(CCryptProv &Prov, CCryptKey &Key, LPCTSTR szText) throw()\r
1047 {\r
1048 ATLASSUME(m_hHash == NULL);\r
1049 \r
1050 if (!CryptCreateHash(Prov.GetHandle(), CALG_SSL3_SHAMD5, Key.GetHandle(), 0, &m_hHash))\r
1051 {\r
1052 return AtlHresultFromLastError();\r
1053 }\r
1054 if (szText!=NULL)\r
1055 return AddString(szText);\r
1056 else return S_OK;\r
1057 \r
1058 }\r
1059 \r
1060 }; // namespace ATL\r
1061 \r
1062 #endif //__ATLCRYPT_INL__\r