?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Clear dirty flags after calling all the state handlers in context_apply_draw...
[wine.git] / dlls / bcrypt / gnutls.c
blob9c1e7b5ab06d0f137ba758677782cc8486bf8737
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 #include "wine/port.h"
27
28 #ifdef HAVE_GNUTLS_CIPHER_INIT
29
30 #include <stdarg.h>
31 #include <assert.h>
32 #include <gnutls/gnutls.h>
33 #include <gnutls/crypto.h>
34 #include <gnutls/abstract.h>
35
36 #include "ntstatus.h"
37 #define WIN32_NO_STATUS
38 #include "windef.h"
39 #include "winbase.h"
40 #include "winternl.h"
41 #include "ntsecapi.h"
42 #include "wincrypt.h"
43 #include "bcrypt.h"
44
45 #include "bcrypt_internal.h"
46
47 #include "wine/debug.h"
48 #include "wine/unicode.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
51 WINE_DECLARE_DEBUG_CHANNEL(winediag);
52
53 #if GNUTLS_VERSION_MAJOR < 3
54 #define GNUTLS_CIPHER_AES_192_CBC 92
55 #define GNUTLS_CIPHER_AES_128_GCM 93
56 #define GNUTLS_CIPHER_AES_256_GCM 94
57 #define GNUTLS_PK_ECC 4
58
59 #define GNUTLS_CURVE_TO_BITS(curve) (unsigned int)(((unsigned int)1<<31)|((unsigned int)(curve)))
60
61 typedef enum
62 {
63 GNUTLS_ECC_CURVE_INVALID,
64 GNUTLS_ECC_CURVE_SECP224R1,
65 GNUTLS_ECC_CURVE_SECP256R1,
66 GNUTLS_ECC_CURVE_SECP384R1,
67 GNUTLS_ECC_CURVE_SECP521R1,
68 } gnutls_ecc_curve_t;
69 #endif
70
71 union key_data
72 {
73 gnutls_cipher_hd_t cipher;
74 gnutls_privkey_t privkey;
75 };
76 C_ASSERT( sizeof(union key_data) <= sizeof(((struct key *)0)->private) );
77
78 static union key_data *key_data( struct key *key )
79 {
80 return (union key_data *)key->private;
81 }
82
83 /* Not present in gnutls version < 3.0 */
84 static int (*pgnutls_cipher_tag)(gnutls_cipher_hd_t, void *, size_t);
85 static int (*pgnutls_cipher_add_auth)(gnutls_cipher_hd_t, const void *, size_t);
86 static gnutls_sign_algorithm_t (*pgnutls_pk_to_sign)(gnutls_pk_algorithm_t, gnutls_digest_algorithm_t);
87 static int (*pgnutls_pubkey_import_ecc_raw)(gnutls_pubkey_t, gnutls_ecc_curve_t,
88 const gnutls_datum_t *, const gnutls_datum_t *);
89 static int (*pgnutls_privkey_import_ecc_raw)(gnutls_privkey_t, gnutls_ecc_curve_t, const gnutls_datum_t *,
90 const gnutls_datum_t *, const gnutls_datum_t *);
91 static int (*pgnutls_pubkey_verify_hash2)(gnutls_pubkey_t, gnutls_sign_algorithm_t, unsigned int,
92 const gnutls_datum_t *, const gnutls_datum_t *);
93
94 /* Not present in gnutls version < 2.11.0 */
95 static int (*pgnutls_pubkey_import_rsa_raw)(gnutls_pubkey_t, const gnutls_datum_t *, const gnutls_datum_t *);
96
97 /* Not present in gnutls version < 2.12.0 */
98 static int (*pgnutls_pubkey_import_dsa_raw)(gnutls_pubkey_t, const gnutls_datum_t *, const gnutls_datum_t *,
99 const gnutls_datum_t *, const gnutls_datum_t *);
100
101 /* Not present in gnutls version < 3.3.0 */
102 static int (*pgnutls_privkey_export_ecc_raw)(gnutls_privkey_t, gnutls_ecc_curve_t *,
103 gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *);
104 static int (*pgnutls_privkey_export_rsa_raw)(gnutls_privkey_t, gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *,
105 gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *,
106 gnutls_datum_t *);
107 static int (*pgnutls_privkey_export_dsa_raw)(gnutls_privkey_t, gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *,
108 gnutls_datum_t *, gnutls_datum_t *);
109 static int (*pgnutls_privkey_generate)(gnutls_privkey_t, gnutls_pk_algorithm_t, unsigned int, unsigned int);
110 static int (*pgnutls_privkey_import_rsa_raw)(gnutls_privkey_t, const gnutls_datum_t *, const gnutls_datum_t *,
111 const gnutls_datum_t *, const gnutls_datum_t *, const gnutls_datum_t *,
112 const gnutls_datum_t *, const gnutls_datum_t *, const gnutls_datum_t *);
113 static int (*pgnutls_privkey_decrypt_data)(gnutls_privkey_t, unsigned int flags, const gnutls_datum_t *, gnutls_datum_t *);
114
115 /* Not present in gnutls version < 3.6.0 */
116 static int (*pgnutls_decode_rs_value)(const gnutls_datum_t *, gnutls_datum_t *, gnutls_datum_t *);
117
118 static void *libgnutls_handle;
119 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
120 MAKE_FUNCPTR(gnutls_cipher_decrypt2);
121 MAKE_FUNCPTR(gnutls_cipher_deinit);
122 MAKE_FUNCPTR(gnutls_cipher_encrypt2);
123 MAKE_FUNCPTR(gnutls_cipher_init);
124 MAKE_FUNCPTR(gnutls_global_deinit);
125 MAKE_FUNCPTR(gnutls_global_init);
126 MAKE_FUNCPTR(gnutls_global_set_log_function);
127 MAKE_FUNCPTR(gnutls_global_set_log_level);
128 MAKE_FUNCPTR(gnutls_perror);
129 MAKE_FUNCPTR(gnutls_privkey_decrypt_data);
130 MAKE_FUNCPTR(gnutls_privkey_deinit);
131 MAKE_FUNCPTR(gnutls_privkey_import_dsa_raw);
132 MAKE_FUNCPTR(gnutls_privkey_init);
133 MAKE_FUNCPTR(gnutls_privkey_sign_hash);
134 MAKE_FUNCPTR(gnutls_pubkey_deinit);
135 MAKE_FUNCPTR(gnutls_pubkey_init);
136 #undef MAKE_FUNCPTR
137
138 static int compat_gnutls_cipher_tag(gnutls_cipher_hd_t handle, void *tag, size_t tag_size)
139 {
140 return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
141 }
142
143 static int compat_gnutls_cipher_add_auth(gnutls_cipher_hd_t handle, const void *ptext, size_t ptext_size)
144 {
145 return GNUTLS_E_UNKNOWN_CIPHER_TYPE;
146 }
147
148 static int compat_gnutls_pubkey_import_ecc_raw(gnutls_pubkey_t key, gnutls_ecc_curve_t curve,
149 const gnutls_datum_t *x, const gnutls_datum_t *y)
150 {
151 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
152 }
153
154 static int compat_gnutls_privkey_export_rsa_raw(gnutls_privkey_t key, gnutls_datum_t *m, gnutls_datum_t *e,
155 gnutls_datum_t *d, gnutls_datum_t *p, gnutls_datum_t *q,
156 gnutls_datum_t *u, gnutls_datum_t *e1, gnutls_datum_t *e2)
157 {
158 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
159 }
160
161 static int compat_gnutls_privkey_export_ecc_raw(gnutls_privkey_t key, gnutls_ecc_curve_t *curve,
162 gnutls_datum_t *x, gnutls_datum_t *y, gnutls_datum_t *k)
163 {
164 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
165 }
166
167 static int compat_gnutls_privkey_import_ecc_raw(gnutls_privkey_t key, gnutls_ecc_curve_t curve,
168 const gnutls_datum_t *x, const gnutls_datum_t *y,
169 const gnutls_datum_t *k)
170 {
171 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
172 }
173
174 static int compat_gnutls_privkey_export_dsa_raw(gnutls_privkey_t key, gnutls_datum_t *p, gnutls_datum_t *q,
175 gnutls_datum_t *g, gnutls_datum_t *y, gnutls_datum_t *x)
176 {
177 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
178 }
179
180 static gnutls_sign_algorithm_t compat_gnutls_pk_to_sign(gnutls_pk_algorithm_t pk, gnutls_digest_algorithm_t hash)
181 {
182 return GNUTLS_SIGN_UNKNOWN;
183 }
184
185 static int compat_gnutls_pubkey_verify_hash2(gnutls_pubkey_t key, gnutls_sign_algorithm_t algo,
186 unsigned int flags, const gnutls_datum_t *hash,
187 const gnutls_datum_t *signature)
188 {
189 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
190 }
191
192 static int compat_gnutls_pubkey_import_rsa_raw(gnutls_pubkey_t key, const gnutls_datum_t *m, const gnutls_datum_t *e)
193 {
194 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
195 }
196
197 static int compat_gnutls_pubkey_import_dsa_raw(gnutls_pubkey_t key, const gnutls_datum_t *p, const gnutls_datum_t *q,
198 const gnutls_datum_t *g, const gnutls_datum_t *y)
199 {
200 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
201 }
202
203 static int compat_gnutls_privkey_generate(gnutls_privkey_t key, gnutls_pk_algorithm_t algo, unsigned int bits,
204 unsigned int flags)
205 {
206 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
207 }
208
209 static int compat_gnutls_decode_rs_value(const gnutls_datum_t * sig_value, gnutls_datum_t * r, gnutls_datum_t * s)
210 {
211 return GNUTLS_E_INTERNAL_ERROR;
212 }
213
214 static int compat_gnutls_privkey_import_rsa_raw(gnutls_privkey_t key, const gnutls_datum_t *m, const gnutls_datum_t *e,
215 const gnutls_datum_t *d, const gnutls_datum_t *p, const gnutls_datum_t *q,
216 const gnutls_datum_t *u, const gnutls_datum_t *e1, const gnutls_datum_t *e2)
217 {
218 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
219 }
220
221 static int compat_gnutls_privkey_decrypt_data(gnutls_privkey_t key, unsigned int flags, const gnutls_datum_t *cipher_text,
222 gnutls_datum_t *plain_text)
223 {
224 return GNUTLS_E_UNKNOWN_PK_ALGORITHM;
225 }
226
227 static void gnutls_log( int level, const char *msg )
228 {
229 TRACE( "<%d> %s", level, msg );
230 }
231
232 static BOOL gnutls_initialize(void)
233 {
234 const char *env_str;
235 int ret;
236
237 if ((env_str = getenv("GNUTLS_SYSTEM_PRIORITY_FILE")))
238 {
239 WARN("GNUTLS_SYSTEM_PRIORITY_FILE is %s.\n", debugstr_a(env_str));
240 }
241 else
242 {
243 WARN("Setting GNUTLS_SYSTEM_PRIORITY_FILE to \"/dev/null\".\n");
244 setenv("GNUTLS_SYSTEM_PRIORITY_FILE", "/dev/null", 0);
245 }
246
247 if (!(libgnutls_handle = dlopen( SONAME_LIBGNUTLS, RTLD_NOW )))
248 {
249 ERR_(winediag)( "failed to load libgnutls, no support for encryption\n" );
250 return FALSE;
251 }
252
253 #define LOAD_FUNCPTR(f) \
254 if (!(p##f = dlsym( libgnutls_handle, #f ))) \
255 { \
256 ERR( "failed to load %s\n", #f ); \
257 goto fail; \
258 }
259
260 LOAD_FUNCPTR(gnutls_cipher_decrypt2)
261 LOAD_FUNCPTR(gnutls_cipher_deinit)
262 LOAD_FUNCPTR(gnutls_cipher_encrypt2)
263 LOAD_FUNCPTR(gnutls_cipher_init)
264 LOAD_FUNCPTR(gnutls_global_deinit)
265 LOAD_FUNCPTR(gnutls_global_init)
266 LOAD_FUNCPTR(gnutls_global_set_log_function)
267 LOAD_FUNCPTR(gnutls_global_set_log_level)
268 LOAD_FUNCPTR(gnutls_perror)
269 LOAD_FUNCPTR(gnutls_privkey_deinit);
270 LOAD_FUNCPTR(gnutls_privkey_import_dsa_raw);
271 LOAD_FUNCPTR(gnutls_privkey_init);
272 LOAD_FUNCPTR(gnutls_privkey_sign_hash);
273 LOAD_FUNCPTR(gnutls_pubkey_deinit);
274 LOAD_FUNCPTR(gnutls_pubkey_init);
275 #undef LOAD_FUNCPTR
276
277 if (!(pgnutls_cipher_tag = dlsym( libgnutls_handle, "gnutls_cipher_tag" )))
278 {
279 WARN("gnutls_cipher_tag not found\n");
280 pgnutls_cipher_tag = compat_gnutls_cipher_tag;
281 }
282 if (!(pgnutls_cipher_add_auth = dlsym( libgnutls_handle, "gnutls_cipher_add_auth" )))
283 {
284 WARN("gnutls_cipher_add_auth not found\n");
285 pgnutls_cipher_add_auth = compat_gnutls_cipher_add_auth;
286 }
287
288 if ((ret = pgnutls_global_init()) != GNUTLS_E_SUCCESS)
289 {
290 pgnutls_perror( ret );
291 goto fail;
292 }
293 if (!(pgnutls_pubkey_import_ecc_raw = dlsym( libgnutls_handle, "gnutls_pubkey_import_ecc_raw" )))
294 {
295 WARN("gnutls_pubkey_import_ecc_raw not found\n");
296 pgnutls_pubkey_import_ecc_raw = compat_gnutls_pubkey_import_ecc_raw;
297 }
298 if (!(pgnutls_privkey_export_rsa_raw = dlsym( libgnutls_handle, "gnutls_privkey_export_rsa_raw" )))
299 {
300 WARN("gnutls_privkey_export_rsa_raw not found\n");
301 pgnutls_privkey_export_rsa_raw = compat_gnutls_privkey_export_rsa_raw;
302 }
303 if (!(pgnutls_privkey_export_ecc_raw = dlsym( libgnutls_handle, "gnutls_privkey_export_ecc_raw" )))
304 {
305 WARN("gnutls_privkey_export_ecc_raw not found\n");
306 pgnutls_privkey_export_ecc_raw = compat_gnutls_privkey_export_ecc_raw;
307 }
308 if (!(pgnutls_privkey_import_ecc_raw = dlsym( libgnutls_handle, "gnutls_privkey_import_ecc_raw" )))
309 {
310 WARN("gnutls_privkey_import_ecc_raw not found\n");
311 pgnutls_privkey_import_ecc_raw = compat_gnutls_privkey_import_ecc_raw;
312 }
313 if (!(pgnutls_privkey_export_dsa_raw = dlsym( libgnutls_handle, "gnutls_privkey_export_dsa_raw" )))
314 {
315 WARN("gnutls_privkey_export_dsa_raw not found\n");
316 pgnutls_privkey_export_dsa_raw = compat_gnutls_privkey_export_dsa_raw;
317 }
318 if (!(pgnutls_pk_to_sign = dlsym( libgnutls_handle, "gnutls_pk_to_sign" )))
319 {
320 WARN("gnutls_pk_to_sign not found\n");
321 pgnutls_pk_to_sign = compat_gnutls_pk_to_sign;
322 }
323 if (!(pgnutls_pubkey_verify_hash2 = dlsym( libgnutls_handle, "gnutls_pubkey_verify_hash2" )))
324 {
325 WARN("gnutls_pubkey_verify_hash2 not found\n");
326 pgnutls_pubkey_verify_hash2 = compat_gnutls_pubkey_verify_hash2;
327 }
328 if (!(pgnutls_pubkey_import_rsa_raw = dlsym( libgnutls_handle, "gnutls_pubkey_import_rsa_raw" )))
329 {
330 WARN("gnutls_pubkey_import_rsa_raw not found\n");
331 pgnutls_pubkey_import_rsa_raw = compat_gnutls_pubkey_import_rsa_raw;
332 }
333 if (!(pgnutls_pubkey_import_dsa_raw = dlsym( libgnutls_handle, "gnutls_pubkey_import_dsa_raw" )))
334 {
335 WARN("gnutls_pubkey_import_dsa_raw not found\n");
336 pgnutls_pubkey_import_dsa_raw = compat_gnutls_pubkey_import_dsa_raw;
337 }
338 if (!(pgnutls_privkey_generate = dlsym( libgnutls_handle, "gnutls_privkey_generate" )))
339 {
340 WARN("gnutls_privkey_generate not found\n");
341 pgnutls_privkey_generate = compat_gnutls_privkey_generate;
342 }
343 if (!(pgnutls_decode_rs_value = dlsym( libgnutls_handle, "gnutls_decode_rs_value" )))
344 {
345 WARN("gnutls_decode_rs_value not found\n");
346 pgnutls_decode_rs_value = compat_gnutls_decode_rs_value;
347 }
348 if (!(pgnutls_privkey_import_rsa_raw = dlsym( libgnutls_handle, "gnutls_privkey_import_rsa_raw" )))
349 {
350 WARN("gnutls_privkey_import_rsa_raw not found\n");
351 pgnutls_privkey_import_rsa_raw = compat_gnutls_privkey_import_rsa_raw;
352 }
353 if (!(pgnutls_privkey_decrypt_data = dlsym( libgnutls_handle, "gnutls_privkey_decrypt_data" )))
354 {
355 WARN("gnutls_privkey_decrypt_data not found\n");
356 pgnutls_privkey_decrypt_data = compat_gnutls_privkey_decrypt_data;
357 }
358
359 if (TRACE_ON( bcrypt ))
360 {
361 pgnutls_global_set_log_level( 4 );
362 pgnutls_global_set_log_function( gnutls_log );
363 }
364
365 return TRUE;
366
367 fail:
368 dlclose( libgnutls_handle );
369 libgnutls_handle = NULL;
370 return FALSE;
371 }
372
373 static void gnutls_uninitialize(void)
374 {
375 pgnutls_global_deinit();
376 dlclose( libgnutls_handle );
377 libgnutls_handle = NULL;
378 }
379
380 struct buffer
381 {
382 BYTE *buffer;
383 DWORD length;
384 DWORD pos;
385 BOOL error;
386 };
387
388 static void buffer_init( struct buffer *buffer )
389 {
390 buffer->buffer = NULL;
391 buffer->length = 0;
392 buffer->pos = 0;
393 buffer->error = FALSE;
394 }
395
396 static void buffer_free( struct buffer *buffer )
397 {
398 free( buffer->buffer );
399 }
400
401 static void buffer_append( struct buffer *buffer, BYTE *data, DWORD len )
402 {
403 if (!len) return;
404
405 if (buffer->pos + len > buffer->length)
406 {
407 DWORD new_length = max( max( buffer->pos + len, buffer->length * 2 ), 64 );
408 BYTE *new_buffer;
409
410 if (!(new_buffer = realloc( buffer->buffer, new_length )))
411 {
412 ERR( "out of memory\n" );
413 buffer->error = TRUE;
414 return;
415 }
416
417 buffer->buffer = new_buffer;
418 buffer->length = new_length;
419 }
420
421 memcpy( &buffer->buffer[buffer->pos], data, len );
422 buffer->pos += len;
423 }
424
425 static void buffer_append_byte( struct buffer *buffer, BYTE value )
426 {
427 buffer_append( buffer, &value, sizeof(value) );
428 }
429
430 static void buffer_append_asn1_length( struct buffer *buffer, DWORD length )
431 {
432 DWORD num_bytes;
433
434 if (length < 128)
435 {
436 buffer_append_byte( buffer, length );
437 return;
438 }
439
440 if (length <= 0xff) num_bytes = 1;
441 else if (length <= 0xffff) num_bytes = 2;
442 else if (length <= 0xffffff) num_bytes = 3;
443 else num_bytes = 4;
444
445 buffer_append_byte( buffer, 0x80 | num_bytes );
446 while (num_bytes--) buffer_append_byte( buffer, length >> (num_bytes * 8) );
447 }
448
449 static void buffer_append_asn1_integer( struct buffer *buffer, BYTE *data, DWORD len )
450 {
451 DWORD leading_zero = (*data & 0x80) != 0;
452
453 buffer_append_byte( buffer, 0x02 ); /* tag */
454 buffer_append_asn1_length( buffer, len + leading_zero );
455 if (leading_zero) buffer_append_byte( buffer, 0 );
456 buffer_append( buffer, data, len );
457 }
458
459 static void buffer_append_asn1_sequence( struct buffer *buffer, struct buffer *content )
460 {
461 if (content->error)
462 {
463 buffer->error = TRUE;
464 return;
465 }
466
467 buffer_append_byte( buffer, 0x30 ); /* tag */
468 buffer_append_asn1_length( buffer, content->pos );
469 buffer_append( buffer, content->buffer, content->pos );
470 }
471
472 static void buffer_append_asn1_r_s( struct buffer *buffer, BYTE *r, DWORD r_len, BYTE *s, DWORD s_len )
473 {
474 struct buffer value;
475
476 buffer_init( &value );
477 buffer_append_asn1_integer( &value, r, r_len );
478 buffer_append_asn1_integer( &value, s, s_len );
479 buffer_append_asn1_sequence( buffer, &value );
480 buffer_free( &value );
481 }
482
483 static NTSTATUS CDECL key_set_property( struct key *key, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags )
484 {
485 if (!strcmpW( prop, BCRYPT_CHAINING_MODE ))
486 {
487 if (!strcmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB ))
488 {
489 key->u.s.mode = MODE_ID_ECB;
490 return STATUS_SUCCESS;
491 }
492 else if (!strcmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC ))
493 {
494 key->u.s.mode = MODE_ID_CBC;
495 return STATUS_SUCCESS;
496 }
497 else if (!strcmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM ))
498 {
499 key->u.s.mode = MODE_ID_GCM;
500 return STATUS_SUCCESS;
501 }
502 else
503 {
504 FIXME( "unsupported mode %s\n", debugstr_w((WCHAR *)value) );
505 return STATUS_NOT_IMPLEMENTED;
506 }
507 }
508
509 FIXME( "unsupported key property %s\n", debugstr_w(prop) );
510 return STATUS_NOT_IMPLEMENTED;
511 }
512
513 static NTSTATUS CDECL key_symmetric_init( struct key *key )
514 {
515 if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
516
517 switch (key->alg_id)
518 {
519 case ALG_ID_3DES:
520 case ALG_ID_AES:
521 return STATUS_SUCCESS;
522
523 default:
524 FIXME( "algorithm %u not supported\n", key->alg_id );
525 return STATUS_NOT_SUPPORTED;
526 }
527 }
528
529 static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key )
530 {
531 switch (key->alg_id)
532 {
533 case ALG_ID_3DES:
534 WARN( "handle block size\n" );
535 switch (key->u.s.mode)
536 {
537 case MODE_ID_CBC:
538 return GNUTLS_CIPHER_3DES_CBC;
539 default:
540 break;
541 }
542 FIXME( "3DES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len );
543 return GNUTLS_CIPHER_UNKNOWN;
544
545 case ALG_ID_AES:
546 WARN( "handle block size\n" );
547 switch (key->u.s.mode)
548 {
549 case MODE_ID_GCM:
550 if (key->u.s.secret_len == 16) return GNUTLS_CIPHER_AES_128_GCM;
551 if (key->u.s.secret_len == 32) return GNUTLS_CIPHER_AES_256_GCM;
552 break;
553 case MODE_ID_ECB: /* can be emulated with CBC + empty IV */
554 case MODE_ID_CBC:
555 if (key->u.s.secret_len == 16) return GNUTLS_CIPHER_AES_128_CBC;
556 if (key->u.s.secret_len == 24) return GNUTLS_CIPHER_AES_192_CBC;
557 if (key->u.s.secret_len == 32) return GNUTLS_CIPHER_AES_256_CBC;
558 break;
559 default:
560 break;
561 }
562 FIXME( "AES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len );
563 return GNUTLS_CIPHER_UNKNOWN;
564
565 default:
566 FIXME( "algorithm %u not supported\n", key->alg_id );
567 return GNUTLS_CIPHER_UNKNOWN;
568 }
569 }
570
571 static void CDECL key_symmetric_vector_reset( struct key *key )
572 {
573 if (!key_data(key)->cipher) return;
574 TRACE( "invalidating cipher handle\n" );
575 pgnutls_cipher_deinit( key_data(key)->cipher );
576 key_data(key)->cipher = NULL;
577 }
578
579 static NTSTATUS init_cipher_handle( struct key *key )
580 {
581 gnutls_cipher_algorithm_t cipher;
582 gnutls_datum_t secret, vector;
583 int ret;
584
585 if (key_data(key)->cipher) return STATUS_SUCCESS;
586 if ((cipher = get_gnutls_cipher( key )) == GNUTLS_CIPHER_UNKNOWN) return STATUS_NOT_SUPPORTED;
587
588 secret.data = key->u.s.secret;
589 secret.size = key->u.s.secret_len;
590
591 vector.data = key->u.s.vector;
592 vector.size = key->u.s.vector_len;
593
594 if ((ret = pgnutls_cipher_init( &key_data(key)->cipher, cipher, &secret, key->u.s.vector ? &vector : NULL )))
595 {
596 pgnutls_perror( ret );
597 return STATUS_INTERNAL_ERROR;
598 }
599
600 return STATUS_SUCCESS;
601 }
602
603 static NTSTATUS CDECL key_symmetric_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len )
604 {
605 NTSTATUS status;
606 int ret;
607
608 if (!auth_data) return STATUS_SUCCESS;
609 if ((status = init_cipher_handle( key ))) return status;
610
611 if ((ret = pgnutls_cipher_add_auth( key_data(key)->cipher, auth_data, len )))
612 {
613 pgnutls_perror( ret );
614 return STATUS_INTERNAL_ERROR;
615 }
616 return STATUS_SUCCESS;
617 }
618
619 static NTSTATUS CDECL key_symmetric_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len )
620 {
621 NTSTATUS status;
622 int ret;
623
624 if ((status = init_cipher_handle( key ))) return status;
625
626 if ((ret = pgnutls_cipher_encrypt2( key_data(key)->cipher, input, input_len, output, output_len )))
627 {
628 pgnutls_perror( ret );
629 return STATUS_INTERNAL_ERROR;
630 }
631 return STATUS_SUCCESS;
632 }
633
634 static NTSTATUS CDECL key_symmetric_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, ULONG output_len )
635 {
636 NTSTATUS status;
637 int ret;
638
639 if ((status = init_cipher_handle( key ))) return status;
640
641 if ((ret = pgnutls_cipher_decrypt2( key_data(key)->cipher, input, input_len, output, output_len )))
642 {
643 pgnutls_perror( ret );
644 return STATUS_INTERNAL_ERROR;
645 }
646 return STATUS_SUCCESS;
647 }
648
649 static NTSTATUS CDECL key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len )
650 {
651 NTSTATUS status;
652 int ret;
653
654 if ((status = init_cipher_handle( key ))) return status;
655
656 if ((ret = pgnutls_cipher_tag( key_data(key)->cipher, tag, len )))
657 {
658 pgnutls_perror( ret );
659 return STATUS_INTERNAL_ERROR;
660 }
661 return STATUS_SUCCESS;
662 }
663
664 static void CDECL key_symmetric_destroy( struct key *key )
665 {
666 if (key_data(key)->cipher) pgnutls_cipher_deinit( key_data(key)->cipher );
667 }
668
669 static void export_gnutls_datum( UCHAR *buffer, ULONG length, gnutls_datum_t *d, ULONG *actual_length )
670 {
671 ULONG size = d->size;
672 UCHAR *src = d->data;
673 ULONG offset;
674
675 assert( size <= length + 1 );
676 if (size == length + 1)
677 {
678 assert(!src[0]);
679 ++src;
680 --size;
681 }
682 if (actual_length)
683 {
684 offset = 0;
685 *actual_length = size;
686 }
687 else
688 {
689 offset = length - size;
690 memset( buffer, 0, offset );
691 }
692 memcpy( buffer + offset, src, size );
693 }
694
695 static NTSTATUS export_gnutls_pubkey_rsa( gnutls_privkey_t gnutls_key, ULONG bitlen, UCHAR **pubkey, ULONG *pubkey_len )
696 {
697 BCRYPT_RSAKEY_BLOB *rsa_blob;
698 gnutls_datum_t m, e;
699 UCHAR *dst;
700 int ret;
701
702 if ((ret = pgnutls_privkey_export_rsa_raw( gnutls_key, &m, &e, NULL, NULL, NULL, NULL, NULL, NULL )))
703 {
704 pgnutls_perror( ret );
705 return STATUS_INTERNAL_ERROR;
706 }
707
708 if (!(rsa_blob = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*rsa_blob) + e.size + m.size )))
709 {
710 pgnutls_perror( ret );
711 free( e.data ); free( m.data );
712 return STATUS_NO_MEMORY;
713 }
714
715 dst = (UCHAR *)(rsa_blob + 1);
716 export_gnutls_datum( dst, bitlen / 8, &e, &rsa_blob->cbPublicExp );
717
718 dst += rsa_blob->cbPublicExp;
719 export_gnutls_datum( dst, bitlen / 8, &m, &rsa_blob->cbModulus );
720
721 rsa_blob->Magic = BCRYPT_RSAPUBLIC_MAGIC;
722 rsa_blob->BitLength = bitlen;
723 rsa_blob->cbPrime1 = 0;
724 rsa_blob->cbPrime2 = 0;
725
726 *pubkey = (UCHAR *)rsa_blob;
727 *pubkey_len = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus;
728
729 free( e.data ); free( m.data );
730 return STATUS_SUCCESS;
731 }
732
733 static NTSTATUS export_gnutls_pubkey_ecc( gnutls_privkey_t gnutls_key, enum alg_id alg_id, UCHAR **pubkey,
734 ULONG *pubkey_len )
735 {
736 BCRYPT_ECCKEY_BLOB *ecc_blob;
737 gnutls_ecc_curve_t curve;
738 gnutls_datum_t x, y;
739 DWORD magic, size;
740 UCHAR *dst;
741 int ret;
742
743 switch (alg_id)
744 {
745 case ALG_ID_ECDH_P256:
746 magic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
747 size = 32;
748 break;
749 case ALG_ID_ECDSA_P256:
750 magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
751 size = 32;
752 break;
753 default:
754 FIXME( "algorithm %u not supported\n", alg_id );
755 return STATUS_NOT_IMPLEMENTED;
756 }
757
758 if ((ret = pgnutls_privkey_export_ecc_raw( gnutls_key, &curve, &x, &y, NULL )))
759 {
760 pgnutls_perror( ret );
761 return STATUS_INTERNAL_ERROR;
762 }
763
764 if (curve != GNUTLS_ECC_CURVE_SECP256R1)
765 {
766 FIXME( "curve %u not supported\n", curve );
767 free( x.data ); free( y.data );
768 return STATUS_NOT_IMPLEMENTED;
769 }
770
771 if (!(ecc_blob = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*ecc_blob) + size * 2 )))
772 {
773 pgnutls_perror( ret );
774 free( x.data ); free( y.data );
775 return STATUS_NO_MEMORY;
776 }
777
778 ecc_blob->dwMagic = magic;
779 ecc_blob->cbKey = size;
780
781 dst = (UCHAR *)(ecc_blob + 1);
782 export_gnutls_datum( dst, size, &x, NULL );
783
784 dst += size;
785 export_gnutls_datum( dst, size, &y, NULL );
786
787 *pubkey = (UCHAR *)ecc_blob;
788 *pubkey_len = sizeof(*ecc_blob) + ecc_blob->cbKey * 2;
789
790 free( x.data ); free( y.data );
791 return STATUS_SUCCESS;
792 }
793
794 static NTSTATUS export_gnutls_pubkey_dsa( gnutls_privkey_t gnutls_key, ULONG bitlen, UCHAR **pubkey, ULONG *pubkey_len )
795 {
796 BCRYPT_DSA_KEY_BLOB *dsa_blob;
797 gnutls_datum_t p, q, g, y;
798 UCHAR *dst;
799 int ret;
800
801 if ((ret = pgnutls_privkey_export_dsa_raw( gnutls_key, &p, &q, &g, &y, NULL )))
802 {
803 pgnutls_perror( ret );
804 return STATUS_INTERNAL_ERROR;
805 }
806
807 if (bitlen > 1024)
808 {
809 FIXME( "bitlen > 1024 not supported\n" );
810 return STATUS_NOT_IMPLEMENTED;
811 }
812
813 if (!(dsa_blob = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*dsa_blob) + bitlen / 8 * 3 )))
814 {
815 pgnutls_perror( ret );
816 free( p.data ); free( q.data ); free( g.data ); free( y.data );
817 return STATUS_NO_MEMORY;
818 }
819
820 dst = (UCHAR *)(dsa_blob + 1);
821 export_gnutls_datum( dst, bitlen / 8, &p, NULL );
822
823 dst += bitlen / 8;
824 export_gnutls_datum( dst, bitlen / 8, &g, NULL );
825
826 dst += bitlen / 8;
827 export_gnutls_datum( dst, bitlen / 8, &y, NULL );
828
829 dst = dsa_blob->q;
830 export_gnutls_datum( dst, sizeof(dsa_blob->q), &q, NULL );
831
832 dsa_blob->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
833 dsa_blob->cbKey = bitlen / 8;
834 memset( dsa_blob->Count, 0, sizeof(dsa_blob->Count) ); /* FIXME */
835 memset( dsa_blob->Seed, 0, sizeof(dsa_blob->Seed) ); /* FIXME */
836
837 *pubkey = (UCHAR *)dsa_blob;
838 *pubkey_len = sizeof(*dsa_blob) + dsa_blob->cbKey * 3;
839
840 free( p.data ); free( q.data ); free( g.data ); free( y.data );
841 return STATUS_SUCCESS;
842 }
843
844 static void reverse_bytes( UCHAR *buf, ULONG len )
845 {
846 unsigned int i;
847 UCHAR tmp;
848
849 for (i = 0; i < len / 2; ++i)
850 {
851 tmp = buf[i];
852 buf[i] = buf[len - i - 1];
853 buf[len - i - 1] = tmp;
854 }
855 }
856
857 #define Q_SIZE 20
858 static NTSTATUS export_gnutls_pubkey_dsa_capi( gnutls_privkey_t gnutls_key, const DSSSEED *seed, ULONG bitlen,
859 UCHAR **pubkey, ULONG *pubkey_len )
860 {
861 BLOBHEADER *hdr;
862 DSSPUBKEY *dsskey;
863 gnutls_datum_t p, q, g, y;
864 UCHAR *dst;
865 int ret, size = sizeof(*hdr) + sizeof(*dsskey) + sizeof(*seed);
866
867 if (bitlen > 1024)
868 {
869 FIXME( "bitlen > 1024 not supported\n" );
870 return STATUS_NOT_IMPLEMENTED;
871 }
872
873 if ((ret = pgnutls_privkey_export_dsa_raw( gnutls_key, &p, &q, &g, &y, NULL )))
874 {
875 pgnutls_perror( ret );
876 return STATUS_INTERNAL_ERROR;
877 }
878
879 if (!(hdr = RtlAllocateHeap( GetProcessHeap(), 0, size + bitlen / 8 * 3 + Q_SIZE )))
880 {
881 pgnutls_perror( ret );
882 free( p.data ); free( q.data ); free( g.data ); free( y.data );
883 return STATUS_NO_MEMORY;
884 }
885
886 hdr->bType = PUBLICKEYBLOB;
887 hdr->bVersion = 2;
888 hdr->reserved = 0;
889 hdr->aiKeyAlg = CALG_DSS_SIGN;
890
891 dsskey = (DSSPUBKEY *)(hdr + 1);
892 dsskey->magic = MAGIC_DSS1;
893 dsskey->bitlen = bitlen;
894
895 dst = (UCHAR *)(dsskey + 1);
896 export_gnutls_datum( dst, bitlen / 8, &p, NULL );
897 reverse_bytes( dst, bitlen / 8 );
898 dst += bitlen / 8;
899
900 export_gnutls_datum( dst, Q_SIZE, &q, NULL );
901 reverse_bytes( dst, Q_SIZE );
902 dst += Q_SIZE;
903
904 export_gnutls_datum( dst, bitlen / 8, &g, NULL );
905 reverse_bytes( dst, bitlen / 8 );
906 dst += bitlen / 8;
907
908 export_gnutls_datum( dst, bitlen / 8, &y, NULL );
909 reverse_bytes( dst, bitlen / 8 );
910 dst += bitlen / 8;
911
912 memcpy( dst, seed, sizeof(*seed) );
913
914 *pubkey = (UCHAR *)hdr;
915 *pubkey_len = size + bitlen / 8 * 3 + Q_SIZE;
916
917 free( p.data ); free( q.data ); free( g.data ); free( y.data );
918 return STATUS_SUCCESS;
919 }
920
921 static NTSTATUS CDECL key_asymmetric_generate( struct key *key )
922 {
923 gnutls_pk_algorithm_t pk_alg;
924 gnutls_privkey_t handle;
925 unsigned int bitlen;
926 NTSTATUS status;
927 int ret;
928
929 if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
930
931 switch (key->alg_id)
932 {
933 case ALG_ID_RSA:
934 case ALG_ID_RSA_SIGN:
935 pk_alg = GNUTLS_PK_RSA;
936 bitlen = key->u.a.bitlen;
937 break;
938
939 case ALG_ID_DSA:
940 pk_alg = GNUTLS_PK_DSA;
941 bitlen = key->u.a.bitlen;
942 break;
943
944 case ALG_ID_ECDH_P256:
945 case ALG_ID_ECDSA_P256:
946 pk_alg = GNUTLS_PK_ECC; /* compatible with ECDSA and ECDH */
947 bitlen = GNUTLS_CURVE_TO_BITS( GNUTLS_ECC_CURVE_SECP256R1 );
948 break;
949
950 default:
951 FIXME( "algorithm %u not supported\n", key->alg_id );
952 return STATUS_NOT_SUPPORTED;
953 }
954
955 if ((ret = pgnutls_privkey_init( &handle )))
956 {
957 pgnutls_perror( ret );
958 return STATUS_INTERNAL_ERROR;
959 }
960
961 if ((ret = pgnutls_privkey_generate( handle, pk_alg, bitlen, 0 )))
962 {
963 pgnutls_perror( ret );
964 pgnutls_privkey_deinit( handle );
965 return STATUS_INTERNAL_ERROR;
966 }
967
968 switch (pk_alg)
969 {
970 case GNUTLS_PK_RSA:
971 status = export_gnutls_pubkey_rsa( handle, key->u.a.bitlen, &key->u.a.pubkey, &key->u.a.pubkey_len );
972 break;
973
974 case GNUTLS_PK_ECC:
975 status = export_gnutls_pubkey_ecc( handle, key->alg_id, &key->u.a.pubkey, &key->u.a.pubkey_len );
976 break;
977
978 case GNUTLS_PK_DSA:
979 status = export_gnutls_pubkey_dsa( handle, key->u.a.bitlen, &key->u.a.pubkey, &key->u.a.pubkey_len );
980 break;
981
982 default:
983 ERR( "unhandled algorithm %u\n", pk_alg );
984 return STATUS_INTERNAL_ERROR;
985 }
986
987 if (status)
988 {
989 pgnutls_privkey_deinit( handle );
990 return status;
991 }
992
993 key_data(key)->privkey = handle;
994 return STATUS_SUCCESS;
995 }
996
997 static NTSTATUS CDECL key_export_ecc( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
998 {
999 BCRYPT_ECCKEY_BLOB *ecc_blob;
1000 gnutls_ecc_curve_t curve;
1001 gnutls_datum_t x, y, d;
1002 DWORD magic, size;
1003 UCHAR *dst;
1004 int ret;
1005
1006 switch (key->alg_id)
1007 {
1008 case ALG_ID_ECDH_P256:
1009 magic = BCRYPT_ECDH_PRIVATE_P256_MAGIC;
1010 size = 32;
1011 break;
1012 case ALG_ID_ECDSA_P256:
1013 magic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
1014 size = 32;
1015 break;
1016
1017 default:
1018 FIXME( "algorithm %u does not yet support exporting ecc blob\n", key->alg_id );
1019 return STATUS_NOT_IMPLEMENTED;
1020 }
1021
1022 if ((ret = pgnutls_privkey_export_ecc_raw( key_data(key)->privkey, &curve, &x, &y, &d )))
1023 {
1024 pgnutls_perror( ret );
1025 return STATUS_INTERNAL_ERROR;
1026 }
1027
1028 if (curve != GNUTLS_ECC_CURVE_SECP256R1)
1029 {
1030 FIXME( "curve %u not supported\n", curve );
1031 free( x.data ); free( y.data ); free( d.data );
1032 return STATUS_NOT_IMPLEMENTED;
1033 }
1034
1035 *ret_len = sizeof(*ecc_blob) + size * 3;
1036 if (len >= *ret_len && buf)
1037 {
1038 ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
1039 ecc_blob->dwMagic = magic;
1040 ecc_blob->cbKey = size;
1041
1042 dst = (UCHAR *)(ecc_blob + 1);
1043 export_gnutls_datum( dst, size, &x, NULL );
1044 dst += size;
1045
1046 export_gnutls_datum( dst, size, &y, NULL );
1047 dst += size;
1048
1049 export_gnutls_datum( dst, size, &d, NULL );
1050 }
1051
1052 free( x.data ); free( y.data ); free( d.data );
1053 return STATUS_SUCCESS;
1054 }
1055
1056 static NTSTATUS CDECL key_import_ecc( struct key *key, UCHAR *buf, ULONG len )
1057 {
1058 BCRYPT_ECCKEY_BLOB *ecc_blob;
1059 gnutls_ecc_curve_t curve;
1060 gnutls_privkey_t handle;
1061 gnutls_datum_t x, y, k;
1062 NTSTATUS status;
1063 int ret;
1064
1065 switch (key->alg_id)
1066 {
1067 case ALG_ID_ECDH_P256:
1068 case ALG_ID_ECDSA_P256:
1069 curve = GNUTLS_ECC_CURVE_SECP256R1;
1070 break;
1071
1072 default:
1073 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1074 return STATUS_NOT_IMPLEMENTED;
1075 }
1076
1077 if ((ret = pgnutls_privkey_init( &handle )))
1078 {
1079 pgnutls_perror( ret );
1080 return STATUS_INTERNAL_ERROR;
1081 }
1082
1083 ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
1084 x.data = (unsigned char *)(ecc_blob + 1);
1085 x.size = ecc_blob->cbKey;
1086 y.data = x.data + ecc_blob->cbKey;
1087 y.size = ecc_blob->cbKey;
1088 k.data = y.data + ecc_blob->cbKey;
1089 k.size = ecc_blob->cbKey;
1090
1091 if ((ret = pgnutls_privkey_import_ecc_raw( handle, curve, &x, &y, &k )))
1092 {
1093 pgnutls_perror( ret );
1094 pgnutls_privkey_deinit( handle );
1095 return STATUS_INTERNAL_ERROR;
1096 }
1097
1098 if ((status = export_gnutls_pubkey_ecc( handle, key->alg_id, &key->u.a.pubkey, &key->u.a.pubkey_len )))
1099 {
1100 pgnutls_privkey_deinit( handle );
1101 return status;
1102 }
1103
1104 key_data(key)->privkey = handle;
1105 return STATUS_SUCCESS;
1106 }
1107
1108 static NTSTATUS CDECL key_import_rsa( struct key *key, UCHAR *buf, ULONG len )
1109 {
1110 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
1111 gnutls_datum_t m, e, p, q;
1112 gnutls_privkey_t handle;
1113 int ret;
1114
1115 if ((ret = pgnutls_privkey_init( &handle )))
1116 {
1117 pgnutls_perror( ret );
1118 return STATUS_INTERNAL_ERROR;
1119 }
1120
1121 e.data = (unsigned char *)(rsa_blob + 1);
1122 e.size = rsa_blob->cbPublicExp;
1123 m.data = e.data + e.size;
1124 m.size = rsa_blob->cbModulus;
1125 p.data = m.data + m.size;
1126 p.size = rsa_blob->cbPrime1;
1127 q.data = p.data + p.size;
1128 q.size = rsa_blob->cbPrime2;
1129
1130 if ((ret = pgnutls_privkey_import_rsa_raw( handle, &m, &e, NULL, &p, &q, NULL, NULL, NULL )))
1131 {
1132 pgnutls_perror( ret );
1133 pgnutls_privkey_deinit( handle );
1134 return STATUS_INTERNAL_ERROR;
1135 }
1136
1137 key_data(key)->privkey = handle;
1138 return STATUS_SUCCESS;
1139 }
1140
1141 static NTSTATUS CDECL key_export_dsa_capi( struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len )
1142 {
1143 BLOBHEADER *hdr;
1144 DSSPUBKEY *pubkey;
1145 gnutls_datum_t p, q, g, y, x;
1146 UCHAR *dst;
1147 int ret, size;
1148
1149 if ((ret = pgnutls_privkey_export_dsa_raw( key_data(key)->privkey, &p, &q, &g, &y, &x )))
1150 {
1151 pgnutls_perror( ret );
1152 return STATUS_INTERNAL_ERROR;
1153 }
1154
1155 if (q.size > 21 || x.size > 21)
1156 {
1157 ERR( "can't export key in this format\n" );
1158 free( p.data ); free( q.data ); free( g.data ); free( y.data ); free( x.data );
1159 return STATUS_NOT_SUPPORTED;
1160 }
1161
1162 size = key->u.a.bitlen / 8;
1163 *ret_len = sizeof(*hdr) + sizeof(*pubkey) + size * 2 + 40 + sizeof(key->u.a.dss_seed);
1164 if (len >= *ret_len && buf)
1165 {
1166 hdr = (BLOBHEADER *)buf;
1167 hdr->bType = PRIVATEKEYBLOB;
1168 hdr->bVersion = 2;
1169 hdr->reserved = 0;
1170 hdr->aiKeyAlg = CALG_DSS_SIGN;
1171
1172 pubkey = (DSSPUBKEY *)(hdr + 1);
1173 pubkey->magic = MAGIC_DSS2;
1174 pubkey->bitlen = key->u.a.bitlen;
1175
1176 dst = (UCHAR *)(pubkey + 1);
1177 export_gnutls_datum( dst, size, &p, NULL );
1178 reverse_bytes( dst, size );
1179 dst += size;
1180
1181 export_gnutls_datum( dst, 20, &q, NULL );
1182 reverse_bytes( dst, 20 );
1183 dst += 20;
1184
1185 export_gnutls_datum( dst, size, &g, NULL );
1186 reverse_bytes( dst, size );
1187 dst += size;
1188
1189 export_gnutls_datum( dst, 20, &x, NULL );
1190 reverse_bytes( dst, 20 );
1191 dst += 20;
1192
1193 memcpy( dst, &key->u.a.dss_seed, sizeof(key->u.a.dss_seed) );
1194 }
1195
1196 free( p.data ); free( q.data ); free( g.data ); free( y.data ); free( x.data );
1197 return STATUS_SUCCESS;
1198 }
1199
1200 static NTSTATUS CDECL key_import_dsa_capi( struct key *key, UCHAR *buf, ULONG len )
1201 {
1202 BLOBHEADER *hdr = (BLOBHEADER *)buf;
1203 DSSPUBKEY *pubkey;
1204 gnutls_privkey_t handle;
1205 gnutls_datum_t p, q, g, y, x;
1206 unsigned char dummy[128];
1207 unsigned char *data, p_data[128], q_data[20], g_data[128], x_data[20];
1208 int i, ret, size;
1209 NTSTATUS status;
1210
1211 if ((ret = pgnutls_privkey_init( &handle )))
1212 {
1213 pgnutls_perror( ret );
1214 return STATUS_INTERNAL_ERROR;
1215 }
1216
1217 hdr = (BLOBHEADER *)buf;
1218 pubkey = (DSSPUBKEY *)(hdr + 1);
1219 if ((size = pubkey->bitlen / 8) > sizeof(p_data))
1220 {
1221 FIXME( "size %u not supported\n", size );
1222 pgnutls_privkey_deinit( handle );
1223 return STATUS_NOT_SUPPORTED;
1224 }
1225 data = (unsigned char *)(pubkey + 1);
1226
1227 p.data = p_data;
1228 p.size = size;
1229 for (i = 0; i < p.size; i++) p.data[i] = data[p.size - i - 1];
1230 data += p.size;
1231
1232 q.data = q_data;
1233 q.size = sizeof(q_data);
1234 for (i = 0; i < q.size; i++) q.data[i] = data[q.size - i - 1];
1235 data += q.size;
1236
1237 g.data = g_data;
1238 g.size = size;
1239 for (i = 0; i < g.size; i++) g.data[i] = data[g.size - i - 1];
1240 data += g.size;
1241
1242 x.data = x_data;
1243 x.size = sizeof(x_data);
1244 for (i = 0; i < x.size; i++) x.data[i] = data[x.size - i - 1];
1245 data += x.size;
1246
1247 WARN( "using dummy public key\n" );
1248 memset( dummy, 1, sizeof(dummy) );
1249 y.data = dummy;
1250 y.size = min( p.size, sizeof(dummy) );
1251
1252 if ((ret = pgnutls_privkey_import_dsa_raw( handle, &p, &q, &g, &y, &x )))
1253 {
1254 pgnutls_perror( ret );
1255 pgnutls_privkey_deinit( handle );
1256 return STATUS_INTERNAL_ERROR;
1257 }
1258
1259 if ((status = export_gnutls_pubkey_dsa_capi( handle, &key->u.a.dss_seed, key->u.a.bitlen, &key->u.a.pubkey,
1260 &key->u.a.pubkey_len )))
1261 {
1262 pgnutls_privkey_deinit( handle );
1263 return status;
1264 }
1265
1266 memcpy( &key->u.a.dss_seed, data, sizeof(key->u.a.dss_seed) );
1267
1268 key->u.a.flags |= KEY_FLAG_LEGACY_DSA_V2;
1269 key_data(key)->privkey = handle;
1270
1271 return STATUS_SUCCESS;
1272 }
1273
1274 static NTSTATUS CDECL key_asymmetric_init( struct key *key )
1275 {
1276 if (!libgnutls_handle) return STATUS_INTERNAL_ERROR;
1277
1278 switch (key->alg_id)
1279 {
1280 case ALG_ID_ECDH_P256:
1281 case ALG_ID_ECDSA_P256:
1282 case ALG_ID_ECDSA_P384:
1283 case ALG_ID_RSA:
1284 case ALG_ID_RSA_SIGN:
1285 case ALG_ID_DSA:
1286 return STATUS_SUCCESS;
1287
1288 default:
1289 FIXME( "algorithm %u not supported\n", key->alg_id );
1290 return STATUS_NOT_SUPPORTED;
1291 }
1292 }
1293
1294 static NTSTATUS import_gnutls_pubkey_ecc( struct key *key, gnutls_pubkey_t *gnutls_key )
1295 {
1296 BCRYPT_ECCKEY_BLOB *ecc_blob;
1297 gnutls_ecc_curve_t curve;
1298 gnutls_datum_t x, y;
1299 int ret;
1300
1301 switch (key->alg_id)
1302 {
1303 case ALG_ID_ECDSA_P256: curve = GNUTLS_ECC_CURVE_SECP256R1; break;
1304 case ALG_ID_ECDSA_P384: curve = GNUTLS_ECC_CURVE_SECP384R1; break;
1305
1306 default:
1307 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1308 return STATUS_NOT_IMPLEMENTED;
1309 }
1310
1311 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1312 {
1313 pgnutls_perror( ret );
1314 return STATUS_INTERNAL_ERROR;
1315 }
1316
1317 ecc_blob = (BCRYPT_ECCKEY_BLOB *)key->u.a.pubkey;
1318 x.data = key->u.a.pubkey + sizeof(*ecc_blob);
1319 x.size = ecc_blob->cbKey;
1320 y.data = key->u.a.pubkey + sizeof(*ecc_blob) + ecc_blob->cbKey;
1321 y.size = ecc_blob->cbKey;
1322
1323 if ((ret = pgnutls_pubkey_import_ecc_raw( *gnutls_key, curve, &x, &y )))
1324 {
1325 pgnutls_perror( ret );
1326 pgnutls_pubkey_deinit( *gnutls_key );
1327 return STATUS_INTERNAL_ERROR;
1328 }
1329
1330 return STATUS_SUCCESS;
1331 }
1332
1333 static NTSTATUS import_gnutls_pubkey_rsa( struct key *key, gnutls_pubkey_t *gnutls_key )
1334 {
1335 BCRYPT_RSAKEY_BLOB *rsa_blob;
1336 gnutls_datum_t m, e;
1337 int ret;
1338
1339 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1340 {
1341 pgnutls_perror( ret );
1342 return STATUS_INTERNAL_ERROR;
1343 }
1344
1345 rsa_blob = (BCRYPT_RSAKEY_BLOB *)key->u.a.pubkey;
1346 e.data = key->u.a.pubkey + sizeof(*rsa_blob);
1347 e.size = rsa_blob->cbPublicExp;
1348 m.data = key->u.a.pubkey + sizeof(*rsa_blob) + rsa_blob->cbPublicExp;
1349 m.size = rsa_blob->cbModulus;
1350
1351 if ((ret = pgnutls_pubkey_import_rsa_raw( *gnutls_key, &m, &e )))
1352 {
1353 pgnutls_perror( ret );
1354 pgnutls_pubkey_deinit( *gnutls_key );
1355 return STATUS_INTERNAL_ERROR;
1356 }
1357
1358 return STATUS_SUCCESS;
1359 }
1360
1361 static NTSTATUS import_gnutls_pubkey_dsa( struct key *key, gnutls_pubkey_t *gnutls_key )
1362 {
1363 BCRYPT_DSA_KEY_BLOB *dsa_blob;
1364 gnutls_datum_t p, q, g, y;
1365 int ret;
1366
1367 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1368 {
1369 pgnutls_perror( ret );
1370 return STATUS_INTERNAL_ERROR;
1371 }
1372
1373 dsa_blob = (BCRYPT_DSA_KEY_BLOB *)key->u.a.pubkey;
1374 p.data = key->u.a.pubkey + sizeof(*dsa_blob);
1375 p.size = dsa_blob->cbKey;
1376 q.data = dsa_blob->q;
1377 q.size = sizeof(dsa_blob->q);
1378 g.data = key->u.a.pubkey + sizeof(*dsa_blob) + dsa_blob->cbKey;
1379 g.size = dsa_blob->cbKey;
1380 y.data = key->u.a.pubkey + sizeof(*dsa_blob) + dsa_blob->cbKey * 2;
1381 y.size = dsa_blob->cbKey;
1382
1383 if ((ret = pgnutls_pubkey_import_dsa_raw( *gnutls_key, &p, &q, &g, &y )))
1384 {
1385 pgnutls_perror( ret );
1386 pgnutls_pubkey_deinit( *gnutls_key );
1387 return STATUS_INTERNAL_ERROR;
1388 }
1389
1390 return STATUS_SUCCESS;
1391 }
1392
1393 static NTSTATUS import_gnutls_pubkey_dsa_capi( struct key *key, gnutls_pubkey_t *gnutls_key )
1394 {
1395 BLOBHEADER *hdr;
1396 DSSPUBKEY *pubkey;
1397 gnutls_datum_t p, q, g, y;
1398 unsigned char *data, p_data[128], q_data[20], g_data[128], y_data[128];
1399 int i, ret, size;
1400
1401 if ((ret = pgnutls_pubkey_init( gnutls_key )))
1402 {
1403 pgnutls_perror( ret );
1404 return STATUS_INTERNAL_ERROR;
1405 }
1406
1407 hdr = (BLOBHEADER *)key->u.a.pubkey;
1408 pubkey = (DSSPUBKEY *)(hdr + 1);
1409 size = pubkey->bitlen / 8;
1410 data = (unsigned char *)(pubkey + 1);
1411
1412 p.data = p_data;
1413 p.size = size;
1414 for (i = 0; i < p.size; i++) p.data[i] = data[p.size - i - 1];
1415 data += p.size;
1416
1417 q.data = q_data;
1418 q.size = sizeof(q_data);
1419 for (i = 0; i < q.size; i++) q.data[i] = data[q.size - i - 1];
1420 data += q.size;
1421
1422 g.data = g_data;
1423 g.size = size;
1424 for (i = 0; i < g.size; i++) g.data[i] = data[g.size - i - 1];
1425 data += g.size;
1426
1427 y.data = y_data;
1428 y.size = sizeof(y_data);
1429 for (i = 0; i < y.size; i++) y.data[i] = data[y.size - i - 1];
1430
1431 if ((ret = pgnutls_pubkey_import_dsa_raw( *gnutls_key, &p, &q, &g, &y )))
1432 {
1433 pgnutls_perror( ret );
1434 pgnutls_pubkey_deinit( *gnutls_key );
1435 return STATUS_INTERNAL_ERROR;
1436 }
1437
1438 return STATUS_SUCCESS;
1439 }
1440
1441 static NTSTATUS import_gnutls_pubkey( struct key *key, gnutls_pubkey_t *gnutls_key )
1442 {
1443 switch (key->alg_id)
1444 {
1445 case ALG_ID_ECDSA_P256:
1446 case ALG_ID_ECDSA_P384:
1447 return import_gnutls_pubkey_ecc( key, gnutls_key );
1448
1449 case ALG_ID_RSA:
1450 case ALG_ID_RSA_SIGN:
1451 return import_gnutls_pubkey_rsa( key, gnutls_key );
1452
1453 case ALG_ID_DSA:
1454 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1455 return import_gnutls_pubkey_dsa_capi( key, gnutls_key );
1456 else
1457 return import_gnutls_pubkey_dsa( key, gnutls_key );
1458
1459 default:
1460 FIXME("algorithm %u not yet supported\n", key->alg_id );
1461 return STATUS_NOT_IMPLEMENTED;
1462 }
1463 }
1464
1465 static NTSTATUS prepare_gnutls_signature_dsa( struct key *key, UCHAR *signature, ULONG signature_len,
1466 gnutls_datum_t *gnutls_signature )
1467 {
1468 struct buffer buffer;
1469 DWORD r_len = signature_len / 2;
1470 DWORD s_len = r_len;
1471 BYTE *r = signature;
1472 BYTE *s = signature + r_len;
1473
1474 buffer_init( &buffer );
1475 buffer_append_asn1_r_s( &buffer, r, r_len, s, s_len );
1476 if (buffer.error)
1477 {
1478 buffer_free( &buffer );
1479 return STATUS_NO_MEMORY;
1480 }
1481
1482 gnutls_signature->data = buffer.buffer;
1483 gnutls_signature->size = buffer.pos;
1484 return STATUS_SUCCESS;
1485 }
1486
1487 static NTSTATUS prepare_gnutls_signature_rsa( struct key *key, UCHAR *signature, ULONG signature_len,
1488 gnutls_datum_t *gnutls_signature )
1489 {
1490 gnutls_signature->data = signature;
1491 gnutls_signature->size = signature_len;
1492 return STATUS_SUCCESS;
1493 }
1494
1495 static NTSTATUS prepare_gnutls_signature( struct key *key, UCHAR *signature, ULONG signature_len,
1496 gnutls_datum_t *gnutls_signature )
1497 {
1498 switch (key->alg_id)
1499 {
1500 case ALG_ID_ECDSA_P256:
1501 case ALG_ID_ECDSA_P384:
1502 case ALG_ID_DSA:
1503 return prepare_gnutls_signature_dsa( key, signature, signature_len, gnutls_signature );
1504
1505 case ALG_ID_RSA:
1506 case ALG_ID_RSA_SIGN:
1507 return prepare_gnutls_signature_rsa( key, signature, signature_len, gnutls_signature );
1508
1509 default:
1510 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1511 return STATUS_NOT_IMPLEMENTED;
1512 }
1513 }
1514
1515 static gnutls_digest_algorithm_t get_digest_from_id( const WCHAR *alg_id )
1516 {
1517 if (!strcmpW( alg_id, BCRYPT_SHA1_ALGORITHM )) return GNUTLS_DIG_SHA1;
1518 if (!strcmpW( alg_id, BCRYPT_SHA256_ALGORITHM )) return GNUTLS_DIG_SHA256;
1519 if (!strcmpW( alg_id, BCRYPT_SHA384_ALGORITHM )) return GNUTLS_DIG_SHA384;
1520 if (!strcmpW( alg_id, BCRYPT_SHA512_ALGORITHM )) return GNUTLS_DIG_SHA512;
1521 if (!strcmpW( alg_id, BCRYPT_MD2_ALGORITHM )) return GNUTLS_DIG_MD2;
1522 if (!strcmpW( alg_id, BCRYPT_MD5_ALGORITHM )) return GNUTLS_DIG_MD5;
1523 return -1;
1524 }
1525
1526 static NTSTATUS CDECL key_asymmetric_verify( struct key *key, void *padding, UCHAR *hash, ULONG hash_len,
1527 UCHAR *signature, ULONG signature_len, DWORD flags )
1528 {
1529 gnutls_digest_algorithm_t hash_alg;
1530 gnutls_sign_algorithm_t sign_alg;
1531 gnutls_datum_t gnutls_hash, gnutls_signature;
1532 gnutls_pk_algorithm_t pk_alg;
1533 gnutls_pubkey_t gnutls_key;
1534 NTSTATUS status;
1535 int ret;
1536
1537 switch (key->alg_id)
1538 {
1539 case ALG_ID_ECDSA_P256:
1540 case ALG_ID_ECDSA_P384:
1541 {
1542 if (flags) FIXME( "flags %08x not supported\n", flags );
1543
1544 /* only the hash size must match, not the actual hash function */
1545 switch (hash_len)
1546 {
1547 case 20: hash_alg = GNUTLS_DIG_SHA1; break;
1548 case 32: hash_alg = GNUTLS_DIG_SHA256; break;
1549 case 48: hash_alg = GNUTLS_DIG_SHA384; break;
1550
1551 default:
1552 FIXME( "hash size %u not yet supported\n", hash_len );
1553 return STATUS_INVALID_SIGNATURE;
1554 }
1555 pk_alg = GNUTLS_PK_ECC;
1556 break;
1557 }
1558 case ALG_ID_RSA:
1559 case ALG_ID_RSA_SIGN:
1560 {
1561 BCRYPT_PKCS1_PADDING_INFO *info = (BCRYPT_PKCS1_PADDING_INFO *)padding;
1562
1563 if (!(flags & BCRYPT_PAD_PKCS1) || !info) return STATUS_INVALID_PARAMETER;
1564 if (!info->pszAlgId) return STATUS_INVALID_SIGNATURE;
1565
1566 if ((hash_alg = get_digest_from_id(info->pszAlgId)) == -1)
1567 {
1568 FIXME( "hash algorithm %s not supported\n", debugstr_w(info->pszAlgId) );
1569 return STATUS_NOT_SUPPORTED;
1570 }
1571 pk_alg = GNUTLS_PK_RSA;
1572 break;
1573 }
1574 case ALG_ID_DSA:
1575 {
1576 if (flags) FIXME( "flags %08x not supported\n", flags );
1577 if (hash_len != 20)
1578 {
1579 FIXME( "hash size %u not supported\n", hash_len );
1580 return STATUS_INVALID_PARAMETER;
1581 }
1582 hash_alg = GNUTLS_DIG_SHA1;
1583 pk_alg = GNUTLS_PK_DSA;
1584 break;
1585 }
1586 default:
1587 FIXME( "algorithm %u not yet supported\n", key->alg_id );
1588 return STATUS_NOT_IMPLEMENTED;
1589 }
1590
1591 if ((sign_alg = pgnutls_pk_to_sign( pk_alg, hash_alg )) == GNUTLS_SIGN_UNKNOWN)
1592 {
1593 FIXME("GnuTLS does not support algorithm %u with hash len %u\n", key->alg_id, hash_len );
1594 return STATUS_NOT_IMPLEMENTED;
1595 }
1596
1597 if ((status = import_gnutls_pubkey( key, &gnutls_key ))) return status;
1598 if ((status = prepare_gnutls_signature( key, signature, signature_len, &gnutls_signature )))
1599 {
1600 pgnutls_pubkey_deinit( gnutls_key );
1601 return status;
1602 }
1603
1604 gnutls_hash.data = hash;
1605 gnutls_hash.size = hash_len;
1606 ret = pgnutls_pubkey_verify_hash2( gnutls_key, sign_alg, 0, &gnutls_hash, &gnutls_signature );
1607
1608 if (gnutls_signature.data != signature) free( gnutls_signature.data );
1609 pgnutls_pubkey_deinit( gnutls_key );
1610 return (ret < 0) ? STATUS_INVALID_SIGNATURE : STATUS_SUCCESS;
1611 }
1612
1613 static unsigned int get_signature_length( enum alg_id id )
1614 {
1615 switch (id)
1616 {
1617 case ALG_ID_ECDSA_P256: return 64;
1618 case ALG_ID_ECDSA_P384: return 96;
1619 case ALG_ID_DSA: return 40;
1620 default:
1621 FIXME( "unhandled algorithm %u\n", id );
1622 return 0;
1623 }
1624 }
1625
1626 static NTSTATUS format_gnutls_signature( enum alg_id type, gnutls_datum_t signature,
1627 UCHAR *output, ULONG output_len, ULONG *ret_len )
1628 {
1629 switch (type)
1630 {
1631 case ALG_ID_RSA:
1632 case ALG_ID_RSA_SIGN:
1633 {
1634 *ret_len = signature.size;
1635 if (output_len < signature.size) return STATUS_BUFFER_TOO_SMALL;
1636 if (output) memcpy( output, signature.data, signature.size );
1637 return STATUS_SUCCESS;
1638 }
1639 case ALG_ID_ECDSA_P256:
1640 case ALG_ID_ECDSA_P384:
1641 case ALG_ID_DSA:
1642 {
1643 int err;
1644 unsigned int sig_len = get_signature_length( type );
1645 gnutls_datum_t r, s; /* format as r||s */
1646
1647 if ((err = pgnutls_decode_rs_value( &signature, &r, &s )))
1648 {
1649 pgnutls_perror( err );
1650 return STATUS_INTERNAL_ERROR;
1651 }
1652
1653 *ret_len = sig_len;
1654 if (output_len < sig_len) return STATUS_BUFFER_TOO_SMALL;
1655
1656 if (r.size > sig_len / 2 + 1 || s.size > sig_len / 2 + 1)
1657 {
1658 ERR( "we didn't get a correct signature\n" );
1659 return STATUS_INTERNAL_ERROR;
1660 }
1661
1662 if (output)
1663 {
1664 export_gnutls_datum( output, sig_len / 2, &r, NULL );
1665 export_gnutls_datum( output + sig_len / 2, sig_len / 2, &s, NULL );
1666 }
1667
1668 free( r.data ); free( s.data );
1669 return STATUS_SUCCESS;
1670 }
1671 default:
1672 return STATUS_INTERNAL_ERROR;
1673 }
1674 }
1675
1676 static NTSTATUS CDECL key_asymmetric_sign( struct key *key, void *padding, UCHAR *input, ULONG input_len, UCHAR *output,
1677 ULONG output_len, ULONG *ret_len, ULONG flags )
1678 {
1679 BCRYPT_PKCS1_PADDING_INFO *pad = padding;
1680 gnutls_datum_t hash, signature;
1681 gnutls_digest_algorithm_t hash_alg;
1682 NTSTATUS status;
1683 int ret;
1684
1685 if (key->alg_id == ALG_ID_ECDSA_P256 || key->alg_id == ALG_ID_ECDSA_P384)
1686 {
1687 /* With ECDSA, we find the digest algorithm from the hash length, and verify it */
1688 switch (input_len)
1689 {
1690 case 20: hash_alg = GNUTLS_DIG_SHA1; break;
1691 case 32: hash_alg = GNUTLS_DIG_SHA256; break;
1692 case 48: hash_alg = GNUTLS_DIG_SHA384; break;
1693 case 64: hash_alg = GNUTLS_DIG_SHA512; break;
1694
1695 default:
1696 FIXME( "hash size %u not yet supported\n", input_len );
1697 return STATUS_INVALID_PARAMETER;
1698 }
1699
1700 if (flags == BCRYPT_PAD_PKCS1 && pad && pad->pszAlgId && get_digest_from_id( pad->pszAlgId ) != hash_alg)
1701 {
1702 WARN( "incorrect hashing algorithm %s, expected %u\n", debugstr_w(pad->pszAlgId), hash_alg );
1703 return STATUS_INVALID_PARAMETER;
1704 }
1705 }
1706 else if (key->alg_id == ALG_ID_DSA)
1707 {
1708 if (flags) FIXME( "flags %08x not supported\n", flags );
1709 if (input_len != 20)
1710 {
1711 FIXME( "hash size %u not supported\n", input_len );
1712 return STATUS_INVALID_PARAMETER;
1713 }
1714 hash_alg = GNUTLS_DIG_SHA1;
1715 }
1716 else if (flags == BCRYPT_PAD_PKCS1)
1717 {
1718 if (!pad || !pad->pszAlgId)
1719 {
1720 WARN( "padding info not found\n" );
1721 return STATUS_INVALID_PARAMETER;
1722 }
1723
1724 if ((hash_alg = get_digest_from_id( pad->pszAlgId )) == -1)
1725 {
1726 FIXME( "hash algorithm %s not recognized\n", debugstr_w(pad->pszAlgId) );
1727 return STATUS_NOT_SUPPORTED;
1728 }
1729 }
1730 else if (!flags)
1731 {
1732 WARN( "invalid flags %08x\n", flags );
1733 return STATUS_INVALID_PARAMETER;
1734 }
1735 else
1736 {
1737 FIXME( "flags %08x not implemented\n", flags );
1738 return STATUS_NOT_IMPLEMENTED;
1739 }
1740
1741 if (!input)
1742 {
1743 *ret_len = key->u.a.bitlen / 8;
1744 return STATUS_SUCCESS;
1745 }
1746 if (!key_data(key)->privkey) return STATUS_INVALID_PARAMETER;
1747
1748 hash.data = input;
1749 hash.size = input_len;
1750
1751 signature.data = NULL;
1752 signature.size = 0;
1753
1754 if ((ret = pgnutls_privkey_sign_hash( key_data(key)->privkey, hash_alg, 0, &hash, &signature )))
1755 {
1756 pgnutls_perror( ret );
1757 return STATUS_INTERNAL_ERROR;
1758 }
1759
1760 status = format_gnutls_signature( key->alg_id, signature, output, output_len, ret_len );
1761
1762 free( signature.data );
1763 return status;
1764 }
1765
1766 static void CDECL key_asymmetric_destroy( struct key *key )
1767 {
1768 if (key_data(key)->privkey) pgnutls_privkey_deinit( key_data(key)->privkey );
1769 }
1770
1771 static NTSTATUS CDECL key_asymmetric_duplicate( struct key *key_orig, struct key *key_copy )
1772 {
1773 int ret;
1774
1775 if (!key_data(key_orig)->privkey) return STATUS_SUCCESS;
1776
1777 if ((ret = pgnutls_privkey_init( &key_data(key_copy)->privkey )))
1778 {
1779 pgnutls_perror( ret );
1780 return STATUS_INTERNAL_ERROR;
1781 }
1782
1783 switch (key_orig->alg_id)
1784 {
1785 case ALG_ID_RSA:
1786 case ALG_ID_RSA_SIGN:
1787 {
1788 gnutls_datum_t m, e, d, p, q, u, e1, e2;
1789 if ((ret = pgnutls_privkey_export_rsa_raw( key_data(key_orig)->privkey, &m, &e, &d, &p, &q, &u, &e1, &e2 )))
1790 {
1791 pgnutls_perror( ret );
1792 return STATUS_INTERNAL_ERROR;
1793 }
1794 ret = pgnutls_privkey_import_rsa_raw( key_data(key_copy)->privkey, &m, &e, &d, &p, &q, &u, &e1, &e2 );
1795 free( m.data ); free( e.data ); free( d.data ); free( p.data ); free( q.data ); free( u.data );
1796 free( e1.data ); free( e2.data );
1797 if (ret)
1798 {
1799 pgnutls_perror( ret );
1800 return STATUS_INTERNAL_ERROR;
1801 }
1802 break;
1803 }
1804 case ALG_ID_DSA:
1805 {
1806 gnutls_datum_t p, q, g, y, x;
1807 if ((ret = pgnutls_privkey_export_dsa_raw( key_data(key_orig)->privkey, &p, &q, &g, &y, &x )))
1808 {
1809 pgnutls_perror( ret );
1810 return STATUS_INTERNAL_ERROR;
1811 }
1812 ret = pgnutls_privkey_import_dsa_raw( key_data(key_copy)->privkey, &p, &q, &g, &y, &x );
1813 free( p.data ); free( q.data ); free( g.data ); free( y.data ); free( x.data );
1814 if (ret)
1815 {
1816 pgnutls_perror( ret );
1817 return STATUS_INTERNAL_ERROR;
1818 }
1819 break;
1820 }
1821 case ALG_ID_ECDH_P256:
1822 case ALG_ID_ECDSA_P256:
1823 case ALG_ID_ECDSA_P384:
1824 {
1825 gnutls_ecc_curve_t curve;
1826 gnutls_datum_t x, y, k;
1827 if ((ret = pgnutls_privkey_export_ecc_raw( key_data(key_orig)->privkey, &curve, &x, &y, &k )))
1828 {
1829 pgnutls_perror( ret );
1830 return STATUS_INTERNAL_ERROR;
1831 }
1832 ret = pgnutls_privkey_import_ecc_raw( key_data(key_copy)->privkey, curve, &x, &y, &k );
1833 free( x.data ); free( y.data ); free( k.data );
1834 if (ret)
1835 {
1836 pgnutls_perror( ret );
1837 return STATUS_INTERNAL_ERROR;
1838 }
1839 break;
1840 }
1841 default:
1842 ERR( "unhandled algorithm %u\n", key_orig->alg_id );
1843 return STATUS_INTERNAL_ERROR;
1844 }
1845
1846 return STATUS_SUCCESS;
1847 }
1848
1849 static NTSTATUS CDECL key_asymmetric_decrypt( struct key *key, UCHAR *input, ULONG input_len, UCHAR *output,
1850 ULONG output_len, ULONG *ret_len )
1851 {
1852 gnutls_datum_t e, d = { 0 };
1853 NTSTATUS status = STATUS_SUCCESS;
1854 int ret;
1855
1856 e.data = input;
1857 e.size = input_len;
1858 if ((ret = pgnutls_privkey_decrypt_data( key_data(key)->privkey, 0, &e, &d )))
1859 {
1860 pgnutls_perror( ret );
1861 return STATUS_INTERNAL_ERROR;
1862 }
1863
1864 *ret_len = d.size;
1865 if (output_len >= d.size) memcpy( output, d.data, *ret_len );
1866 else status = STATUS_BUFFER_TOO_SMALL;
1867
1868 free( d.data );
1869 return status;
1870 }
1871
1872 static const struct key_funcs key_funcs =
1873 {
1874 key_set_property,
1875 key_symmetric_init,
1876 key_symmetric_vector_reset,
1877 key_symmetric_set_auth_data,
1878 key_symmetric_encrypt,
1879 key_symmetric_decrypt,
1880 key_symmetric_get_tag,
1881 key_symmetric_destroy,
1882 key_asymmetric_init,
1883 key_asymmetric_generate,
1884 key_asymmetric_decrypt,
1885 key_asymmetric_duplicate,
1886 key_asymmetric_sign,
1887 key_asymmetric_verify,
1888 key_asymmetric_destroy,
1889 key_export_dsa_capi,
1890 key_export_ecc,
1891 key_import_dsa_capi,
1892 key_import_ecc,
1893 key_import_rsa
1894 };
1895
1896 NTSTATUS CDECL __wine_init_unix_lib( HMODULE module, DWORD reason, const void *ptr_in, void *ptr_out )
1897 {
1898 switch (reason)
1899 {
1900 case DLL_PROCESS_ATTACH:
1901 if (!gnutls_initialize()) return STATUS_DLL_NOT_FOUND;
1902 *(const struct key_funcs **)ptr_out = &key_funcs;
1903 break;
1904 case DLL_PROCESS_DETACH:
1905 if (libgnutls_handle) gnutls_uninitialize();
1906 break;
1907 }
1908 return STATUS_SUCCESS;
1909 }
1910
1911 #endif /* HAVE_GNUTLS_CIPHER_INIT */
Windows API implementation