?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netapi32: Default to CP_UTF8 when WINEUNIXCP is not set.
[wine.git] / dlls / bcrypt / bcrypt_main.c
blob5eb50cd616bffa64bf9b6ae28b370f77049eb342
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_symmetric_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_import_pair( struct algorithm *alg, const WCHAR *type, BCRYPT_KEY_HANDLE *ret_key, UCHAR *input,
1244 ULONG input_len )
1245 {
1246 struct key *key;
1247 NTSTATUS status;
1248
1249 if (!wcscmp( type, BCRYPT_ECCPUBLIC_BLOB ))
1250 {
1251 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)input;
1252 DWORD key_size, magic, size;
1253
1254 if (input_len < sizeof(*ecc_blob)) return STATUS_INVALID_PARAMETER;
1255
1256 switch (alg->id)
1257 {
1258 case ALG_ID_ECDH_P256:
1259 key_size = 32;
1260 magic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
1261 break;
1262
1263 case ALG_ID_ECDSA_P256:
1264 key_size = 32;
1265 magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
1266 break;
1267
1268 case ALG_ID_ECDSA_P384:
1269 key_size = 48;
1270 magic = BCRYPT_ECDSA_PUBLIC_P384_MAGIC;
1271 break;
1272
1273 default:
1274 FIXME( "algorithm %u does not yet support importing blob of type %s\n", alg->id, debugstr_w(type) );
1275 return STATUS_NOT_SUPPORTED;
1276 }
1277
1278 if (ecc_blob->dwMagic != magic) return STATUS_INVALID_PARAMETER;
1279 if (ecc_blob->cbKey != key_size || input_len < sizeof(*ecc_blob) + ecc_blob->cbKey * 2)
1280 return STATUS_INVALID_PARAMETER;
1281
1282 size = sizeof(*ecc_blob) + ecc_blob->cbKey * 2;
1283 return key_asymmetric_create( (struct key **)ret_key, alg, key_size * 8, (BYTE *)ecc_blob, size );
1284 }
1285 else if (!wcscmp( type, BCRYPT_ECCPRIVATE_BLOB ))
1286 {
1287 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)input;
1288 DWORD key_size, magic;
1289
1290 if (input_len < sizeof(*ecc_blob)) return STATUS_INVALID_PARAMETER;
1291
1292 switch (alg->id)
1293 {
1294 case ALG_ID_ECDH_P256:
1295 key_size = 32;
1296 magic = BCRYPT_ECDH_PRIVATE_P256_MAGIC;
1297 break;
1298 case ALG_ID_ECDSA_P256:
1299 key_size = 32;
1300 magic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
1301 break;
1302
1303 default:
1304 FIXME( "algorithm %u does not yet support importing blob of type %s\n", alg->id, debugstr_w(type) );
1305 return STATUS_NOT_SUPPORTED;
1306 }
1307
1308 if (ecc_blob->dwMagic != magic) return STATUS_INVALID_PARAMETER;
1309 if (ecc_blob->cbKey != key_size || input_len < sizeof(*ecc_blob) + ecc_blob->cbKey * 3)
1310 return STATUS_INVALID_PARAMETER;
1311
1312 if ((status = key_asymmetric_create( &key, alg, key_size * 8, NULL, 0 ))) return status;
1313 if ((status = key_funcs->key_import_ecc( key, input, input_len )))
1314 {
1315 BCryptDestroyKey( key );
1316 return status;
1317 }
1318
1319 *ret_key = key;
1320 return STATUS_SUCCESS;
1321 }
1322 else if (!wcscmp( type, BCRYPT_RSAPUBLIC_BLOB ))
1323 {
1324 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)input;
1325 ULONG size;
1326
1327 if (input_len < sizeof(*rsa_blob)) return STATUS_INVALID_PARAMETER;
1328 if ((alg->id != ALG_ID_RSA && alg->id != ALG_ID_RSA_SIGN) || rsa_blob->Magic != BCRYPT_RSAPUBLIC_MAGIC)
1329 return STATUS_NOT_SUPPORTED;
1330
1331 size = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus;
1332 return key_asymmetric_create( (struct key **)ret_key, alg, rsa_blob->BitLength, (BYTE *)rsa_blob, size );
1333 }
1334 else if (!wcscmp( type, BCRYPT_RSAPRIVATE_BLOB ))
1335 {
1336 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)input;
1337 ULONG size;
1338
1339 if (input_len < sizeof(*rsa_blob)) return STATUS_INVALID_PARAMETER;
1340 if (alg->id != ALG_ID_RSA || rsa_blob->Magic != BCRYPT_RSAPRIVATE_MAGIC)
1341 return STATUS_NOT_SUPPORTED;
1342
1343 size = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus;
1344 if ((status = key_asymmetric_create( &key, alg, rsa_blob->BitLength, (BYTE *)rsa_blob, size )))
1345 return status;
1346 if ((status = key_funcs->key_import_rsa( key, input, input_len )))
1347 {
1348 BCryptDestroyKey( key );
1349 return status;
1350 }
1351
1352 *ret_key = key;
1353 return STATUS_SUCCESS;
1354 }
1355 else if (!wcscmp( type, BCRYPT_DSA_PUBLIC_BLOB ))
1356 {
1357 BCRYPT_DSA_KEY_BLOB *dsa_blob = (BCRYPT_DSA_KEY_BLOB *)input;
1358 ULONG size;
1359
1360 if (input_len < sizeof(*dsa_blob)) return STATUS_INVALID_PARAMETER;
1361 if ((alg->id != ALG_ID_DSA) || dsa_blob->dwMagic != BCRYPT_DSA_PUBLIC_MAGIC)
1362 return STATUS_NOT_SUPPORTED;
1363
1364 size = sizeof(*dsa_blob) + dsa_blob->cbKey * 3;
1365 return key_asymmetric_create( (struct key **)ret_key, alg, dsa_blob->cbKey * 8, (BYTE *)dsa_blob, size );
1366 }
1367 else if (!wcscmp( type, LEGACY_DSA_V2_PRIVATE_BLOB ))
1368 {
1369 BLOBHEADER *hdr = (BLOBHEADER *)input;
1370 DSSPUBKEY *pubkey;
1371
1372 if (input_len < sizeof(*hdr)) return STATUS_INVALID_PARAMETER;
1373
1374 if (hdr->bType != PRIVATEKEYBLOB && hdr->bVersion != 2 && hdr->aiKeyAlg != CALG_DSS_SIGN)
1375 {
1376 FIXME( "blob type %u version %u alg id %u not supported\n", hdr->bType, hdr->bVersion, hdr->aiKeyAlg );
1377 return STATUS_NOT_SUPPORTED;
1378 }
1379 if (alg->id != ALG_ID_DSA)
1380 {
1381 FIXME( "algorithm %u does not support importing blob of type %s\n", alg->id, debugstr_w(type) );
1382 return STATUS_NOT_SUPPORTED;
1383 }
1384
1385 if (input_len < sizeof(*hdr) + sizeof(*pubkey)) return STATUS_INVALID_PARAMETER;
1386 pubkey = (DSSPUBKEY *)(hdr + 1);
1387 if (pubkey->magic != MAGIC_DSS2) return STATUS_NOT_SUPPORTED;
1388
1389 if (input_len < sizeof(*hdr) + sizeof(*pubkey) + (pubkey->bitlen / 8) * 2 + 40 + sizeof(DSSSEED))
1390 return STATUS_INVALID_PARAMETER;
1391
1392 if ((status = key_asymmetric_create( &key, alg, pubkey->bitlen, NULL, 0 ))) return status;
1393 if ((status = key_funcs->key_import_dsa_capi( key, input, input_len )))
1394 {
1395 BCryptDestroyKey( key );
1396 return status;
1397 }
1398
1399 *ret_key = key;
1400 return STATUS_SUCCESS;
1401 }
1402 else if (!wcscmp( type, LEGACY_DSA_V2_PUBLIC_BLOB )) /* not supported on native */
1403 {
1404 BLOBHEADER *hdr = (BLOBHEADER *)input;
1405 DSSPUBKEY *pubkey;
1406 ULONG size;
1407
1408 if (alg->id != ALG_ID_DSA) return STATUS_NOT_SUPPORTED;
1409 if (input_len < sizeof(*hdr)) return STATUS_INVALID_PARAMETER;
1410
1411 if (hdr->bType != PUBLICKEYBLOB && hdr->bVersion != 2 && hdr->aiKeyAlg != CALG_DSS_SIGN)
1412 {
1413 FIXME( "blob type %u version %u alg id %u not supported\n", hdr->bType, hdr->bVersion, hdr->aiKeyAlg );
1414 return STATUS_NOT_SUPPORTED;
1415 }
1416
1417 if (input_len < sizeof(*hdr) + sizeof(*pubkey)) return STATUS_INVALID_PARAMETER;
1418 pubkey = (DSSPUBKEY *)(hdr + 1);
1419 if (pubkey->magic != MAGIC_DSS1) return STATUS_NOT_SUPPORTED;
1420
1421 size = sizeof(*hdr) + sizeof(*pubkey) + (pubkey->bitlen / 8) * 3 + 20 + sizeof(DSSSEED);
1422 if (input_len < size) return STATUS_INVALID_PARAMETER;
1423
1424 if ((status = key_asymmetric_create( &key, alg, pubkey->bitlen, (BYTE *)hdr, size ))) return status;
1425 key->u.a.flags |= KEY_FLAG_LEGACY_DSA_V2;
1426
1427 *ret_key = key;
1428 return STATUS_SUCCESS;
1429 }
1430
1431 FIXME( "unsupported key type %s\n", debugstr_w(type) );
1432 return STATUS_NOT_SUPPORTED;
1433 }
1434
1435 static ULONG get_block_size( struct algorithm *alg )
1436 {
1437 ULONG ret = 0, size = sizeof(ret);
1438 get_alg_property( alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&ret, sizeof(ret), &size );
1439 return ret;
1440 }
1441
1442 NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle,
1443 UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len,
1444 ULONG flags )
1445 {
1446 struct algorithm *alg = algorithm;
1447 struct key *key;
1448 ULONG block_size;
1449 NTSTATUS status;
1450
1451 TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", algorithm, handle, object, object_len, secret, secret_len, flags );
1452
1453 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1454 if (object) FIXME( "ignoring object buffer\n" );
1455
1456 if (!key_funcs)
1457 {
1458 ERR( "no encryption support\n" );
1459 return STATUS_NOT_IMPLEMENTED;
1460 }
1461
1462 if (!(block_size = get_block_size( alg ))) return STATUS_INVALID_PARAMETER;
1463
1464 if (!(key = heap_alloc_zero( sizeof(*key) ))) return STATUS_NO_MEMORY;
1465 InitializeCriticalSection( &key->u.s.cs );
1466 key->hdr.magic = MAGIC_KEY;
1467 key->alg_id = alg->id;
1468 key->u.s.mode = alg->mode;
1469 key->u.s.block_size = block_size;
1470
1471 if (!(key->u.s.secret = heap_alloc( secret_len )))
1472 {
1473 heap_free( key );
1474 return STATUS_NO_MEMORY;
1475 }
1476 memcpy( key->u.s.secret, secret, secret_len );
1477 key->u.s.secret_len = secret_len;
1478
1479 if ((status = key_funcs->key_symmetric_init( key )))
1480 {
1481 heap_free( key->u.s.secret );
1482 heap_free( key );
1483 return status;
1484 }
1485
1486 *handle = key;
1487 return STATUS_SUCCESS;
1488 }
1489
1490 NTSTATUS WINAPI BCryptGenerateKeyPair( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle, ULONG key_len,
1491 ULONG flags )
1492 {
1493 struct algorithm *alg = algorithm;
1494 struct key *key;
1495 NTSTATUS status;
1496
1497 TRACE( "%p, %p, %u, %08x\n", algorithm, handle, key_len, flags );
1498
1499 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1500 if (!handle) return STATUS_INVALID_PARAMETER;
1501
1502 if (!(status = key_asymmetric_create( &key, alg, key_len, NULL, 0 ))) *handle = key;
1503 return status;
1504 }
1505
1506 NTSTATUS WINAPI BCryptFinalizeKeyPair( BCRYPT_KEY_HANDLE handle, ULONG flags )
1507 {
1508 struct key *key = handle;
1509
1510 TRACE( "%p, %08x\n", key, flags );
1511 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1512
1513 return key_funcs->key_asymmetric_generate( key );
1514 }
1515
1516 NTSTATUS WINAPI BCryptImportKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE decrypt_key, LPCWSTR type,
1517 BCRYPT_KEY_HANDLE *key, PUCHAR object, ULONG object_len, PUCHAR input,
1518 ULONG input_len, ULONG flags )
1519 {
1520 struct algorithm *alg = algorithm;
1521
1522 TRACE("%p, %p, %s, %p, %p, %u, %p, %u, %u\n", algorithm, decrypt_key, debugstr_w(type), key, object,
1523 object_len, input, input_len, flags);
1524
1525 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1526 if (!key || !type || !input) return STATUS_INVALID_PARAMETER;
1527
1528 if (decrypt_key)
1529 {
1530 FIXME( "decryption of key not yet supported\n" );
1531 return STATUS_NOT_IMPLEMENTED;
1532 }
1533
1534 return key_import( algorithm, type, key, object, object_len, input, input_len );
1535 }
1536
1537 NTSTATUS WINAPI BCryptExportKey( BCRYPT_KEY_HANDLE export_key, BCRYPT_KEY_HANDLE encrypt_key, LPCWSTR type,
1538 PUCHAR output, ULONG output_len, ULONG *size, ULONG flags )
1539 {
1540 struct key *key = export_key;
1541
1542 TRACE("%p, %p, %s, %p, %u, %p, %u\n", key, encrypt_key, debugstr_w(type), output, output_len, size, flags);
1543
1544 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1545 if (!type || !size) return STATUS_INVALID_PARAMETER;
1546
1547 if (encrypt_key)
1548 {
1549 FIXME( "encryption of key not yet supported\n" );
1550 return STATUS_NOT_IMPLEMENTED;
1551 }
1552
1553 return key_export( key, type, output, output_len, size );
1554 }
1555
1556 static NTSTATUS key_duplicate( struct key *key_orig, struct key *key_copy )
1557 {
1558 UCHAR *buffer;
1559 NTSTATUS status;
1560
1561 memset( key_copy, 0, sizeof(*key_copy) );
1562 key_copy->hdr = key_orig->hdr;
1563 key_copy->alg_id = key_orig->alg_id;
1564
1565 if (key_is_symmetric( key_orig ))
1566 {
1567 if (!(buffer = heap_alloc( key_orig->u.s.secret_len ))) return STATUS_NO_MEMORY;
1568 memcpy( buffer, key_orig->u.s.secret, key_orig->u.s.secret_len );
1569
1570 key_copy->u.s.mode = key_orig->u.s.mode;
1571 key_copy->u.s.block_size = key_orig->u.s.block_size;
1572 key_copy->u.s.secret = buffer;
1573 key_copy->u.s.secret_len = key_orig->u.s.secret_len;
1574 InitializeCriticalSection( &key_copy->u.s.cs );
1575 }
1576 else
1577 {
1578 if (!(buffer = heap_alloc( key_orig->u.a.pubkey_len ))) return STATUS_NO_MEMORY;
1579 memcpy( buffer, key_orig->u.a.pubkey, key_orig->u.a.pubkey_len );
1580
1581 key_copy->u.a.bitlen = key_orig->u.a.bitlen;
1582 key_copy->u.a.flags = key_orig->u.a.flags;
1583 key_copy->u.a.pubkey = buffer;
1584 key_copy->u.a.pubkey_len = key_orig->u.a.pubkey_len;
1585 key_copy->u.a.dss_seed = key_orig->u.a.dss_seed;
1586
1587 if ((status = key_funcs->key_asymmetric_duplicate( key_orig, key_copy ))) return status;
1588 }
1589
1590 return STATUS_SUCCESS;
1591 }
1592
1593 static void key_destroy( struct key *key )
1594 {
1595 if (key_is_symmetric( key ))
1596 {
1597 key_funcs->key_symmetric_destroy( key );
1598 heap_free( key->u.s.vector );
1599 heap_free( key->u.s.secret );
1600 DeleteCriticalSection( &key->u.s.cs );
1601 }
1602 else
1603 {
1604 key_funcs->key_asymmetric_destroy( key );
1605 heap_free( key->u.a.pubkey );
1606 }
1607 key->hdr.magic = 0;
1608 heap_free( key );
1609 }
1610
1611 NTSTATUS WINAPI BCryptDuplicateKey( BCRYPT_KEY_HANDLE handle, BCRYPT_KEY_HANDLE *handle_copy,
1612 UCHAR *object, ULONG object_len, ULONG flags )
1613 {
1614 struct key *key_orig = handle;
1615 struct key *key_copy;
1616 NTSTATUS status;
1617
1618 TRACE( "%p, %p, %p, %u, %08x\n", handle, handle_copy, object, object_len, flags );
1619 if (object) FIXME( "ignoring object buffer\n" );
1620
1621 if (!key_orig || key_orig->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1622 if (!handle_copy) return STATUS_INVALID_PARAMETER;
1623 if (!(key_copy = heap_alloc( sizeof(*key_copy) ))) return STATUS_NO_MEMORY;
1624
1625 if ((status = key_duplicate( key_orig, key_copy )))
1626 {
1627 key_destroy( key_copy );
1628 return status;
1629 }
1630
1631 *handle_copy = key_copy;
1632 return STATUS_SUCCESS;
1633 }
1634
1635 NTSTATUS WINAPI BCryptImportKeyPair( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE decrypt_key, const WCHAR *type,
1636 BCRYPT_KEY_HANDLE *ret_key, UCHAR *input, ULONG input_len, ULONG flags )
1637 {
1638 struct algorithm *alg = algorithm;
1639
1640 TRACE( "%p, %p, %s, %p, %p, %u, %08x\n", algorithm, decrypt_key, debugstr_w(type), ret_key, input,
1641 input_len, flags );
1642
1643 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1644 if (!ret_key || !type || !input) return STATUS_INVALID_PARAMETER;
1645 if (decrypt_key)
1646 {
1647 FIXME( "decryption of key not yet supported\n" );
1648 return STATUS_NOT_IMPLEMENTED;
1649 }
1650
1651 return key_import_pair( alg, type, ret_key, input, input_len );
1652 }
1653
1654 NTSTATUS WINAPI BCryptSignHash( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *input, ULONG input_len,
1655 UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1656 {
1657 struct key *key = handle;
1658
1659 TRACE( "%p, %p, %p, %u, %p, %u, %p, %08x\n", handle, padding, input, input_len, output, output_len,
1660 ret_len, flags );
1661
1662 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1663 if (key_is_symmetric( key ))
1664 {
1665 FIXME( "signing with symmetric keys not yet supported\n" );
1666 return STATUS_NOT_IMPLEMENTED;
1667 }
1668
1669 return key_funcs->key_asymmetric_sign( key, padding, input, input_len, output, output_len, ret_len, flags );
1670 }
1671
1672 NTSTATUS WINAPI BCryptVerifySignature( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len,
1673 UCHAR *signature, ULONG signature_len, ULONG flags )
1674 {
1675 struct key *key = handle;
1676
1677 TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", handle, padding, hash, hash_len, signature, signature_len, flags );
1678
1679 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1680 if (!hash || !hash_len || !signature || !signature_len) return STATUS_INVALID_PARAMETER;
1681 if (key_is_symmetric( key )) return STATUS_NOT_SUPPORTED;
1682
1683 return key_funcs->key_asymmetric_verify( key, padding, hash, hash_len, signature, signature_len, flags );
1684 }
1685
1686 NTSTATUS WINAPI BCryptDestroyKey( BCRYPT_KEY_HANDLE handle )
1687 {
1688 struct key *key = handle;
1689
1690 TRACE( "%p\n", handle );
1691
1692 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1693
1694 key_destroy( key );
1695 return STATUS_SUCCESS;
1696 }
1697
1698 NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1699 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1700 {
1701 struct key *key = handle;
1702 NTSTATUS ret;
1703
1704 TRACE( "%p, %p, %u, %p, %p, %u, %p, %u, %p, %08x\n", handle, input, input_len, padding, iv, iv_len, output,
1705 output_len, ret_len, flags );
1706
1707 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1708 if (!key_is_symmetric( key ))
1709 {
1710 FIXME( "encryption with asymmetric keys not yet supported\n" );
1711 return STATUS_NOT_IMPLEMENTED;
1712 }
1713 if (flags & ~BCRYPT_BLOCK_PADDING)
1714 {
1715 FIXME( "flags %08x not implemented\n", flags );
1716 return STATUS_NOT_IMPLEMENTED;
1717 }
1718
1719 EnterCriticalSection( &key->u.s.cs );
1720 ret = key_symmetric_encrypt( key, input, input_len, padding, iv, iv_len, output, output_len, ret_len, flags );
1721 LeaveCriticalSection( &key->u.s.cs );
1722 return ret;
1723 }
1724
1725 NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv,
1726 ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags )
1727 {
1728 struct key *key = handle;
1729
1730 TRACE( "%p, %p, %u, %p, %p, %u, %p, %u, %p, %08x\n", handle, input, input_len, padding, iv, iv_len, output,
1731 output_len, ret_len, flags );
1732
1733 if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1734 if (flags & ~BCRYPT_BLOCK_PADDING)
1735 {
1736 FIXME( "flags %08x not supported\n", flags );
1737 return STATUS_NOT_IMPLEMENTED;
1738 }
1739
1740 if (key_is_symmetric( key ))
1741 {
1742 NTSTATUS ret;
1743 EnterCriticalSection( &key->u.s.cs );
1744 ret = key_symmetric_decrypt( key, input, input_len, padding, iv, iv_len, output, output_len, ret_len, flags );
1745 LeaveCriticalSection( &key->u.s.cs );
1746 return ret;
1747 }
1748
1749 return key_funcs->key_asymmetric_decrypt( key, input, input_len, output, output_len, ret_len );
1750 }
1751
1752 NTSTATUS WINAPI BCryptSetProperty( BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
1753 {
1754 struct object *object = handle;
1755
1756 TRACE( "%p, %s, %p, %u, %08x\n", handle, debugstr_w(prop), value, size, flags );
1757
1758 if (!object) return STATUS_INVALID_HANDLE;
1759
1760 switch (object->magic)
1761 {
1762 case MAGIC_ALG:
1763 {
1764 struct algorithm *alg = (struct algorithm *)object;
1765 return set_alg_property( alg, prop, value, size, flags );
1766 }
1767 case MAGIC_KEY:
1768 {
1769 struct key *key = (struct key *)object;
1770 return key_funcs->key_set_property( key, prop, value, size, flags );
1771 }
1772 default:
1773 WARN( "unknown magic %08x\n", object->magic );
1774 return STATUS_INVALID_HANDLE;
1775 }
1776 }
1777
1778 #define HMAC_PAD_LEN 64
1779 NTSTATUS WINAPI BCryptDeriveKeyCapi( BCRYPT_HASH_HANDLE handle, BCRYPT_ALG_HANDLE halg, UCHAR *key, ULONG keylen, ULONG flags )
1780 {
1781 struct hash *hash = handle;
1782 UCHAR buf[MAX_HASH_OUTPUT_BYTES * 2];
1783 NTSTATUS status;
1784 ULONG len;
1785
1786 TRACE( "%p, %p, %p, %u, %08x\n", handle, halg, key, keylen, flags );
1787
1788 if (!key || !keylen) return STATUS_INVALID_PARAMETER;
1789 if (!hash || hash->hdr.magic != MAGIC_HASH) return STATUS_INVALID_HANDLE;
1790 if (keylen > builtin_algorithms[hash->alg_id].hash_length * 2) return STATUS_INVALID_PARAMETER;
1791
1792 if (halg)
1793 {
1794 FIXME( "algorithm handle not supported\n" );
1795 return STATUS_NOT_IMPLEMENTED;
1796 }
1797
1798 len = builtin_algorithms[hash->alg_id].hash_length;
1799 if ((status = hash_finalize( hash, buf, len ))) return status;
1800
1801 if (len < keylen)
1802 {
1803 UCHAR pad1[HMAC_PAD_LEN], pad2[HMAC_PAD_LEN];
1804 ULONG i;
1805
1806 for (i = 0; i < sizeof(pad1); i++)
1807 {
1808 pad1[i] = 0x36 ^ (i < len ? buf[i] : 0);
1809 pad2[i] = 0x5c ^ (i < len ? buf[i] : 0);
1810 }
1811
1812 if ((status = hash_prepare( hash )) ||
1813 (status = hash_update( &hash->inner, hash->alg_id, pad1, sizeof(pad1) )) ||
1814 (status = hash_finalize( hash, buf, len ))) return status;
1815
1816 if ((status = hash_prepare( hash )) ||
1817 (status = hash_update( &hash->inner, hash->alg_id, pad2, sizeof(pad2) )) ||
1818 (status = hash_finalize( hash, buf + len, len ))) return status;
1819 }
1820
1821 memcpy( key, buf, keylen );
1822 return STATUS_SUCCESS;
1823 }
1824
1825 static NTSTATUS pbkdf2( struct hash *hash, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len,
1826 ULONGLONG iterations, ULONG i, UCHAR *dst, ULONG hash_len )
1827 {
1828 NTSTATUS status = STATUS_INVALID_PARAMETER;
1829 UCHAR bytes[4], *buf;
1830 ULONG j, k;
1831
1832 if (!(buf = heap_alloc( hash_len ))) return STATUS_NO_MEMORY;
1833
1834 for (j = 0; j < iterations; j++)
1835 {
1836 if (j == 0)
1837 {
1838 /* use salt || INT(i) */
1839 if ((status = hash_update( &hash->inner, hash->alg_id, salt, salt_len )))
1840 {
1841 heap_free( buf );
1842 return status;
1843 }
1844 bytes[0] = (i >> 24) & 0xff;
1845 bytes[1] = (i >> 16) & 0xff;
1846 bytes[2] = (i >> 8) & 0xff;
1847 bytes[3] = i & 0xff;
1848 status = hash_update( &hash->inner, hash->alg_id, bytes, 4 );
1849 }
1850 else status = hash_update( &hash->inner, hash->alg_id, buf, hash_len ); /* use U_j */
1851
1852 if (status)
1853 {
1854 heap_free( buf );
1855 return status;
1856 }
1857
1858 if ((status = hash_finalize( hash, buf, hash_len )))
1859 {
1860 heap_free( buf );
1861 return status;
1862 }
1863
1864 if (j == 0) memcpy( dst, buf, hash_len );
1865 else for (k = 0; k < hash_len; k++) dst[k] ^= buf[k];
1866 }
1867
1868 heap_free( buf );
1869 return status;
1870 }
1871
1872 NTSTATUS WINAPI BCryptDeriveKeyPBKDF2( BCRYPT_ALG_HANDLE handle, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len,
1873 ULONGLONG iterations, UCHAR *dk, ULONG dk_len, ULONG flags )
1874 {
1875 struct algorithm *alg = handle;
1876 ULONG hash_len, block_count, bytes_left, i;
1877 struct hash *hash;
1878 UCHAR *partial;
1879 NTSTATUS status;
1880
1881 TRACE( "%p, %p, %u, %p, %u, %s, %p, %u, %08x\n", handle, pwd, pwd_len, salt, salt_len,
1882 wine_dbgstr_longlong(iterations), dk, dk_len, flags );
1883
1884 if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE;
1885
1886 hash_len = builtin_algorithms[alg->id].hash_length;
1887 if (dk_len <= 0 || dk_len > ((((ULONGLONG)1) << 32) - 1) * hash_len) return STATUS_INVALID_PARAMETER;
1888
1889 block_count = 1 + ((dk_len - 1) / hash_len); /* ceil(dk_len / hash_len) */
1890 bytes_left = dk_len - (block_count - 1) * hash_len;
1891
1892 if ((status = hash_create( alg, pwd, pwd_len, BCRYPT_HASH_REUSABLE_FLAG, &hash ))) return status;
1893
1894 /* full blocks */
1895 for (i = 1; i < block_count; i++)
1896 {
1897 if ((status = pbkdf2( hash, pwd, pwd_len, salt, salt_len, iterations, i, dk + ((i - 1) * hash_len), hash_len )))
1898 {
1899 hash_destroy( hash );
1900 return status;
1901 }
1902 }
1903
1904 /* final partial block */
1905 if (!(partial = heap_alloc( hash_len )))
1906 {
1907 hash_destroy( hash );
1908 return STATUS_NO_MEMORY;
1909 }
1910
1911 if ((status = pbkdf2( hash, pwd, pwd_len, salt, salt_len, iterations, block_count, partial, hash_len )))
1912 {
1913 hash_destroy( hash );
1914 heap_free( partial );
1915 return status;
1916 }
1917 memcpy( dk + ((block_count - 1) * hash_len), partial, bytes_left );
1918
1919 hash_destroy( hash );
1920 heap_free( partial );
1921 return STATUS_SUCCESS;
1922 }
1923
1924 NTSTATUS WINAPI BCryptSecretAgreement(BCRYPT_KEY_HANDLE privatekey, BCRYPT_KEY_HANDLE publickey, BCRYPT_SECRET_HANDLE *handle, ULONG flags)
1925 {
1926 struct key *privkey = privatekey;
1927 struct key *pubkey = publickey;
1928 struct secret *secret;
1929
1930 FIXME( "%p, %p, %p, %08x\n", privatekey, publickey, handle, flags );
1931
1932 if (!privkey || privkey->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1933 if (!pubkey || pubkey->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE;
1934 if (!handle) return STATUS_INVALID_PARAMETER;
1935
1936 if (!(secret = heap_alloc_zero( sizeof(*secret) ))) return STATUS_NO_MEMORY;
1937 secret->hdr.magic = MAGIC_SECRET;
1938
1939 *handle = secret;
1940 return STATUS_SUCCESS;
1941 }
1942
1943 NTSTATUS WINAPI BCryptDestroySecret(BCRYPT_SECRET_HANDLE handle)
1944 {
1945 struct secret *secret = handle;
1946
1947 FIXME( "%p\n", handle );
1948
1949 if (!secret || secret->hdr.magic != MAGIC_SECRET) return STATUS_INVALID_HANDLE;
1950 secret->hdr.magic = 0;
1951 heap_free( secret );
1952 return STATUS_SUCCESS;
1953 }
1954
1955 NTSTATUS WINAPI BCryptDeriveKey(BCRYPT_SECRET_HANDLE handle, LPCWSTR kdf, BCryptBufferDesc *parameter,
1956 PUCHAR derived, ULONG derived_size, ULONG *result, ULONG flags)
1957 {
1958 struct secret *secret = handle;
1959
1960 FIXME( "%p, %s, %p, %p, %d, %p, %08x\n", secret, debugstr_w(kdf), parameter, derived, derived_size, result, flags );
1961
1962 if (!secret || secret->hdr.magic != MAGIC_SECRET) return STATUS_INVALID_HANDLE;
1963 if (!kdf) return STATUS_INVALID_PARAMETER;
1964
1965 return STATUS_INTERNAL_ERROR;
1966 }
1967
1968 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
1969 {
1970 switch (reason)
1971 {
1972 case DLL_PROCESS_ATTACH:
1973 instance = hinst;
1974 DisableThreadLibraryCalls( hinst );
1975 __wine_init_unix_lib( hinst, reason, NULL, &key_funcs );
1976 break;
1977 case DLL_PROCESS_DETACH:
1978 if (reserved) break;
1979 __wine_init_unix_lib( hinst, reason, NULL, NULL );
1980 break;
1981 }
1982 return TRUE;
1983 }
Windows API implementation