ReactOS 0.4.17-dev-1190-g4c812f4
bcrypt_main.c
Go to the documentation of this file.
1/*
2 * Copyright 2009 Henri Verbeet for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 *
18 */
19
20#include <assert.h>
21#include <stdarg.h>
22#include <stdlib.h>
23
24#include "ntstatus.h"
25#ifdef __REACTOS__
26#define WIN32_NO_STATUS
27#endif
28#include "windef.h"
29#include "winbase.h"
30#include "ntsecapi.h"
31#include "wincrypt.h"
32#include "winternl.h"
33#include "bcrypt.h"
34
35#include "symcrypt.h"
36#include "wine/debug.h"
37
38WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
39
40SYMCRYPT_ENVIRONMENT_DEFS( WindowsUsermodeWin8_1nLater );
41
42#define MAGIC_DSS1 ('D' | ('S' << 8) | ('S' << 16) | ('1' << 24))
43#define MAGIC_DSS2 ('D' | ('S' << 8) | ('S' << 16) | ('2' << 24))
44
45#define MAGIC_ALG (('A' << 24) | ('L' << 16) | ('G' << 8) | '0')
46#define MAGIC_HASH (('H' << 24) | ('A' << 16) | ('S' << 8) | 'H')
47#define MAGIC_KEY (('K' << 24) | ('E' << 16) | ('Y' << 8) | '0')
48#define MAGIC_SECRET (('S' << 24) | ('C' << 16) | ('R' << 8) | 'T')
49struct object
50{
51 ULONG magic;
52};
53
54enum alg_id
55{
56 /* cipher */
57 ALG_ID_3DES,
58 ALG_ID_CHACHA20_POLY1305,
59 ALG_ID_AES,
60 ALG_ID_AES_GMAC,
61 ALG_ID_RC4,
62
63 /* hash */
64 ALG_ID_SHA256,
65 ALG_ID_SHA384,
66 ALG_ID_SHA512,
67 ALG_ID_SHA1,
68 ALG_ID_MD5,
69 ALG_ID_MD4,
70 ALG_ID_MD2,
71
72 /* asymmetric encryption */
73 ALG_ID_RSA,
74
75 /* secret agreement */
76 ALG_ID_DH,
77 ALG_ID_ECDH,
78 ALG_ID_ECDH_P256,
79 ALG_ID_ECDH_P384,
80 ALG_ID_ECDH_P521,
81
82 /* signature */
83 ALG_ID_RSA_SIGN,
84 ALG_ID_ECDSA,
85 ALG_ID_ECDSA_P256,
86 ALG_ID_ECDSA_P384,
87 ALG_ID_ECDSA_P521,
88 ALG_ID_DSA,
89
90 /* rng */
91 ALG_ID_RNG,
92
93 /* key derivation */
94 ALG_ID_PBKDF2,
95 ALG_ID_TLS1_1_KDF,
96 ALG_ID_TLS1_2_KDF,
97 ALG_ID_HKDF,
98};
99
100#define HASH_FLAG_HMAC 0x01
101#define HASH_FLAG_REUSABLE 0x02
102struct hash
103{
104 struct object hdr;
105 enum alg_id alg_id;
106 ULONG len;
107 ULONG flags;
108 UCHAR *secret;
109 ULONG secret_len;
110
111 const SYMCRYPT_HASH *desc;
112 SYMCRYPT_HASH_STATE state;
113 SYMCRYPT_HMAC_EXPANDED_KEY hmac;
114 SYMCRYPT_HMAC_STATE hmac_state;
115};
116
117enum chain_mode
118{
119 CHAIN_MODE_CBC,
120 CHAIN_MODE_ECB,
121 CHAIN_MODE_CFB,
122 CHAIN_MODE_CCM,
123 CHAIN_MODE_GCM,
124};
125
126enum ecc_curve_id
127{
128 ECC_CURVE_INVALID = -1,
129 ECC_CURVE_NONE,
130 ECC_CURVE_25519,
131 ECC_CURVE_BRAINPOOLP256R1,
132 ECC_CURVE_BRAINPOOLP384R1,
133 ECC_CURVE_P256R1,
134 ECC_CURVE_P384R1,
135 ECC_CURVE_P521R1,
136};
137
138struct algorithm
139{
140 struct object hdr;
141 enum alg_id id;
142 enum chain_mode chain_mode;
143 ULONG flags;
144 enum ecc_curve_id curve_id;
145};
146
147struct aes_key
148{
149 SYMCRYPT_AES_EXPANDED_KEY handle;
150};
151
152struct gcm_key
153{
154 SYMCRYPT_GCM_EXPANDED_KEY handle;
155 SYMCRYPT_GCM_STATE state;
156};
157
158struct hkdf_key
159{
160 SYMCRYPT_HKDF_EXPANDED_KEY handle;
161 const SYMCRYPT_MAC *hmac;
162};
163
164#define BLOCK_LENGTH_RC4 1
165#define BLOCK_LENGTH_CHACHA20_POLY1305 1
166#define BLOCK_LENGTH_3DES 8
167#define BLOCK_LENGTH_AES 16
168
169struct symmetric_key
170{
171 enum chain_mode mode;
172 ULONG block_size;
173 UCHAR *secret;
174 ULONG secret_len;
175 UCHAR vector[BLOCK_LENGTH_AES];
176 CRITICAL_SECTION cs;
177 union
178 {
179 struct aes_key aes;
180 struct gcm_key gcm;
181 struct hkdf_key hkdf;
182 };
183};
184
185struct rsa_key
186{
187 SYMCRYPT_RSAKEY *handle;
188};
189
190struct ecc_key
191{
192 SYMCRYPT_ECKEY *handle;
193 SYMCRYPT_ECURVE *curve;
194 enum ecc_curve_id curve_id;
195};
196
197struct dsa_key
198{
199 SYMCRYPT_DLKEY *handle;
200 SYMCRYPT_DLGROUP *group;
201 UCHAR seed[20];
202 UINT32 count;
203};
204
205struct asymmetric_key
206{
207 ULONG bitlen; /* key strength for ECC keys */
208 union
209 {
210 struct rsa_key rsa;
211 struct ecc_key ecc;
212 struct dsa_key dsa;
213 };
214};
215
216#define KEY_FLAG_PRIVATE 0x00000001
217#define KEY_FLAG_FINALIZED 0x00000002
218
219struct key
220{
221 struct object hdr;
222 enum alg_id alg_id;
223 ULONG flags;
224 union
225 {
226 struct symmetric_key s;
227 struct asymmetric_key a;
228 };
229};
230
231#define KEY_EXPORT_FLAG_PRIVATE 0x00000001
232#define KEY_EXPORT_FLAG_RSA_FULL 0x00000002
233
234struct secret
235{
236 struct object hdr;
237 UCHAR *derived_key;
238 ULONG derived_key_len;
239};
240
241void * SYMCRYPT_CALL SymCryptCallbackAlloc( SIZE_T size )
242{
243 return _aligned_malloc( size, SYMCRYPT_ASYM_ALIGN_VALUE );
244}
245
246void SYMCRYPT_CALL SymCryptCallbackFree( void *ptr )
247{
248 _aligned_free( ptr );
249}
250
251SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCallbackRandom( BYTE *buf, SIZE_T size )
252{
253 return RtlGenRandom( buf, size ) ? SYMCRYPT_NO_ERROR : SYMCRYPT_EXTERNAL_FAILURE;
254}
255
256SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaSignVerifyPct( const SYMCRYPT_RSAKEY *key )
257{
258 return SYMCRYPT_NO_ERROR;
259}
260
261SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaPct( const SYMCRYPT_DLKEY *key )
262{
263 return SYMCRYPT_NO_ERROR;
264}
265
266void SYMCRYPT_CALL SymCryptRsaSelftest( void )
267{
268}
269
270SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaPct( const SYMCRYPT_ECKEY *key )
271{
272 return SYMCRYPT_NO_ERROR;
273}
274
275void SYMCRYPT_CALL SymCryptDsaSelftest( void )
276{
277}
278
279void SYMCRYPT_CALL SymCryptEcDsaSelftest( void )
280{
281}
282
283void SYMCRYPT_CALL SymCryptDhSecretAgreementSelftest( void )
284{
285}
286
287void SYMCRYPT_CALL SymCryptEcDhSecretAgreementSelftest( void )
288{
289}
290
291UINT32 g_SymCryptFipsSelftestsPerformed;
292
293static inline ULONG len_from_bitlen( ULONG bitlen )
294{
295 return (bitlen + 7) / 8;
296}
297
298NTSTATUS WINAPI BCryptAddContextFunction( ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func, ULONG pos )
299{
300 FIXME( "%#lx, %s, %#lx, %s, %lu: stub\n", table, debugstr_w(ctx), iface, debugstr_w(func), pos );
301 return STATUS_SUCCESS;
302}
303
304NTSTATUS WINAPI BCryptAddContextFunctionProvider( ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func,
305 const WCHAR *provider, ULONG pos )
306{
307 FIXME( "%#lx, %s, %#lx, %s, %s, %lu: stub\n", table, debugstr_w(ctx), iface, debugstr_w(func),
308 debugstr_w(provider), pos );
309 return STATUS_SUCCESS;
310}
311
312NTSTATUS WINAPI BCryptRemoveContextFunction( ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func )
313{
314 FIXME( "%#lx, %s, %#lx, %s: stub\n", table, debugstr_w(ctx), iface, debugstr_w(func) );
315 return STATUS_NOT_IMPLEMENTED;
316}
317
318NTSTATUS WINAPI BCryptRemoveContextFunctionProvider( ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func,
319 const WCHAR *provider )
320{
321 FIXME( "%#lx, %s, %#lx, %s, %s: stub\n", table, debugstr_w(ctx), iface, debugstr_w(func), debugstr_w(provider) );
322 return STATUS_NOT_IMPLEMENTED;
323}
324
325NTSTATUS WINAPI BCryptEnumContextFunctions( ULONG table, const WCHAR *ctx, ULONG iface, ULONG *buflen,
326 CRYPT_CONTEXT_FUNCTIONS **buffer )
327{
328 FIXME( "%#lx, %s, %#lx, %p, %p\n", table, debugstr_w(ctx), iface, buflen, buffer );
329 return STATUS_NOT_IMPLEMENTED;
330}
331
332void WINAPI BCryptFreeBuffer( void *buffer )
333{
334 free( buffer );
335}
336
337NTSTATUS WINAPI BCryptRegisterProvider( const WCHAR *provider, ULONG flags, CRYPT_PROVIDER_REG *reg )
338{
339 FIXME( "%s, %#lx, %p: stub\n", debugstr_w(provider), flags, reg );
340 return STATUS_SUCCESS;
341}
342
343NTSTATUS WINAPI BCryptUnregisterProvider( const WCHAR *provider )
344{
345 FIXME( "%s: stub\n", debugstr_w(provider) );
346 return STATUS_NOT_IMPLEMENTED;
347}
348
349#define MAX_HASH_OUTPUT_BYTES 64
350
351/* ordered by class, keep in sync with enum alg_id */
352static const struct
353{
354 const WCHAR *name;
355 ULONG class;
356 ULONG object_length;
357 ULONG hash_length;
358 ULONG hash_block_length;
359 enum ecc_curve_id curve_id;
360 enum chain_mode chain_mode;
361}
362builtin_algorithms[] =
363{
364 { BCRYPT_3DES_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 522, 0, 0 },
365 { BCRYPT_CHACHA20_POLY1305_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 166, 0, 0 },
366 { BCRYPT_AES_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 654, 0, 0 },
367 { BCRYPT_AES_GMAC_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 654, 0, 0, 0, CHAIN_MODE_GCM },
368 { BCRYPT_RC4_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 654, 0, 0 },
369 { BCRYPT_SHA256_ALGORITHM, BCRYPT_HASH_INTERFACE, 286, 32, 64 },
370 { BCRYPT_SHA384_ALGORITHM, BCRYPT_HASH_INTERFACE, 382, 48, 128 },
371 { BCRYPT_SHA512_ALGORITHM, BCRYPT_HASH_INTERFACE, 382, 64, 128 },
372 { BCRYPT_SHA1_ALGORITHM, BCRYPT_HASH_INTERFACE, 278, 20, 64 },
373 { BCRYPT_MD5_ALGORITHM, BCRYPT_HASH_INTERFACE, 274, 16, 64 },
374 { BCRYPT_MD4_ALGORITHM, BCRYPT_HASH_INTERFACE, 270, 16, 64 },
375 { BCRYPT_MD2_ALGORITHM, BCRYPT_HASH_INTERFACE, 270, 16, 16 },
376 { BCRYPT_RSA_ALGORITHM, BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE, 0, 0, 0 },
377 { BCRYPT_DH_ALGORITHM, BCRYPT_SECRET_AGREEMENT_INTERFACE, 0, 0, 0 },
378 { BCRYPT_ECDH_ALGORITHM, BCRYPT_SECRET_AGREEMENT_INTERFACE, 0, 0, 0 },
379 { BCRYPT_ECDH_P256_ALGORITHM, BCRYPT_SECRET_AGREEMENT_INTERFACE, 0, 0, 0, ECC_CURVE_P256R1 },
380 { BCRYPT_ECDH_P384_ALGORITHM, BCRYPT_SECRET_AGREEMENT_INTERFACE, 0, 0, 0, ECC_CURVE_P384R1 },
381 { BCRYPT_ECDH_P521_ALGORITHM, BCRYPT_SECRET_AGREEMENT_INTERFACE, 0, 0, 0, ECC_CURVE_P521R1 },
382 { BCRYPT_RSA_SIGN_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
383 { BCRYPT_ECDSA_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
384 { BCRYPT_ECDSA_P256_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0, ECC_CURVE_P256R1 },
385 { BCRYPT_ECDSA_P384_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0, ECC_CURVE_P384R1 },
386 { BCRYPT_ECDSA_P521_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0, ECC_CURVE_P521R1 },
387 { BCRYPT_DSA_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
388 { BCRYPT_RNG_ALGORITHM, BCRYPT_RNG_INTERFACE, 0, 0, 0 },
389 { BCRYPT_PBKDF2_ALGORITHM, BCRYPT_KEY_DERIVATION_INTERFACE, 618, 0, 0 },
390 { BCRYPT_TLS1_1_KDF_ALGORITHM, BCRYPT_KEY_DERIVATION_INTERFACE, 702, 0, 0 },
391 { BCRYPT_TLS1_2_KDF_ALGORITHM, BCRYPT_KEY_DERIVATION_INTERFACE, 702, 0, 0 },
392 { BCRYPT_HKDF_ALGORITHM, BCRYPT_KEY_DERIVATION_INTERFACE, 702, 0, 0 },
393};
394
395static inline BOOL is_symmetric_alg( const struct algorithm *alg )
396{
397 return builtin_algorithms[alg->id].class == BCRYPT_CIPHER_INTERFACE
398 || builtin_algorithms[alg->id].class == BCRYPT_KEY_DERIVATION_INTERFACE;
399}
400
401static inline BOOL is_symmetric_key( const struct key *key )
402{
403 return builtin_algorithms[key->alg_id].class == BCRYPT_CIPHER_INTERFACE
404 || builtin_algorithms[key->alg_id].class == BCRYPT_KEY_DERIVATION_INTERFACE;
405}
406
407static BOOL match_operation_type( ULONG type, ULONG class )
408{
409 if (!type) return TRUE;
410 switch (class)
411 {
412 case BCRYPT_CIPHER_INTERFACE: return type & BCRYPT_CIPHER_OPERATION;
413 case BCRYPT_HASH_INTERFACE: return type & BCRYPT_HASH_OPERATION;
414 case BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE: return type & BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION;
415 case BCRYPT_SECRET_AGREEMENT_INTERFACE: return type & BCRYPT_SECRET_AGREEMENT_OPERATION;
416 case BCRYPT_SIGNATURE_INTERFACE: return type & BCRYPT_SIGNATURE_OPERATION;
417 case BCRYPT_RNG_INTERFACE: return type & BCRYPT_RNG_OPERATION;
418 case BCRYPT_KEY_DERIVATION_INTERFACE: return type & BCRYPT_KEY_DERIVATION_OPERATION;
419 default: break;
420 }
421 return FALSE;
422}
423
424NTSTATUS WINAPI BCryptEnumAlgorithms( ULONG type, ULONG *ret_count, BCRYPT_ALGORITHM_IDENTIFIER **ret_list, ULONG flags )
425{
426 static const ULONG supported = BCRYPT_CIPHER_OPERATION |\
427 BCRYPT_HASH_OPERATION |\
428 BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION |\
429 BCRYPT_SECRET_AGREEMENT_OPERATION |\
430 BCRYPT_SIGNATURE_OPERATION |\
431 BCRYPT_RNG_OPERATION |\
432 BCRYPT_KEY_DERIVATION_OPERATION;
433 BCRYPT_ALGORITHM_IDENTIFIER *list;
434 ULONG i, j, count = 0;
435
436 TRACE( "%#lx, %p, %p, %#lx\n", type, ret_count, ret_list, flags );
437
438 if (!ret_count || !ret_list || (type & ~supported)) return STATUS_INVALID_PARAMETER;
439
440 for (i = 0; i < ARRAY_SIZE( builtin_algorithms ); i++)
441 {
442 if (match_operation_type( type, builtin_algorithms[i].class )) count++;
443 }
444
445 if (!(list = malloc( count * sizeof(*list) ))) return STATUS_NO_MEMORY;
446
447 for (i = 0, j = 0; i < ARRAY_SIZE( builtin_algorithms ); i++)
448 {
449 if (!match_operation_type( type, builtin_algorithms[i].class )) continue;
450 list[j].pszName = (WCHAR *)builtin_algorithms[i].name;
451 list[j].dwClass = builtin_algorithms[i].class;
452 list[j].dwFlags = 0;
453 j++;
454 }
455
456 *ret_count = count;
457 *ret_list = list;
458 return STATUS_SUCCESS;
459}
460
461static const struct algorithm pseudo_algorithms[] =
462{
463 {{ MAGIC_ALG }, ALG_ID_MD2 },
464 {{ MAGIC_ALG }, ALG_ID_MD4 },
465 {{ MAGIC_ALG }, ALG_ID_MD5 },
466 {{ MAGIC_ALG }, ALG_ID_SHA1 },
467 {{ MAGIC_ALG }, ALG_ID_SHA256 },
468 {{ MAGIC_ALG }, ALG_ID_SHA384 },
469 {{ MAGIC_ALG }, ALG_ID_SHA512 },
470 {{ MAGIC_ALG }, ALG_ID_RC4 },
471 {{ MAGIC_ALG }, ALG_ID_RNG },
472 {{ MAGIC_ALG }, ALG_ID_MD5, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
473 {{ MAGIC_ALG }, ALG_ID_SHA1, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
474 {{ MAGIC_ALG }, ALG_ID_SHA256, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
475 {{ MAGIC_ALG }, ALG_ID_SHA384, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
476 {{ MAGIC_ALG }, ALG_ID_SHA512, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
477 {{ MAGIC_ALG }, ALG_ID_RSA },
478 {{ MAGIC_ALG }, ALG_ID_ECDSA },
479 {{ 0 }}, /* AES_CMAC */
480 {{ MAGIC_ALG }, ALG_ID_AES_GMAC, CHAIN_MODE_GCM },
481 {{ MAGIC_ALG }, ALG_ID_MD2, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
482 {{ MAGIC_ALG }, ALG_ID_MD4, 0, BCRYPT_ALG_HANDLE_HMAC_FLAG },
483 {{ MAGIC_ALG }, ALG_ID_3DES, CHAIN_MODE_CBC },
484 {{ MAGIC_ALG }, ALG_ID_3DES, CHAIN_MODE_ECB },
485 {{ MAGIC_ALG }, ALG_ID_3DES, CHAIN_MODE_CFB },
486 {{ 0 }}, /* 3DES_112_CBC */
487 {{ 0 }}, /* 3DES_112_ECB */
488 {{ 0 }}, /* 3DES_112_CFB */
489 {{ MAGIC_ALG }, ALG_ID_AES, CHAIN_MODE_CBC },
490 {{ MAGIC_ALG }, ALG_ID_AES, CHAIN_MODE_ECB },
491 {{ MAGIC_ALG }, ALG_ID_AES, CHAIN_MODE_CFB },
492 {{ MAGIC_ALG }, ALG_ID_AES, CHAIN_MODE_CCM },
493 {{ MAGIC_ALG }, ALG_ID_AES, CHAIN_MODE_GCM },
494 {{ 0 }}, /* DES_CBC */
495 {{ 0 }}, /* DES_ECB */
496 {{ 0 }}, /* DES_CFB */
497 {{ 0 }}, /* DESX_CBC */
498 {{ 0 }}, /* DESX_ECB */
499 {{ 0 }}, /* DESX_CFB */
500 {{ 0 }}, /* RC2_CBC */
501 {{ 0 }}, /* RC2_ECB */
502 {{ 0 }}, /* RC2_CFB */
503 {{ MAGIC_ALG }, ALG_ID_DH },
504 {{ MAGIC_ALG }, ALG_ID_ECDH },
505 {{ MAGIC_ALG }, ALG_ID_ECDH_P256, 0, 0, ECC_CURVE_P256R1 },
506 {{ MAGIC_ALG }, ALG_ID_ECDH_P384, 0, 0, ECC_CURVE_P384R1 },
507 {{ MAGIC_ALG }, ALG_ID_ECDH_P521, 0, 0, ECC_CURVE_P521R1 },
508 {{ MAGIC_ALG }, ALG_ID_DSA },
509 {{ MAGIC_ALG }, ALG_ID_ECDSA_P256, 0, 0, ECC_CURVE_P256R1 },
510 {{ MAGIC_ALG }, ALG_ID_ECDSA_P384, 0, 0, ECC_CURVE_P384R1 },
511 {{ MAGIC_ALG }, ALG_ID_ECDSA_P521, 0, 0, ECC_CURVE_P521R1 },
512 {{ MAGIC_ALG }, ALG_ID_RSA_SIGN },
513 {{ 0 }}, /* CAPI_KDF */
514 {{ MAGIC_ALG }, ALG_ID_PBKDF2 },
515 {{ 0 }}, /* SP800108_CTR_HMAC */
516 {{ 0 }}, /* SP80056A_CONCAT */
517 {{ MAGIC_ALG }, ALG_ID_TLS1_1_KDF },
518 {{ MAGIC_ALG }, ALG_ID_TLS1_2_KDF },
519 {{ 0 }}, /* XTS_AES */
520 {{ MAGIC_ALG }, ALG_ID_HKDF },
521 {{ MAGIC_ALG }, ALG_ID_CHACHA20_POLY1305 },
522};
523
524/* Algorithm pseudo-handles are denoted by having the lowest bit set.
525 * An aligned algorithm pointer will never have this bit set.
526 */
527static inline BOOL is_alg_pseudo_handle( BCRYPT_ALG_HANDLE handle )
528{
529 return (((ULONG_PTR)handle & 1) == 1);
530}
531
532static struct object *get_object( BCRYPT_HANDLE handle, ULONG magic )
533{
534 ULONG idx;
535
536 if (!handle) return NULL;
537
538 if (!is_alg_pseudo_handle( handle ))
539 {
540 struct object *obj = handle;
541 if (magic && obj->magic != magic) return NULL;
542 return obj;
543 }
544
545 idx = (ULONG_PTR)handle >> 4;
546 if (idx >= ARRAY_SIZE(pseudo_algorithms) || !pseudo_algorithms[idx].hdr.magic)
547 {
548 FIXME( "pseudo-handle %p not supported\n", handle );
549 return NULL;
550 }
551 return (struct object *)&pseudo_algorithms[idx];
552}
553
554static inline struct algorithm *get_alg_object( BCRYPT_ALG_HANDLE handle )
555{
556 return (struct algorithm *)get_object( handle, MAGIC_ALG );
557}
558
559static inline struct hash *get_hash_object( BCRYPT_HASH_HANDLE handle )
560{
561 return (struct hash *)get_object( handle, MAGIC_HASH );
562}
563
564static inline struct key *get_key_object( BCRYPT_KEY_HANDLE handle )
565{
566 return (struct key *)get_object( handle, MAGIC_KEY );
567}
568
569static inline struct secret *get_secret_object( BCRYPT_SECRET_HANDLE handle )
570{
571 return (struct secret *)get_object( handle, MAGIC_SECRET );
572}
573
574NTSTATUS WINAPI BCryptGenRandom( BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags )
575{
576 const DWORD supported_flags = BCRYPT_USE_SYSTEM_PREFERRED_RNG;
577 const struct algorithm *alg = get_alg_object( handle );
578
579 TRACE("%p, %p, %lu, %#lx - semi-stub\n", handle, buffer, count, flags);
580
581 if (!handle)
582 {
583 /* It's valid to call without an algorithm if BCRYPT_USE_SYSTEM_PREFERRED_RNG
584 * is set. In this case the preferred system RNG is used.
585 */
586 if (!(flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
587 return STATUS_INVALID_HANDLE;
588 }
589 else if (is_alg_pseudo_handle( handle ) && handle != BCRYPT_RNG_ALG_HANDLE)
590 {
591 FIXME( "pseudo-handle %p not supported\n", handle );
592 return STATUS_NOT_IMPLEMENTED;
593 }
594 else if (!alg || alg->id != ALG_ID_RNG)
595 return STATUS_INVALID_HANDLE;
596
597 if (!buffer)
598 return STATUS_INVALID_PARAMETER;
599
600 if (flags & ~supported_flags)
601 FIXME("unsupported flags %#lx\n", flags & ~supported_flags);
602
603 if (alg)
604 FIXME("ignoring selected algorithm\n");
605
606 if (!count) return STATUS_SUCCESS;
607
608 if (alg || (flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
609 {
610 if (RtlGenRandom(buffer, count)) return STATUS_SUCCESS;
611 }
612
613 FIXME("called with unsupported parameters, returning error\n");
614 return STATUS_NOT_IMPLEMENTED;
615}
616
617static struct algorithm *create_algorithm( enum alg_id id, DWORD flags )
618{
619 struct algorithm *ret;
620 if (!(ret = calloc( 1, sizeof(*ret) ))) return NULL;
621 ret->hdr.magic = MAGIC_ALG;
622 ret->id = id;
623 ret->flags = flags;
624 ret->curve_id = builtin_algorithms[id].curve_id;
625 ret->chain_mode = builtin_algorithms[id].chain_mode;
626 return ret;
627}
628
629NTSTATUS WINAPI BCryptOpenAlgorithmProvider( BCRYPT_ALG_HANDLE *handle, const WCHAR *id, const WCHAR *implementation,
630 DWORD flags )
631{
632 const DWORD supported_flags = BCRYPT_ALG_HANDLE_HMAC_FLAG | BCRYPT_HASH_REUSABLE_FLAG;
633 struct algorithm *alg;
634 enum alg_id alg_id;
635 ULONG i;
636
637 TRACE( "%p, %s, %s, %#lx\n", handle, wine_dbgstr_w(id), wine_dbgstr_w(implementation), flags );
638
639 if (!handle || !id) return STATUS_INVALID_PARAMETER;
640 if (flags & ~supported_flags)
641 {
642 FIXME( "unsupported flags %#lx\n", flags & ~supported_flags );
643 return STATUS_NOT_IMPLEMENTED;
644 }
645
646 for (i = 0; i < ARRAY_SIZE( builtin_algorithms ); i++)
647 {
648 if (!wcscmp( id, builtin_algorithms[i].name))
649 {
650 alg_id = i;
651 break;
652 }
653 }
654 if (i == ARRAY_SIZE( builtin_algorithms ))
655 {
656 FIXME( "algorithm %s not supported\n", debugstr_w(id) );
657 return STATUS_NOT_IMPLEMENTED;
658 }
659
660 if (implementation && wcscmp( implementation, MS_PRIMITIVE_PROVIDER ))
661 {
662 FIXME( "implementation %s not supported\n", debugstr_w(implementation) );
663 return STATUS_NOT_IMPLEMENTED;
664 }
665
666 if (!(alg = create_algorithm( alg_id, flags ))) return STATUS_NO_MEMORY;
667 *handle = alg;
668
669 TRACE( "returning handle %p\n", *handle );
670 return STATUS_SUCCESS;
671}
672
673static void secure_zero( void *ptr, SIZE_T size )
674{
675 if (ptr) SecureZeroMemory( ptr, size );
676}
677
678static void destroy_object( struct object *obj )
679{
680 secure_zero( &obj->magic, sizeof(obj->magic) );
681 free( obj );
682}
683
684NTSTATUS WINAPI BCryptCloseAlgorithmProvider( BCRYPT_ALG_HANDLE handle, DWORD flags )
685{
686 struct algorithm *alg = handle;
687
688 TRACE( "%p, %#lx\n", handle, flags );
689
690 if (!handle || is_alg_pseudo_handle( handle ) || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
691
692 destroy_object( &alg->hdr );
693 return STATUS_SUCCESS;
694}
695
696NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
697{
698 FIXME("%p - semi-stub\n", enabled);
699
700 if (!enabled)
701 return STATUS_INVALID_PARAMETER;
702
703 *enabled = FALSE;
704 return STATUS_SUCCESS;
705}
706
707static NTSTATUS get_dword_property( UCHAR *buf, ULONG size, ULONG *ret_size, DWORD value )
708{
709 *ret_size = sizeof(value);
710 if (size < sizeof(value)) return STATUS_BUFFER_TOO_SMALL;
711 if (buf) *(DWORD *)buf = value;
712 return STATUS_SUCCESS;
713}
714
715static NTSTATUS get_generic_alg_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
716{
717 if (!wcscmp( prop, BCRYPT_OBJECT_LENGTH ))
718 {
719 if (!builtin_algorithms[id].object_length) return STATUS_NOT_SUPPORTED;
720 return get_dword_property( buf, size, ret_size, builtin_algorithms[id].object_length );
721 }
722
723 if (!wcscmp( prop, BCRYPT_HASH_LENGTH ))
724 {
725 if (!builtin_algorithms[id].hash_length) return STATUS_NOT_SUPPORTED;
726 return get_dword_property( buf, size, ret_size, builtin_algorithms[id].hash_length );
727 }
728
729 if (!wcscmp( prop, BCRYPT_HASH_BLOCK_LENGTH ))
730 {
731 if (!builtin_algorithms[id].hash_block_length) return STATUS_NOT_SUPPORTED;
732 return get_dword_property( buf, size, ret_size, builtin_algorithms[id].hash_block_length );
733 }
734
735 if (!wcscmp( prop, BCRYPT_ALGORITHM_NAME ))
736 {
737 *ret_size = (lstrlenW(builtin_algorithms[id].name) + 1) * sizeof(WCHAR);
738 if (size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
739 if(buf) memcpy(buf, builtin_algorithms[id].name, *ret_size);
740 return STATUS_SUCCESS;
741 }
742
743 return STATUS_NOT_IMPLEMENTED;
744}
745
746static NTSTATUS get_3des_property( enum chain_mode mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
747{
748 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH ))
749 return get_dword_property( buf, size, ret_size, BLOCK_LENGTH_3DES );
750
751 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
752 {
753 const WCHAR *str;
754 switch (mode)
755 {
756 case CHAIN_MODE_CBC:
757 str = BCRYPT_CHAIN_MODE_CBC; break;
758 default:
759 return STATUS_NOT_IMPLEMENTED;
760 }
761
762 *ret_size = (wcslen(str) + 1) * sizeof(WCHAR) * 2; /* quirk */
763 if (size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
764 memcpy( buf, str, (wcslen(str) + 1) * sizeof(WCHAR) );
765 return STATUS_SUCCESS;
766 }
767 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
768 {
769 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
770 *ret_size = sizeof(*key_lengths);
771 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
772 if (key_lengths)
773 {
774 key_lengths->dwMinLength = 192;
775 key_lengths->dwMaxLength = 192;
776 key_lengths->dwIncrement = 0;
777 }
778 return STATUS_SUCCESS;
779 }
780 FIXME( "unsupported property %s\n", debugstr_w(prop) );
781 return STATUS_NOT_IMPLEMENTED;
782}
783
784static NTSTATUS get_aes_property( enum chain_mode mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
785{
786 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH ))
787 return get_dword_property( buf, size, ret_size, BLOCK_LENGTH_AES );
788
789 if (!wcscmp( prop, BCRYPT_MESSAGE_BLOCK_LENGTH ))
790 return get_dword_property( buf, size, ret_size, 1 );
791
792 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
793 {
794 const WCHAR *str;
795 switch (mode)
796 {
797 case CHAIN_MODE_ECB: str = BCRYPT_CHAIN_MODE_ECB; break;
798 case CHAIN_MODE_CBC: str = BCRYPT_CHAIN_MODE_CBC; break;
799 case CHAIN_MODE_GCM: str = BCRYPT_CHAIN_MODE_GCM; break;
800 case CHAIN_MODE_CFB: str = BCRYPT_CHAIN_MODE_CFB; break;
801 default: return STATUS_NOT_IMPLEMENTED;
802 }
803
804 *ret_size = (wcslen(str) + 1) * sizeof(WCHAR) * 2; /* quirk */
805 if (size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
806 memcpy( buf, str, (wcslen(str) + 1) * sizeof(WCHAR) );
807 return STATUS_SUCCESS;
808 }
809 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
810 {
811 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
812 *ret_size = sizeof(*key_lengths);
813 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
814 if (key_lengths)
815 {
816 key_lengths->dwMinLength = 128;
817 key_lengths->dwMaxLength = 256;
818 key_lengths->dwIncrement = 64;
819 }
820 return STATUS_SUCCESS;
821 }
822 if (!wcscmp( prop, BCRYPT_AUTH_TAG_LENGTH ))
823 {
824 BCRYPT_AUTH_TAG_LENGTHS_STRUCT *tag_length = (void *)buf;
825 if (mode != CHAIN_MODE_GCM) return STATUS_NOT_SUPPORTED;
826 *ret_size = sizeof(*tag_length);
827 if (tag_length && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
828 if (tag_length)
829 {
830 tag_length->dwMinLength = 12;
831 tag_length->dwMaxLength = 16;
832 tag_length->dwIncrement = 1;
833 }
834 return STATUS_SUCCESS;
835 }
836
837 FIXME( "unsupported property %s\n", debugstr_w(prop) );
838 return STATUS_NOT_IMPLEMENTED;
839}
840
841static NTSTATUS get_rc4_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
842{
843 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH ))
844 return get_dword_property( buf, size, ret_size, BLOCK_LENGTH_RC4 );
845
846 FIXME( "unsupported property %s\n", debugstr_w(prop) );
847 return STATUS_NOT_IMPLEMENTED;
848}
849
850static NTSTATUS get_rsa_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
851{
852 if (!wcscmp( prop, BCRYPT_PADDING_SCHEMES ))
853 return get_dword_property( buf, size, ret_size, BCRYPT_SUPPORTED_PAD_PKCS1_SIG | BCRYPT_SUPPORTED_PAD_OAEP );
854
855 FIXME( "unsupported property %s\n", debugstr_w(prop) );
856 return STATUS_NOT_IMPLEMENTED;
857}
858
859static NTSTATUS get_dsa_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
860{
861 if (!wcscmp( prop, BCRYPT_PADDING_SCHEMES )) return STATUS_NOT_SUPPORTED;
862 FIXME( "unsupported property %s\n", debugstr_w(prop) );
863 return STATUS_NOT_IMPLEMENTED;
864}
865
866static NTSTATUS get_pbkdf2_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
867{
868 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH )) return STATUS_NOT_SUPPORTED;
869 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
870 {
871 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
872 *ret_size = sizeof(*key_lengths);
873 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
874 if (key_lengths)
875 {
876 key_lengths->dwMinLength = 0;
877 key_lengths->dwMaxLength = 16384;
878 key_lengths->dwIncrement = 8;
879 }
880 return STATUS_SUCCESS;
881 }
882 FIXME( "unsupported property %s\n", debugstr_w(prop) );
883 return STATUS_NOT_IMPLEMENTED;
884}
885
886static NTSTATUS get_tls_kdf_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
887{
888 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH )) return STATUS_NOT_SUPPORTED;
889 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
890 {
891 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
892 *ret_size = sizeof(*key_lengths);
893 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
894 if (key_lengths)
895 {
896 key_lengths->dwMinLength = 0;
897 key_lengths->dwMaxLength = 16384;
898 key_lengths->dwIncrement = 8;
899 }
900 return STATUS_SUCCESS;
901 }
902 FIXME( "unsupported property %s\n", debugstr_w(prop) );
903 return STATUS_NOT_IMPLEMENTED;
904}
905
906static NTSTATUS get_hkdf_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
907{
908 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH )) return STATUS_NOT_SUPPORTED;
909 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
910 {
911 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
912 *ret_size = sizeof(*key_lengths);
913 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
914 if (key_lengths)
915 {
916 key_lengths->dwMinLength = 0;
917 key_lengths->dwMaxLength = 16384;
918 key_lengths->dwIncrement = 8;
919 }
920 return STATUS_SUCCESS;
921 }
922 FIXME( "unsupported property %s\n", debugstr_w(prop) );
923 return STATUS_NOT_IMPLEMENTED;
924}
925
926static NTSTATUS get_chacha20_poly1305_property( const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
927{
928 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH ))
929 return get_dword_property( buf, size, ret_size, BLOCK_LENGTH_CHACHA20_POLY1305 );
930
931 FIXME( "unsupported property %s\n", debugstr_w(prop) );
932 return STATUS_NOT_IMPLEMENTED;
933}
934
935static NTSTATUS get_alg_property( const struct algorithm *alg, const WCHAR *prop, UCHAR *buf, ULONG size,
936 ULONG *ret_size )
937{
938 NTSTATUS status;
939
940 if ((status = get_generic_alg_property( alg->id, prop, buf, size, ret_size )) != STATUS_NOT_IMPLEMENTED)
941 return status;
942
943 switch (alg->id)
944 {
945 case ALG_ID_3DES:
946 return get_3des_property( alg->chain_mode, prop, buf, size, ret_size );
947
948 case ALG_ID_CHACHA20_POLY1305:
949 return get_chacha20_poly1305_property( prop, buf, size, ret_size );
950
951 case ALG_ID_AES:
952 case ALG_ID_AES_GMAC:
953 return get_aes_property( alg->chain_mode, prop, buf, size, ret_size );
954
955 case ALG_ID_RC4:
956 return get_rc4_property( prop, buf, size, ret_size );
957
958 case ALG_ID_RSA:
959 return get_rsa_property( prop, buf, size, ret_size );
960
961 case ALG_ID_DSA:
962 return get_dsa_property( prop, buf, size, ret_size );
963
964 case ALG_ID_PBKDF2:
965 return get_pbkdf2_property( prop, buf, size, ret_size );
966
967 case ALG_ID_TLS1_1_KDF:
968 case ALG_ID_TLS1_2_KDF:
969 return get_tls_kdf_property( prop, buf, size, ret_size );
970
971 case ALG_ID_HKDF:
972 return get_hkdf_property( prop, buf, size, ret_size );
973
974 default:
975 break;
976 }
977
978 FIXME( "unsupported property %s algorithm %u\n", debugstr_w(prop), alg->id );
979 return STATUS_NOT_IMPLEMENTED;
980}
981
982static NTSTATUS set_alg_property( struct algorithm *alg, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
983{
984 switch (alg->id)
985 {
986 case ALG_ID_3DES:
987 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
988 {
989 TRACE( "mode %s\n", debugstr_w((WCHAR *)value) );
990 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
991 {
992 alg->chain_mode = CHAIN_MODE_CBC;
993 return STATUS_SUCCESS;
994 }
995 else
996 {
997 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
998 return STATUS_NOT_SUPPORTED;
999 }
1000 }
1001 FIXME( "unsupported 3des algorithm property %s\n", debugstr_w(prop) );
1002 return STATUS_NOT_IMPLEMENTED;
1003
1004 case ALG_ID_CHACHA20_POLY1305:
1005 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
1006 {
1007 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_NA )) return STATUS_SUCCESS;
1008
1009 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
1010 return STATUS_NOT_IMPLEMENTED;
1011 }
1012 FIXME( "unsupported CHACHA20_POLY1305 algorithm property %s\n", debugstr_w(prop) );
1013 return STATUS_NOT_IMPLEMENTED;
1014
1015 case ALG_ID_AES:
1016 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
1017 {
1018 TRACE( "mode %s\n", debugstr_w((WCHAR *)value) );
1019 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB ))
1020 {
1021 alg->chain_mode = CHAIN_MODE_ECB;
1022 return STATUS_SUCCESS;
1023 }
1024 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
1025 {
1026 alg->chain_mode = CHAIN_MODE_CBC;
1027 return STATUS_SUCCESS;
1028 }
1029 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM ))
1030 {
1031 alg->chain_mode = CHAIN_MODE_GCM;
1032 return STATUS_SUCCESS;
1033 }
1034 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CFB ))
1035 {
1036 alg->chain_mode = CHAIN_MODE_CFB;
1037 return STATUS_SUCCESS;
1038 }
1039 else
1040 {
1041 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
1042 return STATUS_NOT_IMPLEMENTED;
1043 }
1044 }
1045 else if (!wcscmp( (WCHAR *)prop, BCRYPT_MESSAGE_BLOCK_LENGTH ))
1046 return STATUS_INVALID_PARAMETER;
1047
1048 FIXME( "unsupported aes algorithm property %s\n", debugstr_w(prop) );
1049 return STATUS_NOT_IMPLEMENTED;
1050
1051 case ALG_ID_RC4:
1052 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
1053 {
1054 TRACE( "mode %s\n", debugstr_w((WCHAR *)value) );
1055 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_NA )) return STATUS_SUCCESS;
1056
1057 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
1058 return STATUS_NOT_IMPLEMENTED;
1059 }
1060 FIXME( "unsupported rc4 algorithm property %s\n", debugstr_w(prop) );
1061 return STATUS_NOT_IMPLEMENTED;
1062
1063 case ALG_ID_ECDH:
1064 case ALG_ID_ECDSA:
1065 if (!wcscmp( prop, BCRYPT_ECC_CURVE_NAME ))
1066 {
1067 TRACE( "curve %s\n", debugstr_w((const WCHAR *)value) );
1068 if (!wcscmp( (const WCHAR *)value, BCRYPT_ECC_CURVE_25519 ))
1069 {
1070 if (alg->id != ALG_ID_ECDH) return STATUS_NOT_SUPPORTED;
1071 alg->curve_id = ECC_CURVE_25519;
1072 return STATUS_SUCCESS;
1073 }
1074 else if (!wcscmp( (WCHAR *)value, BCRYPT_ECC_CURVE_SECP256R1 ))
1075 {
1076 alg->curve_id = ECC_CURVE_P256R1;
1077 return STATUS_SUCCESS;
1078 }
1079 else if (!wcscmp( (WCHAR *)value, BCRYPT_ECC_CURVE_SECP384R1 ))
1080 {
1081 alg->curve_id = ECC_CURVE_P384R1;
1082 return STATUS_SUCCESS;
1083 }
1084 else if (!wcscmp( (WCHAR *)value, BCRYPT_ECC_CURVE_SECP521R1 ))
1085 {
1086 alg->curve_id = ECC_CURVE_P521R1;
1087 return STATUS_SUCCESS;
1088 }
1089 else if (!wcscmp( (WCHAR *)value, BCRYPT_ECC_CURVE_BRAINPOOLP256R1 ))
1090 {
1091 alg->curve_id = ECC_CURVE_BRAINPOOLP256R1;
1092 return STATUS_SUCCESS;
1093 }
1094 else if (!wcscmp( (WCHAR *)value, BCRYPT_ECC_CURVE_BRAINPOOLP384R1 ))
1095 {
1096 alg->curve_id = ECC_CURVE_BRAINPOOLP384R1;
1097 return STATUS_SUCCESS;
1098 }
1099 FIXME( "unsupported curve %s\n", debugstr_w((WCHAR *)value) );
1100 return STATUS_NOT_IMPLEMENTED;
1101 }
1102 FIXME( "unsupported ECDH/ECDSA algorithm property %s\n", debugstr_w(prop) );
1103 return STATUS_NOT_IMPLEMENTED;
1104
1105 default:
1106 FIXME( "unsupported algorithm %u\n", alg->id );
1107 return STATUS_NOT_IMPLEMENTED;
1108 }
1109}
1110
1111static NTSTATUS set_dh_parameters( struct key *key, const UCHAR *buf, ULONG size )
1112{
1113 BCRYPT_DH_PARAMETER_HEADER *hdr = (BCRYPT_DH_PARAMETER_HEADER *)buf;
1114 UCHAR *prime, *generator;
1115 ULONG key_size = len_from_bitlen( key->a.bitlen );
1116
1117 if (key->alg_id != ALG_ID_DH || (key->flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
1118
1119 if (size < sizeof(*hdr) || hdr->dwMagic != BCRYPT_DH_PARAMETERS_MAGIC || hdr->cbKeyLength != key_size ||
1120 hdr->cbLength != sizeof(*hdr) + key_size * 2 || size != hdr->cbLength) return STATUS_INVALID_PARAMETER;
1121
1122 if (!key->a.dsa.group && !(key->a.dsa.group = SymCryptDlgroupAllocate( key_size * 8, 0 )))
1123 return STATUS_NO_MEMORY;
1124
1125 prime = (UCHAR *)(hdr + 1);
1126 generator = prime + key_size;
1127
1128 if (SymCryptDlgroupSetValue( prime, key_size, NULL, 0, generator, key_size, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
1129 NULL, NULL, 0, key->a.dsa.count, SYMCRYPT_DLGROUP_FIPS_NONE, key->a.dsa.group ))
1130 return STATUS_INTERNAL_ERROR;
1131
1132 return STATUS_SUCCESS;
1133}
1134
1135static const SYMCRYPT_MAC *get_hmac_from_hash( const WCHAR *alg )
1136{
1137 if (!alg) return NULL;
1138 if (!wcscmp( alg, BCRYPT_SHA1_ALGORITHM )) return SymCryptHmacSha1Algorithm;
1139 if (!wcscmp( alg, BCRYPT_SHA256_ALGORITHM )) return SymCryptHmacSha256Algorithm;
1140 if (!wcscmp( alg, BCRYPT_SHA384_ALGORITHM )) return SymCryptHmacSha384Algorithm;
1141 if (!wcscmp( alg, BCRYPT_SHA512_ALGORITHM )) return SymCryptHmacSha512Algorithm;
1142
1143 FIXME( "hash algorithm %s not supported\n", debugstr_w(alg) );
1144 return NULL;
1145}
1146
1147static NTSTATUS hkdf_finalize( struct key *key, UCHAR *salt, ULONG salt_len )
1148{
1149 SYMCRYPT_ERROR error;
1150
1151 if (salt)
1152 error = SymCryptHkdfExpandKey( &key->s.hkdf.handle, key->s.hkdf.hmac, key->s.secret, key->s.secret_len, salt,
1153 salt_len );
1154 else
1155 error = SymCryptHkdfPrkExpandKey( &key->s.hkdf.handle, key->s.hkdf.hmac, key->s.secret, key->s.secret_len );
1156
1157 if (error) return STATUS_INTERNAL_ERROR;
1158 return STATUS_SUCCESS;
1159}
1160
1161static NTSTATUS set_key_property( struct key *key, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
1162{
1163 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
1164 {
1165 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB ))
1166 {
1167 key->s.mode = CHAIN_MODE_ECB;
1168 return STATUS_SUCCESS;
1169 }
1170 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
1171 {
1172 key->s.mode = CHAIN_MODE_CBC;
1173 return STATUS_SUCCESS;
1174 }
1175 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM ))
1176 {
1177 key->s.mode = CHAIN_MODE_GCM;
1178 return STATUS_SUCCESS;
1179 }
1180 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CFB ))
1181 {
1182 key->s.mode = CHAIN_MODE_CFB;
1183 return STATUS_SUCCESS;
1184 }
1185 else
1186 {
1187 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
1188 return STATUS_NOT_IMPLEMENTED;
1189 }
1190 }
1191 else if (!wcscmp( prop, BCRYPT_INITIALIZATION_VECTOR ))
1192 {
1193 if (!is_symmetric_key( key )) return STATUS_INVALID_HANDLE;
1194 if (size != key->s.block_size || size > sizeof(key->s.vector)) return STATUS_INVALID_PARAMETER;
1195
1196 EnterCriticalSection( &key->s.cs );
1197 memcpy( key->s.vector, value, size );
1198 LeaveCriticalSection( &key->s.cs );
1199 return STATUS_SUCCESS;
1200 }
1201 else if (!wcscmp( prop, BCRYPT_KEY_LENGTH ))
1202 {
1203 if (size < sizeof(DWORD)) return STATUS_INVALID_PARAMETER;
1204 key->a.bitlen = *(DWORD*)value;
1205 return STATUS_SUCCESS;
1206 }
1207 else if (!wcscmp( prop, BCRYPT_DH_PARAMETERS ))
1208 {
1209 return set_dh_parameters( key, value, size );
1210 }
1211 else if (!wcscmp( prop, BCRYPT_HKDF_HASH_ALGORITHM ))
1212 {
1213 if (!(key->s.hkdf.hmac = get_hmac_from_hash( (const WCHAR *)value )))
1214 return STATUS_INVALID_PARAMETER;
1215 return STATUS_SUCCESS;
1216 }
1217 else if (!wcscmp( prop, BCRYPT_HKDF_SALT_AND_FINALIZE ))
1218 {
1219 return hkdf_finalize( key, value, size );
1220 }
1221 else if (!wcscmp( prop, BCRYPT_HKDF_PRK_AND_FINALIZE ))
1222 {
1223 return hkdf_finalize( key, NULL, 0 );
1224 }
1225
1226 FIXME( "unsupported key property %s\n", debugstr_w(prop) );
1227 return STATUS_NOT_IMPLEMENTED;
1228}
1229
1230NTSTATUS WINAPI BCryptSetProperty( BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
1231{
1232 struct object *object = get_object( handle, 0 );
1233
1234 TRACE( "%p, %s, %p, %lu, %#lx\n", handle, debugstr_w(prop), value, size, flags );
1235
1236 if (!handle) return STATUS_INVALID_HANDLE;
1237 if (is_alg_pseudo_handle( handle )) return STATUS_ACCESS_DENIED;
1238
1239 switch (object->magic)
1240 {
1241 case MAGIC_ALG:
1242 {
1243 struct algorithm *alg = (struct algorithm *)object;
1244 return set_alg_property( alg, prop, value, size, flags );
1245 }
1246 case MAGIC_KEY:
1247 {
1248 struct key *key = (struct key *)object;
1249 return set_key_property( key, prop, value, size, flags );
1250 }
1251 default:
1252 WARN( "unknown magic %#lx\n", object->magic );
1253 return STATUS_INVALID_HANDLE;
1254 }
1255}
1256
1257static NTSTATUS get_hash_property( const struct hash *hash, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
1258{
1259 NTSTATUS status;
1260
1261 if ((status = get_generic_alg_property( hash->alg_id, prop, buf, size, ret_size )) == STATUS_NOT_IMPLEMENTED)
1262 FIXME( "unsupported property %s\n", debugstr_w(prop) );
1263 return status;
1264}
1265
1266static NTSTATUS get_dh_parameters( const struct key *key, UCHAR *buf, ULONG size, ULONG *ret_size )
1267{
1268 BCRYPT_DH_PARAMETER_HEADER *hdr = (BCRYPT_DH_PARAMETER_HEADER *)buf;
1269 UCHAR *prime, *generator;
1270 UINT32 key_size = len_from_bitlen( key->a.bitlen ), required_size = sizeof(*hdr) + key_size * 2;
1271
1272 if (!(key->flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
1273
1274 *ret_size = required_size;
1275 if (!buf) return STATUS_SUCCESS;
1276 else if (size < required_size) return STATUS_BUFFER_TOO_SMALL;
1277
1278 prime = (UCHAR *)(hdr + 1);
1279 generator = prime + key_size;
1280
1281 if (SymCryptDlgroupGetValue( key->a.dsa.group, prime, key_size, NULL, 0, generator, key_size,
1282 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, NULL, (BYTE *)key->a.dsa.seed,
1283 sizeof(key->a.dsa.seed), (UINT32 *)&key->a.dsa.count )) return STATUS_INTERNAL_ERROR;
1284
1285 hdr->cbLength = sizeof(*hdr) + key_size * 2;
1286 hdr->dwMagic = BCRYPT_DH_PARAMETERS_MAGIC;
1287 hdr->cbKeyLength = key_size;
1288
1289 return STATUS_SUCCESS;
1290}
1291
1292static NTSTATUS get_key_property( const struct key *key, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
1293{
1294 if (!wcscmp( prop, BCRYPT_KEY_STRENGTH ))
1295 {
1296 DWORD value = is_symmetric_key (key ) ? key->s.block_size * 8 : key->a.bitlen;
1297 return get_dword_property( buf, size, ret_size, value );
1298 }
1299
1300 switch (key->alg_id)
1301 {
1302 case ALG_ID_3DES:
1303 return get_3des_property( key->s.mode, prop, buf, size, ret_size );
1304
1305 case ALG_ID_AES:
1306 case ALG_ID_AES_GMAC:
1307 if (!wcscmp( prop, BCRYPT_AUTH_TAG_LENGTH )) return STATUS_NOT_SUPPORTED;
1308 return get_aes_property( key->s.mode, prop, buf, size, ret_size );
1309
1310 case ALG_ID_DH:
1311 if (wcscmp( prop, BCRYPT_DH_PARAMETERS )) return STATUS_NOT_SUPPORTED;
1312 return get_dh_parameters( key, buf, size, ret_size );
1313
1314 case ALG_ID_RSA:
1315 case ALG_ID_RSA_SIGN:
1316 if (wcscmp( prop, BCRYPT_SIGNATURE_LENGTH )) return STATUS_NOT_SUPPORTED;
1317 return get_dword_property( buf, size, ret_size, key->a.bitlen / 8 );
1318
1319 default:
1320 FIXME( "unsupported algorithm %u\n", key->alg_id );
1321 return STATUS_NOT_IMPLEMENTED;
1322 }
1323}
1324
1325NTSTATUS WINAPI BCryptGetProperty( BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *buffer, ULONG count, ULONG *res,
1326 ULONG flags )
1327{
1328 const struct object *object = get_object( handle, 0 );
1329
1330 TRACE( "%p, %s, %p, %lu, %p, %#lx\n", handle, wine_dbgstr_w(prop), buffer, count, res, flags );
1331
1332 if (!object) return STATUS_INVALID_HANDLE;
1333 if (!prop || !res) return STATUS_INVALID_PARAMETER;
1334
1335 switch (object->magic)
1336 {
1337 case MAGIC_ALG:
1338 {
1339 const struct algorithm *alg = (const struct algorithm *)object;
1340 return get_alg_property( alg, prop, buffer, count, res );
1341 }
1342 case MAGIC_KEY:
1343 {
1344 const struct key *key = (const struct key *)object;
1345 return get_key_property( key, prop, buffer, count, res );
1346 }
1347 case MAGIC_HASH:
1348 {
1349 const struct hash *hash = (const struct hash *)object;
1350 return get_hash_property( hash, prop, buffer, count, res );
1351 }
1352 default:
1353 WARN( "unknown magic %#lx\n", object->magic );
1354 return STATUS_INVALID_HANDLE;
1355 }
1356}
1357
1358static void prepare_hash( struct hash *hash )
1359{
1360 if (hash->flags & HASH_FLAG_HMAC)
1361 {
1362 SymCryptHmacExpandKey( hash->desc, &hash->hmac, hash->secret, hash->secret_len );
1363 SymCryptHmacInit( &hash->hmac_state, &hash->hmac );
1364 }
1365 else SymCryptHashInit( hash->desc, &hash->state );
1366}
1367
1368static const SYMCRYPT_HASH *get_hash_from_alg( enum alg_id alg_id )
1369{
1370 switch (alg_id)
1371 {
1372 case ALG_ID_MD2: return SymCryptMd2Algorithm;
1373 case ALG_ID_MD4: return SymCryptMd4Algorithm;
1374 case ALG_ID_MD5: return SymCryptMd5Algorithm;
1375 case ALG_ID_SHA1: return SymCryptSha1Algorithm;
1376 case ALG_ID_SHA256: return SymCryptSha256Algorithm;
1377 case ALG_ID_SHA384: return SymCryptSha384Algorithm;
1378 case ALG_ID_SHA512: return SymCryptSha512Algorithm;
1379 default:
1380 FIXME( "unhandled algorithm %u\n", alg_id );
1381 return NULL;
1382 }
1383}
1384
1385static NTSTATUS create_hash( const struct algorithm *alg, UCHAR *secret, ULONG secret_len, ULONG flags,
1386 struct hash **ret_hash )
1387{
1388 struct hash *hash;
1389 const SYMCRYPT_HASH *desc = get_hash_from_alg( alg->id );
1390
1391 if (secret && !(alg->flags & BCRYPT_ALG_HANDLE_HMAC_FLAG)) return STATUS_INVALID_PARAMETER;
1392
1393 if (!desc) return STATUS_NOT_IMPLEMENTED;
1394 if (!(hash = calloc( 1, sizeof(*hash) ))) return STATUS_NO_MEMORY;
1395 hash->hdr.magic = MAGIC_HASH;
1396 hash->alg_id = alg->id;
1397 hash->len = builtin_algorithms[alg->id].hash_length;
1398 hash->desc = desc;
1399 if (alg->flags & BCRYPT_ALG_HANDLE_HMAC_FLAG) hash->flags = HASH_FLAG_HMAC;
1400 if ((alg->flags & BCRYPT_HASH_REUSABLE_FLAG) || (flags & BCRYPT_HASH_REUSABLE_FLAG))
1401 hash->flags |= HASH_FLAG_REUSABLE;
1402
1403 if (secret_len && !(hash->secret = malloc( secret_len )))
1404 {
1405 free( hash );
1406 return STATUS_NO_MEMORY;
1407 }
1408 memcpy( hash->secret, secret, secret_len );
1409 hash->secret_len = secret_len;
1410
1411 prepare_hash( hash );
1412 *ret_hash = hash;
1413 return STATUS_SUCCESS;
1414}
1415
1416NTSTATUS WINAPI BCryptCreateHash( BCRYPT_ALG_HANDLE handle, BCRYPT_HASH_HANDLE *ret_handle, UCHAR *object,
1417 ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags )
1418{
1419 struct algorithm *alg = get_alg_object( handle );
1420 struct hash *hash;
1421 NTSTATUS status;
1422
1423 TRACE( "%p, %p, %p, %lu, %p, %lu, %#lx\n", handle, ret_handle, object, object_len, secret, secret_len, flags );
1424 if (flags & ~BCRYPT_HASH_REUSABLE_FLAG)
1425 {
1426 FIXME( "unimplemented flags %#lx\n", flags );
1427 return STATUS_NOT_IMPLEMENTED;
1428 }
1429 if (object) FIXME( "ignoring object buffer\n" );
1430
1431 if (!alg) return STATUS_INVALID_HANDLE;
1432 if (!ret_handle) return STATUS_INVALID_PARAMETER;
1433
1434 if ((status = create_hash( alg, secret, secret_len, flags, &hash ))) return status;
1435 *ret_handle = hash;
1436
1437 TRACE( "returning handle %p\n", *ret_handle );
1438 return STATUS_SUCCESS;
1439}
1440
1441NTSTATUS WINAPI BCryptDuplicateHash( BCRYPT_HASH_HANDLE handle, BCRYPT_HASH_HANDLE *handle_copy, UCHAR *object,
1442 ULONG object_len, ULONG flags )
1443{
1444 const struct hash *hash_orig = get_hash_object( handle );
1445 struct hash *hash_copy;
1446
1447 TRACE( "%p, %p, %p, %lu, %#lx\n", handle, handle_copy, object, object_len, flags );
1448
1449 if (!hash_orig) return STATUS_INVALID_HANDLE;
1450 if (!handle_copy) return STATUS_INVALID_PARAMETER;
1451 if (object) FIXME( "ignoring object buffer\n" );
1452
1453 if (!(hash_copy = malloc( sizeof(*hash_copy) ))) return STATUS_NO_MEMORY;
1454
1455 memcpy( hash_copy, hash_orig, sizeof(*hash_orig) );
1456 if (hash_orig->secret && !(hash_copy->secret = malloc( hash_orig->secret_len )))
1457 {
1458 free( hash_copy );
1459 return STATUS_NO_MEMORY;
1460 }
1461 memcpy( hash_copy->secret, hash_orig->secret, hash_orig->secret_len );
1462
1463 if (hash_orig->flags & HASH_FLAG_HMAC)
1464 {
1465 SymCryptHmacKeyCopy( &hash_orig->hmac, &hash_copy->hmac );
1466 SymCryptHmacStateCopy( &hash_orig->hmac_state, &hash_orig->hmac, &hash_copy->hmac_state );
1467 }
1468 else
1469 SymCryptHashStateCopy( hash_orig->desc, &hash_orig->state, &hash_copy->state );
1470
1471 *handle_copy = hash_copy;
1472 TRACE( "returning handle %p\n", *handle_copy );
1473 return STATUS_SUCCESS;
1474}
1475
1476static void destroy_hash( struct hash *hash )
1477{
1478 if (!hash) return;
1479 free( hash->secret );
1480 destroy_object( &hash->hdr );
1481}
1482
1483NTSTATUS WINAPI BCryptDestroyHash( BCRYPT_HASH_HANDLE handle )
1484{
1485 struct hash *hash = get_hash_object( handle );
1486
1487 TRACE( "%p\n", handle );
1488
1489 if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_PARAMETER;
1490
1491 destroy_hash( hash );
1492 return STATUS_SUCCESS;
1493}
1494
1495static void hash_data( struct hash *hash, UCHAR *input, ULONG size )
1496{
1497 if (hash->flags & HASH_FLAG_HMAC)
1498 SymCryptHmacAppend( &hash->hmac_state, input, size );
1499 else
1500 SymCryptHashAppend( hash->desc, &hash->state, input, size );
1501}
1502
1503NTSTATUS WINAPI BCryptHashData( BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags )
1504{
1505 struct hash *hash = get_hash_object( handle );
1506
1507 TRACE( "%p, %p, %lu, %#lx\n", handle, input, size, flags );
1508
1509 if (!hash) return STATUS_INVALID_HANDLE;
1510
1511 hash_data( hash, input, size );
1512 return STATUS_SUCCESS;
1513}
1514
1515static void finish_hash( struct hash *hash, UCHAR *output )
1516{
1517 if (hash->flags & HASH_FLAG_HMAC)
1518 SymCryptHmacResult( &hash->hmac_state, output );
1519 else
1520 SymCryptHashResult( hash->desc, &hash->state, output, hash->len );
1521
1522 if (hash->flags & HASH_FLAG_REUSABLE) prepare_hash( hash );
1523}
1524
1525NTSTATUS WINAPI BCryptFinishHash( BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags )
1526{
1527 struct hash *hash = get_hash_object( handle );
1528
1529 TRACE( "%p, %p, %lu, %#lx\n", handle, output, size, flags );
1530
1531 if (!hash) return STATUS_INVALID_HANDLE;
1532 if (!output || size != hash->len) return STATUS_INVALID_PARAMETER;
1533
1534 finish_hash( hash, output );
1535 return STATUS_SUCCESS;
1536}
1537
1538static NTSTATUS hash_single( const struct algorithm *alg, UCHAR *secret, ULONG secret_len, UCHAR *input,
1539 ULONG input_len, UCHAR *output )
1540{
1541 struct hash *hash;
1542 NTSTATUS status;
1543
1544 if ((status = create_hash( alg, secret, secret_len, 0, &hash ))) return status;
1545
1546 if (hash->flags & HASH_FLAG_HMAC)
1547 SymCryptHmac( &hash->hmac, input, input_len, output );
1548 else
1549 SymCryptHash( hash->desc, input, input_len, output, hash->len );
1550
1551 destroy_hash( hash );
1552 return STATUS_SUCCESS;
1553}
1554
1555NTSTATUS WINAPI BCryptHash( BCRYPT_ALG_HANDLE handle, UCHAR *secret, ULONG secret_len, UCHAR *input, ULONG input_len,
1556 UCHAR *output, ULONG output_len )
1557{
1558 struct algorithm *alg = get_alg_object( handle );
1559
1560 TRACE( "%p, %p, %lu, %p, %lu, %p, %lu\n", handle, secret, secret_len, input, input_len, output, output_len );
1561
1562 if (!alg) return STATUS_INVALID_HANDLE;
1563 if (!output || output_len != builtin_algorithms[alg->id].hash_length) return STATUS_INVALID_PARAMETER;
1564
1565 return hash_single( alg, secret, secret_len, input, input_len, output );
1566}
1567
1568static void destroy_key( struct key *key )
1569{
1570 if (!key) return;
1571 if (is_symmetric_key( key ))
1572 {
1573 secure_zero( key->s.secret, key->s.secret_len );
1574 free( key->s.secret );
1575 secure_zero( key->s.vector, key->s.block_size );
1576 DeleteCriticalSection( &key->s.cs );
1577 }
1578 else
1579 {
1580 switch (key->alg_id)
1581 {
1582 case ALG_ID_RSA:
1583 case ALG_ID_RSA_SIGN:
1584 if (key->a.rsa.handle) SymCryptRsakeyFree( key->a.rsa.handle );
1585 break;
1586 case ALG_ID_ECDH:
1587 case ALG_ID_ECDH_P256:
1588 case ALG_ID_ECDH_P384:
1589 case ALG_ID_ECDH_P521:
1590 case ALG_ID_ECDSA:
1591 case ALG_ID_ECDSA_P256:
1592 case ALG_ID_ECDSA_P384:
1593 case ALG_ID_ECDSA_P521:
1594 if (key->a.ecc.handle) SymCryptEckeyFree( key->a.ecc.handle );
1595 if (key->a.ecc.curve) SymCryptEcurveFree( key->a.ecc.curve );
1596 break;
1597 case ALG_ID_DH:
1598 case ALG_ID_DSA:
1599 if (key->a.dsa.handle) SymCryptDlkeyFree( key->a.dsa.handle );
1600 if (key->a.dsa.group) SymCryptDlgroupFree( key->a.dsa.group );
1601 break;
1602 default:
1603 FIXME( "algorithm %u not handled\n", key->alg_id );
1604 break;
1605 }
1606 }
1607
1608 secure_zero( &key->hdr.magic, sizeof(key->hdr.magic) );
1609 _aligned_free( key );
1610}
1611
1612static NTSTATUS alloc_aes_key( struct key *key, enum chain_mode mode, ULONG block_size, const UCHAR *secret,
1613 ULONG secret_len )
1614{
1615 key->s.mode = mode;
1616 key->s.block_size = block_size;
1617
1618 if (!(key->s.secret = malloc( secret_len ))) return STATUS_NO_MEMORY;
1619 memcpy( key->s.secret, secret, secret_len );
1620 key->s.secret_len = secret_len;
1621
1622 InitializeCriticalSection( &key->s.cs );
1623
1624 switch (mode)
1625 {
1626 case CHAIN_MODE_ECB:
1627 case CHAIN_MODE_CBC:
1628 case CHAIN_MODE_CFB:
1629 if (SymCryptAesExpandKey( &key->s.aes.handle, secret, secret_len )) return STATUS_INTERNAL_ERROR;
1630 break;
1631
1632 case CHAIN_MODE_GCM:
1633 if (SymCryptGcmExpandKey( &key->s.gcm.handle, SymCryptAesBlockCipher, secret, secret_len ))
1634 return STATUS_INTERNAL_ERROR;
1635 break;
1636
1637 default:
1638 FIXME( "unhandled mode %u\n", mode );
1639 return STATUS_NOT_SUPPORTED;
1640 }
1641
1642 return STATUS_SUCCESS;
1643}
1644
1645static NTSTATUS alloc_key( enum alg_id alg_id, ULONG flags, struct key **ret_key )
1646{
1647 struct key *key;
1648
1649 if (!(key = _aligned_malloc( sizeof(struct key), TYPE_ALIGNMENT(struct key) ))) return STATUS_NO_MEMORY;
1650 memset( key, 0, sizeof(*key) );
1651 key->hdr.magic = MAGIC_KEY;
1652 key->alg_id = alg_id;
1653 key->flags = flags;
1654
1655 *ret_key = key;
1656 return STATUS_SUCCESS;
1657}
1658
1659static NTSTATUS validate_len_aes( const BCRYPT_KEY_LENGTHS_STRUCT *key_lengths, ULONG secret_len, ULONG *ret_len )
1660{
1661 ULONG size;
1662
1663 if (secret_len > (size = key_lengths->dwMaxLength / 8))
1664 {
1665 WARN( "secret_len %lu exceeds key max length %lu, setting to maximum\n", secret_len, size );
1666 *ret_len = size;
1667 return STATUS_SUCCESS;
1668 }
1669 else if (secret_len < (size = key_lengths->dwMinLength / 8))
1670 {
1671 WARN( "secret_len %lu is less than minimum key length %lu\n", secret_len, size );
1672 return STATUS_INVALID_PARAMETER;
1673 }
1674 else if (key_lengths->dwIncrement && (secret_len * 8 - key_lengths->dwMinLength) % key_lengths->dwIncrement)
1675 {
1676 WARN( "secret_len %lu is not a valid key length\n", secret_len );
1677 return STATUS_INVALID_PARAMETER;
1678 }
1679
1680 *ret_len = secret_len;
1681 return STATUS_SUCCESS;
1682}
1683
1684static NTSTATUS generate_symmetric_key( const struct algorithm *alg, const UCHAR *secret, ULONG secret_len,
1685 struct key **ret_key )
1686{
1687 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
1688 struct key *key;
1689 NTSTATUS status;
1690 ULONG size;
1691
1692 if ((status = get_alg_property( alg, BCRYPT_KEY_LENGTHS, (UCHAR *)&key_lengths, sizeof(key_lengths), &size )))
1693 return status;
1694
1695 if ((status = alloc_key( alg->id, 0, &key ))) return status;
1696
1697 switch (alg->id)
1698 {
1699 case ALG_ID_AES:
1700 case ALG_ID_AES_GMAC:
1701 if ((status = validate_len_aes( &key_lengths, secret_len, &secret_len )) ||
1702 (status = alloc_aes_key( key, alg->chain_mode, BLOCK_LENGTH_AES, secret, secret_len )))
1703 {
1704 destroy_key( key );
1705 return status;
1706 }
1707 break;
1708
1709 case ALG_ID_PBKDF2:
1710 case ALG_ID_TLS1_1_KDF:
1711 case ALG_ID_TLS1_2_KDF:
1712 case ALG_ID_HKDF:
1713 if (secret_len > key_lengths.dwMaxLength / 8 || secret_len < key_lengths.dwMinLength / 8)
1714 {
1715 destroy_key( key );
1716 return STATUS_INVALID_PARAMETER;
1717 }
1718 if (!(key->s.secret = malloc( secret_len )))
1719 {
1720 destroy_key( key );
1721 return STATUS_NO_MEMORY;
1722 }
1723 memcpy( key->s.secret, secret, secret_len );
1724 key->s.block_size = key->s.secret_len = secret_len;
1725 break;
1726
1727 default:
1728 FIXME( "unhandled algorithm %u\n", alg->id );
1729 destroy_key( key );
1730 return STATUS_NOT_SUPPORTED;
1731 }
1732
1733 *ret_key = key;
1734 return status;
1735}
1736
1737NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *object,
1738 ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags )
1739{
1740 const struct algorithm *alg = get_alg_object( handle );
1741 struct key *key;
1742 NTSTATUS status;
1743
1744 TRACE( "%p, %p, %p, %lu, %p, %lu, %#lx\n", handle, ret_handle, object, object_len, secret, secret_len, flags );
1745 if (object) FIXME( "ignoring object buffer\n" );
1746
1747 if (!alg) return STATUS_INVALID_HANDLE;
1748
1749 if ((status = generate_symmetric_key( alg, secret, secret_len, &key ))) return status;
1750 *ret_handle = key;
1751
1752 TRACE( "returning handle %p\n", *ret_handle );
1753 return STATUS_SUCCESS;
1754}
1755
1756static NTSTATUS decrypt_aes_ecb( const struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
1757 ULONG output_len, ULONG *ret_len, ULONG flags )
1758{
1759 ULONG offset = input_len, block_size = key->s.block_size;
1760 UCHAR buf[BLOCK_LENGTH_AES];
1761 NTSTATUS status = STATUS_SUCCESS;
1762
1763 if (input_len & (block_size - 1)) return STATUS_INVALID_BUFFER_SIZE;
1764 if (!output) return STATUS_SUCCESS;
1765
1766 if (flags & BCRYPT_BLOCK_PADDING)
1767 {
1768 if (output_len + block_size < *ret_len || input_len < block_size) return STATUS_BUFFER_TOO_SMALL;
1769 offset -= block_size;
1770 }
1771 else if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1772
1773 SymCryptEcbDecrypt( SymCryptAesBlockCipher, &key->s.aes.handle, input, output, offset );
1774
1775 if (flags & BCRYPT_BLOCK_PADDING)
1776 {
1777 SymCryptEcbDecrypt( SymCryptAesBlockCipher, &key->s.aes.handle, input + offset, buf, block_size );
1778
1779 if (buf[block_size - 1] <= block_size)
1780 {
1781 *ret_len -= buf[block_size - 1];
1782 if (output_len < *ret_len) status = STATUS_BUFFER_TOO_SMALL;
1783 else memcpy( output + offset, buf, block_size - buf[block_size - 1] );
1784 }
1785 else status = STATUS_UNSUCCESSFUL; /* FIXME: invalid padding */
1786 }
1787
1788 return status;
1789}
1790
1791static NTSTATUS decrypt_aes_gcm( struct key *key, const UCHAR *input, ULONG input_len,
1792 const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *output, ULONG output_len,
1793 ULONG *ret_len )
1794{
1795 SYMCRYPT_ERROR error;
1796
1797 if (!info || !info->pbNonce || !info->pbTag || info->cbTag < 12 || info->cbTag > 16)
1798 return STATUS_INVALID_PARAMETER;
1799 if (info->dwFlags & BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG) FIXME( "call chaining not implemented\n" );
1800
1801 if (!output) return STATUS_SUCCESS;
1802 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1803
1804 EnterCriticalSection( &key->s.cs );
1805
1806 SymCryptGcmInit( &key->s.gcm.state, &key->s.gcm.handle, info->pbNonce, info->cbNonce );
1807 SymCryptGcmAuthPart( &key->s.gcm.state, info->pbAuthData, info->cbAuthData );
1808 SymCryptGcmDecryptPart( &key->s.gcm.state, input, output, input_len );
1809 error = SymCryptGcmDecryptFinal( &key->s.gcm.state, info->pbTag, info->cbTag );
1810
1811 LeaveCriticalSection( &key->s.cs );
1812
1813 if (error == SYMCRYPT_AUTHENTICATION_FAILURE) return STATUS_AUTH_TAG_MISMATCH;
1814 if (error) return STATUS_INTERNAL_ERROR;
1815 return STATUS_SUCCESS;
1816}
1817
1818static NTSTATUS decrypt_aes_vector( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *iv, UCHAR *output,
1819 ULONG output_len, ULONG *ret_len, ULONG flags )
1820{
1821 UCHAR buf[BLOCK_LENGTH_AES], *out;
1822 const UCHAR *in;
1823 ULONG bytes_left = input_len, block_size = key->s.block_size;
1824 NTSTATUS status = STATUS_SUCCESS;
1825
1826 if (input_len & (block_size - 1)) return STATUS_INVALID_BUFFER_SIZE;
1827 if (!output) return STATUS_SUCCESS;
1828
1829 if (flags & BCRYPT_BLOCK_PADDING)
1830 {
1831 if (output_len + block_size < *ret_len || input_len < block_size) return STATUS_BUFFER_TOO_SMALL;
1832 bytes_left -= block_size;
1833 }
1834 else if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1835
1836 EnterCriticalSection( &key->s.cs );
1837
1838 if (iv) memcpy( key->s.vector, iv, block_size );
1839
1840 in = input;
1841 out = output;
1842 while (bytes_left >= block_size)
1843 {
1844 if (key->s.mode == CHAIN_MODE_CFB)
1845 SymCryptCfbDecrypt( SymCryptAesBlockCipher, 1, &key->s.aes.handle, key->s.vector, in, out, block_size );
1846 else
1847 SymCryptCbcDecrypt( SymCryptAesBlockCipher, &key->s.aes.handle, key->s.vector, in, out, block_size );
1848
1849 bytes_left -= block_size;
1850 in += block_size;
1851 out += block_size;
1852 }
1853
1854 if (flags & BCRYPT_BLOCK_PADDING)
1855 {
1856 if (key->s.mode == CHAIN_MODE_CFB)
1857 SymCryptCfbDecrypt( SymCryptAesBlockCipher, 1, &key->s.aes.handle, key->s.vector, in, buf, block_size );
1858 else
1859 SymCryptCbcDecrypt( SymCryptAesBlockCipher, &key->s.aes.handle, key->s.vector, in, buf, block_size );
1860
1861 if (buf[block_size - 1] <= block_size)
1862 {
1863 *ret_len -= buf[block_size - 1];
1864 if (output_len < *ret_len) status = STATUS_BUFFER_TOO_SMALL;
1865 else memcpy( out, buf, block_size - buf[block_size - 1] );
1866 }
1867 else status = STATUS_UNSUCCESSFUL; /* FIXME: invalid padding */
1868 }
1869
1870 if (iv) memcpy( iv, key->s.vector, block_size );
1871
1872 LeaveCriticalSection( &key->s.cs );
1873 return status;
1874}
1875
1876static NTSTATUS decrypt_symmetric( struct key *key, const UCHAR *input, ULONG input_len,
1877 const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *iv, ULONG iv_len,
1878 UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1879{
1880 *ret_len = input_len;
1881
1882 if (key->s.mode == CHAIN_MODE_GCM && (flags & BCRYPT_BLOCK_PADDING)) return STATUS_INVALID_PARAMETER;
1883 if (key->s.mode == CHAIN_MODE_ECB && iv) return STATUS_INVALID_PARAMETER;
1884
1885 switch (key->alg_id)
1886 {
1887 case ALG_ID_AES:
1888 case ALG_ID_AES_GMAC:
1889 switch (key->s.mode)
1890 {
1891 case CHAIN_MODE_ECB:
1892 return decrypt_aes_ecb( key, input, input_len, output, output_len, ret_len, flags );
1893
1894 case CHAIN_MODE_GCM:
1895 return decrypt_aes_gcm( key, input, input_len, info, output, output_len, ret_len );
1896
1897 default:
1898 if (iv && iv_len != key->s.block_size) return STATUS_INVALID_PARAMETER;
1899 return decrypt_aes_vector( key, input, input_len, iv, output, output_len, ret_len, flags );
1900 }
1901 default:
1902 FIXME( "unhandled algorithm %u\n", key->alg_id );
1903 break;
1904 }
1905
1906 return STATUS_NOT_SUPPORTED;
1907}
1908
1909static const SYMCRYPT_HASH *get_hash_from_str( const WCHAR *str )
1910{
1911 if (!str) return NULL;
1912 if (!wcscmp( str, BCRYPT_MD5_ALGORITHM )) return SymCryptMd5Algorithm;
1913 if (!wcscmp( str, BCRYPT_SHA1_ALGORITHM )) return SymCryptSha1Algorithm;
1914 if (!wcscmp( str, BCRYPT_SHA256_ALGORITHM )) return SymCryptSha256Algorithm;
1915 if (!wcscmp( str, BCRYPT_SHA384_ALGORITHM )) return SymCryptSha384Algorithm;
1916 if (!wcscmp( str, BCRYPT_SHA512_ALGORITHM )) return SymCryptSha512Algorithm;
1917
1918 FIXME( "unhandled algorithm %s\n", debugstr_w(str) );
1919 return NULL;
1920}
1921
1922static NTSTATUS decrypt_rsa( const struct key *key, const UCHAR *input, ULONG input_len, const void *padding,
1923 UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1924{
1925 SIZE_T size = len_from_bitlen( key->a.bitlen );
1926
1927 if (!flags || flags == BCRYPT_PAD_NONE)
1928 {
1929 if (input_len % size) return STATUS_INVALID_PARAMETER;
1930
1931 *ret_len = size;
1932 if (output_len < size)
1933 {
1934 if (output) return STATUS_BUFFER_TOO_SMALL;
1935 return STATUS_SUCCESS;
1936 }
1937 if (SymCryptRsaRawDecrypt( key->a.rsa.handle, input, input_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, output,
1938 output_len )) return STATUS_INTERNAL_ERROR;
1939 }
1940 else if (flags == BCRYPT_PAD_PKCS1)
1941 {
1942 if (SymCryptRsaPkcs1Decrypt( key->a.rsa.handle, input, input_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, output,
1943 output_len, &size )) return STATUS_INTERNAL_ERROR;
1944 *ret_len = size;
1945 }
1946 else if (flags == BCRYPT_PAD_OAEP)
1947 {
1948 const BCRYPT_OAEP_PADDING_INFO *pad = padding;
1949 const SYMCRYPT_HASH *hash_desc;
1950
1951 if (!pad) return STATUS_INVALID_PARAMETER;
1952 hash_desc = get_hash_from_str( pad->pszAlgId );
1953
1954 if (SymCryptRsaOaepDecrypt( key->a.rsa.handle, input, input_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, hash_desc,
1955 pad->pbLabel, pad->cbLabel, 0, output, output_len, &size ))
1956 return STATUS_INTERNAL_ERROR;
1957 *ret_len = size;
1958 }
1959 else
1960 {
1961 FIXME( "unsupported flags %#lx", flags );
1962 return STATUS_NOT_SUPPORTED;
1963 }
1964
1965 return STATUS_SUCCESS;
1966}
1967
1968NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1969 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1970{
1971 struct key *key = get_key_object( handle );
1972 NTSTATUS status;
1973
1974 TRACE( "%p, %p, %lu, %p, %p, %lu, %p, %lu, %p, %#lx\n", handle, input, input_len, padding, iv, iv_len, output,
1975 output_len, ret_len, flags );
1976
1977 if (!key) return STATUS_INVALID_HANDLE;
1978
1979 if (is_symmetric_key( key ))
1980 {
1981 if (flags & ~BCRYPT_BLOCK_PADDING)
1982 {
1983 FIXME( "flags %#lx not supported\n", flags );
1984 return STATUS_NOT_IMPLEMENTED;
1985 }
1986
1987 status = decrypt_symmetric( key, input, input_len, padding, iv, iv_len, output, output_len, ret_len, flags );
1988 }
1989 else
1990 {
1991 if (key->alg_id != ALG_ID_RSA) return STATUS_NOT_SUPPORTED;
1992 if (!(key->flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
1993
1994 status = decrypt_rsa( key, input, input_len, padding, output, output_len, ret_len, flags );
1995 }
1996 return status;
1997}
1998
1999/* AES Key Wrap Algorithm (RFC3394) */
2000static NTSTATUS unwrap_aes( const UCHAR *secret, ULONG secret_len, const UCHAR *cipher, ULONG cipher_len, UCHAR *plain )
2001{
2002 UCHAR a[8], *r, b[16];
2003 ULONG len = 16, t, i, n = cipher_len / 8;
2004 NTSTATUS status;
2005 int j;
2006 struct key *key;
2007
2008 memcpy( a, cipher, 8 );
2009 r = plain;
2010 memcpy( r, cipher + 8, 8 * n );
2011
2012 if ((status = alloc_key( ALG_ID_AES, 0, &key ))) return status;
2013 if ((status = alloc_aes_key( key, CHAIN_MODE_ECB, BLOCK_LENGTH_AES, secret, secret_len )))
2014 {
2015 destroy_key( key );
2016 return status;
2017 }
2018
2019 for (j = 5; j >= 0; j--)
2020 {
2021 r = plain + (n - 1) * 8;
2022 for (i = n; i >= 1; i--)
2023 {
2024 memcpy( b, a, 8 );
2025 t = n * j + i;
2026 b[7] ^= t;
2027 b[6] ^= t >> 8;
2028 b[5] ^= t >> 16;
2029 b[4] ^= t >> 24;
2030
2031 memcpy( b + 8, r, 8 );
2032 decrypt_aes_ecb( key, b, 16, b, 16, &len, 0 );
2033 memcpy( a, b, 8 );
2034 memcpy( r, b + 8, 8 );
2035 r -= 8;
2036 }
2037 }
2038
2039 destroy_key( key );
2040
2041 for (i = 0; i < 8; i++) if (a[i] != 0xa6) return STATUS_UNSUCCESSFUL;
2042 return STATUS_SUCCESS;
2043}
2044
2045static NTSTATUS import_key( const struct algorithm *alg, const struct key *decrypt_key, const WCHAR *type,
2046 const UCHAR *input, ULONG input_len, struct key **ret_key )
2047{
2048 ULONG len;
2049 NTSTATUS status;
2050
2051 if (decrypt_key && wcscmp( type, BCRYPT_AES_WRAP_KEY_BLOB ))
2052 {
2053 FIXME( "decryption of key not supported\n" );
2054 return STATUS_NOT_IMPLEMENTED;
2055 }
2056
2057 if (!wcscmp( type, BCRYPT_KEY_DATA_BLOB ))
2058 {
2059 BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)input;
2060
2061 if (input_len < sizeof(BCRYPT_KEY_DATA_BLOB_HEADER)) return STATUS_BUFFER_TOO_SMALL;
2062 if (header->dwMagic != BCRYPT_KEY_DATA_BLOB_MAGIC) return STATUS_INVALID_PARAMETER;
2063 if (header->dwVersion != BCRYPT_KEY_DATA_BLOB_VERSION1)
2064 {
2065 FIXME( "unknown key data blob version %lu\n", header->dwVersion );
2066 return STATUS_INVALID_PARAMETER;
2067 }
2068 len = header->cbKeyData;
2069 if (len + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) > input_len) return STATUS_INVALID_PARAMETER;
2070
2071 return generate_symmetric_key( alg, (UCHAR *)&header[1], len, ret_key );
2072 }
2073 else if (!wcscmp( type, BCRYPT_OPAQUE_KEY_BLOB ))
2074 {
2075 if (input_len < sizeof(len)) return STATUS_BUFFER_TOO_SMALL;
2076 len = *(ULONG *)input;
2077 if (len + sizeof(len) > input_len) return STATUS_INVALID_PARAMETER;
2078
2079 return generate_symmetric_key( alg, input + sizeof(len), len, ret_key);
2080 }
2081 else if (!wcscmp( type, BCRYPT_AES_WRAP_KEY_BLOB ))
2082 {
2083 UCHAR output[32];
2084
2085 if (!decrypt_key || input_len < 8) return STATUS_INVALID_PARAMETER;
2086
2087 len = input_len - 8;
2088 if (len < BLOCK_LENGTH_AES || len > sizeof(output) || len & (BLOCK_LENGTH_AES - 1))
2089 return STATUS_INVALID_PARAMETER;
2090
2091 if ((status = unwrap_aes( decrypt_key->s.secret, decrypt_key->s.secret_len, input, len, output )))
2092 return status;
2093
2094 return generate_symmetric_key( alg, output, len, ret_key );
2095 }
2096
2097 FIXME( "unsupported blob type %s\n", debugstr_w(type) );
2098 return STATUS_NOT_IMPLEMENTED;
2099}
2100
2101NTSTATUS WINAPI BCryptImportKey( BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE decrypt_key_handle, const WCHAR *type,
2102 BCRYPT_KEY_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *input,
2103 ULONG input_len, ULONG flags )
2104{
2105 const struct algorithm *alg = get_alg_object( handle );
2106 struct key *key;
2107 const struct key *decrypt_key = NULL;
2108 NTSTATUS status;
2109
2110 TRACE( "%p, %p, %s, %p, %p, %lu, %p, %lu, %#lx\n", handle, decrypt_key_handle, debugstr_w(type), ret_handle,
2111 object, object_len, input, input_len, flags );
2112
2113 if (!alg || !is_symmetric_alg( alg )) return STATUS_INVALID_HANDLE;
2114 if (!ret_handle || !type || !input) return STATUS_INVALID_PARAMETER;
2115 if (decrypt_key_handle && !(decrypt_key = get_key_object( decrypt_key_handle ))) return STATUS_INVALID_HANDLE;
2116
2117 if ((status = import_key( alg, decrypt_key, type, input, input_len, &key ))) return status;
2118 *ret_handle = key;
2119
2120 TRACE( "returning handle %p\n", *ret_handle );
2121 return STATUS_SUCCESS;
2122}
2123
2124static NTSTATUS encrypt_aes_ecb( const struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output,
2125 ULONG output_len, ULONG *ret_len, ULONG flags )
2126{
2127 ULONG bytes_left, offset, block_size = key->s.block_size;
2128 UCHAR buf[BLOCK_LENGTH_AES];
2129
2130 if (flags & BCRYPT_BLOCK_PADDING) *ret_len = (input_len + block_size) & ~(block_size - 1);
2131 else if (input_len & (block_size - 1)) return STATUS_INVALID_BUFFER_SIZE;
2132
2133 if (!output) return STATUS_SUCCESS;
2134 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
2135
2136 bytes_left = input_len % block_size;
2137 offset = input_len - bytes_left;
2138
2139 SymCryptEcbEncrypt( SymCryptAesBlockCipher, &key->s.aes.handle, input, output, offset );
2140
2141 if (flags & BCRYPT_BLOCK_PADDING)
2142 {
2143 memcpy( buf, input + offset, bytes_left );
2144 memset( buf + bytes_left, block_size - bytes_left, block_size - bytes_left );
2145
2146 SymCryptEcbEncrypt( SymCryptAesBlockCipher, &key->s.aes.handle, buf, output + offset, block_size );
2147 }
2148
2149 return STATUS_SUCCESS;
2150}
2151
2152static NTSTATUS encrypt_aes_gcm( struct key *key, const UCHAR *input, ULONG input_len,
2153 const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *output, ULONG output_len,
2154 ULONG *ret_len )
2155{
2156 if (!info || !info->pbNonce || !info->pbTag || info->cbTag < 12 || info->cbTag > 16)
2157 return STATUS_INVALID_PARAMETER;
2158 if (info->dwFlags & BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG) FIXME( "call chaining not implemented\n" );
2159
2160 if (input && !input_len) return STATUS_SUCCESS;
2161 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
2162
2163 EnterCriticalSection( &key->s.cs );
2164
2165 SymCryptGcmInit( &key->s.gcm.state, &key->s.gcm.handle, info->pbNonce, info->cbNonce );
2166 SymCryptGcmAuthPart( &key->s.gcm.state, info->pbAuthData, info->cbAuthData );
2167 SymCryptGcmEncryptPart( &key->s.gcm.state, input, output, input_len );
2168 SymCryptGcmEncryptFinal( &key->s.gcm.state, info->pbTag, info->cbTag );
2169
2170 LeaveCriticalSection( &key->s.cs );
2171 return STATUS_SUCCESS;
2172}
2173
2174static NTSTATUS encrypt_aes_vector( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *iv, UCHAR *output,
2175 ULONG output_len, ULONG *ret_len, ULONG flags )
2176{
2177 ULONG bytes_left = input_len, block_size = key->s.block_size;
2178 UCHAR buf[BLOCK_LENGTH_AES], *out;
2179 const UCHAR *in;
2180
2181 if (flags & BCRYPT_BLOCK_PADDING) *ret_len = (input_len + block_size) & ~(block_size - 1);
2182 else if (input_len & (block_size - 1)) return STATUS_INVALID_BUFFER_SIZE;
2183
2184 if (!output) return STATUS_SUCCESS;
2185 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
2186
2187 EnterCriticalSection( &key->s.cs );
2188
2189 if (iv) memcpy( key->s.vector, iv, block_size );
2190
2191 in = input;
2192 out = output;
2193 while (bytes_left >= block_size)
2194 {
2195 if (key->s.mode == CHAIN_MODE_CFB)
2196 SymCryptCfbEncrypt( SymCryptAesBlockCipher, 1, &key->s.aes.handle, key->s.vector, in, out, block_size );
2197 else
2198 SymCryptCbcEncrypt( SymCryptAesBlockCipher, &key->s.aes.handle, key->s.vector, in, out, block_size );
2199
2200 bytes_left -= block_size;
2201 in += block_size;
2202 out += block_size;
2203 }
2204
2205 if (flags & BCRYPT_BLOCK_PADDING)
2206 {
2207 memcpy( buf, in, bytes_left );
2208 memset( buf + bytes_left, block_size - bytes_left, block_size - bytes_left );
2209
2210 if (key->s.mode == CHAIN_MODE_CFB)
2211 SymCryptCfbEncrypt( SymCryptAesBlockCipher, 1, &key->s.aes.handle, key->s.vector, buf, out, block_size );
2212 else
2213 SymCryptCbcEncrypt( SymCryptAesBlockCipher, &key->s.aes.handle, key->s.vector, buf, out, block_size );
2214 }
2215
2216 if (iv) memcpy( iv, key->s.vector, block_size );
2217
2218 LeaveCriticalSection( &key->s.cs );
2219 return STATUS_SUCCESS;
2220}
2221
2222static NTSTATUS encrypt_symmetric( struct key *key, const UCHAR *input, ULONG input_len,
2223 const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *iv, ULONG iv_len,
2224 UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
2225{
2226 *ret_len = input_len;
2227
2228 if (key->s.mode == CHAIN_MODE_ECB && iv) return STATUS_INVALID_PARAMETER;
2229 if (key->s.mode == CHAIN_MODE_GCM && (flags & BCRYPT_BLOCK_PADDING)) return STATUS_INVALID_PARAMETER;
2230
2231 switch (key->alg_id)
2232 {
2233 case ALG_ID_AES:
2234 case ALG_ID_AES_GMAC:
2235 switch (key->s.mode)
2236 {
2237 case CHAIN_MODE_ECB:
2238 return encrypt_aes_ecb( key, input, input_len, output, output_len, ret_len, flags );
2239
2240 case CHAIN_MODE_GCM:
2241 return encrypt_aes_gcm( key, input, input_len, info, output, output_len, ret_len );
2242
2243 default:
2244 if (iv && iv_len != key->s.block_size) return STATUS_INVALID_PARAMETER;
2245 return encrypt_aes_vector( key, input, input_len, iv, output, output_len, ret_len, flags );
2246 }
2247 default:
2248 FIXME( "unhandled algorithm %u\n", key->alg_id );
2249 break;
2250 }
2251
2252 return STATUS_NOT_SUPPORTED;
2253}
2254
2255static NTSTATUS encrypt_rsa( const struct key *key, const UCHAR *input, ULONG input_len, const void *padding,
2256 UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
2257{
2258 SIZE_T size = len_from_bitlen( key->a.bitlen );
2259
2260 *ret_len = size;
2261 if (output_len < size)
2262 {
2263 if (output) return STATUS_BUFFER_TOO_SMALL;
2264 return STATUS_SUCCESS;
2265 }
2266
2267 if (!flags || flags == BCRYPT_PAD_NONE)
2268 {
2269 if (input_len % size) return STATUS_INVALID_PARAMETER;
2270
2271 if (SymCryptRsaRawEncrypt( key->a.rsa.handle, input, input_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, output,
2272 output_len )) return STATUS_INTERNAL_ERROR;
2273 }
2274 else if (flags == BCRYPT_PAD_PKCS1)
2275 {
2276 if (SymCryptRsaPkcs1Encrypt( key->a.rsa.handle, input, input_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, output,
2277 output_len, &size )) return STATUS_INTERNAL_ERROR;
2278 *ret_len = size;
2279 }
2280 else if (flags == BCRYPT_PAD_OAEP)
2281 {
2282 const BCRYPT_OAEP_PADDING_INFO *pad = padding;
2283 const SYMCRYPT_HASH *hash_desc = SymCryptSha1Algorithm;
2284 const BYTE *label = NULL;
2285 SIZE_T label_len = 0;
2286
2287 if (pad)
2288 {
2289 hash_desc = get_hash_from_str( pad->pszAlgId );
2290 label = pad->pbLabel;
2291 label_len = pad->cbLabel;
2292 }
2293 if (SymCryptRsaOaepEncrypt( key->a.rsa.handle, input, input_len, hash_desc, label, label_len, 0,
2294 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, output, output_len, &size ))
2295 return STATUS_INTERNAL_ERROR;
2296 *ret_len = size;
2297 }
2298 else
2299 {
2300 FIXME( "unsupported flags %#lx", flags );
2301 return STATUS_NOT_SUPPORTED;
2302 }
2303
2304 return STATUS_SUCCESS;
2305}
2306
2307NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
2308 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
2309{
2310 struct key *key = get_key_object( handle );
2311 NTSTATUS status;
2312
2313 TRACE( "%p, %p, %lu, %p, %p, %lu, %p, %lu, %p, %#lx\n", handle, input, input_len, padding, iv, iv_len, output,
2314 output_len, ret_len, flags );
2315
2316 if (!key) return STATUS_INVALID_HANDLE;
2317
2318 if (is_symmetric_key( key ))
2319 {
2320 if (flags & ~BCRYPT_BLOCK_PADDING)
2321 {
2322 FIXME( "flags %#lx not implemented\n", flags );
2323 return STATUS_NOT_IMPLEMENTED;
2324 }
2325
2326 status = encrypt_symmetric( key, input, input_len, padding, iv, iv_len, output, output_len, ret_len, flags );
2327 }
2328 else
2329 {
2330 if (key->alg_id != ALG_ID_RSA) return STATUS_NOT_SUPPORTED;
2331 if (!(key->flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
2332
2333 status = encrypt_rsa( key, input, input_len, padding, output, output_len, ret_len, flags );
2334 }
2335 return status;
2336}
2337
2338/* AES Key Wrap Algorithm (RFC3394) */
2339static NTSTATUS wrap_aes( const UCHAR *secret, ULONG secret_len, const UCHAR *plain, ULONG plain_len, UCHAR *cipher )
2340{
2341 UCHAR *a, *r, b[16];
2342 ULONG len = 16, t, i, j, n = plain_len / 8;
2343 NTSTATUS status;
2344 struct key *key;
2345
2346 a = cipher;
2347 r = cipher + 8;
2348
2349 memset( a, 0xa6, 8 );
2350 memcpy( r, plain, 8 * n );
2351
2352 if ((status = alloc_key( ALG_ID_AES, 0, &key ))) return status;
2353 if ((status = alloc_aes_key( key, CHAIN_MODE_ECB, BLOCK_LENGTH_AES, secret, secret_len )))
2354 {
2355 destroy_key( key );
2356 return status;
2357 }
2358
2359 for (j = 0; j <= 5; j++)
2360 {
2361 r = cipher + 8;
2362 for (i = 1; i <= n; i++)
2363 {
2364 memcpy( b, a, 8 );
2365 memcpy( b + 8, r, 8 );
2366 encrypt_aes_ecb( key, b, 16, b, 16, &len, 0 );
2367 memcpy( a, b, 8 );
2368 t = n * j + i;
2369 a[7] ^= t;
2370 a[6] ^= t >> 8;
2371 a[5] ^= t >> 16;
2372 a[4] ^= t >> 24;
2373 memcpy( r, b + 8, 8 );
2374 r += 8;
2375 }
2376 }
2377
2378 destroy_key( key );
2379 return STATUS_SUCCESS;
2380}
2381
2382static NTSTATUS export_symmetric_key( const struct key *key, const struct key *encrypt_key, const WCHAR *type,
2383 UCHAR *output, ULONG output_len, ULONG *ret_len )
2384{
2385 NTSTATUS status;
2386
2387 if (encrypt_key && wcscmp( type, BCRYPT_AES_WRAP_KEY_BLOB ))
2388 {
2389 FIXME( "encryption of key not supported\n" );
2390 return STATUS_NOT_IMPLEMENTED;
2391 }
2392
2393 if (!wcscmp( type, BCRYPT_KEY_DATA_BLOB ))
2394 {
2395 BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)output;
2396 ULONG size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->s.secret_len;
2397
2398 *ret_len = size;
2399 if (output)
2400 {
2401 if (output_len < size) return STATUS_BUFFER_TOO_SMALL;
2402 header->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
2403 header->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
2404 header->cbKeyData = key->s.secret_len;
2405 memcpy( &header[1], key->s.secret, key->s.secret_len );
2406 }
2407 return STATUS_SUCCESS;
2408 }
2409 else if (!wcscmp( type, BCRYPT_OPAQUE_KEY_BLOB ))
2410 {
2411 ULONG size = sizeof(ULONG) + key->s.secret_len;
2412
2413 *ret_len = size;
2414 if (output)
2415 {
2416 if (output_len < size) return STATUS_BUFFER_TOO_SMALL;
2417 *(ULONG *)output = key->s.secret_len;
2418 memcpy( output + sizeof(ULONG), key->s.secret, key->s.secret_len );
2419 }
2420 return STATUS_SUCCESS;
2421 }
2422 else if (!wcscmp( type, BCRYPT_AES_WRAP_KEY_BLOB ))
2423 {
2424 ULONG size = key->s.secret_len + 8;
2425
2426 if (!encrypt_key) return STATUS_INVALID_PARAMETER;
2427
2428 *ret_len = size;
2429 if (output)
2430 {
2431 if (output_len < size) return STATUS_BUFFER_TOO_SMALL;
2432 if ((status = wrap_aes( encrypt_key->s.secret, encrypt_key->s.secret_len, key->s.secret,
2433 key->s.secret_len, output ))) return status;
2434 }
2435 return STATUS_SUCCESS;
2436 }
2437
2438 FIXME( "unsupported blob type %s\n", debugstr_w(type) );
2439 return STATUS_NOT_IMPLEMENTED;
2440}
2441
2442static NTSTATUS export_rsa_key( const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len )
2443{
2444 BCRYPT_RSAKEY_BLOB *blob = (BCRYPT_RSAKEY_BLOB *)output;
2445#ifdef __REACTOS__
2446 BYTE *mod, *primes[2] = { 0 }, *exponents[2], *coefficient, *private_exp, *ptr = (BYTE *)(blob + 1);
2447#else
2448 BYTE *mod, *primes[2] = {}, *exponents[2], *coefficient, *private_exp, *ptr = (BYTE *)(blob + 1);
2449#endif
2450 UINT64 pubexp;
2451#ifdef __REACTOS__
2452 SIZE_T mod_size, pubexp_size = sizeof(pubexp), primes_sizes[2] = { 0 };
2453#else
2454 SIZE_T mod_size, pubexp_size = sizeof(pubexp), primes_sizes[2] = {};
2455#endif
2456 ULONG size, magic, num_primes = 0;
2457
2458 pubexp_size = SymCryptRsakeySizeofPublicExponent( key->a.rsa.handle, 0 );
2459 mod_size = SymCryptRsakeySizeofModulus( key->a.rsa.handle );
2460
2461 if (flags & KEY_EXPORT_FLAG_PRIVATE)
2462 {
2463 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
2464 primes_sizes[0] = SymCryptRsakeySizeofPrime( key->a.rsa.handle, 0 );
2465 primes_sizes[1] = SymCryptRsakeySizeofPrime( key->a.rsa.handle, 1 );
2466 num_primes = 2;
2467 }
2468 else primes_sizes[0] = primes_sizes[1] = 0;
2469
2470 size = sizeof(*blob) + pubexp_size + mod_size + primes_sizes[0] + primes_sizes[1];
2471 if (flags & KEY_EXPORT_FLAG_RSA_FULL) size += primes_sizes[0] * 2 + primes_sizes[1] + mod_size;
2472 if (output_len < size || !output)
2473 {
2474 *ret_len = size;
2475 if (output) return STATUS_BUFFER_TOO_SMALL;
2476 return STATUS_SUCCESS;
2477 }
2478
2479 if (flags & KEY_EXPORT_FLAG_RSA_FULL) magic = BCRYPT_RSAFULLPRIVATE_MAGIC;
2480 else if (flags & KEY_EXPORT_FLAG_PRIVATE) magic = BCRYPT_RSAPRIVATE_MAGIC;
2481 else magic = BCRYPT_RSAPUBLIC_MAGIC;
2482
2483 blob->Magic = magic;
2484 blob->BitLength = key->a.bitlen;
2485 blob->cbPublicExp = pubexp_size;
2486 blob->cbModulus = mod_size;
2487 blob->cbPrime1 = primes_sizes[0];
2488 blob->cbPrime2 = primes_sizes[1];
2489
2490 mod = ptr + pubexp_size;
2491 primes[0] = mod + mod_size;
2492 primes[1] = mod + mod_size + primes_sizes[0];
2493
2494 if (SymCryptRsakeyGetValue( key->a.rsa.handle, mod, mod_size, &pubexp, 1, primes, primes_sizes, num_primes,
2495 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0 )) return STATUS_INTERNAL_ERROR;
2496
2497 memcpy( ptr, &pubexp, pubexp_size );
2498
2499 if (flags & KEY_EXPORT_FLAG_RSA_FULL)
2500 {
2501 exponents[0] = primes[1] + primes_sizes[1];
2502 exponents[1] = exponents[0] + primes_sizes[0];
2503 coefficient = exponents[1] + primes_sizes[1];
2504 private_exp = coefficient + primes_sizes[0];
2505
2506 if (SymCryptRsakeyGetCrtValue( key->a.rsa.handle, exponents, primes_sizes, 2, coefficient, primes_sizes[0],
2507 private_exp, mod_size, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0 ))
2508 return STATUS_INTERNAL_ERROR;
2509 }
2510
2511 *ret_len = size;
2512 return STATUS_SUCCESS;
2513}
2514
2515static DWORD get_ecc_magic( enum alg_id alg, BOOL private )
2516{
2517 switch (alg)
2518 {
2519 case ALG_ID_ECDH: return private ? BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC : BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC;
2520 case ALG_ID_ECDH_P256: return private ? BCRYPT_ECDH_PRIVATE_P256_MAGIC : BCRYPT_ECDH_PUBLIC_P256_MAGIC;
2521 case ALG_ID_ECDH_P384: return private ? BCRYPT_ECDH_PRIVATE_P384_MAGIC : BCRYPT_ECDH_PUBLIC_P384_MAGIC;
2522 case ALG_ID_ECDH_P521: return private ? BCRYPT_ECDH_PRIVATE_P521_MAGIC : BCRYPT_ECDH_PUBLIC_P521_MAGIC;
2523
2524 case ALG_ID_ECDSA: return private ? BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC : BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC;
2525 case ALG_ID_ECDSA_P256: return private ? BCRYPT_ECDSA_PRIVATE_P256_MAGIC : BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
2526 case ALG_ID_ECDSA_P384: return private ? BCRYPT_ECDSA_PRIVATE_P384_MAGIC : BCRYPT_ECDSA_PUBLIC_P384_MAGIC;
2527 case ALG_ID_ECDSA_P521: return private ? BCRYPT_ECDSA_PRIVATE_P521_MAGIC : BCRYPT_ECDSA_PUBLIC_P521_MAGIC;
2528 default:
2529 FIXME( "unhandled algorithm %u\n", alg );
2530 return 0;
2531 }
2532}
2533
2534static NTSTATUS export_ecc_key( const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len )
2535{
2536 BCRYPT_ECCKEY_BLOB *blob = (BCRYPT_ECCKEY_BLOB *)output;
2537 UINT32 pub_size = SymCryptEckeySizeofPublicKey( key->a.ecc.handle, SYMCRYPT_ECPOINT_FORMAT_XY ), priv_size = 0;
2538 UCHAR *pub = (UCHAR *)(blob + 1), *priv = NULL;
2539 ULONG size, key_size = len_from_bitlen( key->a.bitlen );
2540
2541 size = sizeof(*blob) + key_size * 2;
2542 if (flags & KEY_EXPORT_FLAG_PRIVATE)
2543 {
2544 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
2545 priv_size = SymCryptEckeySizeofPrivateKey( key->a.ecc.handle );
2546 priv = pub + key_size * 2;
2547 size += key_size;
2548 }
2549 if (output_len < size || !output)
2550 {
2551 *ret_len = size;
2552 if (output) return STATUS_BUFFER_TOO_SMALL;
2553 return STATUS_SUCCESS;
2554 }
2555
2556 blob->dwMagic = get_ecc_magic( key->alg_id, flags & KEY_EXPORT_FLAG_PRIVATE );
2557 blob->cbKey = key_size;
2558
2559 if (SymCryptEckeyGetValue( key->a.ecc.handle, priv, priv_size, pub, pub_size, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
2560 SYMCRYPT_ECPOINT_FORMAT_XY, 0 )) return STATUS_INTERNAL_ERROR;
2561 *ret_len = size;
2562 return STATUS_SUCCESS;
2563}
2564
2565static NTSTATUS export_dsa_key( const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len )
2566{
2567 BCRYPT_DSA_KEY_BLOB *blob = (BCRYPT_DSA_KEY_BLOB *)output;
2568 UINT32 key_size = len_from_bitlen( key->a.bitlen ), priv_size = 0;
2569 UCHAR *prime, *generator, *pub, *priv = NULL;
2570 ULONG size;
2571
2572 size = sizeof(*blob) + key_size * 3;
2573 if (flags & KEY_EXPORT_FLAG_PRIVATE)
2574 {
2575 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
2576 priv_size = 20;
2577 size += priv_size;
2578 }
2579 if (output_len < size || !output)
2580 {
2581 *ret_len = size;
2582 if (output) return STATUS_BUFFER_TOO_SMALL;
2583 return STATUS_SUCCESS;
2584 }
2585
2586 blob->dwMagic = (flags & KEY_EXPORT_FLAG_PRIVATE) ? BCRYPT_DSA_PRIVATE_MAGIC : BCRYPT_DSA_PUBLIC_MAGIC;
2587 blob->cbKey = key_size;
2588
2589 prime = (UCHAR *)(blob + 1);
2590 generator = prime + key_size;
2591
2592 if (SymCryptDlgroupGetValue( key->a.dsa.group, prime, key_size, blob->q, sizeof(blob->q), generator, key_size,
2593 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, NULL, blob->Seed, sizeof(blob->Seed),
2594 (UINT32 *)blob->Count )) return STATUS_INTERNAL_ERROR;
2595 pub = generator + key_size;
2596 if (flags & KEY_EXPORT_FLAG_PRIVATE) priv = pub + key_size;
2597
2598 if (SymCryptDlkeyGetValue( key->a.dsa.handle, priv, priv_size, pub, key_size, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
2599 0 )) return STATUS_INTERNAL_ERROR;
2600 *ret_len = size;
2601 return STATUS_SUCCESS;
2602}
2603
2604static NTSTATUS export_legacy_dsa_key( const struct key *key, UCHAR *output, ULONG output_len, ULONG flags,
2605 ULONG *ret_len )
2606{
2607 BLOBHEADER *hdr = (BLOBHEADER *)output;
2608 DSSPUBKEY *dsskey = (DSSPUBKEY *)(hdr + 1);
2609 UINT32 key_size = len_from_bitlen( key->a.bitlen ), pub_size = 0, priv_size = 0;
2610 UCHAR *prime_p, *prime_q, *generator, *pub = NULL, *priv = NULL, *seed, *count;
2611 ULONG size;
2612
2613 if ((flags & KEY_EXPORT_FLAG_PRIVATE) && !(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
2614
2615 size = sizeof(*hdr) + sizeof(*dsskey) + key_size * 2 + 20 /* q */ + 20 /* x or y */ + 20 /* seed */ + 4 /* count */;
2616 if (output_len < size || !output)
2617 {
2618 *ret_len = size;
2619 if (output) return STATUS_BUFFER_TOO_SMALL;
2620 return STATUS_SUCCESS;
2621 }
2622
2623 hdr->bType = (flags & KEY_EXPORT_FLAG_PRIVATE) ? PRIVATEKEYBLOB : PUBLICKEYBLOB;
2624 hdr->bVersion = 2;
2625 hdr->reserved = 0;
2626 hdr->aiKeyAlg = CALG_DSS_SIGN;
2627
2628 dsskey->magic = (flags & KEY_EXPORT_FLAG_PRIVATE) ? MAGIC_DSS2 : MAGIC_DSS1;
2629 dsskey->bitlen = key->a.bitlen;
2630
2631 prime_p = (UCHAR *)(dsskey + 1);
2632 prime_q = prime_p + key_size;
2633 generator = prime_q + 20;
2634 seed = generator + key_size + 20;
2635 count = seed + 20;
2636
2637 if (SymCryptDlgroupGetValue( key->a.dsa.group, prime_p, key_size, prime_q, 20, generator, key_size,
2638 SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, NULL, seed, 20, (UINT32 *)count ))
2639 return STATUS_INTERNAL_ERROR;
2640
2641 if (flags & KEY_EXPORT_FLAG_PRIVATE)
2642 {
2643 priv = generator + key_size;
2644 priv_size = 20;
2645 }
2646 else
2647 {
2648 pub = generator + key_size;
2649 pub_size = 20;
2650 }
2651
2652 if (SymCryptDlkeyGetValue( key->a.dsa.handle, priv, priv_size, pub, pub_size, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST,
2653 0 )) return STATUS_INTERNAL_ERROR;
2654 *ret_len = size;
2655 return STATUS_SUCCESS;
2656}
2657
2658static NTSTATUS export_dh_key( const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len )
2659{
2660 BCRYPT_DH_KEY_BLOB *blob = (BCRYPT_DH_KEY_BLOB *)output;
2661 UCHAR *modulus, *generator, *pub, *priv = NULL;
2662 ULONG size, priv_size = 0, key_size = len_from_bitlen( key->a.bitlen );
2663
2664 size = sizeof(*blob) + key_size * 3;
2665 if (flags & KEY_EXPORT_FLAG_PRIVATE)
2666 {
2667 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
2668 priv_size = key_size;
2669 size += key_size;
2670 }
2671 if (output_len < size || !output)
2672 {
2673 *ret_len = size;
2674 if (output) return STATUS_BUFFER_TOO_SMALL;
2675 return STATUS_SUCCESS;
2676 }
2677
2678 blob->dwMagic = (flags & KEY_EXPORT_FLAG_PRIVATE) ? BCRYPT_DH_PRIVATE_MAGIC : BCRYPT_DH_PUBLIC_MAGIC;
2679 blob->cbKey = key_size;
2680
2681 modulus = (UCHAR *)(blob + 1);
2682 generator = modulus + key_size;
2683
2684 if (SymCryptDlgroupGetValue( key->a.dsa.group, modulus, key_size, NULL, 0, generator, key_size,
2685 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, NULL, NULL, 0, 0 )) return STATUS_INTERNAL_ERROR;
2686 pub = generator + key_size;
2687 if (flags & KEY_EXPORT_FLAG_PRIVATE) priv = pub + key_size;
2688
2689 if (SymCryptDlkeyGetValue( key->a.dsa.handle, priv, priv_size, pub, key_size,
2690 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0 )) return STATUS_INTERNAL_ERROR;
2691 *ret_len = size;
2692 return STATUS_SUCCESS;
2693}
2694
2695static NTSTATUS export_asymmetric_key( const struct key *key, const WCHAR *type, UCHAR *output, ULONG output_len,
2696 ULONG *ret_len )
2697{
2698 if (!(key->flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
2699
2700 if (!wcscmp( type, BCRYPT_ECCPRIVATE_BLOB ))
2701 {
2702 return export_ecc_key( key, output, output_len, KEY_EXPORT_FLAG_PRIVATE, ret_len );
2703 }
2704 else if (!wcscmp( type, BCRYPT_ECCPUBLIC_BLOB ))
2705 {
2706 return export_ecc_key( key, output, output_len, 0, ret_len );
2707 }
2708 else if (!wcscmp( type, BCRYPT_DSA_PRIVATE_BLOB ))
2709 {
2710 return export_dsa_key( key, output, output_len, KEY_EXPORT_FLAG_PRIVATE, ret_len );
2711 }
2712 else if (!wcscmp( type, BCRYPT_DSA_PUBLIC_BLOB ))
2713 {
2714 return export_dsa_key( key, output, output_len, 0, ret_len );
2715 }
2716 else if (!wcscmp( type, BCRYPT_DH_PRIVATE_BLOB ))
2717 {
2718 return export_dh_key( key, output, output_len, KEY_EXPORT_FLAG_PRIVATE, ret_len );
2719 }
2720 else if (!wcscmp( type, BCRYPT_DH_PUBLIC_BLOB ))
2721 {
2722 return export_dh_key( key, output, output_len, 0, ret_len );
2723 }
2724 else if (!wcscmp( type, BCRYPT_RSAPRIVATE_BLOB ))
2725 {
2726 return export_rsa_key( key, output, output_len, KEY_EXPORT_FLAG_PRIVATE, ret_len );
2727 }
2728 else if (!wcscmp( type, BCRYPT_RSAFULLPRIVATE_BLOB ))
2729 {
2730 return export_rsa_key( key, output, output_len, KEY_EXPORT_FLAG_PRIVATE | KEY_EXPORT_FLAG_RSA_FULL, ret_len );
2731 }
2732 else if (!wcscmp( type, BCRYPT_RSAPUBLIC_BLOB ))
2733 {
2734 return export_rsa_key( key, output, output_len, 0, ret_len );
2735 }
2736 else if (!wcscmp( type, LEGACY_DSA_V2_PRIVATE_BLOB ))
2737 {
2738 return export_legacy_dsa_key( key, output, output_len, KEY_EXPORT_FLAG_PRIVATE, ret_len );
2739 }
2740 else if (!wcscmp( type, LEGACY_DSA_V2_PUBLIC_BLOB ))
2741 {
2742 return export_legacy_dsa_key( key, output, output_len, 0, ret_len );
2743 }
2744
2745 FIXME( "unsupported blob type %s\n", debugstr_w(type) );
2746 return STATUS_NOT_IMPLEMENTED;
2747}
2748
2749NTSTATUS WINAPI BCryptExportKey( BCRYPT_KEY_HANDLE export_key_handle, BCRYPT_KEY_HANDLE encrypt_key_handle,
2750 const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *size, ULONG flags )
2751{
2752 const struct key *key = get_key_object( export_key_handle ), *encrypt_key = NULL;
2753
2754 TRACE( "%p, %p, %s, %p, %lu, %p, %#lx\n", export_key_handle, encrypt_key_handle, debugstr_w(type), output,
2755 output_len, size, flags );
2756
2757 if (!key) return STATUS_INVALID_HANDLE;
2758 if (!type || !size) return STATUS_INVALID_PARAMETER;
2759 if (encrypt_key_handle && !(encrypt_key = get_key_object( encrypt_key_handle ))) return STATUS_INVALID_HANDLE;
2760
2761 if (is_symmetric_key( key )) return export_symmetric_key( key, encrypt_key, type, output, output_len, size );
2762 return export_asymmetric_key( key, type, output, output_len, size );
2763}
2764
2765static NTSTATUS alloc_rsa_key( struct key *key, ULONG bitlen )
2766{
2767 SYMCRYPT_RSA_PARAMS params;
2768
2769 params.version = 1;
2770 params.nBitsOfModulus = bitlen;
2771 params.nPrimes = (key->flags & KEY_FLAG_PRIVATE) ? 2 : 0;
2772 params.nPubExp = 1;
2773 if (!(key->a.rsa.handle = SymCryptRsakeyAllocate( &params, 0 ))) return STATUS_NO_MEMORY;
2774
2775 key->a.bitlen = bitlen;
2776 return STATUS_SUCCESS;
2777}
2778
2779static NTSTATUS import_rsa_key( enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key )
2780{
2781 const BCRYPT_RSAKEY_BLOB *blob = (const BCRYPT_RSAKEY_BLOB *)input;
2782#ifdef __REACTOS__
2783 const UCHAR *mod, *primes[2] = { 0 }, *exp = (const UCHAR *)(blob + 1);
2784 SIZE_T primes_sizes[2] = { 0 };
2785#else
2786 const UCHAR *mod, *primes[2] = {}, *exp = (const UCHAR *)(blob + 1);
2787 SIZE_T primes_sizes[2] = {};
2788#endif
2789 UINT64 exp64 = 0;
2790 ULONG key_flags = 0, set_flags = SYMCRYPT_FLAG_KEY_NO_FIPS, size, i, num_primes = 0;
2791 NTSTATUS status;
2792 struct key *key = NULL;
2793
2794 if (input_len < sizeof(*blob)) return STATUS_INVALID_PARAMETER;
2795
2796 if (alg != ALG_ID_RSA && alg != ALG_ID_RSA_SIGN) return STATUS_NOT_SUPPORTED;
2797 if (blob->Magic == BCRYPT_RSAPRIVATE_MAGIC || blob->Magic == BCRYPT_RSAFULLPRIVATE_MAGIC)
2798 key_flags = KEY_FLAG_PRIVATE;
2799 else if (blob->Magic != BCRYPT_RSAPUBLIC_MAGIC) return STATUS_NOT_SUPPORTED;
2800
2801 if (blob->cbPublicExp > sizeof(exp64)) return NTE_BAD_DATA;
2802 for (i = 0; i < blob->cbPublicExp; i++) exp64 += exp[i] << ((blob->cbPublicExp - i - 1) * 8);
2803 if (exp64 == 1) return STATUS_INVALID_PARAMETER;
2804
2805 size = sizeof(*blob) + blob->cbPublicExp + blob->cbModulus;
2806 if (key_flags & KEY_FLAG_PRIVATE) size += blob->cbPrime1 + blob->cbPrime2;
2807 if (blob->Magic == BCRYPT_RSAFULLPRIVATE_MAGIC) size += blob->cbPrime1 * 2 + blob->cbPrime2 + blob->cbModulus;
2808 if (size != input_len) return NTE_BAD_DATA;
2809
2810 if ((status = alloc_key( alg, key_flags, &key )) || (status = alloc_rsa_key( key, blob->cbModulus * 8 )))
2811 {
2812 destroy_key( key );
2813 return status;
2814 }
2815
2816 if (alg == ALG_ID_RSA) set_flags |= SYMCRYPT_FLAG_RSAKEY_ENCRYPT | SYMCRYPT_FLAG_RSAKEY_SIGN;
2817 else if (alg == ALG_ID_RSA_SIGN) set_flags |= SYMCRYPT_FLAG_RSAKEY_SIGN;
2818
2819 mod = exp + blob->cbPublicExp;
2820
2821 if (key_flags & KEY_FLAG_PRIVATE)
2822 {
2823 num_primes = 2;
2824
2825 primes[0] = mod + blob->cbModulus;
2826 primes[1] = primes[0] + blob->cbPrime1;
2827
2828 primes_sizes[0] = blob->cbPrime1;
2829 primes_sizes[1] = blob->cbPrime2;
2830 }
2831
2832 if (SymCryptRsakeySetValue( mod, blob->cbModulus, &exp64, 1, primes, primes_sizes, num_primes,
2833 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, set_flags, key->a.rsa.handle ))
2834 {
2835 destroy_key( key );
2836 return STATUS_INTERNAL_ERROR;
2837 }
2838
2839 *ret_key = key;
2840 return STATUS_SUCCESS;
2841}
2842
2843static NTSTATUS import_legacy_rsa_key( enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key )
2844{
2845 const BLOBHEADER *hdr = (const BLOBHEADER *)input;
2846 const RSAPUBKEY *rsakey = (RSAPUBKEY *)(hdr + 1);
2847#ifdef __REACTOS__
2848 const UCHAR *mod, *primes[2] = { 0 };
2849 SIZE_T primes_sizes[2] = { 0 };
2850#else
2851 const UCHAR *mod, *primes[2] = {};
2852 SIZE_T primes_sizes[2] = {};
2853#endif
2854 UINT64 exp64;
2855 ULONG key_size, key_flags = 0, set_flags = SYMCRYPT_FLAG_KEY_NO_FIPS, size, num_primes = 0;
2856 NTSTATUS status;
2857 struct key *key = NULL;
2858
2859 if (alg != ALG_ID_RSA && alg != ALG_ID_RSA_SIGN) return STATUS_NOT_SUPPORTED;
2860 if (input_len < sizeof(*hdr)) return STATUS_INVALID_PARAMETER;
2861
2862 if (hdr->bType == PRIVATEKEYBLOB) key_flags |= KEY_FLAG_PRIVATE;
2863 else if (hdr->bType != PUBLICKEYBLOB) return STATUS_NOT_SUPPORTED;
2864 if (hdr->bVersion != 2 || (hdr->aiKeyAlg != CALG_RSA_KEYX && hdr->aiKeyAlg != CALG_RSA_SIGN))
2865 return STATUS_NOT_SUPPORTED;
2866
2867 size = sizeof(*hdr) + sizeof(*rsakey);
2868 if (input_len < size || rsakey->bitlen & 0xf) return STATUS_INVALID_PARAMETER;
2869
2870 key_size = len_from_bitlen( rsakey->bitlen );
2871 size += key_size;
2872 if (key_flags & KEY_FLAG_PRIVATE) size += key_size; /* prime1 + prime2 */
2873 if (input_len < size || rsakey->pubexp == 1) return STATUS_INVALID_PARAMETER;
2874
2875 if ((status = alloc_key( alg, key_flags, &key )) || (status = alloc_rsa_key( key, rsakey->bitlen )))
2876 {
2877 destroy_key( key );
2878 return status;
2879 }
2880
2881 if (alg == ALG_ID_RSA) set_flags |= SYMCRYPT_FLAG_RSAKEY_ENCRYPT | SYMCRYPT_FLAG_RSAKEY_SIGN;
2882 else if (alg == ALG_ID_RSA_SIGN) set_flags |= SYMCRYPT_FLAG_RSAKEY_SIGN;
2883
2884 exp64 = rsakey->pubexp;
2885 mod = (const UCHAR *)(rsakey + 1);
2886 if (key_flags & KEY_FLAG_PRIVATE)
2887 {
2888 num_primes = 2;
2889
2890 primes[0] = mod + key_size;
2891 primes[1] = primes[0] + key_size / 2;
2892
2893 primes_sizes[0] = key_size / 2;
2894 primes_sizes[1] = key_size / 2;
2895 }
2896
2897 if (SymCryptRsakeySetValue( mod, key_size, &exp64, 1, primes, primes_sizes, num_primes,
2898 SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, set_flags, key->a.rsa.handle ))
2899 {
2900 destroy_key( key );
2901 return STATUS_INTERNAL_ERROR;
2902 }
2903
2904 *ret_key = key;
2905 return STATUS_SUCCESS;
2906}
2907
2908static enum ecc_curve_id get_ecc_blob_curve( enum alg_id alg, const BCRYPT_ECCKEY_BLOB *blob, ULONG *size,
2909 ULONG *flags )
2910{
2911 enum ecc_curve_id curve_id = 0;
2912
2913 *flags = 0;
2914 *size = blob->cbKey;
2915
2916 switch (alg)
2917 {
2918 case ALG_ID_ECDH:
2919 if (blob->dwMagic == BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC) *flags = KEY_FLAG_PRIVATE;
2920 else if (blob->dwMagic != BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC) return ECC_CURVE_NONE;
2921 break;
2922
2923 case ALG_ID_ECDH_P256:
2924 if (blob->dwMagic == BCRYPT_ECDH_PRIVATE_P256_MAGIC) *flags = KEY_FLAG_PRIVATE;
2925 else if (blob->dwMagic != BCRYPT_ECDH_PUBLIC_P256_MAGIC) return ECC_CURVE_INVALID;
2926 curve_id = ECC_CURVE_P256R1;
2927 *size = 32;
2928 break;
2929
2930 case ALG_ID_ECDH_P384:
2931 if (blob->dwMagic == BCRYPT_ECDH_PRIVATE_P384_MAGIC) *flags = KEY_FLAG_PRIVATE;
2932 else if (blob->dwMagic != BCRYPT_ECDH_PUBLIC_P384_MAGIC) return ECC_CURVE_INVALID;
2933 curve_id = ECC_CURVE_P384R1;
2934 *size = 48;
2935 break;
2936
2937 case ALG_ID_ECDH_P521:
2938 if (blob->dwMagic == BCRYPT_ECDH_PRIVATE_P521_MAGIC) *flags = KEY_FLAG_PRIVATE;
2939 else if (blob->dwMagic != BCRYPT_ECDH_PUBLIC_P521_MAGIC) return ECC_CURVE_INVALID;
2940 curve_id = ECC_CURVE_P521R1;
2941 *size = 66;
2942 break;
2943
2944 case ALG_ID_ECDSA:
2945 if (blob->dwMagic == BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC) *flags = KEY_FLAG_PRIVATE;
2946 else if (blob->dwMagic != BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC) return ECC_CURVE_NONE;
2947 break;
2948
2949 case ALG_ID_ECDSA_P256:
2950 if (blob->dwMagic == BCRYPT_ECDSA_PRIVATE_P256_MAGIC) *flags = KEY_FLAG_PRIVATE;
2951 else if (blob->dwMagic != BCRYPT_ECDSA_PUBLIC_P256_MAGIC) return ECC_CURVE_INVALID;
2952 curve_id = ECC_CURVE_P256R1;
2953 *size = 32;
2954 break;
2955
2956 case ALG_ID_ECDSA_P384:
2957 if (blob->dwMagic == BCRYPT_ECDSA_PRIVATE_P384_MAGIC) *flags = KEY_FLAG_PRIVATE;
2958 else if (blob->dwMagic != BCRYPT_ECDSA_PUBLIC_P384_MAGIC) return ECC_CURVE_INVALID;
2959 curve_id = ECC_CURVE_P384R1;
2960 *size = 48;
2961 break;
2962
2963 case ALG_ID_ECDSA_P521:
2964 if (blob->dwMagic == BCRYPT_ECDSA_PRIVATE_P521_MAGIC) *flags = KEY_FLAG_PRIVATE;
2965 else if (blob->dwMagic != BCRYPT_ECDSA_PUBLIC_P521_MAGIC) return ECC_CURVE_INVALID;
2966 curve_id = ECC_CURVE_P521R1;
2967 *size = 66;
2968 break;
2969
2970 default:
2971 ERR( "unhandled algorithm %u\n", alg );
2972 return ECC_CURVE_INVALID;
2973 }
2974 return curve_id;
2975}
2976
2977static UINT32 get_ecc_import_flags( enum alg_id alg )
2978{
2979 UINT32 flags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION;
2980
2981 switch (alg)
2982 {
2983 case ALG_ID_ECDH:
2984 case ALG_ID_ECDH_P256:
2985 case ALG_ID_ECDH_P384:
2986 case ALG_ID_ECDH_P521:
2987 flags |= SYMCRYPT_FLAG_ECKEY_ECDH;
2988 break;
2989
2990 case ALG_ID_ECDSA:
2991 case ALG_ID_ECDSA_P256:
2992 case ALG_ID_ECDSA_P384:
2993 case ALG_ID_ECDSA_P521:
2994 flags |= SYMCRYPT_FLAG_ECKEY_ECDSA;
2995 break;
2996
2997 default:
2998 FIXME( "unhandled algorithm %u\n", alg );
2999 break;
3000 }
3001 return flags;
3002}
3003
3004static const BYTE brainpoolP256r1[] =
3005{
3006 /* version */
3007 0x01, 0x00, 0x00, 0x00,
3008 /* type */
3009 0x01, 0x00, 0x00, 0x00,
3010 /* algId */
3011 0x00, 0x00, 0x00, 0x00,
3012 /* cbFieldLength */
3013 0x20, 0x00, 0x00, 0x00,
3014 /* cbSubgroupOrder */
3015 0x20, 0x00, 0x00, 0x00,
3016 /* cbCofactor */
3017 0x01, 0x00, 0x00, 0x00,
3018 /* cbSeed */
3019 0x00, 0x00, 0x00, 0x00,
3020 /* P */
3021 0xa9, 0xfb, 0x57, 0xdb, 0xa1, 0xee, 0xa9, 0xbc,
3022 0x3e, 0x66, 0x0a, 0x90, 0x9d, 0x83, 0x8d, 0x72,
3023 0x6e, 0x3b, 0xf6, 0x23, 0xd5, 0x26, 0x20, 0x28,
3024 0x20, 0x13, 0x48, 0x1d, 0x1f, 0x6e, 0x53, 0x77,
3025 /* A */
3026 0x7d, 0x5a, 0x09, 0x75, 0xfc, 0x2c, 0x30, 0x57,
3027 0xee, 0xf6, 0x75, 0x30, 0x41, 0x7a, 0xff, 0xe7,
3028 0xfb, 0x80, 0x55, 0xc1, 0x26, 0xdc, 0x5c, 0x6c,
3029 0xe9, 0x4a, 0x4b, 0x44, 0xf3, 0x30, 0xb5, 0xd9,
3030 /* B */
3031 0x26, 0xdc, 0x5c, 0x6c, 0xe9, 0x4a, 0x4b, 0x44,
3032 0xf3, 0x30, 0xb5, 0xd9, 0xbb, 0xd7, 0x7c, 0xbf,
3033 0x95, 0x84, 0x16, 0x29, 0x5c, 0xf7, 0xe1, 0xce,
3034 0x6b, 0xcc, 0xdc, 0x18, 0xff, 0x8c, 0x07, 0xb6,
3035 /* Gx */
3036 0x8b, 0xd2, 0xae, 0xb9, 0xcb, 0x7e, 0x57, 0xcb,
3037 0x2c, 0x4b, 0x48, 0x2f, 0xfc, 0x81, 0xb7, 0xaf,
3038 0xb9, 0xde, 0x27, 0xe1, 0xe3, 0xbd, 0x23, 0xc2,
3039 0x3a, 0x44, 0x53, 0xbd, 0x9a, 0xce, 0x32, 0x62,
3040 /* Gy */
3041 0x54, 0x7e, 0xf8, 0x35, 0xc3, 0xda, 0xc4, 0xfd,
3042 0x97, 0xf8, 0x46, 0x1a, 0x14, 0x61, 0x1d, 0xc9,
3043 0xc2, 0x77, 0x45, 0x13, 0x2d, 0xed, 0x8e, 0x54,
3044 0x5c, 0x1d, 0x54, 0xc7, 0x2f, 0x04, 0x69, 0x97,
3045 /* n */
3046 0xa9, 0xfb, 0x57, 0xdb, 0xa1, 0xee, 0xa9, 0xbc,
3047 0x3e, 0x66, 0x0a, 0x90, 0x9d, 0x83, 0x8d, 0x71,
3048 0x8c, 0x39, 0x7a, 0xa3, 0xb5, 0x61, 0xa6, 0xf7,
3049 0x90, 0x1e, 0x0e, 0x82, 0x97, 0x48, 0x56, 0xa7,
3050 /* h */
3051 0x01
3052};
3053const SYMCRYPT_ECURVE_PARAMS *SymCryptEcurveParamsBrainpoolP256r1 = (const SYMCRYPT_ECURVE_PARAMS *)brainpoolP256r1;
3054
3055static const BYTE brainpoolP384r1[] =
3056{
3057 /* version */
3058 0x01, 0x00, 0x00, 0x00,
3059 /* type */
3060 0x01, 0x00, 0x00, 0x00,
3061 /* algId */
3062 0x00, 0x00, 0x00, 0x00,
3063 /* cbFieldLength */
3064 0x30, 0x00, 0x00, 0x00,
3065 /* cbSubgroupOrder */
3066 0x30, 0x00, 0x00, 0x00,
3067 /* cbCofactor */
3068 0x01, 0x00, 0x00, 0x00,
3069 /* cbSeed */
3070 0x00, 0x00, 0x00, 0x00,
3071 /* P */
3072 0x8c, 0xb9, 0x1e, 0x82, 0xa3, 0x38, 0x6d, 0x28,
3073 0x0f, 0x5d, 0x6f, 0x7e, 0x50, 0xe6, 0x41, 0xdf,
3074 0x15, 0x2f, 0x71, 0x09, 0xed, 0x54, 0x56, 0xb4,
3075 0x12, 0xb1, 0xda, 0x19, 0x7f, 0xb7, 0x11, 0x23,
3076 0xac, 0xd3, 0xa7, 0x29, 0x90, 0x1d, 0x1a, 0x71,
3077 0x87, 0x47, 0x00, 0x13, 0x31, 0x07, 0xec, 0x53,
3078 /* A */
3079 0x7b, 0xc3, 0x82, 0xc6, 0x3d, 0x8c, 0x15, 0x0c,
3080 0x3c, 0x72, 0x08, 0x0a, 0xce, 0x05, 0xaf, 0xa0,
3081 0xc2, 0xbe, 0xa2, 0x8e, 0x4f, 0xb2, 0x27, 0x87,
3082 0x13, 0x91, 0x65, 0xef, 0xba, 0x91, 0xf9, 0x0f,
3083 0x8a, 0xa5, 0x81, 0x4a, 0x50, 0x3a, 0xd4, 0xeb,
3084 0x04, 0xa8, 0xc7, 0xdd, 0x22, 0xce, 0x28, 0x26,
3085 /* B */
3086 0x04, 0xa8, 0xc7, 0xdd, 0x22, 0xce, 0x28, 0x26,
3087 0x8b, 0x39, 0xb5, 0x54, 0x16, 0xf0, 0x44, 0x7c,
3088 0x2f, 0xb7, 0x7d, 0xe1, 0x07, 0xdc, 0xd2, 0xa6,
3089 0x2e, 0x88, 0x0e, 0xa5, 0x3e, 0xeb, 0x62, 0xd5,
3090 0x7c, 0xb4, 0x39, 0x02, 0x95, 0xdb, 0xc9, 0x94,
3091 0x3a, 0xb7, 0x86, 0x96, 0xfa, 0x50, 0x4c, 0x11,
3092 /* Gx */
3093 0x1d, 0x1c, 0x64, 0xf0, 0x68, 0xcf, 0x45, 0xff,
3094 0xa2, 0xa6, 0x3a, 0x81, 0xb7, 0xc1, 0x3f, 0x6b,
3095 0x88, 0x47, 0xa3, 0xe7, 0x7e, 0xf1, 0x4f, 0xe3,
3096 0xdb, 0x7f, 0xca, 0xfe, 0x0c, 0xbd, 0x10, 0xe8,
3097 0xe8, 0x26, 0xe0, 0x34, 0x36, 0xd6, 0x46, 0xaa,
3098 0xef, 0x87, 0xb2, 0xe2, 0x47, 0xd4, 0xaf, 0x1e,
3099 /* Gy */
3100 0x8a, 0xbe, 0x1d, 0x75, 0x20, 0xf9, 0xc2, 0xa4,
3101 0x5c, 0xb1, 0xeb, 0x8e, 0x95, 0xcf, 0xd5, 0x52,
3102 0x62, 0xb7, 0x0b, 0x29, 0xfe, 0xec, 0x58, 0x64,
3103 0xe1, 0x9c, 0x05, 0x4f, 0xf9, 0x91, 0x29, 0x28,
3104 0x0e, 0x46, 0x46, 0x21, 0x77, 0x91, 0x81, 0x11,
3105 0x42, 0x82, 0x03, 0x41, 0x26, 0x3c, 0x53, 0x15,
3106 /* n */
3107 0x8c, 0xb9, 0x1e, 0x82, 0xa3, 0x38, 0x6d, 0x28,
3108 0x0f, 0x5d, 0x6f, 0x7e, 0x50, 0xe6, 0x41, 0xdf,
3109 0x15, 0x2f, 0x71, 0x09, 0xed, 0x54, 0x56, 0xb3,
3110 0x1f, 0x16, 0x6e, 0x6c, 0xac, 0x04, 0x25, 0xa7,
3111 0xcf, 0x3a, 0xb6, 0xaf, 0x6b, 0x7f, 0xc3, 0x10,
3112 0x3b, 0x88, 0x32, 0x02, 0xe9, 0x04, 0x65, 0x65,
3113 /* h */
3114 0x01
3115};
3116const SYMCRYPT_ECURVE_PARAMS *SymCryptEcurveParamsBrainpoolP384r1 = (const SYMCRYPT_ECURVE_PARAMS *)brainpoolP384r1;
3117
3118static SYMCRYPT_ECURVE *alloc_ecc_curve( enum ecc_curve_id curve_id )
3119{
3120 const SYMCRYPT_ECURVE_PARAMS *params;
3121
3122 switch (curve_id)
3123 {
3124 case ECC_CURVE_25519:
3125 params = SymCryptEcurveParamsCurve25519;
3126 break;
3127 case ECC_CURVE_BRAINPOOLP256R1:
3128 params = SymCryptEcurveParamsBrainpoolP256r1;
3129 break;
3130 case ECC_CURVE_BRAINPOOLP384R1:
3131 params = SymCryptEcurveParamsBrainpoolP384r1;
3132 break;
3133 case ECC_CURVE_P256R1:
3134 params = SymCryptEcurveParamsNistP256;
3135 break;
3136 case ECC_CURVE_P384R1:
3137 params = SymCryptEcurveParamsNistP384;
3138 break;
3139 case ECC_CURVE_P521R1:
3140 params = SymCryptEcurveParamsNistP521;
3141 break;
3142 default:
3143 FIXME( "unhandled curve %u\n", curve_id );
3144 return NULL;
3145 }
3146 return SymCryptEcurveAllocate( params, 0 );
3147}
3148
3149static ULONG curve_strength( enum ecc_curve_id curve_id )
3150{
3151 switch (curve_id)
3152 {
3153 case ECC_CURVE_25519: return 253;
3154 case ECC_CURVE_BRAINPOOLP256R1:
3155 case ECC_CURVE_P256R1: return 256;
3156 case ECC_CURVE_BRAINPOOLP384R1:
3157 case ECC_CURVE_P384R1: return 384;
3158 case ECC_CURVE_P521R1: return 521;
3159 default:
3160 FIXME( "unsupported curve %u\n", curve_id );
3161 return 0;
3162 }
3163}
3164
3165static NTSTATUS alloc_ecc_key( struct key *key, enum ecc_curve_id curve_id )
3166{
3167 if (!(key->a.ecc.curve = alloc_ecc_curve( curve_id ))) return STATUS_NO_MEMORY;
3168 if (!(key->a.ecc.handle = SymCryptEckeyAllocate( key->a.ecc.curve ))) return STATUS_NO_MEMORY;
3169 key->a.ecc.curve_id = curve_id;
3170 key->a.bitlen = curve_strength( curve_id );
3171 return STATUS_SUCCESS;
3172}
3173
3174static NTSTATUS import_ecc_key( enum alg_id alg, enum ecc_curve_id curve, const UCHAR *input, ULONG input_len,
3175 struct key **ret_key )
3176{
3177 const BCRYPT_ECCKEY_BLOB *blob = (const BCRYPT_ECCKEY_BLOB *)input;
3178 UINT32 pub_size, priv_size = 0, set_flags = get_ecc_import_flags( alg );
3179 ULONG size, key_size, key_flags = 0;
3180 const UCHAR *pub = (UCHAR *)(blob + 1), *priv = NULL;
3181 enum ecc_curve_id blob_curve;
3182 NTSTATUS status;
3183 struct key *key = NULL;
3184
3185 if (input_len < sizeof(*blob)) return STATUS_INVALID_PARAMETER;
3186 if (!(blob_curve = get_ecc_blob_curve( alg, blob, &key_size, &key_flags ))) blob_curve = curve;
3187 if (blob_curve == ECC_CURVE_INVALID) return STATUS_INVALID_PARAMETER;
3188
3189 size = sizeof(*blob) + blob->cbKey * 2;
3190 if (key_flags & KEY_FLAG_PRIVATE)
3191 {
3192 priv = pub + blob->cbKey * 2;
3193 size += blob->cbKey;
3194 }
3195 if (blob->cbKey != key_size || input_len != size) return STATUS_INVALID_PARAMETER;
3196
3197 if ((status = alloc_key( alg, key_flags, &key )) || (status = alloc_ecc_key( key, curve )))
3198 {
3199 destroy_key( key );
3200 return status;
3201 }
3202
3203 pub_size = SymCryptEckeySizeofPublicKey( key->a.ecc.handle, SYMCRYPT_ECPOINT_FORMAT_XY );
3204 if (key_flags & KEY_FLAG_PRIVATE) priv_size = SymCryptEckeySizeofPrivateKey( key->a.ecc.handle );
3205
3206 if (SymCryptEckeySetValue( priv, priv_size, pub, pub_size, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST,
3207 SYMCRYPT_ECPOINT_FORMAT_XY, set_flags, key->a.ecc.handle ))
3208 {
3209 destroy_key( key );
3210 return STATUS_INTERNAL_ERROR;
3211 }
3212
3213 *ret_key = key;
3214 return STATUS_SUCCESS;
3215}
3216
3217static NTSTATUS alloc_dsa_key( struct key *key, ULONG bitlen )
3218{
3219 if (!(key->a.dsa.group = SymCryptDlgroupAllocate( bitlen, 0 ))) return STATUS_NO_MEMORY;
3220 if (!(key->a.dsa.handle = SymCryptDlkeyAllocate( key->a.dsa.group ))) return STATUS_NO_MEMORY;
3221 key->a.bitlen = bitlen;
3222 return STATUS_SUCCESS;
3223}
3224
3225static NTSTATUS import_dsa_key( enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key )
3226{
3227 const BCRYPT_DSA_KEY_BLOB *blob = (const BCRYPT_DSA_KEY_BLOB *)input;
3228 ULONG size, count, priv_size = 0, key_flags = 0, set_flags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_DLKEY_DSA;
3229 const UCHAR *prime, *generator, *pub, *priv = NULL;
3230 struct key *key = NULL;
3231 NTSTATUS status;
3232
3233 if (input_len < sizeof(*blob)) return STATUS_INVALID_PARAMETER;
3234
3235 if (alg != ALG_ID_DSA) return STATUS_NOT_SUPPORTED;
3236 if (blob->dwMagic == BCRYPT_DSA_PRIVATE_MAGIC) key_flags = KEY_FLAG_PRIVATE;
3237 else if (blob->dwMagic != BCRYPT_DSA_PUBLIC_MAGIC) return STATUS_NOT_SUPPORTED;
3238
3239 size = sizeof(*blob) + blob->cbKey * 3;
3240 if (key_flags & KEY_FLAG_PRIVATE) size += 20;
3241 if (input_len != size) return STATUS_INVALID_PARAMETER;
3242
3243 if ((status = alloc_key( alg, key_flags, &key )) || (status = alloc_dsa_key( key, blob->cbKey * 8 )))
3244 {
3245 destroy_key( key );
3246 return status;
3247 }
3248
3249 prime = (const UCHAR *)(blob + 1);
3250 generator = prime + blob->cbKey;
3251 count = *(UINT32 *)blob->Count;
3252
3253 if (SymCryptDlgroupSetValue( prime, blob->cbKey, blob->q, sizeof(blob->q), generator, blob->cbKey,
3254 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, NULL, blob->Seed, sizeof(blob->Seed),
3255 count, SYMCRYPT_DLGROUP_FIPS_NONE, key->a.dsa.group ))
3256 {
3257 destroy_key( key );
3258 return STATUS_INTERNAL_ERROR;
3259 }
3260
3261 pub = generator + blob->cbKey;
3262 if (key_flags & KEY_FLAG_PRIVATE)
3263 {
3264 priv = pub + blob->cbKey;
3265 priv_size = 20;
3266 }
3267
3268 if (alg == ALG_ID_DH) set_flags |= SYMCRYPT_FLAG_DLKEY_DH;
3269 else if (alg == ALG_ID_DSA) set_flags |= SYMCRYPT_FLAG_DLKEY_DSA;
3270
3271 if (SymCryptDlkeySetValue( priv, priv_size, pub, blob->cbKey, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, set_flags,
3272 key->a.dsa.handle ))
3273 {
3274 destroy_key( key );
3275 return STATUS_INTERNAL_ERROR;
3276 }
3277
3278 memcpy( key->a.dsa.seed, blob->Seed, sizeof(blob->Seed) );
3279 memcpy( &key->a.dsa.count, blob->Count, sizeof(blob->Count) );
3280
3281 *ret_key = key;
3282 return STATUS_SUCCESS;
3283}
3284
3285static NTSTATUS import_legacy_dsa_key( enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key )
3286{
3287 const BLOBHEADER *hdr = (const BLOBHEADER *)input;
3288 const DSSPUBKEY *dsskey = (DSSPUBKEY *)(hdr + 1);
3289 UINT32 priv_size = 0, pub_size = 0, set_flags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_DLKEY_DSA;
3290 const UCHAR *prime_p, *prime_q, *generator, *pub = NULL, *priv = NULL, *seed, *count;
3291 ULONG size, key_size, key_flags = 0;
3292 struct key *key = NULL;
3293 NTSTATUS status;
3294
3295 if (alg != ALG_ID_DSA) return STATUS_NOT_SUPPORTED;
3296 if (input_len < sizeof(*hdr)) return STATUS_INVALID_PARAMETER;
3297
3298 if (hdr->bType == PRIVATEKEYBLOB) key_flags |= KEY_FLAG_PRIVATE;
3299 else if (hdr->bType != PUBLICKEYBLOB) return STATUS_NOT_SUPPORTED;
3300 if (hdr->bVersion != 2 || hdr->aiKeyAlg != CALG_DSS_SIGN) return STATUS_NOT_SUPPORTED;
3301
3302 size = sizeof(*hdr) + sizeof(*dsskey);
3303 if (input_len < size || dsskey->bitlen & 0xf) return STATUS_INVALID_PARAMETER;
3304
3305 key_size = len_from_bitlen( dsskey->bitlen );
3306 size += key_size * 2 + 20 /* q */ + 20 /* x or y */ + 20 /* seed */ + 4 /* count */;
3307 if (input_len != size) return STATUS_INVALID_PARAMETER;
3308
3309 if ((status = alloc_key( alg, key_flags, &key )) || (status = alloc_dsa_key( key, dsskey->bitlen )))
3310 {
3311 destroy_key( key );
3312 return status;
3313 }
3314
3315 prime_p = (const UCHAR *)(dsskey + 1);
3316 prime_q = prime_p + key_size;
3317 generator = prime_q + 20;
3318 seed = generator + key_size + 20;
3319 count = seed + 20;
3320
3321 if (SymCryptDlgroupSetValue( prime_p, key_size, prime_q, 20, generator, key_size,
3322 SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, NULL, seed, 20, *(UINT32 *)count,
3323 SYMCRYPT_DLGROUP_FIPS_NONE, key->a.dsa.group ))
3324 {
3325 destroy_key( key );
3326 return STATUS_INTERNAL_ERROR;
3327 }
3328
3329 if (key_flags & KEY_FLAG_PRIVATE)
3330 {
3331 priv = generator + key_size;
3332 priv_size = 20;
3333 }
3334 else
3335 {
3336 pub = generator + key_size;
3337 pub_size = 20;
3338 }
3339
3340 if (SymCryptDlkeySetValue( priv, priv_size, pub, pub_size, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, set_flags,
3341 key->a.dsa.handle ))
3342 {
3343 destroy_key( key );
3344 return STATUS_INTERNAL_ERROR;
3345 }
3346
3347 memcpy( key->a.dsa.seed, seed, 20 );
3348
3349 *ret_key = key;
3350 return STATUS_SUCCESS;
3351}
3352
3353static NTSTATUS import_dh_key( enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key )
3354{
3355 const BCRYPT_DH_KEY_BLOB *blob = (const BCRYPT_DH_KEY_BLOB *)input;
3356 ULONG size, priv_size = 0, key_flags = 0, set_flags = SYMCRYPT_FLAG_KEY_NO_FIPS | SYMCRYPT_FLAG_DLKEY_DH;
3357 const UCHAR *modulus, *generator, *pub, *priv = NULL;
3358 struct key *key = NULL;
3359 NTSTATUS status;
3360
3361 if (input_len < sizeof(*blob)) return STATUS_INVALID_PARAMETER;
3362
3363 if (alg != ALG_ID_DH) return STATUS_NOT_SUPPORTED;
3364 if (blob->dwMagic == BCRYPT_DH_PRIVATE_MAGIC) key_flags = KEY_FLAG_PRIVATE;
3365 else if (blob->dwMagic != BCRYPT_DH_PUBLIC_MAGIC) return STATUS_NOT_SUPPORTED;
3366
3367 size = sizeof(*blob) + blob->cbKey * 3;
3368 if (key_flags & KEY_FLAG_PRIVATE) size += blob->cbKey;
3369 if (input_len != size) return STATUS_INVALID_PARAMETER;
3370
3371 if ((status = alloc_key( alg, key_flags, &key )) || (status = alloc_dsa_key( key, blob->cbKey * 8 )))
3372 {
3373 destroy_key( key );
3374 return status;
3375 }
3376
3377 modulus = (const UCHAR *)(blob + 1);
3378 generator = modulus + blob->cbKey;
3379
3380 if (SymCryptDlgroupSetValue( modulus, blob->cbKey, NULL, 0, generator, blob->cbKey,
3381 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, NULL, NULL, 0, 0,
3382 SYMCRYPT_DLGROUP_FIPS_NONE, key->a.dsa.group ))
3383 {
3384 destroy_key( key );
3385 return STATUS_INTERNAL_ERROR;
3386 }
3387
3388 pub = generator + blob->cbKey;
3389 if (key_flags & KEY_FLAG_PRIVATE)
3390 {
3391 priv = pub + blob->cbKey;
3392 priv_size = blob->cbKey;
3393 }
3394
3395 if (SymCryptDlkeySetValue( priv, priv_size, pub, blob->cbKey, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, set_flags,
3396 key->a.dsa.handle ))
3397 {
3398 destroy_key( key );
3399 return STATUS_INTERNAL_ERROR;
3400 }
3401
3402 *ret_key = key;
3403 return STATUS_SUCCESS;
3404}
3405
3406static NTSTATUS import_key_pair( const struct algorithm *alg, const WCHAR *type, const UCHAR *input, ULONG input_len,
3407 struct key **ret_key )
3408{
3409 struct key *key;
3410 NTSTATUS status;
3411
3412 if (!wcscmp( type, BCRYPT_ECCPUBLIC_BLOB ) || !wcscmp( type, BCRYPT_ECCPRIVATE_BLOB ))
3413 {
3414 status = import_ecc_key( alg->id, alg->curve_id, input, input_len, &key );
3415 }
3416 else if (!wcscmp( type, BCRYPT_RSAPUBLIC_BLOB ) || !wcscmp( type, BCRYPT_RSAPRIVATE_BLOB ) ||
3417 !wcscmp( type, BCRYPT_RSAFULLPRIVATE_BLOB ))
3418 {
3419 status = import_rsa_key( alg->id, input, input_len, &key );
3420 }
3421 else if (!wcscmp( type, LEGACY_RSAPRIVATE_BLOB ))
3422 {
3423 status = import_legacy_rsa_key( alg->id, input, input_len, &key );
3424 }
3425 else if (!wcscmp( type, BCRYPT_DSA_PUBLIC_BLOB ) || !wcscmp( type, BCRYPT_DSA_PRIVATE_BLOB ))
3426 {
3427 status = import_dsa_key( alg->id, input, input_len, &key );
3428 }
3429 else if (!wcscmp( type, BCRYPT_DH_PUBLIC_BLOB ) || !wcscmp( type, BCRYPT_DH_PRIVATE_BLOB ))
3430 {
3431 status = import_dh_key( alg->id, input, input_len, &key );
3432 }
3433 else if (!wcscmp( type, LEGACY_DSA_V2_PRIVATE_BLOB ) || !wcscmp( type, LEGACY_DSA_V2_PUBLIC_BLOB ))
3434 {
3435 status = import_legacy_dsa_key( alg->id, input, input_len, &key );
3436 }
3437 else
3438 {
3439 FIXME( "unsupported blob type %s\n", debugstr_w(type) );
3440 return STATUS_NOT_SUPPORTED;
3441 }
3442
3443 if (!status)
3444 {
3445 key->flags |= KEY_FLAG_FINALIZED;
3446 *ret_key = key;
3447 }
3448 return status;
3449}
3450
3451static const WCHAR *resolve_blob_type( const WCHAR *type, const UCHAR *input, ULONG input_len )
3452{
3453 const BCRYPT_KEY_BLOB *blob = (const BCRYPT_KEY_BLOB *)input;
3454
3455 if (!type) return NULL;
3456 if (wcscmp( type, BCRYPT_PUBLIC_KEY_BLOB )) return type;
3457 if (input_len < sizeof(*blob)) return NULL;
3458
3459 switch (blob->Magic)
3460 {
3461 case BCRYPT_ECDH_PUBLIC_P256_MAGIC:
3462 case BCRYPT_ECDH_PUBLIC_P384_MAGIC:
3463 case BCRYPT_ECDH_PUBLIC_P521_MAGIC:
3464 case BCRYPT_ECDSA_PUBLIC_P256_MAGIC:
3465 case BCRYPT_ECDSA_PUBLIC_P384_MAGIC:
3466 case BCRYPT_ECDSA_PUBLIC_P521_MAGIC:
3467 return BCRYPT_ECCPUBLIC_BLOB;
3468
3469 case BCRYPT_RSAPUBLIC_MAGIC:
3470 return BCRYPT_RSAPUBLIC_BLOB;
3471
3472 case BCRYPT_DSA_PUBLIC_MAGIC:
3473 return BCRYPT_DSA_PUBLIC_BLOB;
3474
3475 default:
3476 FIXME( "unsupported key magic %#lx\n", blob->Magic );
3477 return NULL;
3478 }
3479}
3480
3481NTSTATUS WINAPI BCryptImportKeyPair( BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE decrypt_key_handle, const WCHAR *type,
3482 BCRYPT_KEY_HANDLE *ret_handle, UCHAR *input, ULONG input_len, ULONG flags )
3483{
3484 const struct algorithm *alg = get_alg_object( handle );
3485 struct key *key;
3486 NTSTATUS status;
3487
3488 TRACE( "%p, %p, %s, %p, %p, %lu, %#lx\n", handle, decrypt_key_handle, debugstr_w(type), ret_handle, input,
3489 input_len, flags );
3490
3491 if (!alg) return STATUS_INVALID_HANDLE;
3492 if (!ret_handle || !input || !(type = resolve_blob_type( type, input, input_len ))) return STATUS_INVALID_PARAMETER;
3493 if (decrypt_key_handle)
3494 {
3495 FIXME( "decryption of key not yet supported\n" );
3496 return STATUS_NOT_IMPLEMENTED;
3497 }
3498
3499 if ((status = import_key_pair( alg, type, input, input_len, &key ))) return status;
3500 *ret_handle = key;
3501
3502 TRACE( "returning handle %p\n", *ret_handle );
3503 return STATUS_SUCCESS;
3504}
3505
3506static ULONG curve_size( enum ecc_curve_id curve_id )
3507{
3508 switch (curve_id)
3509 {
3510 case ECC_CURVE_25519: return 255;
3511 case ECC_CURVE_BRAINPOOLP256R1:
3512 case ECC_CURVE_P256R1: return 256;
3513 case ECC_CURVE_BRAINPOOLP384R1:
3514 case ECC_CURVE_P384R1: return 384;
3515 case ECC_CURVE_P521R1: return 521;
3516 default:
3517 FIXME( "unsupported curve %u\n", curve_id );
3518 return 0;
3519 }
3520}
3521
3522static NTSTATUS generate_key_pair( const struct algorithm *alg, ULONG bitlen, ULONG flags, struct key **ret_key )
3523{
3524 NTSTATUS status;
3525 struct key *key;
3526
3527 if ((status = alloc_key( alg->id, KEY_FLAG_PRIVATE, &key ))) return status;
3528
3529 switch (alg->id)
3530 {
3531 case ALG_ID_DH:
3532 if (bitlen < 512)
3533 {
3534 destroy_key( key );
3535 return STATUS_INVALID_PARAMETER;
3536 }
3537 /* fall through */
3538 case ALG_ID_DSA:
3539 case ALG_ID_RSA:
3540 case ALG_ID_RSA_SIGN:
3541 key->a.bitlen = bitlen;
3542 break;
3543
3544 case ALG_ID_ECDH:
3545 case ALG_ID_ECDH_P256:
3546 case ALG_ID_ECDH_P384:
3547 case ALG_ID_ECDH_P521:
3548 case ALG_ID_ECDSA:
3549 case ALG_ID_ECDSA_P256:
3550 case ALG_ID_ECDSA_P384:
3551 case ALG_ID_ECDSA_P521:
3552 if (bitlen && bitlen != curve_size( alg->curve_id ))
3553 {
3554 destroy_key( key );
3555 return STATUS_INVALID_PARAMETER;
3556 }
3557 key->a.ecc.curve_id = alg->curve_id;
3558 key->a.bitlen = curve_strength( key->a.ecc.curve_id );
3559 break;
3560
3561 default:
3562 FIXME( "unhandled algorithm %u\n", alg->id );
3563 destroy_key( key );
3564 return STATUS_NOT_SUPPORTED;
3565 }
3566
3567 *ret_key = key;
3568 return STATUS_SUCCESS;
3569}
3570
3571NTSTATUS WINAPI BCryptGenerateKeyPair( BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE *ret_handle, ULONG bitlen,
3572 ULONG flags )
3573{
3574 const struct algorithm *alg = get_alg_object( handle );
3575 struct key *key;
3576 NTSTATUS status;
3577
3578 TRACE( "%p, %p, %lu, %#lx\n", handle, ret_handle, bitlen, flags );
3579
3580 if (!alg) return STATUS_INVALID_HANDLE;
3581 if (!ret_handle) return STATUS_INVALID_PARAMETER;
3582
3583 if ((status = generate_key_pair( alg, bitlen, flags, &key ))) return status;
3584
3585 *ret_handle = key;
3586 TRACE( "returning handle %p\n", *ret_handle );
3587 return STATUS_SUCCESS;
3588}
3589
3590static NTSTATUS finalize_key_pair( struct key *key )
3591{
3592 UINT32 flags = SYMCRYPT_FLAG_KEY_NO_FIPS;
3593 NTSTATUS status;
3594
3595 switch (key->alg_id)
3596 {
3597 case ALG_ID_RSA:
3598 case ALG_ID_RSA_SIGN:
3599 {
3600 UINT64 exp = 65537;
3601
3602 if (key->alg_id == ALG_ID_RSA) flags |= SYMCRYPT_FLAG_RSAKEY_ENCRYPT | SYMCRYPT_FLAG_RSAKEY_SIGN;
3603 else flags |= SYMCRYPT_FLAG_RSAKEY_SIGN;
3604
3605 if ((status = alloc_rsa_key( key, key->a.bitlen ))) return status;
3606 if (SymCryptRsakeyGenerate( key->a.rsa.handle, &exp, 1, flags )) return STATUS_INTERNAL_ERROR;
3607 break;
3608 }
3609 case ALG_ID_ECDH:
3610 if (!key->a.ecc.curve_id) return STATUS_INVALID_PARAMETER;
3611 /* fall through */
3612 case ALG_ID_ECDH_P256:
3613 case ALG_ID_ECDH_P384:
3614 case ALG_ID_ECDH_P521:
3615 {
3616 flags |= SYMCRYPT_FLAG_ECKEY_ECDH;
3617 if ((status = alloc_ecc_key( key, key->a.ecc.curve_id ))) return status;
3618 if (SymCryptEckeySetRandom( flags, key->a.ecc.handle )) return STATUS_INTERNAL_ERROR;
3619 break;
3620 }
3621 case ALG_ID_ECDSA:
3622 if (!key->a.ecc.curve_id) return STATUS_INVALID_PARAMETER;
3623 /* fall through */
3624 case ALG_ID_ECDSA_P256:
3625 case ALG_ID_ECDSA_P384:
3626 case ALG_ID_ECDSA_P521:
3627 {
3628 flags |= SYMCRYPT_FLAG_ECKEY_ECDSA;
3629 if ((status = alloc_ecc_key( key, key->a.ecc.curve_id ))) return status;
3630 if (SymCryptEckeySetRandom( flags, key->a.ecc.handle )) return STATUS_INTERNAL_ERROR;
3631 break;
3632 }
3633 case ALG_ID_DH:
3634 case ALG_ID_DSA:
3635 {
3636 if (key->alg_id == ALG_ID_DSA) flags |= SYMCRYPT_FLAG_DLKEY_DSA;
3637 else flags |= SYMCRYPT_FLAG_DLKEY_DH;
3638
3639 if (!(key->a.dsa.group)) /* no parameters have been imported */
3640 {
3641 if (!(key->a.dsa.group = SymCryptDlgroupAllocate( key->a.bitlen, 0 ))) return STATUS_NO_MEMORY;
3642 if (SymCryptDlgroupGenerate( NULL, SYMCRYPT_DLGROUP_FIPS_186_2, key->a.dsa.group ))
3643 return STATUS_INTERNAL_ERROR;
3644 }
3645 if (!(key->a.dsa.handle = SymCryptDlkeyAllocate( key->a.dsa.group ))) return STATUS_NO_MEMORY;
3646 if (SymCryptDlkeyGenerate( flags, key->a.dsa.handle )) return STATUS_INTERNAL_ERROR;
3647 break;
3648 }
3649 default:
3650 FIXME( "unhandled algorithm %u\n", key->alg_id );
3651 return STATUS_NOT_SUPPORTED;
3652 }
3653
3654 key->flags |= KEY_FLAG_FINALIZED;
3655 return STATUS_SUCCESS;
3656}
3657
3658NTSTATUS WINAPI BCryptFinalizeKeyPair( BCRYPT_KEY_HANDLE handle, ULONG flags )
3659{
3660 struct key *key = get_key_object( handle );
3661
3662 TRACE( "%p, %#lx\n", key, flags );
3663
3664 if (!key || key->flags & KEY_FLAG_FINALIZED) return STATUS_INVALID_HANDLE;
3665
3666 return finalize_key_pair( key );
3667}
3668
3669static NTSTATUS duplicate_key( const struct key *src, struct key **ret_key )
3670{
3671 struct key *dst;
3672 NTSTATUS status;
3673
3674 switch (src->alg_id)
3675 {
3676 case ALG_ID_AES:
3677 case ALG_ID_AES_GMAC:
3678 if ((status = alloc_key( src->alg_id, src->flags, &dst ))) return status;
3679 if ((status = alloc_aes_key( dst, src->s.mode, src->s.block_size, src->s.secret, src->s.secret_len )))
3680 {
3681 destroy_key( dst );
3682 return status;
3683 }
3684 if (src->s.mode == CHAIN_MODE_GCM)
3685 {
3686 SymCryptGcmKeyCopy( &src->s.gcm.handle, &dst->s.gcm.handle );
3687 SymCryptGcmStateCopy( &src->s.gcm.state, &src->s.gcm.handle, &dst->s.gcm.state );
3688 }
3689 else SymCryptAesKeyCopy( &src->s.aes.handle, &dst->s.aes.handle );
3690 break;
3691
3692 case ALG_ID_PBKDF2:
3693 case ALG_ID_TLS1_1_KDF:
3694 case ALG_ID_TLS1_2_KDF:
3695 if ((status = alloc_key( src->alg_id, src->flags, &dst ))) return status;
3696 dst->s.mode = src->s.mode;
3697 dst->s.block_size = src->s.block_size;
3698 if (src->s.secret_len && !(dst->s.secret = malloc( src->s.secret_len )))
3699 {
3700 destroy_key( dst );
3701 return STATUS_NO_MEMORY;
3702 }
3703 memcpy( dst->s.secret, src->s.secret, src->s.secret_len );
3704 dst->s.secret_len = src->s.secret_len;
3705 InitializeCriticalSection( &dst->s.cs );
3706 break;
3707
3708 default:
3709 FIXME( "algorithm %u not supported\n", src->alg_id );
3710 return STATUS_NOT_SUPPORTED;
3711 }
3712
3713 *ret_key = dst;
3714 return STATUS_SUCCESS;
3715}
3716
3717NTSTATUS WINAPI BCryptDuplicateKey( BCRYPT_KEY_HANDLE handle, BCRYPT_KEY_HANDLE *handle_copy, UCHAR *object,
3718 ULONG object_len, ULONG flags )
3719{
3720 const struct key *key_orig = get_key_object( handle );
3721 struct key *key_copy;
3722 NTSTATUS status;
3723
3724 TRACE( "%p, %p, %p, %lu, %#lx\n", handle, handle_copy, object, object_len, flags );
3725 if (object) FIXME( "ignoring object buffer\n" );
3726
3727 if (!key_orig) return STATUS_INVALID_HANDLE;
3728 if (!handle_copy) return STATUS_INVALID_PARAMETER;
3729
3730 if ((status = duplicate_key( key_orig, &key_copy ))) return status;
3731 *handle_copy = key_copy;
3732
3733 TRACE( "returning handle %p\n", *handle_copy );
3734 return STATUS_SUCCESS;
3735}
3736
3737static NTSTATUS get_hash_oid( const WCHAR *str, const SYMCRYPT_OID **oid, UINT32 *oid_count )
3738{
3739 if (!str)
3740 {
3741 *oid = NULL;
3742 *oid_count = 0;
3743 return STATUS_SUCCESS;
3744 }
3745 if (!wcscmp( str, BCRYPT_MD5_ALGORITHM ))
3746 {
3747 *oid = SymCryptMd5OidList;
3748 *oid_count = ARRAY_SIZE( SymCryptMd5OidList );
3749 return STATUS_SUCCESS;
3750 }
3751 if (!wcscmp( str, BCRYPT_SHA1_ALGORITHM ))
3752 {
3753 *oid = SymCryptSha1OidList;
3754 *oid_count = ARRAY_SIZE( SymCryptSha1OidList );
3755 return STATUS_SUCCESS;
3756 }
3757 if (!wcscmp( str, BCRYPT_SHA256_ALGORITHM ))
3758 {
3759 *oid = SymCryptSha256OidList;
3760 *oid_count = ARRAY_SIZE( SymCryptSha256OidList );
3761 return STATUS_SUCCESS;
3762 }
3763 if (!wcscmp( str, BCRYPT_SHA384_ALGORITHM ))
3764 {
3765 *oid = SymCryptSha384OidList;
3766 *oid_count = ARRAY_SIZE( SymCryptSha384OidList );
3767 return STATUS_SUCCESS;
3768 }
3769 if (!wcscmp( str, BCRYPT_SHA512_ALGORITHM ))
3770 {
3771 *oid = SymCryptSha512OidList;
3772 *oid_count = ARRAY_SIZE( SymCryptSha512OidList );
3773 return STATUS_SUCCESS;
3774 }
3775 FIXME( "unhandled algorithm %s\n", debugstr_w(str) );
3776 return STATUS_NOT_SUPPORTED;
3777}
3778
3779static NTSTATUS sign_hash_rsa( const struct key *key, const void *padding, const UCHAR *hash, ULONG hash_len,
3780 UCHAR *signature, ULONG signature_len, ULONG *ret_len, ULONG flags )
3781{
3782 ULONG required_len = len_from_bitlen( key->a.bitlen );
3783 NTSTATUS status;
3784
3785 if (!padding) return STATUS_INVALID_PARAMETER;
3786 if (signature_len < required_len)
3787 {
3788 *ret_len = required_len;
3789 if (signature) return STATUS_BUFFER_TOO_SMALL;
3790 return STATUS_SUCCESS;
3791 }
3792 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
3793
3794 if (flags == BCRYPT_PAD_PKCS1)
3795 {
3796 const BCRYPT_PKCS1_PADDING_INFO *pad = padding;
3797 UINT32 hash_oid_count, flags = 0;
3798 const SYMCRYPT_OID *hash_oid;
3799 SIZE_T size;
3800
3801 if ((status = get_hash_oid( pad->pszAlgId, &hash_oid, &hash_oid_count ))) return status;
3802 if (!hash_oid) flags = SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1;
3803
3804 if (SymCryptRsaPkcs1Sign( key->a.rsa.handle, hash, hash_len, hash_oid, hash_oid_count, flags,
3805 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, signature, required_len, &size ))
3806 return STATUS_INTERNAL_ERROR;
3807 *ret_len = size;
3808 }
3809 else if (flags == BCRYPT_PAD_PSS)
3810 {
3811 const BCRYPT_PSS_PADDING_INFO *pad = padding;
3812 const SYMCRYPT_HASH *hash_desc = get_hash_from_str( pad->pszAlgId );
3813 SIZE_T size;
3814
3815 if (SymCryptRsaPssSign( key->a.rsa.handle, hash, hash_len, hash_desc, pad->cbSalt, 0,
3816 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, signature, required_len, &size ))
3817 return STATUS_INTERNAL_ERROR;
3818 *ret_len = size;
3819 }
3820 else
3821 {
3822 FIXME( "unsupported flags %#lx", flags );
3823 if (padding) return STATUS_INVALID_PARAMETER;
3824 return STATUS_NOT_SUPPORTED;
3825 }
3826
3827 return STATUS_SUCCESS;
3828}
3829
3830static NTSTATUS sign_hash_ecc( const struct key *key, const UCHAR *hash, ULONG hash_len, UCHAR *signature,
3831 ULONG signature_len, ULONG *ret_len )
3832{
3833 ULONG required_len = len_from_bitlen( key->a.bitlen ) * 2;
3834
3835 if (signature_len < required_len)
3836 {
3837 *ret_len = required_len;
3838 if (signature) return STATUS_BUFFER_TOO_SMALL;
3839 return STATUS_SUCCESS;
3840 }
3841 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
3842
3843 if (SymCryptEcDsaSign( key->a.ecc.handle, hash, hash_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, signature,
3844 required_len )) return STATUS_INTERNAL_ERROR;
3845
3846 *ret_len = required_len;
3847 return STATUS_SUCCESS;
3848}
3849
3850static NTSTATUS sign_hash_dsa( const struct key *key, const UCHAR *hash, ULONG hash_len, UCHAR *signature,
3851 ULONG signature_len, ULONG *ret_len )
3852{
3853 ULONG required_len = hash_len * 2;
3854
3855 if (signature_len < required_len)
3856 {
3857 *ret_len = required_len;
3858 if (signature) return STATUS_BUFFER_TOO_SMALL;
3859 return STATUS_SUCCESS;
3860 }
3861 if (!(key->flags & KEY_FLAG_PRIVATE)) return STATUS_INVALID_PARAMETER;
3862
3863 if (SymCryptDsaSign( key->a.dsa.handle, hash, hash_len, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, signature,
3864 required_len )) return STATUS_INTERNAL_ERROR;
3865
3866 *ret_len = required_len;
3867 return STATUS_SUCCESS;
3868}
3869
3870NTSTATUS WINAPI BCryptSignHash( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len,
3871 UCHAR *signature, ULONG signature_len, ULONG *ret_len, ULONG flags )
3872{
3873 const struct key *key = get_key_object( handle );
3874
3875 TRACE( "%p, %p, %p, %lu, %p, %lu, %p, %#lx\n", handle, padding, hash, hash_len, signature, signature_len,
3876 ret_len, flags );
3877
3878 if (!key) return STATUS_INVALID_HANDLE;
3879
3880 switch (key->alg_id)
3881 {
3882 case ALG_ID_RSA:
3883 case ALG_ID_RSA_SIGN:
3884 return sign_hash_rsa( key, padding, hash, hash_len, signature, signature_len, ret_len, flags );
3885
3886 case ALG_ID_ECDSA:
3887 case ALG_ID_ECDSA_P256:
3888 case ALG_ID_ECDSA_P384:
3889 case ALG_ID_ECDSA_P521:
3890 if (padding) return STATUS_INVALID_PARAMETER;
3891 return sign_hash_ecc( key, hash, hash_len, signature, signature_len, ret_len );
3892
3893 case ALG_ID_DSA:
3894 return sign_hash_dsa( key, hash, hash_len, signature, signature_len, ret_len );
3895
3896 default:
3897 FIXME( "unhandled algorithm %u\n", key->alg_id );
3898 break;
3899 }
3900
3901 return STATUS_NOT_SUPPORTED;
3902}
3903
3904static NTSTATUS verify_signature_rsa( const struct key *key, const void *padding, const UCHAR *hash, ULONG hash_len,
3905 const UCHAR *signature, ULONG signature_len, ULONG flags )
3906{
3907 NTSTATUS status;
3908 SYMCRYPT_ERROR error;
3909
3910 if (!padding || signature_len != len_from_bitlen( key->a.bitlen )) return STATUS_INVALID_PARAMETER;
3911
3912 if (flags == BCRYPT_PAD_PKCS1)
3913 {
3914 const BCRYPT_PKCS1_PADDING_INFO *pad = padding;
3915 UINT32 flags = 0, hash_oid_count;
3916 const SYMCRYPT_OID *hash_oid;
3917
3918 if (!pad) return STATUS_INVALID_PARAMETER;
3919 if ((status = get_hash_oid( pad->pszAlgId, &hash_oid, &hash_oid_count ))) return status;
3920 if (!hash_oid) flags = SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID;
3921
3922 error = SymCryptRsaPkcs1Verify( key->a.rsa.handle, hash, hash_len, signature, signature_len,
3923 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, hash_oid, hash_oid_count, flags );
3924 }
3925 else if (flags == BCRYPT_PAD_PSS)
3926 {
3927 const BCRYPT_PSS_PADDING_INFO *pad = padding;
3928 const SYMCRYPT_HASH *hash_desc = get_hash_from_str( pad->pszAlgId );
3929
3930 error = SymCryptRsaPssVerify( key->a.rsa.handle, hash, hash_len, signature, signature_len,
3931 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, hash_desc, pad->cbSalt, 0 );
3932 }
3933 else
3934 {
3935 FIXME( "unsupported flags %#lx\n", flags );
3936 if (padding) return STATUS_INVALID_PARAMETER;
3937 return STATUS_NOT_SUPPORTED;
3938 }
3939
3940 if (error == SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE) return STATUS_INVALID_SIGNATURE;
3941 if (error) return STATUS_INTERNAL_ERROR;
3942 return STATUS_SUCCESS;
3943}
3944
3945static NTSTATUS verify_signature_ecc( const struct key *key, const UCHAR *hash, ULONG hash_len, const UCHAR *signature,
3946 ULONG signature_len, ULONG flags )
3947{
3948 SYMCRYPT_ERROR error;
3949
3950 if (signature_len != len_from_bitlen( key->a.bitlen ) * 2) return STATUS_INVALID_PARAMETER;
3951
3952 error = SymCryptEcDsaVerify( key->a.ecc.handle, hash, hash_len, signature, signature_len,
3953 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0 );
3954
3955 if (error == SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE) return STATUS_INVALID_SIGNATURE;
3956 if (error) return STATUS_INTERNAL_ERROR;
3957 return STATUS_SUCCESS;
3958}
3959
3960static NTSTATUS verify_signature_dsa( const struct key *key, const UCHAR *hash, ULONG hash_len, const UCHAR *signature,
3961 ULONG signature_len, ULONG flags )
3962{
3963 SYMCRYPT_ERROR error;
3964
3965 if (signature_len != hash_len * 2) return STATUS_INVALID_PARAMETER;
3966
3967 error = SymCryptDsaVerify( key->a.dsa.handle, hash, hash_len, signature, signature_len,
3968 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0 );
3969
3970 if (error == SYMCRYPT_SIGNATURE_VERIFICATION_FAILURE) return STATUS_INVALID_SIGNATURE;
3971 if (error) return STATUS_INTERNAL_ERROR;
3972 return STATUS_SUCCESS;
3973}
3974
3975NTSTATUS WINAPI BCryptVerifySignature( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len,
3976 UCHAR *signature, ULONG signature_len, ULONG flags )
3977{
3978 const struct key *key = get_key_object( handle );
3979
3980 TRACE( "%p, %p, %p, %lu, %p, %lu, %#lx\n", handle, padding, hash, hash_len, signature, signature_len, flags );
3981
3982 if (!key) return STATUS_INVALID_HANDLE;
3983 if (!hash || !hash_len || !signature || !signature_len) return STATUS_INVALID_PARAMETER;
3984
3985 switch (key->alg_id)
3986 {
3987 case ALG_ID_RSA:
3988 case ALG_ID_RSA_SIGN:
3989 return verify_signature_rsa( key, padding, hash, hash_len, signature, signature_len, flags );
3990
3991 case ALG_ID_ECDSA:
3992 case ALG_ID_ECDSA_P256:
3993 case ALG_ID_ECDSA_P384:
3994 case ALG_ID_ECDSA_P521:
3995 return verify_signature_ecc( key, hash, hash_len, signature, signature_len, flags );
3996
3997 case ALG_ID_DSA:
3998 return verify_signature_dsa( key, hash, hash_len, signature, signature_len, flags );
3999
4000 default:
4001 FIXME( "unhandled algorithm %u\n", key->alg_id );
4002 break;
4003 }
4004
4005 return STATUS_NOT_SUPPORTED;
4006}
4007
4008NTSTATUS WINAPI BCryptDestroyKey( BCRYPT_KEY_HANDLE handle )
4009{
4010 struct key *key = get_key_object( handle );
4011
4012 TRACE( "%p\n", handle );
4013
4014 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
4015
4016 destroy_key( key );
4017 return STATUS_SUCCESS;
4018}
4019
4020#define HMAC_PAD_LEN 64
4021NTSTATUS WINAPI BCryptDeriveKeyCapi( BCRYPT_HASH_HANDLE handle, BCRYPT_ALG_HANDLE halg, UCHAR *key, ULONG keylen,
4022 ULONG flags )
4023{
4024 struct hash *hash = get_hash_object( handle );
4025 UCHAR buf[MAX_HASH_OUTPUT_BYTES * 2];
4026
4027 TRACE( "%p, %p, %p, %lu, %#lx\n", handle, halg, key, keylen, flags );
4028
4029 if (!hash) return STATUS_INVALID_HANDLE;
4030 if (!key || !keylen || keylen > hash->len * 2) return STATUS_INVALID_PARAMETER;
4031 if (halg)
4032 {
4033 FIXME( "algorithm handle not supported\n" );
4034 return STATUS_NOT_IMPLEMENTED;
4035 }
4036
4037 finish_hash( hash, buf );
4038
4039 if (hash->len < keylen)
4040 {
4041 UCHAR pad1[HMAC_PAD_LEN], pad2[HMAC_PAD_LEN];
4042 ULONG i;
4043
4044 for (i = 0; i < sizeof(pad1); i++)
4045 {
4046 pad1[i] = 0x36 ^ (i < hash->len ? buf[i] : 0);
4047 pad2[i] = 0x5c ^ (i < hash->len ? buf[i] : 0);
4048 }
4049
4050 prepare_hash( hash );
4051 hash_data( hash, pad1, sizeof(pad1) );
4052 finish_hash( hash, buf );
4053
4054 prepare_hash( hash );
4055 hash_data( hash, pad2, sizeof(pad2) );
4056 finish_hash( hash, buf + hash->len );
4057 }
4058
4059 memcpy( key, buf, keylen );
4060 return STATUS_SUCCESS;
4061}
4062
4063static void destroy_secret( struct secret *secret )
4064{
4065 if (!secret) return;
4066 secure_zero( secret->derived_key, secret->derived_key_len );
4067 free( secret->derived_key );
4068 destroy_object( &secret->hdr );
4069}
4070
4071NTSTATUS WINAPI BCryptSecretAgreement( BCRYPT_KEY_HANDLE privkey_handle, BCRYPT_KEY_HANDLE pubkey_handle,
4072 BCRYPT_SECRET_HANDLE *ret_handle, ULONG flags )
4073{
4074 const struct key *privkey = get_key_object( privkey_handle );
4075 const struct key *pubkey = get_key_object( pubkey_handle );
4076 struct secret *secret;
4077
4078 TRACE( "%p, %p, %p, %#lx\n", privkey_handle, pubkey_handle, ret_handle, flags );
4079
4080 if (!privkey || !pubkey || privkey->alg_id != pubkey->alg_id || !(privkey->flags & KEY_FLAG_PRIVATE))
4081 return STATUS_INVALID_HANDLE;
4082 if (!ret_handle) return STATUS_INVALID_PARAMETER;
4083
4084 if (!(secret = calloc( 1, sizeof(*secret) ))) return STATUS_NO_MEMORY;
4085 secret->hdr.magic = MAGIC_SECRET;
4086 secret->derived_key_len = len_from_bitlen( privkey->a.bitlen );
4087 if (!(secret->derived_key = malloc( secret->derived_key_len )))
4088 {
4089 free( secret );
4090 return STATUS_NO_MEMORY;
4091 }
4092
4093 switch (privkey->alg_id)
4094 {
4095 case ALG_ID_DH:
4096 if (SymCryptDhSecretAgreement( privkey->a.dsa.handle, pubkey->a.dsa.handle,
4097 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, secret->derived_key,
4098 secret->derived_key_len ))
4099 {
4100 destroy_secret( secret );
4101 return STATUS_INTERNAL_ERROR;
4102 }
4103 break;
4104 case ALG_ID_ECDH:
4105 case ALG_ID_ECDH_P256:
4106 case ALG_ID_ECDH_P384:
4107 case ALG_ID_ECDH_P521:
4108 if (SymCryptEcDhSecretAgreement( privkey->a.ecc.handle, pubkey->a.ecc.handle,
4109 SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, 0, secret->derived_key,
4110 secret->derived_key_len ))
4111 {
4112 destroy_secret( secret );
4113 return STATUS_INTERNAL_ERROR;
4114 }
4115 break;
4116 default:
4117 FIXME( "algorithm %u not supported\n", privkey->alg_id );
4118 destroy_secret( secret );
4119 return STATUS_NOT_SUPPORTED;
4120 }
4121
4122 *ret_handle = secret;
4123 TRACE( "returning handle %p\n", *ret_handle );
4124 return STATUS_SUCCESS;
4125}
4126
4127NTSTATUS WINAPI BCryptDestroySecret( BCRYPT_SECRET_HANDLE handle )
4128{
4129 struct secret *secret = get_secret_object( handle );
4130
4131 TRACE( "%p\n", handle );
4132
4133 if (!secret || secret->hdr.magic != MAGIC_SECRET) return STATUS_INVALID_HANDLE;
4134
4135 destroy_secret( secret );
4136 return STATUS_SUCCESS;
4137}
4138
4139static const SYMCRYPT_MAC *get_mac_from_alg( enum alg_id alg )
4140{
4141 switch (alg)
4142 {
4143 case ALG_ID_SHA1: return SymCryptHmacSha1Algorithm;
4144 case ALG_ID_SHA256: return SymCryptHmacSha256Algorithm;
4145 case ALG_ID_SHA384: return SymCryptHmacSha384Algorithm;
4146 case ALG_ID_SHA512: return SymCryptHmacSha512Algorithm;
4147 default:
4148 FIXME( "hash algorithm %u not supported\n", alg );
4149 return NULL;
4150 }
4151}
4152
4153NTSTATUS WINAPI BCryptDeriveKeyPBKDF2( BCRYPT_ALG_HANDLE handle, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len,
4154 ULONGLONG iterations, UCHAR *key, ULONG key_len, ULONG flags )
4155{
4156 const struct algorithm *alg = get_alg_object( handle );
4157 const SYMCRYPT_MAC *mac;
4158
4159 TRACE( "%p, %p, %lu, %p, %lu, %s, %p, %lu, %#lx\n", handle, pwd, pwd_len, salt, salt_len,
4160 wine_dbgstr_longlong(iterations), key, key_len, flags );
4161
4162 if (!alg || !(alg->flags & BCRYPT_ALG_HANDLE_HMAC_FLAG)) return STATUS_INVALID_HANDLE;
4163 if (!iterations) return STATUS_INVALID_PARAMETER;
4164
4165 if (!(mac = get_mac_from_alg( alg->id ))) return STATUS_NOT_SUPPORTED;
4166
4167 if (SymCryptPbkdf2( mac, pwd, pwd_len, salt, salt_len, iterations, key, key_len )) return STATUS_INTERNAL_ERROR;
4168 return STATUS_SUCCESS;
4169}
4170
4171static const struct algorithm *get_hash_from_desc( const BCryptBufferDesc *desc )
4172{
4173 const struct algorithm *alg = get_alg_object( BCRYPT_SHA1_ALG_HANDLE );
4174 ULONG i;
4175
4176 if (!desc) return alg;
4177 for (i = 0; i < desc->cBuffers; i++)
4178 {
4179 if (desc->pBuffers[i].BufferType == KDF_HASH_ALGORITHM)
4180 {
4181 const WCHAR *str = desc->pBuffers[i].pvBuffer;
4182
4183 if (!wcscmp( str, BCRYPT_SHA1_ALGORITHM )) alg = get_alg_object( BCRYPT_SHA1_ALG_HANDLE );
4184 else if (!wcscmp( str, BCRYPT_SHA256_ALGORITHM )) alg = get_alg_object( BCRYPT_SHA256_ALG_HANDLE );
4185 else if (!wcscmp( str, BCRYPT_SHA384_ALGORITHM )) alg = get_alg_object( BCRYPT_SHA384_ALG_HANDLE );
4186 else if (!wcscmp( str, BCRYPT_SHA512_ALGORITHM )) alg = get_alg_object( BCRYPT_SHA512_ALG_HANDLE );
4187 else
4188 {
4189 FIXME( "hash %s not suported\n", debugstr_w(str) );
4190 return NULL;
4191 }
4192 }
4193 else if (desc->pBuffers[i].BufferType == KDF_SECRET_PREPEND) continue;
4194 else FIXME( "buffer type %lu not supported\n", desc->pBuffers[i].BufferType );
4195 }
4196 return alg;
4197}
4198
4199static NTSTATUS derive_key_hash( const struct secret *secret, const BCryptBufferDesc *desc, UCHAR *output,
4200 ULONG output_len, ULONG *ret_len )
4201{
4202 ULONG derived_key_len = secret->derived_key_len, secret_len = 0;
4203 ULONG i, buffer_count = desc ? desc->cBuffers : 0;
4204 UCHAR *derived_key = secret->derived_key;
4205 const struct algorithm *alg;
4206 ULONG len;
4207 UCHAR hash[MAX_HASH_OUTPUT_BYTES];
4208 NTSTATUS status;
4209
4210 if (!(alg = get_hash_from_desc( desc ))) return STATUS_NOT_SUPPORTED;
4211 len = builtin_algorithms[alg->id].hash_length;
4212
4213 if (!output)
4214 {
4215 *ret_len = len;
4216 return STATUS_SUCCESS;
4217 }
4218
4219 for (i = 0; i < buffer_count; i++)
4220 if (desc->pBuffers[i].BufferType == KDF_SECRET_PREPEND) secret_len += desc->pBuffers[i].cbBuffer;
4221
4222 if (secret_len)
4223 {
4224 if (!(derived_key = malloc( secret_len + derived_key_len ))) return STATUS_NO_MEMORY;
4225
4226 derived_key_len = 0;
4227 for (i = 0; i < buffer_count; i++)
4228 {
4229 if (desc->pBuffers[i].BufferType != KDF_SECRET_PREPEND) continue;
4230 memcpy( derived_key + derived_key_len, desc->pBuffers[i].pvBuffer, desc->pBuffers[i].cbBuffer );
4231 derived_key_len += desc->pBuffers[i].cbBuffer;
4232 }
4233
4234 memcpy( derived_key + derived_key_len, secret->derived_key, secret->derived_key_len );
4235 derived_key_len += secret->derived_key_len;
4236 }
4237
4238 status = hash_single( alg, NULL, 0, derived_key, derived_key_len, hash );
4239 if (derived_key != secret->derived_key) free( derived_key );
4240 if (status) return status;
4241
4242 len = min( len, output_len );
4243 memcpy( output, hash, len );
4244
4245 *ret_len = len;
4246 return STATUS_SUCCESS;
4247}
4248
4249static NTSTATUS derive_key_raw( const struct secret *secret, UCHAR *output, ULONG output_len, ULONG *ret_len )
4250{
4251 ULONG i, len = secret->derived_key_len;
4252
4253 if (!output)
4254 {
4255 *ret_len = len;
4256 return STATUS_SUCCESS;
4257 }
4258
4259 len = min( len, output_len );
4260 for (i = 0; i < len; i++) output[i] = secret->derived_key[len - i - 1];
4261
4262 *ret_len = len;
4263 return STATUS_SUCCESS;
4264}
4265
4266NTSTATUS WINAPI BCryptDeriveKey( BCRYPT_SECRET_HANDLE handle, const WCHAR *kdf, BCryptBufferDesc *desc, UCHAR *output,
4267 ULONG output_len, ULONG *ret_len, ULONG flags )
4268{
4269 const struct secret *secret = get_secret_object( handle );
4270
4271 TRACE( "%p, %s, %p, %p, %lu, %p, %#lx\n", secret, debugstr_w(kdf), desc, output, output_len, ret_len, flags );
4272 if (flags) FIXME( "ignoring flags %#lx\n", flags );
4273
4274 if (!secret) return STATUS_INVALID_HANDLE;
4275 if (!kdf || !ret_len) return STATUS_INVALID_PARAMETER;
4276
4277 if (!wcscmp( kdf, BCRYPT_KDF_HASH ))
4278 {
4279 return derive_key_hash( secret, desc, output, output_len, ret_len );
4280 }
4281 if (!wcscmp( kdf, BCRYPT_KDF_RAW_SECRET ))
4282 {
4283 return derive_key_raw( secret, output, output_len, ret_len );
4284 }
4285
4286 FIXME( "kdf %s not supportedi\n", debugstr_w(kdf) );
4287 return STATUS_NOT_SUPPORTED;
4288}
4289
4290static NTSTATUS key_derivation_pbkdf2( const struct key *key, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len,
4291 ULONG *ret_len )
4292{
4293 const SYMCRYPT_MAC *mac = NULL;
4294 UINT64 iterations = 10000;
4295 ULONG salt_len = 0, i;
4296 const UCHAR *salt = NULL;
4297
4298 if (desc)
4299 {
4300 for (i = 0; i < desc->cBuffers; i++)
4301 {
4302 switch (desc->pBuffers[i].BufferType)
4303 {
4304 case KDF_HASH_ALGORITHM:
4305 mac = get_hmac_from_hash( desc->pBuffers[i].pvBuffer );
4306 break;
4307 case KDF_SALT:
4308 salt = desc->pBuffers[i].pvBuffer;
4309 salt_len = desc->pBuffers[i].cbBuffer;
4310 break;
4311 case KDF_ITERATION_COUNT:
4312 if (desc->pBuffers[i].cbBuffer != sizeof(iterations)) return STATUS_INVALID_PARAMETER;
4313 iterations = *(UINT64 *)desc->pBuffers[i].pvBuffer;
4314 break;
4315 default:
4316 WARN( "unexpected buffer type %lu\n", desc->pBuffers[i].BufferType );
4317 break;
4318 }
4319 }
4320 }
4321 if (!mac) return STATUS_INVALID_PARAMETER;
4322
4323 if (SymCryptPbkdf2( mac, key->s.secret, key->s.secret_len, salt, salt_len, iterations, output, output_len ))
4324 return STATUS_INTERNAL_ERROR;
4325
4326 *ret_len = output_len;
4327 return STATUS_SUCCESS;
4328}
4329
4330static NTSTATUS key_derivation_tls_prf( const struct key *key, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len,
4331 ULONG *ret_len, BOOL tls1_2 )
4332{
4333 const SYMCRYPT_MAC *mac = NULL;
4334 ULONG label_len = 0, seed_len = 0, i;
4335 const UCHAR *label = NULL, *seed = NULL;
4336 SYMCRYPT_ERROR error;
4337
4338 if (desc)
4339 {
4340 for (i = 0; i < desc->cBuffers; i++)
4341 {
4342 switch (desc->pBuffers[i].BufferType)
4343 {
4344 case KDF_TLS_PRF_LABEL:
4345 label = desc->pBuffers[i].pvBuffer;
4346 label_len = desc->pBuffers[i].cbBuffer;
4347 break;
4348 case KDF_TLS_PRF_SEED:
4349 seed = desc->pBuffers[i].pvBuffer;
4350 seed_len = desc->pBuffers[i].cbBuffer;
4351 break;
4352 case KDF_HASH_ALGORITHM:
4353 mac = get_hmac_from_hash( desc->pBuffers[i].pvBuffer );
4354 break;
4355 default:
4356 WARN( "unexpected buffer type %lu\n", desc->pBuffers[i].BufferType );
4357 break;
4358 }
4359 }
4360 }
4361 if (!seed || (tls1_2 && !mac)) return STATUS_INVALID_PARAMETER;
4362
4363 if (tls1_2)
4364 error = SymCryptTlsPrf1_2( mac, key->s.secret, key->s.secret_len, label, label_len, seed, seed_len,
4365 output, output_len );
4366 else
4367 error = SymCryptTlsPrf1_1( key->s.secret, key->s.secret_len, label, label_len, seed, seed_len, output,
4368 output_len );
4369 if (error) return STATUS_INTERNAL_ERROR;
4370
4371 *ret_len = output_len;
4372 return STATUS_SUCCESS;
4373}
4374
4375static NTSTATUS key_derivation_hkdf( const struct key *key, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len,
4376 ULONG *ret_len )
4377{
4378 const UCHAR *info = NULL;
4379 ULONG i, info_len = 0;
4380
4381 if (desc)
4382 {
4383 for (i = 0; i < desc->cBuffers; i++)
4384 {
4385 switch (desc->pBuffers[i].BufferType)
4386 {
4387 case KDF_HKDF_INFO:
4388 info = desc->pBuffers[i].pvBuffer;
4389 info_len = desc->pBuffers[i].cbBuffer;
4390 break;
4391 default:
4392 WARN( "unexpected buffer type %lu\n", desc->pBuffers[i].BufferType );
4393 break;
4394 }
4395 }
4396 }
4397
4398 if (SymCryptHkdfDerive( &key->s.hkdf.handle, info, info_len, output, output_len )) return STATUS_INTERNAL_ERROR;
4399
4400 *ret_len = output_len;
4401 return STATUS_SUCCESS;
4402}
4403
4404NTSTATUS WINAPI BCryptKeyDerivation( BCRYPT_KEY_HANDLE handle, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len,
4405 ULONG *ret_len, ULONG flags )
4406{
4407 const struct key *key = get_key_object( handle );
4408 NTSTATUS status;
4409
4410 TRACE( "%p, %p, %p, %lu, %p, %#lx\n", key, desc, output, output_len, ret_len, flags );
4411
4412 if (!key || !output || !ret_len) return STATUS_INVALID_PARAMETER;
4413
4414 switch (key->alg_id)
4415 {
4416 case ALG_ID_PBKDF2:
4417 status = key_derivation_pbkdf2( key, desc, output, output_len, ret_len );
4418 break;
4419 case ALG_ID_TLS1_1_KDF:
4420 status = key_derivation_tls_prf( key, desc, output, output_len, ret_len, FALSE );
4421 break;
4422 case ALG_ID_TLS1_2_KDF:
4423 status = key_derivation_tls_prf( key, desc, output, output_len, ret_len, TRUE );
4424 break;
4425 case ALG_ID_HKDF:
4426 status = key_derivation_hkdf( key, desc, output, output_len, ret_len );
4427 break;
4428 default:
4429 FIXME( "unsupported algorithm %u\n", key->alg_id );
4430 return STATUS_NOT_IMPLEMENTED;
4431 }
4432 return status;
4433}
4434
4435BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
4436{
4437 switch (reason)
4438 {
4439 case DLL_PROCESS_ATTACH:
4440 DisableThreadLibraryCalls( hinst );
4441 SymCryptInit();
4442 break;
4443 case DLL_PROCESS_DETACH:
4444 if (reserved) break;
4445 break;
4446 }
4447 return TRUE;
4448}
mod
std::map< E_MODULE, HMODULE > mod
Definition: LocaleTests.cpp:68
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
UINT64
COMPILER_DEPENDENT_UINT64 UINT64
Definition: actypes.h:131
WINE_DEFAULT_DEBUG_CHANNEL
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
pwd_len
ULONG pwd_len
Definition: bcrypt.c:511
iterations
ULONGLONG iterations
Definition: bcrypt.c:513
pwd
UCHAR * pwd
Definition: bcrypt.c:515
salt_len
ULONG salt_len
Definition: bcrypt.c:512
salt
static UCHAR salt[]
Definition: bcrypt.c:495
private_exp
BYTE private_exp[512/8]
Definition: bcrypt.c:2643
coefficient
BYTE coefficient[512/16]
Definition: bcrypt.c:2642
BCRYPT_MD4_ALGORITHM
#define BCRYPT_MD4_ALGORITHM
Definition: bcrypt.h:111
BCRYPT_KEY_LENGTHS
#define BCRYPT_KEY_LENGTHS
Definition: bcrypt.h:62
LEGACY_RSAPRIVATE_BLOB
#define LEGACY_RSAPRIVATE_BLOB
Definition: bcrypt.h:90
BCRYPT_RSAPUBLIC_BLOB
#define BCRYPT_RSAPUBLIC_BLOB
Definition: bcrypt.h:76
BCRYPT_RNG_ALG_HANDLE
#define BCRYPT_RNG_ALG_HANDLE
Definition: bcrypt.h:424
LEGACY_DSA_V2_PRIVATE_BLOB
#define LEGACY_DSA_V2_PRIVATE_BLOB
Definition: bcrypt.h:88
BCRYPT_KDF_HASH
#define BCRYPT_KDF_HASH
Definition: bcrypt.h:146
BCRYPT_HKDF_HASH_ALGORITHM
#define BCRYPT_HKDF_HASH_ALGORITHM
Definition: bcrypt.h:127
BCRYPT_ECDH_P384_ALGORITHM
#define BCRYPT_ECDH_P384_ALGORITHM
Definition: bcrypt.h:104
BCRYPT_SECRET_AGREEMENT_OPERATION
#define BCRYPT_SECRET_AGREEMENT_OPERATION
Definition: bcrypt.h:180
BCRYPT_3DES_ALGORITHM
#define BCRYPT_3DES_ALGORITHM
Definition: bcrypt.h:95
BCRYPT_CHAIN_MODE_GCM
#define BCRYPT_CHAIN_MODE_GCM
Definition: bcrypt.h:136
BCRYPT_SIGNATURE_OPERATION
#define BCRYPT_SIGNATURE_OPERATION
Definition: bcrypt.h:181
BCRYPT_HASH_OPERATION
#define BCRYPT_HASH_OPERATION
Definition: bcrypt.h:178
BCRYPT_DH_PUBLIC_MAGIC
#define BCRYPT_DH_PUBLIC_MAGIC
Definition: bcrypt.h:318
BCRYPT_ECDH_PRIVATE_P256_MAGIC
#define BCRYPT_ECDH_PRIVATE_P256_MAGIC
Definition: bcrypt.h:165
BCRYPT_KEY_DATA_BLOB_MAGIC
#define BCRYPT_KEY_DATA_BLOB_MAGIC
Definition: bcrypt.h:406
BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC
#define BCRYPT_ECDSA_PUBLIC_GENERIC_MAGIC
Definition: bcrypt.h:174
BCRYPT_ECDSA_PUBLIC_P256_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P256_MAGIC
Definition: bcrypt.h:157
BCRYPT_SIGNATURE_LENGTH
#define BCRYPT_SIGNATURE_LENGTH
Definition: bcrypt.h:68
BCRYPT_ECDSA_P384_ALGORITHM
#define BCRYPT_ECDSA_P384_ALGORITHM
Definition: bcrypt.h:108
BCRYPT_ECCPUBLIC_BLOB
#define BCRYPT_ECCPUBLIC_BLOB
Definition: bcrypt.h:74
BCRYPT_RSA_ALGORITHM
#define BCRYPT_RSA_ALGORITHM
Definition: bcrypt.h:117
BCRYPT_KEY_DERIVATION_INTERFACE
#define BCRYPT_KEY_DERIVATION_INTERFACE
Definition: bcrypt.h:191
BCRYPT_ECDH_PUBLIC_P384_MAGIC
#define BCRYPT_ECDH_PUBLIC_P384_MAGIC
Definition: bcrypt.h:166
BCRYPT_SHA256_ALG_HANDLE
#define BCRYPT_SHA256_ALG_HANDLE
Definition: bcrypt.h:420
LEGACY_DSA_V2_PUBLIC_BLOB
#define LEGACY_DSA_V2_PUBLIC_BLOB
Definition: bcrypt.h:87
BCRYPT_SHA384_ALG_HANDLE
#define BCRYPT_SHA384_ALG_HANDLE
Definition: bcrypt.h:421
BCRYPT_HKDF_ALGORITHM
#define BCRYPT_HKDF_ALGORITHM
Definition: bcrypt.h:125
BCRYPT_ECDH_P521_ALGORITHM
#define BCRYPT_ECDH_P521_ALGORITHM
Definition: bcrypt.h:105
BCRYPT_HASH_BLOCK_LENGTH
#define BCRYPT_HASH_BLOCK_LENGTH
Definition: bcrypt.h:57
BCRYPT_OBJECT_LENGTH
#define BCRYPT_OBJECT_LENGTH
Definition: bcrypt.h:65
BCRYPT_RC4_ALGORITHM
#define BCRYPT_RC4_ALGORITHM
Definition: bcrypt.h:115
BCRYPT_ECDSA_PUBLIC_P384_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P384_MAGIC
Definition: bcrypt.h:159
KDF_SALT
#define KDF_SALT
Definition: bcrypt.h:386
BCRYPT_ECDSA_ALGORITHM
#define BCRYPT_ECDSA_ALGORITHM
Definition: bcrypt.h:106
BCRYPT_KEY_LENGTH
#define BCRYPT_KEY_LENGTH
Definition: bcrypt.h:61
BCRYPT_AUTH_TAG_LENGTH
#define BCRYPT_AUTH_TAG_LENGTH
Definition: bcrypt.h:52
BCRYPT_CHAINING_MODE
#define BCRYPT_CHAINING_MODE
Definition: bcrypt.h:55
BCRYPT_CHAIN_MODE_CFB
#define BCRYPT_CHAIN_MODE_CFB
Definition: bcrypt.h:134
BCRYPT_CHAIN_MODE_CBC
#define BCRYPT_CHAIN_MODE_CBC
Definition: bcrypt.h:132
KDF_ITERATION_COUNT
#define KDF_ITERATION_COUNT
Definition: bcrypt.h:387
BCRYPT_KEY_DATA_BLOB
#define BCRYPT_KEY_DATA_BLOB
Definition: bcrypt.h:72
BCRYPT_SHA512_ALGORITHM
#define BCRYPT_SHA512_ALGORITHM
Definition: bcrypt.h:122
BCRYPT_ALGORITHM_NAME
#define BCRYPT_ALGORITHM_NAME
Definition: bcrypt.h:51
BCRYPT_DH_PARAMETERS
#define BCRYPT_DH_PARAMETERS
Definition: bcrypt.h:153
BCRYPT_DSA_ALGORITHM
#define BCRYPT_DSA_ALGORITHM
Definition: bcrypt.h:101
BCRYPT_KEY_STRENGTH
#define BCRYPT_KEY_STRENGTH
Definition: bcrypt.h:64
BCRYPT_ECC_CURVE_NAME
#define BCRYPT_ECC_CURVE_NAME
Definition: bcrypt.h:138
BCRYPT_ECC_CURVE_25519
#define BCRYPT_ECC_CURVE_25519
Definition: bcrypt.h:139
BCRYPT_ECC_CURVE_SECP384R1
#define BCRYPT_ECC_CURVE_SECP384R1
Definition: bcrypt.h:143
BCRYPT_AES_ALGORITHM
#define BCRYPT_AES_ALGORITHM
Definition: bcrypt.h:96
BCRYPT_PBKDF2_ALGORITHM
#define BCRYPT_PBKDF2_ALGORITHM
Definition: bcrypt.h:113
BCRYPT_ECC_CURVE_BRAINPOOLP256R1
#define BCRYPT_ECC_CURVE_BRAINPOOLP256R1
Definition: bcrypt.h:140
BCRYPT_SUPPORTED_PAD_PKCS1_SIG
#define BCRYPT_SUPPORTED_PAD_PKCS1_SIG
Definition: bcrypt.h:195
BCRYPT_PAD_PKCS1
#define BCRYPT_PAD_PKCS1
Definition: bcrypt.h:274
BCRYPT_KEY_DATA_BLOB_HEADER
struct _BCRYPT_KEY_DATA_BLOB_HEADER BCRYPT_KEY_DATA_BLOB_HEADER
BCRYPT_RSAFULLPRIVATE_MAGIC
#define BCRYPT_RSAFULLPRIVATE_MAGIC
Definition: bcrypt.h:243
BCRYPT_BLOCK_LENGTH
#define BCRYPT_BLOCK_LENGTH
Definition: bcrypt.h:53
BCRYPT_MD2_ALGORITHM
#define BCRYPT_MD2_ALGORITHM
Definition: bcrypt.h:110
BCRYPT_SECRET_AGREEMENT_INTERFACE
#define BCRYPT_SECRET_AGREEMENT_INTERFACE
Definition: bcrypt.h:188
BCRYPT_PUBLIC_KEY_BLOB
#define BCRYPT_PUBLIC_KEY_BLOB
Definition: bcrypt.h:81
BCRYPT_SHA256_ALGORITHM
#define BCRYPT_SHA256_ALGORITHM
Definition: bcrypt.h:120
BCRYPT_CHAIN_MODE_NA
#define BCRYPT_CHAIN_MODE_NA
Definition: bcrypt.h:131
BCRYPT_RSAPRIVATE_MAGIC
#define BCRYPT_RSAPRIVATE_MAGIC
Definition: bcrypt.h:242
BCRYPT_CIPHER_INTERFACE
#define BCRYPT_CIPHER_INTERFACE
Definition: bcrypt.h:185
BCRYPT_PAD_PSS
#define BCRYPT_PAD_PSS
Definition: bcrypt.h:276
BCRYPT_RSAPRIVATE_BLOB
#define BCRYPT_RSAPRIVATE_BLOB
Definition: bcrypt.h:77
KDF_SECRET_PREPEND
#define KDF_SECRET_PREPEND
Definition: bcrypt.h:372
BCRYPT_DSA_PUBLIC_BLOB
#define BCRYPT_DSA_PUBLIC_BLOB
Definition: bcrypt.h:79
BCRYPT_SUPPORTED_PAD_OAEP
#define BCRYPT_SUPPORTED_PAD_OAEP
Definition: bcrypt.h:196
BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE
#define BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE
Definition: bcrypt.h:187
BCRYPT_RNG_OPERATION
#define BCRYPT_RNG_OPERATION
Definition: bcrypt.h:182
BCRYPT_ECDH_PUBLIC_P256_MAGIC
#define BCRYPT_ECDH_PUBLIC_P256_MAGIC
Definition: bcrypt.h:164
BCRYPT_ALG_HANDLE_HMAC_FLAG
#define BCRYPT_ALG_HANDLE_HMAC_FLAG
Definition: bcrypt.h:481
BCRYPT_ECCPRIVATE_BLOB
#define BCRYPT_ECCPRIVATE_BLOB
Definition: bcrypt.h:75
KDF_HASH_ALGORITHM
#define KDF_HASH_ALGORITHM
Definition: bcrypt.h:371
KDF_TLS_PRF_SEED
#define KDF_TLS_PRF_SEED
Definition: bcrypt.h:376
BCRYPT_ECDSA_PRIVATE_P521_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P521_MAGIC
Definition: bcrypt.h:162
BCRYPT_CIPHER_OPERATION
#define BCRYPT_CIPHER_OPERATION
Definition: bcrypt.h:177
BCRYPT_ECDSA_P256_ALGORITHM
#define BCRYPT_ECDSA_P256_ALGORITHM
Definition: bcrypt.h:107
KDF_HKDF_INFO
#define KDF_HKDF_INFO
Definition: bcrypt.h:388
BCRYPT_HKDF_PRK_AND_FINALIZE
#define BCRYPT_HKDF_PRK_AND_FINALIZE
Definition: bcrypt.h:129
BCRYPT_RNG_ALGORITHM
#define BCRYPT_RNG_ALGORITHM
Definition: bcrypt.h:116
BCRYPT_DSA_PRIVATE_MAGIC
#define BCRYPT_DSA_PRIVATE_MAGIC
Definition: bcrypt.h:280
BCRYPT_AES_WRAP_KEY_BLOB
#define BCRYPT_AES_WRAP_KEY_BLOB
Definition: bcrypt.h:73
BCRYPT_HKDF_SALT_AND_FINALIZE
#define BCRYPT_HKDF_SALT_AND_FINALIZE
Definition: bcrypt.h:128
BCRYPT_ECDSA_P521_ALGORITHM
#define BCRYPT_ECDSA_P521_ALGORITHM
Definition: bcrypt.h:109
BCRYPT_DSA_PRIVATE_BLOB
#define BCRYPT_DSA_PRIVATE_BLOB
Definition: bcrypt.h:80
BCRYPT_HASH_LENGTH
#define BCRYPT_HASH_LENGTH
Definition: bcrypt.h:58
BCRYPT_ECDSA_PRIVATE_P256_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P256_MAGIC
Definition: bcrypt.h:158
BCRYPT_ECDH_ALGORITHM
#define BCRYPT_ECDH_ALGORITHM
Definition: bcrypt.h:102
BCRYPT_SIGNATURE_INTERFACE
#define BCRYPT_SIGNATURE_INTERFACE
Definition: bcrypt.h:189
BCRYPT_KDF_RAW_SECRET
#define BCRYPT_KDF_RAW_SECRET
Definition: bcrypt.h:150
BCRYPT_ECDSA_PRIVATE_P384_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P384_MAGIC
Definition: bcrypt.h:160
BCRYPT_ECC_CURVE_BRAINPOOLP384R1
#define BCRYPT_ECC_CURVE_BRAINPOOLP384R1
Definition: bcrypt.h:141
BCRYPT_BLOCK_PADDING
#define BCRYPT_BLOCK_PADDING
Definition: bcrypt.h:484
BCRYPT_SHA512_ALG_HANDLE
#define BCRYPT_SHA512_ALG_HANDLE
Definition: bcrypt.h:422
BCRYPT_ECDSA_PUBLIC_P521_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P521_MAGIC
Definition: bcrypt.h:161
BCRYPT_AES_GMAC_ALGORITHM
#define BCRYPT_AES_GMAC_ALGORITHM
Definition: bcrypt.h:97
BCRYPT_PADDING_SCHEMES
#define BCRYPT_PADDING_SCHEMES
Definition: bcrypt.h:66
BCRYPT_DH_PARAMETERS_MAGIC
#define BCRYPT_DH_PARAMETERS_MAGIC
Definition: bcrypt.h:327
BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC
#define BCRYPT_ECDSA_PRIVATE_GENERIC_MAGIC
Definition: bcrypt.h:175
BCRYPT_RSAPUBLIC_MAGIC
#define BCRYPT_RSAPUBLIC_MAGIC
Definition: bcrypt.h:241
BCRYPT_ECDH_PRIVATE_P384_MAGIC
#define BCRYPT_ECDH_PRIVATE_P384_MAGIC
Definition: bcrypt.h:167
BCRYPT_KEY_DERIVATION_OPERATION
#define BCRYPT_KEY_DERIVATION_OPERATION
Definition: bcrypt.h:183
BCRYPT_TLS1_2_KDF_ALGORITHM
#define BCRYPT_TLS1_2_KDF_ALGORITHM
Definition: bcrypt.h:124
BCRYPT_HASH_REUSABLE_FLAG
#define BCRYPT_HASH_REUSABLE_FLAG
Definition: bcrypt.h:487
BCRYPT_KEY_DATA_BLOB_VERSION1
#define BCRYPT_KEY_DATA_BLOB_VERSION1
Definition: bcrypt.h:407
BCRYPT_INITIALIZATION_VECTOR
#define BCRYPT_INITIALIZATION_VECTOR
Definition: bcrypt.h:60
BCRYPT_HASH_INTERFACE
#define BCRYPT_HASH_INTERFACE
Definition: bcrypt.h:186
BCRYPT_ECC_CURVE_SECP256R1
#define BCRYPT_ECC_CURVE_SECP256R1
Definition: bcrypt.h:142
MS_PRIMITIVE_PROVIDER
#define MS_PRIMITIVE_PROVIDER
Definition: bcrypt.h:92
BCRYPT_ECDH_PUBLIC_P521_MAGIC
#define BCRYPT_ECDH_PUBLIC_P521_MAGIC
Definition: bcrypt.h:168
KDF_TLS_PRF_LABEL
#define KDF_TLS_PRF_LABEL
Definition: bcrypt.h:375
BCRYPT_DH_PRIVATE_BLOB
#define BCRYPT_DH_PRIVATE_BLOB
Definition: bcrypt.h:84
BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG
#define BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG
Definition: bcrypt.h:338
BCRYPT_ECDH_P256_ALGORITHM
#define BCRYPT_ECDH_P256_ALGORITHM
Definition: bcrypt.h:103
BCRYPT_PAD_OAEP
#define BCRYPT_PAD_OAEP
Definition: bcrypt.h:275
BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION
#define BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION
Definition: bcrypt.h:179
BCRYPT_CHACHA20_POLY1305_ALGORITHM
#define BCRYPT_CHACHA20_POLY1305_ALGORITHM
Definition: bcrypt.h:98
BCRYPT_ECDH_PRIVATE_P521_MAGIC
#define BCRYPT_ECDH_PRIVATE_P521_MAGIC
Definition: bcrypt.h:169
BCRYPT_RSA_SIGN_ALGORITHM
#define BCRYPT_RSA_SIGN_ALGORITHM
Definition: bcrypt.h:118
BCRYPT_SHA384_ALGORITHM
#define BCRYPT_SHA384_ALGORITHM
Definition: bcrypt.h:121
BCRYPT_DSA_PUBLIC_MAGIC
#define BCRYPT_DSA_PUBLIC_MAGIC
Definition: bcrypt.h:279
BCRYPT_OPAQUE_KEY_BLOB
#define BCRYPT_OPAQUE_KEY_BLOB
Definition: bcrypt.h:71
BCRYPT_DH_ALGORITHM
#define BCRYPT_DH_ALGORITHM
Definition: bcrypt.h:100
BCRYPT_TLS1_1_KDF_ALGORITHM
#define BCRYPT_TLS1_1_KDF_ALGORITHM
Definition: bcrypt.h:123
BCRYPT_CHAIN_MODE_ECB
#define BCRYPT_CHAIN_MODE_ECB
Definition: bcrypt.h:133
BCRYPT_SHA1_ALGORITHM
#define BCRYPT_SHA1_ALGORITHM
Definition: bcrypt.h:119
BCRYPT_RNG_INTERFACE
#define BCRYPT_RNG_INTERFACE
Definition: bcrypt.h:190
BCRYPT_PAD_NONE
#define BCRYPT_PAD_NONE
Definition: bcrypt.h:273
BCRYPT_RSAFULLPRIVATE_BLOB
#define BCRYPT_RSAFULLPRIVATE_BLOB
Definition: bcrypt.h:78
BCRYPT_MESSAGE_BLOCK_LENGTH
#define BCRYPT_MESSAGE_BLOCK_LENGTH
Definition: bcrypt.h:155
BCRYPT_ECC_CURVE_SECP521R1
#define BCRYPT_ECC_CURVE_SECP521R1
Definition: bcrypt.h:144
BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC
#define BCRYPT_ECDH_PUBLIC_GENERIC_MAGIC
Definition: bcrypt.h:171
BCRYPT_MD5_ALGORITHM
#define BCRYPT_MD5_ALGORITHM
Definition: bcrypt.h:112
BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC
#define BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC
Definition: bcrypt.h:172
BCRYPT_SHA1_ALG_HANDLE
#define BCRYPT_SHA1_ALG_HANDLE
Definition: bcrypt.h:419
BCRYPT_DH_PUBLIC_BLOB
#define BCRYPT_DH_PUBLIC_BLOB
Definition: bcrypt.h:83
BCRYPT_DH_PRIVATE_MAGIC
#define BCRYPT_DH_PRIVATE_MAGIC
Definition: bcrypt.h:319
BCRYPT_USE_SYSTEM_PREFERRED_RNG
#define BCRYPT_USE_SYSTEM_PREFERRED_RNG
Definition: bcrypt.h:478
MAGIC_ALG
#define MAGIC_ALG
Definition: bcrypt_main.c:45
BCryptAddContextFunctionProvider
NTSTATUS WINAPI BCryptAddContextFunctionProvider(ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func, const WCHAR *provider, ULONG pos)
Definition: bcrypt_main.c:304
MAX_HASH_OUTPUT_BYTES
#define MAX_HASH_OUTPUT_BYTES
Definition: bcrypt_main.c:349
pseudo_algorithms
static const struct algorithm pseudo_algorithms[]
Definition: bcrypt_main.c:461
export_rsa_key
static NTSTATUS export_rsa_key(const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len)
Definition: bcrypt_main.c:2442
BCryptSecretAgreement
NTSTATUS WINAPI BCryptSecretAgreement(BCRYPT_KEY_HANDLE privkey_handle, BCRYPT_KEY_HANDLE pubkey_handle, BCRYPT_SECRET_HANDLE *ret_handle, ULONG flags)
Definition: bcrypt_main.c:4071
get_hash_oid
static NTSTATUS get_hash_oid(const WCHAR *str, const SYMCRYPT_OID **oid, UINT32 *oid_count)
Definition: bcrypt_main.c:3737
BCryptRemoveContextFunctionProvider
NTSTATUS WINAPI BCryptRemoveContextFunctionProvider(ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func, const WCHAR *provider)
Definition: bcrypt_main.c:318
get_rsa_property
static NTSTATUS get_rsa_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:850
get_hash_from_alg
static const SYMCRYPT_HASH * get_hash_from_alg(enum alg_id alg_id)
Definition: bcrypt_main.c:1368
derive_key_hash
static NTSTATUS derive_key_hash(const struct secret *secret, const BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:4199
SymCryptEcDsaSelftest
void SYMCRYPT_CALL SymCryptEcDsaSelftest(void)
Definition: bcrypt_main.c:279
BCryptGenRandom
NTSTATUS WINAPI BCryptGenRandom(BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags)
Definition: bcrypt_main.c:574
BLOCK_LENGTH_AES
#define BLOCK_LENGTH_AES
Definition: bcrypt_main.c:167
get_rc4_property
static NTSTATUS get_rc4_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:841
BCryptDuplicateKey
NTSTATUS WINAPI BCryptDuplicateKey(BCRYPT_KEY_HANDLE handle, BCRYPT_KEY_HANDLE *handle_copy, UCHAR *object, ULONG object_len, ULONG flags)
Definition: bcrypt_main.c:3717
export_dh_key
static NTSTATUS export_dh_key(const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len)
Definition: bcrypt_main.c:2658
validate_len_aes
static NTSTATUS validate_len_aes(const BCRYPT_KEY_LENGTHS_STRUCT *key_lengths, ULONG secret_len, ULONG *ret_len)
Definition: bcrypt_main.c:1659
destroy_key
static void destroy_key(struct key *key)
Definition: bcrypt_main.c:1568
brainpoolP384r1
static const BYTE brainpoolP384r1[]
Definition: bcrypt_main.c:3055
get_key_property
static NTSTATUS get_key_property(const struct key *key, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:1292
curve_strength
static ULONG curve_strength(enum ecc_curve_id curve_id)
Definition: bcrypt_main.c:3149
BCryptHashData
NTSTATUS WINAPI BCryptHashData(BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1503
SymCryptRsaSignVerifyPct
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaSignVerifyPct(const SYMCRYPT_RSAKEY *key)
Definition: bcrypt_main.c:256
BCryptGetProperty
NTSTATUS WINAPI BCryptGetProperty(BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *buffer, ULONG count, ULONG *res, ULONG flags)
Definition: bcrypt_main.c:1325
MAGIC_SECRET
#define MAGIC_SECRET
Definition: bcrypt_main.c:48
get_pbkdf2_property
static NTSTATUS get_pbkdf2_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:866
SymCryptEcurveParamsBrainpoolP256r1
const SYMCRYPT_ECURVE_PARAMS * SymCryptEcurveParamsBrainpoolP256r1
Definition: bcrypt_main.c:3053
set_dh_parameters
static NTSTATUS set_dh_parameters(struct key *key, const UCHAR *buf, ULONG size)
Definition: bcrypt_main.c:1111
finish_hash
static void finish_hash(struct hash *hash, UCHAR *output)
Definition: bcrypt_main.c:1515
builtin_algorithms
static const struct @409 builtin_algorithms[]
curve_size
static ULONG curve_size(enum ecc_curve_id curve_id)
Definition: bcrypt_main.c:3506
set_key_property
static NTSTATUS set_key_property(struct key *key, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1161
KEY_EXPORT_FLAG_PRIVATE
#define KEY_EXPORT_FLAG_PRIVATE
Definition: bcrypt_main.c:231
BCryptCreateHash
NTSTATUS WINAPI BCryptCreateHash(BCRYPT_ALG_HANDLE handle, BCRYPT_HASH_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags)
Definition: bcrypt_main.c:1416
alloc_dsa_key
static NTSTATUS alloc_dsa_key(struct key *key, ULONG bitlen)
Definition: bcrypt_main.c:3217
BCryptDecrypt
NTSTATUS WINAPI BCryptDecrypt(BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv, ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:1968
curve_id
enum ecc_curve_id curve_id
Definition: bcrypt_main.c:359
BCryptUnregisterProvider
NTSTATUS WINAPI BCryptUnregisterProvider(const WCHAR *provider)
Definition: bcrypt_main.c:343
encrypt_rsa
static NTSTATUS encrypt_rsa(const struct key *key, const UCHAR *input, ULONG input_len, const void *padding, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:2255
KEY_FLAG_FINALIZED
#define KEY_FLAG_FINALIZED
Definition: bcrypt_main.c:217
SymCryptDsaSelftest
void SYMCRYPT_CALL SymCryptDsaSelftest(void)
Definition: bcrypt_main.c:275
decrypt_symmetric
static NTSTATUS decrypt_symmetric(struct key *key, const UCHAR *input, ULONG input_len, const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *iv, ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:1876
duplicate_key
static NTSTATUS duplicate_key(const struct key *src, struct key **ret_key)
Definition: bcrypt_main.c:3669
BCryptRemoveContextFunction
NTSTATUS WINAPI BCryptRemoveContextFunction(ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func)
Definition: bcrypt_main.c:312
get_alg_object
static struct algorithm * get_alg_object(BCRYPT_ALG_HANDLE handle)
Definition: bcrypt_main.c:554
import_dh_key
static NTSTATUS import_dh_key(enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:3353
MAGIC_KEY
#define MAGIC_KEY
Definition: bcrypt_main.c:47
BCryptImportKeyPair
NTSTATUS WINAPI BCryptImportKeyPair(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE decrypt_key_handle, const WCHAR *type, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *input, ULONG input_len, ULONG flags)
Definition: bcrypt_main.c:3481
get_3des_property
static NTSTATUS get_3des_property(enum chain_mode mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:746
BCryptGenerateKeyPair
NTSTATUS WINAPI BCryptGenerateKeyPair(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE *ret_handle, ULONG bitlen, ULONG flags)
Definition: bcrypt_main.c:3571
key_derivation_hkdf
static NTSTATUS key_derivation_hkdf(const struct key *key, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:4375
import_ecc_key
static NTSTATUS import_ecc_key(enum alg_id alg, enum ecc_curve_id curve, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:3174
len_from_bitlen
static ULONG len_from_bitlen(ULONG bitlen)
Definition: bcrypt_main.c:293
BCryptRegisterProvider
NTSTATUS WINAPI BCryptRegisterProvider(const WCHAR *provider, ULONG flags, CRYPT_PROVIDER_REG *reg)
Definition: bcrypt_main.c:337
get_dsa_property
static NTSTATUS get_dsa_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:859
BCryptDeriveKeyPBKDF2
NTSTATUS WINAPI BCryptDeriveKeyPBKDF2(BCRYPT_ALG_HANDLE handle, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len, ULONGLONG iterations, UCHAR *key, ULONG key_len, ULONG flags)
Definition: bcrypt_main.c:4153
BCryptDestroyHash
NTSTATUS WINAPI BCryptDestroyHash(BCRYPT_HASH_HANDLE handle)
Definition: bcrypt_main.c:1483
key_derivation_pbkdf2
static NTSTATUS key_derivation_pbkdf2(const struct key *key, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:4290
alloc_ecc_key
static NTSTATUS alloc_ecc_key(struct key *key, enum ecc_curve_id curve_id)
Definition: bcrypt_main.c:3165
get_hmac_from_hash
static const SYMCRYPT_MAC * get_hmac_from_hash(const WCHAR *alg)
Definition: bcrypt_main.c:1135
DllMain
BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved)
Definition: bcrypt_main.c:4435
get_dh_parameters
static NTSTATUS get_dh_parameters(const struct key *key, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:1266
BCryptGenerateSymmetricKey
NTSTATUS WINAPI BCryptGenerateSymmetricKey(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags)
Definition: bcrypt_main.c:1737
destroy_secret
static void destroy_secret(struct secret *secret)
Definition: bcrypt_main.c:4063
decrypt_aes_vector
static NTSTATUS decrypt_aes_vector(struct key *key, const UCHAR *input, ULONG input_len, UCHAR *iv, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:1818
get_alg_property
static NTSTATUS get_alg_property(const struct algorithm *alg, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:935
get_tls_kdf_property
static NTSTATUS get_tls_kdf_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:886
destroy_object
static void destroy_object(struct object *obj)
Definition: bcrypt_main.c:678
import_dsa_key
static NTSTATUS import_dsa_key(enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:3225
alloc_aes_key
static NTSTATUS alloc_aes_key(struct key *key, enum chain_mode mode, ULONG block_size, const UCHAR *secret, ULONG secret_len)
Definition: bcrypt_main.c:1612
BCryptExportKey
NTSTATUS WINAPI BCryptExportKey(BCRYPT_KEY_HANDLE export_key_handle, BCRYPT_KEY_HANDLE encrypt_key_handle, const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *size, ULONG flags)
Definition: bcrypt_main.c:2749
alloc_ecc_curve
static SYMCRYPT_ECURVE * alloc_ecc_curve(enum ecc_curve_id curve_id)
Definition: bcrypt_main.c:3118
get_hkdf_property
static NTSTATUS get_hkdf_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:906
key_derivation_tls_prf
static NTSTATUS key_derivation_tls_prf(const struct key *key, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len, BOOL tls1_2)
Definition: bcrypt_main.c:4330
SymCryptEcDsaPct
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaPct(const SYMCRYPT_ECKEY *key)
Definition: bcrypt_main.c:270
set_alg_property
static NTSTATUS set_alg_property(struct algorithm *alg, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags)
Definition: bcrypt_main.c:982
create_hash
static NTSTATUS create_hash(const struct algorithm *alg, UCHAR *secret, ULONG secret_len, ULONG flags, struct hash **ret_hash)
Definition: bcrypt_main.c:1385
get_hash_property
static NTSTATUS get_hash_property(const struct hash *hash, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:1257
SymCryptDhSecretAgreementSelftest
void SYMCRYPT_CALL SymCryptDhSecretAgreementSelftest(void)
Definition: bcrypt_main.c:283
sign_hash_ecc
static NTSTATUS sign_hash_ecc(const struct key *key, const UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG *ret_len)
Definition: bcrypt_main.c:3830
BCryptDuplicateHash
NTSTATUS WINAPI BCryptDuplicateHash(BCRYPT_HASH_HANDLE handle, BCRYPT_HASH_HANDLE *handle_copy, UCHAR *object, ULONG object_len, ULONG flags)
Definition: bcrypt_main.c:1441
sign_hash_dsa
static NTSTATUS sign_hash_dsa(const struct key *key, const UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG *ret_len)
Definition: bcrypt_main.c:3850
hash_block_length
ULONG hash_block_length
Definition: bcrypt_main.c:358
unwrap_aes
static NTSTATUS unwrap_aes(const UCHAR *secret, ULONG secret_len, const UCHAR *cipher, ULONG cipher_len, UCHAR *plain)
Definition: bcrypt_main.c:2000
HMAC_PAD_LEN
#define HMAC_PAD_LEN
Definition: bcrypt_main.c:4020
MAGIC_DSS1
#define MAGIC_DSS1
Definition: bcrypt_main.c:42
get_secret_object
static struct secret * get_secret_object(BCRYPT_SECRET_HANDLE handle)
Definition: bcrypt_main.c:569
SymCryptCallbackFree
void SYMCRYPT_CALL SymCryptCallbackFree(void *ptr)
Definition: bcrypt_main.c:246
wrap_aes
static NTSTATUS wrap_aes(const UCHAR *secret, ULONG secret_len, const UCHAR *plain, ULONG plain_len, UCHAR *cipher)
Definition: bcrypt_main.c:2339
BLOCK_LENGTH_CHACHA20_POLY1305
#define BLOCK_LENGTH_CHACHA20_POLY1305
Definition: bcrypt_main.c:165
create_algorithm
static struct algorithm * create_algorithm(enum alg_id id, DWORD flags)
Definition: bcrypt_main.c:617
hash_single
static NTSTATUS hash_single(const struct algorithm *alg, UCHAR *secret, ULONG secret_len, UCHAR *input, ULONG input_len, UCHAR *output)
Definition: bcrypt_main.c:1538
chain_mode
chain_mode
Definition: bcrypt_main.c:118
CHAIN_MODE_ECB
@ CHAIN_MODE_ECB
Definition: bcrypt_main.c:120
CHAIN_MODE_CCM
@ CHAIN_MODE_CCM
Definition: bcrypt_main.c:122
CHAIN_MODE_CBC
@ CHAIN_MODE_CBC
Definition: bcrypt_main.c:119
CHAIN_MODE_GCM
@ CHAIN_MODE_GCM
Definition: bcrypt_main.c:123
CHAIN_MODE_CFB
@ CHAIN_MODE_CFB
Definition: bcrypt_main.c:121
export_ecc_key
static NTSTATUS export_ecc_key(const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len)
Definition: bcrypt_main.c:2534
BCryptEncrypt
NTSTATUS WINAPI BCryptEncrypt(BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv, ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:2307
BLOCK_LENGTH_3DES
#define BLOCK_LENGTH_3DES
Definition: bcrypt_main.c:166
g_SymCryptFipsSelftestsPerformed
UINT32 g_SymCryptFipsSelftestsPerformed
Definition: bcrypt_main.c:291
get_generic_alg_property
static NTSTATUS get_generic_alg_property(enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:715
export_dsa_key
static NTSTATUS export_dsa_key(const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len)
Definition: bcrypt_main.c:2565
decrypt_aes_ecb
static NTSTATUS decrypt_aes_ecb(const struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:1756
object_length
ULONG object_length
Definition: bcrypt_main.c:356
get_mac_from_alg
static const SYMCRYPT_MAC * get_mac_from_alg(enum alg_id alg)
Definition: bcrypt_main.c:4139
resolve_blob_type
static const WCHAR * resolve_blob_type(const WCHAR *type, const UCHAR *input, ULONG input_len)
Definition: bcrypt_main.c:3451
SymCryptDsaPct
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaPct(const SYMCRYPT_DLKEY *key)
Definition: bcrypt_main.c:261
BCryptOpenAlgorithmProvider
NTSTATUS WINAPI BCryptOpenAlgorithmProvider(BCRYPT_ALG_HANDLE *handle, const WCHAR *id, const WCHAR *implementation, DWORD flags)
Definition: bcrypt_main.c:629
BCryptEnumAlgorithms
NTSTATUS WINAPI BCryptEnumAlgorithms(ULONG type, ULONG *ret_count, BCRYPT_ALGORITHM_IDENTIFIER **ret_list, ULONG flags)
Definition: bcrypt_main.c:424
BCryptAddContextFunction
NTSTATUS WINAPI BCryptAddContextFunction(ULONG table, const WCHAR *ctx, ULONG iface, const WCHAR *func, ULONG pos)
Definition: bcrypt_main.c:298
SymCryptCallbackAlloc
void *SYMCRYPT_CALL SymCryptCallbackAlloc(SIZE_T size)
Definition: bcrypt_main.c:241
BCryptKeyDerivation
NTSTATUS WINAPI BCryptKeyDerivation(BCRYPT_KEY_HANDLE handle, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:4404
KEY_FLAG_PRIVATE
#define KEY_FLAG_PRIVATE
Definition: bcrypt_main.c:216
is_symmetric_alg
static BOOL is_symmetric_alg(const struct algorithm *alg)
Definition: bcrypt_main.c:395
name
const WCHAR * name
Definition: bcrypt_main.c:354
prepare_hash
static void prepare_hash(struct hash *hash)
Definition: bcrypt_main.c:1358
BCryptSetProperty
NTSTATUS WINAPI BCryptSetProperty(BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1230
get_hash_object
static struct hash * get_hash_object(BCRYPT_HASH_HANDLE handle)
Definition: bcrypt_main.c:559
MAGIC_HASH
#define MAGIC_HASH
Definition: bcrypt_main.c:46
brainpoolP256r1
static const BYTE brainpoolP256r1[]
Definition: bcrypt_main.c:3004
import_key_pair
static NTSTATUS import_key_pair(const struct algorithm *alg, const WCHAR *type, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:3406
export_asymmetric_key
static NTSTATUS export_asymmetric_key(const struct key *key, const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:2695
get_ecc_import_flags
static UINT32 get_ecc_import_flags(enum alg_id alg)
Definition: bcrypt_main.c:2977
import_rsa_key
static NTSTATUS import_rsa_key(enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:2779
decrypt_aes_gcm
static NTSTATUS decrypt_aes_gcm(struct key *key, const UCHAR *input, ULONG input_len, const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:1791
BLOCK_LENGTH_RC4
#define BLOCK_LENGTH_RC4
Definition: bcrypt_main.c:164
SymCryptCallbackRandom
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptCallbackRandom(BYTE *buf, SIZE_T size)
Definition: bcrypt_main.c:251
destroy_hash
static void destroy_hash(struct hash *hash)
Definition: bcrypt_main.c:1476
generate_key_pair
static NTSTATUS generate_key_pair(const struct algorithm *alg, ULONG bitlen, ULONG flags, struct key **ret_key)
Definition: bcrypt_main.c:3522
encrypt_symmetric
static NTSTATUS encrypt_symmetric(struct key *key, const UCHAR *input, ULONG input_len, const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *iv, ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:2222
is_symmetric_key
static BOOL is_symmetric_key(const struct key *key)
Definition: bcrypt_main.c:401
generate_symmetric_key
static NTSTATUS generate_symmetric_key(const struct algorithm *alg, const UCHAR *secret, ULONG secret_len, struct key **ret_key)
Definition: bcrypt_main.c:1684
export_legacy_dsa_key
static NTSTATUS export_legacy_dsa_key(const struct key *key, UCHAR *output, ULONG output_len, ULONG flags, ULONG *ret_len)
Definition: bcrypt_main.c:2604
BCryptFinalizeKeyPair
NTSTATUS WINAPI BCryptFinalizeKeyPair(BCRYPT_KEY_HANDLE handle, ULONG flags)
Definition: bcrypt_main.c:3658
get_hash_from_desc
static const struct algorithm * get_hash_from_desc(const BCryptBufferDesc *desc)
Definition: bcrypt_main.c:4171
alloc_key
static NTSTATUS alloc_key(enum alg_id alg_id, ULONG flags, struct key **ret_key)
Definition: bcrypt_main.c:1645
BCryptDeriveKeyCapi
NTSTATUS WINAPI BCryptDeriveKeyCapi(BCRYPT_HASH_HANDLE handle, BCRYPT_ALG_HANDLE halg, UCHAR *key, ULONG keylen, ULONG flags)
Definition: bcrypt_main.c:4021
BCryptCloseAlgorithmProvider
NTSTATUS WINAPI BCryptCloseAlgorithmProvider(BCRYPT_ALG_HANDLE handle, DWORD flags)
Definition: bcrypt_main.c:684
get_ecc_magic
static DWORD get_ecc_magic(enum alg_id alg, BOOL private)
Definition: bcrypt_main.c:2515
encrypt_aes_gcm
static NTSTATUS encrypt_aes_gcm(struct key *key, const UCHAR *input, ULONG input_len, const BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *info, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:2152
export_symmetric_key
static NTSTATUS export_symmetric_key(const struct key *key, const struct key *encrypt_key, const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:2382
finalize_key_pair
static NTSTATUS finalize_key_pair(struct key *key)
Definition: bcrypt_main.c:3590
BCryptDeriveKey
NTSTATUS WINAPI BCryptDeriveKey(BCRYPT_SECRET_HANDLE handle, const WCHAR *kdf, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:4266
BCryptDestroySecret
NTSTATUS WINAPI BCryptDestroySecret(BCRYPT_SECRET_HANDLE handle)
Definition: bcrypt_main.c:4127
verify_signature_rsa
static NTSTATUS verify_signature_rsa(const struct key *key, const void *padding, const UCHAR *hash, ULONG hash_len, const UCHAR *signature, ULONG signature_len, ULONG flags)
Definition: bcrypt_main.c:3904
BCryptVerifySignature
NTSTATUS WINAPI BCryptVerifySignature(BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG flags)
Definition: bcrypt_main.c:3975
hash_length
ULONG hash_length
Definition: bcrypt_main.c:357
BCryptImportKey
NTSTATUS WINAPI BCryptImportKey(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE decrypt_key_handle, const WCHAR *type, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *input, ULONG input_len, ULONG flags)
Definition: bcrypt_main.c:2101
verify_signature_dsa
static NTSTATUS verify_signature_dsa(const struct key *key, const UCHAR *hash, ULONG hash_len, const UCHAR *signature, ULONG signature_len, ULONG flags)
Definition: bcrypt_main.c:3960
KEY_EXPORT_FLAG_RSA_FULL
#define KEY_EXPORT_FLAG_RSA_FULL
Definition: bcrypt_main.c:232
derive_key_raw
static NTSTATUS derive_key_raw(const struct secret *secret, UCHAR *output, ULONG output_len, ULONG *ret_len)
Definition: bcrypt_main.c:4249
get_ecc_blob_curve
static enum ecc_curve_id get_ecc_blob_curve(enum alg_id alg, const BCRYPT_ECCKEY_BLOB *blob, ULONG *size, ULONG *flags)
Definition: bcrypt_main.c:2908
HASH_FLAG_HMAC
#define HASH_FLAG_HMAC
Definition: bcrypt_main.c:100
import_legacy_rsa_key
static NTSTATUS import_legacy_rsa_key(enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:2843
ecc_curve_id
ecc_curve_id
Definition: bcrypt_main.c:127
ECC_CURVE_NONE
@ ECC_CURVE_NONE
Definition: bcrypt_main.c:129
ECC_CURVE_P384R1
@ ECC_CURVE_P384R1
Definition: bcrypt_main.c:134
ECC_CURVE_P521R1
@ ECC_CURVE_P521R1
Definition: bcrypt_main.c:135
ECC_CURVE_BRAINPOOLP384R1
@ ECC_CURVE_BRAINPOOLP384R1
Definition: bcrypt_main.c:132
ECC_CURVE_BRAINPOOLP256R1
@ ECC_CURVE_BRAINPOOLP256R1
Definition: bcrypt_main.c:131
ECC_CURVE_P256R1
@ ECC_CURVE_P256R1
Definition: bcrypt_main.c:133
ECC_CURVE_INVALID
@ ECC_CURVE_INVALID
Definition: bcrypt_main.c:128
ECC_CURVE_25519
@ ECC_CURVE_25519
Definition: bcrypt_main.c:130
verify_signature_ecc
static NTSTATUS verify_signature_ecc(const struct key *key, const UCHAR *hash, ULONG hash_len, const UCHAR *signature, ULONG signature_len, ULONG flags)
Definition: bcrypt_main.c:3945
import_key
static NTSTATUS import_key(const struct algorithm *alg, const struct key *decrypt_key, const WCHAR *type, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:2045
get_dword_property
static NTSTATUS get_dword_property(UCHAR *buf, ULONG size, ULONG *ret_size, DWORD value)
Definition: bcrypt_main.c:707
sign_hash_rsa
static NTSTATUS sign_hash_rsa(const struct key *key, const void *padding, const UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:3779
BCryptSignHash
NTSTATUS WINAPI BCryptSignHash(BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:3870
get_object
static struct object * get_object(BCRYPT_HANDLE handle, ULONG magic)
Definition: bcrypt_main.c:532
BCryptDestroyKey
NTSTATUS WINAPI BCryptDestroyKey(BCRYPT_KEY_HANDLE handle)
Definition: bcrypt_main.c:4008
secure_zero
static void secure_zero(void *ptr, SIZE_T size)
Definition: bcrypt_main.c:673
MAGIC_DSS2
#define MAGIC_DSS2
Definition: bcrypt_main.c:43
encrypt_aes_vector
static NTSTATUS encrypt_aes_vector(struct key *key, const UCHAR *input, ULONG input_len, UCHAR *iv, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:2174
get_chacha20_poly1305_property
static NTSTATUS get_chacha20_poly1305_property(const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:926
SymCryptRsaSelftest
void SYMCRYPT_CALL SymCryptRsaSelftest(void)
Definition: bcrypt_main.c:266
SymCryptEcDhSecretAgreementSelftest
void SYMCRYPT_CALL SymCryptEcDhSecretAgreementSelftest(void)
Definition: bcrypt_main.c:287
hkdf_finalize
static NTSTATUS hkdf_finalize(struct key *key, UCHAR *salt, ULONG salt_len)
Definition: bcrypt_main.c:1147
encrypt_aes_ecb
static NTSTATUS encrypt_aes_ecb(const struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:2124
is_alg_pseudo_handle
static BOOL is_alg_pseudo_handle(BCRYPT_ALG_HANDLE handle)
Definition: bcrypt_main.c:527
import_legacy_dsa_key
static NTSTATUS import_legacy_dsa_key(enum alg_id alg, const UCHAR *input, ULONG input_len, struct key **ret_key)
Definition: bcrypt_main.c:3285
get_key_object
static struct key * get_key_object(BCRYPT_KEY_HANDLE handle)
Definition: bcrypt_main.c:564
decrypt_rsa
static NTSTATUS decrypt_rsa(const struct key *key, const UCHAR *input, ULONG input_len, const void *padding, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:1922
BCryptFinishHash
NTSTATUS WINAPI BCryptFinishHash(BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1525
BCryptFreeBuffer
void WINAPI BCryptFreeBuffer(void *buffer)
Definition: bcrypt_main.c:332
SymCryptEcurveParamsBrainpoolP384r1
const SYMCRYPT_ECURVE_PARAMS * SymCryptEcurveParamsBrainpoolP384r1
Definition: bcrypt_main.c:3116
match_operation_type
static BOOL match_operation_type(ULONG type, ULONG class)
Definition: bcrypt_main.c:407
BCryptHash
NTSTATUS WINAPI BCryptHash(BCRYPT_ALG_HANDLE handle, UCHAR *secret, ULONG secret_len, UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len)
Definition: bcrypt_main.c:1555
get_aes_property
static NTSTATUS get_aes_property(enum chain_mode mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size)
Definition: bcrypt_main.c:784
HASH_FLAG_REUSABLE
#define HASH_FLAG_REUSABLE
Definition: bcrypt_main.c:101
alloc_rsa_key
static NTSTATUS alloc_rsa_key(struct key *key, ULONG bitlen)
Definition: bcrypt_main.c:2765
BCryptGetFipsAlgorithmMode
NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
Definition: bcrypt_main.c:696
alg_id
alg_id
Definition: bcrypt_main.c:55
ALG_ID_RSA
@ ALG_ID_RSA
Definition: bcrypt_main.c:73
ALG_ID_AES_GMAC
@ ALG_ID_AES_GMAC
Definition: bcrypt_main.c:60
ALG_ID_DSA
@ ALG_ID_DSA
Definition: bcrypt_main.c:88
ALG_ID_RSA_SIGN
@ ALG_ID_RSA_SIGN
Definition: bcrypt_main.c:83
ALG_ID_3DES
@ ALG_ID_3DES
Definition: bcrypt_main.c:57
ALG_ID_ECDSA_P256
@ ALG_ID_ECDSA_P256
Definition: bcrypt_main.c:85
ALG_ID_SHA512
@ ALG_ID_SHA512
Definition: bcrypt_main.c:66
ALG_ID_PBKDF2
@ ALG_ID_PBKDF2
Definition: bcrypt_main.c:94
ALG_ID_TLS1_2_KDF
@ ALG_ID_TLS1_2_KDF
Definition: bcrypt_main.c:96
ALG_ID_ECDH_P256
@ ALG_ID_ECDH_P256
Definition: bcrypt_main.c:78
ALG_ID_TLS1_1_KDF
@ ALG_ID_TLS1_1_KDF
Definition: bcrypt_main.c:95
ALG_ID_ECDSA
@ ALG_ID_ECDSA
Definition: bcrypt_main.c:84
ALG_ID_HKDF
@ ALG_ID_HKDF
Definition: bcrypt_main.c:97
ALG_ID_SHA384
@ ALG_ID_SHA384
Definition: bcrypt_main.c:65
ALG_ID_SHA1
@ ALG_ID_SHA1
Definition: bcrypt_main.c:67
ALG_ID_DH
@ ALG_ID_DH
Definition: bcrypt_main.c:76
ALG_ID_RC4
@ ALG_ID_RC4
Definition: bcrypt_main.c:61
ALG_ID_MD2
@ ALG_ID_MD2
Definition: bcrypt_main.c:70
ALG_ID_ECDSA_P384
@ ALG_ID_ECDSA_P384
Definition: bcrypt_main.c:86
ALG_ID_SHA256
@ ALG_ID_SHA256
Definition: bcrypt_main.c:64
ALG_ID_ECDH_P521
@ ALG_ID_ECDH_P521
Definition: bcrypt_main.c:80
ALG_ID_MD4
@ ALG_ID_MD4
Definition: bcrypt_main.c:69
ALG_ID_CHACHA20_POLY1305
@ ALG_ID_CHACHA20_POLY1305
Definition: bcrypt_main.c:58
ALG_ID_ECDH_P384
@ ALG_ID_ECDH_P384
Definition: bcrypt_main.c:79
ALG_ID_AES
@ ALG_ID_AES
Definition: bcrypt_main.c:59
ALG_ID_MD5
@ ALG_ID_MD5
Definition: bcrypt_main.c:68
ALG_ID_ECDH
@ ALG_ID_ECDH
Definition: bcrypt_main.c:77
ALG_ID_ECDSA_P521
@ ALG_ID_ECDSA_P521
Definition: bcrypt_main.c:87
ALG_ID_RNG
@ ALG_ID_RNG
Definition: bcrypt_main.c:91
BCryptEnumContextFunctions
NTSTATUS WINAPI BCryptEnumContextFunctions(ULONG table, const WCHAR *ctx, ULONG iface, ULONG *buflen, CRYPT_CONTEXT_FUNCTIONS **buffer)
Definition: bcrypt_main.c:325
get_hash_from_str
static const SYMCRYPT_HASH * get_hash_from_str(const WCHAR *str)
Definition: bcrypt_main.c:1909
obj
struct object obj[50]
Definition: butterflies.c:34
list
Definition: list.h:39
STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
STATUS_NO_MEMORY
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
free
#define free
Definition: debug_ros.c:5
malloc
#define malloc
Definition: debug_ros.c:4
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
idx
unsigned int idx
Definition: utils.c:40
reason
static WCHAR reason[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1971
DLL_PROCESS_ATTACH
#define DLL_PROCESS_ATTACH
Definition: compat.h:131
DLL_PROCESS_DETACH
#define DLL_PROCESS_DETACH
Definition: compat.h:130
wine_dbgstr_longlong
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
lstrlenW
#define lstrlenW
Definition: compat.h:750
pubkey
static const WCHAR pubkey[]
Definition: asmname.c:68
DisableThreadLibraryCalls
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
_aligned_malloc
void *CDECL _aligned_malloc(size_t size, size_t alignment)
Definition: heap.c:603
_aligned_free
void CDECL _aligned_free(void *memblock)
Definition: heap.c:546
wcslen
_ACRTIMP size_t __cdecl wcslen(const wchar_t *)
Definition: wcs.c:2988
wcscmp
_ACRTIMP int __cdecl wcscmp(const wchar_t *, const wchar_t *)
Definition: wcs.c:1977
ret
return ret
Definition: mutex.c:147
reserved
r reserved
Definition: btrfs.c:3006
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
s
GLdouble s
Definition: gl.h:2039
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
t
GLdouble GLdouble t
Definition: gl.h:2047
func
GLenum func
Definition: glext.h:6028
enabled
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
n
GLdouble n
Definition: glext.h:7729
buffer
GLuint buffer
Definition: glext.h:5915
res
GLuint res
Definition: glext.h:9613
src
GLenum src
Definition: glext.h:6340
size
GLsizeiptr size
Definition: glext.h:5919
offset
GLintptr offset
Definition: glext.h:5920
flags
GLbitfield flags
Definition: glext.h:7161
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
mode
GLenum mode
Definition: glext.h:6217
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
in
GLuint in
Definition: glext.h:9616
dst
GLenum GLenum dst
Definition: glext.h:6340
len
GLenum GLsizei len
Definition: glext.h:6722
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
params
GLenum const GLfloat * params
Definition: glext.h:5645
input
GLenum GLenum GLenum input
Definition: glext.h:9031
id
GLuint id
Definition: glext.h:5910
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
reg
static int reg
Definition: i386-dis.c:1290
hdr
char hdr[14]
Definition: iptest.cpp:33
block_size
static DWORD block_size(DWORD block)
Definition: jsutils.c:61
a
#define a
Definition: ke_i.h:78
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
if
if(dx< 0)
Definition: linetemp.h:194
error
#define error(str)
Definition: mkdosfs.c:1605
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ptr
static PVOID ptr
Definition: dispmode.c:27
hinst
static HINSTANCE hinst
Definition: edit.c:551
label
static const WCHAR label[]
Definition: itemdlg.c:1608
cipher
static DATA_BLOB cipher
Definition: protectdata.c:34
desc
D3D11_SHADER_VARIABLE_DESC desc
Definition: reflection.c:1683
ret_len
static JOBOBJECTINFOCLASS LPVOID DWORD LPDWORD ret_len
Definition: process.c:81
hash_data
static const struct @1962 hash_data[]
padding
static const DWORD padding[]
Definition: mciwnd.c:88
ret_size
static void ULONG ULONG * ret_size
Definition: time.c:40
set_flags
DWORD set_flags
Definition: misc.c:1973
exp
DWORD exp
Definition: msg.c:18625
min
#define min(a, b)
Definition: monoChain.cc:55
TYPE_ALIGNMENT
#define TYPE_ALIGNMENT(t)
Definition: ntbasedef.h:117
STATUS_INTERNAL_ERROR
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:559
STATUS_AUTH_TAG_MISMATCH
#define STATUS_AUTH_TAG_MISMATCH
Definition: ntstatus.h:1399
STATUS_INVALID_BUFFER_SIZE
#define STATUS_INVALID_BUFFER_SIZE
Definition: ntstatus.h:772
STATUS_INVALID_SIGNATURE
#define STATUS_INVALID_SIGNATURE
Definition: ntstatus.h:1397
WCHAR
short WCHAR
Definition: pedump.c:58
RtlGenRandom
#define RtlGenRandom
Definition: ntsecapi.h:691
calloc
#define calloc
Definition: rosglue.h:14
list
#define list
Definition: rosglue.h:35
str
const WCHAR * str
Definition: rpc_transport.c:2696
memset
#define memset(x, y, z)
Definition: compat.h:39
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
_BCRYPT_ALGORITHM_IDENTIFIER
Definition: bcrypt.h:200
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO
Definition: bcrypt.h:214
_BCRYPT_DH_KEY_BLOB
Definition: bcrypt.h:322
_BCRYPT_DH_PARAMETER_HEADER
Definition: bcrypt.h:330
_BCRYPT_DSA_KEY_BLOB
Definition: bcrypt.h:283
_BCRYPT_ECCKEY_BLOB
Definition: bcrypt.h:236
_BCRYPT_KEY_BLOB
Definition: bcrypt.h:231
_BCRYPT_KEY_DATA_BLOB_HEADER
Definition: bcrypt.h:365
_BCRYPT_OAEP_PADDING_INFO
Definition: bcrypt.h:267
_BCRYPT_OAEP_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:268
_BCRYPT_OAEP_PADDING_INFO::cbLabel
ULONG cbLabel
Definition: bcrypt.h:270
_BCRYPT_OAEP_PADDING_INFO::pbLabel
PUCHAR pbLabel
Definition: bcrypt.h:269
_BCRYPT_PKCS1_PADDING_INFO
Definition: bcrypt.h:256
_BCRYPT_PKCS1_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:257
_BCRYPT_PSS_PADDING_INFO
Definition: bcrypt.h:261
_BCRYPT_PSS_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:262
_BCRYPT_PSS_PADDING_INFO::cbSalt
ULONG cbSalt
Definition: bcrypt.h:263
_BCRYPT_RSAKEY_BLOB
Definition: bcrypt.h:246
_BCryptBufferDesc
Definition: bcrypt.h:400
_CRYPT_CONTEXT_FUNCTIONS
Definition: bcrypt.h:493
_CRYPT_PROVIDER_REG
Definition: bcrypt.h:357
_PUBKEY
Definition: wincrypt.h:157
_PUBKEY::magic
DWORD magic
Definition: wincrypt.h:158
_PUBKEY::bitlen
DWORD bitlen
Definition: wincrypt.h:159
_PUBLICKEYSTRUC
Definition: wincrypt.h:144
_RSAPUBKEY
Definition: wincrypt.h:151
_RSAPUBKEY::pubexp
DWORD pubexp
Definition: wincrypt.h:154
_RSAPUBKEY::bitlen
DWORD bitlen
Definition: wincrypt.h:153
_RTL_CRITICAL_SECTION
Definition: rtltypes.h:1477
_SYMCRYPT_ECURVE_PARAMS
Definition: symcrypt.h:7167
_SYMCRYPT_HKDF_EXPANDED_KEY
Definition: symcrypt_internal.h:2262
_SYMCRYPT_MAC
Definition: symcrypt_internal.h:1767
_SYMCRYPT_OID
Definition: symcrypt_internal.h:1077
_SYMCRYPT_RSA_PARAMS
Definition: symcrypt.h:7032
__BCRYPT_KEY_LENGTHS_STRUCT
Definition: bcrypt.h:207
__BCRYPT_KEY_LENGTHS_STRUCT::dwIncrement
ULONG dwIncrement
Definition: bcrypt.h:210
__BCRYPT_KEY_LENGTHS_STRUCT::dwMaxLength
ULONG dwMaxLength
Definition: bcrypt.h:209
__BCRYPT_KEY_LENGTHS_STRUCT::dwMinLength
ULONG dwMinLength
Definition: bcrypt.h:208
aes_key
Definition: bcrypt_main.c:148
aes_key::handle
SYMCRYPT_AES_EXPANDED_KEY handle
Definition: bcrypt_main.c:149
algorithm::flags
ULONG flags
Definition: bcrypt_main.c:143
algorithm::curve_id
enum ecc_curve_id curve_id
Definition: bcrypt_main.c:144
algorithm::hdr
struct object hdr
Definition: bcrypt_main.c:140
algorithm::chain_mode
enum chain_mode chain_mode
Definition: bcrypt_main.c:142
algorithm::id
enum alg_id id
Definition: bcrypt_main.c:141
asymmetric_key
Definition: bcrypt_main.c:206
asymmetric_key::bitlen
ULONG bitlen
Definition: bcrypt_main.c:207
asymmetric_key::rsa
struct rsa_key rsa
Definition: bcrypt_main.c:210
asymmetric_key::ecc
struct ecc_key ecc
Definition: bcrypt_main.c:211
asymmetric_key::dsa
struct dsa_key dsa
Definition: bcrypt_main.c:212
blob
Definition: image.c:229
dsa_key
Definition: bcrypt_main.c:198
dsa_key::handle
SYMCRYPT_DLKEY * handle
Definition: bcrypt_main.c:199
dsa_key::count
UINT32 count
Definition: bcrypt_main.c:202
dsa_key::group
SYMCRYPT_DLGROUP * group
Definition: bcrypt_main.c:200
dsa_key::seed
UCHAR seed[20]
Definition: bcrypt_main.c:201
ecc_key
Definition: bcrypt_main.c:191
ecc_key::handle
SYMCRYPT_ECKEY * handle
Definition: bcrypt_main.c:192
ecc_key::curve
SYMCRYPT_ECURVE * curve
Definition: bcrypt_main.c:193
ecc_key::curve_id
enum ecc_curve_id curve_id
Definition: bcrypt_main.c:194
gcm_key
Definition: bcrypt_main.c:153
gcm_key::handle
SYMCRYPT_GCM_EXPANDED_KEY handle
Definition: bcrypt_main.c:154
gcm_key::state
SYMCRYPT_GCM_STATE state
Definition: bcrypt_main.c:155
hash::hdr
struct object hdr
Definition: bcrypt_main.c:104
hash::state
SYMCRYPT_HASH_STATE state
Definition: bcrypt_main.c:112
hash::len
ULONG len
Definition: bcrypt_main.c:106
hash::secret_len
ULONG secret_len
Definition: bcrypt_main.c:109
hash::hmac
SYMCRYPT_HMAC_EXPANDED_KEY hmac
Definition: bcrypt_main.c:113
hash::alg_id
enum alg_id alg_id
Definition: bcrypt_main.c:105
hash::hmac_state
SYMCRYPT_HMAC_STATE hmac_state
Definition: bcrypt_main.c:114
hash::flags
ULONG flags
Definition: bcrypt_main.c:107
hash::desc
const SYMCRYPT_HASH * desc
Definition: bcrypt_main.c:111
hash::secret
UCHAR * secret
Definition: bcrypt_main.c:108
hkdf_key
Definition: bcrypt_main.c:159
hkdf_key::handle
SYMCRYPT_HKDF_EXPANDED_KEY handle
Definition: bcrypt_main.c:160
hkdf_key::hmac
const SYMCRYPT_MAC * hmac
Definition: bcrypt_main.c:161
key
Definition: copy.c:22
key::s
struct symmetric_key s
Definition: bcrypt_main.c:226
key::flags
ULONG flags
Definition: bcrypt_main.c:223
key::a
struct asymmetric_key a
Definition: bcrypt_main.c:227
key::hdr
struct object hdr
Definition: bcrypt_main.c:221
key::alg_id
enum alg_id alg_id
Definition: bcrypt_main.c:222
name
Definition: name.c:39
object::magic
ULONG magic
Definition: bcrypt_main.c:51
rsa_key
Definition: bcrypt_main.c:186
rsa_key::handle
SYMCRYPT_RSAKEY * handle
Definition: bcrypt_main.c:187
secret::hdr
struct object hdr
Definition: bcrypt_main.c:236
secret::derived_key
UCHAR * derived_key
Definition: bcrypt_main.c:237
secret::derived_key_len
ULONG derived_key_len
Definition: bcrypt_main.c:238
status
Definition: ps.c:97
symmetric_key
Definition: bcrypt_main.c:170
symmetric_key::mode
enum chain_mode mode
Definition: bcrypt_main.c:171
symmetric_key::gcm
struct gcm_key gcm
Definition: bcrypt_main.c:180
symmetric_key::secret
UCHAR * secret
Definition: bcrypt_main.c:173
symmetric_key::hkdf
struct hkdf_key hkdf
Definition: bcrypt_main.c:181
symmetric_key::block_size
ULONG block_size
Definition: bcrypt_main.c:172
symmetric_key::cs
CRITICAL_SECTION cs
Definition: bcrypt_main.c:176
symmetric_key::aes
struct aes_key aes
Definition: bcrypt_main.c:179
symmetric_key::secret_len
ULONG secret_len
Definition: bcrypt_main.c:174
SymCryptRsakeyAllocate
PSYMCRYPT_RSAKEY SYMCRYPT_CALL SymCryptRsakeyAllocate(_In_ PCSYMCRYPT_RSA_PARAMS pParams, _In_ UINT32 flags)
Definition: rsakey.c:13
SymCryptEcurveFree
VOID SYMCRYPT_CALL SymCryptEcurveFree(_Out_ PSYMCRYPT_ECURVE pCurve)
Definition: ecurve.c:657
SymCryptGcmInit
VOID SYMCRYPT_CALL SymCryptGcmInit(_Out_ PSYMCRYPT_GCM_STATE pState, _In_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_reads_(cbNonce) PCBYTE pbNonce, SIZE_T cbNonce)
Definition: gcm.c:391
SymCryptHkdfExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfExpandKey(_Out_ PSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbIkm) PCBYTE pbIkm, SIZE_T cbIkm, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt)
Definition: hkdf.c:18
SymCryptRsakeySetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeySetValue(_In_reads_bytes_(cbModulus) PCBYTE pbModulus, SIZE_T cbModulus, _In_reads_(nPubExp) PCUINT64 pu64PubExp, UINT32 nPubExp, _In_reads_opt_(nPrimes) PCBYTE *ppPrimes, _In_reads_opt_(nPrimes) SIZE_T *pcbPrimes, UINT32 nPrimes, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Inout_ PSYMCRYPT_RSAKEY pkRsakey)
Definition: rsakey.c:1399
SymCryptHmacResult
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacResult(_Inout_ PSYMCRYPT_HMAC_STATE pState, _Out_writes_(pState->pKey->pHash->resultSize) PBYTE pbResult)
Definition: hmac.c:141
SymCryptEckeyFree
VOID SYMCRYPT_CALL SymCryptEckeyFree(_Out_ PSYMCRYPT_ECKEY pkObj)
Definition: eckey.c:35
SymCryptGcmEncryptPart
VOID SYMCRYPT_CALL SymCryptGcmEncryptPart(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: gcm.c:450
SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1
#define SYMCRYPT_FLAG_RSA_PKCS1_NO_ASN1
Definition: symcrypt.h:8671
SymCryptRsakeySizeofPrime
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofPrime(_In_ PCSYMCRYPT_RSAKEY pkRsakey, UINT32 index)
Definition: rsakey.c:289
SymCryptDlkeySetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeySetValue(_In_reads_bytes_(cbPrivateKey) PCBYTE pbPrivateKey, SIZE_T cbPrivateKey, _In_reads_bytes_(cbPublicKey) PCBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Inout_ PSYMCRYPT_DLKEY pkDlkey)
Definition: dlkey.c:541
SymCryptEcDhSecretAgreement
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDhSecretAgreement(_In_ PCSYMCRYPT_ECKEY pkPrivate, _In_ PCSYMCRYPT_ECKEY pkPublic, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
Definition: ec_dh.c:12
SymCryptEcbEncrypt
VOID SYMCRYPT_CALL SymCryptEcbEncrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: blockciphermodes.c:11
SymCryptRsakeyGenerate
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGenerate(_Inout_ PSYMCRYPT_RSAKEY pkRsakey, _In_reads_opt_(nPubExp) PCUINT64 pu64PubExp, UINT32 nPubExp, _In_ UINT32 flags)
Definition: rsakey.c:514
SymCryptEcurveParamsNistP521
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP521
Definition: ec_internal_curve_params.c:587
SymCryptCfbDecrypt
VOID SYMCRYPT_CALL SymCryptCfbDecrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, SIZE_T cbShift, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: blockciphermodes.c:423
SymCryptRsakeyGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGetValue(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _Out_writes_bytes_(cbModulus) PBYTE pbModulus, SIZE_T cbModulus, _Out_writes_opt_(nPubExp) PUINT64 pu64PubExp, UINT32 nPubExp, _Out_writes_opt_(nPrimes) PBYTE *ppPrimes, _In_reads_opt_(nPrimes) SIZE_T *pcbPrimes, UINT32 nPrimes, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags)
Definition: rsakey.c:1445
SYMCRYPT_FLAG_DLKEY_DSA
#define SYMCRYPT_FLAG_DLKEY_DSA
Definition: symcrypt.h:7592
SymCryptHashAppend
VOID SYMCRYPT_CALL SymCryptHashAppend(_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: hash.c:182
SYMCRYPT_DLGROUP_FIPS_186_2
@ SYMCRYPT_DLGROUP_FIPS_186_2
Definition: symcrypt.h:249
SYMCRYPT_DLGROUP_FIPS_NONE
@ SYMCRYPT_DLGROUP_FIPS_NONE
Definition: symcrypt.h:248
SymCryptEckeySizeofPrivateKey
UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPrivateKey(_In_ PCSYMCRYPT_ECKEY pkEckey)
Definition: eckey.c:164
SymCryptAesBlockCipher
const PCSYMCRYPT_BLOCKCIPHER SymCryptAesBlockCipher
Definition: aes-default-bc.c:92
SymCryptGcmKeyCopy
VOID SYMCRYPT_CALL SymCryptGcmKeyCopy(_In_ PCSYMCRYPT_GCM_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_GCM_EXPANDED_KEY pDst)
Definition: gcm.c:322
SymCryptCbcEncrypt
VOID SYMCRYPT_CALL SymCryptCbcEncrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: blockciphermodes.c:78
SymCryptRsakeyFree
VOID SYMCRYPT_CALL SymCryptRsakeyFree(_Out_ PSYMCRYPT_RSAKEY pkObj)
Definition: rsakey.c:42
SymCryptHmacSha1Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha1Algorithm
Definition: hmacsha1.c:36
SymCryptEcurveParamsNistP384
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP384
Definition: ec_internal_curve_params.c:586
SymCryptHmacKeyCopy
VOID SYMCRYPT_CALL SymCryptHmacKeyCopy(_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_HMAC_EXPANDED_KEY pDst)
Definition: hmac.c:36
SymCryptHmacSha512Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha512Algorithm
Definition: hmacsha512.c:29
SymCryptHmacSha256Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha256Algorithm
Definition: hmacsha256.c:29
SymCryptGcmEncryptFinal
VOID SYMCRYPT_CALL SymCryptGcmEncryptFinal(_Inout_ PSYMCRYPT_GCM_STATE pState, _Out_writes_(cbTag) PBYTE pbTag, SIZE_T cbTag)
Definition: gcm.c:564
SymCryptSha256Algorithm
const PCSYMCRYPT_HASH SymCryptSha256Algorithm
Definition: sha256.c:46
SymCryptHashInit
VOID SYMCRYPT_CALL SymCryptHashInit(_In_ PCSYMCRYPT_HASH pHash, _Out_writes_bytes_(pHash->stateSize) PVOID pState)
Definition: hash.c:173
SymCryptInit
VOID SYMCRYPT_CALL SymCryptInit(void)
SymCryptRsaPkcs1Verify
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Verify(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT nfSignature, _In_reads_opt_(nOIDCount) PCSYMCRYPT_OID pHashOID, _In_ SIZE_T nOIDCount, UINT32 flags)
Definition: rsa_enc.c:1199
SymCryptRsaPssSign
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssSign(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_ PCSYMCRYPT_HASH hashAlgorithm, SIZE_T cbSalt, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfSignature, _Out_writes_opt_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature, _Out_ SIZE_T *pcbSignature)
Definition: rsa_enc.c:1297
SYMCRYPT_FLAG_ECKEY_ECDSA
#define SYMCRYPT_FLAG_ECKEY_ECDSA
Definition: symcrypt.h:7595
SymCryptRsaRawEncrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaRawEncrypt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
Definition: rsa_enc.c:510
SymCryptAesExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKey(_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: aes-key.c:219
SymCryptGcmDecryptPart
VOID SYMCRYPT_CALL SymCryptGcmDecryptPart(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: gcm.c:512
SymCryptGcmStateCopy
VOID SYMCRYPT_CALL SymCryptGcmStateCopy(_In_ PCSYMCRYPT_GCM_STATE pSrc, _In_opt_ PCSYMCRYPT_GCM_EXPANDED_KEY pExpandedKeyCopy, _Out_ PSYMCRYPT_GCM_STATE pDst)
Definition: gcm.c:415
SymCryptRsaPssVerify
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPssVerify(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT nfSignature, _In_ PCSYMCRYPT_HASH hashAlgorithm, SIZE_T cbSalt, UINT32 flags)
Definition: rsa_enc.c:1434
SymCryptHmacAppend
VOID SYMCRYPT_CALL SymCryptHmacAppend(_Inout_ PSYMCRYPT_HMAC_STATE pState, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData)
Definition: hmac.c:130
SymCryptRsakeySizeofModulus
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofModulus(_In_ PCSYMCRYPT_RSAKEY pkRsakey)
Definition: rsakey.c:264
SymCryptHmacStateCopy
VOID SYMCRYPT_CALL SymCryptHmacStateCopy(_In_ PCSYMCRYPT_HMAC_STATE pSrc, _In_opt_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _Out_ PSYMCRYPT_HMAC_STATE pDst)
Definition: hmac.c:10
SymCryptDlgroupGenerate
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGenerate(_In_ PCSYMCRYPT_HASH hashAlgorithm, _In_ SYMCRYPT_DLGROUP_FIPS fipsStandard, _Inout_ PSYMCRYPT_DLGROUP pDlgroup)
Definition: dlgroup.c:850
SymCryptPbkdf2
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptPbkdf2(PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, _In_reads_opt_(cbSalt) PCBYTE pbSalt, SIZE_T cbSalt, UINT64 iterationCnt, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: pbkdf2.c:89
SymCryptHashStateCopy
VOID SYMCRYPT_CALL SymCryptHashStateCopy(_In_ PCSYMCRYPT_HASH pHash, _In_reads_(pHash->stateSize) PCVOID pSrc, _Out_writes_(pHash->stateSize) PVOID pDst)
Definition: hash.c:210
SymCryptEckeySizeofPublicKey
UINT32 SYMCRYPT_CALL SymCryptEckeySizeofPublicKey(_In_ PCSYMCRYPT_ECKEY pkEckey, _In_ SYMCRYPT_ECPOINT_FORMAT ecPointFormat)
Definition: eckey.c:147
SymCryptRsaPkcs1Sign
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Sign(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_ PCSYMCRYPT_OID pHashOIDs, _In_ SIZE_T nOIDCount, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfSignature, _Out_writes_opt_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature, _Out_ SIZE_T *pcbSignature)
Definition: rsa_enc.c:1071
SymCryptRsaPkcs1Decrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Decrypt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT nfSrc, UINT32 flags, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
Definition: rsa_enc.c:725
SymCryptSha1Algorithm
const PCSYMCRYPT_HASH SymCryptSha1Algorithm
Definition: sha1.c:29
SymCryptMd2Algorithm
const PCSYMCRYPT_HASH SymCryptMd2Algorithm
Definition: md2.c:40
SymCryptMd5Algorithm
const PCSYMCRYPT_HASH SymCryptMd5Algorithm
Definition: md5.c:43
SYMCRYPT_FLAG_RSAKEY_SIGN
#define SYMCRYPT_FLAG_RSAKEY_SIGN
Definition: symcrypt.h:7598
SymCryptEckeySetRandom
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetRandom(_In_ UINT32 flags, _Inout_ PSYMCRYPT_ECKEY pEckey)
Definition: eckey.c:733
SYMCRYPT_FLAG_RSAKEY_ENCRYPT
#define SYMCRYPT_FLAG_RSAKEY_ENCRYPT
Definition: symcrypt.h:7599
SymCryptHmacExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHmacExpandKey(_In_ PCSYMCRYPT_HASH pHash, _Out_ PSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: hmac.c:53
SymCryptEcbDecrypt
VOID SYMCRYPT_CALL SymCryptEcbDecrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: blockciphermodes.c:42
SymCryptTlsPrf1_2
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_2(_In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: tlsprf.c:530
SymCryptRsaRawDecrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaRawDecrypt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags, _Out_writes_(cbDst) PBYTE pbDst, SIZE_T cbDst)
Definition: rsa_enc.c:560
SymCryptDlgroupGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupGetValue(_In_ PCSYMCRYPT_DLGROUP pDlgroup, _Out_writes_bytes_(cbPrimeP) PBYTE pbPrimeP, SIZE_T cbPrimeP, _Out_writes_bytes_(cbPrimeQ) PBYTE pbPrimeQ, SIZE_T cbPrimeQ, _Out_writes_bytes_(cbGenG) PBYTE pbGenG, SIZE_T cbGenG, SYMCRYPT_NUMBER_FORMAT numFormat, _Out_ PCSYMCRYPT_HASH *ppHashAlgorithm, _Out_writes_bytes_(cbSeed) PBYTE pbSeed, SIZE_T cbSeed, _Out_ PUINT32 pGenCounter)
Definition: dlgroup.c:1901
SymCryptHkdfDerive
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfDerive(_In_ PCSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_reads_opt_(cbInfo) PCBYTE pbInfo, SIZE_T cbInfo, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: hkdf.c:106
SymCryptDlkeyAllocate
PSYMCRYPT_DLKEY SYMCRYPT_CALL SymCryptDlkeyAllocate(_In_ PCSYMCRYPT_DLGROUP pDlgroup)
Definition: dlkey.c:12
SymCryptHmacInit
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmacInit(_Out_ PSYMCRYPT_HMAC_STATE pState, _In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey)
Definition: hmac.c:115
SymCryptDsaSign
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaSign(_In_ PCSYMCRYPT_DLKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
Definition: dsa.c:395
SYMCRYPT_ECPOINT_FORMAT_XY
@ SYMCRYPT_ECPOINT_FORMAT_XY
Definition: symcrypt.h:7195
SymCryptDlgroupFree
VOID SYMCRYPT_CALL SymCryptDlgroupFree(_Out_ PSYMCRYPT_DLGROUP pgObj)
Definition: dlgroup.c:73
SymCryptGcmExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmExpandKey(_Out_ PSYMCRYPT_GCM_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
Definition: gcm.c:268
SymCryptRsakeySizeofPublicExponent
UINT32 SYMCRYPT_CALL SymCryptRsakeySizeofPublicExponent(_In_ PCSYMCRYPT_RSAKEY pRsakey, UINT32 index)
Definition: rsakey.c:278
SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID
#define SYMCRYPT_FLAG_RSA_PKCS1_OPTIONAL_HASH_OID
Definition: symcrypt.h:8672
SYMCRYPT_FLAG_DLKEY_DH
#define SYMCRYPT_FLAG_DLKEY_DH
Definition: symcrypt.h:7593
SymCryptHash
VOID SYMCRYPT_CALL SymCryptHash(_In_ PCSYMCRYPT_HASH pHash, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
Definition: hash.c:155
SymCryptTlsPrf1_1
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptTlsPrf1_1(_In_reads_(cbKey) PCBYTE pbKey, _In_ SIZE_T cbKey, _In_reads_opt_(cbLabel) PCBYTE pbLabel, _In_ SIZE_T cbLabel, _In_reads_(cbSeed) PCBYTE pbSeed, _In_ SIZE_T cbSeed, _Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult)
Definition: tlsprf.c:484
SymCryptEcurveParamsNistP256
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsNistP256
Definition: ec_internal_curve_params.c:585
SymCryptDlkeyGenerate
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyGenerate(_In_ UINT32 flags, _Inout_ PSYMCRYPT_DLKEY pkDlkey)
Definition: dlkey.c:283
SymCryptCfbEncrypt
VOID SYMCRYPT_CALL SymCryptCfbEncrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, SIZE_T cbShift, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: blockciphermodes.c:360
SymCryptHmacSha384Algorithm
const PCSYMCRYPT_MAC SymCryptHmacSha384Algorithm
Definition: hmacsha384.c:31
SymCryptDlkeyFree
VOID SYMCRYPT_CALL SymCryptDlkeyFree(_Out_ PSYMCRYPT_DLKEY pkObj)
Definition: dlkey.c:35
SYMCRYPT_FLAG_KEY_NO_FIPS
#define SYMCRYPT_FLAG_KEY_NO_FIPS
Definition: symcrypt.h:7579
SymCryptEckeySetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeySetValue(_In_reads_bytes_(cbPrivateKey) PCBYTE pbPrivateKey, SIZE_T cbPrivateKey, _In_reads_bytes_(cbPublicKey) PCBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, SYMCRYPT_ECPOINT_FORMAT ecPointFormat, UINT32 flags, _Inout_ PSYMCRYPT_ECKEY pEckey)
Definition: eckey.c:261
SymCryptGcmAuthPart
VOID SYMCRYPT_CALL SymCryptGcmAuthPart(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_opt_(cbData) PCBYTE pbAuthData, SIZE_T cbData)
Definition: gcm.c:435
SymCryptDlgroupSetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlgroupSetValue(_In_reads_bytes_(cbPrimeP) PCBYTE pbPrimeP, SIZE_T cbPrimeP, _In_reads_bytes_(cbPrimeQ) PCBYTE pbPrimeQ, SIZE_T cbPrimeQ, _In_reads_bytes_(cbGenG) PCBYTE pbGenG, SIZE_T cbGenG, SYMCRYPT_NUMBER_FORMAT numFormat, _In_opt_ PCSYMCRYPT_HASH pHashAlgorithm, _In_reads_bytes_(cbSeed) PCBYTE pbSeed, SIZE_T cbSeed, UINT32 genCounter, SYMCRYPT_DLGROUP_FIPS fipsStandard, _Inout_ PSYMCRYPT_DLGROUP pDlgroup)
Definition: dlgroup.c:1410
SymCryptEcurveAllocate
PSYMCRYPT_ECURVE SYMCRYPT_CALL SymCryptEcurveAllocate(_In_ PCSYMCRYPT_ECURVE_PARAMS pParams, _In_ UINT32 flags)
Definition: ecurve.c:606
SymCryptEckeyAllocate
PSYMCRYPT_ECKEY SYMCRYPT_CALL SymCryptEckeyAllocate(_In_ PCSYMCRYPT_ECURVE pCurve)
Definition: eckey.c:12
SymCryptEcDsaVerify
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaVerify(_In_ PCSYMCRYPT_ECKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags)
Definition: ec_dsa.c:440
SymCryptEcurveParamsCurve25519
const PCSYMCRYPT_ECURVE_PARAMS SymCryptEcurveParamsCurve25519
Definition: ec_internal_curve_params.c:593
SymCryptEckeyGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEckeyGetValue(_In_ PCSYMCRYPT_ECKEY pEckey, _Out_writes_bytes_(cbPrivateKey) PBYTE pbPrivateKey, SIZE_T cbPrivateKey, _Out_writes_bytes_(cbPublicKey) PBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, SYMCRYPT_ECPOINT_FORMAT ecPointFormat, UINT32 flags)
Definition: eckey.c:581
SymCryptEcDsaSign
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptEcDsaSign(_In_ PCSYMCRYPT_ECKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_bytes_(cbSignature) PBYTE pbSignature, SIZE_T cbSignature)
Definition: ec_dsa.c:408
SymCryptDlkeyGetValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDlkeyGetValue(_In_ PCSYMCRYPT_DLKEY pkDlkey, _Out_writes_bytes_(cbPrivateKey) PBYTE pbPrivateKey, SIZE_T cbPrivateKey, _Out_writes_bytes_(cbPublicKey) PBYTE pbPublicKey, SIZE_T cbPublicKey, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags)
Definition: dlkey.c:825
SymCryptSha512Algorithm
const PCSYMCRYPT_HASH SymCryptSha512Algorithm
Definition: sha512.c:170
SymCryptGcmDecryptFinal
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptGcmDecryptFinal(_Inout_ PSYMCRYPT_GCM_STATE pState, _In_reads_(cbTag) PCBYTE pbTag, SIZE_T cbTag)
Definition: gcm.c:585
SymCryptSha384Algorithm
const PCSYMCRYPT_HASH SymCryptSha384Algorithm
Definition: sha512.c:169
SymCryptRsakeyGetCrtValue
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsakeyGetCrtValue(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _Out_writes_opt_(nCrtExponents) PBYTE *ppCrtExponents, _In_reads_(nCrtExponents) SIZE_T *pcbCrtExponents, UINT32 nCrtExponents, _Out_writes_bytes_opt_(cbCrtCoefficient) PBYTE pbCrtCoefficient, SIZE_T cbCrtCoefficient, _Out_writes_bytes_opt_(cbPrivateExponent) PBYTE pbPrivateExponent, SIZE_T cbPrivateExponent, SYMCRYPT_NUMBER_FORMAT numFormat, UINT32 flags)
Definition: rsakey.c:1518
SymCryptRsaOaepEncrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepEncrypt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfDst, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
Definition: rsa_enc.c:833
SYMCRYPT_NUMBER_FORMAT_MSB_FIRST
@ SYMCRYPT_NUMBER_FORMAT_MSB_FIRST
Definition: symcrypt.h:7017
SYMCRYPT_NUMBER_FORMAT_LSB_FIRST
@ SYMCRYPT_NUMBER_FORMAT_LSB_FIRST
Definition: symcrypt.h:7016
SymCryptHashResult
VOID SYMCRYPT_CALL SymCryptHashResult(_In_ PCSYMCRYPT_HASH pHash, _Inout_updates_bytes_(pHash->stateSize) PVOID pState, _Out_writes_(SYMCRYPT_MIN(cbResult, pHash->resultSize)) PBYTE pbResult, SIZE_T cbResult)
Definition: hash.c:193
SymCryptDlgroupAllocate
PSYMCRYPT_DLGROUP SYMCRYPT_CALL SymCryptDlgroupAllocate(UINT32 nBitsOfP, UINT32 nBitsOfQ)
Definition: dlgroup.c:42
SymCryptHmac
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCryptHmac(_In_ PCSYMCRYPT_HMAC_EXPANDED_KEY pExpandedKey, _In_reads_(cbData) PCBYTE pbData, SIZE_T cbData, _Out_writes_(pExpandedKey->pHash->resultSize) PBYTE pbResult)
Definition: hmac.c:184
SymCryptDsaVerify
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDsaVerify(_In_ PCSYMCRYPT_DLKEY pKey, _In_reads_bytes_(cbHashValue) PCBYTE pbHashValue, SIZE_T cbHashValue, _In_reads_bytes_(cbSignature) PCBYTE pbSignature, SIZE_T cbSignature, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags)
Definition: dsa.c:410
SymCryptRsaOaepDecrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaOaepDecrypt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, SYMCRYPT_NUMBER_FORMAT nfSrc, _In_ PCSYMCRYPT_HASH hashAlgorithm, _In_reads_bytes_(cbLabel) PCBYTE pbLabel, SIZE_T cbLabel, UINT32 flags, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
Definition: rsa_enc.c:937
SymCryptAesKeyCopy
VOID SYMCRYPT_CALL SymCryptAesKeyCopy(_In_ PCSYMCRYPT_AES_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_AES_EXPANDED_KEY pDst)
Definition: aes-key.c:240
SymCryptDhSecretAgreement
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDhSecretAgreement(_In_ PCSYMCRYPT_DLKEY pkPrivate, _In_ PCSYMCRYPT_DLKEY pkPublic, SYMCRYPT_NUMBER_FORMAT format, UINT32 flags, _Out_writes_(cbAgreedSecret) PBYTE pbAgreedSecret, SIZE_T cbAgreedSecret)
Definition: dh.c:12
SymCryptRsaPkcs1Encrypt
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptRsaPkcs1Encrypt(_In_ PCSYMCRYPT_RSAKEY pkRsakey, _In_reads_bytes_(cbSrc) PCBYTE pbSrc, SIZE_T cbSrc, UINT32 flags, SYMCRYPT_NUMBER_FORMAT nfDst, _Out_writes_opt_(cbDst) PBYTE pbDst, SIZE_T cbDst, _Out_ SIZE_T *pcbDst)
Definition: rsa_enc.c:629
SymCryptCbcDecrypt
VOID SYMCRYPT_CALL SymCryptCbcDecrypt(_In_ PCSYMCRYPT_BLOCKCIPHER pBlockCipher, _In_ PCVOID pExpandedKey, _Inout_updates_(pBlockCipher->blockSize) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
Definition: blockciphermodes.c:143
SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION
#define SYMCRYPT_FLAG_KEY_MINIMAL_VALIDATION
Definition: symcrypt.h:7586
SYMCRYPT_ERROR
SYMCRYPT_ERROR
Definition: symcrypt.h:227
SymCryptMd4Algorithm
const PCSYMCRYPT_HASH SymCryptMd4Algorithm
Definition: md4.c:46
SymCryptHkdfPrkExpandKey
SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptHkdfPrkExpandKey(_Out_ PSYMCRYPT_HKDF_EXPANDED_KEY pExpandedKey, _In_ PCSYMCRYPT_MAC macAlgorithm, _In_reads_(cbPrk) PCBYTE pbPrk, SIZE_T cbPrk)
Definition: hkdf.c:92
SYMCRYPT_FLAG_ECKEY_ECDH
#define SYMCRYPT_FLAG_ECKEY_ECDH
Definition: symcrypt.h:7596
SYMCRYPT_CALL
#define SYMCRYPT_CALL
Definition: symcrypt_internal.h:167
SYMCRYPT_DLGROUP
SYMCRYPT_MAGIC_FIELD SYMCRYPT_DLGROUP
Definition: symcrypt_internal.h:2855
SYMCRYPT_ENVIRONMENT_DEFS
#define SYMCRYPT_ENVIRONMENT_DEFS(envName)
Definition: symcrypt_internal.h:3219
SYMCRYPT_HASH
struct _SYMCRYPT_HASH SYMCRYPT_HASH
Definition: symcrypt_internal.h:1181
SYMCRYPT_HMAC_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_STATE
Definition: symcrypt_internal.h:1539
SymCryptMd5OidList
const SYMCRYPT_OID SymCryptMd5OidList[SYMCRYPT_MD5_OID_COUNT]
Definition: rsa_padding.c:19
SYMCRYPT_RSAKEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_RSAKEY
Definition: symcrypt_internal.h:2756
SymCryptSha384OidList
const SYMCRYPT_OID SymCryptSha384OidList[SYMCRYPT_SHA384_OID_COUNT]
Definition: rsa_padding.c:43
SYMCRYPT_ECKEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_ECKEY
Definition: symcrypt_internal.h:3066
SymCryptSha512OidList
const SYMCRYPT_OID SymCryptSha512OidList[SYMCRYPT_SHA512_OID_COUNT]
Definition: rsa_padding.c:49
SYMCRYPT_AES_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_AES_EXPANDED_KEY
Definition: symcrypt_internal.h:1655
SYMCRYPT_HMAC_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_HMAC_EXPANDED_KEY
Definition: symcrypt_internal.h:1526
SYMCRYPT_ASYM_ALIGN_VALUE
#define SYMCRYPT_ASYM_ALIGN_VALUE
Definition: symcrypt_internal.h:2297
SYMCRYPT_GCM_EXPANDED_KEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_GCM_EXPANDED_KEY
Definition: symcrypt_internal.h:1963
SymCryptSha256OidList
const SYMCRYPT_OID SymCryptSha256OidList[SYMCRYPT_SHA256_OID_COUNT]
Definition: rsa_padding.c:37
SymCryptSha1OidList
const SYMCRYPT_OID SymCryptSha1OidList[SYMCRYPT_SHA1_OID_COUNT]
Definition: rsa_padding.c:25
SYMCRYPT_ECURVE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_ECURVE
Definition: symcrypt_internal.h:3005
SYMCRYPT_GCM_STATE
SYMCRYPT_MAGIC_FIELD SYMCRYPT_GCM_STATE
Definition: symcrypt_internal.h:1977
SYMCRYPT_DLKEY
SYMCRYPT_MAGIC_FIELD SYMCRYPT_DLKEY
Definition: symcrypt_internal.h:2883
InitializeCriticalSection
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:687
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
UINT32
uint32_t UINT32
Definition: typedefs.h:59
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
_SYMCRYPT_HASH_STATE
Definition: symcrypt_internal.h:1158
value
Definition: pdh_main.c:64
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383
SecureZeroMemory
#define SecureZeroMemory
Definition: winbase.h:1441
LeaveCriticalSection
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
DeleteCriticalSection
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
CALG_RSA_SIGN
#define CALG_RSA_SIGN
Definition: wincrypt.h:2069
PRIVATEKEYBLOB
#define PRIVATEKEYBLOB
Definition: wincrypt.h:2445
PUBLICKEYBLOB
#define PUBLICKEYBLOB
Definition: wincrypt.h:2444
CALG_RSA_KEYX
#define CALG_RSA_KEYX
Definition: wincrypt.h:2080
CALG_DSS_SIGN
#define CALG_DSS_SIGN
Definition: wincrypt.h:2070
WINAPI
#define WINAPI
Definition: msvc.h:6
NTE_BAD_DATA
#define NTE_BAD_DATA
Definition: winerror.h:4252
buffer_count
size_t const buffer_count
Definition: xtoa.cpp:36
BYTE
unsigned char BYTE
Definition: xxhash.c:193