Line data Source code
1 : /*
2 : * Public Key abstraction layer: wrapper functions
3 : *
4 : * Copyright The Mbed TLS Contributors
5 : * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
6 : */
7 :
8 : #include "common.h"
9 :
10 : #include "mbedtls/platform_util.h"
11 :
12 : #if defined(MBEDTLS_PK_C)
13 : #include "pk_wrap.h"
14 : #include "pk_internal.h"
15 : #include "mbedtls/error.h"
16 : #include "mbedtls/psa_util.h"
17 :
18 : /* Even if RSA not activated, for the sake of RSA-alt */
19 : #include "mbedtls/rsa.h"
20 :
21 : #if defined(MBEDTLS_ECP_C)
22 : #include "mbedtls/ecp.h"
23 : #endif
24 :
25 : #if defined(MBEDTLS_ECDSA_C)
26 : #include "mbedtls/ecdsa.h"
27 : #endif
28 :
29 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
30 : #include "psa_util_internal.h"
31 : #include "psa/crypto.h"
32 : #include "mbedtls/psa_util.h"
33 :
34 : #if defined(MBEDTLS_RSA_C)
35 : #include "pkwrite.h"
36 : #include "rsa_internal.h"
37 : #endif
38 :
39 : #if defined(MBEDTLS_PK_CAN_ECDSA_SOME)
40 : #include "mbedtls/asn1write.h"
41 : #include "mbedtls/asn1.h"
42 : #endif
43 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
44 :
45 : #include "mbedtls/platform.h"
46 :
47 : #include <limits.h>
48 : #include <stdint.h>
49 : #include <string.h>
50 :
51 : #if defined(MBEDTLS_RSA_C)
52 554 : static int rsa_can_do(mbedtls_pk_type_t type)
53 : {
54 554 : return type == MBEDTLS_PK_RSA ||
55 : type == MBEDTLS_PK_RSASSA_PSS;
56 : }
57 :
58 600 : static size_t rsa_get_bitlen(mbedtls_pk_context *pk)
59 : {
60 600 : const mbedtls_rsa_context *rsa = (const mbedtls_rsa_context *) pk->pk_ctx;
61 600 : return mbedtls_rsa_get_bitlen(rsa);
62 : }
63 :
64 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
65 : static int rsa_verify_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
66 : const unsigned char *hash, size_t hash_len,
67 : const unsigned char *sig, size_t sig_len)
68 : {
69 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
70 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
71 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
72 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
73 : psa_status_t status;
74 : int key_len;
75 : unsigned char buf[MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES];
76 : unsigned char *p = buf + sizeof(buf);
77 : psa_algorithm_t psa_alg_md;
78 : size_t rsa_len = mbedtls_rsa_get_len(rsa);
79 :
80 : #if SIZE_MAX > UINT_MAX
81 : if (md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len) {
82 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
83 : }
84 : #endif
85 :
86 : if (mbedtls_rsa_get_padding_mode(rsa) == MBEDTLS_RSA_PKCS_V21) {
87 : psa_alg_md = PSA_ALG_RSA_PSS(mbedtls_md_psa_alg_from_type(md_alg));
88 : } else {
89 : psa_alg_md = PSA_ALG_RSA_PKCS1V15_SIGN(mbedtls_md_psa_alg_from_type(md_alg));
90 : }
91 :
92 : if (sig_len < rsa_len) {
93 : return MBEDTLS_ERR_RSA_VERIFY_FAILED;
94 : }
95 :
96 : key_len = mbedtls_rsa_write_pubkey(rsa, buf, &p);
97 : if (key_len <= 0) {
98 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
99 : }
100 :
101 : psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
102 : psa_set_key_algorithm(&attributes, psa_alg_md);
103 : psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY);
104 :
105 : status = psa_import_key(&attributes,
106 : buf + sizeof(buf) - key_len, key_len,
107 : &key_id);
108 : if (status != PSA_SUCCESS) {
109 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
110 : goto cleanup;
111 : }
112 :
113 : status = psa_verify_hash(key_id, psa_alg_md, hash, hash_len,
114 : sig, sig_len);
115 : if (status != PSA_SUCCESS) {
116 : ret = PSA_PK_RSA_TO_MBEDTLS_ERR(status);
117 : goto cleanup;
118 : }
119 : ret = 0;
120 :
121 : cleanup:
122 : status = psa_destroy_key(key_id);
123 : if (ret == 0 && status != PSA_SUCCESS) {
124 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
125 : }
126 :
127 : return ret;
128 : }
129 : #else /* MBEDTLS_USE_PSA_CRYPTO */
130 277 : static int rsa_verify_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
131 : const unsigned char *hash, size_t hash_len,
132 : const unsigned char *sig, size_t sig_len)
133 : {
134 277 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
135 277 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
136 277 : size_t rsa_len = mbedtls_rsa_get_len(rsa);
137 :
138 : #if SIZE_MAX > UINT_MAX
139 277 : if (md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len) {
140 0 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
141 : }
142 : #endif
143 :
144 277 : if (sig_len < rsa_len) {
145 0 : return MBEDTLS_ERR_RSA_VERIFY_FAILED;
146 : }
147 :
148 277 : if ((ret = mbedtls_rsa_pkcs1_verify(rsa, md_alg,
149 : (unsigned int) hash_len,
150 : hash, sig)) != 0) {
151 0 : return ret;
152 : }
153 :
154 : /* The buffer contains a valid signature followed by extra data.
155 : * We have a special error code for that so that so that callers can
156 : * use mbedtls_pk_verify() to check "Does the buffer start with a
157 : * valid signature?" and not just "Does the buffer contain a valid
158 : * signature?". */
159 277 : if (sig_len > rsa_len) {
160 0 : return MBEDTLS_ERR_PK_SIG_LEN_MISMATCH;
161 : }
162 :
163 277 : return 0;
164 : }
165 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
166 :
167 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
168 : int mbedtls_pk_psa_rsa_sign_ext(psa_algorithm_t alg,
169 : mbedtls_rsa_context *rsa_ctx,
170 : const unsigned char *hash, size_t hash_len,
171 : unsigned char *sig, size_t sig_size,
172 : size_t *sig_len)
173 : {
174 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
175 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
176 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
177 : psa_status_t status;
178 : int key_len;
179 : unsigned char *buf = NULL;
180 : unsigned char *p;
181 :
182 : buf = mbedtls_calloc(1, MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES);
183 : if (buf == NULL) {
184 : return MBEDTLS_ERR_PK_ALLOC_FAILED;
185 : }
186 : p = buf + MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES;
187 :
188 : *sig_len = mbedtls_rsa_get_len(rsa_ctx);
189 : if (sig_size < *sig_len) {
190 : mbedtls_free(buf);
191 : return MBEDTLS_ERR_PK_BUFFER_TOO_SMALL;
192 : }
193 :
194 : key_len = mbedtls_rsa_write_key(rsa_ctx, buf, &p);
195 : if (key_len <= 0) {
196 : mbedtls_free(buf);
197 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
198 : }
199 : psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
200 : psa_set_key_algorithm(&attributes, alg);
201 : psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR);
202 :
203 : status = psa_import_key(&attributes,
204 : buf + MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES - key_len, key_len,
205 : &key_id);
206 : if (status != PSA_SUCCESS) {
207 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
208 : goto cleanup;
209 : }
210 : status = psa_sign_hash(key_id, alg, hash, hash_len,
211 : sig, sig_size, sig_len);
212 : if (status != PSA_SUCCESS) {
213 : ret = PSA_PK_RSA_TO_MBEDTLS_ERR(status);
214 : goto cleanup;
215 : }
216 :
217 : ret = 0;
218 :
219 : cleanup:
220 : mbedtls_free(buf);
221 : status = psa_destroy_key(key_id);
222 : if (ret == 0 && status != PSA_SUCCESS) {
223 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
224 : }
225 : return ret;
226 : }
227 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
228 :
229 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
230 : static int rsa_sign_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
231 : const unsigned char *hash, size_t hash_len,
232 : unsigned char *sig, size_t sig_size, size_t *sig_len,
233 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
234 : {
235 : ((void) f_rng);
236 : ((void) p_rng);
237 :
238 : psa_algorithm_t psa_md_alg;
239 : psa_md_alg = mbedtls_md_psa_alg_from_type(md_alg);
240 : if (psa_md_alg == 0) {
241 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
242 : }
243 : psa_algorithm_t psa_alg;
244 : if (mbedtls_rsa_get_padding_mode(mbedtls_pk_rsa(*pk)) == MBEDTLS_RSA_PKCS_V21) {
245 : psa_alg = PSA_ALG_RSA_PSS(psa_md_alg);
246 : } else {
247 : psa_alg = PSA_ALG_RSA_PKCS1V15_SIGN(psa_md_alg);
248 : }
249 :
250 : return mbedtls_pk_psa_rsa_sign_ext(psa_alg, pk->pk_ctx, hash, hash_len,
251 : sig, sig_size, sig_len);
252 : }
253 : #else /* MBEDTLS_USE_PSA_CRYPTO */
254 0 : static int rsa_sign_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
255 : const unsigned char *hash, size_t hash_len,
256 : unsigned char *sig, size_t sig_size, size_t *sig_len,
257 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
258 : {
259 0 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
260 :
261 : #if SIZE_MAX > UINT_MAX
262 0 : if (md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len) {
263 0 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
264 : }
265 : #endif
266 :
267 0 : *sig_len = mbedtls_rsa_get_len(rsa);
268 0 : if (sig_size < *sig_len) {
269 0 : return MBEDTLS_ERR_PK_BUFFER_TOO_SMALL;
270 : }
271 :
272 0 : return mbedtls_rsa_pkcs1_sign(rsa, f_rng, p_rng,
273 : md_alg, (unsigned int) hash_len,
274 : hash, sig);
275 : }
276 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
277 :
278 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
279 : static int rsa_decrypt_wrap(mbedtls_pk_context *pk,
280 : const unsigned char *input, size_t ilen,
281 : unsigned char *output, size_t *olen, size_t osize,
282 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
283 : {
284 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
285 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
286 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
287 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
288 : psa_algorithm_t psa_md_alg, decrypt_alg;
289 : psa_status_t status;
290 : int key_len;
291 : unsigned char buf[MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES];
292 : unsigned char *p = buf + sizeof(buf);
293 :
294 : ((void) f_rng);
295 : ((void) p_rng);
296 :
297 : if (ilen != mbedtls_rsa_get_len(rsa)) {
298 : return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
299 : }
300 :
301 : key_len = mbedtls_rsa_write_key(rsa, buf, &p);
302 : if (key_len <= 0) {
303 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
304 : }
305 :
306 : psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR);
307 : psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_DECRYPT);
308 : if (mbedtls_rsa_get_padding_mode(rsa) == MBEDTLS_RSA_PKCS_V21) {
309 : psa_md_alg = mbedtls_md_psa_alg_from_type((mbedtls_md_type_t) mbedtls_rsa_get_md_alg(rsa));
310 : decrypt_alg = PSA_ALG_RSA_OAEP(psa_md_alg);
311 : } else {
312 : decrypt_alg = PSA_ALG_RSA_PKCS1V15_CRYPT;
313 : }
314 : psa_set_key_algorithm(&attributes, decrypt_alg);
315 :
316 : status = psa_import_key(&attributes,
317 : buf + sizeof(buf) - key_len, key_len,
318 : &key_id);
319 : if (status != PSA_SUCCESS) {
320 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
321 : goto cleanup;
322 : }
323 :
324 : status = psa_asymmetric_decrypt(key_id, decrypt_alg,
325 : input, ilen,
326 : NULL, 0,
327 : output, osize, olen);
328 : if (status != PSA_SUCCESS) {
329 : ret = PSA_PK_RSA_TO_MBEDTLS_ERR(status);
330 : goto cleanup;
331 : }
332 :
333 : ret = 0;
334 :
335 : cleanup:
336 : mbedtls_platform_zeroize(buf, sizeof(buf));
337 : status = psa_destroy_key(key_id);
338 : if (ret == 0 && status != PSA_SUCCESS) {
339 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
340 : }
341 :
342 : return ret;
343 : }
344 : #else /* MBEDTLS_USE_PSA_CRYPTO */
345 0 : static int rsa_decrypt_wrap(mbedtls_pk_context *pk,
346 : const unsigned char *input, size_t ilen,
347 : unsigned char *output, size_t *olen, size_t osize,
348 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
349 : {
350 0 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
351 :
352 0 : if (ilen != mbedtls_rsa_get_len(rsa)) {
353 0 : return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
354 : }
355 :
356 0 : return mbedtls_rsa_pkcs1_decrypt(rsa, f_rng, p_rng,
357 : olen, input, output, osize);
358 : }
359 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
360 :
361 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
362 : static int rsa_encrypt_wrap(mbedtls_pk_context *pk,
363 : const unsigned char *input, size_t ilen,
364 : unsigned char *output, size_t *olen, size_t osize,
365 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
366 : {
367 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
368 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
369 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
370 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
371 : psa_algorithm_t psa_md_alg, psa_encrypt_alg;
372 : psa_status_t status;
373 : int key_len;
374 : unsigned char buf[MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES];
375 : unsigned char *p = buf + sizeof(buf);
376 :
377 : ((void) f_rng);
378 : ((void) p_rng);
379 :
380 : if (mbedtls_rsa_get_len(rsa) > osize) {
381 : return MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
382 : }
383 :
384 : key_len = mbedtls_rsa_write_pubkey(rsa, buf, &p);
385 : if (key_len <= 0) {
386 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
387 : }
388 :
389 : psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_ENCRYPT);
390 : if (mbedtls_rsa_get_padding_mode(rsa) == MBEDTLS_RSA_PKCS_V21) {
391 : psa_md_alg = mbedtls_md_psa_alg_from_type((mbedtls_md_type_t) mbedtls_rsa_get_md_alg(rsa));
392 : psa_encrypt_alg = PSA_ALG_RSA_OAEP(psa_md_alg);
393 : } else {
394 : psa_encrypt_alg = PSA_ALG_RSA_PKCS1V15_CRYPT;
395 : }
396 : psa_set_key_algorithm(&attributes, psa_encrypt_alg);
397 : psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY);
398 :
399 : status = psa_import_key(&attributes,
400 : buf + sizeof(buf) - key_len, key_len,
401 : &key_id);
402 : if (status != PSA_SUCCESS) {
403 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
404 : goto cleanup;
405 : }
406 :
407 : status = psa_asymmetric_encrypt(key_id, psa_encrypt_alg,
408 : input, ilen,
409 : NULL, 0,
410 : output, osize, olen);
411 : if (status != PSA_SUCCESS) {
412 : ret = PSA_PK_RSA_TO_MBEDTLS_ERR(status);
413 : goto cleanup;
414 : }
415 :
416 : ret = 0;
417 :
418 : cleanup:
419 : status = psa_destroy_key(key_id);
420 : if (ret == 0 && status != PSA_SUCCESS) {
421 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
422 : }
423 :
424 : return ret;
425 : }
426 : #else /* MBEDTLS_USE_PSA_CRYPTO */
427 0 : static int rsa_encrypt_wrap(mbedtls_pk_context *pk,
428 : const unsigned char *input, size_t ilen,
429 : unsigned char *output, size_t *olen, size_t osize,
430 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
431 : {
432 0 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
433 0 : *olen = mbedtls_rsa_get_len(rsa);
434 :
435 0 : if (*olen > osize) {
436 0 : return MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
437 : }
438 :
439 0 : return mbedtls_rsa_pkcs1_encrypt(rsa, f_rng, p_rng,
440 : ilen, input, output);
441 : }
442 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
443 :
444 0 : static int rsa_check_pair_wrap(mbedtls_pk_context *pub, mbedtls_pk_context *prv,
445 : int (*f_rng)(void *, unsigned char *, size_t),
446 : void *p_rng)
447 : {
448 : (void) f_rng;
449 : (void) p_rng;
450 0 : return mbedtls_rsa_check_pub_priv((const mbedtls_rsa_context *) pub->pk_ctx,
451 0 : (const mbedtls_rsa_context *) prv->pk_ctx);
452 : }
453 :
454 1361 : static void *rsa_alloc_wrap(void)
455 : {
456 1361 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_rsa_context));
457 :
458 1361 : if (ctx != NULL) {
459 1361 : mbedtls_rsa_init((mbedtls_rsa_context *) ctx);
460 : }
461 :
462 1361 : return ctx;
463 : }
464 :
465 1361 : static void rsa_free_wrap(void *ctx)
466 : {
467 1361 : mbedtls_rsa_free((mbedtls_rsa_context *) ctx);
468 1361 : mbedtls_free(ctx);
469 1361 : }
470 :
471 0 : static void rsa_debug(mbedtls_pk_context *pk, mbedtls_pk_debug_item *items)
472 : {
473 : #if defined(MBEDTLS_RSA_ALT)
474 : /* Not supported */
475 : (void) pk;
476 : (void) items;
477 : #else
478 0 : mbedtls_rsa_context *rsa = (mbedtls_rsa_context *) pk->pk_ctx;
479 :
480 0 : items->type = MBEDTLS_PK_DEBUG_MPI;
481 0 : items->name = "rsa.N";
482 0 : items->value = &(rsa->N);
483 :
484 0 : items++;
485 :
486 0 : items->type = MBEDTLS_PK_DEBUG_MPI;
487 0 : items->name = "rsa.E";
488 0 : items->value = &(rsa->E);
489 : #endif
490 0 : }
491 :
492 : const mbedtls_pk_info_t mbedtls_rsa_info = {
493 : .type = MBEDTLS_PK_RSA,
494 : .name = "RSA",
495 : .get_bitlen = rsa_get_bitlen,
496 : .can_do = rsa_can_do,
497 : .verify_func = rsa_verify_wrap,
498 : .sign_func = rsa_sign_wrap,
499 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
500 : .verify_rs_func = NULL,
501 : .sign_rs_func = NULL,
502 : .rs_alloc_func = NULL,
503 : .rs_free_func = NULL,
504 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
505 : .decrypt_func = rsa_decrypt_wrap,
506 : .encrypt_func = rsa_encrypt_wrap,
507 : .check_pair_func = rsa_check_pair_wrap,
508 : .ctx_alloc_func = rsa_alloc_wrap,
509 : .ctx_free_func = rsa_free_wrap,
510 : .debug_func = rsa_debug,
511 : };
512 : #endif /* MBEDTLS_RSA_C */
513 :
514 : #if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
515 : /*
516 : * Generic EC key
517 : */
518 2794 : static int eckey_can_do(mbedtls_pk_type_t type)
519 : {
520 2794 : return type == MBEDTLS_PK_ECKEY ||
521 5588 : type == MBEDTLS_PK_ECKEY_DH ||
522 : type == MBEDTLS_PK_ECDSA;
523 : }
524 :
525 0 : static size_t eckey_get_bitlen(mbedtls_pk_context *pk)
526 : {
527 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
528 : return pk->ec_bits;
529 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
530 0 : mbedtls_ecp_keypair *ecp = (mbedtls_ecp_keypair *) pk->pk_ctx;
531 0 : return ecp->grp.pbits;
532 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
533 : }
534 :
535 : #if defined(MBEDTLS_PK_CAN_ECDSA_VERIFY)
536 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
537 : /* Common helper for ECDSA verify using PSA functions. */
538 : static int ecdsa_verify_psa(unsigned char *key, size_t key_len,
539 : psa_ecc_family_t curve, size_t curve_bits,
540 : const unsigned char *hash, size_t hash_len,
541 : const unsigned char *sig, size_t sig_len)
542 : {
543 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
544 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
545 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
546 : psa_algorithm_t psa_sig_md = PSA_ALG_ECDSA_ANY;
547 : size_t signature_len = PSA_ECDSA_SIGNATURE_SIZE(curve_bits);
548 : size_t converted_sig_len;
549 : unsigned char extracted_sig[PSA_VENDOR_ECDSA_SIGNATURE_MAX_SIZE];
550 : unsigned char *p;
551 : psa_status_t status;
552 :
553 : if (curve == 0) {
554 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
555 : }
556 :
557 : psa_set_key_type(&attributes, PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve));
558 : psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH);
559 : psa_set_key_algorithm(&attributes, psa_sig_md);
560 :
561 : status = psa_import_key(&attributes, key, key_len, &key_id);
562 : if (status != PSA_SUCCESS) {
563 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
564 : goto cleanup;
565 : }
566 :
567 : if (signature_len > sizeof(extracted_sig)) {
568 : ret = MBEDTLS_ERR_PK_BAD_INPUT_DATA;
569 : goto cleanup;
570 : }
571 :
572 : p = (unsigned char *) sig;
573 : ret = mbedtls_ecdsa_der_to_raw(curve_bits, p, sig_len, extracted_sig,
574 : sizeof(extracted_sig), &converted_sig_len);
575 : if (ret != 0) {
576 : goto cleanup;
577 : }
578 :
579 : if (converted_sig_len != signature_len) {
580 : ret = MBEDTLS_ERR_PK_BAD_INPUT_DATA;
581 : goto cleanup;
582 : }
583 :
584 : status = psa_verify_hash(key_id, psa_sig_md, hash, hash_len,
585 : extracted_sig, signature_len);
586 : if (status != PSA_SUCCESS) {
587 : ret = PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
588 : goto cleanup;
589 : }
590 :
591 : ret = 0;
592 :
593 : cleanup:
594 : status = psa_destroy_key(key_id);
595 : if (ret == 0 && status != PSA_SUCCESS) {
596 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
597 : }
598 :
599 : return ret;
600 : }
601 :
602 : static int ecdsa_opaque_verify_wrap(mbedtls_pk_context *pk,
603 : mbedtls_md_type_t md_alg,
604 : const unsigned char *hash, size_t hash_len,
605 : const unsigned char *sig, size_t sig_len)
606 : {
607 : (void) md_alg;
608 : unsigned char key[MBEDTLS_PK_MAX_EC_PUBKEY_RAW_LEN];
609 : size_t key_len;
610 : psa_key_attributes_t key_attr = PSA_KEY_ATTRIBUTES_INIT;
611 : psa_ecc_family_t curve;
612 : size_t curve_bits;
613 : psa_status_t status;
614 :
615 : status = psa_get_key_attributes(pk->priv_id, &key_attr);
616 : if (status != PSA_SUCCESS) {
617 : return PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
618 : }
619 : curve = PSA_KEY_TYPE_ECC_GET_FAMILY(psa_get_key_type(&key_attr));
620 : curve_bits = psa_get_key_bits(&key_attr);
621 : psa_reset_key_attributes(&key_attr);
622 :
623 : status = psa_export_public_key(pk->priv_id, key, sizeof(key), &key_len);
624 : if (status != PSA_SUCCESS) {
625 : return PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
626 : }
627 :
628 : return ecdsa_verify_psa(key, key_len, curve, curve_bits,
629 : hash, hash_len, sig, sig_len);
630 : }
631 :
632 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
633 : static int ecdsa_verify_wrap(mbedtls_pk_context *pk,
634 : mbedtls_md_type_t md_alg,
635 : const unsigned char *hash, size_t hash_len,
636 : const unsigned char *sig, size_t sig_len)
637 : {
638 : (void) md_alg;
639 : psa_ecc_family_t curve = pk->ec_family;
640 : size_t curve_bits = pk->ec_bits;
641 :
642 : return ecdsa_verify_psa(pk->pub_raw, pk->pub_raw_len, curve, curve_bits,
643 : hash, hash_len, sig, sig_len);
644 : }
645 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
646 : static int ecdsa_verify_wrap(mbedtls_pk_context *pk,
647 : mbedtls_md_type_t md_alg,
648 : const unsigned char *hash, size_t hash_len,
649 : const unsigned char *sig, size_t sig_len)
650 : {
651 : (void) md_alg;
652 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
653 : mbedtls_ecp_keypair *ctx = pk->pk_ctx;
654 : unsigned char key[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH];
655 : size_t key_len;
656 : size_t curve_bits;
657 : psa_ecc_family_t curve = mbedtls_ecc_group_to_psa(ctx->grp.id, &curve_bits);
658 :
659 : ret = mbedtls_ecp_point_write_binary(&ctx->grp, &ctx->Q,
660 : MBEDTLS_ECP_PF_UNCOMPRESSED,
661 : &key_len, key, sizeof(key));
662 : if (ret != 0) {
663 : return ret;
664 : }
665 :
666 : return ecdsa_verify_psa(key, key_len, curve, curve_bits,
667 : hash, hash_len, sig, sig_len);
668 : }
669 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
670 : #else /* MBEDTLS_USE_PSA_CRYPTO */
671 1391 : static int ecdsa_verify_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
672 : const unsigned char *hash, size_t hash_len,
673 : const unsigned char *sig, size_t sig_len)
674 : {
675 1391 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
676 : ((void) md_alg);
677 :
678 1391 : ret = mbedtls_ecdsa_read_signature((mbedtls_ecdsa_context *) pk->pk_ctx,
679 : hash, hash_len, sig, sig_len);
680 :
681 1391 : if (ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH) {
682 0 : return MBEDTLS_ERR_PK_SIG_LEN_MISMATCH;
683 : }
684 :
685 1391 : return ret;
686 : }
687 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
688 : #endif /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
689 :
690 : #if defined(MBEDTLS_PK_CAN_ECDSA_SIGN)
691 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
692 : /* Common helper for ECDSA sign using PSA functions.
693 : * Instead of extracting key's properties in order to check which kind of ECDSA
694 : * signature it supports, we try both deterministic and non-deterministic.
695 : */
696 : static int ecdsa_sign_psa(mbedtls_svc_key_id_t key_id, mbedtls_md_type_t md_alg,
697 : const unsigned char *hash, size_t hash_len,
698 : unsigned char *sig, size_t sig_size, size_t *sig_len)
699 : {
700 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
701 : psa_status_t status;
702 : psa_key_attributes_t key_attr = PSA_KEY_ATTRIBUTES_INIT;
703 : size_t key_bits = 0;
704 :
705 : status = psa_get_key_attributes(key_id, &key_attr);
706 : if (status != PSA_SUCCESS) {
707 : return PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
708 : }
709 : key_bits = psa_get_key_bits(&key_attr);
710 : psa_reset_key_attributes(&key_attr);
711 :
712 : status = psa_sign_hash(key_id,
713 : PSA_ALG_DETERMINISTIC_ECDSA(mbedtls_md_psa_alg_from_type(md_alg)),
714 : hash, hash_len, sig, sig_size, sig_len);
715 : if (status == PSA_SUCCESS) {
716 : goto done;
717 : } else if (status != PSA_ERROR_NOT_PERMITTED) {
718 : return PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
719 : }
720 :
721 : status = psa_sign_hash(key_id,
722 : PSA_ALG_ECDSA(mbedtls_md_psa_alg_from_type(md_alg)),
723 : hash, hash_len, sig, sig_size, sig_len);
724 : if (status != PSA_SUCCESS) {
725 : return PSA_PK_ECDSA_TO_MBEDTLS_ERR(status);
726 : }
727 :
728 : done:
729 : ret = mbedtls_ecdsa_raw_to_der(key_bits, sig, *sig_len, sig, sig_size, sig_len);
730 :
731 : return ret;
732 : }
733 :
734 : static int ecdsa_opaque_sign_wrap(mbedtls_pk_context *pk,
735 : mbedtls_md_type_t md_alg,
736 : const unsigned char *hash, size_t hash_len,
737 : unsigned char *sig, size_t sig_size,
738 : size_t *sig_len,
739 : int (*f_rng)(void *, unsigned char *, size_t),
740 : void *p_rng)
741 : {
742 : ((void) f_rng);
743 : ((void) p_rng);
744 :
745 : return ecdsa_sign_psa(pk->priv_id, md_alg, hash, hash_len, sig, sig_size,
746 : sig_len);
747 : }
748 :
749 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
750 : /* When PK_USE_PSA_EC_DATA is defined opaque and non-opaque keys end up
751 : * using the same function. */
752 : #define ecdsa_sign_wrap ecdsa_opaque_sign_wrap
753 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
754 : static int ecdsa_sign_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
755 : const unsigned char *hash, size_t hash_len,
756 : unsigned char *sig, size_t sig_size, size_t *sig_len,
757 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
758 : {
759 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
760 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
761 : psa_status_t status;
762 : mbedtls_ecp_keypair *ctx = pk->pk_ctx;
763 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
764 : unsigned char buf[MBEDTLS_PSA_MAX_EC_KEY_PAIR_LENGTH];
765 : size_t curve_bits;
766 : psa_ecc_family_t curve =
767 : mbedtls_ecc_group_to_psa(ctx->grp.id, &curve_bits);
768 : size_t key_len = PSA_BITS_TO_BYTES(curve_bits);
769 : psa_algorithm_t psa_hash = mbedtls_md_psa_alg_from_type(md_alg);
770 : psa_algorithm_t psa_sig_md = MBEDTLS_PK_PSA_ALG_ECDSA_MAYBE_DET(psa_hash);
771 : ((void) f_rng);
772 : ((void) p_rng);
773 :
774 : if (curve == 0) {
775 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
776 : }
777 :
778 : if (key_len > sizeof(buf)) {
779 : return MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
780 : }
781 : ret = mbedtls_mpi_write_binary(&ctx->d, buf, key_len);
782 : if (ret != 0) {
783 : goto cleanup;
784 : }
785 :
786 : psa_set_key_type(&attributes, PSA_KEY_TYPE_ECC_KEY_PAIR(curve));
787 : psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH);
788 : psa_set_key_algorithm(&attributes, psa_sig_md);
789 :
790 : status = psa_import_key(&attributes, buf, key_len, &key_id);
791 : if (status != PSA_SUCCESS) {
792 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
793 : goto cleanup;
794 : }
795 :
796 : ret = ecdsa_sign_psa(key_id, md_alg, hash, hash_len, sig, sig_size, sig_len);
797 :
798 : cleanup:
799 : mbedtls_platform_zeroize(buf, sizeof(buf));
800 : status = psa_destroy_key(key_id);
801 : if (ret == 0 && status != PSA_SUCCESS) {
802 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
803 : }
804 :
805 : return ret;
806 : }
807 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
808 : #else /* MBEDTLS_USE_PSA_CRYPTO */
809 6 : static int ecdsa_sign_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
810 : const unsigned char *hash, size_t hash_len,
811 : unsigned char *sig, size_t sig_size, size_t *sig_len,
812 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
813 : {
814 6 : return mbedtls_ecdsa_write_signature((mbedtls_ecdsa_context *) pk->pk_ctx,
815 : md_alg, hash, hash_len,
816 : sig, sig_size, sig_len,
817 : f_rng, p_rng);
818 : }
819 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
820 : #endif /* MBEDTLS_PK_CAN_ECDSA_SIGN */
821 :
822 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
823 : /* Forward declarations */
824 : static int ecdsa_verify_rs_wrap(mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
825 : const unsigned char *hash, size_t hash_len,
826 : const unsigned char *sig, size_t sig_len,
827 : void *rs_ctx);
828 :
829 : static int ecdsa_sign_rs_wrap(mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg,
830 : const unsigned char *hash, size_t hash_len,
831 : unsigned char *sig, size_t sig_size, size_t *sig_len,
832 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
833 : void *rs_ctx);
834 :
835 : /*
836 : * Restart context for ECDSA operations with ECKEY context
837 : *
838 : * We need to store an actual ECDSA context, as we need to pass the same to
839 : * the underlying ecdsa function, so we can't create it on the fly every time.
840 : */
841 : typedef struct {
842 : mbedtls_ecdsa_restart_ctx ecdsa_rs;
843 : mbedtls_ecdsa_context ecdsa_ctx;
844 : } eckey_restart_ctx;
845 :
846 0 : static void *eckey_rs_alloc(void)
847 : {
848 : eckey_restart_ctx *rs_ctx;
849 :
850 0 : void *ctx = mbedtls_calloc(1, sizeof(eckey_restart_ctx));
851 :
852 0 : if (ctx != NULL) {
853 0 : rs_ctx = ctx;
854 0 : mbedtls_ecdsa_restart_init(&rs_ctx->ecdsa_rs);
855 0 : mbedtls_ecdsa_init(&rs_ctx->ecdsa_ctx);
856 : }
857 :
858 0 : return ctx;
859 : }
860 :
861 0 : static void eckey_rs_free(void *ctx)
862 : {
863 : eckey_restart_ctx *rs_ctx;
864 :
865 0 : if (ctx == NULL) {
866 0 : return;
867 : }
868 :
869 0 : rs_ctx = ctx;
870 0 : mbedtls_ecdsa_restart_free(&rs_ctx->ecdsa_rs);
871 0 : mbedtls_ecdsa_free(&rs_ctx->ecdsa_ctx);
872 :
873 0 : mbedtls_free(ctx);
874 : }
875 :
876 0 : static int eckey_verify_rs_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
877 : const unsigned char *hash, size_t hash_len,
878 : const unsigned char *sig, size_t sig_len,
879 : void *rs_ctx)
880 : {
881 0 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
882 0 : eckey_restart_ctx *rs = rs_ctx;
883 :
884 : /* Should never happen */
885 0 : if (rs == NULL) {
886 0 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
887 : }
888 :
889 : /* set up our own sub-context if needed (that is, on first run) */
890 0 : if (rs->ecdsa_ctx.grp.pbits == 0) {
891 0 : MBEDTLS_MPI_CHK(mbedtls_ecdsa_from_keypair(&rs->ecdsa_ctx, pk->pk_ctx));
892 : }
893 :
894 0 : MBEDTLS_MPI_CHK(ecdsa_verify_rs_wrap(pk,
895 : md_alg, hash, hash_len,
896 : sig, sig_len, &rs->ecdsa_rs));
897 :
898 0 : cleanup:
899 0 : return ret;
900 : }
901 :
902 0 : static int eckey_sign_rs_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
903 : const unsigned char *hash, size_t hash_len,
904 : unsigned char *sig, size_t sig_size, size_t *sig_len,
905 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
906 : void *rs_ctx)
907 : {
908 0 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
909 0 : eckey_restart_ctx *rs = rs_ctx;
910 :
911 : /* Should never happen */
912 0 : if (rs == NULL) {
913 0 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
914 : }
915 :
916 : /* set up our own sub-context if needed (that is, on first run) */
917 0 : if (rs->ecdsa_ctx.grp.pbits == 0) {
918 0 : MBEDTLS_MPI_CHK(mbedtls_ecdsa_from_keypair(&rs->ecdsa_ctx, pk->pk_ctx));
919 : }
920 :
921 0 : MBEDTLS_MPI_CHK(ecdsa_sign_rs_wrap(pk, md_alg,
922 : hash, hash_len, sig, sig_size, sig_len,
923 : f_rng, p_rng, &rs->ecdsa_rs));
924 :
925 0 : cleanup:
926 0 : return ret;
927 : }
928 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
929 :
930 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
931 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
932 : static int eckey_check_pair_psa(mbedtls_pk_context *pub, mbedtls_pk_context *prv)
933 : {
934 : psa_status_t status;
935 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
936 : uint8_t prv_key_buf[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH];
937 : size_t prv_key_len;
938 : mbedtls_svc_key_id_t key_id = prv->priv_id;
939 :
940 : status = psa_export_public_key(key_id, prv_key_buf, sizeof(prv_key_buf),
941 : &prv_key_len);
942 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
943 : if (ret != 0) {
944 : return ret;
945 : }
946 :
947 : if (memcmp(prv_key_buf, pub->pub_raw, pub->pub_raw_len) != 0) {
948 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
949 : }
950 :
951 : return 0;
952 : }
953 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
954 : static int eckey_check_pair_psa(mbedtls_pk_context *pub, mbedtls_pk_context *prv)
955 : {
956 : psa_status_t status;
957 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
958 : uint8_t prv_key_buf[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH];
959 : size_t prv_key_len;
960 : psa_status_t destruction_status;
961 : mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT;
962 : psa_key_attributes_t key_attr = PSA_KEY_ATTRIBUTES_INIT;
963 : uint8_t pub_key_buf[MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH];
964 : size_t pub_key_len;
965 : size_t curve_bits;
966 : const psa_ecc_family_t curve =
967 : mbedtls_ecc_group_to_psa(mbedtls_pk_ec_ro(*prv)->grp.id, &curve_bits);
968 : const size_t curve_bytes = PSA_BITS_TO_BYTES(curve_bits);
969 :
970 : if (curve == 0) {
971 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
972 : }
973 :
974 : psa_set_key_type(&key_attr, PSA_KEY_TYPE_ECC_KEY_PAIR(curve));
975 : psa_set_key_usage_flags(&key_attr, PSA_KEY_USAGE_EXPORT);
976 :
977 : ret = mbedtls_mpi_write_binary(&mbedtls_pk_ec_ro(*prv)->d,
978 : prv_key_buf, curve_bytes);
979 : if (ret != 0) {
980 : mbedtls_platform_zeroize(prv_key_buf, sizeof(prv_key_buf));
981 : return ret;
982 : }
983 :
984 : status = psa_import_key(&key_attr, prv_key_buf, curve_bytes, &key_id);
985 : mbedtls_platform_zeroize(prv_key_buf, sizeof(prv_key_buf));
986 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
987 : if (ret != 0) {
988 : return ret;
989 : }
990 :
991 : // From now on prv_key_buf is used to store the public key of prv.
992 : status = psa_export_public_key(key_id, prv_key_buf, sizeof(prv_key_buf),
993 : &prv_key_len);
994 : ret = PSA_PK_TO_MBEDTLS_ERR(status);
995 : destruction_status = psa_destroy_key(key_id);
996 : if (ret != 0) {
997 : return ret;
998 : } else if (destruction_status != PSA_SUCCESS) {
999 : return PSA_PK_TO_MBEDTLS_ERR(destruction_status);
1000 : }
1001 :
1002 : ret = mbedtls_ecp_point_write_binary(&mbedtls_pk_ec_rw(*pub)->grp,
1003 : &mbedtls_pk_ec_rw(*pub)->Q,
1004 : MBEDTLS_ECP_PF_UNCOMPRESSED,
1005 : &pub_key_len, pub_key_buf,
1006 : sizeof(pub_key_buf));
1007 : if (ret != 0) {
1008 : return ret;
1009 : }
1010 :
1011 : if (memcmp(prv_key_buf, pub_key_buf, curve_bytes) != 0) {
1012 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
1013 : }
1014 :
1015 : return 0;
1016 : }
1017 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1018 :
1019 : static int eckey_check_pair_wrap(mbedtls_pk_context *pub, mbedtls_pk_context *prv,
1020 : int (*f_rng)(void *, unsigned char *, size_t),
1021 : void *p_rng)
1022 : {
1023 : (void) f_rng;
1024 : (void) p_rng;
1025 : return eckey_check_pair_psa(pub, prv);
1026 : }
1027 : #else /* MBEDTLS_USE_PSA_CRYPTO */
1028 0 : static int eckey_check_pair_wrap(mbedtls_pk_context *pub, mbedtls_pk_context *prv,
1029 : int (*f_rng)(void *, unsigned char *, size_t),
1030 : void *p_rng)
1031 : {
1032 0 : return mbedtls_ecp_check_pub_priv((const mbedtls_ecp_keypair *) pub->pk_ctx,
1033 0 : (const mbedtls_ecp_keypair *) prv->pk_ctx,
1034 : f_rng, p_rng);
1035 : }
1036 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
1037 :
1038 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
1039 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
1040 : /* When PK_USE_PSA_EC_DATA is defined opaque and non-opaque keys end up
1041 : * using the same function. */
1042 : #define ecdsa_opaque_check_pair_wrap eckey_check_pair_wrap
1043 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
1044 : static int ecdsa_opaque_check_pair_wrap(mbedtls_pk_context *pub,
1045 : mbedtls_pk_context *prv,
1046 : int (*f_rng)(void *, unsigned char *, size_t),
1047 : void *p_rng)
1048 : {
1049 : psa_status_t status;
1050 : uint8_t exp_pub_key[MBEDTLS_PK_MAX_EC_PUBKEY_RAW_LEN];
1051 : size_t exp_pub_key_len = 0;
1052 : uint8_t pub_key[MBEDTLS_PK_MAX_EC_PUBKEY_RAW_LEN];
1053 : size_t pub_key_len = 0;
1054 : int ret;
1055 : (void) f_rng;
1056 : (void) p_rng;
1057 :
1058 : status = psa_export_public_key(prv->priv_id, exp_pub_key, sizeof(exp_pub_key),
1059 : &exp_pub_key_len);
1060 : if (status != PSA_SUCCESS) {
1061 : ret = psa_pk_status_to_mbedtls(status);
1062 : return ret;
1063 : }
1064 : ret = mbedtls_ecp_point_write_binary(&(mbedtls_pk_ec_ro(*pub)->grp),
1065 : &(mbedtls_pk_ec_ro(*pub)->Q),
1066 : MBEDTLS_ECP_PF_UNCOMPRESSED,
1067 : &pub_key_len, pub_key, sizeof(pub_key));
1068 : if (ret != 0) {
1069 : return ret;
1070 : }
1071 : if ((exp_pub_key_len != pub_key_len) ||
1072 : memcmp(exp_pub_key, pub_key, exp_pub_key_len)) {
1073 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
1074 : }
1075 : return 0;
1076 : }
1077 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1078 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
1079 :
1080 : #if !defined(MBEDTLS_PK_USE_PSA_EC_DATA)
1081 11656 : static void *eckey_alloc_wrap(void)
1082 : {
1083 11656 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_ecp_keypair));
1084 :
1085 11656 : if (ctx != NULL) {
1086 11656 : mbedtls_ecp_keypair_init(ctx);
1087 : }
1088 :
1089 11656 : return ctx;
1090 : }
1091 :
1092 11650 : static void eckey_free_wrap(void *ctx)
1093 : {
1094 11650 : mbedtls_ecp_keypair_free((mbedtls_ecp_keypair *) ctx);
1095 11650 : mbedtls_free(ctx);
1096 11650 : }
1097 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1098 :
1099 0 : static void eckey_debug(mbedtls_pk_context *pk, mbedtls_pk_debug_item *items)
1100 : {
1101 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
1102 : items->type = MBEDTLS_PK_DEBUG_PSA_EC;
1103 : items->name = "eckey.Q";
1104 : items->value = pk;
1105 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
1106 0 : mbedtls_ecp_keypair *ecp = (mbedtls_ecp_keypair *) pk->pk_ctx;
1107 0 : items->type = MBEDTLS_PK_DEBUG_ECP;
1108 0 : items->name = "eckey.Q";
1109 0 : items->value = &(ecp->Q);
1110 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1111 0 : }
1112 :
1113 : const mbedtls_pk_info_t mbedtls_eckey_info = {
1114 : .type = MBEDTLS_PK_ECKEY,
1115 : .name = "EC",
1116 : .get_bitlen = eckey_get_bitlen,
1117 : .can_do = eckey_can_do,
1118 : #if defined(MBEDTLS_PK_CAN_ECDSA_VERIFY)
1119 : .verify_func = ecdsa_verify_wrap, /* Compatible key structures */
1120 : #else /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1121 : .verify_func = NULL,
1122 : #endif /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1123 : #if defined(MBEDTLS_PK_CAN_ECDSA_SIGN)
1124 : .sign_func = ecdsa_sign_wrap, /* Compatible key structures */
1125 : #else /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1126 : .sign_func = NULL,
1127 : #endif /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1128 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1129 : .verify_rs_func = eckey_verify_rs_wrap,
1130 : .sign_rs_func = eckey_sign_rs_wrap,
1131 : .rs_alloc_func = eckey_rs_alloc,
1132 : .rs_free_func = eckey_rs_free,
1133 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1134 : .decrypt_func = NULL,
1135 : .encrypt_func = NULL,
1136 : .check_pair_func = eckey_check_pair_wrap,
1137 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
1138 : .ctx_alloc_func = NULL,
1139 : .ctx_free_func = NULL,
1140 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
1141 : .ctx_alloc_func = eckey_alloc_wrap,
1142 : .ctx_free_func = eckey_free_wrap,
1143 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1144 : .debug_func = eckey_debug,
1145 : };
1146 :
1147 : /*
1148 : * EC key restricted to ECDH
1149 : */
1150 0 : static int eckeydh_can_do(mbedtls_pk_type_t type)
1151 : {
1152 0 : return type == MBEDTLS_PK_ECKEY ||
1153 : type == MBEDTLS_PK_ECKEY_DH;
1154 : }
1155 :
1156 : const mbedtls_pk_info_t mbedtls_eckeydh_info = {
1157 : .type = MBEDTLS_PK_ECKEY_DH,
1158 : .name = "EC_DH",
1159 : .get_bitlen = eckey_get_bitlen, /* Same underlying key structure */
1160 : .can_do = eckeydh_can_do,
1161 : .verify_func = NULL,
1162 : .sign_func = NULL,
1163 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1164 : .verify_rs_func = NULL,
1165 : .sign_rs_func = NULL,
1166 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1167 : .decrypt_func = NULL,
1168 : .encrypt_func = NULL,
1169 : .check_pair_func = eckey_check_pair_wrap,
1170 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
1171 : .ctx_alloc_func = NULL,
1172 : .ctx_free_func = NULL,
1173 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
1174 : .ctx_alloc_func = eckey_alloc_wrap, /* Same underlying key structure */
1175 : .ctx_free_func = eckey_free_wrap, /* Same underlying key structure */
1176 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1177 : .debug_func = eckey_debug, /* Same underlying key structure */
1178 : };
1179 :
1180 : #if defined(MBEDTLS_PK_CAN_ECDSA_SOME)
1181 0 : static int ecdsa_can_do(mbedtls_pk_type_t type)
1182 : {
1183 0 : return type == MBEDTLS_PK_ECDSA;
1184 : }
1185 :
1186 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1187 0 : static int ecdsa_verify_rs_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
1188 : const unsigned char *hash, size_t hash_len,
1189 : const unsigned char *sig, size_t sig_len,
1190 : void *rs_ctx)
1191 : {
1192 0 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1193 : ((void) md_alg);
1194 :
1195 0 : ret = mbedtls_ecdsa_read_signature_restartable(
1196 0 : (mbedtls_ecdsa_context *) pk->pk_ctx,
1197 : hash, hash_len, sig, sig_len,
1198 : (mbedtls_ecdsa_restart_ctx *) rs_ctx);
1199 :
1200 0 : if (ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH) {
1201 0 : return MBEDTLS_ERR_PK_SIG_LEN_MISMATCH;
1202 : }
1203 :
1204 0 : return ret;
1205 : }
1206 :
1207 0 : static int ecdsa_sign_rs_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
1208 : const unsigned char *hash, size_t hash_len,
1209 : unsigned char *sig, size_t sig_size, size_t *sig_len,
1210 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng,
1211 : void *rs_ctx)
1212 : {
1213 0 : return mbedtls_ecdsa_write_signature_restartable(
1214 0 : (mbedtls_ecdsa_context *) pk->pk_ctx,
1215 : md_alg, hash, hash_len, sig, sig_size, sig_len, f_rng, p_rng,
1216 : (mbedtls_ecdsa_restart_ctx *) rs_ctx);
1217 :
1218 : }
1219 :
1220 0 : static void *ecdsa_rs_alloc(void)
1221 : {
1222 0 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_ecdsa_restart_ctx));
1223 :
1224 0 : if (ctx != NULL) {
1225 0 : mbedtls_ecdsa_restart_init(ctx);
1226 : }
1227 :
1228 0 : return ctx;
1229 : }
1230 :
1231 0 : static void ecdsa_rs_free(void *ctx)
1232 : {
1233 0 : mbedtls_ecdsa_restart_free(ctx);
1234 0 : mbedtls_free(ctx);
1235 0 : }
1236 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1237 :
1238 : const mbedtls_pk_info_t mbedtls_ecdsa_info = {
1239 : .type = MBEDTLS_PK_ECDSA,
1240 : .name = "ECDSA",
1241 : .get_bitlen = eckey_get_bitlen, /* Compatible key structures */
1242 : .can_do = ecdsa_can_do,
1243 : #if defined(MBEDTLS_PK_CAN_ECDSA_VERIFY)
1244 : .verify_func = ecdsa_verify_wrap, /* Compatible key structures */
1245 : #else /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1246 : .verify_func = NULL,
1247 : #endif /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1248 : #if defined(MBEDTLS_PK_CAN_ECDSA_SIGN)
1249 : .sign_func = ecdsa_sign_wrap, /* Compatible key structures */
1250 : #else /* MBEDTLS_PK_CAN_ECDSA_SIGN */
1251 : .sign_func = NULL,
1252 : #endif /* MBEDTLS_PK_CAN_ECDSA_SIGN */
1253 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1254 : .verify_rs_func = ecdsa_verify_rs_wrap,
1255 : .sign_rs_func = ecdsa_sign_rs_wrap,
1256 : .rs_alloc_func = ecdsa_rs_alloc,
1257 : .rs_free_func = ecdsa_rs_free,
1258 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1259 : .decrypt_func = NULL,
1260 : .encrypt_func = NULL,
1261 : .check_pair_func = eckey_check_pair_wrap, /* Compatible key structures */
1262 : #if defined(MBEDTLS_PK_USE_PSA_EC_DATA)
1263 : .ctx_alloc_func = NULL,
1264 : .ctx_free_func = NULL,
1265 : #else /* MBEDTLS_PK_USE_PSA_EC_DATA */
1266 : .ctx_alloc_func = eckey_alloc_wrap, /* Compatible key structures */
1267 : .ctx_free_func = eckey_free_wrap, /* Compatible key structures */
1268 : #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */
1269 : .debug_func = eckey_debug, /* Compatible key structures */
1270 : };
1271 : #endif /* MBEDTLS_PK_CAN_ECDSA_SOME */
1272 : #endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
1273 :
1274 : #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT)
1275 : /*
1276 : * Support for alternative RSA-private implementations
1277 : */
1278 :
1279 : static int rsa_alt_can_do(mbedtls_pk_type_t type)
1280 : {
1281 : return type == MBEDTLS_PK_RSA;
1282 : }
1283 :
1284 : static size_t rsa_alt_get_bitlen(mbedtls_pk_context *pk)
1285 : {
1286 : const mbedtls_rsa_alt_context *rsa_alt = pk->pk_ctx;
1287 :
1288 : return 8 * rsa_alt->key_len_func(rsa_alt->key);
1289 : }
1290 :
1291 : static int rsa_alt_sign_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
1292 : const unsigned char *hash, size_t hash_len,
1293 : unsigned char *sig, size_t sig_size, size_t *sig_len,
1294 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
1295 : {
1296 : mbedtls_rsa_alt_context *rsa_alt = pk->pk_ctx;
1297 :
1298 : #if SIZE_MAX > UINT_MAX
1299 : if (UINT_MAX < hash_len) {
1300 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
1301 : }
1302 : #endif
1303 :
1304 : *sig_len = rsa_alt->key_len_func(rsa_alt->key);
1305 : if (*sig_len > MBEDTLS_PK_SIGNATURE_MAX_SIZE) {
1306 : return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
1307 : }
1308 : if (*sig_len > sig_size) {
1309 : return MBEDTLS_ERR_PK_BUFFER_TOO_SMALL;
1310 : }
1311 :
1312 : return rsa_alt->sign_func(rsa_alt->key, f_rng, p_rng,
1313 : md_alg, (unsigned int) hash_len, hash, sig);
1314 : }
1315 :
1316 : static int rsa_alt_decrypt_wrap(mbedtls_pk_context *pk,
1317 : const unsigned char *input, size_t ilen,
1318 : unsigned char *output, size_t *olen, size_t osize,
1319 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
1320 : {
1321 : mbedtls_rsa_alt_context *rsa_alt = pk->pk_ctx;
1322 :
1323 : ((void) f_rng);
1324 : ((void) p_rng);
1325 :
1326 : if (ilen != rsa_alt->key_len_func(rsa_alt->key)) {
1327 : return MBEDTLS_ERR_RSA_BAD_INPUT_DATA;
1328 : }
1329 :
1330 : return rsa_alt->decrypt_func(rsa_alt->key,
1331 : olen, input, output, osize);
1332 : }
1333 :
1334 : #if defined(MBEDTLS_RSA_C)
1335 : static int rsa_alt_check_pair(mbedtls_pk_context *pub, mbedtls_pk_context *prv,
1336 : int (*f_rng)(void *, unsigned char *, size_t),
1337 : void *p_rng)
1338 : {
1339 : unsigned char sig[MBEDTLS_MPI_MAX_SIZE];
1340 : unsigned char hash[32];
1341 : size_t sig_len = 0;
1342 : int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1343 :
1344 : if (rsa_alt_get_bitlen(prv) != rsa_get_bitlen(pub)) {
1345 : return MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
1346 : }
1347 :
1348 : memset(hash, 0x2a, sizeof(hash));
1349 :
1350 : if ((ret = rsa_alt_sign_wrap(prv, MBEDTLS_MD_NONE,
1351 : hash, sizeof(hash),
1352 : sig, sizeof(sig), &sig_len,
1353 : f_rng, p_rng)) != 0) {
1354 : return ret;
1355 : }
1356 :
1357 : if (rsa_verify_wrap(pub, MBEDTLS_MD_NONE,
1358 : hash, sizeof(hash), sig, sig_len) != 0) {
1359 : return MBEDTLS_ERR_RSA_KEY_CHECK_FAILED;
1360 : }
1361 :
1362 : return 0;
1363 : }
1364 : #endif /* MBEDTLS_RSA_C */
1365 :
1366 : static void *rsa_alt_alloc_wrap(void)
1367 : {
1368 : void *ctx = mbedtls_calloc(1, sizeof(mbedtls_rsa_alt_context));
1369 :
1370 : if (ctx != NULL) {
1371 : memset(ctx, 0, sizeof(mbedtls_rsa_alt_context));
1372 : }
1373 :
1374 : return ctx;
1375 : }
1376 :
1377 : static void rsa_alt_free_wrap(void *ctx)
1378 : {
1379 : mbedtls_zeroize_and_free(ctx, sizeof(mbedtls_rsa_alt_context));
1380 : }
1381 :
1382 : const mbedtls_pk_info_t mbedtls_rsa_alt_info = {
1383 : .type = MBEDTLS_PK_RSA_ALT,
1384 : .name = "RSA-alt",
1385 : .get_bitlen = rsa_alt_get_bitlen,
1386 : .can_do = rsa_alt_can_do,
1387 : .verify_func = NULL,
1388 : .sign_func = rsa_alt_sign_wrap,
1389 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1390 : .verify_rs_func = NULL,
1391 : .sign_rs_func = NULL,
1392 : .rs_alloc_func = NULL,
1393 : .rs_free_func = NULL,
1394 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1395 : .decrypt_func = rsa_alt_decrypt_wrap,
1396 : .encrypt_func = NULL,
1397 : #if defined(MBEDTLS_RSA_C)
1398 : .check_pair_func = rsa_alt_check_pair,
1399 : #else
1400 : .check_pair_func = NULL,
1401 : #endif
1402 : .ctx_alloc_func = rsa_alt_alloc_wrap,
1403 : .ctx_free_func = rsa_alt_free_wrap,
1404 : .debug_func = NULL,
1405 : };
1406 : #endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */
1407 :
1408 : #if defined(MBEDTLS_USE_PSA_CRYPTO)
1409 : static size_t opaque_get_bitlen(mbedtls_pk_context *pk)
1410 : {
1411 : size_t bits;
1412 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1413 :
1414 : if (PSA_SUCCESS != psa_get_key_attributes(pk->priv_id, &attributes)) {
1415 : return 0;
1416 : }
1417 :
1418 : bits = psa_get_key_bits(&attributes);
1419 : psa_reset_key_attributes(&attributes);
1420 : return bits;
1421 : }
1422 :
1423 : #if defined(MBEDTLS_PK_HAVE_ECC_KEYS)
1424 : static int ecdsa_opaque_can_do(mbedtls_pk_type_t type)
1425 : {
1426 : return type == MBEDTLS_PK_ECKEY ||
1427 : type == MBEDTLS_PK_ECDSA;
1428 : }
1429 :
1430 : const mbedtls_pk_info_t mbedtls_ecdsa_opaque_info = {
1431 : .type = MBEDTLS_PK_OPAQUE,
1432 : .name = "Opaque",
1433 : .get_bitlen = opaque_get_bitlen,
1434 : .can_do = ecdsa_opaque_can_do,
1435 : #if defined(MBEDTLS_PK_CAN_ECDSA_VERIFY)
1436 : .verify_func = ecdsa_opaque_verify_wrap,
1437 : #else /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1438 : .verify_func = NULL,
1439 : #endif /* MBEDTLS_PK_CAN_ECDSA_VERIFY */
1440 : #if defined(MBEDTLS_PK_CAN_ECDSA_SIGN)
1441 : .sign_func = ecdsa_opaque_sign_wrap,
1442 : #else /* MBEDTLS_PK_CAN_ECDSA_SIGN */
1443 : .sign_func = NULL,
1444 : #endif /* MBEDTLS_PK_CAN_ECDSA_SIGN */
1445 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1446 : .verify_rs_func = NULL,
1447 : .sign_rs_func = NULL,
1448 : .rs_alloc_func = NULL,
1449 : .rs_free_func = NULL,
1450 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1451 : .decrypt_func = NULL,
1452 : .encrypt_func = NULL,
1453 : .check_pair_func = ecdsa_opaque_check_pair_wrap,
1454 : .ctx_alloc_func = NULL,
1455 : .ctx_free_func = NULL,
1456 : .debug_func = NULL,
1457 : };
1458 : #endif /* MBEDTLS_PK_HAVE_ECC_KEYS */
1459 :
1460 : static int rsa_opaque_can_do(mbedtls_pk_type_t type)
1461 : {
1462 : return type == MBEDTLS_PK_RSA ||
1463 : type == MBEDTLS_PK_RSASSA_PSS;
1464 : }
1465 :
1466 : #if defined(PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_BASIC)
1467 : static int rsa_opaque_decrypt(mbedtls_pk_context *pk,
1468 : const unsigned char *input, size_t ilen,
1469 : unsigned char *output, size_t *olen, size_t osize,
1470 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
1471 : {
1472 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1473 : psa_algorithm_t alg;
1474 : psa_key_type_t type;
1475 : psa_status_t status;
1476 :
1477 : /* PSA has its own RNG */
1478 : (void) f_rng;
1479 : (void) p_rng;
1480 :
1481 : status = psa_get_key_attributes(pk->priv_id, &attributes);
1482 : if (status != PSA_SUCCESS) {
1483 : return PSA_PK_TO_MBEDTLS_ERR(status);
1484 : }
1485 :
1486 : type = psa_get_key_type(&attributes);
1487 : alg = psa_get_key_algorithm(&attributes);
1488 : psa_reset_key_attributes(&attributes);
1489 :
1490 : if (!PSA_KEY_TYPE_IS_RSA(type)) {
1491 : return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
1492 : }
1493 :
1494 : status = psa_asymmetric_decrypt(pk->priv_id, alg, input, ilen, NULL, 0, output, osize, olen);
1495 : if (status != PSA_SUCCESS) {
1496 : return PSA_PK_RSA_TO_MBEDTLS_ERR(status);
1497 : }
1498 :
1499 : return 0;
1500 : }
1501 : #endif /* PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_BASIC */
1502 :
1503 : static int rsa_opaque_sign_wrap(mbedtls_pk_context *pk, mbedtls_md_type_t md_alg,
1504 : const unsigned char *hash, size_t hash_len,
1505 : unsigned char *sig, size_t sig_size, size_t *sig_len,
1506 : int (*f_rng)(void *, unsigned char *, size_t), void *p_rng)
1507 : {
1508 : #if defined(MBEDTLS_RSA_C)
1509 : psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT;
1510 : psa_algorithm_t alg;
1511 : psa_key_type_t type;
1512 : psa_status_t status;
1513 :
1514 : /* PSA has its own RNG */
1515 : (void) f_rng;
1516 : (void) p_rng;
1517 :
1518 : status = psa_get_key_attributes(pk->priv_id, &attributes);
1519 : if (status != PSA_SUCCESS) {
1520 : return PSA_PK_TO_MBEDTLS_ERR(status);
1521 : }
1522 :
1523 : type = psa_get_key_type(&attributes);
1524 : alg = psa_get_key_algorithm(&attributes);
1525 : psa_reset_key_attributes(&attributes);
1526 :
1527 : if (PSA_KEY_TYPE_IS_RSA(type)) {
1528 : alg = (alg & ~PSA_ALG_HASH_MASK) | mbedtls_md_psa_alg_from_type(md_alg);
1529 : } else {
1530 : return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
1531 : }
1532 :
1533 : status = psa_sign_hash(pk->priv_id, alg, hash, hash_len, sig, sig_size, sig_len);
1534 : if (status != PSA_SUCCESS) {
1535 : if (PSA_KEY_TYPE_IS_RSA(type)) {
1536 : return PSA_PK_RSA_TO_MBEDTLS_ERR(status);
1537 : } else {
1538 : return PSA_PK_TO_MBEDTLS_ERR(status);
1539 : }
1540 : }
1541 :
1542 : return 0;
1543 : #else /* !MBEDTLS_RSA_C */
1544 : ((void) pk);
1545 : ((void) md_alg);
1546 : ((void) hash);
1547 : ((void) hash_len);
1548 : ((void) sig);
1549 : ((void) sig_size);
1550 : ((void) sig_len);
1551 : ((void) f_rng);
1552 : ((void) p_rng);
1553 : return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
1554 : #endif /* !MBEDTLS_RSA_C */
1555 : }
1556 :
1557 : const mbedtls_pk_info_t mbedtls_rsa_opaque_info = {
1558 : .type = MBEDTLS_PK_OPAQUE,
1559 : .name = "Opaque",
1560 : .get_bitlen = opaque_get_bitlen,
1561 : .can_do = rsa_opaque_can_do,
1562 : .verify_func = NULL,
1563 : .sign_func = rsa_opaque_sign_wrap,
1564 : #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
1565 : .verify_rs_func = NULL,
1566 : .sign_rs_func = NULL,
1567 : .rs_alloc_func = NULL,
1568 : .rs_free_func = NULL,
1569 : #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
1570 : #if defined(PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_BASIC)
1571 : .decrypt_func = rsa_opaque_decrypt,
1572 : #else /* PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_BASIC */
1573 : .decrypt_func = NULL,
1574 : #endif /* PSA_WANT_KEY_TYPE_RSA_KEY_PAIR_BASIC */
1575 : .encrypt_func = NULL,
1576 : .check_pair_func = NULL,
1577 : .ctx_alloc_func = NULL,
1578 : .ctx_free_func = NULL,
1579 : .debug_func = NULL,
1580 : };
1581 :
1582 : #endif /* MBEDTLS_USE_PSA_CRYPTO */
1583 :
1584 : #endif /* MBEDTLS_PK_C */
|
