ReactOS 0.4.17-dev-863-gc5f151a
mbedtls.c
Go to the documentation of this file.
1#include "precomp.h"
2
3#ifdef SONAME_LIBMBEDTLS
4
5#include <mbedtls/asn1.h>
6#include <mbedtls/asn1write.h>
7#include <mbedtls/cipher.h>
8#include <mbedtls/ctr_drbg.h>
9#include <mbedtls/dhm.h>
10#include <mbedtls/ecdh.h>
11#include <mbedtls/ecp.h>
12#include <mbedtls/entropy.h>
13#include <mbedtls/md.h>
14#include <mbedtls/pk.h>
15#include <mbedtls/rsa.h>
16#include <mbedtls/dsa.h>
17
18WINE_DEFAULT_DEBUG_CHANNEL(bcrypt);
19
20#ifndef __REACTOS__
21static void *libmbedtls_handle;
22#endif
23static mbedtls_entropy_context entropy;
24static mbedtls_ctr_drbg_context ctr_drbg;
25static CRITICAL_SECTION rng_lock;
26static BOOL rng_seeded;
27
28union key_data
29{
30 union
31 {
32 mbedtls_cipher_context_t cipher_ctx;
33 } s;
34 union
35 {
36 struct
37 {
38 mbedtls_pk_context privkey;
39 mbedtls_pk_context pubkey;
40 } pk;
41 struct
42 {
43 mbedtls_dhm_context privkey;
44 mbedtls_dhm_context pubkey;
45 } dh;
46#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
47 struct
48 {
49 mbedtls_dsa_context privkey;
50 mbedtls_dsa_context pubkey;
51 } dsa;
52#endif
53 } a;
54};
55C_ASSERT(sizeof(union key_data) <= sizeof(((struct key *)0)->private));
56
57static union key_data *key_data(struct key *key)
58{
59 return (union key_data *)key->private;
60}
61
62#ifndef __REACTOS__
63#define MAKE_FUNCPTR(f) static typeof(f) * p##f;
64MAKE_FUNCPTR(mbedtls_md_init)
65MAKE_FUNCPTR(mbedtls_md_info_from_type)
66MAKE_FUNCPTR(mbedtls_md_get_size)
67MAKE_FUNCPTR(mbedtls_md_setup)
68MAKE_FUNCPTR(mbedtls_md_update)
69MAKE_FUNCPTR(mbedtls_md_starts)
70MAKE_FUNCPTR(mbedtls_md_finish)
71MAKE_FUNCPTR(mbedtls_md_hmac_update)
72MAKE_FUNCPTR(mbedtls_md_hmac_starts)
73MAKE_FUNCPTR(mbedtls_md_hmac_finish)
74MAKE_FUNCPTR(mbedtls_md_free)
75MAKE_FUNCPTR(mbedtls_cipher_init)
76MAKE_FUNCPTR(mbedtls_cipher_setup)
77MAKE_FUNCPTR(mbedtls_cipher_info_from_type)
78MAKE_FUNCPTR(mbedtls_cipher_setkey)
79MAKE_FUNCPTR(mbedtls_cipher_set_iv)
80MAKE_FUNCPTR(mbedtls_cipher_set_padding_mode)
81MAKE_FUNCPTR(mbedtls_cipher_update)
82MAKE_FUNCPTR(mbedtls_cipher_update_ad)
83MAKE_FUNCPTR(mbedtls_cipher_check_tag)
84MAKE_FUNCPTR(mbedtls_cipher_write_tag)
85MAKE_FUNCPTR(mbedtls_cipher_finish)
86MAKE_FUNCPTR(mbedtls_cipher_free)
87MAKE_FUNCPTR(mbedtls_ctr_drbg_init)
88MAKE_FUNCPTR(mbedtls_ctr_drbg_random)
89MAKE_FUNCPTR(mbedtls_ctr_drbg_seed)
90MAKE_FUNCPTR(mbedtls_ctr_drbg_free)
91MAKE_FUNCPTR(mbedtls_entropy_init)
92MAKE_FUNCPTR(mbedtls_entropy_func)
93MAKE_FUNCPTR(mbedtls_entropy_free)
94MAKE_FUNCPTR(mbedtls_pk_init)
95MAKE_FUNCPTR(mbedtls_pk_get_type)
96MAKE_FUNCPTR(mbedtls_pk_setup)
97MAKE_FUNCPTR(mbedtls_pk_info_from_type)
98MAKE_FUNCPTR(mbedtls_pk_parse_key)
99MAKE_FUNCPTR(mbedtls_pk_parse_public_key)
100MAKE_FUNCPTR(mbedtls_pk_verify_ext)
101MAKE_FUNCPTR(mbedtls_pk_sign)
102MAKE_FUNCPTR(mbedtls_pk_encrypt)
103MAKE_FUNCPTR(mbedtls_pk_decrypt)
104MAKE_FUNCPTR(mbedtls_pk_free)
105MAKE_FUNCPTR(mbedtls_ecdh_init)
106MAKE_FUNCPTR(mbedtls_ecdh_compute_shared)
107MAKE_FUNCPTR(mbedtls_ecdh_free)
108MAKE_FUNCPTR(mbedtls_rsa_gen_key)
109MAKE_FUNCPTR(mbedtls_rsa_export)
110MAKE_FUNCPTR(mbedtls_rsa_import_raw)
111MAKE_FUNCPTR(mbedtls_rsa_export_raw)
112MAKE_FUNCPTR(mbedtls_rsa_export_crt)
113MAKE_FUNCPTR(mbedtls_rsa_set_padding)
114MAKE_FUNCPTR(mbedtls_rsa_complete)
115MAKE_FUNCPTR(mbedtls_rsa_check_pubkey)
116MAKE_FUNCPTR(mbedtls_rsa_check_privkey)
117MAKE_FUNCPTR(mbedtls_rsa_check_pub_priv)
118MAKE_FUNCPTR(mbedtls_ecp_gen_key)
119MAKE_FUNCPTR(mbedtls_ecp_group_load)
120MAKE_FUNCPTR(mbedtls_ecp_point_read_binary)
121MAKE_FUNCPTR(mbedtls_ecp_point_write_binary)
122MAKE_FUNCPTR(mbedtls_ecp_check_pubkey)
123MAKE_FUNCPTR(mbedtls_ecp_copy)
124MAKE_FUNCPTR(mbedtls_mpi_init)
125MAKE_FUNCPTR(mbedtls_mpi_size)
126MAKE_FUNCPTR(mbedtls_mpi_lset)
127MAKE_FUNCPTR(mbedtls_mpi_copy)
128MAKE_FUNCPTR(mbedtls_mpi_cmp_mpi)
129MAKE_FUNCPTR(mbedtls_mpi_cmp_int)
130MAKE_FUNCPTR(mbedtls_mpi_read_binary)
131MAKE_FUNCPTR(mbedtls_mpi_write_binary)
132MAKE_FUNCPTR(mbedtls_mpi_read_string)
133MAKE_FUNCPTR(mbedtls_mpi_gen_prime)
134MAKE_FUNCPTR(mbedtls_mpi_sub_int)
135MAKE_FUNCPTR(mbedtls_mpi_div_int)
136MAKE_FUNCPTR(mbedtls_mpi_is_prime_ext)
137MAKE_FUNCPTR(mbedtls_mpi_free)
138MAKE_FUNCPTR(mbedtls_asn1_get_len)
139MAKE_FUNCPTR(mbedtls_asn1_get_mpi)
140MAKE_FUNCPTR(mbedtls_asn1_get_tag)
141MAKE_FUNCPTR(mbedtls_asn1_write_len)
142MAKE_FUNCPTR(mbedtls_asn1_write_mpi)
143MAKE_FUNCPTR(mbedtls_asn1_write_tag)
144MAKE_FUNCPTR(mbedtls_asn1_write_raw_buffer)
145MAKE_FUNCPTR(mbedtls_dhm_init)
146MAKE_FUNCPTR(mbedtls_dhm_make_params)
147MAKE_FUNCPTR(mbedtls_dhm_calc_secret)
148MAKE_FUNCPTR(mbedtls_dhm_free)
149MAKE_FUNCPTR(mbedtls_dsa_init)
150MAKE_FUNCPTR(mbedtls_dsa_set_group)
151MAKE_FUNCPTR(mbedtls_dsa_genkey)
152MAKE_FUNCPTR(mbedtls_dsa_check_pqg)
153MAKE_FUNCPTR(mbedtls_dsa_check_pubkey)
154MAKE_FUNCPTR(mbedtls_dsa_check_privkey)
155MAKE_FUNCPTR(mbedtls_dsa_pubkey_from_privkey)
156MAKE_FUNCPTR(mbedtls_dsa_verify)
157MAKE_FUNCPTR(mbedtls_dsa_sign)
158MAKE_FUNCPTR(mbedtls_dsa_free)
159#undef MAKE_FUNCPTR
160#endif
161
162NTSTATUS process_attach(void *args)
163{
164#ifndef __REACTOS__
165 if (!(libmbedtls_handle = wine_dlopen(SONAME_LIBMBEDTLS, RTLD_NOW, NULL, 0)))
166 {
167 ERR("failed to load libmbedtls, no support for crypto hashes\n");
168 return STATUS_DLL_NOT_FOUND;
169 }
170
171#define LOAD_FUNCPTR(f) \
172 if (!(p##f = wine_dlsym(libmbedtls_handle, #f, NULL, 0))) \
173 { \
174 ERR("failed to load %s\n", #f); \
175 goto fail; \
176 }
177
178 LOAD_FUNCPTR(mbedtls_md_init)
179 LOAD_FUNCPTR(mbedtls_md_info_from_type)
180 LOAD_FUNCPTR(mbedtls_md_get_size)
181 LOAD_FUNCPTR(mbedtls_md_setup)
182 LOAD_FUNCPTR(mbedtls_md_update)
183 LOAD_FUNCPTR(mbedtls_md_starts)
184 LOAD_FUNCPTR(mbedtls_md_finish)
185 LOAD_FUNCPTR(mbedtls_md_hmac_update)
186 LOAD_FUNCPTR(mbedtls_md_hmac_starts)
187 LOAD_FUNCPTR(mbedtls_md_hmac_finish)
188 LOAD_FUNCPTR(mbedtls_md_free);
189 LOAD_FUNCPTR(mbedtls_cipher_init)
190 LOAD_FUNCPTR(mbedtls_cipher_setup)
191 LOAD_FUNCPTR(mbedtls_cipher_info_from_type)
192 LOAD_FUNCPTR(mbedtls_cipher_setkey)
193 LOAD_FUNCPTR(mbedtls_cipher_set_iv)
194 LOAD_FUNCPTR(mbedtls_cipher_set_padding_mode);
195 LOAD_FUNCPTR(mbedtls_cipher_update);
196 LOAD_FUNCPTR(mbedtls_cipher_update_ad);
197 LOAD_FUNCPTR(mbedtls_cipher_check_tag);
198 LOAD_FUNCPTR(mbedtls_cipher_write_tag);
199 LOAD_FUNCPTR(mbedtls_cipher_finish);
200 LOAD_FUNCPTR(mbedtls_cipher_free);
201 LOAD_FUNCPTR(mbedtls_ctr_drbg_init)
202 LOAD_FUNCPTR(mbedtls_ctr_drbg_random)
203 LOAD_FUNCPTR(mbedtls_ctr_drbg_seed)
204 LOAD_FUNCPTR(mbedtls_ctr_drbg_free)
205 LOAD_FUNCPTR(mbedtls_entropy_init)
206 LOAD_FUNCPTR(mbedtls_entropy_func)
207 LOAD_FUNCPTR(mbedtls_entropy_free)
208 LOAD_FUNCPTR(mbedtls_pk_init)
209 LOAD_FUNCPTR(mbedtls_pk_get_type)
210 LOAD_FUNCPTR(mbedtls_pk_setup)
211 LOAD_FUNCPTR(mbedtls_pk_info_from_type)
212 LOAD_FUNCPTR(mbedtls_pk_parse_key)
213 LOAD_FUNCPTR(mbedtls_pk_parse_public_key)
214 LOAD_FUNCPTR(mbedtls_pk_verify_ext)
215 LOAD_FUNCPTR(mbedtls_pk_sign)
216 LOAD_FUNCPTR(mbedtls_pk_encrypt)
217 LOAD_FUNCPTR(mbedtls_pk_decrypt)
218 LOAD_FUNCPTR(mbedtls_pk_free)
219 LOAD_FUNCPTR(mbedtls_ecdh_init)
220 LOAD_FUNCPTR(mbedtls_ecdh_compute_shared)
221 LOAD_FUNCPTR(mbedtls_ecdh_free)
222 LOAD_FUNCPTR(mbedtls_rsa_gen_key)
223 LOAD_FUNCPTR(mbedtls_rsa_import_raw)
224 LOAD_FUNCPTR(mbedtls_rsa_export_raw)
225 LOAD_FUNCPTR(mbedtls_rsa_export)
226 LOAD_FUNCPTR(mbedtls_rsa_export_crt)
227 LOAD_FUNCPTR(mbedtls_rsa_set_padding)
228 LOAD_FUNCPTR(mbedtls_rsa_complete)
229 LOAD_FUNCPTR(mbedtls_rsa_check_pubkey)
230 LOAD_FUNCPTR(mbedtls_rsa_check_privkey)
231 LOAD_FUNCPTR(mbedtls_rsa_check_pub_priv)
232 LOAD_FUNCPTR(mbedtls_ecp_gen_key)
233 LOAD_FUNCPTR(mbedtls_ecp_group_load)
234 LOAD_FUNCPTR(mbedtls_ecp_point_read_binary)
235 LOAD_FUNCPTR(mbedtls_ecp_point_write_binary)
236 LOAD_FUNCPTR(mbedtls_ecp_check_pubkey)
237 LOAD_FUNCPTR(mbedtls_ecp_copy)
238 LOAD_FUNCPTR(mbedtls_mpi_init)
239 LOAD_FUNCPTR(mbedtls_mpi_size)
240 LOAD_FUNCPTR(mbedtls_mpi_lset)
241 LOAD_FUNCPTR(mbedtls_mpi_copy)
242 LOAD_FUNCPTR(mbedtls_mpi_cmp_mpi)
243 LOAD_FUNCPTR(mbedtls_mpi_cmp_int)
244 LOAD_FUNCPTR(mbedtls_mpi_read_binary)
245 LOAD_FUNCPTR(mbedtls_mpi_write_binary)
246 LOAD_FUNCPTR(mbedtls_mpi_read_string)
247 LOAD_FUNCPTR(mbedtls_mpi_gen_prime)
248 LOAD_FUNCPTR(mbedtls_mpi_sub_int)
249 LOAD_FUNCPTR(mbedtls_mpi_div_int)
250 LOAD_FUNCPTR(mbedtls_mpi_is_prime_ext)
251 LOAD_FUNCPTR(mbedtls_mpi_free)
252 LOAD_FUNCPTR(mbedtls_asn1_get_len)
253 LOAD_FUNCPTR(mbedtls_asn1_get_mpi)
254 LOAD_FUNCPTR(mbedtls_asn1_get_tag)
255 LOAD_FUNCPTR(mbedtls_asn1_write_len)
256 LOAD_FUNCPTR(mbedtls_asn1_write_mpi)
257 LOAD_FUNCPTR(mbedtls_asn1_write_tag)
258 LOAD_FUNCPTR(mbedtls_asn1_write_raw_buffer)
259 LOAD_FUNCPTR(mbedtls_dhm_init)
260 LOAD_FUNCPTR(mbedtls_dhm_make_params)
261 LOAD_FUNCPTR(mbedtls_dhm_calc_secret)
262 LOAD_FUNCPTR(mbedtls_dhm_free)
263 LOAD_FUNCPTR(mbedtls_dsa_init)
264 LOAD_FUNCPTR(mbedtls_dsa_set_group)
265 LOAD_FUNCPTR(mbedtls_dsa_genkey)
266 LOAD_FUNCPTR(mbedtls_dsa_check_pqg)
267 LOAD_FUNCPTR(mbedtls_dsa_check_pubkey)
268 LOAD_FUNCPTR(mbedtls_dsa_check_privkey)
269 LOAD_FUNCPTR(mbedtls_dsa_pubkey_from_privkey)
270 LOAD_FUNCPTR(mbedtls_dsa_verify)
271 LOAD_FUNCPTR(mbedtls_dsa_sign)
272 LOAD_FUNCPTR(mbedtls_dsa_free)
273#undef LOAD_FUNCPTR
274#endif
275 mbedtls_ctr_drbg_init(&ctr_drbg);
276 mbedtls_entropy_init(&entropy);
277 InitializeCriticalSection(&rng_lock);
278
279 return STATUS_SUCCESS;
280#ifndef __REACTOS__
281fail:
282 wine_dlclose(libmbedtls_handle, NULL, 0);
283 libmbedtls_handle = NULL;
284 return STATUS_DLL_NOT_FOUND;
285#endif
286}
287
288#ifndef __REACTOS__
289#define mbedtls_md_init pmbedtls_md_init
290#define mbedtls_md_info_from_type pmbedtls_md_info_from_type
291#define mbedtls_md_get_size pmbedtls_md_get_size
292#define mbedtls_md_setup pmbedtls_md_setup
293#define mbedtls_md_update pmbedtls_md_update
294#define mbedtls_md_starts pmbedtls_md_starts
295#define mbedtls_md_finish pmbedtls_md_finish
296#define mbedtls_md_hmac_update pmbedtls_md_hmac_update
297#define mbedtls_md_hmac_starts pmbedtls_md_hmac_starts
298#define mbedtls_md_hmac_finish pmbedtls_md_hmac_finish
299#define mbedtls_md_free pmbedtls_md_free
300#define mbedtls_cipher_init pmbedtls_cipher_init
301#define mbedtls_cipher_setup pmbedtls_cipher_setup
302#define mbedtls_cipher_info_from_type pmbedtls_cipher_info_from_type
303#define mbedtls_cipher_setkey pmbedtls_cipher_setkey
304#define mbedtls_cipher_set_iv pmbedtls_cipher_set_iv
305#define mbedtls_cipher_set_padding_mode pmbedtls_cipher_set_padding_mode
306#define mbedtls_cipher_update pmbedtls_cipher_update
307#define mbedtls_cipher_update_ad pmbedtls_cipher_update_ad
308#define mbedtls_cipher_check_tag pmbedtls_cipher_check_tag
309#define mbedtls_cipher_write_tag pmbedtls_cipher_write_tag
310#define mbedtls_cipher_finish pmbedtls_cipher_finish
311#define mbedtls_cipher_free pmbedtls_cipher_free
312#define mbedtls_ctr_drbg_init pmbedtls_ctr_drbg_init
313#define mbedtls_ctr_drbg_random pmbedtls_ctr_drbg_random
314#define mbedtls_ctr_drbg_seed pmbedtls_ctr_drbg_seed
315#define mbedtls_ctr_drbg_free pmbedtls_ctr_drbg_free
316#define mbedtls_entropy_init pmbedtls_entropy_init
317#define mbedtls_entropy_func pmbedtls_entropy_func
318#define mbedtls_entropy_free pmbedtls_entropy_free
319#define mbedtls_pk_init pmbedtls_pk_init
320#define mbedtls_pk_get_type pmbedtls_pk_get_type
321#define mbedtls_pk_setup pmbedtls_pk_setup
322#define mbedtls_pk_info_from_type pmbedtls_pk_info_from_type
323#define mbedtls_pk_parse_key pmbedtls_pk_parse_key
324#define mbedtls_pk_parse_public_key pmbedtls_pk_parse_public_key
325#define mbedtls_pk_verify_ext pmbedtls_pk_verify_ext
326#define mbedtls_pk_sign pmbedtls_pk_sign
327#define mbedtls_pk_encrypt pmbedtls_pk_encrypt
328#define mbedtls_pk_decrypt pmbedtls_pk_decrypt
329#define mbedtls_pk_free pmbedtls_pk_free
330#define mbedtls_ecdh_init pmbedtls_ecdh_init
331#define mbedtls_ecdh_compute_shared pmbedtls_ecdh_compute_shared
332#define mbedtls_ecdh_free pmbedtls_ecdh_free
333#define mbedtls_rsa_gen_key pmbedtls_rsa_gen_key
334#define mbedtls_rsa_import_raw pmbedtls_rsa_import_raw
335#define mbedtls_rsa_export pmbedtls_rsa_export
336#define mbedtls_rsa_export_raw pmbedtls_rsa_export_raw
337#define mbedtls_rsa_export_crt pmbedtls_rsa_export_crt
338#define mbedtls_rsa_set_padding pmbedtls_rsa_set_padding
339#define mbedtls_rsa_complete pmbedtls_rsa_complete
340#define mbedtls_rsa_check_pubkey pmbedtls_rsa_check_pubkey
341#define mbedtls_rsa_check_privkey pmbedtls_rsa_check_privkey
342#define mbedtls_rsa_check_pub_priv pmbedtls_rsa_check_pub_priv
343#define mbedtls_ecp_gen_key pmbedtls_ecp_gen_key
344#define mbedtls_ecp_group_load pmbedtls_ecp_group_load
345#define mbedtls_ecp_point_read_binary pmbedtls_ecp_point_read_binary
346#define mbedtls_ecp_point_write_binary pmbedtls_ecp_point_write_binary
347#define mbedtls_ecp_check_pubkey pmbedtls_ecp_check_pubkey
348#define mbedtls_ecp_copy pmbedtls_ecp_copy
349#define mbedtls_mpi_init pmbedtls_mpi_init
350#define mbedtls_mpi_size pmbedtls_mpi_size
351#define mbedtls_mpi_lset pmbedtls_mpi_lset
352#define mbedtls_mpi_copy pmbedtls_mpi_copy
353#define mbedtls_mpi_cmp_mpi pmbedtls_mpi_cmp_mpi
354#define mbedtls_mpi_cmp_int pmbedtls_mpi_cmp_int
355#define mbedtls_mpi_read_binary pmbedtls_mpi_read_binary
356#define mbedtls_mpi_write_binary pmbedtls_mpi_write_binary
357#define mbedtls_mpi_read_string pmbedtls_mpi_read_string
358#define mbedtls_mpi_gen_prime pmbedtls_mpi_gen_prime
359#define mbedtls_mpi_sub_int pmbedtls_mpi_sub_int
360#define mbedtls_mpi_div_int pmbedtls_mpi_div_int
361#define mbedtls_mpi_is_prime_ext pmbedtls_mpi_is_prime_ext
362#define mbedtls_mpi_free pmbedtls_mpi_free
363#define mbedtls_asn1_get_len pmbedtls_asn1_get_len
364#define mbedtls_asn1_get_mpi pmbedtls_asn1_get_mpi
365#define mbedtls_asn1_get_tag pmbedtls_asn1_get_tag
366#define mbedtls_asn1_write_len pmbedtls_asn1_write_len
367#define mbedtls_asn1_write_mpi pmbedtls_asn1_write_mpi
368#define mbedtls_asn1_write_tag pmbedtls_asn1_write_tag
369#define mbedtls_asn1_write_raw_buffer pmbedtls_asn1_write_raw_buffer
370#define mbedtls_dhm_init pmbedtls_dhm_init
371#define mbedtls_dhm_make_params pmbedtls_dhm_make_params
372#define mbedtls_dhm_calc_secret pmbedtls_dhm_calc_secret
373#define mbedtls_dhm_free pmbedtls_dhm_free
374#define mbedtls_dsa_init pmbedtls_dsa_init
375#define mbedtls_dsa_set_group pmbedtls_dsa_set_group
376#define mbedtls_dsa_genkey pmbedtls_dsa_genkey
377#define mbedtls_dsa_check_pqg pmbedtls_dsa_check_pqg
378#define mbedtls_dsa_check_pubkey pmbedtls_dsa_check_pubkey
379#define mbedtls_dsa_check_privkey pmbedtls_dsa_check_privkey
380#define mbedtls_dsa_pubkey_from_privkey pmbedtls_dsa_pubkey_from_privkey
381#define mbedtls_dsa_verify pmbedtls_dsa_verify
382#define mbedtls_dsa_sign pmbedtls_dsa_sign
383#define mbedtls_dsa_free pmbedtls_dsa_free
384#endif
385
386NTSTATUS process_detach(void *args)
387{
388#ifndef __REACTOS__
389 if (libmbedtls_handle)
390 {
391#endif
392 mbedtls_entropy_free(&entropy);
393 mbedtls_ctr_drbg_free(&ctr_drbg);
394 DeleteCriticalSection(&rng_lock);
395 rng_seeded = FALSE;
396#ifndef __REACTOS__
397 wine_dlclose(libmbedtls_handle, NULL, 0);
398 libmbedtls_handle = NULL;
399 }
400#endif
401 return STATUS_SUCCESS;
402}
403
404static int bcrypt_rng(void *ctx, unsigned char *output, size_t len)
405{
406 int ret = 0;
407
408 EnterCriticalSection(&rng_lock);
409 if (!rng_seeded)
410 {
411 ret = mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0);
412 if (!ret)
413 rng_seeded = TRUE;
414 else
415 ERR("cannot seed the random generator: %d\n", ret);
416 }
417 LeaveCriticalSection(&rng_lock);
418
419 if (ret)
420 return ret;
421
422 return mbedtls_ctr_drbg_random(&ctr_drbg, output, len);
423}
424
425NTSTATUS hash_init(struct hash *hash)
426{
427 const mbedtls_md_info_t *md_info;
428 mbedtls_md_type_t md_type;
429 int ret;
430#ifndef __REACTOS__
431 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
432#endif
433 mbedtls_md_init(&hash->hash_ctx);
434 switch (hash->alg_id)
435 {
436 case ALG_ID_MD2:
437 md_type = MBEDTLS_MD_MD2;
438 break;
439
440 case ALG_ID_MD4:
441 md_type = MBEDTLS_MD_MD4;
442 break;
443
444 case ALG_ID_MD5:
445 md_type = MBEDTLS_MD_MD5;
446 break;
447
448 case ALG_ID_SHA1:
449 md_type = MBEDTLS_MD_SHA1;
450 break;
451
452 case ALG_ID_SHA256:
453 md_type = MBEDTLS_MD_SHA256;
454 break;
455
456 case ALG_ID_SHA384:
457 md_type = MBEDTLS_MD_SHA384;
458 break;
459
460 case ALG_ID_SHA512:
461 md_type = MBEDTLS_MD_SHA512;
462 break;
463
464 default:
465 ERR("unhandled id %u\n", hash->alg_id);
466 return STATUS_NOT_IMPLEMENTED;
467 }
468 if ((md_info = mbedtls_md_info_from_type(md_type)) == NULL)
469 {
470 mbedtls_md_free(&hash->hash_ctx);
471 return STATUS_INTERNAL_ERROR;
472 }
473
474 if ((ret = mbedtls_md_setup(&hash->hash_ctx, md_info, hash->flags & HASH_FLAG_HMAC)) != 0)
475 {
476 mbedtls_md_free(&hash->hash_ctx);
477 return STATUS_INTERNAL_ERROR;
478 }
479
480 if (hash->flags & HASH_FLAG_HMAC)
481 mbedtls_md_hmac_starts(&hash->hash_ctx, hash->secret, hash->secret_len);
482 else
483 mbedtls_md_starts(&hash->hash_ctx);
484
485 return STATUS_SUCCESS;
486}
487
488NTSTATUS hash_update(struct hash *hash, UCHAR *input, ULONG size)
489{
490#ifndef __REACTOS__
491 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
492#endif
493 if (hash->flags & HASH_FLAG_HMAC)
494 mbedtls_md_hmac_update(&hash->hash_ctx, input, size);
495 else
496 mbedtls_md_update(&hash->hash_ctx, input, size);
497
498 return STATUS_SUCCESS;
499}
500
501NTSTATUS hash_finish(struct hash *hash, UCHAR *output)
502{
503#ifndef __REACTOS__
504 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
505#endif
506 if (hash->flags & HASH_FLAG_HMAC)
507 mbedtls_md_hmac_finish(&hash->hash_ctx, output);
508 else
509 mbedtls_md_finish(&hash->hash_ctx, output);
510
511 mbedtls_md_free(&hash->hash_ctx);
512
513 return STATUS_SUCCESS;
514}
515
516NTSTATUS hash_get_size(struct hash *hash, ULONG *output)
517{
518#ifndef __REACTOS__
519 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
520#endif
521 if (!hash->hash_ctx.md_info) return STATUS_INTERNAL_ERROR;
522 if (!output) return STATUS_INTERNAL_ERROR;
523 *output = mbedtls_md_get_size(hash->hash_ctx.md_info);
524
525 return STATUS_SUCCESS;
526}
527
528mbedtls_cipher_type_t key_get_cipher(const struct key *key)
529{
530 switch (key->alg_id)
531 {
532 case ALG_ID_RC4:
533 WARN("handle block size\n");
534 return MBEDTLS_CIPHER_ARC4_128;
535
536 case ALG_ID_3DES:
537 WARN("handle block size\n");
538 switch (key->u.s.mode)
539 {
540 case CHAIN_MODE_ECB:
541 return MBEDTLS_CIPHER_DES_EDE3_ECB;
542 case CHAIN_MODE_CBC:
543 return MBEDTLS_CIPHER_DES_EDE3_CBC;
544 default:
545 break;
546 }
547 FIXME("3DES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len);
548 return MBEDTLS_CIPHER_NONE;
549
550 case ALG_ID_AES:
551 WARN("handle block size\n");
552 switch (key->u.s.mode)
553 {
554 case CHAIN_MODE_GCM:
555 if (key->u.s.secret_len == 16) return MBEDTLS_CIPHER_AES_128_GCM;
556 if (key->u.s.secret_len == 24) return MBEDTLS_CIPHER_AES_192_GCM;
557 if (key->u.s.secret_len == 32) return MBEDTLS_CIPHER_AES_256_GCM;
558 break;
559 case CHAIN_MODE_ECB: /* can be emulated with CBC + empty IV */
560 case CHAIN_MODE_CBC:
561 if (key->u.s.secret_len == 16) return MBEDTLS_CIPHER_AES_128_CBC;
562 if (key->u.s.secret_len == 24) return MBEDTLS_CIPHER_AES_192_CBC;
563 if (key->u.s.secret_len == 32) return MBEDTLS_CIPHER_AES_256_CBC;
564 break;
565 case CHAIN_MODE_CFB:
566 if (key->u.s.secret_len == 16) return MBEDTLS_CIPHER_AES_128_CFB8;
567 if (key->u.s.secret_len == 24) return MBEDTLS_CIPHER_AES_192_CFB8;
568 if (key->u.s.secret_len == 32) return MBEDTLS_CIPHER_AES_256_CFB8;
569 break;
570 default:
571 break;
572 }
573 FIXME("AES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len);
574 return MBEDTLS_CIPHER_NONE;
575
576 default:
577 FIXME("algorithm %u not supported\n", key->alg_id);
578 return MBEDTLS_CIPHER_NONE;
579 }
580 return MBEDTLS_CIPHER_NONE;
581}
582
583NTSTATUS key_symmetric_vector_reset(void *args)
584{
585 struct key *key = args;
586
587#ifndef __REACTOS__
588 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
589#endif
590 if (key_data(key)->s.cipher_ctx.cipher_info != NULL && key->u.s.vector != NULL && key->u.s.vector_len)
591 {
592 if (mbedtls_cipher_set_iv(&key_data(key)->s.cipher_ctx, key->u.s.vector, key->u.s.vector_len)) return STATUS_INTERNAL_ERROR;
593 return STATUS_SUCCESS;
594 }
595 TRACE("invalidating cipher handle\n");
596 mbedtls_cipher_free(&key_data(key)->s.cipher_ctx);
597 key_data(key)->s.cipher_ctx.cipher_info = NULL;
598 return STATUS_SUCCESS;
599}
600
601NTSTATUS init_cipher_handle(struct key *key, const mbedtls_operation_t operation)
602{
603 mbedtls_cipher_type_t cipher;
604 const mbedtls_cipher_info_t *info;
605
606#ifndef __REACTOS__
607 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
608#endif
609 if (key_data(key)->s.cipher_ctx.cipher_info != NULL)
610 {
611 if (mbedtls_cipher_get_operation(&key_data(key)->s.cipher_ctx) == operation) return STATUS_SUCCESS;
612 mbedtls_cipher_free(&key_data(key)->s.cipher_ctx);
613 key_data(key)->s.cipher_ctx.cipher_info = NULL;
614 }
615 cipher = key_get_cipher(key);
616 if (cipher == MBEDTLS_CIPHER_NONE) return STATUS_NOT_SUPPORTED;
617
618 if ((info = mbedtls_cipher_info_from_type(cipher)) == NULL) return STATUS_INTERNAL_ERROR;
619 mbedtls_cipher_init(&key_data(key)->s.cipher_ctx);
620 if (mbedtls_cipher_setup(&key_data(key)->s.cipher_ctx, info))
621 {
622 mbedtls_cipher_free(&key_data(key)->s.cipher_ctx);
623 return STATUS_INTERNAL_ERROR;
624 }
625 mbedtls_cipher_set_padding_mode(&key_data(key)->s.cipher_ctx, MBEDTLS_PADDING_NONE);
626 if (key->u.s.secret != NULL && key->u.s.secret_len > 0) mbedtls_cipher_setkey(&key_data(key)->s.cipher_ctx, key->u.s.secret, key->u.s.secret_len * 8, operation);
627 if (key->u.s.vector != NULL && key->u.s.vector_len > 0) mbedtls_cipher_set_iv(&key_data(key)->s.cipher_ctx, key->u.s.vector, key->u.s.vector_len);
628
629 return STATUS_SUCCESS;
630}
631
632NTSTATUS key_symmetric_set_auth_data(void *args)
633{
634 struct key_symmetric_set_auth_data_params *auth_params = args;
635 NTSTATUS status;
636 int ret;
637
638#ifndef __REACTOS__
639 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
640#endif
641 if ((status = init_cipher_handle(auth_params->key, auth_params->encrypt ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT))) return status;
642
643 ret = mbedtls_cipher_update_ad(&key_data(auth_params->key)->s.cipher_ctx, auth_params->auth_data, auth_params->len);
644 if (ret) return STATUS_INTERNAL_ERROR;
645 return STATUS_SUCCESS;
646}
647
648NTSTATUS key_symmetric_get_tag(void *args)
649{
650 struct key_symmetric_get_tag_params *tag_params = args;
651 mbedtls_operation_t operation;
652 int ret;
653 NTSTATUS status;
654
655#ifndef __REACTOS__
656 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
657#endif
658 operation = mbedtls_cipher_get_operation(&key_data(tag_params->key)->s.cipher_ctx);
659 if ((status = init_cipher_handle(tag_params->key, operation))) return status;
660
661 switch (operation) {
662 case MBEDTLS_ENCRYPT:
663 ret = mbedtls_cipher_write_tag(&key_data(tag_params->key)->s.cipher_ctx, tag_params->tag, tag_params->len);
664 if (ret) return STATUS_INTERNAL_ERROR;
665 break;
666 case MBEDTLS_DECRYPT:
667 ret = mbedtls_cipher_check_tag(&key_data(tag_params->key)->s.cipher_ctx, tag_params->tag, tag_params->len);
668 if (ret)
669 {
670 if (ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED)
671 return STATUS_AUTH_TAG_MISMATCH;
672 else
673 return STATUS_INTERNAL_ERROR;
674 }
675 break;
676 default:
677 FIXME("AES operation %u not supported\n", operation);
678 return STATUS_INTERNAL_ERROR;
679 break;
680 }
681
682 return status;
683}
684
685NTSTATUS key_symmetric_encrypt_internal(void *args)
686{
687 const struct key_symmetric_encrypt_params *params = args;
688 NTSTATUS status;
689 int ret;
690 size_t output_len = 0;
691
692#ifndef __REACTOS__
693 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
694#endif
695 if ((status = init_cipher_handle(params->key, MBEDTLS_ENCRYPT))) return status;
696
697 ret = mbedtls_cipher_update(&key_data(params->key)->s.cipher_ctx,
698 params->input, params->input_len,
699 params->output, &output_len);
700 if (!output_len)
701 ret = mbedtls_cipher_finish(&key_data(params->key)->s.cipher_ctx,
702 params->output, &output_len);
703 if (ret) return STATUS_INTERNAL_ERROR;
704
705 if (params->output_len != output_len) return STATUS_INTERNAL_ERROR;
706
707 return STATUS_SUCCESS;
708}
709
710NTSTATUS key_symmetric_decrypt_internal(void *args)
711{
712 const struct key_symmetric_decrypt_params *params = args;
713 NTSTATUS status;
714 int ret;
715 size_t output_len = 0;
716
717#ifndef __REACTOS__
718 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
719#endif
720 if ((status = init_cipher_handle(params->key, MBEDTLS_DECRYPT))) return status;
721
722 ret = mbedtls_cipher_update(&key_data(params->key)->s.cipher_ctx,
723 params->input, params->input_len,
724 params->output, &output_len);
725 if (!output_len)
726 ret = mbedtls_cipher_finish(&key_data(params->key)->s.cipher_ctx,
727 params->output, &output_len);
728 if (ret) return STATUS_INTERNAL_ERROR;
729
730 if (params->output_len != output_len) return STATUS_INTERNAL_ERROR;
731
732 return STATUS_SUCCESS;
733}
734
735NTSTATUS key_symmetric_destroy(void *args)
736{
737 struct key *key = args;
738
739#ifndef __REACTOS__
740 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
741#endif
742 if (key_data(key)->s.cipher_ctx.cipher_info != NULL)
743 {
744 mbedtls_cipher_free(&key_data(key)->s.cipher_ctx);
745 key_data(key)->s.cipher_ctx.cipher_info = NULL;
746 }
747 return STATUS_SUCCESS;
748}
749
750static mbedtls_pk_type_t key_get_type(enum alg_id alg_id)
751{
752 mbedtls_pk_type_t pk_type;
753
754 switch (alg_id)
755 {
756 case ALG_ID_RSA:
757 case ALG_ID_RSA_SIGN:
758 pk_type = MBEDTLS_PK_RSA;
759 break;
760 case ALG_ID_ECDH_P256:
761 case ALG_ID_ECDH_P384:
762 pk_type = MBEDTLS_PK_ECKEY_DH;
763 break;
764 case ALG_ID_ECDSA_P256:
765 case ALG_ID_ECDSA_P384:
766 pk_type = MBEDTLS_PK_ECDSA;
767 break;
768 default:
769 FIXME("algorithm %u not supported\n", alg_id);
770 pk_type = MBEDTLS_PK_NONE;
771 break;
772 }
773 return pk_type;
774}
775
776static NTSTATUS key_export_ecc_public(struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len)
777{
778 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
779 mbedtls_ecp_group_id curve;
780 mbedtls_ecp_keypair *keypair;
781 DWORD magic, size;
782 UCHAR *dst;
783
784 switch (key->alg_id)
785 {
786 case ALG_ID_ECDH_P256:
787 magic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
788 size = 32;
789 break;
790
791 case ALG_ID_ECDH_P384:
792 magic = BCRYPT_ECDH_PUBLIC_P384_MAGIC;
793 size = 48;
794 break;
795
796 case ALG_ID_ECDSA_P256:
797 magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
798 size = 32;
799 break;
800
801 case ALG_ID_ECDSA_P384:
802 magic = BCRYPT_ECDSA_PUBLIC_P384_MAGIC;
803 size = 48;
804 break;
805
806 default:
807 FIXME("algorithm %u not supported\n", key->alg_id);
808 return STATUS_NOT_IMPLEMENTED;
809 }
810
811 keypair = mbedtls_pk_ec(key_data(key)->a.pk.pubkey);
812 if (!keypair) return STATUS_INVALID_PARAMETER;
813
814 curve = keypair->grp.id;
815
816 if (curve != MBEDTLS_ECP_DP_SECP256R1 && curve != MBEDTLS_ECP_DP_SECP384R1)
817 {
818 FIXME("curve %u not supported\n", curve);
819 return STATUS_NOT_IMPLEMENTED;
820 }
821
822 *ret_len = sizeof(*ecc_blob) + size + size;
823 if (len >= *ret_len && buf)
824 {
825 ecc_blob->dwMagic = magic;
826 ecc_blob->cbKey = size;
827
828 dst = buf + sizeof(*ecc_blob);
829 mbedtls_mpi_write_binary(&keypair->Q.X, dst, size);
830 dst += size;
831 mbedtls_mpi_write_binary(&keypair->Q.Y, dst, size);
832 }
833
834 return STATUS_SUCCESS;
835}
836
837static NTSTATUS key_export_ecc(struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len)
838{
839 BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
840 mbedtls_ecp_group_id curve;
841 mbedtls_ecp_keypair *keypair;
842 DWORD magic, size;
843 UCHAR *dst;
844
845 switch (key->alg_id)
846 {
847 case ALG_ID_ECDH_P256:
848 magic = BCRYPT_ECDH_PRIVATE_P256_MAGIC;
849 size = 32;
850 break;
851
852 case ALG_ID_ECDH_P384:
853 magic = BCRYPT_ECDH_PRIVATE_P384_MAGIC;
854 size = 48;
855 break;
856
857 case ALG_ID_ECDSA_P256:
858 magic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
859 size = 32;
860 break;
861
862 case ALG_ID_ECDSA_P384:
863 magic = BCRYPT_ECDSA_PRIVATE_P384_MAGIC;
864 size = 48;
865 break;
866
867 default:
868 FIXME("algorithm %u does not yet support exporting ecc blob\n", key->alg_id);
869 return STATUS_NOT_IMPLEMENTED;
870 }
871
872 keypair = mbedtls_pk_ec(key_data(key)->a.pk.privkey);
873 if (!keypair) return STATUS_INVALID_PARAMETER;
874
875 curve = keypair->grp.id;
876
877 if (curve != MBEDTLS_ECP_DP_SECP256R1 && curve != MBEDTLS_ECP_DP_SECP384R1)
878 {
879 FIXME("curve %u not supported\n", curve);
880 return STATUS_NOT_IMPLEMENTED;
881 }
882
883
884 *ret_len = sizeof(*ecc_blob) + size + size + size;
885 if (len >= *ret_len && buf)
886 {
887 ecc_blob->dwMagic = magic;
888 ecc_blob->cbKey = size;
889
890 dst = buf + sizeof(*ecc_blob);
891 mbedtls_mpi_write_binary(&keypair->Q.X, dst, size);
892 dst += size;
893 mbedtls_mpi_write_binary(&keypair->Q.Y, dst, size);
894 dst += size;
895 mbedtls_mpi_write_binary(&keypair->d, dst, size);
896 }
897 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
898
899 return STATUS_SUCCESS;
900}
901
902static NTSTATUS key_export_rsa_public(struct key *key, UCHAR *buf, ULONG len, ULONG *ret_len)
903{
904 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
905 mbedtls_rsa_context *rsa_context;
906 mbedtls_mpi m, e;
907 UCHAR *dst;
908 int ret;
909 size_t m_size, e_size;
910
911 rsa_context = mbedtls_pk_rsa(key_data(key)->a.pk.pubkey);
912 if (!rsa_context) return STATUS_INVALID_PARAMETER;
913
914 mbedtls_mpi_init(&m);
915 mbedtls_mpi_init(&e);
916
917 ret = mbedtls_rsa_export(rsa_context, &m, NULL, NULL, NULL, &e);
918 if (ret)
919 {
920 mbedtls_mpi_free(&e);
921 mbedtls_mpi_free(&m);
922 return STATUS_INTERNAL_ERROR;
923 }
924
925 m_size = mbedtls_mpi_size(&m);
926 e_size = mbedtls_mpi_size(&e);
927
928 *ret_len = sizeof(*rsa_blob) + e_size + m_size;
929 if (len >= *ret_len && buf)
930 {
931 dst = buf + sizeof(*rsa_blob);
932 mbedtls_mpi_write_binary(&e, dst, e_size);
933 rsa_blob->cbPublicExp = e_size;
934
935 dst += rsa_blob->cbPublicExp;
936 mbedtls_mpi_write_binary(&m, dst, m_size);
937 rsa_blob->cbModulus = m_size;
938
939 rsa_blob->Magic = BCRYPT_RSAPUBLIC_MAGIC;
940 rsa_blob->BitLength = key->u.a.bitlen;
941 rsa_blob->cbPrime1 = 0;
942 rsa_blob->cbPrime2 = 0;
943 }
944
945 mbedtls_mpi_free(&e);
946 mbedtls_mpi_free(&m);
947 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
948
949 return STATUS_SUCCESS;
950}
951
952static NTSTATUS key_export_rsa(struct key *key, ULONG flags, UCHAR *buf, ULONG len, ULONG *ret_len)
953{
954 BCRYPT_RSAKEY_BLOB *rsa_blob;
955 mbedtls_rsa_context *rsa_context;
956 mbedtls_mpi m, e, d, p, q, u, e1, e2;
957 BOOL full = (flags & KEY_EXPORT_FLAG_RSA_FULL);
958 UCHAR *dst;
959 int ret;
960 size_t m_size, e_size, d_size, p_size, q_size, u_size, e1_size, e2_size;
961
962 rsa_context = mbedtls_pk_rsa(key_data(key)->a.pk.privkey);
963 if (!rsa_context) return STATUS_INVALID_PARAMETER;
964
965 mbedtls_mpi_init(&m);
966 mbedtls_mpi_init(&e);
967 mbedtls_mpi_init(&d);
968 mbedtls_mpi_init(&p);
969 mbedtls_mpi_init(&q);
970 if (full)
971 {
972 mbedtls_mpi_init(&u);
973 mbedtls_mpi_init(&e1);
974 mbedtls_mpi_init(&e2);
975 }
976 ret = mbedtls_rsa_export(rsa_context, &m, &p, &q, &d, &e);
977 if (ret)
978 {
979 mbedtls_mpi_free(&m);
980 mbedtls_mpi_free(&e);
981 mbedtls_mpi_free(&d);
982 mbedtls_mpi_free(&p);
983 mbedtls_mpi_free(&q);
984 if (full)
985 {
986 mbedtls_mpi_free(&u);
987 mbedtls_mpi_free(&e1);
988 mbedtls_mpi_free(&e2);
989 }
990 return STATUS_INTERNAL_ERROR;
991 }
992
993 if (full)
994 {
995 ret = mbedtls_rsa_export_crt(rsa_context, &e1, &e2, &u);
996 if (ret)
997 {
998 mbedtls_mpi_free(&m);
999 mbedtls_mpi_free(&e);
1000 mbedtls_mpi_free(&d);
1001 mbedtls_mpi_free(&p);
1002 mbedtls_mpi_free(&q);
1003 mbedtls_mpi_free(&u);
1004 mbedtls_mpi_free(&e1);
1005 mbedtls_mpi_free(&e2);
1006 return STATUS_INTERNAL_ERROR;
1007 }
1008 }
1009
1010 m_size = mbedtls_mpi_size(&m);
1011 e_size = mbedtls_mpi_size(&e);
1012 d_size = mbedtls_mpi_size(&d);
1013 p_size = mbedtls_mpi_size(&p);
1014 q_size = mbedtls_mpi_size(&q);
1015
1016 if (full)
1017 {
1018 u_size = mbedtls_mpi_size(&u);
1019 e1_size = mbedtls_mpi_size(&e1);
1020 e2_size = mbedtls_mpi_size(&e2);
1021 }
1022 *ret_len = sizeof(*rsa_blob) + e_size + m_size + p_size + q_size;
1023
1024 if (full) *ret_len += e1_size + e2_size + u_size + d_size;
1025
1026 if (len >= *ret_len && buf)
1027 {
1028 rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
1029 rsa_blob->Magic = full ? BCRYPT_RSAFULLPRIVATE_MAGIC : BCRYPT_RSAPRIVATE_MAGIC;
1030 rsa_blob->BitLength = key->u.a.bitlen;
1031
1032 dst = buf + sizeof(*rsa_blob);
1033 mbedtls_mpi_write_binary(&e, dst, e_size);
1034 rsa_blob->cbPublicExp = e_size;
1035
1036 dst += rsa_blob->cbPublicExp;
1037 mbedtls_mpi_write_binary(&m, dst, m_size);
1038 rsa_blob->cbModulus = m_size;
1039
1040 dst += rsa_blob->cbModulus;
1041 mbedtls_mpi_write_binary(&p, dst, p_size);
1042 rsa_blob->cbPrime1 = p_size;
1043
1044 dst += rsa_blob->cbPrime1;
1045 mbedtls_mpi_write_binary(&q, dst, q_size);
1046 rsa_blob->cbPrime2 = q_size;
1047
1048 if (full)
1049 {
1050 dst += rsa_blob->cbPrime2;
1051 mbedtls_mpi_write_binary(&e1, dst, e1_size);
1052
1053 dst += e1_size;
1054 mbedtls_mpi_write_binary(&e2, dst, e2_size);
1055
1056 dst += e2_size;
1057 mbedtls_mpi_write_binary(&u, dst, u_size);
1058
1059 dst += u_size;
1060 mbedtls_mpi_write_binary(&d, dst, d_size);
1061 }
1062 }
1063
1064 mbedtls_mpi_free(&m);
1065 mbedtls_mpi_free(&e);
1066 mbedtls_mpi_free(&d);
1067 mbedtls_mpi_free(&p);
1068 mbedtls_mpi_free(&q);
1069 if (full)
1070 {
1071 mbedtls_mpi_free(&u);
1072 mbedtls_mpi_free(&e1);
1073 mbedtls_mpi_free(&e2);
1074 }
1075 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1076
1077 return STATUS_SUCCESS;
1078}
1079
1080static NTSTATUS key_export_params(struct key *key, mbedtls_dhm_context *dh_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1081{
1082 BCRYPT_DH_PARAMETER_HEADER *dh_params = (BCRYPT_DH_PARAMETER_HEADER *)buf;
1083 size_t size = key->u.a.bitlen / 8;
1084 UCHAR *dst;
1085
1086 if (!dh_key) return STATUS_INVALID_PARAMETER;
1087
1088 *ret_len = sizeof(*dh_params) + size + size;
1089
1090 if (len >= *ret_len && buf)
1091 {
1092 dh_params->dwMagic = BCRYPT_DH_PARAMETERS_MAGIC;
1093 dh_params->cbLength = *ret_len;
1094 dh_params->cbKeyLength = key->u.a.bitlen / 8;
1095
1096 dst = buf + sizeof(*dh_params);
1097 mbedtls_mpi_write_binary(&dh_key->P, dst, size);
1098 dst += size;
1099 mbedtls_mpi_write_binary(&dh_key->G, dst, size);
1100 }
1101 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1102
1103 return STATUS_SUCCESS;
1104}
1105
1106static NTSTATUS key_export_dh_public(struct key *key, mbedtls_dhm_context *dh_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1107{
1108 BCRYPT_DH_KEY_BLOB *dh_blob = (BCRYPT_DH_KEY_BLOB *)buf;
1109 size_t size = key->u.a.bitlen / 8;
1110 UCHAR *dst;
1111
1112 if (!dh_key) return STATUS_INVALID_PARAMETER;
1113
1114 *ret_len = sizeof(*dh_blob) + size + size + size;
1115
1116 if (len >= *ret_len && buf)
1117 {
1118 dh_blob->dwMagic = BCRYPT_DH_PUBLIC_MAGIC;
1119 dh_blob->cbKey = key->u.a.bitlen / 8;
1120
1121 dst = buf + sizeof(*dh_blob);
1122 mbedtls_mpi_write_binary(&dh_key->P, dst, size);
1123 dst += size;
1124 mbedtls_mpi_write_binary(&dh_key->G, dst, size);
1125 dst += size;
1126 mbedtls_mpi_write_binary(&dh_key->GX, dst, size);
1127 }
1128 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1129
1130 return STATUS_SUCCESS;
1131}
1132
1133static NTSTATUS key_export_dh(struct key *key, mbedtls_dhm_context *dh_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1134{
1135 BCRYPT_DH_KEY_BLOB *dh_blob = (BCRYPT_DH_KEY_BLOB *)buf;
1136 size_t size = key->u.a.bitlen / 8;
1137 UCHAR *dst;
1138
1139 if (!dh_key) return STATUS_INVALID_PARAMETER;
1140 *ret_len = sizeof(*dh_blob) + size + size + size + size;
1141
1142 if (len >= *ret_len && buf)
1143 {
1144 dh_blob->dwMagic = BCRYPT_DH_PRIVATE_MAGIC;
1145 dh_blob->cbKey = key->u.a.bitlen / 8;
1146
1147 dst = buf + sizeof(*dh_blob);
1148 mbedtls_mpi_write_binary(&dh_key->P, dst, size);
1149 dst += size;
1150 mbedtls_mpi_write_binary(&dh_key->G, dst, size);
1151 dst += size;
1152 mbedtls_mpi_write_binary(&dh_key->GX, dst, size);
1153 dst += size;
1154 mbedtls_mpi_write_binary(&dh_key->X, dst, size);
1155 }
1156 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1157
1158 return STATUS_SUCCESS;
1159}
1160
1161#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
1162static NTSTATUS key_export_dsa_public(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1163{
1164 BCRYPT_DSA_KEY_BLOB *dsa_blob = (BCRYPT_DSA_KEY_BLOB *)buf;
1165 size_t q_size;
1166 ULONG size = key->u.a.bitlen / 8;
1167 UCHAR *dst;
1168
1169 if (key->u.a.bitlen > 1024)
1170 {
1171 FIXME("bitlen > 1024 not supported\n");
1172 return STATUS_NOT_IMPLEMENTED;
1173 }
1174
1175 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1176
1177 q_size = mbedtls_mpi_size(&dsa_key->Q);
1178
1179 if (q_size > sizeof(dsa_blob->q)) return STATUS_INVALID_PARAMETER;
1180
1181 *ret_len = sizeof(*dsa_blob) + size + size + size;
1182 if (len >= *ret_len && buf)
1183 {
1184 dst = buf + sizeof(*dsa_blob);;
1185 mbedtls_mpi_write_binary(&dsa_key->P, dst, size);
1186 dst += size;
1187 mbedtls_mpi_write_binary(&dsa_key->G, dst, size);
1188 dst += size;
1189 mbedtls_mpi_write_binary(&dsa_key->Y, dst, size);
1190
1191 dst = dsa_blob->q;
1192 mbedtls_mpi_write_binary(&dsa_key->Q, dst, sizeof(dsa_blob->q));
1193
1194 dsa_blob->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
1195 dsa_blob->cbKey = size;
1196 memset(dsa_blob->Count, 0, sizeof(dsa_blob->Count)); /* FIXME */
1197 memset(dsa_blob->Seed, 0, sizeof(dsa_blob->Seed)); /* FIXME */
1198 }
1199 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1200
1201 return STATUS_SUCCESS;
1202}
1203
1204static void reverse_bytes(UCHAR *buf, ULONG len)
1205{
1206 unsigned int i;
1207 UCHAR tmp;
1208
1209 for (i = 0; i < len / 2; ++i)
1210 {
1211 tmp = buf[i];
1212 buf[i] = buf[len - i - 1];
1213 buf[len - i - 1] = tmp;
1214 }
1215}
1216
1217#define Q_SIZE 20
1218static NTSTATUS key_export_dsa_capi_public(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1219{
1220 BLOBHEADER *hdr = (BLOBHEADER *)buf;
1221 DSSPUBKEY *dsskey;
1222 size_t q_size;
1223 ULONG size = key->u.a.bitlen / 8;
1224 UCHAR *dst;
1225
1226 if (key->u.a.bitlen > 1024)
1227 {
1228 FIXME("bitlen > 1024 not supported\n");
1229 return STATUS_NOT_IMPLEMENTED;
1230 }
1231
1232 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1233
1234 q_size = mbedtls_mpi_size(&dsa_key->Q);
1235 if (q_size > Q_SIZE) return STATUS_INVALID_PARAMETER;
1236
1237 *ret_len = sizeof(*hdr) + sizeof(*dsskey) + sizeof(key->u.a.dss_seed) +
1238 size + Q_SIZE + size + size;
1239 if (len >= *ret_len && buf)
1240 {
1241 hdr->bType = PUBLICKEYBLOB;
1242 hdr->bVersion = 2;
1243 hdr->reserved = 0;
1244 hdr->aiKeyAlg = CALG_DSS_SIGN;
1245
1246 dsskey = (DSSPUBKEY *)(hdr + 1);
1247 dsskey->magic = MAGIC_DSS1;
1248 dsskey->bitlen = key->u.a.bitlen;
1249
1250 dst = (UCHAR *)(dsskey + 1);
1251 mbedtls_mpi_write_binary(&dsa_key->P, dst, size);
1252 reverse_bytes(dst, size);
1253 dst += size;
1254
1255 mbedtls_mpi_write_binary(&dsa_key->Q, dst, Q_SIZE);
1256 reverse_bytes(dst, Q_SIZE);
1257 dst += Q_SIZE;
1258
1259 mbedtls_mpi_write_binary(&dsa_key->G, dst, size);
1260 reverse_bytes(dst, size);
1261 dst += size;
1262
1263 mbedtls_mpi_write_binary(&dsa_key->Y, dst, size);
1264 reverse_bytes(dst, size);
1265 dst += size;
1266
1267 memcpy(dst, &key->u.a.dss_seed, sizeof(key->u.a.dss_seed));
1268 }
1269 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1270
1271 return STATUS_SUCCESS;
1272}
1273
1274static NTSTATUS key_export_dsa(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1275{
1276 BCRYPT_DSA_KEY_BLOB *dsa_blob = (BCRYPT_DSA_KEY_BLOB *)buf;
1277 size_t q_size;
1278 ULONG size = key->u.a.bitlen / 8;
1279 UCHAR *dst;
1280
1281 if (key->u.a.bitlen > 1024)
1282 {
1283 FIXME("bitlen > 1024 not supported\n");
1284 return STATUS_NOT_IMPLEMENTED;
1285 }
1286
1287 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1288
1289 q_size = mbedtls_mpi_size(&dsa_key->Q);
1290 if (q_size > sizeof(dsa_blob->q)) return STATUS_INVALID_PARAMETER;
1291
1292 *ret_len = sizeof(*dsa_blob) + size + size + size + size;
1293 if (len >= *ret_len && buf)
1294 {
1295 dst = buf + sizeof(*dsa_blob);;
1296 mbedtls_mpi_write_binary(&dsa_key->P, dst, size);
1297 dst += size;
1298 mbedtls_mpi_write_binary(&dsa_key->G, dst, size);
1299 dst += size;
1300 mbedtls_mpi_write_binary(&dsa_key->Y, dst, size);
1301 dst += size;
1302 mbedtls_mpi_write_binary(&dsa_key->X, dst, size);
1303
1304 dst = dsa_blob->q;
1305 mbedtls_mpi_write_binary(&dsa_key->Q, dst, sizeof(dsa_blob->q));
1306
1307 dsa_blob->dwMagic = BCRYPT_DSA_PUBLIC_MAGIC;
1308 dsa_blob->cbKey = size;
1309 memset(dsa_blob->Count, 0, sizeof(dsa_blob->Count)); /* FIXME */
1310 memset(dsa_blob->Seed, 0, sizeof(dsa_blob->Seed)); /* FIXME */
1311 }
1312 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1313
1314 return STATUS_SUCCESS;
1315}
1316
1317static NTSTATUS key_export_dsa_capi(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len, ULONG *ret_len)
1318{
1319 BLOBHEADER *hdr;
1320 DSSPUBKEY *pubkey;
1321 size_t q_size, x_size;
1322 ULONG size = key->u.a.bitlen / 8;
1323 UCHAR *dst;
1324
1325 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1326
1327 q_size = mbedtls_mpi_size(&dsa_key->Q);
1328 x_size = mbedtls_mpi_size(&dsa_key->X);
1329
1330 if (q_size > 21 || x_size > 21)
1331 {
1332 ERR("can't export key in this format\n");
1333 return STATUS_NOT_SUPPORTED;
1334 }
1335
1336 *ret_len = sizeof(*hdr) + sizeof(*pubkey) + sizeof(key->u.a.dss_seed) +
1337 size + Q_SIZE + size + Q_SIZE;
1338 if (len >= *ret_len && buf)
1339 {
1340 hdr = (BLOBHEADER *)buf;
1341 hdr->bType = PRIVATEKEYBLOB;
1342 hdr->bVersion = 2;
1343 hdr->reserved = 0;
1344 hdr->aiKeyAlg = CALG_DSS_SIGN;
1345
1346 pubkey = (DSSPUBKEY *)(hdr + 1);
1347 pubkey->magic = MAGIC_DSS2;
1348 pubkey->bitlen = key->u.a.bitlen;
1349
1350 dst = (UCHAR *)(pubkey + 1);
1351 mbedtls_mpi_write_binary(&dsa_key->P, dst, size);
1352 reverse_bytes(dst, size);
1353 dst += size;
1354
1355 mbedtls_mpi_write_binary(&dsa_key->Q, dst, Q_SIZE);
1356 reverse_bytes(dst, Q_SIZE);
1357 dst += Q_SIZE;
1358
1359 mbedtls_mpi_write_binary(&dsa_key->G, dst, size);
1360 reverse_bytes(dst, size);
1361 dst += size;
1362
1363 mbedtls_mpi_write_binary(&dsa_key->X, dst, Q_SIZE);
1364 reverse_bytes(dst, Q_SIZE);
1365 dst += Q_SIZE;
1366
1367 memcpy(dst, &key->u.a.dss_seed, sizeof(key->u.a.dss_seed));
1368 }
1369 if (len < *ret_len && buf) return STATUS_BUFFER_TOO_SMALL;
1370
1371 return STATUS_SUCCESS;
1372}
1373#endif
1374
1375NTSTATUS key_asymmetric_export(void *args)
1376{
1377 const struct key_asymmetric_export_params *params = args;
1378 struct key *key = params->key;
1379 unsigned flags = params->flags;
1380
1381 if (!(key->u.a.flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
1382
1383 switch (key->alg_id)
1384 {
1385 case ALG_ID_ECDH_P256:
1386 case ALG_ID_ECDH_P384:
1387 case ALG_ID_ECDSA_P256:
1388 case ALG_ID_ECDSA_P384:
1389 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1390 return key_export_ecc_public(key, params->buf, params->len, params->ret_len);
1391 return key_export_ecc(key, params->buf, params->len, params->ret_len);
1392
1393 case ALG_ID_RSA:
1394 case ALG_ID_RSA_SIGN:
1395 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1396 return key_export_rsa_public(key, params->buf, params->len, params->ret_len);
1397 return key_export_rsa(key, flags, params->buf, params->len, params->ret_len);
1398
1399#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
1400 case ALG_ID_DSA:
1401 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1402 {
1403 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1404 return key_export_dsa_capi_public(key, &key_data(key)->a.dsa.pubkey, params->buf, params->len, params->ret_len);
1405 return key_export_dsa_public(key, &key_data(key)->a.dsa.pubkey, params->buf, params->len, params->ret_len);
1406 }
1407 /* if private key is not set return invalid parameter */
1408 if (mbedtls_mpi_cmp_int(&key_data(key)->a.dsa.privkey.X, 0) == 0) return STATUS_INVALID_PARAMETER;
1409 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1410 return key_export_dsa_capi(key, &key_data(key)->a.dsa.privkey, params->buf, params->len, params->ret_len);
1411 return key_export_dsa(key, &key_data(key)->a.dsa.privkey, params->buf, params->len, params->ret_len);
1412#endif
1413
1414 case ALG_ID_DH:
1415 if (flags & KEY_EXPORT_FLAG_DH_PARAMETERS)
1416 return key_export_params(key, &key_data(key)->a.dh.pubkey, params->buf, params->len, params->ret_len);
1417 if (flags & KEY_EXPORT_FLAG_PUBLIC)
1418 return key_export_dh_public(key, &key_data(key)->a.dh.pubkey, params->buf, params->len, params->ret_len);
1419 return key_export_dh(key, &key_data(key)->a.dh.privkey, params->buf, params->len, params->ret_len);
1420 default:
1421 FIXME("algorithm %u not yet supported\n", key->alg_id);
1422 return STATUS_NOT_IMPLEMENTED;
1423 }
1424}
1425
1426static NTSTATUS key_import_ecc_public(struct key *key, UCHAR *buf, ULONG len)
1427{
1428 BCRYPT_ECCKEY_BLOB *ecc_blob;
1429 mbedtls_ecp_group_id curve;
1430 const mbedtls_ecp_keypair *keypair;
1431 int ret;
1432 size_t plen;
1433
1434 switch (key->alg_id)
1435 {
1436 case ALG_ID_ECDH_P256:
1437 case ALG_ID_ECDSA_P256:
1438 curve = MBEDTLS_ECP_DP_SECP256R1;
1439 break;
1440
1441 case ALG_ID_ECDH_P384:
1442 case ALG_ID_ECDSA_P384:
1443 curve = MBEDTLS_ECP_DP_SECP384R1;
1444 break;
1445
1446 default:
1447 FIXME("algorithm %u not yet supported\n", key->alg_id);
1448 return STATUS_NOT_IMPLEMENTED;
1449 }
1450
1451 keypair = mbedtls_pk_ec(key_data(key)->a.pk.pubkey);
1452 if (!keypair) return STATUS_INVALID_PARAMETER;
1453
1454 ret = mbedtls_ecp_group_load((struct mbedtls_ecp_group *)&keypair->grp, curve);
1455 if (ret) return STATUS_INTERNAL_ERROR;
1456
1457 ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
1458 plen = mbedtls_mpi_size(&keypair->grp.P);
1459 if (plen != ecc_blob->cbKey) return STATUS_INTERNAL_ERROR;
1460
1461 mbedtls_mpi_read_binary((struct mbedtls_mpi *)&keypair->Q.X, buf + sizeof(*ecc_blob), ecc_blob->cbKey);
1462 mbedtls_mpi_read_binary((struct mbedtls_mpi *)&keypair->Q.Y, buf + sizeof(*ecc_blob) + ecc_blob->cbKey, ecc_blob->cbKey);
1463 mbedtls_mpi_lset((struct mbedtls_mpi *)&keypair->Q.Z, 1);
1464 ret = mbedtls_ecp_check_pubkey(&keypair->grp, &keypair->Q);
1465
1466 if (ret) return STATUS_INTERNAL_ERROR;
1467
1468 return STATUS_SUCCESS;
1469}
1470
1471static NTSTATUS key_import_ecc(struct key *key, UCHAR *buf, ULONG len)
1472{
1473 BCRYPT_ECCKEY_BLOB *ecc_blob;
1474 mbedtls_ecp_group_id curve;
1475 const mbedtls_ecp_keypair *keypair;
1476 int ret;
1477 size_t plen;
1478
1479 switch (key->alg_id)
1480 {
1481 case ALG_ID_ECDH_P256:
1482 case ALG_ID_ECDSA_P256:
1483 curve = MBEDTLS_ECP_DP_SECP256R1;
1484 break;
1485
1486 case ALG_ID_ECDH_P384:
1487 case ALG_ID_ECDSA_P384:
1488 curve = MBEDTLS_ECP_DP_SECP384R1;
1489 break;
1490
1491 default:
1492 FIXME("algorithm %u not yet supported\n", key->alg_id);
1493 return STATUS_NOT_IMPLEMENTED;
1494 }
1495
1496 keypair = mbedtls_pk_ec(key_data(key)->a.pk.privkey);
1497 if (!keypair) return STATUS_INVALID_PARAMETER;
1498
1499 ret = mbedtls_ecp_group_load((struct mbedtls_ecp_group *)&keypair->grp, curve);
1500
1501 if (ret) return STATUS_INTERNAL_ERROR;
1502
1503 ecc_blob = (BCRYPT_ECCKEY_BLOB *)buf;
1504 plen = mbedtls_mpi_size(&keypair->grp.P);
1505 if (plen != ecc_blob->cbKey) return STATUS_INTERNAL_ERROR;
1506
1507 mbedtls_mpi_read_binary((struct mbedtls_mpi *)&keypair->Q.X, buf + sizeof(*ecc_blob), ecc_blob->cbKey);
1508 mbedtls_mpi_read_binary((struct mbedtls_mpi *)&keypair->Q.Y, buf + sizeof(*ecc_blob) + ecc_blob->cbKey, ecc_blob->cbKey);
1509 mbedtls_mpi_lset((struct mbedtls_mpi *)&keypair->Q.Z, 1);
1510 mbedtls_mpi_read_binary((struct mbedtls_mpi *)&keypair->d, buf + sizeof(*ecc_blob) + 2 * ecc_blob->cbKey, ecc_blob->cbKey);
1511 ret = mbedtls_ecp_check_pubkey(&keypair->grp, &keypair->Q);
1512
1513 if (ret) return STATUS_INTERNAL_ERROR;
1514
1515 return STATUS_SUCCESS;
1516}
1517
1518static NTSTATUS key_import_rsa_public(struct key *key, UCHAR *buf, ULONG len)
1519{
1520 BCRYPT_RSAKEY_BLOB *rsa_blob;
1521 mbedtls_rsa_context *rsa_context;
1522 int ret;
1523
1524 rsa_context = mbedtls_pk_rsa(key_data(key)->a.pk.pubkey);
1525 if (!rsa_context) return STATUS_INVALID_PARAMETER;
1526
1527 rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
1528 ret = mbedtls_rsa_import_raw(rsa_context, buf + sizeof(*rsa_blob) + rsa_blob->cbPublicExp, rsa_blob->cbModulus, NULL, 0, NULL, 0, NULL, 0,
1529 buf + sizeof(*rsa_blob), rsa_blob->cbPublicExp);
1530 if (ret) return STATUS_INTERNAL_ERROR;
1531 ret = mbedtls_rsa_complete(rsa_context);
1532 if (ret) return STATUS_INTERNAL_ERROR;
1533 ret = mbedtls_rsa_check_pubkey(rsa_context);
1534 if (ret) return STATUS_INTERNAL_ERROR;
1535
1536 return STATUS_SUCCESS;
1537}
1538
1539static NTSTATUS key_import_rsa(struct key *key, UCHAR *buf, ULONG len)
1540{
1541 BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)buf;
1542 mbedtls_rsa_context *rsa_context;
1543 int ret;
1544
1545 rsa_context = mbedtls_pk_rsa(key_data(key)->a.pk.privkey);
1546 if (!rsa_context) return STATUS_INVALID_PARAMETER;
1547
1548 ret = mbedtls_rsa_import_raw(rsa_context, buf + sizeof(*rsa_blob) + rsa_blob->cbPublicExp, rsa_blob->cbModulus,
1549 buf + sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus, rsa_blob->cbPrime1,
1550 buf + sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus + rsa_blob->cbPrime1, rsa_blob->cbPrime2,
1551 NULL, 0, buf + sizeof(*rsa_blob), rsa_blob->cbPublicExp);
1552 if (ret) return STATUS_INTERNAL_ERROR;
1553 ret = mbedtls_rsa_complete(rsa_context);
1554 if (ret) return STATUS_INTERNAL_ERROR;
1555 ret = mbedtls_rsa_check_privkey(rsa_context);
1556 if (ret) return STATUS_INTERNAL_ERROR;
1557 ret = mbedtls_rsa_check_pubkey(rsa_context);
1558 if (ret) return STATUS_INTERNAL_ERROR;
1559 ret = mbedtls_rsa_check_pub_priv(rsa_context, rsa_context);
1560 if (ret) return STATUS_INTERNAL_ERROR;
1561 return STATUS_SUCCESS;
1562}
1563
1564static NTSTATUS key_import_dh_params(struct key *key, mbedtls_dhm_context *dh_key, UCHAR *buf, ULONG len)
1565{
1566 BCRYPT_DH_PARAMETER_HEADER *dh_params = (BCRYPT_DH_PARAMETER_HEADER *)buf;
1567 UCHAR *p;
1568 size_t key_len = dh_params->cbKeyLength;
1569
1570 if (!dh_key) return STATUS_INVALID_PARAMETER;
1571
1572 if (dh_params->dwMagic != BCRYPT_DH_PARAMETERS_MAGIC && dh_params->dwMagic != BCRYPT_DH_PUBLIC_MAGIC && dh_params->dwMagic != BCRYPT_DH_PRIVATE_MAGIC)
1573 return STATUS_INVALID_PARAMETER;
1574 if (len < 2 * key_len) return STATUS_INVALID_PARAMETER;
1575
1576 p = (UCHAR *)buf + sizeof(*dh_params);
1577
1578 mbedtls_mpi_read_binary(&dh_key->P, p, key_len);
1579 p += key_len;
1580 mbedtls_mpi_read_binary(&dh_key->G, p, key_len);
1581
1582 key->u.a.bitlen = dh_params->cbKeyLength * 8;
1583 dh_key->len = key_len;
1584
1585 return STATUS_SUCCESS;
1586}
1587
1588static NTSTATUS key_import_dh_public(struct key *key, mbedtls_dhm_context *dh_key, UCHAR *buf, ULONG len)
1589{
1590 BCRYPT_DH_KEY_BLOB *dh_blob = (BCRYPT_DH_KEY_BLOB *)buf;
1591 UCHAR *p;
1592 size_t key_len = dh_blob->cbKey;
1593
1594 if (!dh_key) return STATUS_INVALID_PARAMETER;
1595
1596 if (dh_blob->dwMagic != BCRYPT_DH_PUBLIC_MAGIC && dh_blob->dwMagic != BCRYPT_DH_PRIVATE_MAGIC)
1597 return STATUS_INVALID_PARAMETER;
1598 if (len < 3 * key_len) return STATUS_INVALID_PARAMETER;
1599
1600 p = (UCHAR *)buf + sizeof(*dh_blob);
1601 mbedtls_mpi_read_binary(&dh_key->P, p, key_len);
1602 p += key_len;
1603 mbedtls_mpi_read_binary(&dh_key->G, p, key_len);
1604 p += key_len;
1605 mbedtls_mpi_read_binary(&dh_key->GX, p, key_len);
1606
1607 key->u.a.bitlen = dh_blob->cbKey * 8;
1608 dh_key->len = key_len;
1609
1610 return STATUS_SUCCESS;
1611}
1612
1613static NTSTATUS key_import_dh(struct key *key, mbedtls_dhm_context *dh_key, UCHAR *buf, ULONG len)
1614{
1615 BCRYPT_DH_KEY_BLOB *dh_blob = (BCRYPT_DH_KEY_BLOB *)buf;
1616 UCHAR *p;
1617 size_t key_len = dh_blob->cbKey;
1618
1619 if (!dh_key) return STATUS_INVALID_PARAMETER;
1620
1621 if (dh_blob->dwMagic != BCRYPT_DH_PRIVATE_MAGIC) return STATUS_INVALID_PARAMETER;
1622 if (len < 4 * key_len) return STATUS_INVALID_PARAMETER;
1623
1624 p = (UCHAR *)buf + sizeof(*dh_blob);
1625 mbedtls_mpi_read_binary(&dh_key->P, p, key_len);
1626 p += key_len;
1627 mbedtls_mpi_read_binary(&dh_key->G, p, key_len);
1628 p += key_len;
1629 mbedtls_mpi_read_binary(&dh_key->GX, p, key_len);
1630 p += key_len;
1631 mbedtls_mpi_read_binary(&dh_key->X, p, key_len);
1632
1633 key->u.a.bitlen = dh_blob->cbKey * 8;
1634 dh_key->len = key_len;
1635
1636 return STATUS_SUCCESS;
1637}
1638
1639#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
1640static NTSTATUS key_import_dsa_public(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len)
1641{
1642 BCRYPT_DSA_KEY_BLOB *dsa_blob;
1643 mbedtls_mpi P, Q, G, Y;
1644 UCHAR *p_data, *q_data, *g_data, *y_data;
1645 int ret;
1646 size_t p_size, q_size, g_size, y_size;
1647
1648 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1649
1650 dsa_blob = (BCRYPT_DSA_KEY_BLOB *)buf;
1651 p_data = buf + sizeof(*dsa_blob);
1652 p_size = dsa_blob->cbKey;
1653 q_data = dsa_blob->q;
1654 q_size = sizeof(dsa_blob->q);
1655 g_data = buf + sizeof(*dsa_blob) + dsa_blob->cbKey;
1656 g_size = dsa_blob->cbKey;
1657 y_data = buf + sizeof(*dsa_blob) + dsa_blob->cbKey * 2;
1658 y_size = dsa_blob->cbKey;
1659
1660 mbedtls_mpi_init(&P);
1661 mbedtls_mpi_init(&Q);
1662 mbedtls_mpi_init(&G);
1663 mbedtls_mpi_init(&Y);
1664
1665 mbedtls_mpi_read_binary(&P, p_data, p_size);
1666 mbedtls_mpi_read_binary(&Q, q_data, q_size);
1667 mbedtls_mpi_read_binary(&G, g_data, g_size);
1668 mbedtls_mpi_read_binary(&Y, y_data, y_size);
1669
1670 ret = mbedtls_dsa_check_pqg(&P, &Q, &G);
1671 ret = mbedtls_dsa_set_group(dsa_key, &P, &Q, &G);
1672 if (ret)
1673 {
1674 mbedtls_mpi_free(&P);
1675 mbedtls_mpi_free(&Q);
1676 mbedtls_mpi_free(&G);
1677 mbedtls_mpi_free(&Y);
1678 return STATUS_INTERNAL_ERROR;
1679 }
1680
1681 mbedtls_mpi_copy(&dsa_key->Y, &Y);
1682
1683 ret = mbedtls_dsa_check_pubkey(dsa_key);
1684
1685 mbedtls_mpi_free(&P);
1686 mbedtls_mpi_free(&Q);
1687 mbedtls_mpi_free(&G);
1688 mbedtls_mpi_free(&Y);
1689
1690 return STATUS_SUCCESS;
1691}
1692
1693static NTSTATUS key_import_dsa(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len)
1694{
1695 BCRYPT_DSA_KEY_BLOB *dsa_blob;
1696 mbedtls_mpi P, Q, G, Y, X;
1697 UCHAR *p_data, *q_data, *g_data, *y_data, *x_data;
1698 int ret, p_size, q_size, g_size, y_size, x_size;
1699
1700 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1701
1702 dsa_blob = (BCRYPT_DSA_KEY_BLOB *)buf;
1703 p_data = buf + sizeof(*dsa_blob);
1704 p_size = dsa_blob->cbKey;
1705 q_data = dsa_blob->q;
1706 q_size = sizeof(dsa_blob->q);
1707 g_data = buf + sizeof(*dsa_blob) + dsa_blob->cbKey;
1708 g_size = dsa_blob->cbKey;
1709 y_data = buf + sizeof(*dsa_blob) + dsa_blob->cbKey * 2;
1710 y_size = dsa_blob->cbKey;
1711 x_data = buf + sizeof(*dsa_blob) + dsa_blob->cbKey * 3;
1712 x_size = dsa_blob->cbKey;
1713
1714 mbedtls_mpi_init(&P);
1715 mbedtls_mpi_init(&Q);
1716 mbedtls_mpi_init(&G);
1717 mbedtls_mpi_init(&Y);
1718 mbedtls_mpi_init(&X);
1719
1720 mbedtls_mpi_read_binary(&P, p_data, p_size);
1721 mbedtls_mpi_read_binary(&Q, q_data, q_size);
1722 mbedtls_mpi_read_binary(&G, g_data, g_size);
1723 mbedtls_mpi_read_binary(&Y, y_data, y_size);
1724 mbedtls_mpi_read_binary(&X, x_data, x_size);
1725
1726 ret = mbedtls_dsa_check_pqg(&P, &Q, &G);
1727 ret = mbedtls_dsa_set_group(dsa_key, &P, &Q, &G);
1728 if (ret)
1729 {
1730 mbedtls_mpi_free(&P);
1731 mbedtls_mpi_free(&Q);
1732 mbedtls_mpi_free(&G);
1733 mbedtls_mpi_free(&Y);
1734 return STATUS_INTERNAL_ERROR;
1735 }
1736
1737 mbedtls_mpi_copy(&dsa_key->Y, &Y);
1738 mbedtls_mpi_copy(&dsa_key->X, &X);
1739
1740 ret = mbedtls_dsa_check_privkey(dsa_key);
1741
1742 mbedtls_mpi_free(&P);
1743 mbedtls_mpi_free(&Q);
1744 mbedtls_mpi_free(&G);
1745 mbedtls_mpi_free(&Y);
1746 mbedtls_mpi_free(&X);
1747
1748 return STATUS_SUCCESS;
1749}
1750
1751static NTSTATUS key_import_dsa_capi_public(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len)
1752{
1753 BLOBHEADER *hdr = (BLOBHEADER *)buf;
1754 DSSPUBKEY *pubkey;
1755 mbedtls_mpi P, Q, G, Y;
1756 unsigned char *data, p_data[128], q_data[20], g_data[128], y_data[128];
1757 int i, ret, size, p_size, q_size, g_size, y_size;
1758
1759 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1760
1761 pubkey = (DSSPUBKEY *)(buf+sizeof(*hdr));
1762 size = pubkey->bitlen / 8;
1763 if (size > sizeof(p_data))
1764 {
1765 FIXME("size %u not supported\n", size);
1766 return STATUS_NOT_SUPPORTED;
1767 }
1768 data = buf + sizeof(*hdr) + sizeof(*pubkey);
1769
1770 p_size = size;
1771 for (i = 0; i < p_size; i++) p_data[i] = data[p_size - i - 1];
1772 data += p_size;
1773
1774 q_size = sizeof(q_data);
1775 for (i = 0; i < q_size; i++) q_data[i] = data[q_size - i - 1];
1776 data += q_size;
1777
1778 g_size = size;
1779 for (i = 0; i < g_size; i++) g_data[i] = data[g_size - i - 1];
1780 data += g_size;
1781
1782 y_size = sizeof(y_data);
1783 for (i = 0; i < y_size; i++) y_data[i] = data[y_size - i - 1];
1784 data += y_size;
1785
1786 mbedtls_mpi_init(&P);
1787 mbedtls_mpi_init(&Q);
1788 mbedtls_mpi_init(&G);
1789 mbedtls_mpi_init(&Y);
1790
1791 mbedtls_mpi_read_binary(&P, p_data, p_size);
1792 mbedtls_mpi_read_binary(&Q, q_data, q_size);
1793 mbedtls_mpi_read_binary(&G, g_data, g_size);
1794 mbedtls_mpi_read_binary(&Y, y_data, y_size);
1795
1796
1797 ret = mbedtls_dsa_check_pqg(&P, &Q, &G);
1798 ret = mbedtls_dsa_set_group(dsa_key, &P, &Q, &G);
1799 if (ret)
1800 {
1801 mbedtls_mpi_free(&P);
1802 mbedtls_mpi_free(&Q);
1803 mbedtls_mpi_free(&G);
1804 mbedtls_mpi_free(&Y);
1805 return STATUS_INTERNAL_ERROR;
1806 }
1807
1808 mbedtls_mpi_copy(&dsa_key->Y, &Y);
1809
1810 ret = mbedtls_dsa_check_pubkey(dsa_key);
1811
1812 memcpy(&key->u.a.dss_seed, data, sizeof(key->u.a.dss_seed));
1813
1814 mbedtls_mpi_free(&P);
1815 mbedtls_mpi_free(&Q);
1816 mbedtls_mpi_free(&G);
1817 mbedtls_mpi_free(&Y);
1818
1819 return STATUS_SUCCESS;
1820}
1821
1822static NTSTATUS key_import_dsa_capi(struct key *key, mbedtls_dsa_context *dsa_key, UCHAR *buf, ULONG len)
1823{
1824 BLOBHEADER *hdr = (BLOBHEADER *)buf;
1825 DSSPUBKEY *pubkey;
1826 mbedtls_mpi P, Q, G, X;
1827 unsigned char *data, p_data[128], q_data[20], g_data[128], x_data[20];
1828 int i, ret, size, p_size, q_size, g_size, x_size;
1829
1830 if (!dsa_key) return STATUS_INVALID_PARAMETER;
1831
1832 pubkey = (DSSPUBKEY *)(buf+sizeof(*hdr));
1833 if ((size = pubkey->bitlen / 8) > sizeof(p_data))
1834 {
1835 FIXME("size %u not supported\n", size);
1836 return STATUS_NOT_SUPPORTED;
1837 }
1838 data = buf + sizeof(*hdr) + sizeof(*pubkey);
1839
1840 p_size = size;
1841 for (i = 0; i < p_size; i++) p_data[i] = data[p_size - i - 1];
1842 data += p_size;
1843
1844 q_size = sizeof(q_data);
1845 for (i = 0; i < q_size; i++) q_data[i] = data[q_size - i - 1];
1846 data += q_size;
1847
1848 g_size = size;
1849 for (i = 0; i < g_size; i++) g_data[i] = data[g_size - i - 1];
1850 data += g_size;
1851
1852 x_size = sizeof(x_data);
1853 for (i = 0; i < x_size; i++) x_data[i] = data[x_size - i - 1];
1854 data += x_size;
1855
1856 mbedtls_mpi_init(&P);
1857 mbedtls_mpi_init(&Q);
1858 mbedtls_mpi_init(&G);
1859 mbedtls_mpi_init(&X);
1860
1861 mbedtls_mpi_read_binary(&P, p_data, p_size);
1862 mbedtls_mpi_read_binary(&Q, q_data, q_size);
1863 mbedtls_mpi_read_binary(&G, g_data, g_size);
1864 mbedtls_mpi_read_binary(&X, x_data, x_size);
1865
1866 ret = mbedtls_dsa_check_pqg(&P, &Q, &G);
1867 ret = mbedtls_dsa_set_group(dsa_key, &P, &Q, &G);
1868 if (ret)
1869 {
1870 mbedtls_mpi_free(&P);
1871 mbedtls_mpi_free(&Q);
1872 mbedtls_mpi_free(&G);
1873 mbedtls_mpi_free(&X);
1874 return STATUS_INTERNAL_ERROR;
1875 }
1876
1877 mbedtls_mpi_copy(&dsa_key->X, &X);
1878
1879 ret = mbedtls_dsa_pubkey_from_privkey(dsa_key);
1880 ret = mbedtls_dsa_check_privkey(dsa_key);
1881
1882 memcpy(&key->u.a.dss_seed, data, sizeof(key->u.a.dss_seed));
1883
1884 mbedtls_mpi_free(&P);
1885 mbedtls_mpi_free(&Q);
1886 mbedtls_mpi_free(&G);
1887 mbedtls_mpi_free(&X);
1888
1889 return STATUS_SUCCESS;
1890}
1891#endif
1892
1893static NTSTATUS init_pk_key(mbedtls_pk_context *key, mbedtls_pk_type_t pk_type, BOOL reinit)
1894{
1895 const mbedtls_pk_info_t *info;
1896 int ret;
1897
1898 if (pk_type == MBEDTLS_PK_NONE) return STATUS_NOT_SUPPORTED;
1899 info = mbedtls_pk_info_from_type(pk_type);
1900 if (info == NULL) return STATUS_NOT_SUPPORTED;
1901 if (reinit) mbedtls_pk_free(key);
1902 mbedtls_pk_init(key);
1903 ret = mbedtls_pk_setup(key, info);
1904 if (ret) return STATUS_INVALID_PARAMETER;
1905 return STATUS_SUCCESS;
1906}
1907
1908static void init_dh_key(mbedtls_dhm_context *key, BOOL reinit)
1909{
1910 if (reinit) mbedtls_dhm_free(key);
1911 mbedtls_dhm_init(key);
1912}
1913
1914#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
1915static void init_dsa_key(mbedtls_dsa_context *key, int len, BOOL reinit)
1916{
1917 if (reinit) mbedtls_dsa_free(key);
1918 mbedtls_dsa_init(key);
1919 key->len = len;
1920}
1921#endif
1922
1923NTSTATUS key_asymmetric_import(void *args)
1924{
1925 const struct key_asymmetric_import_params *params = args;
1926 struct key *key = params->key;
1927 NTSTATUS status = STATUS_SUCCESS;
1928 int ret;
1929 mbedtls_pk_type_t pk_type;
1930 UCHAR *buf;
1931 size_t olen;
1932 BOOL bPrivate = (params->flags & KEY_IMPORT_FLAG_PUBLIC) == 0;
1933
1934#ifndef __REACTOS__
1935 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
1936#endif
1937
1938 pk_type = key_get_type(key->alg_id);
1939 if (bPrivate)
1940 {
1941 switch (key->alg_id)
1942 {
1943 case ALG_ID_ECDH_P256:
1944 case ALG_ID_ECDH_P384:
1945 case ALG_ID_ECDSA_P256:
1946 case ALG_ID_ECDSA_P384:
1947 status = init_pk_key(&key_data(key)->a.pk.privkey, pk_type, TRUE);
1948 status = key_import_ecc(key, params->buf, params->len);
1949 break;
1950
1951 case ALG_ID_RSA:
1952 case ALG_ID_RSA_SIGN:
1953 status = init_pk_key(&key_data(key)->a.pk.privkey, pk_type, TRUE);
1954 status = key_import_rsa(key, params->buf, params->len);
1955 break;
1956
1957#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
1958 case ALG_ID_DSA:
1959 init_dsa_key(&key_data(key)->a.dsa.privkey, (key->u.a.bitlen + 7) / 8, TRUE);
1960 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
1961 ret = key_import_dsa_capi(key, &key_data(key)->a.dsa.privkey, params->buf, params->len);
1962 else
1963 ret = key_import_dsa(key, &key_data(key)->a.dsa.privkey, params->buf, params->len);
1964 if (ret) status = STATUS_INTERNAL_ERROR;
1965 break;
1966#endif
1967 case ALG_ID_DH:
1968 init_dh_key(&key_data(key)->a.dh.privkey, TRUE);
1969 if (params->flags & KEY_IMPORT_FLAG_DH_PARAMETERS)
1970 status = key_import_dh_params(key, &key_data(key)->a.dh.privkey, params->buf, params->len);
1971 else
1972 status = key_import_dh(key, &key_data(key)->a.dh.privkey, params->buf, params->len);
1973 break;
1974
1975 default:
1976 FIXME("algorithm %u not yet supported\n", key->alg_id);
1977 return STATUS_NOT_IMPLEMENTED;
1978 }
1979
1980 if (status) return status;
1981 }
1982 switch (key->alg_id)
1983 {
1984 case ALG_ID_ECDH_P256:
1985 case ALG_ID_ECDH_P384:
1986 case ALG_ID_ECDSA_P256:
1987 case ALG_ID_ECDSA_P384:
1988 status = init_pk_key(&key_data(key)->a.pk.pubkey, pk_type, TRUE);
1989 status = key_import_ecc_public(key, params->buf, params->len);
1990 break;
1991
1992 case ALG_ID_RSA:
1993 case ALG_ID_RSA_SIGN:
1994 status = init_pk_key(&key_data(key)->a.pk.pubkey, pk_type, TRUE);
1995 status = key_import_rsa_public(key, params->buf, params->len);
1996 if (status) break;
1997 if (bPrivate)
1998 {
1999 ret = mbedtls_rsa_check_pub_priv(mbedtls_pk_rsa(key_data(key)->a.pk.pubkey), mbedtls_pk_rsa(key_data(key)->a.pk.privkey));
2000 if (ret) status = STATUS_INTERNAL_ERROR;
2001 }
2002 break;
2003
2004#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2005 case ALG_ID_DSA:
2006 init_dsa_key(&key_data(key)->a.dsa.pubkey, (key->u.a.bitlen + 7) / 8, TRUE);
2007 if (key->u.a.flags & KEY_FLAG_LEGACY_DSA_V2)
2008 {
2009 if (bPrivate)
2010 {
2011 ret = key_import_dsa_capi(key, &key_data(key)->a.dsa.pubkey, params->buf, params->len);
2012 mbedtls_mpi_lset(&key_data(key)->a.dsa.pubkey.X, 0);
2013 }
2014 else
2015 ret = key_import_dsa_capi_public(key, &key_data(key)->a.dsa.pubkey, params->buf, params->len);
2016 }
2017 else
2018 ret = key_import_dsa_public(key, &key_data(key)->a.dsa.pubkey, params->buf, params->len);
2019 if (ret) status = STATUS_INTERNAL_ERROR;
2020 break;
2021#endif
2022 case ALG_ID_DH:
2023 init_dh_key(&key_data(key)->a.dh.pubkey, TRUE);
2024 if (params->flags & KEY_IMPORT_FLAG_DH_PARAMETERS)
2025 {
2026 status = key_import_dh_params(key, &key_data(key)->a.dh.pubkey, params->buf, params->len);
2027 if (status) break;
2028 buf = malloc(1024);
2029 if (!buf) return STATUS_NO_MEMORY;
2030 ret = mbedtls_dhm_make_params(&key_data(key)->a.dh.pubkey, (key->u.a.bitlen + 7) / 8, buf, &olen, bcrypt_rng, NULL);
2031 free(buf);
2032 if (ret) status = STATUS_INTERNAL_ERROR;
2033 }
2034 else
2035 status = key_import_dh_public(key, &key_data(key)->a.dh.pubkey, params->buf, params->len);
2036 break;
2037
2038 default:
2039 FIXME("algorithm %u not yet supported\n", key->alg_id);
2040 return STATUS_NOT_IMPLEMENTED;
2041 }
2042
2043 return status;
2044}
2045
2046#define MBEDTLS_DH_GEN_PRIME
2047#ifdef MBEDTLS_DH_GEN_PRIME
2048static int dh_gen_prime(mbedtls_dhm_context *dh, int nbits, int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
2049{
2050 int ret;
2051 mbedtls_mpi Q, P1;
2052 mbedtls_mpi_init(&Q);
2053 mbedtls_mpi_init(&P1);
2054 ret = mbedtls_mpi_read_string(&dh->G, 10, "4");
2055 ret = mbedtls_mpi_gen_prime(&dh->P, nbits, MBEDTLS_MPI_GEN_PRIME_FLAG_DH, f_rng, p_rng);
2056 // Verifying that Q = (P-1)/2 is prime
2057 ret = mbedtls_mpi_sub_int(&P1, &dh->P, 1);
2058 ret = mbedtls_mpi_div_int(&Q, NULL, &P1, 2);
2059 ret = mbedtls_mpi_is_prime_ext(&Q, 50, f_rng, p_rng);
2060 mbedtls_mpi_free(&Q);
2061 mbedtls_mpi_free(&P1);
2062 return ret;
2063}
2064#endif /* MBEDTLS_DH_GEN_PRIME */
2065
2066NTSTATUS key_asymmetric_generate(void *args)
2067{
2068 struct key *key = args;
2069 mbedtls_pk_type_t pk_type;
2070 mbedtls_ecp_group_id grp_id;
2071 int ret;
2072 NTSTATUS status;
2073 UCHAR *buf;
2074 ULONG len;
2075 size_t olen;
2076 BCRYPT_DSA_KEY_BLOB *dsa_blob;
2077
2078#ifndef __REACTOS__
2079 if (!libmbedtls_handle)
2080 return STATUS_INTERNAL_ERROR;
2081#endif
2082
2083 switch (key->alg_id)
2084 {
2085 case ALG_ID_RSA:
2086 case ALG_ID_RSA_SIGN:
2087 pk_type = key_get_type(key->alg_id);
2088 status = init_pk_key(&key_data(key)->a.pk.privkey, pk_type, FALSE);
2089 ret = mbedtls_rsa_gen_key(mbedtls_pk_rsa(key_data(key)->a.pk.privkey), bcrypt_rng, NULL, key->u.a.bitlen, 65537);
2090 ret = mbedtls_rsa_complete(mbedtls_pk_rsa(key_data(key)->a.pk.privkey));
2091 ret = mbedtls_rsa_check_privkey(mbedtls_pk_rsa(key_data(key)->a.pk.privkey));
2092 ret = mbedtls_rsa_check_pubkey(mbedtls_pk_rsa(key_data(key)->a.pk.privkey));
2093 if (ret) mbedtls_pk_free(&key_data(key)->a.pk.privkey);
2094 break;
2095 case ALG_ID_ECDH_P256:
2096 case ALG_ID_ECDSA_P256:
2097 case ALG_ID_ECDH_P384:
2098 case ALG_ID_ECDSA_P384:
2099 switch (key->alg_id)
2100 {
2101 case ALG_ID_ECDH_P256:
2102 case ALG_ID_ECDSA_P256:
2103 grp_id = MBEDTLS_ECP_DP_SECP256R1;
2104 break;
2105 case ALG_ID_ECDH_P384:
2106 case ALG_ID_ECDSA_P384:
2107 grp_id = MBEDTLS_ECP_DP_SECP384R1;
2108 break;
2109 default:
2110 grp_id = MBEDTLS_ECP_DP_NONE;
2111 }
2112 pk_type = key_get_type(key->alg_id);
2113 status = init_pk_key(&key_data(key)->a.pk.privkey, pk_type, FALSE);
2114 ret = mbedtls_ecp_gen_key(grp_id, mbedtls_pk_ec(key_data(key)->a.pk.privkey), bcrypt_rng, NULL);
2115 if (ret) mbedtls_pk_free(&key_data(key)->a.pk.privkey);
2116 break;
2117 case ALG_ID_DH:
2118 init_dh_key(&key_data(key)->a.dh.privkey, FALSE);
2119#ifdef MBEDTLS_DH_GEN_PRIME
2120 ret = dh_gen_prime(&key_data(key)->a.dh.privkey, key->u.a.bitlen, bcrypt_rng, NULL);
2121#endif
2122 buf = malloc(1024);
2123 if (!buf) return STATUS_NO_MEMORY;
2124 ret = mbedtls_dhm_make_params(&key_data(key)->a.dh.privkey, (key->u.a.bitlen + 7) / 8, buf, &olen, bcrypt_rng, NULL);
2125 free(buf);
2126 if (ret) mbedtls_dhm_free(&key_data(key)->a.dh.privkey);
2127 break;
2128
2129#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2130 case ALG_ID_DSA:
2131 ret = 0;
2132 init_dsa_key(&key_data(key)->a.dsa.privkey, (key->u.a.bitlen + 7) / 8, FALSE);
2133 ret = mbedtls_dsa_genkey(&key_data(key)->a.dsa.privkey, sizeof(dsa_blob->q), (key->u.a.bitlen + 7) / 8, bcrypt_rng, NULL);
2134 ret = mbedtls_dsa_check_pqg(&key_data(key)->a.dsa.privkey.P, &key_data(key)->a.dsa.privkey.Q, &key_data(key)->a.dsa.privkey.G);
2135 ret = mbedtls_dsa_check_pubkey(&key_data(key)->a.dsa.privkey);
2136 ret = mbedtls_dsa_check_privkey(&key_data(key)->a.dsa.privkey);
2137 if (ret) mbedtls_dsa_free(&key_data(key)->a.dsa.privkey);
2138 break;
2139#endif
2140 default:
2141 FIXME("unsupported alg_id %d\n", key->alg_id);
2142 ret = MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
2143 break;
2144 }
2145
2146 if (ret) return STATUS_INTERNAL_ERROR;
2147
2148 buf = malloc(1024);
2149 if (!buf) return STATUS_NO_MEMORY;
2150
2151 switch (key->alg_id)
2152 {
2153 case ALG_ID_ECDH_P256:
2154 case ALG_ID_ECDH_P384:
2155 case ALG_ID_ECDSA_P256:
2156 case ALG_ID_ECDSA_P384:
2157 status = init_pk_key(&key_data(key)->a.pk.pubkey, pk_type, FALSE);
2158 status = key_export_ecc(key, buf, 1024, &len);
2159 status = key_import_ecc_public(key, buf, len);
2160 if (status) mbedtls_pk_free(&key_data(key)->a.pk.pubkey);
2161 break;
2162
2163 case ALG_ID_RSA:
2164 case ALG_ID_RSA_SIGN:
2165 status = init_pk_key(&key_data(key)->a.pk.pubkey, pk_type, FALSE);
2166 status = key_export_rsa(key, 0, buf, 1024, &len);
2167 status = key_import_rsa_public(key, buf, len);
2168 if (status) mbedtls_pk_free(&key_data(key)->a.pk.pubkey);
2169 break;
2170
2171#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2172 case ALG_ID_DSA:
2173 init_dsa_key(&key_data(key)->a.dsa.pubkey, (key->u.a.bitlen + 7) / 8, FALSE);
2174 status = key_export_dsa(key, &key_data(key)->a.dsa.privkey, buf, 1024, &len);
2175 status = key_import_dsa_public(key, &key_data(key)->a.dsa.pubkey, buf, len);
2176 if (status) mbedtls_dsa_free(&key_data(key)->a.dsa.pubkey);
2177 break;
2178#endif
2179 case ALG_ID_DH:
2180 init_dh_key(&key_data(key)->a.dh.pubkey, FALSE);
2181 status = key_export_dh(key, &key_data(key)->a.dh.privkey, buf, 1024, &len);
2182 status = key_import_dh_public(key, &key_data(key)->a.dh.pubkey, buf, len);
2183 if (status) mbedtls_dhm_free(&key_data(key)->a.dh.pubkey);
2184 break;
2185
2186 default:
2187 FIXME("algorithm %u not yet supported\n", key->alg_id);
2188 return STATUS_NOT_IMPLEMENTED;
2189 }
2190 free(buf);
2191
2192 if (status) return status;
2193
2194 return STATUS_SUCCESS;
2195}
2196
2197static mbedtls_md_type_t get_digest_from_id(const WCHAR *alg_id)
2198{
2199 if (!wcscmp(alg_id, BCRYPT_SHA1_ALGORITHM)) return MBEDTLS_MD_SHA1;
2200 if (!wcscmp(alg_id, BCRYPT_SHA256_ALGORITHM)) return MBEDTLS_MD_SHA256;
2201 if (!wcscmp(alg_id, BCRYPT_SHA384_ALGORITHM)) return MBEDTLS_MD_SHA384;
2202 if (!wcscmp(alg_id, BCRYPT_SHA512_ALGORITHM)) return MBEDTLS_MD_SHA512;
2203 if (!wcscmp(alg_id, BCRYPT_MD2_ALGORITHM)) return MBEDTLS_MD_MD2;
2204 if (!wcscmp(alg_id, BCRYPT_MD5_ALGORITHM)) return MBEDTLS_MD_MD5;
2205 return MBEDTLS_MD_NONE;
2206}
2207
2208NTSTATUS key_asymmetric_verify(void *args)
2209{
2210 const struct key_asymmetric_verify_params *params = args;
2211 struct key *key = params->key;
2212 mbedtls_md_type_t hash_alg = MBEDTLS_MD_NONE;
2213 mbedtls_pk_type_t pk_type = key_get_type(key->alg_id);
2214 mbedtls_pk_rsassa_pss_options pss_options;
2215 UCHAR *out_signature;
2216 ULONG out_signature_len;
2217 UCHAR *p, *start;
2218 size_t len;
2219 int ret;
2220
2221#ifndef __REACTOS__
2222 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2223#endif
2224
2225 switch (key->alg_id)
2226 {
2227 case ALG_ID_ECDSA_P256:
2228 case ALG_ID_ECDSA_P384:
2229 {
2230 if (params->flags) FIXME("flags %x not supported\n", params->flags);
2231
2232 /* only the hash size must match, not the actual hash function */
2233 switch (params->hash_len)
2234 {
2235 case 20:
2236 hash_alg = MBEDTLS_MD_SHA1;
2237 break;
2238 case 32:
2239 hash_alg = MBEDTLS_MD_SHA256;
2240 break;
2241 case 48:
2242 hash_alg = MBEDTLS_MD_SHA384;
2243 break;
2244
2245 default:
2246 FIXME("hash size %u not yet supported\n", params->hash_len);
2247 return STATUS_INVALID_SIGNATURE;
2248 }
2249 break;
2250 }
2251 case ALG_ID_RSA:
2252 case ALG_ID_RSA_SIGN:
2253 {
2254 if (params->flags & BCRYPT_PAD_PKCS1)
2255 {
2256 BCRYPT_PKCS1_PADDING_INFO *info = params->padding;
2257
2258 if (!info) return STATUS_INVALID_PARAMETER;
2259 if (!info->pszAlgId)
2260 {
2261 hash_alg = MBEDTLS_MD_NONE;
2262 }
2263 else
2264 {
2265 if ((hash_alg = get_digest_from_id(info->pszAlgId)) == MBEDTLS_MD_NONE)
2266 {
2267 FIXME("hash algorithm %s not supported\n", debugstr_w(info->pszAlgId));
2268 return STATUS_NOT_SUPPORTED;
2269 }
2270 }
2271 }
2272 else if (params->flags & BCRYPT_PAD_PSS)
2273 {
2274 BCRYPT_PSS_PADDING_INFO *info = params->padding;
2275
2276 if (!info) return STATUS_INVALID_PARAMETER;
2277 if (!info->pszAlgId) return STATUS_INVALID_SIGNATURE;
2278 if ((hash_alg = get_digest_from_id(info->pszAlgId)) == MBEDTLS_MD_NONE)
2279 {
2280 FIXME("hash algorithm %s not supported\n", debugstr_w(info->pszAlgId));
2281 return STATUS_NOT_SUPPORTED;
2282 }
2283 pss_options.mgf1_hash_id = hash_alg;
2284 pss_options.expected_salt_len = info->cbSalt;
2285 pk_type = MBEDTLS_PK_RSASSA_PSS;
2286 }
2287 else
2288 return STATUS_INVALID_PARAMETER;
2289 break;
2290 }
2291#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2292 case ALG_ID_DSA:
2293 {
2294 if (params->flags) FIXME("flags %x not supported\n", params->flags);
2295 if (params->hash_len != 20)
2296 {
2297 FIXME("hash size %u not supported\n", params->hash_len);
2298 return STATUS_INVALID_PARAMETER;
2299 }
2300 hash_alg = MBEDTLS_MD_SHA1;
2301 break;
2302 }
2303#endif
2304 default:
2305 FIXME("algorithm %u not yet supported\n", key->alg_id);
2306 return STATUS_NOT_IMPLEMENTED;
2307 }
2308
2309 if (key->alg_id == ALG_ID_ECDSA_P256 || key->alg_id == ALG_ID_ECDSA_P384
2310#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2311 || key->alg_id == ALG_ID_DSA
2312#endif
2313 )
2314 {
2315 len = params->signature_len / 2;
2316 out_signature = malloc(params->signature_len + 6);
2317 if (!out_signature) return STATUS_NO_MEMORY;
2318 p = out_signature + params->signature_len + 6;
2319 start = out_signature;
2320 ret = mbedtls_asn1_write_raw_buffer(&p, start, params->signature + len, len);
2321 ret = mbedtls_asn1_write_len(&p, start, len);
2322 ret = mbedtls_asn1_write_tag(&p, start, MBEDTLS_ASN1_INTEGER);
2323 ret = mbedtls_asn1_write_raw_buffer(&p, start, params->signature, len);
2324 ret = mbedtls_asn1_write_len(&p, start, len);
2325 ret = mbedtls_asn1_write_tag(&p, start, MBEDTLS_ASN1_INTEGER);
2326 ret = mbedtls_asn1_write_len(&p, start, params->signature_len + 4);
2327 ret = mbedtls_asn1_write_tag(&p, start, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE);
2328 out_signature_len = params->signature_len + 6;
2329 }
2330 else
2331 {
2332 out_signature = params->signature;
2333 out_signature_len = params->signature_len;
2334 }
2335
2336#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2337 if (key->alg_id == ALG_ID_DSA)
2338 ret = mbedtls_dsa_verify(&key_data(params->key)->a.dsa.pubkey, params->hash, params->hash_len, out_signature, out_signature_len);
2339 else
2340#endif
2341 ret = mbedtls_pk_verify_ext(pk_type, (params->flags & BCRYPT_PAD_PSS) == 0 ? NULL : &pss_options, &key_data(params->key)->a.pk.pubkey,
2342 hash_alg, params->hash, params->hash_len, out_signature, out_signature_len);
2343 if (out_signature != params->signature) free(out_signature);
2344 if (ret) return STATUS_INVALID_SIGNATURE;
2345
2346 return STATUS_SUCCESS;
2347}
2348
2349NTSTATUS key_asymmetric_sign(void *args)
2350{
2351 const struct key_asymmetric_sign_params *params = args;
2352 struct key *key = params->key;
2353 size_t sig_len, len, expected_len;
2354 mbedtls_md_type_t hash_alg = MBEDTLS_MD_NONE;
2355 unsigned int flags = params->flags;
2356 UCHAR *p, *end, *output;
2357 int ret;
2358
2359#ifndef __REACTOS__
2360 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2361#endif
2362
2363 if (key->alg_id == ALG_ID_ECDSA_P256 || key->alg_id == ALG_ID_ECDSA_P384)
2364 {
2365 /* With ECDSA, we find the digest algorithm from the hash length, and verify it */
2366 switch (params->input_len)
2367 {
2368 case 20:
2369 hash_alg = MBEDTLS_MD_SHA1;
2370 break;
2371 case 32:
2372 hash_alg = MBEDTLS_MD_SHA256;
2373 break;
2374 case 48:
2375 hash_alg = MBEDTLS_MD_SHA384;
2376 break;
2377 case 64:
2378 hash_alg = MBEDTLS_MD_SHA512;
2379 break;
2380
2381 default:
2382 FIXME("hash size %u not yet supported\n", params->input_len);
2383 return STATUS_INVALID_PARAMETER;
2384 }
2385
2386 if (flags == BCRYPT_PAD_PKCS1)
2387 {
2388 BCRYPT_PKCS1_PADDING_INFO *pad = params->padding;
2389 if (pad && pad->pszAlgId && get_digest_from_id(pad->pszAlgId) != hash_alg)
2390 {
2391 WARN("incorrect hashing algorithm %s, expected %u\n", debugstr_w(pad->pszAlgId), hash_alg);
2392 return STATUS_INVALID_PARAMETER;
2393 }
2394 }
2395 }
2396#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2397 else if (key->alg_id == ALG_ID_DSA)
2398 {
2399 if (flags) FIXME("flags %#x not supported\n", flags);
2400 if (params->input_len != 20)
2401 {
2402 FIXME("hash size %u not supported\n", params->input_len);
2403 return STATUS_INVALID_PARAMETER;
2404 }
2405 hash_alg = MBEDTLS_MD_SHA1;
2406 }
2407#endif
2408 else if (flags == BCRYPT_PAD_PKCS1)
2409 {
2410 BCRYPT_PKCS1_PADDING_INFO *pad = params->padding;
2411
2412 if (!pad)
2413 {
2414 WARN("padding info not found\n");
2415 return STATUS_INVALID_PARAMETER;
2416 }
2417 if (!pad->pszAlgId) hash_alg = MBEDTLS_MD_NONE;
2418 else if ((hash_alg = get_digest_from_id(pad->pszAlgId)) == MBEDTLS_MD_NONE)
2419 {
2420 FIXME("hash algorithm %s not recognized\n", debugstr_w(pad->pszAlgId));
2421 return STATUS_NOT_SUPPORTED;
2422 }
2423 }
2424 else if (flags == BCRYPT_PAD_PSS)
2425 {
2426 BCRYPT_PSS_PADDING_INFO *pad = params->padding;
2427
2428 if (!pad || !pad->pszAlgId)
2429 {
2430 WARN("padding info not found\n");
2431 return STATUS_INVALID_PARAMETER;
2432 }
2433 if (key->alg_id != ALG_ID_RSA && key->alg_id != ALG_ID_RSA_SIGN)
2434 {
2435 FIXME("BCRYPT_PAD_PSS not supported for key algorithm %u\n", key->alg_id);
2436 return STATUS_NOT_SUPPORTED;
2437 }
2438 if ((hash_alg = get_digest_from_id(pad->pszAlgId)) == MBEDTLS_MD_NONE)
2439 {
2440 FIXME("hash algorithm %s not recognized\n", debugstr_w(pad->pszAlgId));
2441 return STATUS_NOT_SUPPORTED;
2442 }
2443
2444 mbedtls_rsa_set_padding(mbedtls_pk_rsa(key_data(key)->a.pk.privkey), MBEDTLS_RSA_PKCS_V21, hash_alg);
2445 }
2446 else if (!flags)
2447 {
2448 WARN("invalid flags %#x\n", flags);
2449 return STATUS_INVALID_PARAMETER;
2450 }
2451 else
2452 {
2453 FIXME("flags %#x not implemented\n", flags);
2454 return STATUS_NOT_IMPLEMENTED;
2455 }
2456
2457 if (!params->output)
2458 {
2459 *params->ret_len = key->u.a.bitlen / 8;
2460 return STATUS_SUCCESS;
2461 }
2462
2463 output = malloc(1024);
2464 if (!output) return STATUS_NO_MEMORY;
2465#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2466 if (key->alg_id == ALG_ID_DSA)
2467 ret = mbedtls_dsa_sign(&key_data(params->key)->a.dsa.privkey, params->input, params->input_len, output, &sig_len,
2468 bcrypt_rng, NULL);
2469 else
2470#endif
2471 ret = mbedtls_pk_sign(&key_data(params->key)->a.pk.privkey, hash_alg, params->input, params->input_len, output, &sig_len,
2472 bcrypt_rng, NULL);
2473 if (ret)
2474 {
2475 free(output);
2476 return STATUS_INTERNAL_ERROR;
2477 }
2478 if ((key->alg_id == ALG_ID_ECDSA_P256 || key->alg_id == ALG_ID_ECDSA_P384
2479#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2480 || key->alg_id == ALG_ID_DSA
2481#endif
2482 ))
2483 {
2484 p = output;
2485 end = output + sig_len;
2486 ret = mbedtls_asn1_get_tag(&p, end, &len, MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE);
2487 ret = mbedtls_asn1_get_tag(&p, end, &len, MBEDTLS_ASN1_INTEGER);
2488 expected_len = (len / 2) * 2;
2489 if (!ret && expected_len < len) p += len - expected_len;
2490 if (!ret) sig_len = expected_len;
2491 memcpy(params->output, p, expected_len);
2492 p += expected_len;
2493 ret = mbedtls_asn1_get_tag(&p, end, &len, MBEDTLS_ASN1_INTEGER);
2494 expected_len = (len / 2) * 2;
2495 if (!ret && expected_len < len) p += len - expected_len;
2496 if (!ret) memcpy(params->output + sig_len, p, expected_len);
2497 if (!ret) sig_len += expected_len;
2498 }
2499 else
2500 if (sig_len <= params->output_len) memcpy(params->output, output, sig_len);
2501 free(output);
2502
2503 *params->ret_len = sig_len;
2504 if (sig_len > params->output_len) return STATUS_BUFFER_TOO_SMALL;
2505 if (ret) return STATUS_INTERNAL_ERROR;
2506 return STATUS_SUCCESS;
2507}
2508
2509NTSTATUS key_asymmetric_destroy(void *args)
2510{
2511 struct key *key = args;
2512
2513#ifndef __REACTOS__
2514 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2515#endif
2516
2517 switch (key->alg_id)
2518 {
2519 case ALG_ID_ECDSA_P256:
2520 case ALG_ID_ECDSA_P384:
2521 case ALG_ID_RSA:
2522 case ALG_ID_RSA_SIGN:
2523 {
2524 mbedtls_pk_free(&key_data(key)->a.pk.privkey);
2525 mbedtls_pk_free(&key_data(key)->a.pk.pubkey);
2526 break;
2527 }
2528 case ALG_ID_DH:
2529 {
2530 mbedtls_dhm_free(&key_data(key)->a.dh.privkey);
2531 mbedtls_dhm_free(&key_data(key)->a.dh.pubkey);
2532 break;
2533 }
2534#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2535 case ALG_ID_DSA:
2536 {
2537 mbedtls_dsa_free(&key_data(key)->a.dsa.privkey);
2538 mbedtls_dsa_free(&key_data(key)->a.dsa.pubkey);
2539 break;
2540 }
2541#endif
2542 default:
2543 FIXME("algorithm %u not yet supported\n", key->alg_id);
2544 return STATUS_NOT_IMPLEMENTED;
2545 }
2546 return STATUS_SUCCESS;
2547}
2548
2549NTSTATUS key_asymmetric_duplicate(void *args)
2550{
2551 const struct key_asymmetric_duplicate_params *params = args;
2552 mbedtls_pk_type_t pk_type;
2553 unsigned char *buf;
2554 ULONG len;
2555 NTSTATUS status;
2556
2557#ifndef __REACTOS__
2558 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2559#endif
2560
2561 buf = malloc(1024);
2562 if (!buf) return STATUS_NO_MEMORY;
2563
2564 switch (params->key_orig->alg_id)
2565 {
2566 case ALG_ID_RSA:
2567 case ALG_ID_RSA_SIGN:
2568 {
2569 pk_type = key_get_type(params->key_orig->alg_id);
2570 init_pk_key(&key_data(params->key_copy)->a.pk.privkey, pk_type, TRUE);
2571 init_pk_key(&key_data(params->key_copy)->a.pk.pubkey, pk_type, TRUE);
2572 status = key_export_rsa(params->key_orig, KEY_EXPORT_FLAG_RSA_FULL, buf, 1024, &len);
2573 status = key_import_rsa(params->key_copy, buf, len);
2574 status = key_export_rsa_public(params->key_orig, buf, 1024, &len);
2575 if (status)
2576 {
2577 mbedtls_pk_free(&key_data(params->key_copy)->a.pk.privkey);
2578 mbedtls_pk_free(&key_data(params->key_copy)->a.pk.pubkey);
2579 break;
2580 }
2581 status = key_import_rsa_public(params->key_copy, buf, len);
2582 break;
2583 }
2584 case ALG_ID_ECDH_P256:
2585 case ALG_ID_ECDH_P384:
2586 {
2587 pk_type = key_get_type(params->key_orig->alg_id);
2588 init_pk_key(&key_data(params->key_copy)->a.pk.privkey, pk_type, TRUE);
2589 init_pk_key(&key_data(params->key_copy)->a.pk.pubkey, pk_type, TRUE);
2590 status = key_export_ecc(params->key_orig, buf, 1024, &len);
2591 status = key_import_ecc(params->key_copy, buf, len);
2592 status = key_export_ecc_public(params->key_orig, buf, 1024, &len);
2593 if (status)
2594 {
2595 mbedtls_pk_free(&key_data(params->key_copy)->a.pk.privkey);
2596 mbedtls_pk_free(&key_data(params->key_copy)->a.pk.pubkey);
2597 break;
2598 }
2599 status = key_import_ecc_public(params->key_copy, buf, len);
2600 break;
2601 }
2602#ifdef MBEDTLS_DSA_C /* DSA is not supported by mbedtls */
2603 case ALG_ID_DSA:
2604 {
2605 init_dsa_key(&key_data(params->key_copy)->a.dsa.privkey, (params->key_orig->u.a.bitlen + 7) / 8, TRUE);
2606 init_dsa_key(&key_data(params->key_copy)->a.dsa.pubkey, (params->key_orig->u.a.bitlen + 7) / 8, TRUE);
2607 status = key_export_dsa(params->key_orig, &key_data(params->key_orig)->a.dsa.privkey, buf, 1024, &len);
2608 status = key_import_dsa(params->key_copy, &key_data(params->key_copy)->a.dsa.privkey, buf, len);
2609 status = key_export_dsa_public(params->key_orig, &key_data(params->key_orig)->a.dsa.pubkey, buf, 1024, &len);
2610 if (status)
2611 {
2612 mbedtls_dsa_free(&key_data(params->key_copy)->a.dsa.privkey);
2613 mbedtls_dsa_free(&key_data(params->key_copy)->a.dsa.pubkey);
2614 break;
2615 }
2616 status = key_import_dsa_public(params->key_copy, &key_data(params->key_copy)->a.dsa.pubkey, buf, len);
2617 break;
2618 }
2619#endif
2620 case ALG_ID_DH:
2621 {
2622 init_dh_key(&key_data(params->key_copy)->a.dh.privkey, TRUE);
2623 init_dh_key(&key_data(params->key_copy)->a.dh.pubkey, TRUE);
2624 status = key_export_dh(params->key_orig, &key_data(params->key_orig)->a.dh.privkey, buf, 1024, &len);
2625 status = key_import_dh(params->key_copy, &key_data(params->key_copy)->a.dh.privkey, buf, len);
2626 status = key_export_dh_public(params->key_orig, &key_data(params->key_orig)->a.dh.pubkey, buf, 1024, &len);
2627 if (status)
2628 {
2629 mbedtls_dhm_free(&key_data(params->key_copy)->a.dh.privkey);
2630 mbedtls_dhm_free(&key_data(params->key_copy)->a.dh.pubkey);
2631 break;
2632 }
2633 status = key_import_dh_public(params->key_copy, &key_data(params->key_copy)->a.dh.pubkey, buf, len);
2634 break;
2635 }
2636 default:
2637 FIXME("unsupported algorithm %u\n", params->key_orig->alg_id);
2638 return STATUS_NOT_IMPLEMENTED;
2639 }
2640
2641 free(buf);
2642 if (!status) return STATUS_SUCCESS;
2643
2644 return STATUS_INTERNAL_ERROR;
2645}
2646
2647NTSTATUS key_asymmetric_decrypt(void *args)
2648{
2649 const struct key_asymmetric_decrypt_params *params = args;
2650 size_t olen;
2651 int ret;
2652
2653#ifndef __REACTOS__
2654 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2655#endif
2656
2657 if (!(params->key->u.a.flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
2658
2659 if (params->key->alg_id == ALG_ID_RSA && params->flags & BCRYPT_PAD_OAEP)
2660 {
2661 BCRYPT_OAEP_PADDING_INFO *pad = params->padding;
2662 mbedtls_md_type_t dig;
2663
2664 if (!pad || !pad->pszAlgId)
2665 {
2666 WARN("padding info not found\n");
2667 return STATUS_INVALID_PARAMETER;
2668 }
2669 if ((dig = get_digest_from_id(pad->pszAlgId)) == MBEDTLS_MD_NONE)
2670 {
2671 FIXME("hash algorithm %s not recognized\n", debugstr_w(pad->pszAlgId));
2672 return STATUS_NOT_SUPPORTED;
2673 }
2674
2675 mbedtls_rsa_set_padding(mbedtls_pk_rsa(key_data(params->key)->a.pk.privkey), MBEDTLS_RSA_PKCS_V21, dig);
2676 }
2677 ret = mbedtls_pk_decrypt(&key_data(params->key)->a.pk.privkey, params->input, params->input_len, params->output, &olen, params->output_len, bcrypt_rng, NULL);
2678
2679 if (ret) return STATUS_INTERNAL_ERROR;
2680
2681 *params->ret_len = olen;
2682 return STATUS_SUCCESS;
2683}
2684
2685NTSTATUS key_asymmetric_encrypt(void *args)
2686{
2687 const struct key_asymmetric_encrypt_params *params = args;
2688 size_t olen;
2689 int ret;
2690
2691#ifndef __REACTOS__
2692 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2693#endif
2694
2695 if (!(params->key->u.a.flags & KEY_FLAG_FINALIZED)) return STATUS_INVALID_HANDLE;
2696
2697 if (params->key->alg_id == ALG_ID_RSA && params->flags & BCRYPT_PAD_OAEP)
2698 {
2699 BCRYPT_OAEP_PADDING_INFO *pad = params->padding;
2700 mbedtls_md_type_t dig;
2701
2702 if (!pad || !pad->pszAlgId || !pad->pbLabel)
2703 {
2704 WARN("padding info not found\n");
2705 return STATUS_INVALID_PARAMETER;
2706 }
2707 if ((dig = get_digest_from_id(pad->pszAlgId)) == MBEDTLS_MD_NONE)
2708 {
2709 FIXME("hash algorithm %s not recognized\n", debugstr_w(pad->pszAlgId));
2710 return STATUS_NOT_SUPPORTED;
2711 }
2712
2713 mbedtls_rsa_set_padding(mbedtls_pk_rsa(key_data(params->key)->a.pk.pubkey), MBEDTLS_RSA_PKCS_V21, dig);
2714 }
2715
2716 ret = mbedtls_pk_encrypt(&key_data(params->key)->a.pk.pubkey, params->input, params->input_len, params->output, &olen, params->output_len,
2717 bcrypt_rng, NULL);
2718
2719 if (ret) return STATUS_INTERNAL_ERROR;
2720
2721 *params->ret_len = olen;
2722 return STATUS_SUCCESS;
2723}
2724
2725NTSTATUS key_asymmetric_derive_key(void *args)
2726{
2727 const struct key_asymmetric_derive_key_params *params = args;
2728 int ret;
2729
2730#ifndef __REACTOS__
2731 if (!libmbedtls_handle) return STATUS_INTERNAL_ERROR;
2732#endif
2733
2734 switch (params->privkey->alg_id)
2735 {
2736 case ALG_ID_ECDH_P256:
2737 case ALG_ID_ECDH_P384:
2738 {
2739 mbedtls_ecdh_context ecdh;
2740 mbedtls_ecp_keypair *ecp_keypair_pr;
2741 mbedtls_ecp_keypair *ecp_keypair_pu;
2742
2743 mbedtls_ecdh_init(&ecdh);
2744 ecp_keypair_pr = mbedtls_pk_ec(key_data(params->privkey)->a.pk.privkey);
2745 ecp_keypair_pu = mbedtls_pk_ec(key_data(params->pubkey)->a.pk.pubkey);
2746 if (!ecp_keypair_pr || !ecp_keypair_pu) return STATUS_INTERNAL_ERROR;
2747 mbedtls_ecp_group_load(&ecdh.grp, ecp_keypair_pr->grp.id);
2748 mbedtls_mpi_copy(&ecdh.d, &ecp_keypair_pr->d);
2749 mbedtls_ecp_copy(&ecdh.Qp, &ecp_keypair_pu->Q);
2750
2751 *params->ret_len = mbedtls_mpi_size(&ecdh.grp.P);
2752 if (params->output)
2753 {
2754 if (params->output_len < *params->ret_len)
2755 {
2756 mbedtls_ecdh_free(&ecdh);
2757 return STATUS_BUFFER_TOO_SMALL;
2758 }
2759 ret = mbedtls_ecdh_compute_shared(&ecdh.grp, &ecdh.z, &ecdh.Qp, &ecdh.d, bcrypt_rng, NULL);
2760 if (ret)
2761 {
2762 FIXME("mbedtls_ecdh_compute_shared failed: %d\n", ret);
2763 mbedtls_ecdh_free(&ecdh);
2764 return STATUS_UNSUCCESSFUL;
2765 }
2766 mbedtls_mpi_write_binary(&ecdh.z, params->output, *params->ret_len);
2767 }
2768 mbedtls_ecdh_free(&ecdh);
2769 break;
2770 }
2771 case ALG_ID_DH:
2772 {
2773 mbedtls_dhm_context *dhm;
2774 mbedtls_dhm_context *dhm_pub;
2775 size_t secret_len;
2776
2777 dhm = &key_data(params->privkey)->a.dh.privkey;
2778 dhm_pub = &key_data(params->pubkey)->a.dh.pubkey;
2779
2780 mbedtls_mpi_copy(&dhm->GY, &dhm_pub->GX);
2781
2782 *params->ret_len = mbedtls_mpi_size(&dhm->P);
2783 if (params->output)
2784 {
2785 if (params->output_len < *params->ret_len) return STATUS_BUFFER_TOO_SMALL;
2786 ret = mbedtls_dhm_calc_secret(dhm, params->output, params->output_len, &secret_len, bcrypt_rng, NULL);
2787 if (ret)
2788 {
2789 FIXME("mbedtls_dhm_calc_secret failed with %d\n", ret);
2790 return STATUS_UNSUCCESSFUL;
2791 }
2792 *params->ret_len = secret_len;
2793 }
2794 break;
2795 }
2796 default:
2797 FIXME("unsupported algorithm %u\n", params->privkey->alg_id);
2798 return STATUS_NOT_IMPLEMENTED;
2799 }
2800
2801 return STATUS_SUCCESS;
2802}
2803
2804#endif /* SONAME_LIBMBEDTLS */
asn1.h
Generic ASN.1 parsing.
asn1write.h
ASN.1 buffer writing functionality.
mbedtls_asn1_write_raw_buffer
int mbedtls_asn1_write_raw_buffer(unsigned char **p, unsigned char *start, const unsigned char *buf, size_t size)
Write raw buffer data.
mbedtls_asn1_write_tag
int mbedtls_asn1_write_tag(unsigned char **p, unsigned char *start, unsigned char tag)
Write an ASN.1 tag in ASN.1 format.
mbedtls_asn1_write_len
int mbedtls_asn1_write_len(unsigned char **p, unsigned char *start, size_t len)
Write a length field in ASN.1 format.
mbedtls_asn1_write_mpi
int mbedtls_asn1_write_mpi(unsigned char **p, unsigned char *start, const mbedtls_mpi *X)
Write a arbitrary-precision number (MBEDTLS_ASN1_INTEGER) in ASN.1 format.
WINE_DEFAULT_DEBUG_CHANNEL
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
operation
operation
Definition: copy.c:29
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
BCRYPT_DH_PUBLIC_MAGIC
#define BCRYPT_DH_PUBLIC_MAGIC
Definition: bcrypt.h:280
BCRYPT_ECDH_PRIVATE_P256_MAGIC
#define BCRYPT_ECDH_PRIVATE_P256_MAGIC
Definition: bcrypt.h:133
BCRYPT_ECDSA_PUBLIC_P256_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P256_MAGIC
Definition: bcrypt.h:125
BCRYPT_ECDH_PUBLIC_P384_MAGIC
#define BCRYPT_ECDH_PUBLIC_P384_MAGIC
Definition: bcrypt.h:134
BCRYPT_ECDSA_PUBLIC_P384_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P384_MAGIC
Definition: bcrypt.h:127
BCRYPT_SHA512_ALGORITHM
#define BCRYPT_SHA512_ALGORITHM
Definition: bcrypt.h:107
BCRYPT_PAD_PKCS1
#define BCRYPT_PAD_PKCS1
Definition: bcrypt.h:236
BCRYPT_RSAFULLPRIVATE_MAGIC
#define BCRYPT_RSAFULLPRIVATE_MAGIC
Definition: bcrypt.h:205
BCRYPT_MD2_ALGORITHM
#define BCRYPT_MD2_ALGORITHM
Definition: bcrypt.h:96
BCRYPT_SHA256_ALGORITHM
#define BCRYPT_SHA256_ALGORITHM
Definition: bcrypt.h:105
BCRYPT_RSAPRIVATE_MAGIC
#define BCRYPT_RSAPRIVATE_MAGIC
Definition: bcrypt.h:204
BCRYPT_PAD_PSS
#define BCRYPT_PAD_PSS
Definition: bcrypt.h:238
BCRYPT_ECDH_PUBLIC_P256_MAGIC
#define BCRYPT_ECDH_PUBLIC_P256_MAGIC
Definition: bcrypt.h:132
BCRYPT_ECDSA_PRIVATE_P256_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P256_MAGIC
Definition: bcrypt.h:126
BCRYPT_ECDSA_PRIVATE_P384_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P384_MAGIC
Definition: bcrypt.h:128
BCRYPT_DH_PARAMETERS_MAGIC
#define BCRYPT_DH_PARAMETERS_MAGIC
Definition: bcrypt.h:289
BCRYPT_RSAPUBLIC_MAGIC
#define BCRYPT_RSAPUBLIC_MAGIC
Definition: bcrypt.h:203
BCRYPT_ECDH_PRIVATE_P384_MAGIC
#define BCRYPT_ECDH_PRIVATE_P384_MAGIC
Definition: bcrypt.h:135
BCRYPT_PAD_OAEP
#define BCRYPT_PAD_OAEP
Definition: bcrypt.h:237
BCRYPT_SHA384_ALGORITHM
#define BCRYPT_SHA384_ALGORITHM
Definition: bcrypt.h:106
BCRYPT_DSA_PUBLIC_MAGIC
#define BCRYPT_DSA_PUBLIC_MAGIC
Definition: bcrypt.h:241
BCRYPT_SHA1_ALGORITHM
#define BCRYPT_SHA1_ALGORITHM
Definition: bcrypt.h:104
BCRYPT_MD5_ALGORITHM
#define BCRYPT_MD5_ALGORITHM
Definition: bcrypt.h:98
BCRYPT_DH_PRIVATE_MAGIC
#define BCRYPT_DH_PRIVATE_MAGIC
Definition: bcrypt.h:281
key_symmetric_vector_reset
NTSTATUS key_symmetric_vector_reset(void *args)
key_symmetric_encrypt_internal
NTSTATUS key_symmetric_encrypt_internal(void *args)
key_asymmetric_export
NTSTATUS key_asymmetric_export(void *args)
KEY_FLAG_FINALIZED
#define KEY_FLAG_FINALIZED
Definition: bcrypt_internal.h:91
key_symmetric_set_auth_data
NTSTATUS key_symmetric_set_auth_data(void *args)
key_symmetric_get_tag
NTSTATUS key_symmetric_get_tag(void *args)
hash_update
NTSTATUS hash_update(struct hash *hash, UCHAR *input, ULONG size)
key_asymmetric_encrypt
NTSTATUS key_asymmetric_encrypt(void *args)
key_symmetric_destroy
NTSTATUS key_symmetric_destroy(void *args)
MAGIC_DSS1
#define MAGIC_DSS1
Definition: bcrypt_internal.h:9
CHAIN_MODE_ECB
@ CHAIN_MODE_ECB
Definition: bcrypt_internal.h:61
CHAIN_MODE_CBC
@ CHAIN_MODE_CBC
Definition: bcrypt_internal.h:60
CHAIN_MODE_GCM
@ CHAIN_MODE_GCM
Definition: bcrypt_internal.h:64
CHAIN_MODE_CFB
@ CHAIN_MODE_CFB
Definition: bcrypt_internal.h:62
KEY_EXPORT_FLAG_DH_PARAMETERS
#define KEY_EXPORT_FLAG_DH_PARAMETERS
Definition: bcrypt_internal.h:211
key_symmetric_decrypt_internal
NTSTATUS key_symmetric_decrypt_internal(void *args)
hash_get_size
NTSTATUS hash_get_size(struct hash *hash, ULONG *output)
hash_finish
NTSTATUS hash_finish(struct hash *hash, UCHAR *output)
KEY_IMPORT_FLAG_PUBLIC
#define KEY_IMPORT_FLAG_PUBLIC
Definition: bcrypt_internal.h:222
key_asymmetric_generate
NTSTATUS key_asymmetric_generate(void *args)
key_asymmetric_destroy
NTSTATUS key_asymmetric_destroy(void *args)
process_attach
NTSTATUS process_attach(void *args)
KEY_EXPORT_FLAG_RSA_FULL
#define KEY_EXPORT_FLAG_RSA_FULL
Definition: bcrypt_internal.h:210
HASH_FLAG_HMAC
#define HASH_FLAG_HMAC
Definition: bcrypt_internal.h:243
key_asymmetric_verify
NTSTATUS key_asymmetric_verify(void *args)
key_asymmetric_derive_key
NTSTATUS key_asymmetric_derive_key(void *args)
MAGIC_DSS2
#define MAGIC_DSS2
Definition: bcrypt_internal.h:10
key_asymmetric_import
NTSTATUS key_asymmetric_import(void *args)
hash_init
NTSTATUS hash_init(struct hash *hash)
KEY_IMPORT_FLAG_DH_PARAMETERS
#define KEY_IMPORT_FLAG_DH_PARAMETERS
Definition: bcrypt_internal.h:223
KEY_FLAG_LEGACY_DSA_V2
#define KEY_FLAG_LEGACY_DSA_V2
Definition: bcrypt_internal.h:90
key_asymmetric_sign
NTSTATUS key_asymmetric_sign(void *args)
key_asymmetric_decrypt
NTSTATUS key_asymmetric_decrypt(void *args)
key_asymmetric_duplicate
NTSTATUS key_asymmetric_duplicate(void *args)
alg_id
alg_id
Definition: bcrypt_internal.h:22
ALG_ID_RSA
@ ALG_ID_RSA
Definition: bcrypt_internal.h:38
ALG_ID_DSA
@ ALG_ID_DSA
Definition: bcrypt_internal.h:49
ALG_ID_RSA_SIGN
@ ALG_ID_RSA_SIGN
Definition: bcrypt_internal.h:46
ALG_ID_3DES
@ ALG_ID_3DES
Definition: bcrypt_internal.h:24
ALG_ID_ECDSA_P256
@ ALG_ID_ECDSA_P256
Definition: bcrypt_internal.h:47
ALG_ID_SHA512
@ ALG_ID_SHA512
Definition: bcrypt_internal.h:31
ALG_ID_ECDH_P256
@ ALG_ID_ECDH_P256
Definition: bcrypt_internal.h:42
ALG_ID_SHA384
@ ALG_ID_SHA384
Definition: bcrypt_internal.h:30
ALG_ID_SHA1
@ ALG_ID_SHA1
Definition: bcrypt_internal.h:32
ALG_ID_DH
@ ALG_ID_DH
Definition: bcrypt_internal.h:41
ALG_ID_RC4
@ ALG_ID_RC4
Definition: bcrypt_internal.h:26
ALG_ID_MD2
@ ALG_ID_MD2
Definition: bcrypt_internal.h:35
ALG_ID_ECDSA_P384
@ ALG_ID_ECDSA_P384
Definition: bcrypt_internal.h:48
ALG_ID_SHA256
@ ALG_ID_SHA256
Definition: bcrypt_internal.h:29
ALG_ID_MD4
@ ALG_ID_MD4
Definition: bcrypt_internal.h:34
ALG_ID_ECDH_P384
@ ALG_ID_ECDH_P384
Definition: bcrypt_internal.h:43
ALG_ID_AES
@ ALG_ID_AES
Definition: bcrypt_internal.h:25
ALG_ID_MD5
@ ALG_ID_MD5
Definition: bcrypt_internal.h:33
KEY_EXPORT_FLAG_PUBLIC
#define KEY_EXPORT_FLAG_PUBLIC
Definition: bcrypt_internal.h:209
reverse_bytes
static void reverse_bytes(UCHAR *buf, ULONG len)
Definition: bcrypt_main.c:2576
mbedtls_mpi_read_string
int mbedtls_mpi_read_string(mbedtls_mpi *X, int radix, const char *s)
Import an MPI from an ASCII string.
mbedtls_mpi_sub_int
int mbedtls_mpi_sub_int(mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b)
Perform a signed subtraction of an MPI and an integer: X = A - b.
mbedtls_mpi_is_prime_ext
int mbedtls_mpi_is_prime_ext(const mbedtls_mpi *X, int rounds, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
Miller-Rabin primality test.
mbedtls_mpi_copy
int mbedtls_mpi_copy(mbedtls_mpi *X, const mbedtls_mpi *Y)
Make a copy of an MPI.
MBEDTLS_MPI_GEN_PRIME_FLAG_DH
@ MBEDTLS_MPI_GEN_PRIME_FLAG_DH
Definition: bignum.h:967
mbedtls_mpi_size
size_t mbedtls_mpi_size(const mbedtls_mpi *X)
Return the total size of an MPI value in bytes.
mbedtls_mpi_lset
int mbedtls_mpi_lset(mbedtls_mpi *X, mbedtls_mpi_sint z)
Store integer value in MPI.
mbedtls_mpi_read_binary
int mbedtls_mpi_read_binary(mbedtls_mpi *X, const unsigned char *buf, size_t buflen)
Import an MPI from unsigned big endian binary data.
mbedtls_mpi_cmp_mpi
int mbedtls_mpi_cmp_mpi(const mbedtls_mpi *X, const mbedtls_mpi *Y)
Compare two MPIs.
mbedtls_mpi_div_int
int mbedtls_mpi_div_int(mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A, mbedtls_mpi_sint b)
Perform a division with remainder of an MPI by an integer: A = Q * b + R.
mbedtls_mpi_gen_prime
int mbedtls_mpi_gen_prime(mbedtls_mpi *X, size_t nbits, int flags, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
Generate a prime number.
mbedtls_mpi_init
void mbedtls_mpi_init(mbedtls_mpi *X)
Initialize an MPI context.
mbedtls_mpi_free
void mbedtls_mpi_free(mbedtls_mpi *X)
This function frees the components of an MPI context.
mbedtls_mpi_write_binary
int mbedtls_mpi_write_binary(const mbedtls_mpi *X, unsigned char *buf, size_t buflen)
Export an MPI into unsigned big endian binary data of fixed size.
mbedtls_mpi_cmp_int
int mbedtls_mpi_cmp_int(const mbedtls_mpi *X, mbedtls_mpi_sint z)
Compare an MPI with an integer.
G
#define G(r, i, a, b, c, d)
Definition: blake2b-ref.c:117
cipher.h
This file contains an abstraction interface for use with the cipher primitives provided by the librar...
mbedtls_cipher_setup
int mbedtls_cipher_setup(mbedtls_cipher_context_t *ctx, const mbedtls_cipher_info_t *cipher_info)
This function initializes and fills the cipher-context structure with the appropriate values....
mbedtls_cipher_type_t
mbedtls_cipher_type_t
Supported {cipher type, cipher mode} pairs.
Definition: cipher.h:129
MBEDTLS_CIPHER_DES_EDE3_CBC
@ MBEDTLS_CIPHER_DES_EDE3_CBC
Definition: cipher.h:172
MBEDTLS_CIPHER_AES_128_CBC
@ MBEDTLS_CIPHER_AES_128_CBC
Definition: cipher.h:135
MBEDTLS_CIPHER_AES_192_GCM
@ MBEDTLS_CIPHER_AES_192_GCM
Definition: cipher.h:150
MBEDTLS_CIPHER_AES_256_GCM
@ MBEDTLS_CIPHER_AES_256_GCM
Definition: cipher.h:151
MBEDTLS_CIPHER_AES_128_GCM
@ MBEDTLS_CIPHER_AES_128_GCM
Definition: cipher.h:149
MBEDTLS_CIPHER_NONE
@ MBEDTLS_CIPHER_NONE
Definition: cipher.h:130
MBEDTLS_CIPHER_AES_192_CBC
@ MBEDTLS_CIPHER_AES_192_CBC
Definition: cipher.h:136
MBEDTLS_CIPHER_AES_256_CBC
@ MBEDTLS_CIPHER_AES_256_CBC
Definition: cipher.h:137
MBEDTLS_CIPHER_ARC4_128
@ MBEDTLS_CIPHER_ARC4_128
Definition: cipher.h:177
MBEDTLS_CIPHER_DES_EDE3_ECB
@ MBEDTLS_CIPHER_DES_EDE3_ECB
Definition: cipher.h:171
mbedtls_cipher_setkey
int mbedtls_cipher_setkey(mbedtls_cipher_context_t *ctx, const unsigned char *key, int key_bitlen, const mbedtls_operation_t operation)
This function sets the key to use with the given context.
mbedtls_cipher_set_iv
int mbedtls_cipher_set_iv(mbedtls_cipher_context_t *ctx, const unsigned char *iv, size_t iv_len)
This function sets the initialization vector (IV) or nonce.
MBEDTLS_PADDING_NONE
@ MBEDTLS_PADDING_NONE
Definition: cipher.h:232
mbedtls_cipher_finish
int mbedtls_cipher_finish(mbedtls_cipher_context_t *ctx, unsigned char *output, size_t *olen)
The generic cipher finalization function. If data still needs to be flushed from an incomplete block,...
MBEDTLS_ERR_CIPHER_AUTH_FAILED
#define MBEDTLS_ERR_CIPHER_AUTH_FAILED
Definition: cipher.h:89
mbedtls_cipher_init
void mbedtls_cipher_init(mbedtls_cipher_context_t *ctx)
This function initializes a cipher_context as NONE.
mbedtls_cipher_update_ad
int mbedtls_cipher_update_ad(mbedtls_cipher_context_t *ctx, const unsigned char *ad, size_t ad_len)
This function adds additional data for AEAD ciphers. Currently supported with GCM and ChaCha20+Poly13...
mbedtls_cipher_write_tag
int mbedtls_cipher_write_tag(mbedtls_cipher_context_t *ctx, unsigned char *tag, size_t tag_len)
This function writes a tag for AEAD ciphers. Currently supported with GCM and ChaCha20+Poly1305....
mbedtls_cipher_get_operation
static mbedtls_operation_t mbedtls_cipher_get_operation(const mbedtls_cipher_context_t *ctx)
This function returns the operation of the given cipher.
Definition: cipher.h:575
mbedtls_cipher_free
void mbedtls_cipher_free(mbedtls_cipher_context_t *ctx)
This function frees and clears the cipher-specific context of ctx. Freeing ctx itself remains the res...
mbedtls_cipher_update
int mbedtls_cipher_update(mbedtls_cipher_context_t *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen)
The generic cipher update function. It encrypts or decrypts using the given cipher context....
mbedtls_operation_t
mbedtls_operation_t
Definition: cipher.h:236
MBEDTLS_DECRYPT
@ MBEDTLS_DECRYPT
Definition: cipher.h:238
MBEDTLS_ENCRYPT
@ MBEDTLS_ENCRYPT
Definition: cipher.h:239
mbedtls_cipher_check_tag
int mbedtls_cipher_check_tag(mbedtls_cipher_context_t *ctx, const unsigned char *tag, size_t tag_len)
This function checks the tag for AEAD ciphers. Currently supported with GCM and ChaCha20+Poly1305....
mbedtls_cipher_set_padding_mode
int mbedtls_cipher_set_padding_mode(mbedtls_cipher_context_t *ctx, mbedtls_cipher_padding_t mode)
This function sets the padding mode, for cipher modes that use padding.
rsa_context
#define rsa_context
Definition: compat-1.3.h:2236
ctr_drbg.h
This file contains definitions and functions for the CTR_DRBG pseudorandom generator.
STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40
STATUS_NO_MEMORY
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
free
#define free
Definition: debug_ros.c:5
malloc
#define malloc
Definition: debug_ros.c:4
dhm.h
This file contains Diffie-Hellman-Merkle (DHM) key exchange definitions and functions.
mbedtls_dhm_free
void mbedtls_dhm_free(mbedtls_dhm_context *ctx)
This function frees and clears the components of a DHM context.
mbedtls_dhm_init
void mbedtls_dhm_init(mbedtls_dhm_context *ctx)
This function initializes the DHM context.
mbedtls_dhm_calc_secret
int mbedtls_dhm_calc_secret(mbedtls_dhm_context *ctx, unsigned char *output, size_t output_size, size_t *olen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
This function derives and exports the shared secret (G^Y)^X mod P.
mbedtls_dhm_make_params
int mbedtls_dhm_make_params(mbedtls_dhm_context *ctx, int x_size, unsigned char *output, size_t *olen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
This function generates a DHM key pair and exports its public part together with the DHM parameters i...
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
Y
#define Y(I)
P
#define P(row, col)
pubkey
static const WCHAR pubkey[]
Definition: asmname.c:68
process_detach
static void process_detach(void)
Definition: main.c:94
wcscmp
_ACRTIMP int __cdecl wcscmp(const wchar_t *, const wchar_t *)
Definition: wcs.c:1977
ret
return ret
Definition: mutex.c:147
mbedtls_dsa_set_group
int mbedtls_dsa_set_group(mbedtls_dsa_context *ctx, const mbedtls_mpi *P, const mbedtls_mpi *Q, const mbedtls_mpi *G)
This function sets the DSA group parameters.
mbedtls_dsa_pubkey_from_privkey
int mbedtls_dsa_pubkey_from_privkey(mbedtls_dsa_context *ctx)
This function derived public key from private key.
mbedtls_dsa_verify
int mbedtls_dsa_verify(mbedtls_dsa_context *ctx, const unsigned char *hash, size_t hlen, const unsigned char *sig, size_t slen)
This function reads and verifies a DSA signature.
mbedtls_dsa_check_pubkey
int mbedtls_dsa_check_pubkey(const mbedtls_dsa_context *ctx)
This function checks if the public key is valid.
mbedtls_dsa_sign
int mbedtls_dsa_sign(mbedtls_dsa_context *ctx, const unsigned char *hash, size_t hlen, unsigned char *sig, size_t *slen, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
This function computes the DSA signature of a message hash.
mbedtls_dsa_init
void mbedtls_dsa_init(mbedtls_dsa_context *ctx)
This function initializes a DSA context.
mbedtls_dsa_check_privkey
int mbedtls_dsa_check_privkey(const mbedtls_dsa_context *ctx)
This function checks if the private key is valid.
mbedtls_dsa_genkey
int mbedtls_dsa_genkey(mbedtls_dsa_context *ctx, size_t group_size, size_t modulus_size, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
This function generates a DSA keypair.
mbedtls_dsa_check_pqg
int mbedtls_dsa_check_pqg(const mbedtls_mpi *P, const mbedtls_mpi *Q, const mbedtls_mpi *G)
This function checks if the DSA group parameters are valid.
mbedtls_dsa_free
void mbedtls_dsa_free(mbedtls_dsa_context *ctx)
This function frees a DSA context.
LOAD_FUNCPTR
#define LOAD_FUNCPTR(f)
ecdh.h
This file contains ECDH definitions and functions.
mbedtls_ecdh_free
void mbedtls_ecdh_free(mbedtls_ecdh_context *ctx)
This function frees a context.
mbedtls_ecdh_init
void mbedtls_ecdh_init(mbedtls_ecdh_context *ctx)
This function initializes an ECDH context.
mbedtls_ecdh_compute_shared
int mbedtls_ecdh_compute_shared(mbedtls_ecp_group *grp, mbedtls_mpi *z, const mbedtls_ecp_point *Q, const mbedtls_mpi *d, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
This function computes the shared secret.
entropy.h
Entropy accumulator implementation.
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
start
GLuint start
Definition: gl.h:1545
s
GLdouble s
Definition: gl.h:2039
end
GLuint GLuint end
Definition: gl.h:1545
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
q
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
size
GLsizeiptr size
Definition: glext.h:5919
params
GLenum const GLfloat * params
Definition: glext.h:5645
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
dst
GLenum GLenum dst
Definition: glext.h:6340
flags
GLbitfield flags
Definition: glext.h:7161
p
GLfloat GLfloat p
Definition: glext.h:8902
len
GLenum GLsizei len
Definition: glext.h:6722
a
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
input
GLenum GLenum GLenum input
Definition: glext.h:9031
m
const GLfloat * m
Definition: glext.h:10848
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
u
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
mbedtls_asn1_get_mpi
int mbedtls_asn1_get_mpi(unsigned char **p, const unsigned char *end, mbedtls_mpi *X)
Retrieve a MPI value from an integer ASN.1 tag. Updates the pointer to immediately behind the full ta...
MBEDTLS_ASN1_SEQUENCE
#define MBEDTLS_ASN1_SEQUENCE
Definition: asn1.h:104
MBEDTLS_ASN1_INTEGER
#define MBEDTLS_ASN1_INTEGER
Definition: asn1.h:98
MBEDTLS_ASN1_CONSTRUCTED
#define MBEDTLS_ASN1_CONSTRUCTED
Definition: asn1.h:114
mbedtls_asn1_get_len
int mbedtls_asn1_get_len(unsigned char **p, const unsigned char *end, size_t *len)
Get the length of an ASN.1 element. Updates the pointer to immediately behind the length.
mbedtls_asn1_get_tag
int mbedtls_asn1_get_tag(unsigned char **p, const unsigned char *end, size_t *len, int tag)
Get the tag and length of the tag. Check for the requested tag. Updates the pointer to immediately be...
X
#define X(b, s)
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
hdr
char hdr[14]
Definition: iptest.cpp:33
d
#define d
Definition: ke_i.h:81
e
#define e
Definition: ke_i.h:82
a
#define a
Definition: ke_i.h:78
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
wine_dlopen
void * wine_dlopen(const char *filename, int flag, char *error, size_t errorsize)
Definition: loader.c:53
wine_dlclose
int wine_dlclose(void *handle, char *error, size_t errorsize)
Definition: loader.c:58
md.h
This file contains the generic message-digest wrapper.
mbedtls_md_setup
int mbedtls_md_setup(mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac)
This function selects the message digest algorithm to use, and allocates internal structures.
mbedtls_md_type_t
mbedtls_md_type_t
Supported message digests.
Definition: md.h:83
MBEDTLS_MD_SHA512
@ MBEDTLS_MD_SHA512
Definition: md.h:92
MBEDTLS_MD_MD5
@ MBEDTLS_MD_MD5
Definition: md.h:87
MBEDTLS_MD_SHA384
@ MBEDTLS_MD_SHA384
Definition: md.h:91
MBEDTLS_MD_NONE
@ MBEDTLS_MD_NONE
Definition: md.h:84
MBEDTLS_MD_SHA256
@ MBEDTLS_MD_SHA256
Definition: md.h:90
MBEDTLS_MD_SHA1
@ MBEDTLS_MD_SHA1
Definition: md.h:88
MBEDTLS_MD_MD4
@ MBEDTLS_MD_MD4
Definition: md.h:86
MBEDTLS_MD_MD2
@ MBEDTLS_MD_MD2
Definition: md.h:85
mbedtls_md_starts
int mbedtls_md_starts(mbedtls_md_context_t *ctx)
This function starts a message-digest computation.
mbedtls_md_hmac_finish
int mbedtls_md_hmac_finish(mbedtls_md_context_t *ctx, unsigned char *output)
This function finishes the HMAC operation, and writes the result to the output buffer.
mbedtls_md_update
int mbedtls_md_update(mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen)
This function feeds an input buffer into an ongoing message-digest computation.
mbedtls_md_hmac_update
int mbedtls_md_hmac_update(mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen)
This function feeds an input buffer into an ongoing HMAC computation.
mbedtls_md_hmac_starts
int mbedtls_md_hmac_starts(mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen)
This function sets the HMAC key and prepares to authenticate a new message.
mbedtls_md_init
void mbedtls_md_init(mbedtls_md_context_t *ctx)
This function initializes a message-digest context without binding it to a particular message-digest ...
mbedtls_md_finish
int mbedtls_md_finish(mbedtls_md_context_t *ctx, unsigned char *output)
This function finishes the digest operation, and writes the result to the output buffer.
mbedtls_md_get_size
unsigned char mbedtls_md_get_size(const mbedtls_md_info_t *md_info)
This function extracts the message-digest size from the message-digest information structure.
mbedtls_md_free
void mbedtls_md_free(mbedtls_md_context_t *ctx)
This function clears the internal structure of ctx and frees any embedded internal structure,...
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
cipher
static DATA_BLOB cipher
Definition: protectdata.c:34
ret_len
static JOBOBJECTINFOCLASS LPVOID DWORD LPDWORD ret_len
Definition: process.c:81
RTLD_NOW
#define RTLD_NOW
Definition: port.h:100
STATUS_INTERNAL_ERROR
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:559
STATUS_AUTH_TAG_MISMATCH
#define STATUS_AUTH_TAG_MISMATCH
Definition: ntstatus.h:1399
STATUS_DLL_NOT_FOUND
#define STATUS_DLL_NOT_FOUND
Definition: ntstatus.h:639
STATUS_INVALID_SIGNATURE
#define STATUS_INVALID_SIGNATURE
Definition: ntstatus.h:1397
WCHAR
short WCHAR
Definition: pedump.c:58
pk.h
Public Key abstraction layer.
mbedtls_pk_parse_key
int mbedtls_pk_parse_key(mbedtls_pk_context *ctx, const unsigned char *key, size_t keylen, const unsigned char *pwd, size_t pwdlen)
Parse a private key in PEM or DER format.
mbedtls_pk_type_t
mbedtls_pk_type_t
Public key types.
Definition: pk.h:103
MBEDTLS_PK_NONE
@ MBEDTLS_PK_NONE
Definition: pk.h:104
MBEDTLS_PK_ECDSA
@ MBEDTLS_PK_ECDSA
Definition: pk.h:108
MBEDTLS_PK_RSASSA_PSS
@ MBEDTLS_PK_RSASSA_PSS
Definition: pk.h:110
MBEDTLS_PK_RSA
@ MBEDTLS_PK_RSA
Definition: pk.h:105
MBEDTLS_PK_ECKEY_DH
@ MBEDTLS_PK_ECKEY_DH
Definition: pk.h:107
mbedtls_pk_decrypt
int mbedtls_pk_decrypt(mbedtls_pk_context *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen, size_t osize, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
Decrypt message (including padding if relevant).
mbedtls_pk_rsa
static mbedtls_rsa_context * mbedtls_pk_rsa(const mbedtls_pk_context pk)
Definition: pk.h:182
mbedtls_pk_sign
int mbedtls_pk_sign(mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg, const unsigned char *hash, size_t hash_len, unsigned char *sig, size_t *sig_len, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
Make signature, including padding if relevant.
mbedtls_pk_ec
static mbedtls_ecp_keypair * mbedtls_pk_ec(const mbedtls_pk_context pk)
Definition: pk.h:195
mbedtls_pk_setup
int mbedtls_pk_setup(mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info)
Initialize a PK context with the information given and allocates the type-specific PK subcontext.
mbedtls_pk_verify_ext
int mbedtls_pk_verify_ext(mbedtls_pk_type_t type, const void *options, mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg, const unsigned char *hash, size_t hash_len, const unsigned char *sig, size_t sig_len)
Verify signature, with options. (Includes verification of the padding depending on type....
mbedtls_pk_init
void mbedtls_pk_init(mbedtls_pk_context *ctx)
Initialize a mbedtls_pk_context (as NONE).
mbedtls_pk_info_from_type
const mbedtls_pk_info_t * mbedtls_pk_info_from_type(mbedtls_pk_type_t pk_type)
Return information associated with the given PK type.
mbedtls_pk_get_type
mbedtls_pk_type_t mbedtls_pk_get_type(const mbedtls_pk_context *ctx)
Get the key type.
mbedtls_pk_free
void mbedtls_pk_free(mbedtls_pk_context *ctx)
Free the components of a mbedtls_pk_context.
mbedtls_pk_parse_public_key
int mbedtls_pk_parse_public_key(mbedtls_pk_context *ctx, const unsigned char *key, size_t keylen)
Parse a public key in PEM or DER format.
mbedtls_pk_encrypt
int mbedtls_pk_encrypt(mbedtls_pk_context *ctx, const unsigned char *input, size_t ilen, unsigned char *output, size_t *olen, size_t osize, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
Encrypt message (including padding if relevant).
MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE
#define MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE
Definition: pk.h:90
rsa.h
This file provides an API for the RSA public-key cryptosystem.
mbedtls_rsa_complete
int mbedtls_rsa_complete(mbedtls_rsa_context *ctx)
This function completes an RSA context from a set of imported core parameters.
mbedtls_rsa_check_pub_priv
int mbedtls_rsa_check_pub_priv(const mbedtls_rsa_context *pub, const mbedtls_rsa_context *prv)
This function checks a public-private RSA key pair.
mbedtls_rsa_import_raw
int mbedtls_rsa_import_raw(mbedtls_rsa_context *ctx, unsigned char const *N, size_t N_len, unsigned char const *P, size_t P_len, unsigned char const *Q, size_t Q_len, unsigned char const *D, size_t D_len, unsigned char const *E, size_t E_len)
This function imports core RSA parameters, in raw big-endian binary format, into an RSA context.
mbedtls_rsa_gen_key
int mbedtls_rsa_gen_key(mbedtls_rsa_context *ctx, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng, unsigned int nbits, int exponent)
This function generates an RSA keypair.
mbedtls_rsa_export
int mbedtls_rsa_export(const mbedtls_rsa_context *ctx, mbedtls_mpi *N, mbedtls_mpi *P, mbedtls_mpi *Q, mbedtls_mpi *D, mbedtls_mpi *E)
This function exports the core parameters of an RSA key.
mbedtls_rsa_export_raw
int mbedtls_rsa_export_raw(const mbedtls_rsa_context *ctx, unsigned char *N, size_t N_len, unsigned char *P, size_t P_len, unsigned char *Q, size_t Q_len, unsigned char *D, size_t D_len, unsigned char *E, size_t E_len)
This function exports core parameters of an RSA key in raw big-endian binary format.
MBEDTLS_RSA_PKCS_V21
#define MBEDTLS_RSA_PKCS_V21
Definition: rsa.h:98
mbedtls_rsa_export_crt
int mbedtls_rsa_export_crt(const mbedtls_rsa_context *ctx, mbedtls_mpi *DP, mbedtls_mpi *DQ, mbedtls_mpi *QP)
This function exports CRT parameters of a private RSA key.
mbedtls_rsa_check_privkey
int mbedtls_rsa_check_privkey(const mbedtls_rsa_context *ctx)
This function checks if a context contains an RSA private key and perform basic consistency checks.
mbedtls_rsa_check_pubkey
int mbedtls_rsa_check_pubkey(const mbedtls_rsa_context *ctx)
This function checks if a context contains at least an RSA public key.
mbedtls_rsa_set_padding
void mbedtls_rsa_set_padding(mbedtls_rsa_context *ctx, int padding, int hash_id)
This function sets padding for an already initialized RSA context. See mbedtls_rsa_init() for details...
libmbedtls_handle
static void * libmbedtls_handle
Definition: schannel_mbedtls_lazyload.h:23
mbedtls_md_info_from_type
#define mbedtls_md_info_from_type
Definition: schannel_mbedtls_lazyload.h:172
mbedtls_ctr_drbg_seed
#define mbedtls_ctr_drbg_seed
Definition: schannel_mbedtls_lazyload.h:174
mbedtls_ctr_drbg_random
#define mbedtls_ctr_drbg_random
Definition: schannel_mbedtls_lazyload.h:144
mbedtls_entropy_free
#define mbedtls_entropy_free
Definition: schannel_mbedtls_lazyload.h:145
mbedtls_ctr_drbg_init
#define mbedtls_ctr_drbg_init
Definition: schannel_mbedtls_lazyload.h:143
mbedtls_entropy_init
#define mbedtls_entropy_init
Definition: schannel_mbedtls_lazyload.h:147
mbedtls_entropy_func
#define mbedtls_entropy_func
Definition: schannel_mbedtls_lazyload.h:146
mbedtls_cipher_info_from_type
#define mbedtls_cipher_info_from_type
Definition: schannel_mbedtls_lazyload.h:171
MAKE_FUNCPTR
#define MAKE_FUNCPTR(f)
Definition: schannel_mbedtls_lazyload.h:25
mbedtls_ctr_drbg_free
#define mbedtls_ctr_drbg_free
Definition: schannel_mbedtls_lazyload.h:142
MBEDTLS_DSA_C
#define MBEDTLS_DSA_C
Definition: config.h:2382
ecp.h
This file provides an API for Elliptic Curves over GF(P) (ECP).
mbedtls_ecp_point_read_binary
int mbedtls_ecp_point_read_binary(const mbedtls_ecp_group *grp, mbedtls_ecp_point *P, const unsigned char *buf, size_t ilen)
This function imports a point from unsigned binary data.
mbedtls_ecp_gen_key
int mbedtls_ecp_gen_key(mbedtls_ecp_group_id grp_id, mbedtls_ecp_keypair *key, int(*f_rng)(void *, unsigned char *, size_t), void *p_rng)
This function generates an ECP key.
mbedtls_ecp_group_load
int mbedtls_ecp_group_load(mbedtls_ecp_group *grp, mbedtls_ecp_group_id id)
This function sets up an ECP group context from a standardized set of domain parameters.
mbedtls_ecp_copy
int mbedtls_ecp_copy(mbedtls_ecp_point *P, const mbedtls_ecp_point *Q)
This function copies the contents of point Q into point P.
mbedtls_ecp_check_pubkey
int mbedtls_ecp_check_pubkey(const mbedtls_ecp_group *grp, const mbedtls_ecp_point *pt)
This function checks that a point is a valid public key on this curve.
mbedtls_ecp_group_id
mbedtls_ecp_group_id
Definition: ecp.h:103
MBEDTLS_ECP_DP_SECP384R1
@ MBEDTLS_ECP_DP_SECP384R1
Definition: ecp.h:108
MBEDTLS_ECP_DP_NONE
@ MBEDTLS_ECP_DP_NONE
Definition: ecp.h:104
MBEDTLS_ECP_DP_SECP256R1
@ MBEDTLS_ECP_DP_SECP256R1
Definition: ecp.h:107
mbedtls_ecp_point_write_binary
int mbedtls_ecp_point_write_binary(const mbedtls_ecp_group *grp, const mbedtls_ecp_point *P, int format, size_t *olen, unsigned char *buf, size_t buflen)
This function exports a point into unsigned binary data.
SONAME_LIBMBEDTLS
#define SONAME_LIBMBEDTLS
Definition: config.h:1245
memset
#define memset(x, y, z)
Definition: compat.h:39
args
#define args
Definition: format.c:66
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
_BCRYPT_DH_KEY_BLOB
Definition: bcrypt.h:284
_BCRYPT_DH_KEY_BLOB::dwMagic
ULONG dwMagic
Definition: bcrypt.h:285
_BCRYPT_DH_KEY_BLOB::cbKey
ULONG cbKey
Definition: bcrypt.h:286
_BCRYPT_DH_PARAMETER_HEADER
Definition: bcrypt.h:292
_BCRYPT_DH_PARAMETER_HEADER::dwMagic
ULONG dwMagic
Definition: bcrypt.h:294
_BCRYPT_DH_PARAMETER_HEADER::cbKeyLength
ULONG cbKeyLength
Definition: bcrypt.h:295
_BCRYPT_DH_PARAMETER_HEADER::cbLength
ULONG cbLength
Definition: bcrypt.h:293
_BCRYPT_DSA_KEY_BLOB
Definition: bcrypt.h:245
_BCRYPT_DSA_KEY_BLOB::cbKey
ULONG cbKey
Definition: bcrypt.h:247
_BCRYPT_DSA_KEY_BLOB::q
UCHAR q[20]
Definition: bcrypt.h:250
_BCRYPT_ECCKEY_BLOB
Definition: bcrypt.h:198
_BCRYPT_ECCKEY_BLOB::dwMagic
ULONG dwMagic
Definition: bcrypt.h:199
_BCRYPT_ECCKEY_BLOB::cbKey
ULONG cbKey
Definition: bcrypt.h:200
_BCRYPT_OAEP_PADDING_INFO
Definition: bcrypt.h:229
_BCRYPT_OAEP_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:230
_BCRYPT_OAEP_PADDING_INFO::pbLabel
PUCHAR pbLabel
Definition: bcrypt.h:231
_BCRYPT_PKCS1_PADDING_INFO
Definition: bcrypt.h:218
_BCRYPT_PKCS1_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:219
_BCRYPT_PSS_PADDING_INFO
Definition: bcrypt.h:223
_BCRYPT_PSS_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:224
_BCRYPT_RSAKEY_BLOB
Definition: bcrypt.h:208
_BCRYPT_RSAKEY_BLOB::cbPublicExp
ULONG cbPublicExp
Definition: bcrypt.h:211
_BCRYPT_RSAKEY_BLOB::BitLength
ULONG BitLength
Definition: bcrypt.h:210
_BCRYPT_RSAKEY_BLOB::Magic
ULONG Magic
Definition: bcrypt.h:209
_BCRYPT_RSAKEY_BLOB::cbPrime2
ULONG cbPrime2
Definition: bcrypt.h:214
_BCRYPT_RSAKEY_BLOB::cbModulus
ULONG cbModulus
Definition: bcrypt.h:212
_BCRYPT_RSAKEY_BLOB::cbPrime1
ULONG cbPrime1
Definition: bcrypt.h:213
_PUBKEY
Definition: wincrypt.h:157
_PUBKEY::magic
DWORD magic
Definition: wincrypt.h:158
_PUBKEY::bitlen
DWORD bitlen
Definition: wincrypt.h:159
_PUBLICKEYSTRUC
Definition: wincrypt.h:144
_RTL_CRITICAL_SECTION
Definition: rtltypes.h:1477
args
Definition: match.c:390
hash::secret_len
ULONG secret_len
Definition: bcrypt_internal.h:277
hash::alg_id
enum alg_id alg_id
Definition: bcrypt_internal.h:274
hash::flags
ULONG flags
Definition: bcrypt_internal.h:275
hash::secret
UCHAR * secret
Definition: bcrypt_internal.h:276
key_asymmetric_decrypt_params
Definition: bcrypt_internal.h:157
key_asymmetric_derive_key_params
Definition: bcrypt_internal.h:234
key_asymmetric_duplicate_params
Definition: bcrypt_internal.h:181
key_asymmetric_encrypt_params
Definition: bcrypt_internal.h:169
key_asymmetric_export_params
Definition: bcrypt_internal.h:214
key_asymmetric_import_params
Definition: bcrypt_internal.h:226
key_asymmetric_sign_params
Definition: bcrypt_internal.h:187
key_asymmetric_verify_params
Definition: bcrypt_internal.h:199
key_symmetric_decrypt_params
Definition: bcrypt_internal.h:141
key_symmetric_decrypt_params::output_len
ULONG output_len
Definition: bcrypt_internal.h:146
key_symmetric_encrypt_params
Definition: bcrypt_internal.h:132
key_symmetric_encrypt_params::output_len
ULONG output_len
Definition: bcrypt_internal.h:137
key_symmetric_get_tag_params
Definition: bcrypt_internal.h:150
key_symmetric_get_tag_params::len
ULONG len
Definition: bcrypt_internal.h:153
key_symmetric_get_tag_params::key
struct key * key
Definition: bcrypt_internal.h:151
key_symmetric_get_tag_params::tag
UCHAR * tag
Definition: bcrypt_internal.h:152
key_symmetric_set_auth_data_params
Definition: bcrypt_internal.h:122
key_symmetric_set_auth_data_params::auth_data
UCHAR * auth_data
Definition: bcrypt_internal.h:124
key_symmetric_set_auth_data_params::len
ULONG len
Definition: bcrypt_internal.h:125
key_symmetric_set_auth_data_params::key
struct key * key
Definition: bcrypt_internal.h:123
key
Definition: copy.c:22
key::a
struct key_asymmetric a
Definition: bcrypt_internal.h:110
key::alg_id
enum alg_id alg_id
Definition: bcrypt_internal.h:105
key::s
struct key_symmetric s
Definition: bcrypt_internal.h:109
key::u
union key::@320 u
key::private
UINT64 private[PRIVATE_DATA_SIZE]
Definition: bcrypt_internal.h:106
mbedtls_cipher_context_t
Definition: cipher.h:315
mbedtls_cipher_info_t
Definition: cipher.h:273
mbedtls_ctr_drbg_context
The CTR_DRBG context structure.
Definition: ctr_drbg.h:195
mbedtls_dhm_context
The DHM context structure.
Definition: dhm.h:128
mbedtls_dhm_context::X
mbedtls_mpi X
Definition: dhm.h:132
mbedtls_dhm_context::G
mbedtls_mpi G
Definition: dhm.h:131
mbedtls_dhm_context::GY
mbedtls_mpi GY
Definition: dhm.h:134
mbedtls_dhm_context::P
mbedtls_mpi P
Definition: dhm.h:130
mbedtls_dhm_context::len
size_t len
Definition: dhm.h:129
mbedtls_dhm_context::GX
mbedtls_mpi GX
Definition: dhm.h:133
mbedtls_dsa_context
DSA context structure.
Definition: dsa.h:46
mbedtls_dsa_context::X
mbedtls_mpi X
Definition: dsa.h:52
mbedtls_dsa_context::Q
mbedtls_mpi Q
Definition: dsa.h:49
mbedtls_dsa_context::P
mbedtls_mpi P
Definition: dsa.h:48
mbedtls_dsa_context::G
mbedtls_mpi G
Definition: dsa.h:50
mbedtls_dsa_context::Y
mbedtls_mpi Y
Definition: dsa.h:51
mbedtls_ecdh_context
The ECDH context structure.
Definition: ecdh.h:136
mbedtls_ecdh_context::d
mbedtls_mpi d
Definition: ecdh.h:139
mbedtls_ecdh_context::Qp
mbedtls_ecp_point Qp
Definition: ecdh.h:141
mbedtls_ecdh_context::grp
mbedtls_ecp_group grp
Definition: ecdh.h:138
mbedtls_ecdh_context::z
mbedtls_mpi z
Definition: ecdh.h:142
mbedtls_ecp_group
The ECP group structure.
Definition: ecp.h:233
mbedtls_ecp_group::id
mbedtls_ecp_group_id id
Definition: ecp.h:234
mbedtls_ecp_group::P
mbedtls_mpi P
Definition: ecp.h:235
mbedtls_ecp_keypair
The ECP key-pair structure.
Definition: ecp.h:398
mbedtls_ecp_keypair::Q
mbedtls_ecp_point Q
Definition: ecp.h:401
mbedtls_ecp_keypair::d
mbedtls_mpi d
Definition: ecp.h:400
mbedtls_ecp_keypair::grp
mbedtls_ecp_group grp
Definition: ecp.h:399
mbedtls_ecp_point::Z
mbedtls_mpi Z
Definition: ecp.h:153
mbedtls_ecp_point::X
mbedtls_mpi X
Definition: ecp.h:151
mbedtls_ecp_point::Y
mbedtls_mpi Y
Definition: ecp.h:152
mbedtls_entropy_context
Entropy context structure.
Definition: entropy.h:149
mbedtls_md_info_t
Definition: md_internal.h:73
mbedtls_mpi
MPI structure.
Definition: bignum.h:211
mbedtls_pk_context
Public key container.
Definition: pk.h:156
mbedtls_pk_info_t
Definition: pk_internal.h:62
mbedtls_pk_rsassa_pss_options
Options for RSASSA-PSS signature verification. See mbedtls_rsa_rsassa_pss_verify_ext()
Definition: pk.h:118
mbedtls_pk_rsassa_pss_options::expected_salt_len
int expected_salt_len
Definition: pk.h:120
mbedtls_pk_rsassa_pss_options::mgf1_hash_id
mbedtls_md_type_t mgf1_hash_id
Definition: pk.h:119
mbedtls_rsa_context
The RSA context structure.
Definition: rsa.h:126
status
Definition: ps.c:97
InitializeCriticalSection
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:687
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
LeaveCriticalSection
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
EnterCriticalSection
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
DeleteCriticalSection
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
PRIVATEKEYBLOB
#define PRIVATEKEYBLOB
Definition: wincrypt.h:2445
PUBLICKEYBLOB
#define PUBLICKEYBLOB
Definition: wincrypt.h:2444
CALG_DSS_SIGN
#define CALG_DSS_SIGN
Definition: wincrypt.h:2070