?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll: Use cpu_info to check for AVX availability.
[wine.git] / dlls / bcrypt / bcrypt_main.c
bloba1423dcd8368605b535db4b7365ff90439916cec
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 <stdarg.h>
21
22 #include "ntstatus.h"
23 #define WIN32_NO_STATUS
24 #include "windef.h"
25 #include "winbase.h"
26 #include "ntsecapi.h"
27 #include "wincrypt.h"
28 #include "winternl.h"
29 #include "bcrypt.h"
30
31 #include "bcrypt_internal.h"
32
33 #include "wine/debug.h"
34 #include "wine/heap.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
37
38 static HINSTANCE instance;
39
40 static const struct key_funcs *key_funcs;
41
42 NTSTATUS WINAPI BCryptAddContextFunction(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function, ULONG pos)
43 {
44 FIXME("%08x, %s, %08x, %s, %u: stub\n", table, debugstr_w(context), iface, debugstr_w(function), pos);
45 return STATUS_SUCCESS;
46 }
47
48 NTSTATUS WINAPI BCryptAddContextFunctionProvider(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function, LPCWSTR provider, ULONG pos)
49 {
50 FIXME("%08x, %s, %08x, %s, %s, %u: stub\n", table, debugstr_w(context), iface, debugstr_w(function), debugstr_w(provider), pos);
51 return STATUS_SUCCESS;
52 }
53
54 NTSTATUS WINAPI BCryptRemoveContextFunction(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function)
55 {
56 FIXME("%08x, %s, %08x, %s: stub\n", table, debugstr_w(context), iface, debugstr_w(function));
57 return STATUS_NOT_IMPLEMENTED;
58 }
59
60 NTSTATUS WINAPI BCryptRemoveContextFunctionProvider(ULONG table, LPCWSTR context, ULONG iface, LPCWSTR function, LPCWSTR provider)
61 {
62 FIXME("%08x, %s, %08x, %s, %s: stub\n", table, debugstr_w(context), iface, debugstr_w(function), debugstr_w(provider));
63 return STATUS_NOT_IMPLEMENTED;
64 }
65
66 NTSTATUS WINAPI BCryptEnumContextFunctions( ULONG table, const WCHAR *ctx, ULONG iface, ULONG *buflen,
67 CRYPT_CONTEXT_FUNCTIONS **buffer )
68 {
69 FIXME( "%u, %s, %u, %p, %p\n", table, debugstr_w(ctx), iface, buflen, buffer );
70 return STATUS_NOT_IMPLEMENTED;
71 }
72
73 void WINAPI BCryptFreeBuffer( void *buffer )
74 {
75 FIXME( "%p\n", buffer );
76 }
77
78 NTSTATUS WINAPI BCryptRegisterProvider(LPCWSTR provider, ULONG flags, PCRYPT_PROVIDER_REG reg)
79 {
80 FIXME("%s, %08x, %p: stub\n", debugstr_w(provider), flags, reg);
81 return STATUS_SUCCESS;
82 }
83
84 NTSTATUS WINAPI BCryptUnregisterProvider(LPCWSTR provider)
85 {
86 FIXME("%s: stub\n", debugstr_w(provider));
87 return STATUS_NOT_IMPLEMENTED;
88 }
89
90 #define MAX_HASH_OUTPUT_BYTES 64
91 #define MAX_HASH_BLOCK_BITS 1024
92
93 /* ordered by class, keep in sync with enum alg_id */
94 static const struct
95 {
96 const WCHAR *name;
97 ULONG class;
98 ULONG object_length;
99 ULONG hash_length;
100 ULONG block_bits;
101 }
102 builtin_algorithms[] =
103 {
104 { BCRYPT_3DES_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 522, 0, 0 },
105 { BCRYPT_AES_ALGORITHM, BCRYPT_CIPHER_INTERFACE, 654, 0, 0 },
106 { BCRYPT_SHA256_ALGORITHM, BCRYPT_HASH_INTERFACE, 286, 32, 512 },
107 { BCRYPT_SHA384_ALGORITHM, BCRYPT_HASH_INTERFACE, 382, 48, 1024 },
108 { BCRYPT_SHA512_ALGORITHM, BCRYPT_HASH_INTERFACE, 382, 64, 1024 },
109 { BCRYPT_SHA1_ALGORITHM, BCRYPT_HASH_INTERFACE, 278, 20, 512 },
110 { BCRYPT_MD5_ALGORITHM, BCRYPT_HASH_INTERFACE, 274, 16, 512 },
111 { BCRYPT_MD4_ALGORITHM, BCRYPT_HASH_INTERFACE, 270, 16, 512 },
112 { BCRYPT_MD2_ALGORITHM, BCRYPT_HASH_INTERFACE, 270, 16, 128 },
113 { BCRYPT_RSA_ALGORITHM, BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE, 0, 0, 0 },
114 { BCRYPT_ECDH_P256_ALGORITHM, BCRYPT_SECRET_AGREEMENT_INTERFACE, 0, 0, 0 },
115 { BCRYPT_RSA_SIGN_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
116 { BCRYPT_ECDSA_P256_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
117 { BCRYPT_ECDSA_P384_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
118 { BCRYPT_DSA_ALGORITHM, BCRYPT_SIGNATURE_INTERFACE, 0, 0, 0 },
119 { BCRYPT_RNG_ALGORITHM, BCRYPT_RNG_INTERFACE, 0, 0, 0 },
120 };
121
122 static BOOL match_operation_type( ULONG type, ULONG class )
123 {
124 if (!type) return TRUE;
125 switch (class)
126 {
127 case BCRYPT_CIPHER_INTERFACE: return type & BCRYPT_CIPHER_OPERATION;
128 case BCRYPT_HASH_INTERFACE: return type & BCRYPT_HASH_OPERATION;
129 case BCRYPT_ASYMMETRIC_ENCRYPTION_INTERFACE: return type & BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION;
130 case BCRYPT_SECRET_AGREEMENT_INTERFACE: return type & BCRYPT_SECRET_AGREEMENT_OPERATION;
131 case BCRYPT_SIGNATURE_INTERFACE: return type & BCRYPT_SIGNATURE_OPERATION;
132 case BCRYPT_RNG_INTERFACE: return type & BCRYPT_RNG_OPERATION;
133 default: break;
134 }
135 return FALSE;
136 }
137
138 NTSTATUS WINAPI BCryptEnumAlgorithms( ULONG type, ULONG *ret_count, BCRYPT_ALGORITHM_IDENTIFIER **ret_list, ULONG flags )
139 {
140 static const ULONG supported = BCRYPT_CIPHER_OPERATION |\
141 BCRYPT_HASH_OPERATION |\
142 BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION |\
143 BCRYPT_SECRET_AGREEMENT_OPERATION |\
144 BCRYPT_SIGNATURE_OPERATION |\
145 BCRYPT_RNG_OPERATION;
146 BCRYPT_ALGORITHM_IDENTIFIER *list;
147 ULONG i, count = 0;
148
149 TRACE( "%08x, %p, %p, %08x\n", type, ret_count, ret_list, flags );
150
151 if (!ret_count || !ret_list || (type & ~supported)) return STATUS_INVALID_PARAMETER;
152
153 for (i = 0; i < ARRAY_SIZE( builtin_algorithms ); i++)
154 {
155 if (match_operation_type( type, builtin_algorithms[i].class )) count++;
156 }
157
158 if (!(list = heap_alloc( count * sizeof(*list) ))) return STATUS_NO_MEMORY;
159
160 for (i = 0; i < ARRAY_SIZE( builtin_algorithms ); i++)
161 {
162 if (!match_operation_type( type, builtin_algorithms[i].class )) continue;
163 list[i].pszName = (WCHAR *)builtin_algorithms[i].name;
164 list[i].dwClass = builtin_algorithms[i].class;
165 list[i].dwFlags = 0;
166 }
167
168 *ret_count = count;
169 *ret_list = list;
170 return STATUS_SUCCESS;
171 }
172
173 NTSTATUS WINAPI BCryptGenRandom(BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags)
174 {
175 const DWORD supported_flags = BCRYPT_USE_SYSTEM_PREFERRED_RNG;
176 struct algorithm *algorithm = handle;
177
178 TRACE("%p, %p, %u, %08x - semi-stub\n", handle, buffer, count, flags);
179
180 if (!algorithm)
181 {
182 /* It's valid to call without an algorithm if BCRYPT_USE_SYSTEM_PREFERRED_RNG
183 * is set. In this case the preferred system RNG is used.
184 */
185 if (!(flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
186 return STATUS_INVALID_HANDLE;
187 }
188 else if (algorithm->hdr.magic != MAGIC_ALG || algorithm->id != ALG_ID_RNG)
189 return STATUS_INVALID_HANDLE;
190
191 if (!buffer)
192 return STATUS_INVALID_PARAMETER;
193
194 if (flags & ~supported_flags)
195 FIXME("unsupported flags %08x\n", flags & ~supported_flags);
196
197 if (algorithm)
198 FIXME("ignoring selected algorithm\n");
199
200 /* When zero bytes are requested the function returns success too. */
201 if (!count)
202 return STATUS_SUCCESS;
203
204 if (algorithm || (flags & BCRYPT_USE_SYSTEM_PREFERRED_RNG))
205 {
206 if (RtlGenRandom(buffer, count))
207 return STATUS_SUCCESS;
208 }
209
210 FIXME("called with unsupported parameters, returning error\n");
211 return STATUS_NOT_IMPLEMENTED;
212 }
213
214 NTSTATUS WINAPI BCryptOpenAlgorithmProvider( BCRYPT_ALG_HANDLE *handle, LPCWSTR id, LPCWSTR implementation, DWORD flags )
215 {
216 const DWORD supported_flags = BCRYPT_ALG_HANDLE_HMAC_FLAG | BCRYPT_HASH_REUSABLE_FLAG;
217 struct algorithm *alg;
218 enum alg_id alg_id;
219 ULONG i;
220
221 TRACE( "%p, %s, %s, %08x\n", handle, wine_dbgstr_w(id), wine_dbgstr_w(implementation), flags );
222
223 if (!handle || !id) return STATUS_INVALID_PARAMETER;
224 if (flags & ~supported_flags)
225 {
226 FIXME( "unsupported flags %08x\n", flags & ~supported_flags);
227 return STATUS_NOT_IMPLEMENTED;
228 }
229
230 for (i = 0; i < ARRAY_SIZE( builtin_algorithms ); i++)
231 {
232 if (!wcscmp( id, builtin_algorithms[i].name))
233 {
234 alg_id = i;
235 break;
236 }
237 }
238 if (i == ARRAY_SIZE( builtin_algorithms ))
239 {
240 FIXME( "algorithm %s not supported\n", debugstr_w(id) );
241 return STATUS_NOT_IMPLEMENTED;
242 }
243
244 if (implementation && wcscmp( implementation, MS_PRIMITIVE_PROVIDER ))
245 {
246 FIXME( "implementation %s not supported\n", debugstr_w(implementation) );
247 return STATUS_NOT_IMPLEMENTED;
248 }
249
250 if (!(alg = heap_alloc( sizeof(*alg) ))) return STATUS_NO_MEMORY;
251 alg->hdr.magic = MAGIC_ALG;
252 alg->id = alg_id;
253 alg->mode = MODE_ID_CBC;
254 alg->flags = flags;
255
256 *handle = alg;
257 return STATUS_SUCCESS;
258 }
259
260 NTSTATUS WINAPI BCryptCloseAlgorithmProvider( BCRYPT_ALG_HANDLE handle, DWORD flags )
261 {
262 struct algorithm *alg = handle;
263
264 TRACE( "%p, %08x\n", handle, flags );
265
266 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
267 alg->hdr.magic = 0;
268 heap_free( alg );
269 return STATUS_SUCCESS;
270 }
271
272 NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
273 {
274 FIXME("%p - semi-stub\n", enabled);
275
276 if (!enabled)
277 return STATUS_INVALID_PARAMETER;
278
279 *enabled = FALSE;
280 return STATUS_SUCCESS;
281 }
282
283 struct hash_impl
284 {
285 union
286 {
287 MD2_CTX md2;
288 MD4_CTX md4;
289 MD5_CTX md5;
290 SHA_CTX sha1;
291 SHA256_CTX sha256;
292 SHA512_CTX sha512;
293 } u;
294 };
295
296 static NTSTATUS hash_init( struct hash_impl *hash, enum alg_id alg_id )
297 {
298 switch (alg_id)
299 {
300 case ALG_ID_MD2:
301 md2_init( &hash->u.md2 );
302 break;
303
304 case ALG_ID_MD4:
305 MD4Init( &hash->u.md4 );
306 break;
307
308 case ALG_ID_MD5:
309 MD5Init( &hash->u.md5 );
310 break;
311
312 case ALG_ID_SHA1:
313 A_SHAInit( &hash->u.sha1 );
314 break;
315
316 case ALG_ID_SHA256:
317 sha256_init( &hash->u.sha256 );
318 break;
319
320 case ALG_ID_SHA384:
321 sha384_init( &hash->u.sha512 );
322 break;
323
324 case ALG_ID_SHA512:
325 sha512_init( &hash->u.sha512 );
326 break;
327
328 default:
329 ERR( "unhandled id %u\n", alg_id );
330 return STATUS_NOT_IMPLEMENTED;
331 }
332 return STATUS_SUCCESS;
333 }
334
335 static NTSTATUS hash_update( struct hash_impl *hash, enum alg_id alg_id,
336 UCHAR *input, ULONG size )
337 {
338 switch (alg_id)
339 {
340 case ALG_ID_MD2:
341 md2_update( &hash->u.md2, input, size );
342 break;
343
344 case ALG_ID_MD4:
345 MD4Update( &hash->u.md4, input, size );
346 break;
347
348 case ALG_ID_MD5:
349 MD5Update( &hash->u.md5, input, size );
350 break;
351
352 case ALG_ID_SHA1:
353 A_SHAUpdate( &hash->u.sha1, input, size );
354 break;
355
356 case ALG_ID_SHA256:
357 sha256_update( &hash->u.sha256, input, size );
358 break;
359
360 case ALG_ID_SHA384:
361 sha384_update( &hash->u.sha512, input, size );
362 break;
363
364 case ALG_ID_SHA512:
365 sha512_update( &hash->u.sha512, input, size );
366 break;
367
368 default:
369 ERR( "unhandled id %u\n", alg_id );
370 return STATUS_NOT_IMPLEMENTED;
371 }
372 return STATUS_SUCCESS;
373 }
374
375 static NTSTATUS hash_finish( struct hash_impl *hash, enum alg_id alg_id,
376 UCHAR *output, ULONG size )
377 {
378 switch (alg_id)
379 {
380 case ALG_ID_MD2:
381 md2_finalize( &hash->u.md2, output );
382 break;
383
384 case ALG_ID_MD4:
385 MD4Final( &hash->u.md4 );
386 memcpy( output, hash->u.md4.digest, 16 );
387 break;
388
389 case ALG_ID_MD5:
390 MD5Final( &hash->u.md5 );
391 memcpy( output, hash->u.md5.digest, 16 );
392 break;
393
394 case ALG_ID_SHA1:
395 A_SHAFinal( &hash->u.sha1, (ULONG *)output );
396 break;
397
398 case ALG_ID_SHA256:
399 sha256_finalize( &hash->u.sha256, output );
400 break;
401
402 case ALG_ID_SHA384:
403 sha384_finalize( &hash->u.sha512, output );
404 break;
405
406 case ALG_ID_SHA512:
407 sha512_finalize( &hash->u.sha512, output );
408 break;
409
410 default:
411 ERR( "unhandled id %u\n", alg_id );
412 return STATUS_NOT_IMPLEMENTED;
413 }
414 return STATUS_SUCCESS;
415 }
416
417 #define HASH_FLAG_HMAC 0x01
418 #define HASH_FLAG_REUSABLE 0x02
419 struct hash
420 {
421 struct object hdr;
422 enum alg_id alg_id;
423 ULONG flags;
424 UCHAR *secret;
425 ULONG secret_len;
426 struct hash_impl outer;
427 struct hash_impl inner;
428 };
429
430 #define BLOCK_LENGTH_3DES 8
431 #define BLOCK_LENGTH_AES 16
432
433 static NTSTATUS generic_alg_property( enum alg_id id, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
434 {
435 if (!wcscmp( prop, BCRYPT_OBJECT_LENGTH ))
436 {
437 if (!builtin_algorithms[id].object_length)
438 return STATUS_NOT_SUPPORTED;
439 *ret_size = sizeof(ULONG);
440 if (size < sizeof(ULONG))
441 return STATUS_BUFFER_TOO_SMALL;
442 if (buf)
443 *(ULONG *)buf = builtin_algorithms[id].object_length;
444 return STATUS_SUCCESS;
445 }
446
447 if (!wcscmp( prop, BCRYPT_HASH_LENGTH ))
448 {
449 if (!builtin_algorithms[id].hash_length)
450 return STATUS_NOT_SUPPORTED;
451 *ret_size = sizeof(ULONG);
452 if (size < sizeof(ULONG))
453 return STATUS_BUFFER_TOO_SMALL;
454 if(buf)
455 *(ULONG*)buf = builtin_algorithms[id].hash_length;
456 return STATUS_SUCCESS;
457 }
458
459 if (!wcscmp( prop, BCRYPT_ALGORITHM_NAME ))
460 {
461 *ret_size = (lstrlenW(builtin_algorithms[id].name) + 1) * sizeof(WCHAR);
462 if (size < *ret_size)
463 return STATUS_BUFFER_TOO_SMALL;
464 if(buf)
465 memcpy(buf, builtin_algorithms[id].name, *ret_size);
466 return STATUS_SUCCESS;
467 }
468
469 return STATUS_NOT_IMPLEMENTED;
470 }
471
472 static NTSTATUS get_3des_property( enum mode_id mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
473 {
474 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH ))
475 {
476 *ret_size = sizeof(ULONG);
477 if (size < sizeof(ULONG)) return STATUS_BUFFER_TOO_SMALL;
478 if (buf) *(ULONG *)buf = BLOCK_LENGTH_3DES;
479 return STATUS_SUCCESS;
480 }
481 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
482 {
483 const WCHAR *str;
484 switch (mode)
485 {
486 case MODE_ID_CBC: str = BCRYPT_CHAIN_MODE_CBC; break;
487 default: return STATUS_NOT_IMPLEMENTED;
488 }
489
490 *ret_size = 64;
491 if (size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
492 memcpy( buf, str, (lstrlenW(str) + 1) * sizeof(WCHAR) );
493 return STATUS_SUCCESS;
494 }
495 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
496 {
497 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
498 *ret_size = sizeof(*key_lengths);
499 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
500 if (key_lengths)
501 {
502 key_lengths->dwMinLength = 192;
503 key_lengths->dwMaxLength = 192;
504 key_lengths->dwIncrement = 0;
505 }
506 return STATUS_SUCCESS;
507 }
508 FIXME( "unsupported property %s\n", debugstr_w(prop) );
509 return STATUS_NOT_IMPLEMENTED;
510 }
511
512 static NTSTATUS get_aes_property( enum mode_id mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
513 {
514 if (!wcscmp( prop, BCRYPT_BLOCK_LENGTH ))
515 {
516 *ret_size = sizeof(ULONG);
517 if (size < sizeof(ULONG)) return STATUS_BUFFER_TOO_SMALL;
518 if (buf) *(ULONG *)buf = BLOCK_LENGTH_AES;
519 return STATUS_SUCCESS;
520 }
521 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
522 {
523 const WCHAR *str;
524 switch (mode)
525 {
526 case MODE_ID_ECB: str = BCRYPT_CHAIN_MODE_ECB; break;
527 case MODE_ID_CBC: str = BCRYPT_CHAIN_MODE_CBC; break;
528 case MODE_ID_GCM: str = BCRYPT_CHAIN_MODE_GCM; break;
529 default: return STATUS_NOT_IMPLEMENTED;
530 }
531
532 *ret_size = 64;
533 if (size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
534 memcpy( buf, str, (lstrlenW(str) + 1) * sizeof(WCHAR) );
535 return STATUS_SUCCESS;
536 }
537 if (!wcscmp( prop, BCRYPT_KEY_LENGTHS ))
538 {
539 BCRYPT_KEY_LENGTHS_STRUCT *key_lengths = (void *)buf;
540 *ret_size = sizeof(*key_lengths);
541 if (key_lengths && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
542 if (key_lengths)
543 {
544 key_lengths->dwMinLength = 128;
545 key_lengths->dwMaxLength = 256;
546 key_lengths->dwIncrement = 64;
547 }
548 return STATUS_SUCCESS;
549 }
550 if (!wcscmp( prop, BCRYPT_AUTH_TAG_LENGTH ))
551 {
552 BCRYPT_AUTH_TAG_LENGTHS_STRUCT *tag_length = (void *)buf;
553 if (mode != MODE_ID_GCM) return STATUS_NOT_SUPPORTED;
554 *ret_size = sizeof(*tag_length);
555 if (tag_length && size < *ret_size) return STATUS_BUFFER_TOO_SMALL;
556 if (tag_length)
557 {
558 tag_length->dwMinLength = 12;
559 tag_length->dwMaxLength = 16;
560 tag_length->dwIncrement = 1;
561 }
562 return STATUS_SUCCESS;
563 }
564
565 FIXME( "unsupported property %s\n", debugstr_w(prop) );
566 return STATUS_NOT_IMPLEMENTED;
567 }
568
569 static NTSTATUS get_rsa_property( enum mode_id mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
570 {
571 if (!wcscmp( prop, BCRYPT_PADDING_SCHEMES ))
572 {
573 *ret_size = sizeof(ULONG);
574 if (size < sizeof(ULONG)) return STATUS_BUFFER_TOO_SMALL;
575 if (buf) *(ULONG *)buf = BCRYPT_SUPPORTED_PAD_PKCS1_SIG;
576 return STATUS_SUCCESS;
577 }
578
579 FIXME( "unsupported property %s\n", debugstr_w(prop) );
580 return STATUS_NOT_IMPLEMENTED;
581 }
582
583 static NTSTATUS get_dsa_property( enum mode_id mode, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
584 {
585 if (!wcscmp( prop, BCRYPT_PADDING_SCHEMES )) return STATUS_NOT_SUPPORTED;
586 FIXME( "unsupported property %s\n", debugstr_w(prop) );
587 return STATUS_NOT_IMPLEMENTED;
588 }
589
590 static NTSTATUS get_alg_property( const struct algorithm *alg, const WCHAR *prop,
591 UCHAR *buf, ULONG size, ULONG *ret_size )
592 {
593 NTSTATUS status;
594
595 status = generic_alg_property( alg->id, prop, buf, size, ret_size );
596 if (status != STATUS_NOT_IMPLEMENTED)
597 return status;
598
599 switch (alg->id)
600 {
601 case ALG_ID_3DES:
602 return get_3des_property( alg->mode, prop, buf, size, ret_size );
603
604 case ALG_ID_AES:
605 return get_aes_property( alg->mode, prop, buf, size, ret_size );
606
607 case ALG_ID_RSA:
608 return get_rsa_property( alg->mode, prop, buf, size, ret_size );
609
610 case ALG_ID_DSA:
611 return get_dsa_property( alg->mode, prop, buf, size, ret_size );
612
613 default:
614 break;
615 }
616
617 FIXME( "unsupported property %s algorithm %u\n", debugstr_w(prop), alg->id );
618 return STATUS_NOT_IMPLEMENTED;
619 }
620
621 static NTSTATUS set_alg_property( struct algorithm *alg, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
622 {
623 switch (alg->id)
624 {
625 case ALG_ID_3DES:
626 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
627 {
628 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
629 {
630 alg->mode = MODE_ID_CBC;
631 return STATUS_SUCCESS;
632 }
633 else
634 {
635 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
636 return STATUS_NOT_SUPPORTED;
637 }
638 }
639 FIXME( "unsupported 3des algorithm property %s\n", debugstr_w(prop) );
640 return STATUS_NOT_IMPLEMENTED;
641
642 case ALG_ID_AES:
643 if (!wcscmp( prop, BCRYPT_CHAINING_MODE ))
644 {
645 if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB ))
646 {
647 alg->mode = MODE_ID_ECB;
648 return STATUS_SUCCESS;
649 }
650 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
651 {
652 alg->mode = MODE_ID_CBC;
653 return STATUS_SUCCESS;
654 }
655 else if (!wcscmp( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM ))
656 {
657 alg->mode = MODE_ID_GCM;
658 return STATUS_SUCCESS;
659 }
660 else
661 {
662 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
663 return STATUS_NOT_IMPLEMENTED;
664 }
665 }
666 FIXME( "unsupported aes algorithm property %s\n", debugstr_w(prop) );
667 return STATUS_NOT_IMPLEMENTED;
668
669 default:
670 FIXME( "unsupported algorithm %u\n", alg->id );
671 return STATUS_NOT_IMPLEMENTED;
672 }
673 }
674
675 static NTSTATUS get_hash_property( const struct hash *hash, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
676 {
677 NTSTATUS status;
678
679 status = generic_alg_property( hash->alg_id, prop, buf, size, ret_size );
680 if (status == STATUS_NOT_IMPLEMENTED)
681 FIXME( "unsupported property %s\n", debugstr_w(prop) );
682 return status;
683 }
684
685 static NTSTATUS get_key_property( const struct key *key, const WCHAR *prop, UCHAR *buf, ULONG size, ULONG *ret_size )
686 {
687 switch (key->alg_id)
688 {
689 case ALG_ID_3DES:
690 return get_3des_property( key->u.s.mode, prop, buf, size, ret_size );
691
692 case ALG_ID_AES:
693 if (!wcscmp( prop, BCRYPT_AUTH_TAG_LENGTH )) return STATUS_NOT_SUPPORTED;
694 return get_aes_property( key->u.s.mode, prop, buf, size, ret_size );
695
696 default:
697 FIXME( "unsupported algorithm %u\n", key->alg_id );
698 return STATUS_NOT_IMPLEMENTED;
699 }
700 }
701
702 NTSTATUS WINAPI BCryptGetProperty( BCRYPT_HANDLE handle, LPCWSTR prop, UCHAR *buffer, ULONG count, ULONG *res, ULONG flags )
703 {
704 struct object *object = handle;
705
706 TRACE( "%p, %s, %p, %u, %p, %08x\n", handle, wine_dbgstr_w(prop), buffer, count, res, flags );
707
708 if (!object) return STATUS_INVALID_HANDLE;
709 if (!prop || !res) return STATUS_INVALID_PARAMETER;
710
711 switch (object->magic)
712 {
713 case MAGIC_ALG:
714 {
715 const struct algorithm *alg = (const struct algorithm *)object;
716 return get_alg_property( alg, prop, buffer, count, res );
717 }
718 case MAGIC_KEY:
719 {
720 const struct key *key = (const struct key *)object;
721 return get_key_property( key, prop, buffer, count, res );
722 }
723 case MAGIC_HASH:
724 {
725 const struct hash *hash = (const struct hash *)object;
726 return get_hash_property( hash, prop, buffer, count, res );
727 }
728 default:
729 WARN( "unknown magic %08x\n", object->magic );
730 return STATUS_INVALID_HANDLE;
731 }
732 }
733
734 static NTSTATUS hash_prepare( struct hash *hash )
735 {
736 UCHAR buffer[MAX_HASH_BLOCK_BITS / 8] = {0};
737 int block_bytes, i;
738 NTSTATUS status;
739
740 /* initialize hash */
741 if ((status = hash_init( &hash->inner, hash->alg_id ))) return status;
742 if (!(hash->flags & HASH_FLAG_HMAC)) return STATUS_SUCCESS;
743
744 /* initialize hmac */
745 if ((status = hash_init( &hash->outer, hash->alg_id ))) return status;
746 block_bytes = builtin_algorithms[hash->alg_id].block_bits / 8;
747 if (hash->secret_len > block_bytes)
748 {
749 struct hash_impl temp;
750 if ((status = hash_init( &temp, hash->alg_id ))) return status;
751 if ((status = hash_update( &temp, hash->alg_id, hash->secret, hash->secret_len ))) return status;
752 if ((status = hash_finish( &temp, hash->alg_id, buffer,
753 builtin_algorithms[hash->alg_id].hash_length ))) return status;
754 }
755 else memcpy( buffer, hash->secret, hash->secret_len );
756
757 for (i = 0; i < block_bytes; i++) buffer[i] ^= 0x5c;
758 if ((status = hash_update( &hash->outer, hash->alg_id, buffer, block_bytes ))) return status;
759 for (i = 0; i < block_bytes; i++) buffer[i] ^= (0x5c ^ 0x36);
760 return hash_update( &hash->inner, hash->alg_id, buffer, block_bytes );
761 }
762
763 static NTSTATUS hash_create( const struct algorithm *alg, UCHAR *secret, ULONG secret_len, ULONG flags,
764 struct hash **ret_hash )
765 {
766 struct hash *hash;
767 NTSTATUS status;
768
769 if (!(hash = heap_alloc_zero( sizeof(*hash) ))) return STATUS_NO_MEMORY;
770 hash->hdr.magic = MAGIC_HASH;
771 hash->alg_id = alg->id;
772 if (alg->flags & BCRYPT_ALG_HANDLE_HMAC_FLAG) hash->flags = HASH_FLAG_HMAC;
773 if ((alg->flags & BCRYPT_HASH_REUSABLE_FLAG) || (flags & BCRYPT_HASH_REUSABLE_FLAG))
774 hash->flags |= HASH_FLAG_REUSABLE;
775
776 if (secret_len && !(hash->secret = heap_alloc( secret_len )))
777 {
778 heap_free( hash );
779 return STATUS_NO_MEMORY;
780 }
781 memcpy( hash->secret, secret, secret_len );
782 hash->secret_len = secret_len;
783
784 if ((status = hash_prepare( hash )))
785 {
786 heap_free( hash->secret );
787 heap_free( hash );
788 return status;
789 }
790
791 *ret_hash = hash;
792 return STATUS_SUCCESS;
793 }
794
795 NTSTATUS WINAPI BCryptCreateHash( BCRYPT_ALG_HANDLE algorithm, BCRYPT_HASH_HANDLE *handle, UCHAR *object,
796 ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags )
797 {
798 struct algorithm *alg = algorithm;
799 struct hash *hash;
800 NTSTATUS status;
801
802 TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", algorithm, handle, object, object_len,
803 secret, secret_len, flags );
804 if (flags & ~BCRYPT_HASH_REUSABLE_FLAG)
805 {
806 FIXME( "unimplemented flags %08x\n", flags );
807 return STATUS_NOT_IMPLEMENTED;
808 }
809
810 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
811 if (object) FIXME( "ignoring object buffer\n" );
812
813 if ((status = hash_create( alg, secret, secret_len, flags, &hash ))) return status;
814 *handle = hash;
815 return STATUS_SUCCESS;
816 }
817
818 NTSTATUS WINAPI BCryptDuplicateHash( BCRYPT_HASH_HANDLE handle, BCRYPT_HASH_HANDLE *handle_copy,
819 UCHAR *object, ULONG objectlen, ULONG flags )
820 {
821 struct hash *hash_orig = handle;
822 struct hash *hash_copy;
823
824 TRACE( "%p, %p, %p, %u, %u\n", handle, handle_copy, object, objectlen, flags );
825
826 if (!hash_orig || hash_orig->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
827 if (!handle_copy) return STATUS_INVALID_PARAMETER;
828 if (object) FIXME( "ignoring object buffer\n" );
829
830 if (!(hash_copy = heap_alloc( sizeof(*hash_copy) )))
831 return STATUS_NO_MEMORY;
832
833 memcpy( hash_copy, hash_orig, sizeof(*hash_orig) );
834 if (hash_orig->secret && !(hash_copy->secret = heap_alloc( hash_orig->secret_len )))
835 {
836 heap_free( hash_copy );
837 return STATUS_NO_MEMORY;
838 }
839 memcpy( hash_copy->secret, hash_orig->secret, hash_orig->secret_len );
840
841 *handle_copy = hash_copy;
842 return STATUS_SUCCESS;
843 }
844
845 static void hash_destroy( struct hash *hash )
846 {
847 if (!hash) return;
848 hash->hdr.magic = 0;
849 heap_free( hash->secret );
850 heap_free( hash );
851 }
852
853 NTSTATUS WINAPI BCryptDestroyHash( BCRYPT_HASH_HANDLE handle )
854 {
855 struct hash *hash = handle;
856
857 TRACE( "%p\n", handle );
858
859 if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_PARAMETER;
860 hash_destroy( hash );
861 return STATUS_SUCCESS;
862 }
863
864 NTSTATUS WINAPI BCryptHashData( BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags )
865 {
866 struct hash *hash = handle;
867
868 TRACE( "%p, %p, %u, %08x\n", handle, input, size, flags );
869
870 if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
871 if (!input) return STATUS_SUCCESS;
872
873 return hash_update( &hash->inner, hash->alg_id, input, size );
874 }
875
876 static NTSTATUS hash_finalize( struct hash *hash, UCHAR *output, ULONG size )
877 {
878 UCHAR buffer[MAX_HASH_OUTPUT_BYTES];
879 int hash_length;
880 NTSTATUS status;
881
882 if (!(hash->flags & HASH_FLAG_HMAC))
883 {
884 if ((status = hash_finish( &hash->inner, hash->alg_id, output, size ))) return status;
885 if (hash->flags & HASH_FLAG_REUSABLE) return hash_prepare( hash );
886 return STATUS_SUCCESS;
887 }
888
889 hash_length = builtin_algorithms[hash->alg_id].hash_length;
890 if ((status = hash_finish( &hash->inner, hash->alg_id, buffer, hash_length ))) return status;
891 if ((status = hash_update( &hash->outer, hash->alg_id, buffer, hash_length ))) return status;
892 if ((status = hash_finish( &hash->outer, hash->alg_id, output, size ))) return status;
893
894 if (hash->flags & HASH_FLAG_REUSABLE) return hash_prepare( hash );
895 return STATUS_SUCCESS;
896 }
897
898 NTSTATUS WINAPI BCryptFinishHash( BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags )
899 {
900 struct hash *hash = handle;
901
902 TRACE( "%p, %p, %u, %08x\n", handle, output, size, flags );
903
904 if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
905 if (!output) return STATUS_INVALID_PARAMETER;
906
907 return hash_finalize( hash, output, size );
908 }
909
910 NTSTATUS WINAPI BCryptHash( BCRYPT_ALG_HANDLE algorithm, UCHAR *secret, ULONG secret_len,
911 UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len )
912 {
913 struct algorithm *alg = algorithm;
914 struct hash *hash;
915 NTSTATUS status;
916
917 TRACE( "%p, %p, %u, %p, %u, %p, %u\n", algorithm, secret, secret_len, input, input_len, output, output_len );
918
919 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
920
921 if ((status = hash_create( alg, secret, secret_len, 0, &hash ))) return status;
922 if ((status = hash_update( &hash->inner, hash->alg_id, input, input_len )))
923 {
924 hash_destroy( hash );
925 return status;
926 }
927 status = hash_finalize( hash, output, output_len );
928 hash_destroy( hash );
929 return status;
930 }
931
932 static NTSTATUS key_asymmetric_create( struct key **ret_key, struct algorithm *alg, ULONG bitlen,
933 const UCHAR *pubkey, ULONG pubkey_len )
934 {
935 struct key *key;
936 NTSTATUS status;
937
938 if (!key_funcs)
939 {
940 ERR( "no encryption support\n" );
941 return STATUS_NOT_IMPLEMENTED;
942 }
943
944 if (!(key = heap_alloc_zero( sizeof(*key) ))) return STATUS_NO_MEMORY;
945 key->hdr.magic = MAGIC_KEY;
946 key->alg_id = alg->id;
947 key->u.a.bitlen = bitlen;
948
949 if (pubkey_len)
950 {
951 if (!(key->u.a.pubkey = heap_alloc( pubkey_len )))
952 {
953 heap_free( key );
954 return STATUS_NO_MEMORY;
955 }
956 memcpy( key->u.a.pubkey, pubkey, pubkey_len );
957 key->u.a.pubkey_len = pubkey_len;
958 }
959 if ((status = key_funcs->key_asymmetric_init( key )))
960 {
961 heap_free( key->u.a.pubkey );
962 heap_free( key );
963 return status;
964 }
965 *ret_key = key;
966 return STATUS_SUCCESS;
967 }
968
969 static BOOL key_is_symmetric( struct key *key )
970 {
971 return builtin_algorithms[key->alg_id].class == BCRYPT_CIPHER_INTERFACE;
972 }
973
974 static BOOL is_zero_vector( const UCHAR *vector, ULONG len )
975 {
976 ULONG i;
977 if (!vector) return FALSE;
978 for (i = 0; i < len; i++) if (vector[i]) return FALSE;
979 return TRUE;
980 }
981
982 static BOOL is_equal_vector( const UCHAR *vector, ULONG len, const UCHAR *vector2, ULONG len2 )
983 {
984 if (!vector && !vector2) return TRUE;
985 if (len != len2) return FALSE;
986 return !memcmp( vector, vector2, len );
987 }
988
989 static NTSTATUS key_symmetric_set_vector( struct key *key, UCHAR *vector, ULONG vector_len )
990 {
991 BOOL needs_reset = (!is_zero_vector( vector, vector_len ) ||
992 !is_equal_vector( key->u.s.vector, key->u.s.vector_len, vector, vector_len ));
993
994 heap_free( key->u.s.vector );
995 key->u.s.vector = NULL;
996 key->u.s.vector_len = 0;
997 if (vector)
998 {
999 if (!(key->u.s.vector = heap_alloc( vector_len ))) return STATUS_NO_MEMORY;
1000 memcpy( key->u.s.vector, vector, vector_len );
1001 key->u.s.vector_len = vector_len;
1002 }
1003 if (needs_reset) key_funcs->key_symmetric_vector_reset( key );
1004 return STATUS_SUCCESS;
1005 }
1006
1007 static NTSTATUS key_import( BCRYPT_ALG_HANDLE algorithm, const WCHAR *type, BCRYPT_KEY_HANDLE *key, UCHAR *object,
1008 ULONG object_len, UCHAR *input, ULONG input_len )
1009 {
1010 ULONG len;
1011
1012 if (!wcscmp( type, BCRYPT_KEY_DATA_BLOB ))
1013 {
1014 BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)input;
1015
1016 if (input_len < sizeof(BCRYPT_KEY_DATA_BLOB_HEADER)) return STATUS_BUFFER_TOO_SMALL;
1017 if (header->dwMagic != BCRYPT_KEY_DATA_BLOB_MAGIC) return STATUS_INVALID_PARAMETER;
1018 if (header->dwVersion != BCRYPT_KEY_DATA_BLOB_VERSION1)
1019 {
1020 FIXME( "unknown key data blob version %u\n", header->dwVersion );
1021 return STATUS_INVALID_PARAMETER;
1022 }
1023 len = header->cbKeyData;
1024 if (len + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) > input_len) return STATUS_INVALID_PARAMETER;
1025
1026 return BCryptGenerateSymmetricKey( algorithm, key, object, object_len, (UCHAR *)&header[1], len, 0 );
1027 }
1028 else if (!wcscmp( type, BCRYPT_OPAQUE_KEY_BLOB ))
1029 {
1030 if (input_len < sizeof(len)) return STATUS_BUFFER_TOO_SMALL;
1031 len = *(ULONG *)input;
1032 if (len + sizeof(len) > input_len) return STATUS_INVALID_PARAMETER;
1033
1034 return BCryptGenerateSymmetricKey( algorithm, key, object, object_len, input + sizeof(len), len, 0 );
1035 }
1036
1037 FIXME( "unsupported key type %s\n", debugstr_w(type) );
1038 return STATUS_NOT_IMPLEMENTED;
1039 }
1040
1041 static NTSTATUS key_export( struct key *key, const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *size )
1042 {
1043 if (!wcscmp( type, BCRYPT_KEY_DATA_BLOB ))
1044 {
1045 BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)output;
1046 ULONG req_size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->u.s.secret_len;
1047
1048 *size = req_size;
1049 if (output_len < req_size) return STATUS_BUFFER_TOO_SMALL;
1050 if (output)
1051 {
1052 header->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
1053 header->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
1054 header->cbKeyData = key->u.s.secret_len;
1055 memcpy( &header[1], key->u.s.secret, key->u.s.secret_len );
1056 }
1057 return STATUS_SUCCESS;
1058 }
1059 else if (!wcscmp( type, BCRYPT_OPAQUE_KEY_BLOB ))
1060 {
1061 ULONG len, req_size = sizeof(len) + key->u.s.secret_len;
1062
1063 *size = req_size;
1064 if (output_len < req_size) return STATUS_BUFFER_TOO_SMALL;
1065 if (output)
1066 {
1067 *(ULONG *)output = key->u.s.secret_len;
1068 memcpy( output + sizeof(len), key->u.s.secret, key->u.s.secret_len );
1069 }
1070 return STATUS_SUCCESS;
1071 }
1072 else if (!wcscmp( type, BCRYPT_RSAPUBLIC_BLOB ) || !wcscmp( type, BCRYPT_DSA_PUBLIC_BLOB ) ||
1073 !wcscmp( type, BCRYPT_ECCPUBLIC_BLOB ) || !wcscmp( type, LEGACY_DSA_V2_PUBLIC_BLOB ))
1074 {
1075 *size = key->u.a.pubkey_len;
1076 if (output_len < key->u.a.pubkey_len) return STATUS_SUCCESS;
1077 if (output) memcpy( output, key->u.a.pubkey, key->u.a.pubkey_len );
1078 return STATUS_SUCCESS;
1079 }
1080 else if (!wcscmp( type, BCRYPT_ECCPRIVATE_BLOB ))
1081 {
1082 return key_funcs->key_export_ecc( key, output, output_len, size );
1083 }
1084 else if (!wcscmp( type, LEGACY_DSA_V2_PRIVATE_BLOB ))
1085 {
1086 return key_funcs->key_export_dsa_capi( key, output, output_len, size );
1087 }
1088
1089 FIXME( "unsupported key type %s\n", debugstr_w(type) );
1090 return STATUS_NOT_IMPLEMENTED;
1091 }
1092
1093 static NTSTATUS key_encrypt( struct key *key, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1094 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1095 {
1096 ULONG bytes_left = input_len;
1097 UCHAR *buf, *src, *dst;
1098 NTSTATUS status;
1099
1100 if (key->u.s.mode == MODE_ID_GCM)
1101 {
1102 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *auth_info = padding;
1103
1104 if (!auth_info) return STATUS_INVALID_PARAMETER;
1105 if (!auth_info->pbNonce) return STATUS_INVALID_PARAMETER;
1106 if (!auth_info->pbTag) return STATUS_INVALID_PARAMETER;
1107 if (auth_info->cbTag < 12 || auth_info->cbTag > 16) return STATUS_INVALID_PARAMETER;
1108 if (auth_info->dwFlags & BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG)
1109 FIXME( "call chaining not implemented\n" );
1110
1111 if ((status = key_symmetric_set_vector( key, auth_info->pbNonce, auth_info->cbNonce )))
1112 return status;
1113
1114 *ret_len = input_len;
1115 if (flags & BCRYPT_BLOCK_PADDING) return STATUS_INVALID_PARAMETER;
1116 if (input && !output) return STATUS_SUCCESS;
1117 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1118
1119 if ((status = key_funcs->key_symmetric_set_auth_data( key, auth_info->pbAuthData, auth_info->cbAuthData )))
1120 return status;
1121 if ((status = key_funcs->key_symmetric_encrypt( key, input, input_len, output, output_len ))) return status;
1122
1123 return key_funcs->key_symmetric_get_tag( key, auth_info->pbTag, auth_info->cbTag );
1124 }
1125
1126 *ret_len = input_len;
1127
1128 if (flags & BCRYPT_BLOCK_PADDING)
1129 *ret_len = (input_len + key->u.s.block_size) & ~(key->u.s.block_size - 1);
1130 else if (input_len & (key->u.s.block_size - 1))
1131 return STATUS_INVALID_BUFFER_SIZE;
1132
1133 if (!output) return STATUS_SUCCESS;
1134 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1135 if (key->u.s.mode == MODE_ID_ECB && iv) return STATUS_INVALID_PARAMETER;
1136 if ((status = key_symmetric_set_vector( key, iv, iv_len ))) return status;
1137
1138 src = input;
1139 dst = output;
1140 while (bytes_left >= key->u.s.block_size)
1141 {
1142 if ((status = key_funcs->key_symmetric_encrypt( key, src, key->u.s.block_size, dst, key->u.s.block_size )))
1143 return status;
1144 if (key->u.s.mode == MODE_ID_ECB && (status = key_symmetric_set_vector( key, NULL, 0 )))
1145 return status;
1146 bytes_left -= key->u.s.block_size;
1147 src += key->u.s.block_size;
1148 dst += key->u.s.block_size;
1149 }
1150
1151 if (flags & BCRYPT_BLOCK_PADDING)
1152 {
1153 if (!(buf = heap_alloc( key->u.s.block_size ))) return STATUS_NO_MEMORY;
1154 memcpy( buf, src, bytes_left );
1155 memset( buf + bytes_left, key->u.s.block_size - bytes_left, key->u.s.block_size - bytes_left );
1156 status = key_funcs->key_symmetric_encrypt( key, buf, key->u.s.block_size, dst, key->u.s.block_size );
1157 heap_free( buf );
1158 }
1159
1160 return status;
1161 }
1162
1163 static NTSTATUS key_symmetric_decrypt( struct key *key, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1164 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1165 {
1166 ULONG bytes_left = input_len;
1167 UCHAR *buf, *src, *dst;
1168 NTSTATUS status;
1169
1170 if (key->u.s.mode == MODE_ID_GCM)
1171 {
1172 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *auth_info = padding;
1173 UCHAR tag[16];
1174
1175 if (!auth_info) return STATUS_INVALID_PARAMETER;
1176 if (!auth_info->pbNonce) return STATUS_INVALID_PARAMETER;
1177 if (!auth_info->pbTag) return STATUS_INVALID_PARAMETER;
1178 if (auth_info->cbTag < 12 || auth_info->cbTag > 16) return STATUS_INVALID_PARAMETER;
1179
1180 if ((status = key_symmetric_set_vector( key, auth_info->pbNonce, auth_info->cbNonce )))
1181 return status;
1182
1183 *ret_len = input_len;
1184 if (flags & BCRYPT_BLOCK_PADDING) return STATUS_INVALID_PARAMETER;
1185 if (!output) return STATUS_SUCCESS;
1186 if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1187
1188 if ((status = key_funcs->key_symmetric_set_auth_data( key, auth_info->pbAuthData, auth_info->cbAuthData )))
1189 return status;
1190 if ((status = key_funcs->key_symmetric_decrypt( key, input, input_len, output, output_len ))) return status;
1191
1192 if ((status = key_funcs->key_symmetric_get_tag( key, tag, sizeof(tag) ))) return status;
1193 if (memcmp( tag, auth_info->pbTag, auth_info->cbTag )) return STATUS_AUTH_TAG_MISMATCH;
1194
1195 return STATUS_SUCCESS;
1196 }
1197
1198 *ret_len = input_len;
1199
1200 if (input_len & (key->u.s.block_size - 1)) return STATUS_INVALID_BUFFER_SIZE;
1201 if (!output) return STATUS_SUCCESS;
1202 if (flags & BCRYPT_BLOCK_PADDING)
1203 {
1204 if (output_len + key->u.s.block_size < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1205 if (input_len < key->u.s.block_size) return STATUS_BUFFER_TOO_SMALL;
1206 bytes_left -= key->u.s.block_size;
1207 }
1208 else if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL;
1209
1210 if (key->u.s.mode == MODE_ID_ECB && iv) return STATUS_INVALID_PARAMETER;
1211 if ((status = key_symmetric_set_vector( key, iv, iv_len ))) return status;
1212
1213 src = input;
1214 dst = output;
1215 while (bytes_left >= key->u.s.block_size)
1216 {
1217 if ((status = key_funcs->key_symmetric_decrypt( key, src, key->u.s.block_size, dst, key->u.s.block_size )))
1218 return status;
1219 if (key->u.s.mode == MODE_ID_ECB && (status = key_symmetric_set_vector( key, NULL, 0 )))
1220 return status;
1221 bytes_left -= key->u.s.block_size;
1222 src += key->u.s.block_size;
1223 dst += key->u.s.block_size;
1224 }
1225
1226 if (flags & BCRYPT_BLOCK_PADDING)
1227 {
1228 if (!(buf = heap_alloc( key->u.s.block_size ))) return STATUS_NO_MEMORY;
1229 status = key_funcs->key_symmetric_decrypt( key, src, key->u.s.block_size, buf, key->u.s.block_size );
1230 if (!status && buf[ key->u.s.block_size - 1 ] <= key->u.s.block_size)
1231 {
1232 *ret_len -= buf[ key->u.s.block_size - 1 ];
1233 if (output_len < *ret_len) status = STATUS_BUFFER_TOO_SMALL;
1234 else memcpy( dst, buf, key->u.s.block_size - buf[ key->u.s.block_size - 1 ] );
1235 }
1236 else status = STATUS_UNSUCCESSFUL; /* FIXME: invalid padding */
1237 heap_free( buf );
1238 }
1239
1240 return status;
1241 }
1242
1243 static NTSTATUS key_asymmetric_decrypt( struct key *key, UCHAR *input, ULONG input_len, UCHAR *output,
1244 ULONG output_len, ULONG *ret_len )
1245 {
1246 NTSTATUS status;
1247
1248 if (!(status = key_funcs->key_asymmetric_decrypt( key, input, input_len, output, &output_len )))
1249 *ret_len = output_len;
1250
1251 return status;
1252 }
1253
1254 static NTSTATUS key_decrypt( struct key *key, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1255 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1256 {
1257 return key_is_symmetric( key ) ? key_symmetric_decrypt( key, input, input_len, padding, iv, iv_len,
1258 output, output_len, ret_len, flags ) : key_asymmetric_decrypt( key, input, input_len, output, output_len, ret_len );
1259 }
1260
1261 static NTSTATUS key_import_pair( struct algorithm *alg, const WCHAR *type, BCRYPT_KEY_HANDLE *ret_key, UCHAR *input,
1262 ULONG input_len )
1263 {
1264 struct key *key;
1265 NTSTATUS status;
1266
1267 if (!wcscmp( type, BCRYPT_ECCPUBLIC_BLOB ))
1268 {
1269 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)input;
1270 DWORD key_size, magic, size;
1271
1272 if (input_len < sizeof(*ecc_blob)) return STATUS_INVALID_PARAMETER;
1273
1274 switch (alg->id)
1275 {
1276 case ALG_ID_ECDH_P256:
1277 key_size = 32;
1278 magic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
1279 break;
1280
1281 case ALG_ID_ECDSA_P256:
1282 key_size = 32;
1283 magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
1284 break;
1285
1286 case ALG_ID_ECDSA_P384:
1287 key_size = 48;
1288 magic = BCRYPT_ECDSA_PUBLIC_P384_MAGIC;
1289 break;
1290
1291 default:
1292 FIXME( "algorithm %u does not yet support importing blob of type %s\n", alg->id, debugstr_w(type) );
1293 return STATUS_NOT_SUPPORTED;
1294 }
1295
1296 if (ecc_blob->dwMagic != magic) return STATUS_INVALID_PARAMETER;
1297 if (ecc_blob->cbKey != key_size || input_len < sizeof(*ecc_blob) + ecc_blob->cbKey * 2)
1298 return STATUS_INVALID_PARAMETER;
1299
1300 size = sizeof(*ecc_blob) + ecc_blob->cbKey * 2;
1301 return key_asymmetric_create( (struct key **)ret_key, alg, key_size * 8, (BYTE *)ecc_blob, size );
1302 }
1303 else if (!wcscmp( type, BCRYPT_ECCPRIVATE_BLOB ))
1304 {
1305 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)input;
1306 DWORD key_size, magic;
1307
1308 if (input_len < sizeof(*ecc_blob)) return STATUS_INVALID_PARAMETER;
1309
1310 switch (alg->id)
1311 {
1312 case ALG_ID_ECDH_P256:
1313 key_size = 32;
1314 magic = BCRYPT_ECDH_PRIVATE_P256_MAGIC;
1315 break;
1316 case ALG_ID_ECDSA_P256:
1317 key_size = 32;
1318 magic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
1319 break;
1320
1321 default:
1322 FIXME( "algorithm %u does not yet support importing blob of type %s\n", alg->id, debugstr_w(type) );
1323 return STATUS_NOT_SUPPORTED;
1324 }
1325
1326 if (ecc_blob->dwMagic != magic) return STATUS_INVALID_PARAMETER;
1327 if (ecc_blob->cbKey != key_size || input_len < sizeof(*ecc_blob) + ecc_blob->cbKey * 3)
1328 return STATUS_INVALID_PARAMETER;
1329
1330 if ((status = key_asymmetric_create( &key, alg, key_size * 8, NULL, 0 ))) return status;
1331 if ((status = key_funcs->key_import_ecc( key, input, input_len )))
1332 {
1333 BCryptDestroyKey( key );
1334 return status;
1335 }
1336
1337 *ret_key = key;
1338 return STATUS_SUCCESS;
1339 }
1340 else if (!wcscmp( type, BCRYPT_RSAPUBLIC_BLOB ))
1341 {
1342 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)input;
1343 ULONG size;
1344
1345 if (input_len < sizeof(*rsa_blob)) return STATUS_INVALID_PARAMETER;
1346 if ((alg->id != ALG_ID_RSA && alg->id != ALG_ID_RSA_SIGN) || rsa_blob->Magic != BCRYPT_RSAPUBLIC_MAGIC)
1347 return STATUS_NOT_SUPPORTED;
1348
1349 size = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus;
1350 return key_asymmetric_create( (struct key **)ret_key, alg, rsa_blob->BitLength, (BYTE *)rsa_blob, size );
1351 }
1352 else if (!wcscmp( type, BCRYPT_RSAPRIVATE_BLOB ))
1353 {
1354 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)input;
1355 ULONG size;
1356
1357 if (input_len < sizeof(*rsa_blob)) return STATUS_INVALID_PARAMETER;
1358 if (alg->id != ALG_ID_RSA || rsa_blob->Magic != BCRYPT_RSAPRIVATE_MAGIC)
1359 return STATUS_NOT_SUPPORTED;
1360
1361 size = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus;
1362 if ((status = key_asymmetric_create( &key, alg, rsa_blob->BitLength, (BYTE *)rsa_blob, size )))
1363 return status;
1364 if ((status = key_funcs->key_import_rsa( key, input, input_len )))
1365 {
1366 BCryptDestroyKey( key );
1367 return status;
1368 }
1369
1370 *ret_key = key;
1371 return STATUS_SUCCESS;
1372 }
1373 else if (!wcscmp( type, BCRYPT_DSA_PUBLIC_BLOB ))
1374 {
1375 BCRYPT_DSA_KEY_BLOB *dsa_blob = (BCRYPT_DSA_KEY_BLOB *)input;
1376 ULONG size;
1377
1378 if (input_len < sizeof(*dsa_blob)) return STATUS_INVALID_PARAMETER;
1379 if ((alg->id != ALG_ID_DSA) || dsa_blob->dwMagic != BCRYPT_DSA_PUBLIC_MAGIC)
1380 return STATUS_NOT_SUPPORTED;
1381
1382 size = sizeof(*dsa_blob) + dsa_blob->cbKey * 3;
1383 return key_asymmetric_create( (struct key **)ret_key, alg, dsa_blob->cbKey * 8, (BYTE *)dsa_blob, size );
1384 }
1385 else if (!wcscmp( type, LEGACY_DSA_V2_PRIVATE_BLOB ))
1386 {
1387 BLOBHEADER *hdr = (BLOBHEADER *)input;
1388 DSSPUBKEY *pubkey;
1389
1390 if (input_len < sizeof(*hdr)) return STATUS_INVALID_PARAMETER;
1391
1392 if (hdr->bType != PRIVATEKEYBLOB && hdr->bVersion != 2 && hdr->aiKeyAlg != CALG_DSS_SIGN)
1393 {
1394 FIXME( "blob type %u version %u alg id %u not supported\n", hdr->bType, hdr->bVersion, hdr->aiKeyAlg );
1395 return STATUS_NOT_SUPPORTED;
1396 }
1397 if (alg->id != ALG_ID_DSA)
1398 {
1399 FIXME( "algorithm %u does not support importing blob of type %s\n", alg->id, debugstr_w(type) );
1400 return STATUS_NOT_SUPPORTED;
1401 }
1402
1403 if (input_len < sizeof(*hdr) + sizeof(*pubkey)) return STATUS_INVALID_PARAMETER;
1404 pubkey = (DSSPUBKEY *)(hdr + 1);
1405 if (pubkey->magic != MAGIC_DSS2) return STATUS_NOT_SUPPORTED;
1406
1407 if (input_len < sizeof(*hdr) + sizeof(*pubkey) + (pubkey->bitlen / 8) * 2 + 40 + sizeof(DSSSEED))
1408 return STATUS_INVALID_PARAMETER;
1409
1410 if ((status = key_asymmetric_create( &key, alg, pubkey->bitlen, NULL, 0 ))) return status;
1411 if ((status = key_funcs->key_import_dsa_capi( key, input, input_len )))
1412 {
1413 BCryptDestroyKey( key );
1414 return status;
1415 }
1416
1417 *ret_key = key;
1418 return STATUS_SUCCESS;
1419 }
1420 else if (!wcscmp( type, LEGACY_DSA_V2_PUBLIC_BLOB )) /* not supported on native */
1421 {
1422 BLOBHEADER *hdr = (BLOBHEADER *)input;
1423 DSSPUBKEY *pubkey;
1424 ULONG size;
1425
1426 if (alg->id != ALG_ID_DSA) return STATUS_NOT_SUPPORTED;
1427 if (input_len < sizeof(*hdr)) return STATUS_INVALID_PARAMETER;
1428
1429 if (hdr->bType != PUBLICKEYBLOB && hdr->bVersion != 2 && hdr->aiKeyAlg != CALG_DSS_SIGN)
1430 {
1431 FIXME( "blob type %u version %u alg id %u not supported\n", hdr->bType, hdr->bVersion, hdr->aiKeyAlg );
1432 return STATUS_NOT_SUPPORTED;
1433 }
1434
1435 if (input_len < sizeof(*hdr) + sizeof(*pubkey)) return STATUS_INVALID_PARAMETER;
1436 pubkey = (DSSPUBKEY *)(hdr + 1);
1437 if (pubkey->magic != MAGIC_DSS1) return STATUS_NOT_SUPPORTED;
1438
1439 size = sizeof(*hdr) + sizeof(*pubkey) + (pubkey->bitlen / 8) * 3 + 20 + sizeof(DSSSEED);
1440 if (input_len < size) return STATUS_INVALID_PARAMETER;
1441
1442 if ((status = key_asymmetric_create( &key, alg, pubkey->bitlen, (BYTE *)hdr, size ))) return status;
1443 key->u.a.flags |= KEY_FLAG_LEGACY_DSA_V2;
1444
1445 *ret_key = key;
1446 return STATUS_SUCCESS;
1447 }
1448
1449 FIXME( "unsupported key type %s\n", debugstr_w(type) );
1450 return STATUS_NOT_SUPPORTED;
1451 }
1452
1453 static ULONG get_block_size( struct algorithm *alg )
1454 {
1455 ULONG ret = 0, size = sizeof(ret);
1456 get_alg_property( alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&ret, sizeof(ret), &size );
1457 return ret;
1458 }
1459
1460 NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle,
1461 UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len,
1462 ULONG flags )
1463 {
1464 struct algorithm *alg = algorithm;
1465 struct key *key;
1466 ULONG block_size;
1467 NTSTATUS status;
1468
1469 TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", algorithm, handle, object, object_len, secret, secret_len, flags );
1470
1471 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1472 if (object) FIXME( "ignoring object buffer\n" );
1473
1474 if (!key_funcs)
1475 {
1476 ERR( "no encryption support\n" );
1477 return STATUS_NOT_IMPLEMENTED;
1478 }
1479
1480 if (!(block_size = get_block_size( alg ))) return STATUS_INVALID_PARAMETER;
1481
1482 if (!(key = heap_alloc_zero( sizeof(*key) ))) return STATUS_NO_MEMORY;
1483 key->hdr.magic = MAGIC_KEY;
1484 key->alg_id = alg->id;
1485 key->u.s.mode = alg->mode;
1486 key->u.s.block_size = block_size;
1487
1488 if (!(key->u.s.secret = heap_alloc( secret_len )))
1489 {
1490 heap_free( key );
1491 return STATUS_NO_MEMORY;
1492 }
1493 memcpy( key->u.s.secret, secret, secret_len );
1494 key->u.s.secret_len = secret_len;
1495
1496 if ((status = key_funcs->key_symmetric_init( key )))
1497 {
1498 heap_free( key->u.s.secret );
1499 heap_free( key );
1500 return status;
1501 }
1502
1503 *handle = key;
1504 return STATUS_SUCCESS;
1505 }
1506
1507 NTSTATUS WINAPI BCryptGenerateKeyPair( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle, ULONG key_len,
1508 ULONG flags )
1509 {
1510 struct algorithm *alg = algorithm;
1511 struct key *key;
1512 NTSTATUS status;
1513
1514 TRACE( "%p, %p, %u, %08x\n", algorithm, handle, key_len, flags );
1515
1516 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1517 if (!handle) return STATUS_INVALID_PARAMETER;
1518
1519 if (!(status = key_asymmetric_create( &key, alg, key_len, NULL, 0 ))) *handle = key;
1520 return status;
1521 }
1522
1523 NTSTATUS WINAPI BCryptFinalizeKeyPair( BCRYPT_KEY_HANDLE handle, ULONG flags )
1524 {
1525 struct key *key = handle;
1526
1527 TRACE( "%p, %08x\n", key, flags );
1528 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1529
1530 return key_funcs->key_asymmetric_generate( key );
1531 }
1532
1533 NTSTATUS WINAPI BCryptImportKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE decrypt_key, LPCWSTR type,
1534 BCRYPT_KEY_HANDLE *key, PUCHAR object, ULONG object_len, PUCHAR input,
1535 ULONG input_len, ULONG flags )
1536 {
1537 struct algorithm *alg = algorithm;
1538
1539 TRACE("%p, %p, %s, %p, %p, %u, %p, %u, %u\n", algorithm, decrypt_key, debugstr_w(type), key, object,
1540 object_len, input, input_len, flags);
1541
1542 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1543 if (!key || !type || !input) return STATUS_INVALID_PARAMETER;
1544
1545 if (decrypt_key)
1546 {
1547 FIXME( "decryption of key not yet supported\n" );
1548 return STATUS_NOT_IMPLEMENTED;
1549 }
1550
1551 return key_import( algorithm, type, key, object, object_len, input, input_len );
1552 }
1553
1554 NTSTATUS WINAPI BCryptExportKey( BCRYPT_KEY_HANDLE export_key, BCRYPT_KEY_HANDLE encrypt_key, LPCWSTR type,
1555 PUCHAR output, ULONG output_len, ULONG *size, ULONG flags )
1556 {
1557 struct key *key = export_key;
1558
1559 TRACE("%p, %p, %s, %p, %u, %p, %u\n", key, encrypt_key, debugstr_w(type), output, output_len, size, flags);
1560
1561 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1562 if (!type || !size) return STATUS_INVALID_PARAMETER;
1563
1564 if (encrypt_key)
1565 {
1566 FIXME( "encryption of key not yet supported\n" );
1567 return STATUS_NOT_IMPLEMENTED;
1568 }
1569
1570 return key_export( key, type, output, output_len, size );
1571 }
1572
1573 static NTSTATUS key_duplicate( struct key *key_orig, struct key *key_copy )
1574 {
1575 UCHAR *buffer;
1576 NTSTATUS status;
1577
1578 memset( key_copy, 0, sizeof(*key_copy) );
1579 key_copy->hdr = key_orig->hdr;
1580 key_copy->alg_id = key_orig->alg_id;
1581
1582 if (key_is_symmetric( key_orig ))
1583 {
1584 if (!(buffer = heap_alloc( key_orig->u.s.secret_len ))) return STATUS_NO_MEMORY;
1585 memcpy( buffer, key_orig->u.s.secret, key_orig->u.s.secret_len );
1586
1587 key_copy->u.s.mode = key_orig->u.s.mode;
1588 key_copy->u.s.block_size = key_orig->u.s.block_size;
1589 key_copy->u.s.secret = buffer;
1590 key_copy->u.s.secret_len = key_orig->u.s.secret_len;
1591 }
1592 else
1593 {
1594 if (!(buffer = heap_alloc( key_orig->u.a.pubkey_len ))) return STATUS_NO_MEMORY;
1595 memcpy( buffer, key_orig->u.a.pubkey, key_orig->u.a.pubkey_len );
1596
1597 key_copy->u.a.bitlen = key_orig->u.a.bitlen;
1598 key_copy->u.a.flags = key_orig->u.a.flags;
1599 key_copy->u.a.pubkey = buffer;
1600 key_copy->u.a.pubkey_len = key_orig->u.a.pubkey_len;
1601 key_copy->u.a.dss_seed = key_orig->u.a.dss_seed;
1602
1603 if ((status = key_funcs->key_asymmetric_duplicate( key_orig, key_copy ))) return status;
1604 }
1605
1606 return STATUS_SUCCESS;
1607 }
1608
1609 static void key_destroy( struct key *key )
1610 {
1611 if (key_is_symmetric( key ))
1612 {
1613 key_funcs->key_symmetric_destroy( key );
1614 heap_free( key->u.s.vector );
1615 heap_free( key->u.s.secret );
1616 }
1617 else
1618 {
1619 key_funcs->key_asymmetric_destroy( key );
1620 heap_free( key->u.a.pubkey );
1621 }
1622 key->hdr.magic = 0;
1623 heap_free( key );
1624 }
1625
1626 NTSTATUS WINAPI BCryptDuplicateKey( BCRYPT_KEY_HANDLE handle, BCRYPT_KEY_HANDLE *handle_copy,
1627 UCHAR *object, ULONG object_len, ULONG flags )
1628 {
1629 struct key *key_orig = handle;
1630 struct key *key_copy;
1631 NTSTATUS status;
1632
1633 TRACE( "%p, %p, %p, %u, %08x\n", handle, handle_copy, object, object_len, flags );
1634 if (object) FIXME( "ignoring object buffer\n" );
1635
1636 if (!key_orig || key_orig->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1637 if (!handle_copy) return STATUS_INVALID_PARAMETER;
1638 if (!(key_copy = heap_alloc( sizeof(*key_copy) ))) return STATUS_NO_MEMORY;
1639
1640 if ((status = key_duplicate( key_orig, key_copy )))
1641 {
1642 key_destroy( key_copy );
1643 return status;
1644 }
1645
1646 *handle_copy = key_copy;
1647 return STATUS_SUCCESS;
1648 }
1649
1650 NTSTATUS WINAPI BCryptImportKeyPair( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE decrypt_key, const WCHAR *type,
1651 BCRYPT_KEY_HANDLE *ret_key, UCHAR *input, ULONG input_len, ULONG flags )
1652 {
1653 struct algorithm *alg = algorithm;
1654
1655 TRACE( "%p, %p, %s, %p, %p, %u, %08x\n", algorithm, decrypt_key, debugstr_w(type), ret_key, input,
1656 input_len, flags );
1657
1658 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1659 if (!ret_key || !type || !input) return STATUS_INVALID_PARAMETER;
1660 if (decrypt_key)
1661 {
1662 FIXME( "decryption of key not yet supported\n" );
1663 return STATUS_NOT_IMPLEMENTED;
1664 }
1665
1666 return key_import_pair( alg, type, ret_key, input, input_len );
1667 }
1668
1669 NTSTATUS WINAPI BCryptSignHash( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *input, ULONG input_len,
1670 UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1671 {
1672 struct key *key = handle;
1673
1674 TRACE( "%p, %p, %p, %u, %p, %u, %p, %08x\n", handle, padding, input, input_len, output, output_len,
1675 ret_len, flags );
1676
1677 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1678 if (key_is_symmetric( key ))
1679 {
1680 FIXME( "signing with symmetric keys not yet supported\n" );
1681 return STATUS_NOT_IMPLEMENTED;
1682 }
1683
1684 return key_funcs->key_asymmetric_sign( key, padding, input, input_len, output, output_len, ret_len, flags );
1685 }
1686
1687 NTSTATUS WINAPI BCryptVerifySignature( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len,
1688 UCHAR *signature, ULONG signature_len, ULONG flags )
1689 {
1690 struct key *key = handle;
1691
1692 TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", handle, padding, hash, hash_len, signature, signature_len, flags );
1693
1694 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1695 if (!hash || !hash_len || !signature || !signature_len) return STATUS_INVALID_PARAMETER;
1696 if (key_is_symmetric( key )) return STATUS_NOT_SUPPORTED;
1697
1698 return key_funcs->key_asymmetric_verify( key, padding, hash, hash_len, signature, signature_len, flags );
1699 }
1700
1701 NTSTATUS WINAPI BCryptDestroyKey( BCRYPT_KEY_HANDLE handle )
1702 {
1703 struct key *key = handle;
1704
1705 TRACE( "%p\n", handle );
1706
1707 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1708
1709 key_destroy( key );
1710 return STATUS_SUCCESS;
1711 }
1712
1713 NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1714 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1715 {
1716 struct key *key = handle;
1717
1718 TRACE( "%p, %p, %u, %p, %p, %u, %p, %u, %p, %08x\n", handle, input, input_len, padding, iv, iv_len, output,
1719 output_len, ret_len, flags );
1720
1721 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1722 if (!key_is_symmetric( key ))
1723 {
1724 FIXME( "encryption with asymmetric keys not yet supported\n" );
1725 return STATUS_NOT_IMPLEMENTED;
1726 }
1727 if (flags & ~BCRYPT_BLOCK_PADDING)
1728 {
1729 FIXME( "flags %08x not implemented\n", flags );
1730 return STATUS_NOT_IMPLEMENTED;
1731 }
1732
1733 return key_encrypt( key, input, input_len, padding, iv, iv_len, output, output_len, ret_len, flags );
1734 }
1735
1736 NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1737 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1738 {
1739 struct key *key = handle;
1740
1741 TRACE( "%p, %p, %u, %p, %p, %u, %p, %u, %p, %08x\n", handle, input, input_len, padding, iv, iv_len, output,
1742 output_len, ret_len, flags );
1743
1744 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1745 if (!key_is_symmetric( key ))
1746 {
1747 FIXME( "decryption with asymmetric keys not yet supported\n" );
1748 return STATUS_NOT_IMPLEMENTED;
1749 }
1750 if (flags & ~BCRYPT_BLOCK_PADDING)
1751 {
1752 FIXME( "flags %08x not supported\n", flags );
1753 return STATUS_NOT_IMPLEMENTED;
1754 }
1755
1756 return key_decrypt( key, input, input_len, padding, iv, iv_len, output, output_len, ret_len, flags );
1757 }
1758
1759 NTSTATUS WINAPI BCryptSetProperty( BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
1760 {
1761 struct object *object = handle;
1762
1763 TRACE( "%p, %s, %p, %u, %08x\n", handle, debugstr_w(prop), value, size, flags );
1764
1765 if (!object) return STATUS_INVALID_HANDLE;
1766
1767 switch (object->magic)
1768 {
1769 case MAGIC_ALG:
1770 {
1771 struct algorithm *alg = (struct algorithm *)object;
1772 return set_alg_property( alg, prop, value, size, flags );
1773 }
1774 case MAGIC_KEY:
1775 {
1776 struct key *key = (struct key *)object;
1777 return key_funcs->key_set_property( key, prop, value, size, flags );
1778 }
1779 default:
1780 WARN( "unknown magic %08x\n", object->magic );
1781 return STATUS_INVALID_HANDLE;
1782 }
1783 }
1784
1785 #define HMAC_PAD_LEN 64
1786 NTSTATUS WINAPI BCryptDeriveKeyCapi( BCRYPT_HASH_HANDLE handle, BCRYPT_ALG_HANDLE halg, UCHAR *key, ULONG keylen, ULONG flags )
1787 {
1788 struct hash *hash = handle;
1789 UCHAR buf[MAX_HASH_OUTPUT_BYTES * 2];
1790 NTSTATUS status;
1791 ULONG len;
1792
1793 TRACE( "%p, %p, %p, %u, %08x\n", handle, halg, key, keylen, flags );
1794
1795 if (!key || !keylen) return STATUS_INVALID_PARAMETER;
1796 if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
1797 if (keylen > builtin_algorithms[hash->alg_id].hash_length * 2) return STATUS_INVALID_PARAMETER;
1798
1799 if (halg)
1800 {
1801 FIXME( "algorithm handle not supported\n" );
1802 return STATUS_NOT_IMPLEMENTED;
1803 }
1804
1805 len = builtin_algorithms[hash->alg_id].hash_length;
1806 if ((status = hash_finalize( hash, buf, len ))) return status;
1807
1808 if (len < keylen)
1809 {
1810 UCHAR pad1[HMAC_PAD_LEN], pad2[HMAC_PAD_LEN];
1811 ULONG i;
1812
1813 for (i = 0; i < sizeof(pad1); i++)
1814 {
1815 pad1[i] = 0x36 ^ (i < len ? buf[i] : 0);
1816 pad2[i] = 0x5c ^ (i < len ? buf[i] : 0);
1817 }
1818
1819 if ((status = hash_prepare( hash )) ||
1820 (status = hash_update( &hash->inner, hash->alg_id, pad1, sizeof(pad1) )) ||
1821 (status = hash_finalize( hash, buf, len ))) return status;
1822
1823 if ((status = hash_prepare( hash )) ||
1824 (status = hash_update( &hash->inner, hash->alg_id, pad2, sizeof(pad2) )) ||
1825 (status = hash_finalize( hash, buf + len, len ))) return status;
1826 }
1827
1828 memcpy( key, buf, keylen );
1829 return STATUS_SUCCESS;
1830 }
1831
1832 static NTSTATUS pbkdf2( struct hash *hash, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len,
1833 ULONGLONG iterations, ULONG i, UCHAR *dst, ULONG hash_len )
1834 {
1835 NTSTATUS status = STATUS_INVALID_PARAMETER;
1836 UCHAR bytes[4], *buf;
1837 ULONG j, k;
1838
1839 if (!(buf = heap_alloc( hash_len ))) return STATUS_NO_MEMORY;
1840
1841 for (j = 0; j < iterations; j++)
1842 {
1843 if (j == 0)
1844 {
1845 /* use salt || INT(i) */
1846 if ((status = hash_update( &hash->inner, hash->alg_id, salt, salt_len )))
1847 {
1848 heap_free( buf );
1849 return status;
1850 }
1851 bytes[0] = (i >> 24) & 0xff;
1852 bytes[1] = (i >> 16) & 0xff;
1853 bytes[2] = (i >> 8) & 0xff;
1854 bytes[3] = i & 0xff;
1855 status = hash_update( &hash->inner, hash->alg_id, bytes, 4 );
1856 }
1857 else status = hash_update( &hash->inner, hash->alg_id, buf, hash_len ); /* use U_j */
1858
1859 if (status)
1860 {
1861 heap_free( buf );
1862 return status;
1863 }
1864
1865 if ((status = hash_finalize( hash, buf, hash_len )))
1866 {
1867 heap_free( buf );
1868 return status;
1869 }
1870
1871 if (j == 0) memcpy( dst, buf, hash_len );
1872 else for (k = 0; k < hash_len; k++) dst[k] ^= buf[k];
1873 }
1874
1875 heap_free( buf );
1876 return status;
1877 }
1878
1879 NTSTATUS WINAPI BCryptDeriveKeyPBKDF2( BCRYPT_ALG_HANDLE handle, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len,
1880 ULONGLONG iterations, UCHAR *dk, ULONG dk_len, ULONG flags )
1881 {
1882 struct algorithm *alg = handle;
1883 ULONG hash_len, block_count, bytes_left, i;
1884 struct hash *hash;
1885 UCHAR *partial;
1886 NTSTATUS status;
1887
1888 TRACE( "%p, %p, %u, %p, %u, %s, %p, %u, %08x\n", handle, pwd, pwd_len, salt, salt_len,
1889 wine_dbgstr_longlong(iterations), dk, dk_len, flags );
1890
1891 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1892
1893 hash_len = builtin_algorithms[alg->id].hash_length;
1894 if (dk_len <= 0 || dk_len > ((((ULONGLONG)1) << 32) - 1) * hash_len) return STATUS_INVALID_PARAMETER;
1895
1896 block_count = 1 + ((dk_len - 1) / hash_len); /* ceil(dk_len / hash_len) */
1897 bytes_left = dk_len - (block_count - 1) * hash_len;
1898
1899 if ((status = hash_create( alg, pwd, pwd_len, BCRYPT_HASH_REUSABLE_FLAG, &hash ))) return status;
1900
1901 /* full blocks */
1902 for (i = 1; i < block_count; i++)
1903 {
1904 if ((status = pbkdf2( hash, pwd, pwd_len, salt, salt_len, iterations, i, dk + ((i - 1) * hash_len), hash_len )))
1905 {
1906 hash_destroy( hash );
1907 return status;
1908 }
1909 }
1910
1911 /* final partial block */
1912 if (!(partial = heap_alloc( hash_len )))
1913 {
1914 hash_destroy( hash );
1915 return STATUS_NO_MEMORY;
1916 }
1917
1918 if ((status = pbkdf2( hash, pwd, pwd_len, salt, salt_len, iterations, block_count, partial, hash_len )))
1919 {
1920 hash_destroy( hash );
1921 heap_free( partial );
1922 return status;
1923 }
1924 memcpy( dk + ((block_count - 1) * hash_len), partial, bytes_left );
1925
1926 hash_destroy( hash );
1927 heap_free( partial );
1928 return STATUS_SUCCESS;
1929 }
1930
1931 NTSTATUS WINAPI BCryptSecretAgreement(BCRYPT_KEY_HANDLE privatekey, BCRYPT_KEY_HANDLE publickey, BCRYPT_SECRET_HANDLE *handle, ULONG flags)
1932 {
1933 struct key *privkey = privatekey;
1934 struct key *pubkey = publickey;
1935 struct secret *secret;
1936
1937 FIXME( "%p, %p, %p, %08x\n", privatekey, publickey, handle, flags );
1938
1939 if (!privkey || privkey->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1940 if (!pubkey || pubkey->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1941 if (!handle) return STATUS_INVALID_PARAMETER;
1942
1943 if (!(secret = heap_alloc_zero( sizeof(*secret) ))) return STATUS_NO_MEMORY;
1944 secret->hdr.magic = MAGIC_SECRET;
1945
1946 *handle = secret;
1947 return STATUS_SUCCESS;
1948 }
1949
1950 NTSTATUS WINAPI BCryptDestroySecret(BCRYPT_SECRET_HANDLE handle)
1951 {
1952 struct secret *secret = handle;
1953
1954 FIXME( "%p\n", handle );
1955
1956 if (!secret || secret->hdr.magic != MAGIC_SECRET) return STATUS_INVALID_HANDLE;
1957 secret->hdr.magic = 0;
1958 heap_free( secret );
1959 return STATUS_SUCCESS;
1960 }
1961
1962 NTSTATUS WINAPI BCryptDeriveKey(BCRYPT_SECRET_HANDLE handle, LPCWSTR kdf, BCryptBufferDesc *parameter,
1963 PUCHAR derived, ULONG derived_size, ULONG *result, ULONG flags)
1964 {
1965 struct secret *secret = handle;
1966
1967 FIXME( "%p, %s, %p, %p, %d, %p, %08x\n", secret, debugstr_w(kdf), parameter, derived, derived_size, result, flags );
1968
1969 if (!secret || secret->hdr.magic != MAGIC_SECRET) return STATUS_INVALID_HANDLE;
1970 if (!kdf) return STATUS_INVALID_PARAMETER;
1971
1972 return STATUS_INTERNAL_ERROR;
1973 }
1974
1975 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
1976 {
1977 switch (reason)
1978 {
1979 case DLL_PROCESS_ATTACH:
1980 instance = hinst;
1981 DisableThreadLibraryCalls( hinst );
1982 __wine_init_unix_lib( hinst, reason, NULL, &key_funcs );
1983 break;
1984 case DLL_PROCESS_DETACH:
1985 if (reserved) break;
1986 __wine_init_unix_lib( hinst, reason, NULL, NULL );
1987 break;
1988 }
1989 return TRUE;
1990 }
Windows API implementation