?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bcrypt: Merge the various key export Unix calls into one.
[wine.git] / dlls / bcrypt / gnutls.c
blob01e1fe720929b9a0f51165f49d258ff719a32976
1 /*
2 * Copyright 2009 Henri Verbeet for CodeWeavers
3 * Copyright 2018 Hans Leidekker for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 *
19 */
20
21 #if 0
22 #pragma makedep unix
23 #endif
24
25 #include "config.h"
26
27 #ifdef HAVE_GNUTLS_CIPHER_INIT
28
29 #include <stdarg.h>
30 #include <stdlib.h>
31 #include <assert.h>
32 #include <sys/types.h>
33 #include <dlfcn.h>
34 #include <gnutls/gnutls.h>
35 #include <gnutls/crypto.h>
36 #include <gnutls/abstract.h>
37
38 #include "ntstatus.h"
39 #define WIN32_NO_STATUS
40 #include "windef.h"
41 #include "winbase.h"
42 #include "winternl.h"
43 #include "ntsecapi.h"
44 #include "wincrypt.h"
45 #include "bcrypt.h"
46
47 #include "bcrypt_internal.h"
48
49 #include "wine/debug.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
52 WINE_DECLARE_DEBUG_CHANNEL(winediag);
53
54 #if GNUTLS_VERSION_MAJOR < 3
55 #define GNUTLS_CIPHER_AES_192_CBC 92
56 #define GNUTLS_CIPHER_AES_128_GCM 93
57 #define GNUTLS_CIPHER_AES_256_GCM 94
58 #define GNUTLS_PK_ECC 4
59
60 #define GNUTLS_CURVE_TO_BITS(curve) (unsigned int)(((unsigned int)1<<31)|((unsigned int)(curve)))
61
62 typedef enum
63 {
64 GNUTLS_ECC_CURVE_INVALID,
65 GNUTLS_ECC_CURVE_SECP224R1,
66 GNUTLS_ECC_CURVE_SECP256R1,
67 GNUTLS_ECC_CURVE_SECP384R1,
68 GNUTLS_ECC_CURVE_SECP521R1,
69 } gnutls_ecc_curve_t;
70 #endif
71
72 union key_data
73 {
74 gnutls_cipher_hd_t cipher;
75 gnutls_privkey_t privkey;
76 };
77 C_ASSERT( sizeof(union key_data) <= sizeof(((struct key *)0)->private) );
78
79 static union key_data *key_data( struct key *key )
80 {
81 return (union key_data *)key->private;
82 }
83
84 /* Not present in gnutls version < 3.0 */
85 static int (*pgnutls_cipher_tag)(gnutls_cipher_hd_t, void *, size_t);
86 static int (*pgnutls_cipher_add_auth)(gnutls_cipher_hd_t, const void *, size_t);
87 static gnutls_sign_algorithm_t (*pgnutls_pk_to_sign)(gnutls_pk_algorithm_t, gnutls_digest_algorithm_t);
88 static int (*pgnutls_pubkey_import_ecc_raw)(gnutls_pubkey_t, gnutls_ecc_curve_t,
89 const gnutls_datum_t *, const gnutls_datum_t *);
90 static int (*pgnutls_privkey_import_ecc_raw)(gnutls_privkey_t, gnutls_ecc_curve_t, const gnutls_datum_t *,
91 const gnutls_datum_t *, const gnutls_datum_t *);
92 static int (*pgnutls_pubkey_verify_hash2)(gnutls_pubkey_t, gnutls_sign_algorithm_t, unsigned int,
93 const gnutls_datum_t *, const gnutls_datum_t *);
94
95 /* Not present in gnutls version < 2.11.0 */
96 static int (*pgnutls_pubkey_import_rsa_raw)(gnutls_pubkey_t, const gnutls_datum_t *, const gnutls_datum_t *);
97
98 /* Not present in gnutls version < 2.12.0 */
99 static int (*pgnutls_pubkey_import_dsa_raw)(gnutls_pubkey_t, const gnutls_datum_t *, const gnutls_datum_t *,
100 const gnutls_datum_t *, const gnutls_datum_t *);
101
102 /* Not present in gnutls version < 3.3.0 */
103 static int (*pgnutls_privkey_export_ecc_raw)(gnutls_privkey_t, gnutls_ecc_curve_t *,
104 gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *);
105 static int (*pgnutls_privkey_export_rsa_raw)(gnutls_privkey_t, gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *,
106 gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *,
107 gnutls_datum_t *);
108 static int (*pgnutls_privkey_export_dsa_raw)(gnutls_privkey_t, gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *,
109 gnutls_datum_t *, gnutls_datum_t *);
110 static int (*pgnutls_privkey_generate)(gnutls_privkey_t, gnutls_pk_algorithm_t, unsigned int, unsigned int);
111 static int (*pgnutls_privkey_import_rsa_raw)(gnutls_privkey_t, const gnutls_datum_t *, const gnutls_datum_t *,
112 const gnutls_datum_t *, const gnutls_datum_t *, const gnutls_datum_t *,
113 const gnutls_datum_t *, const gnutls_datum_t *, const gnutls_datum_t *);
114 static int (*pgnutls_privkey_decrypt_data)(gnutls_privkey_t, unsigned int flags, const gnutls_datum_t *, gnutls_datum_t *);
115
116 /* Not present in gnutls version < 3.6.0 */
117 static int (*pgnutls_decode_rs_value)(const gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *);
118
119 static void *libgnutls_handle;
120 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
121 MAKE_FUNCPTR(gnutls_cipher_decrypt2);
122 MAKE_FUNCPTR(gnutls_cipher_deinit);
123 MAKE_FUNCPTR(gnutls_cipher_encrypt2);
124 MAKE_FUNCPTR(gnutls_cipher_init);
125 MAKE_FUNCPTR(gnutls_global_deinit);
126 MAKE_FUNCPTR(gnutls_global_init);
127 MAKE_FUNCPTR(gnutls_global_set_log_function);
128 MAKE_FUNCPTR(gnutls_global_set_log_level);
129 MAKE_FUNCPTR(gnutls_perror);
130 MAKE_FUNCPTR(gnutls_privkey_decrypt_data);
131 MAKE_FUNCPTR(gnutls_privkey_deinit);
132 MAKE_FUNCPTR(gnutls_privkey_import_dsa_raw);
133 MAKE_FUNCPTR(gnutls_privkey_init);
134 MAKE_FUNCPTR(gnutls_privkey_sign_hash);
135 MAKE_FUNCPTR(gnutls_pubkey_deinit);
136 MAKE_FUNCPTR(gnutls_pubkey_init);
137 #undef MAKE_FUNCPTR
138
139 static int compat_gnutls_cipher_tag(gnutls_cipher_hd_t handle, void *tag, size_t tag_size)
140 {
141 return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
142 }
143
144 static int compat_gnutls_cipher_add_auth(gnutls_cipher_hd_t handle, const void *ptext, size_t ptext_size)
145 {
146 return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
147 }
148
149 static int compat_gnutls_pubkey_import_ecc_raw(gnutls_pubkey_t key, gnutls_ecc_curve_t curve,
150 const gnutls_datum_t *x, const gnutls_datum_t *y)
151 {
152 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
153 }
154
155 static int compat_gnutls_privkey_export_rsa_raw(gnutls_privkey_t key, gnutls_datum_t *m, gnutls_datum_t *e,
156 gnutls_datum_t *d, gnutls_datum_t *p, gnutls_datum_t *q,
157 gnutls_datum_t *u, gnutls_datum_t *e1, gnutls_datum_t *e2)
158 {
159 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
160 }
161
162 static int compat_gnutls_privkey_export_ecc_raw(gnutls_privkey_t key, gnutls_ecc_curve_t *curve,
163 gnutls_datum_t *x, gnutls_datum_t *y, gnutls_datum_t *k)
164 {
165 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
166 }
167
168 static int compat_gnutls_privkey_import_ecc_raw(gnutls_privkey_t key, gnutls_ecc_curve_t curve,
169 const gnutls_datum_t *x, const gnutls_datum_t *y,
170 const gnutls_datum_t *k)
171 {
172 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
173 }
174
175 static int compat_gnutls_privkey_export_dsa_raw(gnutls_privkey_t key, gnutls_datum_t *p, gnutls_datum_t *q,
176 gnutls_datum_t *g, gnutls_datum_t *y, gnutls_datum_t *x)
177 {
178 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
179 }
180
181 static gnutls_sign_algorithm_t compat_gnutls_pk_to_sign(gnutls_pk_algorithm_t pk, gnutls_digest_algorithm_t hash)
182 {
183 return GNUTLS_SIGN_UNKNOWN;
184 }
185
186 static int compat_gnutls_pubkey_verify_hash2(gnutls_pubkey_t key, gnutls_sign_algorithm_t algo,
187 unsigned int flags, const gnutls_datum_t *hash,
188 const gnutls_datum_t *signature)
189 {
190 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
191 }
192
193 static int compat_gnutls_pubkey_import_rsa_raw(gnutls_pubkey_t key, const gnutls_datum_t *m, const gnutls_datum_t *e)
194 {
195 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
196 }
197
198 static int compat_gnutls_pubkey_import_dsa_raw(gnutls_pubkey_t key, const gnutls_datum_t *p, const gnutls_datum_t *q,
199 const gnutls_datum_t *g, const gnutls_datum_t *y)
200 {
201 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
202 }
203
204 static int compat_gnutls_privkey_generate(gnutls_privkey_t key, gnutls_pk_algorithm_t algo, unsigned int bits,
205 unsigned int flags)
206 {
207 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
208 }
209
210 static int compat_gnutls_decode_rs_value(const gnutls_datum_t * sig_value, gnutls_datum_t * r, gnutls_datum_t * s)
211 {
212 return GNUTLS_E_INTERNAL_ERROR;
213 }
214
215 static int compat_gnutls_privkey_import_rsa_raw(gnutls_privkey_t key, const gnutls_datum_t *m, const gnutls_datum_t *e,
216 const gnutls_datum_t *d, const gnutls_datum_t *p, const gnutls_datum_t *q,
217 const gnutls_datum_t *u, const gnutls_datum_t *e1, const gnutls_datum_t *e2)
218 {
219 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
220 }
221
222 static int compat_gnutls_privkey_decrypt_data(gnutls_privkey_t key, unsigned int flags, const gnutls_datum_t *cipher_text,
223 gnutls_datum_t *plain_text)
224 {
225 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
226 }
227
228 static void gnutls_log( int level, const char *msg )
229 {
230 TRACE( "<%d> %s", level, msg );
231 }
232
233 static NTSTATUS gnutls_process_attach( void *args )
234 {
235 const char *env_str;
236 int ret;
237
238 if ((env_str = getenv("GNUTLS_SYSTEM_PRIORITY_FILE")))
239 {
240 WARN("GNUTLS_SYSTEM_PRIORITY_FILE is %s.\n", debugstr_a(env_str));
241 }
242 else
243 {
244 WARN("Setting GNUTLS_SYSTEM_PRIORITY_FILE to \"/dev/null\".\n");
245 setenv("GNUTLS_SYSTEM_PRIORITY_FILE", "/dev/null", 0);
246 }
247
248 if (!(libgnutls_handle = dlopen( SONAME_LIBGNUTLS, RTLD_NOW )))
249 {
250 ERR_(winediag)( "failed to load libgnutls, no support for encryption\n" );
251 return STATUS_DLL_NOT_FOUND;
252 }
253
254 #define LOAD_FUNCPTR(f) \
255 if (!(p##f = dlsym( libgnutls_handle, #f ))) \
256 { \
257 ERR( "failed to load %s\n", #f ); \
258 goto fail; \
259 }
260
261 LOAD_FUNCPTR(gnutls_cipher_decrypt2)
262 LOAD_FUNCPTR(gnutls_cipher_deinit)
263 LOAD_FUNCPTR(gnutls_cipher_encrypt2)
264 LOAD_FUNCPTR(gnutls_cipher_init)
265 LOAD_FUNCPTR(gnutls_global_deinit)
266 LOAD_FUNCPTR(gnutls_global_init)
267 LOAD_FUNCPTR(gnutls_global_set_log_function)
268 LOAD_FUNCPTR(gnutls_global_set_log_level)
269 LOAD_FUNCPTR(gnutls_perror)
270 LOAD_FUNCPTR(gnutls_privkey_deinit);
271 LOAD_FUNCPTR(gnutls_privkey_import_dsa_raw);
272 LOAD_FUNCPTR(gnutls_privkey_init);
273 LOAD_FUNCPTR(gnutls_privkey_sign_hash);
274 LOAD_FUNCPTR(gnutls_pubkey_deinit);
275 LOAD_FUNCPTR(gnutls_pubkey_init);
276 #undef LOAD_FUNCPTR
277
278 #define LOAD_FUNCPTR_OPT(f) \
279 if (!(p##f = dlsym( libgnutls_handle, #f ))) \
280 { \
281 WARN( "failed to load %s\n", #f ); \
282 p##f = compat_##f; \
283 }
284
285 LOAD_FUNCPTR_OPT(gnutls_cipher_tag)
286 LOAD_FUNCPTR_OPT(gnutls_cipher_add_auth)
287 LOAD_FUNCPTR_OPT(gnutls_pubkey_import_ecc_raw)
288 LOAD_FUNCPTR_OPT(gnutls_privkey_export_rsa_raw)
289 LOAD_FUNCPTR_OPT(gnutls_privkey_export_ecc_raw)
290 LOAD_FUNCPTR_OPT(gnutls_privkey_import_ecc_raw)
291 LOAD_FUNCPTR_OPT(gnutls_privkey_export_dsa_raw)
292 LOAD_FUNCPTR_OPT(gnutls_pk_to_sign)
293 LOAD_FUNCPTR_OPT(gnutls_pubkey_verify_hash2)
294 LOAD_FUNCPTR_OPT(gnutls_pubkey_import_rsa_raw)
295 LOAD_FUNCPTR_OPT(gnutls_pubkey_import_dsa_raw)
296 LOAD_FUNCPTR_OPT(gnutls_privkey_generate)
297 LOAD_FUNCPTR_OPT(gnutls_decode_rs_value)
298 LOAD_FUNCPTR_OPT(gnutls_privkey_import_rsa_raw)
299 LOAD_FUNCPTR_OPT(gnutls_privkey_decrypt_data)
300 #undef LOAD_FUNCPTR_OPT
301
302 if ((ret = pgnutls_global_init()) != GNUTLS_E_SUCCESS)
303 {
304 pgnutls_perror( ret );
305 goto fail;
306 }
307
308 if (TRACE_ON( bcrypt ))
309 {
310 pgnutls_global_set_log_level( 4 );
311 pgnutls_global_set_log_function( gnutls_log );
312 }
313
314 return STATUS_SUCCESS;
315
316 fail:
317 dlclose( libgnutls_handle );
318 libgnutls_handle = NULL;
319 return STATUS_DLL_NOT_FOUND;
320 }
321
322 static NTSTATUS gnutls_process_detach( void *args )
323 {
324 if (libgnutls_handle)
325 {
326 pgnutls_global_deinit();
327 dlclose( libgnutls_handle );
328 libgnutls_handle = NULL;
329 }
330 return STATUS_SUCCESS;
331 }
332
333 struct buffer
334 {
335 BYTE *buffer;
336 DWORD length;
337 DWORD pos;
338 BOOL error;
339 };
340
341 static void buffer_init( struct buffer *buffer )
342 {
343 buffer->buffer = NULL;
344 buffer->length = 0;
345 buffer->pos = 0;
346 buffer->error = FALSE;
347 }
348
349 static void buffer_free( struct buffer *buffer )
350 {
351 free( buffer->buffer );
352 }
353
354 static void buffer_append( struct buffer *buffer, BYTE *data, DWORD len )
355 {
356 if (!len) return;
357
358 if (buffer->pos + len > buffer->length)
359 {
360 DWORD new_length = max( max( buffer->pos + len, buffer->length * 2 ), 64 );
361 BYTE *new_buffer;
362
363 if (!(new_buffer = realloc( buffer->buffer, new_length )))
364 {
365 ERR( "out of memory\n" );
366 buffer->error = TRUE;
367 return;
368 }
369
370 buffer->buffer = new_buffer;
371 buffer->length = new_length;
372 }
373
374 memcpy( &buffer->buffer[buffer->pos], data, len );
375 buffer->pos += len;
376 }
377
378 static void buffer_append_byte( struct buffer *buffer, BYTE value )
379 {
380 buffer_append( buffer, &value, sizeof(value) );
381 }
382
383 static void buffer_append_asn1_length( struct buffer *buffer, DWORD length )
384 {
385 DWORD num_bytes;
386
387 if (length < 128)
388 {
389 buffer_append_byte( buffer, length );
390 return;
391 }
392
393 if (length <= 0xff) num_bytes = 1;
394 else if (length <= 0xffff) num_bytes = 2;
395 else if (length <= 0xffffff) num_bytes = 3;
396 else num_bytes = 4;
397
398 buffer_append_byte( buffer, 0x80 | num_bytes );
399 while (num_bytes--) buffer_append_byte( buffer, length >> (num_bytes * 8) );
400 }
401
402 static void buffer_append_asn1_integer( struct buffer *buffer, BYTE *data, DWORD len )
403 {
404 DWORD leading_zero = (*data & 0x80) != 0;
405
406 buffer_append_byte( buffer, 0x02 ); /* tag */
407 buffer_append_asn1_length( buffer, len + leading_zero );
408 if (leading_zero) buffer_append_byte( buffer, 0 );
409 buffer_append( buffer, data, len );
410 }
411
412 static void buffer_append_asn1_sequence( struct buffer *buffer, struct buffer *content )
413 {
414 if (content->error)
415 {
416 buffer->error = TRUE;
417 return;
418 }
419
420 buffer_append_byte( buffer, 0x30 ); /* tag */
421 buffer_append_asn1_length( buffer, content->pos );
422 buffer_append( buffer, content->buffer, content->pos );
423 }
424
425 static void buffer_append_asn1_r_s( struct buffer *buffer, BYTE *r, DWORD r_len, BYTE *s, DWORD s_len )
426 {
427 struct buffer value;
428
429 buffer_init( &value );
430 buffer_append_asn1_integer( &value, r, r_len );
431 buffer_append_asn1_integer( &value, s, s_len );
432 buffer_append_asn1_sequence( buffer, &value );
433 buffer_free( &value );
434 }
435
436 static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key )
437 {
438 switch (key->alg_id)
439 {
440 case ALG_ID_3DES:
441 WARN( "handle block size\n" );
442 switch (key->u.s.mode)
443 {
444 case MODE_ID_CBC:
445 return GNUTLS_CIPHER_3DES_CBC;
446 default:
447 break;
448 }
449 FIXME( "3DES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len );
450 return GNUTLS_CIPHER_UNKNOWN;
451
452 case ALG_ID_AES:
453 WARN( "handle block size\n" );
454 switch (key->u.s.mode)
455 {
456 case MODE_ID_GCM:
457 if (key->u.s.secret_len == 16) return GNUTLS_CIPHER_AES_128_GCM;
458 if (key->u.s.secret_len == 32) return GNUTLS_CIPHER_AES_256_GCM;
459 break;
460 case MODE_ID_ECB: /* can be emulated with CBC + empty IV */
461 case MODE_ID_CBC:
462 if (key->u.s.secret_len == 16) return GNUTLS_CIPHER_AES_128_CBC;
463 if (key->u.s.secret_len == 24) return GNUTLS_CIPHER_AES_192_CBC;
464 if (key->u.s.secret_len == 32) return GNUTLS_CIPHER_AES_256_CBC;
465 break;
466 default:
467 break;
468 }
469 FIXME( "AES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len );
470 return GNUTLS_CIPHER_UNKNOWN;
471
472 default:
473 FIXME( "algorithm %u not supported\n", key->alg_id );
474 return GNUTLS_CIPHER_UNKNOWN;
475 }
476 }
477
478 static NTSTATUS key_symmetric_vector_reset( void *args )
479 {
480 struct key *key = args;
481
482 if (!key_data(key)->cipher) return STATUS_SUCCESS;
483 TRACE( "invalidating cipher handle\n" );
484 pgnutls_cipher_deinit( key_data(key)->cipher );
485 key_data(key)->cipher = NULL;
486 return STATUS_SUCCESS;
487 }
488
489 static NTSTATUS init_cipher_handle( struct key *key )
490 {
491 gnutls_cipher_algorithm_t cipher;
492 gnutls_datum_t secret, vector;
493 int ret;
494
495 if (key_data(key)->cipher) return STATUS_SUCCESS;
496 if ((cipher = get_gnutls_cipher( key )) == GNUTLS_CIPHER_UNKNOWN) return STATUS_NOT_SUPPORTED;
497
498 secret.data = key->u.s.secret;
499 secret.size = key->u.s.secret_len;
500
501 vector.data = key->u.s.vector;
502 vector.size = key->u.s.vector_len;
503
504 if ((ret = pgnutls_cipher_init( &key_data(key)->cipher, cipher, &secret, key->u.s.vector ? &vector : NULL )))
505 {
506 pgnutls_perror( ret );
507 return STATUS_INTERNAL_ERROR;
508 }
509
510 return STATUS_SUCCESS;
511 }
512
513 static NTSTATUS key_symmetric_set_auth_data( void *args )
514 {
515 const struct key_symmetric_set_auth_data_params *params = args;
516 NTSTATUS status;
517 int ret;
518
519 if (!params->auth_data) return STATUS_SUCCESS;
520 if ((status = init_cipher_handle( params->key ))) return status;
521
522 if ((ret = pgnutls_cipher_add_auth( key_data(params->key)->cipher, params->auth_data, params->len )))
523 {
524 pgnutls_perror( ret );
525 return STATUS_INTERNAL_ERROR;
526 }
527 return STATUS_SUCCESS;
528 }
529
530 static NTSTATUS key_symmetric_encrypt( void *args )
531 {
532 const struct key_symmetric_encrypt_params *params = args;
533 NTSTATUS status;
534 int ret;
535
536 if ((status = init_cipher_handle( params->key ))) return status;
537
538 if ((ret = pgnutls_cipher_encrypt2( key_data(params->key)->cipher, params->input, params->input_len,
539 params->output, params->output_len )))
540 {
541 pgnutls_perror( ret );
542 return STATUS_INTERNAL_ERROR;
543 }
544 return STATUS_SUCCESS;
545 }
546
547 static NTSTATUS key_symmetric_decrypt( void *args )
548 {
549 const struct key_symmetric_decrypt_params *params = args;
550 NTSTATUS status;
551 int ret;
552
553 if ((status = init_cipher_handle( params->key ))) return status;
554
555 if ((ret = pgnutls_cipher_decrypt2( key_data(params->key)->cipher, params->input, params->input_len,
556 params->output, params->output_len )))
557 {
558 pgnutls_perror( ret );
559 return STATUS_INTERNAL_ERROR;
560 }
561 return STATUS_SUCCESS;
562 }
563
564 static NTSTATUS key_symmetric_get_tag( void *args )
565 {
566 const struct key_symmetric_get_tag_params *params = args;
567 NTSTATUS status;
568 int ret;
569
570 if ((status = init_cipher_handle( params->key ))) return status;
571
572 if ((ret = pgnutls_cipher_tag( key_data(params->key)->cipher, params->tag, params->len )))
573 {
574 pgnutls_perror( ret );
575 return STATUS_INTERNAL_ERROR;
576 }
577 return STATUS_SUCCESS;
578 }
579
580 static NTSTATUS key_symmetric_destroy( void *args )
581 {
582 struct key *key = args;
583
584 if (key_data(key)->cipher) pgnutls_cipher_deinit( key_data(key)->cipher );
585 return STATUS_SUCCESS;
586 }
587
588 static ULONG export_gnutls_datum( UCHAR *buffer, ULONG buflen, gnutls_datum_t *d, BOOL zero_pad )
589 {
590 ULONG size = d->size;
591 UCHAR *src = d->data;
592 ULONG offset = 0;
593
594 assert( size <= buflen + 1 );
595 if (size == buflen + 1)
596 {
597 assert( !src[0] );
598 src++;
599 size--;
600 }
601 if (zero_pad)
602 {
603 offset = buflen - size;
604 if (buffer) memset( buffer, 0, offset );
605 size = buflen;
606 }
607
608 if (buffer) memcpy( buffer + offset, src, size );
609 return size;
610 }
611
612 #define EXPORT_SIZE(d,f,p) export_gnutls_datum( NULL, bitlen / f, &d, p )
613 static NTSTATUS export_gnutls_pubkey_rsa( gnutls_privkey_t gnutls_key, ULONG bitlen, void *pubkey, unsigned *pubkey_len )
614 {
615 BCRYPT_RSAKEY_BLOB *rsa_blob = pubkey;
616 gnutls_datum_t m, e;
617 UCHAR *dst;
618 int ret;
619
620 if ((ret = pgnutls_privkey_export_rsa_raw( gnutls_key, &m, &e, NULL, NULL, NULL, NULL, NULL, NULL )))
621 {
622 pgnutls_perror( ret );
623 return STATUS_INTERNAL_ERROR;
624 }
625
626 if (*pubkey_len < sizeof(*rsa_blob) + EXPORT_SIZE(e,8,0) + EXPORT_SIZE(m,8,1))
627 {
628 FIXME( "wrong pubkey len %u\n", *pubkey_len );
629 pgnutls_perror( ret );
630 free( e.data ); free( m.data );
631 return STATUS_BUFFER_TOO_SMALL;
632 }
633
634 dst = (UCHAR *)(rsa_blob + 1);
635 rsa_blob->cbPublicExp = export_gnutls_datum( dst, bitlen / 8, &e, 0 );
636
637 dst += rsa_blob->cbPublicExp;
638 rsa_blob->cbModulus = export_gnutls_datum( dst, bitlen / 8, &m, 1 );
639
640 rsa_blob->Magic = BCRYPT_RSAPUBLIC_MAGIC;
641 rsa_blob->BitLength = bitlen;
642 rsa_blob->cbPrime1 = 0;
643 rsa_blob->cbPrime2 = 0;
644
645 *pubkey_len = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus;
646
647 free( e.data ); free( m.data );
648 return STATUS_SUCCESS;
649 }
650 #undef EXPORT_SIZE
651
652 static NTSTATUS export_gnutls_pubkey_ecc( gnutls_privkey_t gnutls_key, enum alg_id alg_id, void *pubkey,
653 unsigned *pubkey_len )
654 {
655 BCRYPT_ECCKEY_BLOB *ecc_blob = pubkey;
656 gnutls_ecc_curve_t curve;
657 gnutls_datum_t x, y;
658 DWORD magic, size;
659 UCHAR *dst;
660 int ret;
661
662 switch (alg_id)
663 {
664 case ALG_ID_ECDH_P256:
665 magic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
666 size = 32;
667 break;
668 case ALG_ID_ECDSA_P256:
669 magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
670 size = 32;
671 break;
672 default:
673 FIXME( "algorithm %u not supported\n", alg_id );
674 return STATUS_NOT_IMPLEMENTED;
675 }
676
677 if ((ret = pgnutls_privkey_export_ecc_raw( gnutls_key, &curve, &x, &y, NULL )))
678 {
679 pgnutls_perror( ret );
680 return STATUS_INTERNAL_ERROR;
681 }
682
683 if (curve != GNUTLS_ECC_CURVE_SECP256R1)
684 {
685 FIXME( "curve %u not supported\n", curve );
686 free( x.data ); free( y.data );
687 return STATUS_NOT_IMPLEMENTED;
688 }
689
690 if (*pubkey_len < sizeof(*ecc_blob) + size * 2)
691 {
692 FIXME( "wrong pubkey len %u / %lu\n", *pubkey_len, sizeof(*ecc_blob) + size * 2 );
693 pgnutls_perror( ret );
694 free( x.data ); free( y.data );
695 return STATUS_BUFFER_TOO_SMALL;
696 }
697
698 ecc_blob->dwMagic = magic;
699 ecc_blob->cbKey = size;
700
701 dst = (UCHAR *)(ecc_blob + 1);
702 export_gnutls_datum( dst, size, &x, 1 );
703
704 dst += size;
705 export_gnutls_datum( dst, size, &y, 1 );
706
707 *pubkey_len = sizeof(*ecc_blob) + ecc_blob->cbKey * 2;
708
709 free( x.data ); free( y.data );
710 return STATUS_SUCCESS;
711 }
712
713 static NTSTATUS export_gnutls_pubkey_dsa( gnutls_privkey_t gnutls_key, ULONG bitlen, void *pubkey, unsigned *pubkey_len )
714 {
715 BCRYPT_DSA_KEY_BLOB *dsa_blob = pubkey;
716 gnutls_datum_t p, q, g, y;
717 UCHAR *dst;
718 int ret;
719
720 if ((ret = pgnutls_privkey_export_dsa_raw( gnutls_key, &p, &q, &g, &y, NULL )))
721 {
722 pgnutls_perror( ret );
723 return STATUS_INTERNAL_ERROR;
724 }
725
726 if (bitlen > 1024)
727 {
728 FIXME( "bitlen > 1024 not supported\n" );
729 return STATUS_NOT_IMPLEMENTED;
730 }
731
732 if (*pubkey_len < sizeof(*dsa_blob) + bitlen / 8 * 3)
733 {
734 FIXME( "wrong pubkey len %u / %lu\n", *pubkey_len, sizeof(*dsa_blob) + bitlen / 8 * 3 );
735 pgnutls_perror( ret );
736 free( p.data ); free( q.data ); free( g.data ); free( y.data );
737 return STATUS_NO_MEMORY;
738 }
739
740 dst = (UCHAR *)(dsa_blob + 1);
741 export_gnutls_datum( dst, bitlen / 8, &p, 1 );
742
743 dst += bitlen / 8;
744 export_gnutls_datum( dst, bitlen / 8, &g, 1 );
745
746 dst += bitlen / 8;
747 export_gnutls_datum( dst, bitlen / 8, &y, 1 );
748
749 dst = dsa_blob->q;
750 export_gnutls_datum( dst, sizeof(dsa_blob->q), &q, 1 );
751
752 dsa_blob->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
753 dsa_blob->cbKey = bitlen / 8;
754 memset( dsa_blob->Count, 0, sizeof(dsa_blob->Count) ); /* FIXME */
755 memset( dsa_blob->Seed, 0, sizeof(dsa_blob->Seed) ); /* FIXME */
756
757 *pubkey_len = sizeof(*dsa_blob) + dsa_blob->cbKey * 3;
758
759 free( p.data ); free( q.data ); free( g.data ); free( y.data );
760 return STATUS_SUCCESS;
761 }
762
763 static void reverse_bytes( UCHAR *buf, ULONG len )
764 {
765 unsigned int i;
766 UCHAR tmp;
767
768 for (i = 0; i < len / 2; ++i)
769 {
770 tmp = buf[i];
771 buf[i] = buf[len - i - 1];
772 buf[len - i - 1] = tmp;
773 }
774 }
775
776 #define Q_SIZE 20
777 static NTSTATUS export_gnutls_pubkey_dsa_capi( gnutls_privkey_t gnutls_key, const DSSSEED *seed, unsigned bitlen,
778 void *pubkey, unsigned *pubkey_len )
779 {
780 BLOBHEADER *hdr = pubkey;
781 DSSPUBKEY *dsskey;
782 gnutls_datum_t p, q, g, y;
783 UCHAR *dst;
784 int ret, size = sizeof(*hdr) + sizeof(*dsskey) + sizeof(*seed);
785
786 if (bitlen > 1024)
787 {
788 FIXME( "bitlen > 1024 not supported\n" );
789 return STATUS_NOT_IMPLEMENTED;
790 }
791
792 if ((ret = pgnutls_privkey_export_dsa_raw( gnutls_key, &p, &q, &g, &y, NULL )))
793 {
794 pgnutls_perror( ret );
795 return STATUS_INTERNAL_ERROR;
796 }
797
798 if (*pubkey_len < size + bitlen / 8 * 3 + Q_SIZE)
799 {
800 FIXME( "wrong pubkey len %u / %u\n", *pubkey_len, size + bitlen / 8 * 3 + Q_SIZE );
801 pgnutls_perror( ret );
802 free( p.data ); free( q.data ); free( g.data ); free( y.data );
803 return STATUS_NO_MEMORY;
804 }
805
806 hdr->bType = PUBLICKEYBLOB;
807 hdr->bVersion = 2;
808 hdr->reserved = 0;
809 hdr->aiKeyAlg = CALG_DSS_SIGN;
810
811 dsskey = (DSSPUBKEY *)(hdr + 1);
812 dsskey->magic = MAGIC_DSS1;
813 dsskey->bitlen = bitlen;
814
815 dst = (UCHAR *)(dsskey + 1);
816 export_gnutls_datum( dst, bitlen / 8, &p, 1 );
817 reverse_bytes( dst, bitlen / 8 );
818 dst += bitlen / 8;
819
820 export_gnutls_datum( dst, Q_SIZE, &q, 1 );
821 reverse_bytes( dst, Q_SIZE );
822 dst += Q_SIZE;
823
824 export_gnutls_datum( dst, bitlen / 8, &g, 1 );
825 reverse_bytes( dst, bitlen / 8 );
826 dst += bitlen / 8;
827
828 export_gnutls_datum( dst, bitlen / 8, &y, 1 );
829 reverse_bytes( dst, bitlen / 8 );
830 dst += bitlen / 8;
831
832 memcpy( dst, seed, sizeof(*seed) );
833
834 *pubkey_len = size + bitlen / 8 * 3 + Q_SIZE;
835
836 free( p.data ); free( q.data ); free( g.data ); free( y.data );
837 return STATUS_SUCCESS;
838 }
839
840 #define EXPORT_SIZE(d,f,p) export_gnutls_datum( NULL, key->u.a.bitlen / f, &d, p )
841 static NTSTATUS key_export_rsa_public( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
842 {
843 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
844 gnutls_datum_t m, e;
845 UCHAR *dst;
846 int ret;
847
848 if ((ret = pgnutls_privkey_export_rsa_raw( key_data(key)->privkey, &m, &e, NULL, NULL, NULL, NULL, NULL, NULL )))
849 {
850 pgnutls_perror( ret );
851 return STATUS_INTERNAL_ERROR;
852 }
853
854 *ret_len = sizeof(*rsa_blob) + EXPORT_SIZE(e,8,0) + EXPORT_SIZE(m,8,1);
855 if (len >= *ret_len && buf)
856 {
857 dst = (UCHAR *)(rsa_blob + 1);
858 rsa_blob->cbPublicExp = export_gnutls_datum( dst, key->u.a.bitlen / 8, &e, 0 );
859
860 dst += rsa_blob->cbPublicExp;
861 rsa_blob->cbModulus = export_gnutls_datum( dst, key->u.a.bitlen / 8, &m, 1 );
862
863 rsa_blob->Magic = BCRYPT_RSAPUBLIC_MAGIC;
864 rsa_blob->BitLength = key->u.a.bitlen;
865 rsa_blob->cbPrime1 = 0;
866 rsa_blob->cbPrime2 = 0;
867 }
868
869 free( e.data ); free( m.data );
870 return STATUS_SUCCESS;
871 }
872
873 static NTSTATUS key_export_ecc_public( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
874 {
875 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
876 gnutls_ecc_curve_t curve;
877 gnutls_datum_t x, y;
878 DWORD magic, size;
879 UCHAR *dst;
880 int ret;
881
882 switch (key->alg_id)
883 {
884 case ALG_ID_ECDH_P256:
885 magic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
886 size = 32;
887 break;
888 case ALG_ID_ECDSA_P256:
889 magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
890 size = 32;
891 break;
892 default:
893 FIXME( "algorithm %u not supported\n", key->alg_id );
894 return STATUS_NOT_IMPLEMENTED;
895 }
896
897 if ((ret = pgnutls_privkey_export_ecc_raw( key_data(key)->privkey, &curve, &x, &y, NULL )))
898 {
899 pgnutls_perror( ret );
900 return STATUS_INTERNAL_ERROR;
901 }
902
903 if (curve != GNUTLS_ECC_CURVE_SECP256R1)
904 {
905 FIXME( "curve %u not supported\n", curve );
906 free( x.data ); free( y.data );
907 return STATUS_NOT_IMPLEMENTED;
908 }
909
910 *ret_len = sizeof(*ecc_blob) + size * 2;
911 if (len >= *ret_len && buf)
912 {
913 ecc_blob->dwMagic = magic;
914 ecc_blob->cbKey = size;
915
916 dst = (UCHAR *)(ecc_blob + 1);
917 export_gnutls_datum( dst, size, &x, 1 );
918
919 dst += size;
920 export_gnutls_datum( dst, size, &y, 1 );
921 }
922
923 free( x.data ); free( y.data );
924 return STATUS_SUCCESS;
925 }
926
927 static NTSTATUS key_export_dsa_public( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
928 {
929 BCRYPT_DSA_KEY_BLOB *dsa_blob = (BCRYPT_DSA_KEY_BLOB *)buf;
930 gnutls_datum_t p, q, g, y;
931 UCHAR *dst;
932 int ret;
933
934 if ((ret = pgnutls_privkey_export_dsa_raw( key_data(key)->privkey, &p, &q, &g, &y, NULL )))
935 {
936 pgnutls_perror( ret );
937 return STATUS_INTERNAL_ERROR;
938 }
939
940 if (key->u.a.bitlen > 1024)
941 {
942 FIXME( "bitlen > 1024 not supported\n" );
943 return STATUS_NOT_IMPLEMENTED;
944 }
945
946 *ret_len = sizeof(*dsa_blob) + key->u.a.bitlen / 8 * 3;
947 if (len >= *ret_len && buf)
948 {
949 dst = (UCHAR *)(dsa_blob + 1);
950 export_gnutls_datum( dst, key->u.a.bitlen / 8, &p, 1 );
951
952 dst += key->u.a.bitlen / 8;
953 export_gnutls_datum( dst, key->u.a.bitlen / 8, &g, 1 );
954
955 dst += key->u.a.bitlen / 8;
956 export_gnutls_datum( dst, key->u.a.bitlen / 8, &y, 1 );
957
958 dst = dsa_blob->q;
959 export_gnutls_datum( dst, sizeof(dsa_blob->q), &q, 1 );
960
961 dsa_blob->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
962 dsa_blob->cbKey = key->u.a.bitlen / 8;
963 memset( dsa_blob->Count, 0, sizeof(dsa_blob->Count) ); /* FIXME */
964 memset( dsa_blob->Seed, 0, sizeof(dsa_blob->Seed) ); /* FIXME */
965 }
966
967 free( p.data ); free( q.data ); free( g.data ); free( y.data );
968 return STATUS_SUCCESS;
969 }
970
971 #define Q_SIZE 20
972 static NTSTATUS key_export_dsa_capi_public( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
973 {
974 BLOBHEADER *hdr = (BLOBHEADER *)buf;
975 DSSPUBKEY *dsskey;
976 gnutls_datum_t p, q, g, y;
977 UCHAR *dst;
978 int ret, size = sizeof(*hdr) + sizeof(*dsskey) + sizeof(key->u.a.dss_seed);
979
980 if (key->u.a.bitlen > 1024)
981 {
982 FIXME( "bitlen > 1024 not supported\n" );
983 return STATUS_NOT_IMPLEMENTED;
984 }
985
986 if ((ret = pgnutls_privkey_export_dsa_raw( key_data(key)->privkey, &p, &q, &g, &y, NULL )))
987 {
988 pgnutls_perror( ret );
989 return STATUS_INTERNAL_ERROR;
990 }
991
992 *ret_len = size + key->u.a.bitlen / 8 * 3 + Q_SIZE;
993 if (len >= *ret_len && buf)
994 {
995 hdr->bType = PUBLICKEYBLOB;
996 hdr->bVersion = 2;
997 hdr->reserved = 0;
998 hdr->aiKeyAlg = CALG_DSS_SIGN;
999
1000 dsskey = (DSSPUBKEY *)(hdr + 1);
1001 dsskey->magic = MAGIC_DSS1;
1002 dsskey->bitlen = key->u.a.bitlen;
1003
1004 dst = (UCHAR *)(dsskey + 1);
1005 export_gnutls_datum( dst, key->u.a.bitlen / 8, &p, 1 );
1006 reverse_bytes( dst, key->u.a.bitlen / 8 );
1007 dst += key->u.a.bitlen / 8;
1008
1009 export_gnutls_datum( dst, Q_SIZE, &q, 1 );
1010 reverse_bytes( dst, Q_SIZE );
1011 dst += Q_SIZE;
1012
1013 export_gnutls_datum( dst, key->u.a.bitlen / 8, &g, 1 );
1014 reverse_bytes( dst, key->u.a.bitlen / 8 );
1015 dst += key->u.a.bitlen / 8;
1016
1017 export_gnutls_datum( dst, key->u.a.bitlen / 8, &y, 1 );
1018 reverse_bytes( dst, key->u.a.bitlen / 8 );
1019 dst += key->u.a.bitlen / 8;
1020
1021 memcpy( dst, &key->u.a.dss_seed, sizeof(key->u.a.dss_seed) );
1022 }
1023
1024 free( p.data ); free( q.data ); free( g.data ); free( y.data );
1025 return STATUS_SUCCESS;
1026 }
1027
1028 static NTSTATUS key_asymmetric_generate( void *args )
1029 {
1030 struct key *key = args;
1031 gnutls_pk_algorithm_t pk_alg;
1032 gnutls_privkey_t handle;
1033 unsigned int bitlen;
1034 NTSTATUS status;
1035 int ret;
1036
1037 if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
1038 if (key_data(key)->privkey) return STATUS_INVALID_HANDLE;
1039
1040 switch (key->alg_id)
1041 {
1042 case ALG_ID_RSA:
1043 case ALG_ID_RSA_SIGN:
1044 pk_alg = GNUTLS_PK_RSA;
1045 bitlen = key->u.a.bitlen;
1046 break;
1047
1048 case ALG_ID_DSA:
1049 pk_alg = GNUTLS_PK_DSA;
1050 bitlen = key->u.a.bitlen;
1051 break;
1052
1053 case ALG_ID_ECDH_P256:
1054 case ALG_ID_ECDSA_P256:
1055 pk_alg = GNUTLS_PK_ECC; /* compatible with ECDSA and ECDH */
1056 bitlen = GNUTLS_CURVE_TO_BITS( GNUTLS_ECC_CURVE_SECP256R1 );
1057 break;
1058
1059 default:
1060 FIXME( "algorithm %u not supported\n", key->alg_id );
1061 return STATUS_NOT_SUPPORTED;
1062 }
1063
1064 if ((ret = pgnutls_privkey_init( &handle )))
1065 {
1066 pgnutls_perror( ret );
1067 return STATUS_INTERNAL_ERROR;
1068 }
1069
1070 if ((ret = pgnutls_privkey_generate( handle, pk_alg, bitlen, 0 )))
1071 {
1072 pgnutls_perror( ret );
1073 pgnutls_privkey_deinit( handle );
1074 return STATUS_INTERNAL_ERROR;
1075 }
1076
1077 switch (pk_alg)
1078 {
1079 case GNUTLS_PK_RSA:
1080 status = export_gnutls_pubkey_rsa( handle, key->u.a.bitlen, key->u.a.pubkey, &key->u.a.pubkey_len );
1081 break;
1082
1083 case GNUTLS_PK_ECC:
1084 status = export_gnutls_pubkey_ecc( handle, key->alg_id, key->u.a.pubkey, &key->u.a.pubkey_len );
1085 break;
1086
1087 case GNUTLS_PK_DSA:
1088 status = export_gnutls_pubkey_dsa( handle, key->u.a.bitlen, key->u.a.pubkey, &key->u.a.pubkey_len );
1089 break;
1090
1091 default:
1092 ERR( "unhandled algorithm %u\n", pk_alg );
1093 return STATUS_INTERNAL_ERROR;
1094 }
1095
1096 if (status)
1097 {
1098 pgnutls_privkey_deinit( handle );
1099 return status;
1100 }
1101
1102 key_data(key)->privkey = handle;
1103 return STATUS_SUCCESS;
1104 }
1105
1106 static NTSTATUS key_export_ecc( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
1107 {
1108 BCRYPT_ECCKEY_BLOB *ecc_blob;
1109 gnutls_ecc_curve_t curve;
1110 gnutls_datum_t x, y, d;
1111 DWORD magic, size;
1112 UCHAR *dst;
1113 int ret;
1114
1115 switch (key->alg_id)
1116 {
1117 case ALG_ID_ECDH_P256:
1118 magic = BCRYPT_ECDH_PRIVATE_P256_MAGIC;
1119 size = 32;
1120 break;
1121 case ALG_ID_ECDSA_P256:
1122 magic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
1123 size = 32;
1124 break;
1125
1126 default:
1127 FIXME( "algorithm %u does not yet support exporting ecc blob\n", key->alg_id );
1128 return STATUS_NOT_IMPLEMENTED;
1129 }
1130
1131 if ((ret = pgnutls_privkey_export_ecc_raw( key_data(key)->privkey, &curve, &x, &y, &d )))
1132 {
1133 pgnutls_perror( ret );
1134 return STATUS_INTERNAL_ERROR;
1135 }
1136
1137 if (curve != GNUTLS_ECC_CURVE_SECP256R1)
1138 {
1139 FIXME( "curve %u not supported\n", curve );
1140 free( x.data ); free( y.data ); free( d.data );
1141 return STATUS_NOT_IMPLEMENTED;
1142 }
1143
1144 *ret_len = sizeof(*ecc_blob) + size * 3;
1145 if (len >= *ret_len && buf)
1146 {
1147 ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
1148 ecc_blob->dwMagic = magic;
1149 ecc_blob->cbKey = size;
1150
1151 dst = (UCHAR *)(ecc_blob + 1);
1152 export_gnutls_datum( dst, size, &x, 1 );
1153 dst += size;
1154
1155 export_gnutls_datum( dst, size, &y, 1 );
1156 dst += size;
1157
1158 export_gnutls_datum( dst, size, &d, 1 );
1159 }
1160
1161 free( x.data ); free( y.data ); free( d.data );
1162 return STATUS_SUCCESS;
1163 }
1164
1165 static NTSTATUS key_import_ecc( void *args )
1166 {
1167 const struct key_import_params *params = args;
1168 struct key *key = params->key;
1169 BCRYPT_ECCKEY_BLOB *ecc_blob;
1170 gnutls_ecc_curve_t curve;
1171 gnutls_privkey_t handle;
1172 gnutls_datum_t x, y, k;
1173 NTSTATUS status;
1174 int ret;
1175
1176 switch (key->alg_id)
1177 {
1178 case ALG_ID_ECDH_P256:
1179 case ALG_ID_ECDSA_P256:
1180 curve = GNUTLS_ECC_CURVE_SECP256R1;
1181 break;
1182
1183 default:
1184 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1185 return STATUS_NOT_IMPLEMENTED;
1186 }
1187
1188 if ((ret = pgnutls_privkey_init( &handle )))
1189 {
1190 pgnutls_perror( ret );
1191 return STATUS_INTERNAL_ERROR;
1192 }
1193
1194 ecc_blob = (BCRYPT_ECCKEY_BLOB *)params->buf;
1195 x.data = (unsigned char *)(ecc_blob + 1);
1196 x.size = ecc_blob->cbKey;
1197 y.data = x.data + ecc_blob->cbKey;
1198 y.size = ecc_blob->cbKey;
1199 k.data = y.data + ecc_blob->cbKey;
1200 k.size = ecc_blob->cbKey;
1201
1202 if ((ret = pgnutls_privkey_import_ecc_raw( handle, curve, &x, &y, &k )))
1203 {
1204 pgnutls_perror( ret );
1205 pgnutls_privkey_deinit( handle );
1206 return STATUS_INTERNAL_ERROR;
1207 }
1208
1209 if ((status = export_gnutls_pubkey_ecc( handle, key->alg_id, key->u.a.pubkey, &key->u.a.pubkey_len )))
1210 {
1211 pgnutls_privkey_deinit( handle );
1212 return status;
1213 }
1214
1215 key_data(key)->privkey = handle;
1216 return STATUS_SUCCESS;
1217 }
1218
1219 static NTSTATUS key_export_rsa( struct key *key, ULONG flags, UCHAR *buf, ULONG len, ULONG *ret_len )
1220 {
1221 BCRYPT_RSAKEY_BLOB *rsa_blob;
1222 gnutls_datum_t m, e, d, p, q, u, e1, e2;
1223 ULONG bitlen = key->u.a.bitlen;
1224 BOOL full = (flags & KEY_EXPORT_FLAG_RSA_FULL);
1225 UCHAR *dst;
1226 int ret;
1227
1228 if ((ret = pgnutls_privkey_export_rsa_raw( key_data(key)->privkey, &m, &e, &d, &p, &q, &u, &e1, &e2 )))
1229 {
1230 pgnutls_perror( ret );
1231 return STATUS_INTERNAL_ERROR;
1232 }
1233
1234 *ret_len = sizeof(*rsa_blob) + EXPORT_SIZE(e,8,0) + EXPORT_SIZE(m,8,1) + EXPORT_SIZE(p,16,1) + EXPORT_SIZE(q,16,1);
1235 if (full) *ret_len += EXPORT_SIZE(e1,16,1) + EXPORT_SIZE(e2,16,1) + EXPORT_SIZE(u,16,1) + EXPORT_SIZE(d,8,1);
1236
1237 if (len >= *ret_len && buf)
1238 {
1239 rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
1240 rsa_blob->Magic = full ? BCRYPT_RSAFULLPRIVATE_MAGIC : BCRYPT_RSAPRIVATE_MAGIC;
1241 rsa_blob->BitLength = bitlen;
1242
1243 dst = (UCHAR *)(rsa_blob + 1);
1244 rsa_blob->cbPublicExp = export_gnutls_datum( dst, bitlen / 8, &e, 0 );
1245
1246 dst += rsa_blob->cbPublicExp;
1247 rsa_blob->cbModulus = export_gnutls_datum( dst, bitlen / 8, &m, 1 );
1248
1249 dst += rsa_blob->cbModulus;
1250 rsa_blob->cbPrime1 = export_gnutls_datum( dst, bitlen / 16, &p, 1 );
1251
1252 dst += rsa_blob->cbPrime1;
1253 rsa_blob->cbPrime2 = export_gnutls_datum( dst, bitlen / 16, &q, 1 );
1254
1255 if (full)
1256 {
1257 dst += rsa_blob->cbPrime2;
1258 export_gnutls_datum( dst, bitlen / 16, &e1, 1 );
1259
1260 dst += rsa_blob->cbPrime1;
1261 export_gnutls_datum( dst, bitlen / 16, &e2, 1 );
1262
1263 dst += rsa_blob->cbPrime2;
1264 export_gnutls_datum( dst, bitlen / 16, &u, 1 );
1265
1266 dst += rsa_blob->cbPrime1;
1267 export_gnutls_datum( dst, bitlen / 8, &d, 1 );
1268 }
1269 }
1270
1271 free( m.data ); free( e.data ); free( d.data ); free( p.data ); free( q.data ); free( u.data );
1272 free( e1.data ); free( e2.data );
1273 return STATUS_SUCCESS;
1274 }
1275
1276 static NTSTATUS key_import_rsa( void *args )
1277 {
1278 const struct key_import_params *params = args;
1279 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)params->buf;
1280 gnutls_datum_t m, e, p, q;
1281 gnutls_privkey_t handle;
1282 int ret;
1283
1284 if ((ret = pgnutls_privkey_init( &handle )))
1285 {
1286 pgnutls_perror( ret );
1287 return STATUS_INTERNAL_ERROR;
1288 }
1289
1290 e.data = (unsigned char *)(rsa_blob + 1);
1291 e.size = rsa_blob->cbPublicExp;
1292 m.data = e.data + e.size;
1293 m.size = rsa_blob->cbModulus;
1294 p.data = m.data + m.size;
1295 p.size = rsa_blob->cbPrime1;
1296 q.data = p.data + p.size;
1297 q.size = rsa_blob->cbPrime2;
1298
1299 if ((ret = pgnutls_privkey_import_rsa_raw( handle, &m, &e, NULL, &p, &q, NULL, NULL, NULL )))
1300 {
1301 pgnutls_perror( ret );
1302 pgnutls_privkey_deinit( handle );
1303 return STATUS_INTERNAL_ERROR;
1304 }
1305
1306 key_data(params->key)->privkey = handle;
1307 return STATUS_SUCCESS;
1308 }
1309
1310 static NTSTATUS key_export_dsa_capi( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
1311 {
1312 BLOBHEADER *hdr;
1313 DSSPUBKEY *pubkey;
1314 gnutls_datum_t p, q, g, y, x;
1315 UCHAR *dst;
1316 int ret, size;
1317
1318 if ((ret = pgnutls_privkey_export_dsa_raw( key_data(key)->privkey, &p, &q, &g, &y, &x )))
1319 {
1320 pgnutls_perror( ret );
1321 return STATUS_INTERNAL_ERROR;
1322 }
1323
1324 if (q.size > 21 || x.size > 21)
1325 {
1326 ERR( "can't export key in this format\n" );
1327 free( p.data ); free( q.data ); free( g.data ); free( y.data ); free( x.data );
1328 return STATUS_NOT_SUPPORTED;
1329 }
1330
1331 size = key->u.a.bitlen / 8;
1332 *ret_len = sizeof(*hdr) + sizeof(*pubkey) + size * 2 + 40 + sizeof(key->u.a.dss_seed);
1333 if (len >= *ret_len && buf)
1334 {
1335 hdr = (BLOBHEADER *)buf;
1336 hdr->bType = PRIVATEKEYBLOB;
1337 hdr->bVersion = 2;
1338 hdr->reserved = 0;
1339 hdr->aiKeyAlg = CALG_DSS_SIGN;
1340
1341 pubkey = (DSSPUBKEY *)(hdr + 1);
1342 pubkey->magic = MAGIC_DSS2;
1343 pubkey->bitlen = key->u.a.bitlen;
1344
1345 dst = (UCHAR *)(pubkey + 1);
1346 export_gnutls_datum( dst, size, &p, 1 );
1347 reverse_bytes( dst, size );
1348 dst += size;
1349
1350 export_gnutls_datum( dst, 20, &q, 1 );
1351 reverse_bytes( dst, 20 );
1352 dst += 20;
1353
1354 export_gnutls_datum( dst, size, &g, 1 );
1355 reverse_bytes( dst, size );
1356 dst += size;
1357
1358 export_gnutls_datum( dst, 20, &x, 1 );
1359 reverse_bytes( dst, 20 );
1360 dst += 20;
1361
1362 memcpy( dst, &key->u.a.dss_seed, sizeof(key->u.a.dss_seed) );
1363 }
1364
1365 free( p.data ); free( q.data ); free( g.data ); free( y.data ); free( x.data );
1366 return STATUS_SUCCESS;
1367 }
1368
1369 static NTSTATUS key_import_dsa_capi( void *args )
1370 {
1371 const struct key_import_params *params = args;
1372 struct key *key = params->key;
1373 BLOBHEADER *hdr = (BLOBHEADER *)params->buf;
1374 DSSPUBKEY *pubkey;
1375 gnutls_privkey_t handle;
1376 gnutls_datum_t p, q, g, y, x;
1377 unsigned char dummy[128];
1378 unsigned char *data, p_data[128], q_data[20], g_data[128], x_data[20];
1379 int i, ret, size;
1380 NTSTATUS status;
1381
1382 if ((ret = pgnutls_privkey_init( &handle )))
1383 {
1384 pgnutls_perror( ret );
1385 return STATUS_INTERNAL_ERROR;
1386 }
1387
1388 pubkey = (DSSPUBKEY *)(hdr + 1);
1389 if ((size = pubkey->bitlen / 8) > sizeof(p_data))
1390 {
1391 FIXME( "size %u not supported\n", size );
1392 pgnutls_privkey_deinit( handle );
1393 return STATUS_NOT_SUPPORTED;
1394 }
1395 data = (unsigned char *)(pubkey + 1);
1396
1397 p.data = p_data;
1398 p.size = size;
1399 for (i = 0; i < p.size; i++) p.data[i] = data[p.size - i - 1];
1400 data += p.size;
1401
1402 q.data = q_data;
1403 q.size = sizeof(q_data);
1404 for (i = 0; i < q.size; i++) q.data[i] = data[q.size - i - 1];
1405 data += q.size;
1406
1407 g.data = g_data;
1408 g.size = size;
1409 for (i = 0; i < g.size; i++) g.data[i] = data[g.size - i - 1];
1410 data += g.size;
1411
1412 x.data = x_data;
1413 x.size = sizeof(x_data);
1414 for (i = 0; i < x.size; i++) x.data[i] = data[x.size - i - 1];
1415 data += x.size;
1416
1417 WARN( "using dummy public key\n" );
1418 memset( dummy, 1, sizeof(dummy) );
1419 y.data = dummy;
1420 y.size = min( p.size, sizeof(dummy) );
1421
1422 if ((ret = pgnutls_privkey_import_dsa_raw( handle, &p, &q, &g, &y, &x )))
1423 {
1424 pgnutls_perror( ret );
1425 pgnutls_privkey_deinit( handle );
1426 return STATUS_INTERNAL_ERROR;
1427 }
1428
1429 if ((status = export_gnutls_pubkey_dsa_capi( handle, &key->u.a.dss_seed, key->u.a.bitlen,
1430 key->u.a.pubkey, &key->u.a.pubkey_len )))
1431 {
1432 pgnutls_privkey_deinit( handle );
1433 return status;
1434 }
1435
1436 memcpy( &key->u.a.dss_seed, data, sizeof(key->u.a.dss_seed) );
1437
1438 key->u.a.flags |= KEY_FLAG_LEGACY_DSA_V2;
1439 key_data(key)->privkey = handle;
1440
1441 return STATUS_SUCCESS;
1442 }
1443
1444 static NTSTATUS import_gnutls_pubkey_ecc( struct key *key, gnutls_pubkey_t *gnutls_key )
1445 {
1446 BCRYPT_ECCKEY_BLOB *ecc_blob;
1447 gnutls_ecc_curve_t curve;
1448 gnutls_datum_t x, y;
1449 int ret;
1450
1451 switch (key->alg_id)
1452 {
1453 case ALG_ID_ECDSA_P256: curve = GNUTLS_ECC_CURVE_SECP256R1; break;
1454 case ALG_ID_ECDSA_P384: curve = GNUTLS_ECC_CURVE_SECP384R1; break;
1455
1456 default:
1457 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1458 return STATUS_NOT_IMPLEMENTED;
1459 }
1460
1461 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1462 {
1463 pgnutls_perror( ret );
1464 return STATUS_INTERNAL_ERROR;
1465 }
1466
1467 ecc_blob = (BCRYPT_ECCKEY_BLOB *)key->u.a.pubkey;
1468 x.data = key->u.a.pubkey + sizeof(*ecc_blob);
1469 x.size = ecc_blob->cbKey;
1470 y.data = key->u.a.pubkey + sizeof(*ecc_blob) + ecc_blob->cbKey;
1471 y.size = ecc_blob->cbKey;
1472
1473 if ((ret = pgnutls_pubkey_import_ecc_raw( *gnutls_key, curve, &x, &y )))
1474 {
1475 pgnutls_perror( ret );
1476 pgnutls_pubkey_deinit( *gnutls_key );
1477 return STATUS_INTERNAL_ERROR;
1478 }
1479
1480 return STATUS_SUCCESS;
1481 }
1482
1483 static NTSTATUS import_gnutls_pubkey_rsa( struct key *key, gnutls_pubkey_t *gnutls_key )
1484 {
1485 BCRYPT_RSAKEY_BLOB *rsa_blob;
1486 gnutls_datum_t m, e;
1487 int ret;
1488
1489 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1490 {
1491 pgnutls_perror( ret );
1492 return STATUS_INTERNAL_ERROR;
1493 }
1494
1495 rsa_blob = (BCRYPT_RSAKEY_BLOB *)key->u.a.pubkey;
1496 e.data = key->u.a.pubkey + sizeof(*rsa_blob);
1497 e.size = rsa_blob->cbPublicExp;
1498 m.data = key->u.a.pubkey + sizeof(*rsa_blob) + rsa_blob->cbPublicExp;
1499 m.size = rsa_blob->cbModulus;
1500
1501 if ((ret = pgnutls_pubkey_import_rsa_raw( *gnutls_key, &m, &e )))
1502 {
1503 pgnutls_perror( ret );
1504 pgnutls_pubkey_deinit( *gnutls_key );
1505 return STATUS_INTERNAL_ERROR;
1506 }
1507
1508 return STATUS_SUCCESS;
1509 }
1510
1511 static NTSTATUS import_gnutls_pubkey_dsa( struct key *key, gnutls_pubkey_t *gnutls_key )
1512 {
1513 BCRYPT_DSA_KEY_BLOB *dsa_blob;
1514 gnutls_datum_t p, q, g, y;
1515 int ret;
1516
1517 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1518 {
1519 pgnutls_perror( ret );
1520 return STATUS_INTERNAL_ERROR;
1521 }
1522
1523 dsa_blob = (BCRYPT_DSA_KEY_BLOB *)key->u.a.pubkey;
1524 p.data = key->u.a.pubkey + sizeof(*dsa_blob);
1525 p.size = dsa_blob->cbKey;
1526 q.data = dsa_blob->q;
1527 q.size = sizeof(dsa_blob->q);
1528 g.data = key->u.a.pubkey + sizeof(*dsa_blob) + dsa_blob->cbKey;
1529 g.size = dsa_blob->cbKey;
1530 y.data = key->u.a.pubkey + sizeof(*dsa_blob) + dsa_blob->cbKey * 2;
1531 y.size = dsa_blob->cbKey;
1532
1533 if ((ret = pgnutls_pubkey_import_dsa_raw( *gnutls_key, &p, &q, &g, &y )))
1534 {
1535 pgnutls_perror( ret );
1536 pgnutls_pubkey_deinit( *gnutls_key );
1537 return STATUS_INTERNAL_ERROR;
1538 }
1539
1540 return STATUS_SUCCESS;
1541 }
1542
1543 static NTSTATUS import_gnutls_pubkey_dsa_capi( struct key *key, gnutls_pubkey_t *gnutls_key )
1544 {
1545 BLOBHEADER *hdr;
1546 DSSPUBKEY *pubkey;
1547 gnutls_datum_t p, q, g, y;
1548 unsigned char *data, p_data[128], q_data[20], g_data[128], y_data[128];
1549 int i, ret, size;
1550
1551 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1552 {
1553 pgnutls_perror( ret );
1554 return STATUS_INTERNAL_ERROR;
1555 }
1556
1557 hdr = (BLOBHEADER *)key->u.a.pubkey;
1558 pubkey = (DSSPUBKEY *)(hdr + 1);
1559 size = pubkey->bitlen / 8;
1560 data = (unsigned char *)(pubkey + 1);
1561
1562 p.data = p_data;
1563 p.size = size;
1564 for (i = 0; i < p.size; i++) p.data[i] = data[p.size - i - 1];
1565 data += p.size;
1566
1567 q.data = q_data;
1568 q.size = sizeof(q_data);
1569 for (i = 0; i < q.size; i++) q.data[i] = data[q.size - i - 1];
1570 data += q.size;
1571
1572 g.data = g_data;
1573 g.size = size;
1574 for (i = 0; i < g.size; i++) g.data[i] = data[g.size - i - 1];
1575 data += g.size;
1576
1577 y.data = y_data;
1578 y.size = sizeof(y_data);
1579 for (i = 0; i < y.size; i++) y.data[i] = data[y.size - i - 1];
1580
1581 if ((ret = pgnutls_pubkey_import_dsa_raw( *gnutls_key, &p, &q, &g, &y )))
1582 {
1583 pgnutls_perror( ret );
1584 pgnutls_pubkey_deinit( *gnutls_key );
1585 return STATUS_INTERNAL_ERROR;
1586 }
1587
1588 return STATUS_SUCCESS;
1589 }
1590
1591 static NTSTATUS import_gnutls_pubkey( struct key *key, gnutls_pubkey_t *gnutls_key )
1592 {
1593 switch (key->alg_id)
1594 {
1595 case ALG_ID_ECDSA_P256:
1596 case ALG_ID_ECDSA_P384:
1597 return import_gnutls_pubkey_ecc( key, gnutls_key );
1598
1599 case ALG_ID_RSA:
1600 case ALG_ID_RSA_SIGN:
1601 return import_gnutls_pubkey_rsa( key, gnutls_key );
1602
1603 case ALG_ID_DSA:
1604 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1605 return import_gnutls_pubkey_dsa_capi( key, gnutls_key );
1606 else
1607 return import_gnutls_pubkey_dsa( key, gnutls_key );
1608
1609 default:
1610 FIXME("algorithm %u not yet supported\n", key->alg_id );
1611 return STATUS_NOT_IMPLEMENTED;
1612 }
1613 }
1614
1615 static NTSTATUS key_asymmetric_export( void *args )
1616 {
1617 const struct key_asymmetric_export_params *params = args;
1618 struct key *key = params->key;
1619 unsigned flags = params->flags;
1620
1621 switch (key->alg_id)
1622 {
1623 case ALG_ID_ECDH_P256:
1624 case ALG_ID_ECDSA_P256:
1625 case ALG_ID_ECDSA_P384:
1626 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1627 return key_export_ecc_public( key, params->buf, params->len, params->ret_len );
1628 return key_export_ecc( key, params->buf, params->len, params->ret_len );
1629
1630 case ALG_ID_RSA:
1631 case ALG_ID_RSA_SIGN:
1632 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1633 return key_export_rsa_public( key, params->buf, params->len, params->ret_len );
1634 return key_export_rsa( key, flags, params->buf, params->len, params->ret_len );
1635
1636 case ALG_ID_DSA:
1637 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1638 {
1639 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1640 return key_export_dsa_capi_public( key, params->buf, params->len, params->ret_len );
1641 return key_export_dsa_public( key, params->buf, params->len, params->ret_len );
1642 }
1643 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1644 return key_export_dsa_capi( key, params->buf, params->len, params->ret_len );
1645 return STATUS_NOT_IMPLEMENTED;
1646
1647 default:
1648 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1649 return STATUS_NOT_IMPLEMENTED;
1650 }
1651 }
1652
1653 static NTSTATUS prepare_gnutls_signature_dsa( struct key *key, UCHAR *signature, ULONG signature_len,
1654 gnutls_datum_t *gnutls_signature )
1655 {
1656 struct buffer buffer;
1657 DWORD r_len = signature_len / 2;
1658 DWORD s_len = r_len;
1659 BYTE *r = signature;
1660 BYTE *s = signature + r_len;
1661
1662 buffer_init( &buffer );
1663 buffer_append_asn1_r_s( &buffer, r, r_len, s, s_len );
1664 if (buffer.error)
1665 {
1666 buffer_free( &buffer );
1667 return STATUS_NO_MEMORY;
1668 }
1669
1670 gnutls_signature->data = buffer.buffer;
1671 gnutls_signature->size = buffer.pos;
1672 return STATUS_SUCCESS;
1673 }
1674
1675 static NTSTATUS prepare_gnutls_signature_rsa( struct key *key, UCHAR *signature, ULONG signature_len,
1676 gnutls_datum_t *gnutls_signature )
1677 {
1678 gnutls_signature->data = signature;
1679 gnutls_signature->size = signature_len;
1680 return STATUS_SUCCESS;
1681 }
1682
1683 static NTSTATUS prepare_gnutls_signature( struct key *key, UCHAR *signature, ULONG signature_len,
1684 gnutls_datum_t *gnutls_signature )
1685 {
1686 switch (key->alg_id)
1687 {
1688 case ALG_ID_ECDSA_P256:
1689 case ALG_ID_ECDSA_P384:
1690 case ALG_ID_DSA:
1691 return prepare_gnutls_signature_dsa( key, signature, signature_len, gnutls_signature );
1692
1693 case ALG_ID_RSA:
1694 case ALG_ID_RSA_SIGN:
1695 return prepare_gnutls_signature_rsa( key, signature, signature_len, gnutls_signature );
1696
1697 default:
1698 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1699 return STATUS_NOT_IMPLEMENTED;
1700 }
1701 }
1702
1703 static gnutls_digest_algorithm_t get_digest_from_id( const WCHAR *alg_id )
1704 {
1705 if (!wcscmp( alg_id, BCRYPT_SHA1_ALGORITHM )) return GNUTLS_DIG_SHA1;
1706 if (!wcscmp( alg_id, BCRYPT_SHA256_ALGORITHM )) return GNUTLS_DIG_SHA256;
1707 if (!wcscmp( alg_id, BCRYPT_SHA384_ALGORITHM )) return GNUTLS_DIG_SHA384;
1708 if (!wcscmp( alg_id, BCRYPT_SHA512_ALGORITHM )) return GNUTLS_DIG_SHA512;
1709 if (!wcscmp( alg_id, BCRYPT_MD2_ALGORITHM )) return GNUTLS_DIG_MD2;
1710 if (!wcscmp( alg_id, BCRYPT_MD5_ALGORITHM )) return GNUTLS_DIG_MD5;
1711 return -1;
1712 }
1713
1714 static NTSTATUS key_asymmetric_verify( void *args )
1715 {
1716 const struct key_asymmetric_verify_params *params = args;
1717 struct key *key = params->key;
1718 unsigned flags = params->flags;
1719 gnutls_digest_algorithm_t hash_alg;
1720 gnutls_sign_algorithm_t sign_alg;
1721 gnutls_datum_t gnutls_hash, gnutls_signature;
1722 gnutls_pk_algorithm_t pk_alg;
1723 gnutls_pubkey_t gnutls_key;
1724 NTSTATUS status;
1725 int ret;
1726
1727 switch (key->alg_id)
1728 {
1729 case ALG_ID_ECDSA_P256:
1730 case ALG_ID_ECDSA_P384:
1731 {
1732 if (flags) FIXME( "flags %#x not supported\n", flags );
1733
1734 /* only the hash size must match, not the actual hash function */
1735 switch (params->hash_len)
1736 {
1737 case 20: hash_alg = GNUTLS_DIG_SHA1; break;
1738 case 32: hash_alg = GNUTLS_DIG_SHA256; break;
1739 case 48: hash_alg = GNUTLS_DIG_SHA384; break;
1740
1741 default:
1742 FIXME( "hash size %u not yet supported\n", params->hash_len );
1743 return STATUS_INVALID_SIGNATURE;
1744 }
1745 pk_alg = GNUTLS_PK_ECC;
1746 break;
1747 }
1748 case ALG_ID_RSA:
1749 case ALG_ID_RSA_SIGN:
1750 {
1751 BCRYPT_PKCS1_PADDING_INFO *info = params->padding;
1752
1753 if (!(flags & BCRYPT_PAD_PKCS1) || !info) return STATUS_INVALID_PARAMETER;
1754 if (!info->pszAlgId) return STATUS_INVALID_SIGNATURE;
1755
1756 if ((hash_alg = get_digest_from_id(info->pszAlgId)) == -1)
1757 {
1758 FIXME( "hash algorithm %s not supported\n", debugstr_w(info->pszAlgId) );
1759 return STATUS_NOT_SUPPORTED;
1760 }
1761 pk_alg = GNUTLS_PK_RSA;
1762 break;
1763 }
1764 case ALG_ID_DSA:
1765 {
1766 if (flags) FIXME( "flags %#x not supported\n", flags );
1767 if (params->hash_len != 20)
1768 {
1769 FIXME( "hash size %u not supported\n", params->hash_len );
1770 return STATUS_INVALID_PARAMETER;
1771 }
1772 hash_alg = GNUTLS_DIG_SHA1;
1773 pk_alg = GNUTLS_PK_DSA;
1774 break;
1775 }
1776 default:
1777 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1778 return STATUS_NOT_IMPLEMENTED;
1779 }
1780
1781 if ((sign_alg = pgnutls_pk_to_sign( pk_alg, hash_alg )) == GNUTLS_SIGN_UNKNOWN)
1782 {
1783 FIXME("GnuTLS does not support algorithm %u with hash len %u\n", key->alg_id, params->hash_len );
1784 return STATUS_NOT_IMPLEMENTED;
1785 }
1786
1787 if ((status = import_gnutls_pubkey( key, &gnutls_key ))) return status;
1788 if ((status = prepare_gnutls_signature( key, params->signature, params->signature_len, &gnutls_signature )))
1789 {
1790 pgnutls_pubkey_deinit( gnutls_key );
1791 return status;
1792 }
1793
1794 gnutls_hash.data = params->hash;
1795 gnutls_hash.size = params->hash_len;
1796 ret = pgnutls_pubkey_verify_hash2( gnutls_key, sign_alg, 0, &gnutls_hash, &gnutls_signature );
1797
1798 if (gnutls_signature.data != params->signature) free( gnutls_signature.data );
1799 pgnutls_pubkey_deinit( gnutls_key );
1800 return (ret < 0) ? STATUS_INVALID_SIGNATURE : STATUS_SUCCESS;
1801 }
1802
1803 static unsigned int get_signature_length( enum alg_id id )
1804 {
1805 switch (id)
1806 {
1807 case ALG_ID_ECDSA_P256: return 64;
1808 case ALG_ID_ECDSA_P384: return 96;
1809 case ALG_ID_DSA: return 40;
1810 default:
1811 FIXME( "unhandled algorithm %u\n", id );
1812 return 0;
1813 }
1814 }
1815
1816 static NTSTATUS format_gnutls_signature( enum alg_id type, gnutls_datum_t signature,
1817 UCHAR *output, ULONG output_len, ULONG *ret_len )
1818 {
1819 switch (type)
1820 {
1821 case ALG_ID_RSA:
1822 case ALG_ID_RSA_SIGN:
1823 {
1824 *ret_len = signature.size;
1825 if (output_len < signature.size) return STATUS_BUFFER_TOO_SMALL;
1826 if (output) memcpy( output, signature.data, signature.size );
1827 return STATUS_SUCCESS;
1828 }
1829 case ALG_ID_ECDSA_P256:
1830 case ALG_ID_ECDSA_P384:
1831 case ALG_ID_DSA:
1832 {
1833 int err;
1834 unsigned int sig_len = get_signature_length( type );
1835 gnutls_datum_t r, s; /* format as r||s */
1836
1837 if ((err = pgnutls_decode_rs_value( &signature, &r, &s )))
1838 {
1839 pgnutls_perror( err );
1840 return STATUS_INTERNAL_ERROR;
1841 }
1842
1843 *ret_len = sig_len;
1844 if (output_len < sig_len) return STATUS_BUFFER_TOO_SMALL;
1845
1846 if (r.size > sig_len / 2 + 1 || s.size > sig_len / 2 + 1)
1847 {
1848 ERR( "we didn't get a correct signature\n" );
1849 return STATUS_INTERNAL_ERROR;
1850 }
1851
1852 if (output)
1853 {
1854 export_gnutls_datum( output, sig_len / 2, &r, 1 );
1855 export_gnutls_datum( output + sig_len / 2, sig_len / 2, &s, 1 );
1856 }
1857
1858 free( r.data ); free( s.data );
1859 return STATUS_SUCCESS;
1860 }
1861 default:
1862 return STATUS_INTERNAL_ERROR;
1863 }
1864 }
1865
1866 static NTSTATUS key_asymmetric_sign( void *args )
1867 {
1868 const struct key_asymmetric_sign_params *params = args;
1869 struct key *key = params->key;
1870 unsigned flags = params->flags;
1871 BCRYPT_PKCS1_PADDING_INFO *pad = params->padding;
1872 gnutls_datum_t hash, signature;
1873 gnutls_digest_algorithm_t hash_alg;
1874 NTSTATUS status;
1875 int ret;
1876
1877 if (key->alg_id == ALG_ID_ECDSA_P256 || key->alg_id == ALG_ID_ECDSA_P384)
1878 {
1879 /* With ECDSA, we find the digest algorithm from the hash length, and verify it */
1880 switch (params->input_len)
1881 {
1882 case 20: hash_alg = GNUTLS_DIG_SHA1; break;
1883 case 32: hash_alg = GNUTLS_DIG_SHA256; break;
1884 case 48: hash_alg = GNUTLS_DIG_SHA384; break;
1885 case 64: hash_alg = GNUTLS_DIG_SHA512; break;
1886
1887 default:
1888 FIXME( "hash size %u not yet supported\n", params->input_len );
1889 return STATUS_INVALID_PARAMETER;
1890 }
1891
1892 if (flags == BCRYPT_PAD_PKCS1 && pad && pad->pszAlgId && get_digest_from_id( pad->pszAlgId ) != hash_alg)
1893 {
1894 WARN( "incorrect hashing algorithm %s, expected %u\n", debugstr_w(pad->pszAlgId), hash_alg );
1895 return STATUS_INVALID_PARAMETER;
1896 }
1897 }
1898 else if (key->alg_id == ALG_ID_DSA)
1899 {
1900 if (flags) FIXME( "flags %#x not supported\n", flags );
1901 if (params->input_len != 20)
1902 {
1903 FIXME( "hash size %u not supported\n", params->input_len );
1904 return STATUS_INVALID_PARAMETER;
1905 }
1906 hash_alg = GNUTLS_DIG_SHA1;
1907 }
1908 else if (flags == BCRYPT_PAD_PKCS1)
1909 {
1910 if (!pad || !pad->pszAlgId)
1911 {
1912 WARN( "padding info not found\n" );
1913 return STATUS_INVALID_PARAMETER;
1914 }
1915
1916 if ((hash_alg = get_digest_from_id( pad->pszAlgId )) == -1)
1917 {
1918 FIXME( "hash algorithm %s not recognized\n", debugstr_w(pad->pszAlgId) );
1919 return STATUS_NOT_SUPPORTED;
1920 }
1921 }
1922 else if (!flags)
1923 {
1924 WARN( "invalid flags %#x\n", flags );
1925 return STATUS_INVALID_PARAMETER;
1926 }
1927 else
1928 {
1929 FIXME( "flags %#x not implemented\n", flags );
1930 return STATUS_NOT_IMPLEMENTED;
1931 }
1932
1933 if (!params->output)
1934 {
1935 *params->ret_len = key->u.a.bitlen / 8;
1936 return STATUS_SUCCESS;
1937 }
1938 if (!key_data(key)->privkey) return STATUS_INVALID_PARAMETER;
1939
1940 hash.data = params->input;
1941 hash.size = params->input_len;
1942
1943 signature.data = NULL;
1944 signature.size = 0;
1945
1946 if ((ret = pgnutls_privkey_sign_hash( key_data(key)->privkey, hash_alg, 0, &hash, &signature )))
1947 {
1948 pgnutls_perror( ret );
1949 return STATUS_INTERNAL_ERROR;
1950 }
1951
1952 status = format_gnutls_signature( key->alg_id, signature, params->output,
1953 params->output_len, params->ret_len );
1954
1955 free( signature.data );
1956 return status;
1957 }
1958
1959 static NTSTATUS key_asymmetric_destroy( void *args )
1960 {
1961 struct key *key = args;
1962
1963 if (key_data(key)->privkey) pgnutls_privkey_deinit( key_data(key)->privkey );
1964 return STATUS_SUCCESS;
1965 }
1966
1967 static NTSTATUS key_asymmetric_duplicate( void *args )
1968 {
1969 const struct key_asymmetric_duplicate_params *params = args;
1970 struct key *key_orig = params->key_orig;
1971 struct key *key_copy = params->key_copy;
1972 int ret;
1973
1974 if (!key_data(key_orig)->privkey) return STATUS_SUCCESS;
1975
1976 if ((ret = pgnutls_privkey_init( &key_data(key_copy)->privkey )))
1977 {
1978 pgnutls_perror( ret );
1979 return STATUS_INTERNAL_ERROR;
1980 }
1981
1982 switch (key_orig->alg_id)
1983 {
1984 case ALG_ID_RSA:
1985 case ALG_ID_RSA_SIGN:
1986 {
1987 gnutls_datum_t m, e, d, p, q, u, e1, e2;
1988 if ((ret = pgnutls_privkey_export_rsa_raw( key_data(key_orig)->privkey, &m, &e, &d, &p, &q, &u, &e1, &e2 )))
1989 {
1990 pgnutls_perror( ret );
1991 return STATUS_INTERNAL_ERROR;
1992 }
1993 ret = pgnutls_privkey_import_rsa_raw( key_data(key_copy)->privkey, &m, &e, &d, &p, &q, &u, &e1, &e2 );
1994 free( m.data ); free( e.data ); free( d.data ); free( p.data ); free( q.data ); free( u.data );
1995 free( e1.data ); free( e2.data );
1996 if (ret)
1997 {
1998 pgnutls_perror( ret );
1999 return STATUS_INTERNAL_ERROR;
2000 }
2001 break;
2002 }
2003 case ALG_ID_DSA:
2004 {
2005 gnutls_datum_t p, q, g, y, x;
2006 if ((ret = pgnutls_privkey_export_dsa_raw( key_data(key_orig)->privkey, &p, &q, &g, &y, &x )))
2007 {
2008 pgnutls_perror( ret );
2009 return STATUS_INTERNAL_ERROR;
2010 }
2011 ret = pgnutls_privkey_import_dsa_raw( key_data(key_copy)->privkey, &p, &q, &g, &y, &x );
2012 free( p.data ); free( q.data ); free( g.data ); free( y.data ); free( x.data );
2013 if (ret)
2014 {
2015 pgnutls_perror( ret );
2016 return STATUS_INTERNAL_ERROR;
2017 }
2018 break;
2019 }
2020 case ALG_ID_ECDH_P256:
2021 case ALG_ID_ECDSA_P256:
2022 case ALG_ID_ECDSA_P384:
2023 {
2024 gnutls_ecc_curve_t curve;
2025 gnutls_datum_t x, y, k;
2026 if ((ret = pgnutls_privkey_export_ecc_raw( key_data(key_orig)->privkey, &curve, &x, &y, &k )))
2027 {
2028 pgnutls_perror( ret );
2029 return STATUS_INTERNAL_ERROR;
2030 }
2031 ret = pgnutls_privkey_import_ecc_raw( key_data(key_copy)->privkey, curve, &x, &y, &k );
2032 free( x.data ); free( y.data ); free( k.data );
2033 if (ret)
2034 {
2035 pgnutls_perror( ret );
2036 return STATUS_INTERNAL_ERROR;
2037 }
2038 break;
2039 }
2040 default:
2041 ERR( "unhandled algorithm %u\n", key_orig->alg_id );
2042 return STATUS_INTERNAL_ERROR;
2043 }
2044
2045 return STATUS_SUCCESS;
2046 }
2047
2048 static NTSTATUS key_asymmetric_decrypt( void *args )
2049 {
2050 const struct key_asymmetric_decrypt_params *params = args;
2051 gnutls_datum_t e, d = { 0 };
2052 NTSTATUS status = STATUS_SUCCESS;
2053 int ret;
2054
2055 e.data = params->input;
2056 e.size = params->input_len;
2057 if ((ret = pgnutls_privkey_decrypt_data( key_data(params->key)->privkey, 0, &e, &d )))
2058 {
2059 pgnutls_perror( ret );
2060 return STATUS_INTERNAL_ERROR;
2061 }
2062
2063 *params->ret_len = d.size;
2064 if (params->output_len >= d.size) memcpy( params->output, d.data, *params->ret_len );
2065 else status = STATUS_BUFFER_TOO_SMALL;
2066
2067 free( d.data );
2068 return status;
2069 }
2070
2071 const unixlib_entry_t __wine_unix_call_funcs[] =
2072 {
2073 gnutls_process_attach,
2074 gnutls_process_detach,
2075 key_symmetric_vector_reset,
2076 key_symmetric_set_auth_data,
2077 key_symmetric_encrypt,
2078 key_symmetric_decrypt,
2079 key_symmetric_get_tag,
2080 key_symmetric_destroy,
2081 key_asymmetric_generate,
2082 key_asymmetric_decrypt,
2083 key_asymmetric_duplicate,
2084 key_asymmetric_sign,
2085 key_asymmetric_verify,
2086 key_asymmetric_destroy,
2087 key_asymmetric_export,
2088 key_import_dsa_capi,
2089 key_import_ecc,
2090 key_import_rsa
2091 };
2092
2093 #ifdef _WIN64
2094
2095 typedef ULONG PTR32;
2096
2097 struct key_symmetric32
2098 {
2099 enum mode_id mode;
2100 ULONG block_size;
2101 PTR32 vector;
2102 ULONG vector_len;
2103 PTR32 secret;
2104 ULONG secret_len;
2105 ULONG __cs[6];
2106 };
2107
2108 struct key_asymmetric32
2109 {
2110 ULONG bitlen; /* ignored for ECC keys */
2111 ULONG flags;
2112 PTR32 pubkey;
2113 ULONG pubkey_len;
2114 DSSSEED dss_seed;
2115 };
2116
2117 struct key32
2118 {
2119 struct object hdr;
2120 enum alg_id alg_id;
2121 UINT64 private[2]; /* private data for backend */
2122 union
2123 {
2124 struct key_symmetric32 s;
2125 struct key_asymmetric32 a;
2126 } u;
2127 };
2128
2129 static struct key *get_symmetric_key( struct key32 *key32, struct key *key )
2130 {
2131 key->hdr = key32->hdr;
2132 key->alg_id = key32->alg_id;
2133 key->private[0] = key32->private[0];
2134 key->private[1] = key32->private[1];
2135 key->u.s.mode = key32->u.s.mode;
2136 key->u.s.block_size = key32->u.s.block_size;
2137 key->u.s.vector = ULongToPtr(key32->u.s.vector);
2138 key->u.s.vector_len = key32->u.s.vector_len;
2139 key->u.s.secret = ULongToPtr(key32->u.s.secret);
2140 key->u.s.secret_len = key32->u.s.secret_len;
2141 return key;
2142 }
2143
2144 static struct key *get_asymmetric_key( struct key32 *key32, struct key *key )
2145 {
2146 key->hdr = key32->hdr;
2147 key->alg_id = key32->alg_id;
2148 key->private[0] = key32->private[0];
2149 key->private[1] = key32->private[1];
2150 key->u.a.bitlen = key32->u.a.bitlen;
2151 key->u.a.flags = key32->u.a.flags;
2152 key->u.a.pubkey = ULongToPtr(key32->u.a.pubkey);
2153 key->u.a.pubkey_len = key32->u.a.pubkey_len;
2154 key->u.a.dss_seed = key32->u.a.dss_seed;
2155 return key;
2156 }
2157
2158 static void put_symmetric_key32( struct key *key, struct key32 *key32 )
2159 {
2160 key32->private[0] = key->private[0];
2161 key32->private[1] = key->private[1];
2162 }
2163
2164 static void put_asymmetric_key32( struct key *key, struct key32 *key32 )
2165 {
2166 key32->private[0] = key->private[0];
2167 key32->private[1] = key->private[1];
2168 key32->u.a.flags = key->u.a.flags;
2169 key32->u.a.pubkey_len = key->u.a.pubkey_len;
2170 key32->u.a.dss_seed = key->u.a.dss_seed;
2171 }
2172
2173 static NTSTATUS wow64_key_symmetric_vector_reset( void *args )
2174 {
2175 NTSTATUS ret;
2176 struct key key;
2177 struct key32 *key32 = args;
2178
2179 ret = key_symmetric_vector_reset( get_symmetric_key( key32, &key ));
2180 put_symmetric_key32( &key, key32 );
2181 return ret;
2182 }
2183
2184 static NTSTATUS wow64_key_symmetric_set_auth_data( void *args )
2185 {
2186 struct
2187 {
2188 PTR32 key;
2189 PTR32 auth_data;
2190 ULONG len;
2191 } const *params32 = args;
2192
2193 NTSTATUS ret;
2194 struct key key;
2195 struct key32 *key32 = ULongToPtr( params32->key );
2196 struct key_symmetric_set_auth_data_params params =
2197 {
2198 get_symmetric_key( key32, &key ),
2199 ULongToPtr(params32->auth_data),
2200 params32->len
2201 };
2202
2203 ret = key_symmetric_set_auth_data( &params );
2204 put_symmetric_key32( &key, key32 );
2205 return ret;
2206 }
2207
2208 static NTSTATUS wow64_key_symmetric_encrypt( void *args )
2209 {
2210 struct
2211 {
2212 PTR32 key;
2213 PTR32 input;
2214 ULONG input_len;
2215 PTR32 output;
2216 ULONG output_len;
2217 } const *params32 = args;
2218
2219 NTSTATUS ret;
2220 struct key key;
2221 struct key32 *key32 = ULongToPtr( params32->key );
2222 struct key_symmetric_encrypt_params params =
2223 {
2224 get_symmetric_key( key32, &key ),
2225 ULongToPtr(params32->input),
2226 params32->input_len,
2227 ULongToPtr(params32->output),
2228 params32->output_len
2229 };
2230
2231 ret = key_symmetric_encrypt( &params );
2232 put_symmetric_key32( &key, key32 );
2233 return ret;
2234 }
2235
2236 static NTSTATUS wow64_key_symmetric_decrypt( void *args )
2237 {
2238 struct
2239 {
2240 PTR32 key;
2241 PTR32 input;
2242 ULONG input_len;
2243 PTR32 output;
2244 ULONG output_len;
2245 } const *params32 = args;
2246
2247 NTSTATUS ret;
2248 struct key key;
2249 struct key32 *key32 = ULongToPtr( params32->key );
2250 struct key_symmetric_decrypt_params params =
2251 {
2252 get_symmetric_key( key32, &key ),
2253 ULongToPtr(params32->input),
2254 params32->input_len,
2255 ULongToPtr(params32->output),
2256 params32->output_len
2257 };
2258
2259 ret = key_symmetric_decrypt( &params );
2260 put_symmetric_key32( &key, key32 );
2261 return ret;
2262 }
2263
2264 static NTSTATUS wow64_key_symmetric_get_tag( void *args )
2265 {
2266 struct
2267 {
2268 PTR32 key;
2269 PTR32 tag;
2270 ULONG len;
2271 } const *params32 = args;
2272
2273 NTSTATUS ret;
2274 struct key key;
2275 struct key32 *key32 = ULongToPtr( params32->key );
2276 struct key_symmetric_get_tag_params params =
2277 {
2278 get_symmetric_key( key32, &key ),
2279 ULongToPtr(params32->tag),
2280 params32->len
2281 };
2282
2283 ret = key_symmetric_get_tag( &params );
2284 put_symmetric_key32( &key, key32 );
2285 return ret;
2286 }
2287
2288 static NTSTATUS wow64_key_symmetric_destroy( void *args )
2289 {
2290 struct key32 *key32 = args;
2291 struct key key;
2292
2293 return key_symmetric_destroy( get_symmetric_key( key32, &key ));
2294 }
2295
2296 static NTSTATUS wow64_key_asymmetric_generate( void *args )
2297 {
2298 struct key32 *key32 = args;
2299 struct key key;
2300 NTSTATUS ret;
2301
2302 ret = key_asymmetric_generate( get_asymmetric_key( key32, &key ));
2303 put_asymmetric_key32( &key, key32 );
2304 return ret;
2305 }
2306
2307 static NTSTATUS wow64_key_asymmetric_decrypt( void *args )
2308 {
2309 struct
2310 {
2311 PTR32 key;
2312 PTR32 input;
2313 ULONG input_len;
2314 PTR32 output;
2315 ULONG output_len;
2316 PTR32 ret_len;
2317 } const *params32 = args;
2318
2319 NTSTATUS ret;
2320 struct key key;
2321 struct key32 *key32 = ULongToPtr( params32->key );
2322 struct key_asymmetric_decrypt_params params =
2323 {
2324 get_asymmetric_key( key32, &key ),
2325 ULongToPtr(params32->input),
2326 params32->input_len,
2327 ULongToPtr(params32->output),
2328 params32->output_len,
2329 ULongToPtr(params32->ret_len)
2330 };
2331
2332 ret = key_asymmetric_decrypt( &params );
2333 put_asymmetric_key32( &key, key32 );
2334 return ret;
2335 }
2336
2337 static NTSTATUS wow64_key_asymmetric_duplicate( void *args )
2338 {
2339 struct
2340 {
2341 PTR32 key_orig;
2342 PTR32 key_copy;
2343 } const *params32 = args;
2344
2345 NTSTATUS ret;
2346 struct key key_orig, key_copy;
2347 struct key32 *key_orig32 = ULongToPtr( params32->key_orig );
2348 struct key32 *key_copy32 = ULongToPtr( params32->key_copy );
2349 struct key_asymmetric_duplicate_params params =
2350 {
2351 get_asymmetric_key( key_orig32, &key_orig ),
2352 get_asymmetric_key( key_copy32, &key_copy )
2353 };
2354
2355 ret = key_asymmetric_duplicate( &params );
2356 put_asymmetric_key32( &key_copy, key_copy32 );
2357 return ret;
2358 }
2359
2360 static NTSTATUS wow64_key_asymmetric_sign( void *args )
2361 {
2362 struct
2363 {
2364 PTR32 key;
2365 PTR32 padding;
2366 PTR32 input;
2367 ULONG input_len;
2368 PTR32 output;
2369 ULONG output_len;
2370 PTR32 ret_len;
2371 ULONG flags;
2372 } const *params32 = args;
2373
2374 NTSTATUS ret;
2375 struct key key;
2376 BCRYPT_PKCS1_PADDING_INFO padding;
2377 struct key32 *key32 = ULongToPtr( params32->key );
2378 struct key_asymmetric_sign_params params =
2379 {
2380 get_asymmetric_key( key32, &key ),
2381 NULL, /* padding */
2382 ULongToPtr(params32->input),
2383 params32->input_len,
2384 ULongToPtr(params32->output),
2385 params32->output_len,
2386 ULongToPtr(params32->ret_len),
2387 params32->flags
2388 };
2389
2390 if (params32->flags & BCRYPT_PAD_PKCS1)
2391 {
2392 PTR32 *info = ULongToPtr( params32->padding );
2393 if (!info) return STATUS_INVALID_PARAMETER;
2394 padding.pszAlgId = ULongToPtr( *info );
2395 params.padding = &padding;
2396 }
2397
2398 ret = key_asymmetric_sign( &params );
2399 put_asymmetric_key32( &key, key32 );
2400 return ret;
2401 }
2402
2403 static NTSTATUS wow64_key_asymmetric_verify( void *args )
2404 {
2405 struct
2406 {
2407 PTR32 key;
2408 PTR32 padding;
2409 PTR32 hash;
2410 ULONG hash_len;
2411 PTR32 signature;
2412 ULONG signature_len;
2413 ULONG flags;
2414 } const *params32 = args;
2415
2416 NTSTATUS ret;
2417 struct key key;
2418 BCRYPT_PKCS1_PADDING_INFO padding;
2419 struct key32 *key32 = ULongToPtr( params32->key );
2420 struct key_asymmetric_verify_params params =
2421 {
2422 get_asymmetric_key( key32, &key ),
2423 NULL, /* padding */
2424 ULongToPtr(params32->hash),
2425 params32->hash_len,
2426 ULongToPtr(params32->signature),
2427 params32->signature_len,
2428 params32->flags
2429 };
2430
2431 if (params32->flags & BCRYPT_PAD_PKCS1)
2432 {
2433 PTR32 *info = ULongToPtr( params32->padding );
2434 if (!info) return STATUS_INVALID_PARAMETER;
2435 padding.pszAlgId = ULongToPtr( *info );
2436 params.padding = &padding;
2437 }
2438
2439 ret = key_asymmetric_verify( &params );
2440 put_asymmetric_key32( &key, key32 );
2441 return ret;
2442 }
2443
2444 static NTSTATUS wow64_key_asymmetric_destroy( void *args )
2445 {
2446 struct key32 *key32 = args;
2447 struct key key;
2448
2449 return key_asymmetric_destroy( get_asymmetric_key( key32, &key ));
2450 }
2451
2452 static NTSTATUS wow64_key_asymmetric_export( void *args )
2453 {
2454 struct
2455 {
2456 PTR32 key;
2457 ULONG flags;
2458 PTR32 buf;
2459 ULONG len;
2460 PTR32 ret_len;
2461 } const *params32 = args;
2462
2463 NTSTATUS ret;
2464 struct key key;
2465 struct key32 *key32 = ULongToPtr( params32->key );
2466 struct key_asymmetric_export_params params =
2467 {
2468 get_asymmetric_key( key32, &key ),
2469 params32->flags,
2470 ULongToPtr(params32->buf),
2471 params32->len,
2472 ULongToPtr(params32->ret_len),
2473 };
2474
2475 ret = key_asymmetric_export( &params );
2476 put_asymmetric_key32( &key, key32 );
2477 return ret;
2478 }
2479
2480 static NTSTATUS wow64_key_import_dsa_capi( void *args )
2481 {
2482 struct
2483 {
2484 PTR32 key;
2485 PTR32 buf;
2486 ULONG len;
2487 } const *params32 = args;
2488
2489 NTSTATUS ret;
2490 struct key key;
2491 struct key32 *key32 = ULongToPtr( params32->key );
2492 struct key_import_params params =
2493 {
2494 get_asymmetric_key( key32, &key ),
2495 ULongToPtr(params32->buf),
2496 params32->len
2497 };
2498
2499 ret = key_import_dsa_capi( &params );
2500 put_asymmetric_key32( &key, key32 );
2501 return ret;
2502 }
2503
2504 static NTSTATUS wow64_key_import_ecc( void *args )
2505 {
2506 struct
2507 {
2508 PTR32 key;
2509 PTR32 buf;
2510 ULONG len;
2511 } const *params32 = args;
2512
2513 NTSTATUS ret;
2514 struct key key;
2515 struct key32 *key32 = ULongToPtr( params32->key );
2516 struct key_import_params params =
2517 {
2518 get_asymmetric_key( key32, &key ),
2519 ULongToPtr(params32->buf),
2520 params32->len
2521 };
2522
2523 ret = key_import_ecc( &params );
2524 put_asymmetric_key32( &key, key32 );
2525 return ret;
2526 }
2527
2528 static NTSTATUS wow64_key_import_rsa( void *args )
2529 {
2530 struct
2531 {
2532 PTR32 key;
2533 PTR32 buf;
2534 ULONG len;
2535 } const *params32 = args;
2536
2537 NTSTATUS ret;
2538 struct key key;
2539 struct key32 *key32 = ULongToPtr( params32->key );
2540 struct key_import_params params =
2541 {
2542 get_asymmetric_key( key32, &key ),
2543 ULongToPtr(params32->buf),
2544 params32->len
2545 };
2546
2547 ret = key_import_rsa( &params );
2548 put_asymmetric_key32( &key, key32 );
2549 return ret;
2550 }
2551
2552 const unixlib_entry_t __wine_unix_call_wow64_funcs[] =
2553 {
2554 gnutls_process_attach,
2555 gnutls_process_detach,
2556 wow64_key_symmetric_vector_reset,
2557 wow64_key_symmetric_set_auth_data,
2558 wow64_key_symmetric_encrypt,
2559 wow64_key_symmetric_decrypt,
2560 wow64_key_symmetric_get_tag,
2561 wow64_key_symmetric_destroy,
2562 wow64_key_asymmetric_generate,
2563 wow64_key_asymmetric_decrypt,
2564 wow64_key_asymmetric_duplicate,
2565 wow64_key_asymmetric_sign,
2566 wow64_key_asymmetric_verify,
2567 wow64_key_asymmetric_destroy,
2568 wow64_key_asymmetric_export,
2569 wow64_key_import_dsa_capi,
2570 wow64_key_import_ecc,
2571 wow64_key_import_rsa
2572 };
2573
2574 #endif /* _WIN64 */
2575
2576 #endif /* HAVE_GNUTLS_CIPHER_INIT */
Windows API implementation