[SDK] Added atlex for future use
[reactos.git] / reactos / sdk / include / reactos / atlex / atlcrypt.h
1 /*
2 Copyright 1991-2017 Amebis
3
4 This file is part of atlex.
5
6 Setup is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
10
11 Setup is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with Setup. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #pragma once
21
22 #include "atlex.h"
23 #include <atlcoll.h>
24 #include <atlstr.h>
25 #include <WinCrypt.h>
26
27 ///
28 /// \defgroup ATLCryptoAPI Cryptography API
29 /// Integrates ATL classes with Microsoft Cryptography API
30 ///
31 /// @{
32
33 ///
34 /// Obtains the subject or issuer name from a certificate [CERT_CONTEXT](https://msdn.microsoft.com/en-us/library/windows/desktop/aa377189.aspx) structure and stores it in a ATL::CAtlStringA string.
35 ///
36 /// \sa [CertGetNameString function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376086.aspx)
37 ///
38 inline DWORD CertGetNameStringA(_In_ PCCERT_CONTEXT pCertContext, _In_ DWORD dwType, _In_ DWORD dwFlags, _In_ void *pvTypePara, _Out_ ATL::CAtlStringA &sNameString)
39 {
40 // Query the final string length first.
41 DWORD dwSize = ::CertGetNameStringA(pCertContext, dwType, dwFlags, pvTypePara, NULL, 0);
42
43 // Allocate buffer on heap to format the string data into and read it.
44 LPSTR szBuffer = sNameString.GetBuffer(dwSize);
45 if (!szBuffer) return ERROR_OUTOFMEMORY;
46 dwSize = ::CertGetNameStringA(pCertContext, dwType, dwFlags, pvTypePara, szBuffer, dwSize);
47 sNameString.ReleaseBuffer(dwSize);
48 return dwSize;
49 }
50
51
52 ///
53 /// Obtains the subject or issuer name from a certificate [CERT_CONTEXT](https://msdn.microsoft.com/en-us/library/windows/desktop/aa377189.aspx) structure and stores it in a ATL::CAtlStringW string.
54 ///
55 /// \sa [CertGetNameString function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376086.aspx)
56 ///
57 inline DWORD CertGetNameStringW(_In_ PCCERT_CONTEXT pCertContext, _In_ DWORD dwType, _In_ DWORD dwFlags, _In_ void *pvTypePara, _Out_ ATL::CAtlStringW &sNameString)
58 {
59 // Query the final string length first.
60 DWORD dwSize = ::CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara, NULL, 0);
61
62 // Allocate buffer on heap to format the string data into and read it.
63 LPWSTR szBuffer = sNameString.GetBuffer(dwSize);
64 if (!szBuffer) return ERROR_OUTOFMEMORY;
65 dwSize = ::CertGetNameStringW(pCertContext, dwType, dwFlags, pvTypePara, szBuffer, dwSize);
66 sNameString.ReleaseBuffer(dwSize);
67 return dwSize;
68 }
69
70
71 ///
72 /// Retrieves data that governs the operations of a hash object. The actual hash value can be retrieved by using this function.
73 ///
74 /// \sa [CryptGetHashParam function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379947.aspx)
75 ///
76 inline BOOL CryptGetHashParam(_In_ HCRYPTHASH hHash, _In_ DWORD dwParam, _Out_ ATL::CAtlArray<BYTE> &aData, _In_ DWORD dwFlags)
77 {
78 DWORD dwHashSize;
79
80 if (CryptGetHashParam(hHash, dwParam, NULL, &dwHashSize, dwFlags)) {
81 if (aData.SetCount(dwHashSize)) {
82 if (CryptGetHashParam(hHash, dwParam, aData.GetData(), &dwHashSize, dwFlags)) {
83 return TRUE;
84 } else {
85 aData.SetCount(0);
86 return FALSE;
87 }
88 } else {
89 SetLastError(ERROR_OUTOFMEMORY);
90 return FALSE;
91 }
92 } else
93 return FALSE;
94 }
95
96
97 ///
98 /// Exports a cryptographic key or a key pair from a cryptographic service provider (CSP) in a secure manner.
99 ///
100 /// \sa [CryptExportKey function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379931.aspx)
101 ///
102 inline BOOL CryptExportKey(_In_ HCRYPTKEY hKey, _In_ HCRYPTKEY hExpKey, _In_ DWORD dwBlobType, _In_ DWORD dwFlags, _Out_ ATL::CAtlArray<BYTE> &aData)
103 {
104 DWORD dwKeyBLOBSize;
105
106 if (CryptExportKey(hKey, hExpKey, dwBlobType, dwFlags, NULL, &dwKeyBLOBSize)) {
107 if (aData.SetCount(dwKeyBLOBSize)) {
108 if (CryptExportKey(hKey, hExpKey, dwBlobType, dwFlags, aData.GetData(), &dwKeyBLOBSize)) {
109 return TRUE;
110 } else {
111 aData.SetCount(0);
112 return FALSE;
113 }
114 } else {
115 SetLastError(ERROR_OUTOFMEMORY);
116 return FALSE;
117 }
118 } else
119 return FALSE;
120 }
121
122 /// @}
123
124
125 namespace ATL
126 {
127 namespace Crypt
128 {
129 /// \addtogroup ATLCryptoAPI
130 /// @{
131
132 ///
133 /// PCCERT_CONTEXT wrapper class
134 ///
135 class CCertContext : public ATL::CObjectWithHandleDuplT<PCCERT_CONTEXT>
136 {
137 public:
138 ///
139 /// Destroys the certificate context.
140 ///
141 /// \sa [CertFreeCertificateContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376075.aspx)
142 ///
143 virtual ~CCertContext()
144 {
145 if (m_h)
146 CertFreeCertificateContext(m_h);
147 }
148
149 ///
150 /// Creates the certificate context.
151 ///
152 /// \return
153 /// - TRUE when creation succeeds;
154 /// - FALSE when creation fails. For extended error information, call `GetLastError()`.
155 /// \sa [CertCreateCertificateContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376033.aspx)
156 ///
157 inline BOOL Create(_In_ DWORD dwCertEncodingType, _In_ const BYTE *pbCertEncoded, _In_ DWORD cbCertEncoded)
158 {
159 HANDLE h = CertCreateCertificateContext(dwCertEncodingType, pbCertEncoded, cbCertEncoded);
160 if (h) {
161 Attach(h);
162 return TRUE;
163 } else
164 return FALSE;
165 }
166
167 protected:
168 ///
169 /// Destroys the certificate context.
170 ///
171 /// \sa [CertFreeCertificateContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376075.aspx)
172 ///
173 virtual void InternalFree()
174 {
175 CertFreeCertificateContext(m_h);
176 }
177
178 ///
179 /// Duplicates the certificate context.
180 ///
181 /// \param[in] h Object handle of existing certificate context
182 /// \return Duplicated certificate context handle
183 /// \sa [CertDuplicateCertificateContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376045.aspx)
184 ///
185 virtual HANDLE InternalDuplicate(_In_ HANDLE h) const
186 {
187 return CertDuplicateCertificateContext(h);
188 }
189 };
190
191
192 ///
193 /// PCCERT_CHAIN_CONTEXT wrapper class
194 ///
195 class CCertChainContext : public ATL::CObjectWithHandleDuplT<PCCERT_CHAIN_CONTEXT>
196 {
197 public:
198 ///
199 /// Destroys the certificate chain context.
200 ///
201 /// \sa [CertFreeCertificateChain function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376073.aspx)
202 ///
203 virtual ~CCertChainContext()
204 {
205 if (m_h)
206 CertFreeCertificateChain(m_h);
207 }
208
209 ///
210 /// Creates the certificate chain context.
211 ///
212 /// \return
213 /// - TRUE when creation succeeds;
214 /// - FALSE when creation fails. For extended error information, call `GetLastError()`.
215 /// \sa [CertGetCertificateChain function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376078.aspx)
216 ///
217 inline BOOL Create(_In_opt_ HCERTCHAINENGINE hChainEngine, _In_ PCCERT_CONTEXT pCertContext, _In_opt_ LPFILETIME pTime, _In_opt_ HCERTSTORE hAdditionalStore, _In_ PCERT_CHAIN_PARA pChainPara, _In_ DWORD dwFlags, __reserved LPVOID pvReserved)
218 {
219 HANDLE h;
220 if (CertGetCertificateChain(hChainEngine, pCertContext, pTime, hAdditionalStore, pChainPara, dwFlags, pvReserved, &h)) {
221 Attach(h);
222 return TRUE;
223 } else
224 return FALSE;
225 }
226
227 protected:
228 ///
229 /// Destroys the certificate chain context.
230 ///
231 /// \sa [CertFreeCertificateChain function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376073.aspx)
232 ///
233 virtual void InternalFree()
234 {
235 CertFreeCertificateChain(m_h);
236 }
237
238 ///
239 /// Duplicates the certificate chain context.
240 ///
241 /// \param[in] h Object handle of existing certificate chain context
242 /// \return Duplicated certificate chain context handle
243 /// \sa [CertDuplicateCertificateContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376045.aspx)
244 ///
245 virtual HANDLE InternalDuplicate(_In_ HANDLE h) const
246 {
247 return CertDuplicateCertificateChain(h);
248 }
249 };
250
251
252 ///
253 /// HCERTSTORE wrapper class
254 ///
255 class CCertStore : public ATL::CObjectWithHandleT<HCERTSTORE>
256 {
257 public:
258 ///
259 /// Closes the certificate store.
260 ///
261 /// \sa [CertCloseStore function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376026.aspx)
262 ///
263 virtual ~CCertStore()
264 {
265 if (m_h)
266 CertCloseStore(m_h, 0);
267 }
268
269 ///
270 /// Opens the certificate store.
271 ///
272 /// \return
273 /// - TRUE when creation succeeds;
274 /// - FALSE when creation fails. For extended error information, call `GetLastError()`.
275 /// \sa [CertOpenStore function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376559.aspx)
276 ///
277 inline BOOL Create(_In_ LPCSTR lpszStoreProvider, _In_ DWORD dwEncodingType, _In_opt_ HCRYPTPROV_LEGACY hCryptProv, _In_ DWORD dwFlags, _In_opt_ const void *pvPara)
278 {
279 HANDLE h = CertOpenStore(lpszStoreProvider, dwEncodingType, hCryptProv, dwFlags, pvPara);
280 if (h) {
281 Attach(h);
282 return TRUE;
283 } else
284 return FALSE;
285 }
286
287 protected:
288 ///
289 /// Closes the certificate store.
290 ///
291 /// \sa [CertCloseStore function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376026.aspx)
292 ///
293 virtual void InternalFree()
294 {
295 CertCloseStore(m_h, 0);
296 }
297 };
298
299
300 ///
301 /// HCRYPTPROV wrapper class
302 ///
303 class CContext : public ATL::CObjectWithHandleT<HCRYPTPROV>
304 {
305 public:
306 ///
307 /// Releases the cryptographi context.
308 ///
309 /// \sa [CryptReleaseContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa380268.aspx)
310 ///
311 virtual ~CContext()
312 {
313 if (m_h)
314 CryptReleaseContext(m_h, 0);
315 }
316
317 ///
318 /// Acquires the cryptographic context.
319 ///
320 /// \return
321 /// - TRUE when creation succeeds;
322 /// - FALSE when creation fails. For extended error information, call `GetLastError()`.
323 /// \sa [CryptAcquireContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379886.aspx)
324 ///
325 inline BOOL Create(_In_opt_ LPCTSTR szContainer, _In_opt_ LPCTSTR szProvider, _In_ DWORD dwProvType, _In_ DWORD dwFlags)
326 {
327 HANDLE h;
328 if (CryptAcquireContext(&h, szContainer, szProvider, dwProvType, dwFlags)) {
329 Attach(h);
330 return TRUE;
331 } else
332 return FALSE;
333 }
334
335 protected:
336 ///
337 /// Releases the cryptographic context.
338 ///
339 /// \sa [CryptReleaseContext function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa380268.aspx)
340 ///
341 virtual void InternalFree()
342 {
343 CryptReleaseContext(m_h, 0);
344 }
345 };
346
347
348 ///
349 /// HCRYPTHASH wrapper class
350 ///
351 class CHash : public ATL::CObjectWithHandleDuplT<HCRYPTHASH>
352 {
353 public:
354 ///
355 /// Destroys the hash context.
356 ///
357 /// \sa [CryptDestroyHash function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379917.aspx)
358 ///
359 virtual ~CHash()
360 {
361 if (m_h)
362 CryptDestroyHash(m_h);
363 }
364
365 ///
366 /// Creates the hash context.
367 ///
368 /// \return
369 /// - TRUE when creation succeeds;
370 /// - FALSE when creation fails. For extended error information, call `GetLastError()`.
371 /// \sa [CryptCreateHash function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379908.aspx)
372 ///
373 inline BOOL Create(_In_ HCRYPTPROV hProv, _In_ ALG_ID Algid, _In_ HCRYPTKEY hKey, _In_ DWORD dwFlags)
374 {
375 HANDLE h;
376 if (CryptCreateHash(hProv, Algid, hKey, dwFlags, &h)) {
377 Attach(h);
378 return TRUE;
379 } else
380 return FALSE;
381 }
382
383 protected:
384 ///
385 /// Destroys the hash context.
386 ///
387 /// \sa [CryptDestroyHash function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379917.aspx)
388 ///
389 virtual void InternalFree()
390 {
391 CryptDestroyHash(m_h);
392 }
393
394 ///
395 /// Duplicates the hash context.
396 ///
397 /// \param[in] h Object handle of existing hash context
398 /// \return Duplicated hash context handle
399 /// \sa [CryptDuplicateHash function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379919.aspx)
400 ///
401 virtual HANDLE InternalDuplicate(_In_ HANDLE h) const
402 {
403 HANDLE hNew = NULL;
404 return CryptDuplicateHash(h, NULL, 0, &hNew) ? hNew : NULL;
405 }
406 };
407
408
409 ///
410 /// HCRYPTKEY wrapper class
411 ///
412 class CKey : public ATL::CObjectWithHandleDuplT<HCRYPTKEY>
413 {
414 public:
415 ///
416 /// Destroys the key.
417 ///
418 /// \sa [CryptDestroyKey function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379918.aspx)
419 ///
420 virtual ~CKey()
421 {
422 if (m_h)
423 CryptDestroyKey(m_h);
424 }
425
426 ///
427 /// Generates the key.
428 ///
429 /// \sa [CryptGenKey function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379941.aspx)
430 ///
431 inline BOOL Generate(_In_ HCRYPTPROV hProv, _In_ ALG_ID Algid, _In_ DWORD dwFlags)
432 {
433 HANDLE h;
434 if (CryptGenKey(hProv, Algid, dwFlags, &h)) {
435 Attach(h);
436 return TRUE;
437 } else
438 return FALSE;
439 }
440
441 ///
442 /// Imports the key.
443 ///
444 /// \sa [CryptImportKey function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa380207.aspx)
445 ///
446 inline BOOL Import(_In_ HCRYPTPROV hProv, __in_bcount(dwDataLen) CONST BYTE *pbData, _In_ DWORD dwDataLen, _In_ HCRYPTKEY hPubKey, _In_ DWORD dwFlags)
447 {
448 HANDLE h;
449 if (CryptImportKey(hProv, pbData, dwDataLen, hPubKey, dwFlags, &h)) {
450 Attach(h);
451 return TRUE;
452 } else
453 return FALSE;
454 }
455
456 ///
457 /// Imports the public key.
458 ///
459 /// \sa [CryptImportPublicKeyInfo function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa380209.aspx)
460 ///
461 inline BOOL ImportPublic(_In_ HCRYPTPROV hCryptProv, _In_ DWORD dwCertEncodingType, _In_ PCERT_PUBLIC_KEY_INFO pInfo)
462 {
463 HANDLE h;
464 if (CryptImportPublicKeyInfo(hCryptProv, dwCertEncodingType, pInfo, &h)) {
465 Attach(h);
466 return TRUE;
467 } else
468 return FALSE;
469 }
470
471 protected:
472 ///
473 /// Destroys the key.
474 ///
475 /// \sa [CryptDestroyKey function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379918.aspx)
476 ///
477 virtual void InternalFree()
478 {
479 CryptDestroyKey(m_h);
480 }
481
482 ///
483 /// Duplicates the key.
484 ///
485 /// \param[in] h Object handle of existing key
486 /// \return Duplicated key handle
487 /// \sa [CryptDuplicateKey function](https://msdn.microsoft.com/en-us/library/windows/desktop/aa379920.aspx)
488 ///
489 virtual HANDLE InternalDuplicate(_In_ HANDLE h) const
490 {
491 HANDLE hNew = NULL;
492 return CryptDuplicateKey(h, NULL, 0, &hNew) ? hNew : NULL;
493 }
494 };
495
496 /// @}
497 }
498 }