Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Public Key abstraction layer |
| 3 | * |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 4 | * Copyright The Mbed TLS Contributors |
Dave Rodgman | 16799db | 2023-11-02 19:47:20 +0000 | [diff] [blame] | 5 | * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 6 | */ |
| 7 | |
Gilles Peskine | db09ef6 | 2020-06-03 01:43:33 +0200 | [diff] [blame] | 8 | #include "common.h" |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 9 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 10 | #if defined(MBEDTLS_PK_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 11 | #include "mbedtls/pk.h" |
Chris Jones | daacb59 | 2021-03-09 17:03:29 +0000 | [diff] [blame] | 12 | #include "pk_wrap.h" |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 13 | #include "pkwrite.h" |
Valerio Setti | 3f00b84 | 2023-05-15 12:57:06 +0200 | [diff] [blame] | 14 | #include "pk_internal.h" |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 15 | |
Andres Amaya Garcia | 1f6301b | 2018-04-17 09:51:09 -0500 | [diff] [blame] | 16 | #include "mbedtls/platform_util.h" |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 17 | #include "mbedtls/error.h" |
Andres AG | 7284987 | 2017-01-19 11:24:33 +0000 | [diff] [blame] | 18 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 19 | #if defined(MBEDTLS_RSA_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 20 | #include "mbedtls/rsa.h" |
Tomi Fontanilles | 573dc23 | 2023-12-10 14:57:51 +0200 | [diff] [blame] | 21 | #if defined(MBEDTLS_PKCS1_V21) && !defined(MBEDTLS_USE_PSA_CRYPTO) |
| 22 | #include "rsa_internal.h" |
| 23 | #endif |
Manuel Pégourié-Gonnard | 81c313c | 2013-07-09 10:35:54 +0200 | [diff] [blame] | 24 | #endif |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 25 | #if defined(MBEDTLS_PK_HAVE_ECC_KEYS) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 26 | #include "mbedtls/ecp.h" |
Manuel Pégourié-Gonnard | 81c313c | 2013-07-09 10:35:54 +0200 | [diff] [blame] | 27 | #endif |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 28 | #if defined(MBEDTLS_ECDSA_C) |
Manuel Pégourié-Gonnard | 7f80997 | 2015-03-09 17:05:11 +0000 | [diff] [blame] | 29 | #include "mbedtls/ecdsa.h" |
Manuel Pégourié-Gonnard | 7c5819e | 2013-07-10 12:29:57 +0200 | [diff] [blame] | 30 | #endif |
Manuel Pégourié-Gonnard | 81c313c | 2013-07-09 10:35:54 +0200 | [diff] [blame] | 31 | |
Tomi Fontanilles | bad170e | 2023-12-14 22:03:12 +0200 | [diff] [blame] | 32 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
Manuel Pégourié-Gonnard | 2be8c63 | 2023-06-07 13:07:21 +0200 | [diff] [blame] | 33 | #include "psa_util_internal.h" |
Valerio Setti | 384fbde | 2024-01-02 13:26:40 +0100 | [diff] [blame^] | 34 | #include "mbedtls/psa_util.h" |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 35 | #endif |
| 36 | |
Andres AG | 7284987 | 2017-01-19 11:24:33 +0000 | [diff] [blame] | 37 | #include <limits.h> |
Andres Amaya Garcia | 7c02c50 | 2017-08-04 13:32:15 +0100 | [diff] [blame] | 38 | #include <stdint.h> |
Paul Bakker | 3461772 | 2014-06-13 17:20:13 +0200 | [diff] [blame] | 39 | |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 40 | /* |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 41 | * Initialise a mbedtls_pk_context |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 42 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 43 | void mbedtls_pk_init(mbedtls_pk_context *ctx) |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 44 | { |
Manuel Pégourié-Gonnard | 3fb5c5e | 2013-08-14 18:26:41 +0200 | [diff] [blame] | 45 | ctx->pk_info = NULL; |
| 46 | ctx->pk_ctx = NULL; |
Tomi Fontanilles | bad170e | 2023-12-14 22:03:12 +0200 | [diff] [blame] | 47 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
Valerio Setti | 4f387ef | 2023-05-02 14:15:59 +0200 | [diff] [blame] | 48 | ctx->priv_id = MBEDTLS_SVC_KEY_ID_INIT; |
Tomi Fontanilles | bad170e | 2023-12-14 22:03:12 +0200 | [diff] [blame] | 49 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
Valerio Setti | 722f8f7 | 2023-05-17 15:31:21 +0200 | [diff] [blame] | 50 | #if defined(MBEDTLS_PK_USE_PSA_EC_DATA) |
| 51 | memset(ctx->pub_raw, 0, sizeof(ctx->pub_raw)); |
| 52 | ctx->pub_raw_len = 0; |
| 53 | ctx->ec_family = 0; |
| 54 | ctx->ec_bits = 0; |
| 55 | #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */ |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | /* |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 59 | * Free (the components of) a mbedtls_pk_context |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 60 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 61 | void mbedtls_pk_free(mbedtls_pk_context *ctx) |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 62 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 63 | if (ctx == NULL) { |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 64 | return; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 65 | } |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 66 | |
Valerio Setti | e00954d | 2023-04-28 15:24:32 +0200 | [diff] [blame] | 67 | if ((ctx->pk_info != NULL) && (ctx->pk_info->ctx_free_func != NULL)) { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 68 | ctx->pk_info->ctx_free_func(ctx->pk_ctx); |
| 69 | } |
Manuel Pégourié-Gonnard | 1f73a65 | 2013-07-09 10:26:41 +0200 | [diff] [blame] | 70 | |
Valerio Setti | b536126 | 2023-05-18 18:51:58 +0200 | [diff] [blame] | 71 | #if defined(MBEDTLS_PK_USE_PSA_EC_DATA) |
| 72 | /* The ownership of the priv_id key for opaque keys is external of the PK |
| 73 | * module. It's the user responsibility to clear it after use. */ |
| 74 | if ((ctx->pk_info != NULL) && (ctx->pk_info->type != MBEDTLS_PK_OPAQUE)) { |
| 75 | psa_destroy_key(ctx->priv_id); |
| 76 | } |
| 77 | #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */ |
| 78 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 79 | mbedtls_platform_zeroize(ctx, sizeof(mbedtls_pk_context)); |
Manuel Pégourié-Gonnard | 765db07 | 2013-08-14 15:00:27 +0200 | [diff] [blame] | 80 | } |
| 81 | |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 82 | #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 83 | /* |
| 84 | * Initialize a restart context |
| 85 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 86 | void mbedtls_pk_restart_init(mbedtls_pk_restart_ctx *ctx) |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 87 | { |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 88 | ctx->pk_info = NULL; |
| 89 | ctx->rs_ctx = NULL; |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | /* |
| 93 | * Free the components of a restart context |
| 94 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 95 | void mbedtls_pk_restart_free(mbedtls_pk_restart_ctx *ctx) |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 96 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 97 | if (ctx == NULL || ctx->pk_info == NULL || |
| 98 | ctx->pk_info->rs_free_func == NULL) { |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 99 | return; |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 100 | } |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 101 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 102 | ctx->pk_info->rs_free_func(ctx->rs_ctx); |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 103 | |
| 104 | ctx->pk_info = NULL; |
| 105 | ctx->rs_ctx = NULL; |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 106 | } |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 107 | #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */ |
Manuel Pégourié-Gonnard | 15d7df2 | 2017-08-17 14:33:31 +0200 | [diff] [blame] | 108 | |
Manuel Pégourié-Gonnard | 765db07 | 2013-08-14 15:00:27 +0200 | [diff] [blame] | 109 | /* |
| 110 | * Get pk_info structure from type |
| 111 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 112 | const mbedtls_pk_info_t *mbedtls_pk_info_from_type(mbedtls_pk_type_t pk_type) |
Manuel Pégourié-Gonnard | 765db07 | 2013-08-14 15:00:27 +0200 | [diff] [blame] | 113 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 114 | switch (pk_type) { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 115 | #if defined(MBEDTLS_RSA_C) |
| 116 | case MBEDTLS_PK_RSA: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 117 | return &mbedtls_rsa_info; |
Valerio Setti | 0d2980f | 2023-04-05 18:17:13 +0200 | [diff] [blame] | 118 | #endif /* MBEDTLS_RSA_C */ |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 119 | #if defined(MBEDTLS_PK_HAVE_ECC_KEYS) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 120 | case MBEDTLS_PK_ECKEY: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 121 | return &mbedtls_eckey_info; |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 122 | case MBEDTLS_PK_ECKEY_DH: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 123 | return &mbedtls_eckeydh_info; |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 124 | #endif /* MBEDTLS_PK_HAVE_ECC_KEYS */ |
Valerio Setti | 7ca1318 | 2023-01-27 13:22:42 +0100 | [diff] [blame] | 125 | #if defined(MBEDTLS_PK_CAN_ECDSA_SOME) |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 126 | case MBEDTLS_PK_ECDSA: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 127 | return &mbedtls_ecdsa_info; |
Valerio Setti | 0d2980f | 2023-04-05 18:17:13 +0200 | [diff] [blame] | 128 | #endif /* MBEDTLS_PK_CAN_ECDSA_SOME */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 129 | /* MBEDTLS_PK_RSA_ALT omitted on purpose */ |
Manuel Pégourié-Gonnard | 765db07 | 2013-08-14 15:00:27 +0200 | [diff] [blame] | 130 | default: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 131 | return NULL; |
Manuel Pégourié-Gonnard | 765db07 | 2013-08-14 15:00:27 +0200 | [diff] [blame] | 132 | } |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 133 | } |
| 134 | |
| 135 | /* |
Manuel Pégourié-Gonnard | ab46694 | 2013-08-15 11:30:27 +0200 | [diff] [blame] | 136 | * Initialise context |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 137 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 138 | int mbedtls_pk_setup(mbedtls_pk_context *ctx, const mbedtls_pk_info_t *info) |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 139 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 140 | if (info == NULL || ctx->pk_info != NULL) { |
| 141 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 142 | } |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 143 | |
Valerio Setti | b536126 | 2023-05-18 18:51:58 +0200 | [diff] [blame] | 144 | if ((info->ctx_alloc_func != NULL) && |
Valerio Setti | e00954d | 2023-04-28 15:24:32 +0200 | [diff] [blame] | 145 | ((ctx->pk_ctx = info->ctx_alloc_func()) == NULL)) { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 146 | return MBEDTLS_ERR_PK_ALLOC_FAILED; |
| 147 | } |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 148 | |
Manuel Pégourié-Gonnard | 3fb5c5e | 2013-08-14 18:26:41 +0200 | [diff] [blame] | 149 | ctx->pk_info = info; |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 150 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 151 | return 0; |
Manuel Pégourié-Gonnard | 12e0ed9 | 2013-07-04 13:31:32 +0200 | [diff] [blame] | 152 | } |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 153 | |
Manuel Pégourié-Gonnard | 20678b2 | 2018-10-22 12:11:15 +0200 | [diff] [blame] | 154 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
| 155 | /* |
| 156 | * Initialise a PSA-wrapping context |
| 157 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 158 | int mbedtls_pk_setup_opaque(mbedtls_pk_context *ctx, |
| 159 | const mbedtls_svc_key_id_t key) |
Manuel Pégourié-Gonnard | 20678b2 | 2018-10-22 12:11:15 +0200 | [diff] [blame] | 160 | { |
Neil Armstrong | eabbf9d | 2022-03-15 12:01:26 +0100 | [diff] [blame] | 161 | const mbedtls_pk_info_t *info = NULL; |
Gilles Peskine | d2d45c1 | 2019-05-27 14:53:13 +0200 | [diff] [blame] | 162 | psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
Manuel Pégourié-Gonnard | 920c063 | 2018-10-31 10:57:29 +0100 | [diff] [blame] | 163 | psa_key_type_t type; |
Manuel Pégourié-Gonnard | 20678b2 | 2018-10-22 12:11:15 +0200 | [diff] [blame] | 164 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 165 | if (ctx == NULL || ctx->pk_info != NULL) { |
| 166 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 167 | } |
Manuel Pégourié-Gonnard | 20678b2 | 2018-10-22 12:11:15 +0200 | [diff] [blame] | 168 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 169 | if (PSA_SUCCESS != psa_get_key_attributes(key, &attributes)) { |
| 170 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 171 | } |
| 172 | type = psa_get_key_type(&attributes); |
| 173 | psa_reset_key_attributes(&attributes); |
Manuel Pégourié-Gonnard | 920c063 | 2018-10-31 10:57:29 +0100 | [diff] [blame] | 174 | |
Valerio Setti | f7cd419 | 2023-06-30 18:11:29 +0200 | [diff] [blame] | 175 | #if defined(MBEDTLS_PK_HAVE_ECC_KEYS) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 176 | if (PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type)) { |
Valerio Setti | 76d0f96 | 2023-06-23 13:32:54 +0200 | [diff] [blame] | 177 | info = &mbedtls_ecdsa_opaque_info; |
Valerio Setti | f7cd419 | 2023-06-30 18:11:29 +0200 | [diff] [blame] | 178 | } else |
| 179 | #endif /* MBEDTLS_PK_HAVE_ECC_KEYS */ |
| 180 | if (type == PSA_KEY_TYPE_RSA_KEY_PAIR) { |
Valerio Setti | 76d0f96 | 2023-06-23 13:32:54 +0200 | [diff] [blame] | 181 | info = &mbedtls_rsa_opaque_info; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 182 | } else { |
| 183 | return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE; |
| 184 | } |
Manuel Pégourié-Gonnard | 920c063 | 2018-10-31 10:57:29 +0100 | [diff] [blame] | 185 | |
Manuel Pégourié-Gonnard | 20678b2 | 2018-10-22 12:11:15 +0200 | [diff] [blame] | 186 | ctx->pk_info = info; |
Valerio Setti | 4f387ef | 2023-05-02 14:15:59 +0200 | [diff] [blame] | 187 | ctx->priv_id = key; |
Manuel Pégourié-Gonnard | 7b5fe04 | 2018-10-31 09:57:45 +0100 | [diff] [blame] | 188 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 189 | return 0; |
Manuel Pégourié-Gonnard | 20678b2 | 2018-10-22 12:11:15 +0200 | [diff] [blame] | 190 | } |
| 191 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
| 192 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 193 | #if defined(MBEDTLS_PK_RSA_ALT_SUPPORT) |
Manuel Pégourié-Gonnard | b4fae57 | 2014-01-20 11:22:25 +0100 | [diff] [blame] | 194 | /* |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 195 | * Initialize an RSA-alt context |
| 196 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 197 | int mbedtls_pk_setup_rsa_alt(mbedtls_pk_context *ctx, void *key, |
| 198 | mbedtls_pk_rsa_alt_decrypt_func decrypt_func, |
| 199 | mbedtls_pk_rsa_alt_sign_func sign_func, |
| 200 | mbedtls_pk_rsa_alt_key_len_func key_len_func) |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 201 | { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 202 | mbedtls_rsa_alt_context *rsa_alt; |
| 203 | const mbedtls_pk_info_t *info = &mbedtls_rsa_alt_info; |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 204 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 205 | if (ctx->pk_info != NULL) { |
| 206 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 207 | } |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 208 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 209 | if ((ctx->pk_ctx = info->ctx_alloc_func()) == NULL) { |
| 210 | return MBEDTLS_ERR_PK_ALLOC_FAILED; |
| 211 | } |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 212 | |
| 213 | ctx->pk_info = info; |
| 214 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 215 | rsa_alt = (mbedtls_rsa_alt_context *) ctx->pk_ctx; |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 216 | |
| 217 | rsa_alt->key = key; |
| 218 | rsa_alt->decrypt_func = decrypt_func; |
| 219 | rsa_alt->sign_func = sign_func; |
| 220 | rsa_alt->key_len_func = key_len_func; |
| 221 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 222 | return 0; |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 223 | } |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 224 | #endif /* MBEDTLS_PK_RSA_ALT_SUPPORT */ |
Manuel Pégourié-Gonnard | 12c1ff0 | 2013-08-21 12:28:31 +0200 | [diff] [blame] | 225 | |
| 226 | /* |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 227 | * Tell if a PK can do the operations of the given type |
| 228 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 229 | int mbedtls_pk_can_do(const mbedtls_pk_context *ctx, mbedtls_pk_type_t type) |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 230 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 231 | /* A context with null pk_info is not set up yet and can't do anything. |
| 232 | * For backward compatibility, also accept NULL instead of a context |
| 233 | * pointer. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 234 | if (ctx == NULL || ctx->pk_info == NULL) { |
| 235 | return 0; |
| 236 | } |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 237 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 238 | return ctx->pk_info->can_do(type); |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 239 | } |
| 240 | |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 241 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
| 242 | /* |
| 243 | * Tell if a PK can do the operations of the given PSA algorithm |
| 244 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 245 | int mbedtls_pk_can_do_ext(const mbedtls_pk_context *ctx, psa_algorithm_t alg, |
| 246 | psa_key_usage_t usage) |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 247 | { |
Neil Armstrong | 408f6a6 | 2022-05-17 14:23:20 +0200 | [diff] [blame] | 248 | psa_key_usage_t key_usage; |
| 249 | |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 250 | /* A context with null pk_info is not set up yet and can't do anything. |
| 251 | * For backward compatibility, also accept NULL instead of a context |
| 252 | * pointer. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 253 | if (ctx == NULL || ctx->pk_info == NULL) { |
| 254 | return 0; |
| 255 | } |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 256 | |
| 257 | /* Filter out non allowed algorithms */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 258 | if (PSA_ALG_IS_ECDSA(alg) == 0 && |
| 259 | PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) == 0 && |
| 260 | PSA_ALG_IS_RSA_PSS(alg) == 0 && |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 261 | alg != PSA_ALG_RSA_PKCS1V15_CRYPT && |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 262 | PSA_ALG_IS_ECDH(alg) == 0) { |
| 263 | return 0; |
| 264 | } |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 265 | |
Neil Armstrong | 408f6a6 | 2022-05-17 14:23:20 +0200 | [diff] [blame] | 266 | /* Filter out non allowed usage flags */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 267 | if (usage == 0 || |
| 268 | (usage & ~(PSA_KEY_USAGE_SIGN_HASH | |
| 269 | PSA_KEY_USAGE_DECRYPT | |
| 270 | PSA_KEY_USAGE_DERIVE)) != 0) { |
| 271 | return 0; |
| 272 | } |
Neil Armstrong | 408f6a6 | 2022-05-17 14:23:20 +0200 | [diff] [blame] | 273 | |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 274 | /* Wildcard hash is not allowed */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 275 | if (PSA_ALG_IS_SIGN_HASH(alg) && |
| 276 | PSA_ALG_SIGN_GET_HASH(alg) == PSA_ALG_ANY_HASH) { |
| 277 | return 0; |
| 278 | } |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 279 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 280 | if (mbedtls_pk_get_type(ctx) != MBEDTLS_PK_OPAQUE) { |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 281 | mbedtls_pk_type_t type; |
| 282 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 283 | if (PSA_ALG_IS_ECDSA(alg) || PSA_ALG_IS_ECDH(alg)) { |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 284 | type = MBEDTLS_PK_ECKEY; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 285 | } else if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || |
| 286 | alg == PSA_ALG_RSA_PKCS1V15_CRYPT) { |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 287 | type = MBEDTLS_PK_RSA; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 288 | } else if (PSA_ALG_IS_RSA_PSS(alg)) { |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 289 | type = MBEDTLS_PK_RSASSA_PSS; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 290 | } else { |
| 291 | return 0; |
| 292 | } |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 293 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 294 | if (ctx->pk_info->can_do(type) == 0) { |
| 295 | return 0; |
| 296 | } |
Neil Armstrong | 408f6a6 | 2022-05-17 14:23:20 +0200 | [diff] [blame] | 297 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 298 | switch (type) { |
Neil Armstrong | 084338d | 2022-05-19 16:22:40 +0200 | [diff] [blame] | 299 | case MBEDTLS_PK_ECKEY: |
| 300 | key_usage = PSA_KEY_USAGE_SIGN_HASH | PSA_KEY_USAGE_DERIVE; |
| 301 | break; |
| 302 | case MBEDTLS_PK_RSA: |
| 303 | case MBEDTLS_PK_RSASSA_PSS: |
| 304 | key_usage = PSA_KEY_USAGE_SIGN_HASH | |
| 305 | PSA_KEY_USAGE_SIGN_MESSAGE | |
| 306 | PSA_KEY_USAGE_DECRYPT; |
| 307 | break; |
| 308 | default: |
Neil Armstrong | b80785f | 2022-05-20 09:25:55 +0200 | [diff] [blame] | 309 | /* Should never happen */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 310 | return 0; |
Neil Armstrong | 084338d | 2022-05-19 16:22:40 +0200 | [diff] [blame] | 311 | } |
| 312 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 313 | return (key_usage & usage) == usage; |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 314 | } |
| 315 | |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 316 | psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 317 | psa_status_t status; |
| 318 | |
Valerio Setti | 4f387ef | 2023-05-02 14:15:59 +0200 | [diff] [blame] | 319 | status = psa_get_key_attributes(ctx->priv_id, &attributes); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 320 | if (status != PSA_SUCCESS) { |
| 321 | return 0; |
| 322 | } |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 323 | |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 324 | psa_algorithm_t key_alg = psa_get_key_algorithm(&attributes); |
| 325 | /* Key's enrollment is available only when MBEDTLS_PSA_CRYPTO_CLIENT is |
| 326 | * defined, i.e. when the Mbed TLS implementation of PSA Crypto is being used. |
| 327 | * Even though we don't officially support using other implementations of PSA |
| 328 | * Crypto with TLS and X.509 (yet), we're still trying to simplify the life of |
| 329 | * people who would like to try it before it's officially supported. */ |
| 330 | #if defined(MBEDTLS_PSA_CRYPTO_CLIENT) |
| 331 | psa_algorithm_t key_alg2 = psa_get_key_enrollment_algorithm(&attributes); |
| 332 | #endif /* MBEDTLS_PSA_CRYPTO_CLIENT */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 333 | key_usage = psa_get_key_usage_flags(&attributes); |
| 334 | psa_reset_key_attributes(&attributes); |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 335 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 336 | if ((key_usage & usage) != usage) { |
| 337 | return 0; |
| 338 | } |
Neil Armstrong | 408f6a6 | 2022-05-17 14:23:20 +0200 | [diff] [blame] | 339 | |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 340 | /* |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 341 | * Common case: the key alg [or alg2] only allows alg. |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 342 | * This will match PSA_ALG_RSA_PKCS1V15_CRYPT & PSA_ALG_IS_ECDH |
| 343 | * directly. |
| 344 | * This would also match ECDSA/RSA_PKCS1V15_SIGN/RSA_PSS with |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 345 | * a fixed hash on key_alg [or key_alg2]. |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 346 | */ |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 347 | if (alg == key_alg) { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 348 | return 1; |
| 349 | } |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 350 | #if defined(MBEDTLS_PSA_CRYPTO_CLIENT) |
| 351 | if (alg == key_alg2) { |
| 352 | return 1; |
| 353 | } |
| 354 | #endif /* MBEDTLS_PSA_CRYPTO_CLIENT */ |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 355 | |
| 356 | /* |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 357 | * If key_alg [or key_alg2] is a hash-and-sign with a wildcard for the hash, |
Neil Armstrong | bbb8b75 | 2022-05-17 14:58:27 +0200 | [diff] [blame] | 358 | * and alg is the same hash-and-sign family with any hash, |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 359 | * then alg is compliant with this key alg |
| 360 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 361 | if (PSA_ALG_IS_SIGN_HASH(alg)) { |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 362 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 363 | if (PSA_ALG_IS_SIGN_HASH(key_alg) && |
| 364 | PSA_ALG_SIGN_GET_HASH(key_alg) == PSA_ALG_ANY_HASH && |
| 365 | (alg & ~PSA_ALG_HASH_MASK) == (key_alg & ~PSA_ALG_HASH_MASK)) { |
| 366 | return 1; |
| 367 | } |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 368 | #if defined(MBEDTLS_PSA_CRYPTO_CLIENT) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 369 | if (PSA_ALG_IS_SIGN_HASH(key_alg2) && |
| 370 | PSA_ALG_SIGN_GET_HASH(key_alg2) == PSA_ALG_ANY_HASH && |
| 371 | (alg & ~PSA_ALG_HASH_MASK) == (key_alg2 & ~PSA_ALG_HASH_MASK)) { |
| 372 | return 1; |
| 373 | } |
Valerio Setti | 2bd5366 | 2023-12-05 10:14:06 +0100 | [diff] [blame] | 374 | #endif /* MBEDTLS_PSA_CRYPTO_CLIENT */ |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 375 | } |
| 376 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 377 | return 0; |
Neil Armstrong | a88b158 | 2022-05-11 14:11:25 +0200 | [diff] [blame] | 378 | } |
| 379 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
| 380 | |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 381 | /* |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 382 | * Helper for mbedtls_pk_sign and mbedtls_pk_verify |
Manuel Pégourié-Gonnard | bfe32ef | 2013-08-22 14:55:30 +0200 | [diff] [blame] | 383 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 384 | static inline int pk_hashlen_helper(mbedtls_md_type_t md_alg, size_t *hash_len) |
Manuel Pégourié-Gonnard | bfe32ef | 2013-08-22 14:55:30 +0200 | [diff] [blame] | 385 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 386 | if (*hash_len != 0) { |
| 387 | return 0; |
| 388 | } |
Manuel Pégourié-Gonnard | bfe32ef | 2013-08-22 14:55:30 +0200 | [diff] [blame] | 389 | |
Manuel Pégourié-Gonnard | 9b41eb8 | 2023-03-28 11:14:24 +0200 | [diff] [blame] | 390 | *hash_len = mbedtls_md_get_size_from_type(md_alg); |
Manuel Pégourié-Gonnard | a370e06 | 2022-07-05 11:55:20 +0200 | [diff] [blame] | 391 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 392 | if (*hash_len == 0) { |
| 393 | return -1; |
| 394 | } |
Manuel Pégourié-Gonnard | bfe32ef | 2013-08-22 14:55:30 +0200 | [diff] [blame] | 395 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 396 | return 0; |
Manuel Pégourié-Gonnard | bfe32ef | 2013-08-22 14:55:30 +0200 | [diff] [blame] | 397 | } |
| 398 | |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 399 | #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 400 | /* |
| 401 | * Helper to set up a restart context if needed |
| 402 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 403 | static int pk_restart_setup(mbedtls_pk_restart_ctx *ctx, |
| 404 | const mbedtls_pk_info_t *info) |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 405 | { |
Manuel Pégourié-Gonnard | c8c12b6 | 2018-07-02 13:09:39 +0200 | [diff] [blame] | 406 | /* Don't do anything if already set up or invalid */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 407 | if (ctx == NULL || ctx->pk_info != NULL) { |
| 408 | return 0; |
| 409 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 410 | |
| 411 | /* Should never happen when we're called */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 412 | if (info->rs_alloc_func == NULL || info->rs_free_func == NULL) { |
| 413 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 414 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 415 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 416 | if ((ctx->rs_ctx = info->rs_alloc_func()) == NULL) { |
| 417 | return MBEDTLS_ERR_PK_ALLOC_FAILED; |
| 418 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 419 | |
| 420 | ctx->pk_info = info; |
| 421 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 422 | return 0; |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 423 | } |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 424 | #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */ |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 425 | |
Manuel Pégourié-Gonnard | bfe32ef | 2013-08-22 14:55:30 +0200 | [diff] [blame] | 426 | /* |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 427 | * Verify a signature (restartable) |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 428 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 429 | int mbedtls_pk_verify_restartable(mbedtls_pk_context *ctx, |
| 430 | mbedtls_md_type_t md_alg, |
| 431 | const unsigned char *hash, size_t hash_len, |
| 432 | const unsigned char *sig, size_t sig_len, |
| 433 | mbedtls_pk_restart_ctx *rs_ctx) |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 434 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 435 | if ((md_alg != MBEDTLS_MD_NONE || hash_len != 0) && hash == NULL) { |
Tuvshinzaya Erdenekhuu | 78c1d8c | 2022-07-29 14:51:50 +0100 | [diff] [blame] | 436 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 437 | } |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 438 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 439 | if (ctx->pk_info == NULL || |
| 440 | pk_hashlen_helper(md_alg, &hash_len) != 0) { |
| 441 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 442 | } |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 443 | |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 444 | #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) |
Manuel Pégourié-Gonnard | d55f776 | 2017-08-18 17:40:15 +0200 | [diff] [blame] | 445 | /* optimization: use non-restartable version if restart disabled */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 446 | if (rs_ctx != NULL && |
Manuel Pégourié-Gonnard | b843b15 | 2018-10-16 10:41:31 +0200 | [diff] [blame] | 447 | mbedtls_ecp_restart_is_enabled() && |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 448 | ctx->pk_info->verify_rs_func != NULL) { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 449 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 450 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 451 | if ((ret = pk_restart_setup(rs_ctx, ctx->pk_info)) != 0) { |
| 452 | return ret; |
| 453 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 454 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 455 | ret = ctx->pk_info->verify_rs_func(ctx, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 456 | md_alg, hash, hash_len, sig, sig_len, rs_ctx->rs_ctx); |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 457 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 458 | if (ret != MBEDTLS_ERR_ECP_IN_PROGRESS) { |
| 459 | mbedtls_pk_restart_free(rs_ctx); |
| 460 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 461 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 462 | return ret; |
Manuel Pégourié-Gonnard | 1f59606 | 2017-05-09 10:42:40 +0200 | [diff] [blame] | 463 | } |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 464 | #else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */ |
Manuel Pégourié-Gonnard | 1f59606 | 2017-05-09 10:42:40 +0200 | [diff] [blame] | 465 | (void) rs_ctx; |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 466 | #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */ |
Manuel Pégourié-Gonnard | 1f59606 | 2017-05-09 10:42:40 +0200 | [diff] [blame] | 467 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 468 | if (ctx->pk_info->verify_func == NULL) { |
| 469 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 470 | } |
Manuel Pégourié-Gonnard | fff80f8 | 2013-08-17 15:20:06 +0200 | [diff] [blame] | 471 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 472 | return ctx->pk_info->verify_func(ctx, md_alg, hash, hash_len, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 473 | sig, sig_len); |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 474 | } |
| 475 | |
| 476 | /* |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 477 | * Verify a signature |
| 478 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 479 | int mbedtls_pk_verify(mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg, |
| 480 | const unsigned char *hash, size_t hash_len, |
| 481 | const unsigned char *sig, size_t sig_len) |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 482 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 483 | return mbedtls_pk_verify_restartable(ctx, md_alg, hash, hash_len, |
| 484 | sig, sig_len, NULL); |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 485 | } |
| 486 | |
| 487 | /* |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 488 | * Verify a signature with options |
| 489 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 490 | int mbedtls_pk_verify_ext(mbedtls_pk_type_t type, const void *options, |
| 491 | mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg, |
| 492 | const unsigned char *hash, size_t hash_len, |
| 493 | const unsigned char *sig, size_t sig_len) |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 494 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 495 | if ((md_alg != MBEDTLS_MD_NONE || hash_len != 0) && hash == NULL) { |
Tuvshinzaya Erdenekhuu | 78c1d8c | 2022-07-29 14:51:50 +0100 | [diff] [blame] | 496 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 497 | } |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 498 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 499 | if (ctx->pk_info == NULL) { |
| 500 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 501 | } |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 502 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 503 | if (!mbedtls_pk_can_do(ctx, type)) { |
| 504 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 505 | } |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 506 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 507 | if (type != MBEDTLS_PK_RSASSA_PSS) { |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 508 | /* General case: no options */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 509 | if (options != NULL) { |
| 510 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 511 | } |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 512 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 513 | return mbedtls_pk_verify(ctx, md_alg, hash, hash_len, sig, sig_len); |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 514 | } |
| 515 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 516 | #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21) |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 517 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
| 518 | const mbedtls_pk_rsassa_pss_options *pss_opts; |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 519 | |
Dave Rodgman | 02a53d7 | 2023-09-28 17:17:07 +0100 | [diff] [blame] | 520 | #if SIZE_MAX > UINT_MAX |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 521 | if (md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len) { |
| 522 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 523 | } |
Dave Rodgman | 02a53d7 | 2023-09-28 17:17:07 +0100 | [diff] [blame] | 524 | #endif |
Andres AG | 7284987 | 2017-01-19 11:24:33 +0000 | [diff] [blame] | 525 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 526 | if (options == NULL) { |
| 527 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 528 | } |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 529 | |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 530 | pss_opts = (const mbedtls_pk_rsassa_pss_options *) options; |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 531 | |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 532 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 533 | if (pss_opts->mgf1_hash_id == md_alg) { |
Manuel Pégourié-Gonnard | 4dacf58 | 2022-06-10 12:50:00 +0200 | [diff] [blame] | 534 | unsigned char buf[MBEDTLS_PK_RSA_PUB_DER_MAX_BYTES]; |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 535 | unsigned char *p; |
Andrzej Kurek | 5955053 | 2022-02-16 07:46:42 -0500 | [diff] [blame] | 536 | int key_len; |
| 537 | size_t signature_length; |
Andrzej Kurek | d70fa0e | 2022-02-17 10:51:15 -0500 | [diff] [blame] | 538 | psa_status_t status = PSA_ERROR_DATA_CORRUPT; |
| 539 | psa_status_t destruction_status = PSA_ERROR_DATA_CORRUPT; |
Andrzej Kurek | 5955053 | 2022-02-16 07:46:42 -0500 | [diff] [blame] | 540 | |
Manuel Pégourié-Gonnard | 2d6d993 | 2023-03-28 11:38:08 +0200 | [diff] [blame] | 541 | psa_algorithm_t psa_md_alg = mbedtls_md_psa_alg_from_type(md_alg); |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 542 | mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT; |
| 543 | psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 544 | psa_algorithm_t psa_sig_alg = PSA_ALG_RSA_PSS_ANY_SALT(psa_md_alg); |
| 545 | p = buf + sizeof(buf); |
| 546 | key_len = mbedtls_pk_write_pubkey(&p, buf, ctx); |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 547 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 548 | if (key_len < 0) { |
| 549 | return key_len; |
| 550 | } |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 551 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 552 | psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_PUBLIC_KEY); |
| 553 | psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_VERIFY_HASH); |
| 554 | psa_set_key_algorithm(&attributes, psa_sig_alg); |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 555 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 556 | status = psa_import_key(&attributes, |
| 557 | buf + sizeof(buf) - key_len, key_len, |
| 558 | &key_id); |
| 559 | if (status != PSA_SUCCESS) { |
| 560 | psa_destroy_key(key_id); |
Andrzej Kurek | 8a045ce | 2022-12-23 11:00:06 -0500 | [diff] [blame] | 561 | return PSA_PK_TO_MBEDTLS_ERR(status); |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 562 | } |
| 563 | |
Andrzej Kurek | 4a953cd | 2022-02-16 06:13:35 -0500 | [diff] [blame] | 564 | /* This function requires returning MBEDTLS_ERR_PK_SIG_LEN_MISMATCH |
| 565 | * on a valid signature with trailing data in a buffer, but |
| 566 | * mbedtls_psa_rsa_verify_hash requires the sig_len to be exact, |
| 567 | * so for this reason the passed sig_len is overwritten. Smaller |
| 568 | * signature lengths should not be accepted for verification. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 569 | signature_length = sig_len > mbedtls_pk_get_len(ctx) ? |
| 570 | mbedtls_pk_get_len(ctx) : sig_len; |
| 571 | status = psa_verify_hash(key_id, psa_sig_alg, hash, |
| 572 | hash_len, sig, signature_length); |
| 573 | destruction_status = psa_destroy_key(key_id); |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 574 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 575 | if (status == PSA_SUCCESS && sig_len > mbedtls_pk_get_len(ctx)) { |
| 576 | return MBEDTLS_ERR_PK_SIG_LEN_MISMATCH; |
| 577 | } |
Andrzej Kurek | 8666df6 | 2022-02-15 08:23:02 -0500 | [diff] [blame] | 578 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 579 | if (status == PSA_SUCCESS) { |
Andrzej Kurek | d70fa0e | 2022-02-17 10:51:15 -0500 | [diff] [blame] | 580 | status = destruction_status; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 581 | } |
Andrzej Kurek | d70fa0e | 2022-02-17 10:51:15 -0500 | [diff] [blame] | 582 | |
Andrzej Kurek | 8a045ce | 2022-12-23 11:00:06 -0500 | [diff] [blame] | 583 | return PSA_PK_RSA_TO_MBEDTLS_ERR(status); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 584 | } else |
Tomi Fontanilles | 8174662 | 2023-07-16 13:06:06 +0300 | [diff] [blame] | 585 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 586 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 587 | if (sig_len < mbedtls_pk_get_len(ctx)) { |
| 588 | return MBEDTLS_ERR_RSA_VERIFY_FAILED; |
| 589 | } |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 590 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 591 | ret = mbedtls_rsa_rsassa_pss_verify_ext(mbedtls_pk_rsa(*ctx), |
| 592 | md_alg, (unsigned int) hash_len, hash, |
| 593 | pss_opts->mgf1_hash_id, |
| 594 | pss_opts->expected_salt_len, |
| 595 | sig); |
| 596 | if (ret != 0) { |
| 597 | return ret; |
| 598 | } |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 599 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 600 | if (sig_len > mbedtls_pk_get_len(ctx)) { |
| 601 | return MBEDTLS_ERR_PK_SIG_LEN_MISMATCH; |
| 602 | } |
Andrzej Kurek | 90ba2cb | 2022-02-15 08:18:44 -0500 | [diff] [blame] | 603 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 604 | return 0; |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 605 | } |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 606 | #else |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 607 | return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE; |
Andrzej Kurek | 7db1b78 | 2022-02-09 14:13:44 -0500 | [diff] [blame] | 608 | #endif /* MBEDTLS_RSA_C && MBEDTLS_PKCS1_V21 */ |
Manuel Pégourié-Gonnard | 20422e9 | 2014-06-05 13:41:44 +0200 | [diff] [blame] | 609 | } |
| 610 | |
| 611 | /* |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 612 | * Make a signature (restartable) |
Manuel Pégourié-Gonnard | 8df2769 | 2013-08-21 10:34:38 +0200 | [diff] [blame] | 613 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 614 | int mbedtls_pk_sign_restartable(mbedtls_pk_context *ctx, |
| 615 | mbedtls_md_type_t md_alg, |
| 616 | const unsigned char *hash, size_t hash_len, |
| 617 | unsigned char *sig, size_t sig_size, size_t *sig_len, |
| 618 | int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, |
| 619 | mbedtls_pk_restart_ctx *rs_ctx) |
Manuel Pégourié-Gonnard | 8df2769 | 2013-08-21 10:34:38 +0200 | [diff] [blame] | 620 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 621 | if ((md_alg != MBEDTLS_MD_NONE || hash_len != 0) && hash == NULL) { |
Tuvshinzaya Erdenekhuu | 78c1d8c | 2022-07-29 14:51:50 +0100 | [diff] [blame] | 622 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 623 | } |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 624 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 625 | if (ctx->pk_info == NULL || pk_hashlen_helper(md_alg, &hash_len) != 0) { |
| 626 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 627 | } |
Manuel Pégourié-Gonnard | 8df2769 | 2013-08-21 10:34:38 +0200 | [diff] [blame] | 628 | |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 629 | #if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) |
Manuel Pégourié-Gonnard | d55f776 | 2017-08-18 17:40:15 +0200 | [diff] [blame] | 630 | /* optimization: use non-restartable version if restart disabled */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 631 | if (rs_ctx != NULL && |
Manuel Pégourié-Gonnard | b843b15 | 2018-10-16 10:41:31 +0200 | [diff] [blame] | 632 | mbedtls_ecp_restart_is_enabled() && |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 633 | ctx->pk_info->sign_rs_func != NULL) { |
Janos Follath | 24eed8d | 2019-11-22 13:21:35 +0000 | [diff] [blame] | 634 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 635 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 636 | if ((ret = pk_restart_setup(rs_ctx, ctx->pk_info)) != 0) { |
| 637 | return ret; |
| 638 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 639 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 640 | ret = ctx->pk_info->sign_rs_func(ctx, md_alg, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 641 | hash, hash_len, |
| 642 | sig, sig_size, sig_len, |
| 643 | f_rng, p_rng, rs_ctx->rs_ctx); |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 644 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 645 | if (ret != MBEDTLS_ERR_ECP_IN_PROGRESS) { |
| 646 | mbedtls_pk_restart_free(rs_ctx); |
| 647 | } |
Manuel Pégourié-Gonnard | 0bbc66c | 2017-08-18 16:22:06 +0200 | [diff] [blame] | 648 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 649 | return ret; |
Manuel Pégourié-Gonnard | 1f59606 | 2017-05-09 10:42:40 +0200 | [diff] [blame] | 650 | } |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 651 | #else /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */ |
Manuel Pégourié-Gonnard | 1f59606 | 2017-05-09 10:42:40 +0200 | [diff] [blame] | 652 | (void) rs_ctx; |
Manuel Pégourié-Gonnard | aaa9814 | 2017-08-18 17:30:37 +0200 | [diff] [blame] | 653 | #endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */ |
Manuel Pégourié-Gonnard | 1f59606 | 2017-05-09 10:42:40 +0200 | [diff] [blame] | 654 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 655 | if (ctx->pk_info->sign_func == NULL) { |
| 656 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 657 | } |
Manuel Pégourié-Gonnard | 8df2769 | 2013-08-21 10:34:38 +0200 | [diff] [blame] | 658 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 659 | return ctx->pk_info->sign_func(ctx, md_alg, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 660 | hash, hash_len, |
| 661 | sig, sig_size, sig_len, |
| 662 | f_rng, p_rng); |
Manuel Pégourié-Gonnard | 8df2769 | 2013-08-21 10:34:38 +0200 | [diff] [blame] | 663 | } |
| 664 | |
| 665 | /* |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 666 | * Make a signature |
| 667 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 668 | int mbedtls_pk_sign(mbedtls_pk_context *ctx, mbedtls_md_type_t md_alg, |
| 669 | const unsigned char *hash, size_t hash_len, |
| 670 | unsigned char *sig, size_t sig_size, size_t *sig_len, |
| 671 | int (*f_rng)(void *, unsigned char *, size_t), void *p_rng) |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 672 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 673 | return mbedtls_pk_sign_restartable(ctx, md_alg, hash, hash_len, |
| 674 | sig, sig_size, sig_len, |
| 675 | f_rng, p_rng, NULL); |
Manuel Pégourié-Gonnard | 82cb27b | 2017-05-03 10:59:45 +0200 | [diff] [blame] | 676 | } |
| 677 | |
| 678 | /* |
Jerry Yu | fb0621d | 2022-03-23 11:42:06 +0800 | [diff] [blame] | 679 | * Make a signature given a signature type. |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 680 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 681 | int mbedtls_pk_sign_ext(mbedtls_pk_type_t pk_type, |
| 682 | mbedtls_pk_context *ctx, |
| 683 | mbedtls_md_type_t md_alg, |
| 684 | const unsigned char *hash, size_t hash_len, |
| 685 | unsigned char *sig, size_t sig_size, size_t *sig_len, |
| 686 | int (*f_rng)(void *, unsigned char *, size_t), |
| 687 | void *p_rng) |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 688 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 689 | if (ctx->pk_info == NULL) { |
| 690 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 691 | } |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 692 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 693 | if (!mbedtls_pk_can_do(ctx, pk_type)) { |
| 694 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 695 | } |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 696 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 697 | if (pk_type != MBEDTLS_PK_RSASSA_PSS) { |
| 698 | return mbedtls_pk_sign(ctx, md_alg, hash, hash_len, |
| 699 | sig, sig_size, sig_len, f_rng, p_rng); |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 700 | } |
Neil Armstrong | 13e76be | 2022-04-21 12:08:52 +0200 | [diff] [blame] | 701 | |
Tomi Fontanilles | 8174662 | 2023-07-16 13:06:06 +0300 | [diff] [blame] | 702 | #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PKCS1_V21) |
| 703 | |
| 704 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
| 705 | const psa_algorithm_t psa_md_alg = mbedtls_md_psa_alg_from_type(md_alg); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 706 | if (psa_md_alg == 0) { |
| 707 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 708 | } |
Neil Armstrong | 13e76be | 2022-04-21 12:08:52 +0200 | [diff] [blame] | 709 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 710 | if (mbedtls_pk_get_type(ctx) == MBEDTLS_PK_OPAQUE) { |
Neil Armstrong | 13e76be | 2022-04-21 12:08:52 +0200 | [diff] [blame] | 711 | psa_status_t status; |
| 712 | |
Valerio Setti | 4f387ef | 2023-05-02 14:15:59 +0200 | [diff] [blame] | 713 | status = psa_sign_hash(ctx->priv_id, PSA_ALG_RSA_PSS(psa_md_alg), |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 714 | hash, hash_len, |
| 715 | sig, sig_size, sig_len); |
Andrzej Kurek | 8a045ce | 2022-12-23 11:00:06 -0500 | [diff] [blame] | 716 | return PSA_PK_RSA_TO_MBEDTLS_ERR(status); |
Neil Armstrong | 13e76be | 2022-04-21 12:08:52 +0200 | [diff] [blame] | 717 | } |
| 718 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 719 | return mbedtls_pk_psa_rsa_sign_ext(PSA_ALG_RSA_PSS(psa_md_alg), |
| 720 | ctx->pk_ctx, hash, hash_len, |
| 721 | sig, sig_size, sig_len); |
Tomi Fontanilles | 8174662 | 2023-07-16 13:06:06 +0300 | [diff] [blame] | 722 | #else /* MBEDTLS_USE_PSA_CRYPTO */ |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 723 | |
Tomi Fontanilles | 8174662 | 2023-07-16 13:06:06 +0300 | [diff] [blame] | 724 | if (sig_size < mbedtls_pk_get_len(ctx)) { |
| 725 | return MBEDTLS_ERR_PK_BUFFER_TOO_SMALL; |
| 726 | } |
| 727 | |
| 728 | if (pk_hashlen_helper(md_alg, &hash_len) != 0) { |
| 729 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 730 | } |
| 731 | |
| 732 | mbedtls_rsa_context *const rsa_ctx = mbedtls_pk_rsa(*ctx); |
| 733 | |
Tomi Fontanilles | 573dc23 | 2023-12-10 14:57:51 +0200 | [diff] [blame] | 734 | const int ret = mbedtls_rsa_rsassa_pss_sign_no_mode_check(rsa_ctx, f_rng, p_rng, md_alg, |
| 735 | (unsigned int) hash_len, hash, sig); |
Tomi Fontanilles | 8174662 | 2023-07-16 13:06:06 +0300 | [diff] [blame] | 736 | if (ret == 0) { |
| 737 | *sig_len = rsa_ctx->len; |
| 738 | } |
| 739 | return ret; |
| 740 | |
| 741 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
| 742 | |
| 743 | #else |
| 744 | return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE; |
| 745 | #endif /* MBEDTLS_RSA_C && MBEDTLS_PKCS1_V21 */ |
Jerry Yu | d69439a | 2022-02-24 15:52:15 +0800 | [diff] [blame] | 746 | } |
| 747 | |
| 748 | /* |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 749 | * Decrypt message |
| 750 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 751 | int mbedtls_pk_decrypt(mbedtls_pk_context *ctx, |
| 752 | const unsigned char *input, size_t ilen, |
| 753 | unsigned char *output, size_t *olen, size_t osize, |
| 754 | int (*f_rng)(void *, unsigned char *, size_t), void *p_rng) |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 755 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 756 | if (ctx->pk_info == NULL) { |
| 757 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 758 | } |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 759 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 760 | if (ctx->pk_info->decrypt_func == NULL) { |
| 761 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 762 | } |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 763 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 764 | return ctx->pk_info->decrypt_func(ctx, input, ilen, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 765 | output, olen, osize, f_rng, p_rng); |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 766 | } |
| 767 | |
| 768 | /* |
| 769 | * Encrypt message |
| 770 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 771 | int mbedtls_pk_encrypt(mbedtls_pk_context *ctx, |
| 772 | const unsigned char *input, size_t ilen, |
| 773 | unsigned char *output, size_t *olen, size_t osize, |
| 774 | int (*f_rng)(void *, unsigned char *, size_t), void *p_rng) |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 775 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 776 | if (ctx->pk_info == NULL) { |
| 777 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 778 | } |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 779 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 780 | if (ctx->pk_info->encrypt_func == NULL) { |
| 781 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 782 | } |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 783 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 784 | return ctx->pk_info->encrypt_func(ctx, input, ilen, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 785 | output, olen, osize, f_rng, p_rng); |
Manuel Pégourié-Gonnard | a2d3f22 | 2013-08-21 11:51:08 +0200 | [diff] [blame] | 786 | } |
| 787 | |
| 788 | /* |
Manuel Pégourié-Gonnard | 70bdadf | 2014-11-06 16:51:20 +0100 | [diff] [blame] | 789 | * Check public-private key pair |
| 790 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 791 | int mbedtls_pk_check_pair(const mbedtls_pk_context *pub, |
| 792 | const mbedtls_pk_context *prv, |
| 793 | int (*f_rng)(void *, unsigned char *, size_t), |
| 794 | void *p_rng) |
Manuel Pégourié-Gonnard | 70bdadf | 2014-11-06 16:51:20 +0100 | [diff] [blame] | 795 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 796 | if (pub->pk_info == NULL || |
| 797 | prv->pk_info == NULL) { |
| 798 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
Manuel Pégourié-Gonnard | 70bdadf | 2014-11-06 16:51:20 +0100 | [diff] [blame] | 799 | } |
| 800 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 801 | if (f_rng == NULL) { |
| 802 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
Manuel Pégourié-Gonnard | 70bdadf | 2014-11-06 16:51:20 +0100 | [diff] [blame] | 803 | } |
| 804 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 805 | if (prv->pk_info->check_pair_func == NULL) { |
| 806 | return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE; |
| 807 | } |
| 808 | |
| 809 | if (prv->pk_info->type == MBEDTLS_PK_RSA_ALT) { |
| 810 | if (pub->pk_info->type != MBEDTLS_PK_RSA) { |
| 811 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 812 | } |
| 813 | } else { |
valerio | 8cbef4d | 2023-06-01 10:59:03 +0200 | [diff] [blame] | 814 | if ((prv->pk_info->type != MBEDTLS_PK_OPAQUE) && |
| 815 | (pub->pk_info != prv->pk_info)) { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 816 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 817 | } |
| 818 | } |
| 819 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 820 | return prv->pk_info->check_pair_func((mbedtls_pk_context *) pub, |
| 821 | (mbedtls_pk_context *) prv, |
| 822 | f_rng, p_rng); |
Manuel Pégourié-Gonnard | 70bdadf | 2014-11-06 16:51:20 +0100 | [diff] [blame] | 823 | } |
| 824 | |
| 825 | /* |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 826 | * Get key size in bits |
| 827 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 828 | size_t mbedtls_pk_get_bitlen(const mbedtls_pk_context *ctx) |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 829 | { |
Andrzej Kurek | c470b6b | 2019-01-31 08:20:20 -0500 | [diff] [blame] | 830 | /* For backward compatibility, accept NULL or a context that |
| 831 | * isn't set up yet, and return a fake value that should be safe. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 832 | if (ctx == NULL || ctx->pk_info == NULL) { |
| 833 | return 0; |
| 834 | } |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 835 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 836 | return ctx->pk_info->get_bitlen((mbedtls_pk_context *) ctx); |
Manuel Pégourié-Gonnard | b3d9187 | 2013-08-14 15:56:19 +0200 | [diff] [blame] | 837 | } |
Manuel Pégourié-Gonnard | c6ac887 | 2013-08-14 18:04:18 +0200 | [diff] [blame] | 838 | |
| 839 | /* |
| 840 | * Export debug information |
| 841 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 842 | int mbedtls_pk_debug(const mbedtls_pk_context *ctx, mbedtls_pk_debug_item *items) |
Manuel Pégourié-Gonnard | c6ac887 | 2013-08-14 18:04:18 +0200 | [diff] [blame] | 843 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 844 | if (ctx->pk_info == NULL) { |
| 845 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 846 | } |
Manuel Pégourié-Gonnard | c6ac887 | 2013-08-14 18:04:18 +0200 | [diff] [blame] | 847 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 848 | if (ctx->pk_info->debug_func == NULL) { |
| 849 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
| 850 | } |
Manuel Pégourié-Gonnard | 0148875 | 2014-04-03 22:09:18 +0200 | [diff] [blame] | 851 | |
valerio | 38992cb | 2023-04-20 09:56:30 +0200 | [diff] [blame] | 852 | ctx->pk_info->debug_func((mbedtls_pk_context *) ctx, items); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 853 | return 0; |
Manuel Pégourié-Gonnard | c6ac887 | 2013-08-14 18:04:18 +0200 | [diff] [blame] | 854 | } |
Manuel Pégourié-Gonnard | 3fb5c5e | 2013-08-14 18:26:41 +0200 | [diff] [blame] | 855 | |
| 856 | /* |
| 857 | * Access the PK type name |
| 858 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 859 | const char *mbedtls_pk_get_name(const mbedtls_pk_context *ctx) |
Manuel Pégourié-Gonnard | 3fb5c5e | 2013-08-14 18:26:41 +0200 | [diff] [blame] | 860 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 861 | if (ctx == NULL || ctx->pk_info == NULL) { |
| 862 | return "invalid PK"; |
| 863 | } |
Manuel Pégourié-Gonnard | 3fb5c5e | 2013-08-14 18:26:41 +0200 | [diff] [blame] | 864 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 865 | return ctx->pk_info->name; |
Manuel Pégourié-Gonnard | 3fb5c5e | 2013-08-14 18:26:41 +0200 | [diff] [blame] | 866 | } |
Manuel Pégourié-Gonnard | c40b4c3 | 2013-08-22 13:29:31 +0200 | [diff] [blame] | 867 | |
Manuel Pégourié-Gonnard | 8053da4 | 2013-09-11 22:28:30 +0200 | [diff] [blame] | 868 | /* |
| 869 | * Access the PK type |
| 870 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 871 | mbedtls_pk_type_t mbedtls_pk_get_type(const mbedtls_pk_context *ctx) |
Manuel Pégourié-Gonnard | 8053da4 | 2013-09-11 22:28:30 +0200 | [diff] [blame] | 872 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 873 | if (ctx == NULL || ctx->pk_info == NULL) { |
| 874 | return MBEDTLS_PK_NONE; |
| 875 | } |
Manuel Pégourié-Gonnard | 8053da4 | 2013-09-11 22:28:30 +0200 | [diff] [blame] | 876 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 877 | return ctx->pk_info->type; |
Manuel Pégourié-Gonnard | 8053da4 | 2013-09-11 22:28:30 +0200 | [diff] [blame] | 878 | } |
| 879 | |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 880 | #if defined(MBEDTLS_USE_PSA_CRYPTO) |
| 881 | /* |
| 882 | * Load the key to a PSA key slot, |
| 883 | * then turn the PK context into a wrapper for that key slot. |
| 884 | * |
Neil Armstrong | 56e71d4 | 2022-04-08 15:12:42 +0200 | [diff] [blame] | 885 | * Currently only works for EC & RSA private keys. |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 886 | */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 887 | int mbedtls_pk_wrap_as_opaque(mbedtls_pk_context *pk, |
| 888 | mbedtls_svc_key_id_t *key, |
| 889 | psa_algorithm_t alg, |
| 890 | psa_key_usage_t usage, |
| 891 | psa_algorithm_t alg2) |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 892 | { |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 893 | #if !defined(MBEDTLS_PK_HAVE_ECC_KEYS) && !defined(MBEDTLS_RSA_C) |
John Durkop | f35069a | 2020-08-17 22:05:14 -0700 | [diff] [blame] | 894 | ((void) pk); |
Ronald Cron | cf56a0a | 2020-08-04 09:51:30 +0200 | [diff] [blame] | 895 | ((void) key); |
Neil Armstrong | a1fc18f | 2022-04-22 13:57:14 +0200 | [diff] [blame] | 896 | ((void) alg); |
| 897 | ((void) usage); |
| 898 | ((void) alg2); |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 899 | #else /* !MBEDTLS_PK_HAVE_ECC_KEYS && !MBEDTLS_RSA_C */ |
| 900 | #if defined(MBEDTLS_PK_HAVE_ECC_KEYS) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 901 | if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_ECKEY) { |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 902 | size_t d_len; |
| 903 | psa_ecc_family_t curve_id; |
| 904 | psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| 905 | psa_key_type_t key_type; |
| 906 | size_t bits; |
Neil Armstrong | c1152e4 | 2022-03-22 10:29:06 +0100 | [diff] [blame] | 907 | psa_status_t status; |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 908 | |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 909 | /* export the private key material in the format PSA wants */ |
Valerio Setti | ae8c628 | 2023-05-18 18:57:57 +0200 | [diff] [blame] | 910 | #if defined(MBEDTLS_PK_USE_PSA_EC_DATA) |
Valerio Setti | 1194ffa | 2023-05-24 13:15:58 +0200 | [diff] [blame] | 911 | unsigned char d[MBEDTLS_PSA_MAX_EC_KEY_PAIR_LENGTH]; |
Valerio Setti | ae8c628 | 2023-05-18 18:57:57 +0200 | [diff] [blame] | 912 | status = psa_export_key(pk->priv_id, d, sizeof(d), &d_len); |
| 913 | if (status != PSA_SUCCESS) { |
| 914 | return psa_pk_status_to_mbedtls(status); |
| 915 | } |
| 916 | |
| 917 | curve_id = pk->ec_family; |
| 918 | bits = pk->ec_bits; |
| 919 | #else /* MBEDTLS_PK_USE_PSA_EC_DATA */ |
Valerio Setti | 1194ffa | 2023-05-24 13:15:58 +0200 | [diff] [blame] | 920 | unsigned char d[MBEDTLS_ECP_MAX_BYTES]; |
Valerio Setti | ae8c628 | 2023-05-18 18:57:57 +0200 | [diff] [blame] | 921 | mbedtls_ecp_keypair *ec = mbedtls_pk_ec_rw(*pk); |
| 922 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
| 923 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 924 | d_len = PSA_BITS_TO_BYTES(ec->grp.nbits); |
Jethro Beekman | 33a3ccd | 2023-05-03 18:25:27 +0200 | [diff] [blame] | 925 | if ((ret = mbedtls_ecp_write_key(ec, d, d_len)) != 0) { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 926 | return ret; |
| 927 | } |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 928 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 929 | curve_id = mbedtls_ecc_group_to_psa(ec->grp.id, &bits); |
Valerio Setti | ae8c628 | 2023-05-18 18:57:57 +0200 | [diff] [blame] | 930 | #endif /* MBEDTLS_PK_USE_PSA_EC_DATA */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 931 | key_type = PSA_KEY_TYPE_ECC_KEY_PAIR(curve_id); |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 932 | |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 933 | /* prepare the key attributes */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 934 | psa_set_key_type(&attributes, key_type); |
| 935 | psa_set_key_bits(&attributes, bits); |
| 936 | psa_set_key_usage_flags(&attributes, usage); |
| 937 | psa_set_key_algorithm(&attributes, alg); |
| 938 | if (alg2 != PSA_ALG_NONE) { |
| 939 | psa_set_key_enrollment_algorithm(&attributes, alg2); |
| 940 | } |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 941 | |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 942 | /* import private key into PSA */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 943 | status = psa_import_key(&attributes, d, d_len, key); |
Valerio Setti | 2d81499 | 2023-04-27 10:05:03 +0200 | [diff] [blame] | 944 | mbedtls_platform_zeroize(d, sizeof(d)); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 945 | if (status != PSA_SUCCESS) { |
Andrzej Kurek | 8a045ce | 2022-12-23 11:00:06 -0500 | [diff] [blame] | 946 | return PSA_PK_TO_MBEDTLS_ERR(status); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 947 | } |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 948 | |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 949 | /* make PK context wrap the key slot */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 950 | mbedtls_pk_free(pk); |
| 951 | mbedtls_pk_init(pk); |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 952 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 953 | return mbedtls_pk_setup_opaque(pk, *key); |
| 954 | } else |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 955 | #endif /* MBEDTLS_PK_HAVE_ECC_KEYS */ |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 956 | #if defined(MBEDTLS_RSA_C) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 957 | if (mbedtls_pk_get_type(pk) == MBEDTLS_PK_RSA) { |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 958 | unsigned char buf[MBEDTLS_PK_RSA_PRV_DER_MAX_BYTES]; |
| 959 | psa_key_attributes_t attributes = PSA_KEY_ATTRIBUTES_INIT; |
| 960 | int key_len; |
| 961 | psa_status_t status; |
| 962 | |
| 963 | /* export the private key material in the format PSA wants */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 964 | key_len = mbedtls_pk_write_key_der(pk, buf, sizeof(buf)); |
| 965 | if (key_len <= 0) { |
| 966 | return MBEDTLS_ERR_PK_BAD_INPUT_DATA; |
| 967 | } |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 968 | |
| 969 | /* prepare the key attributes */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 970 | psa_set_key_type(&attributes, PSA_KEY_TYPE_RSA_KEY_PAIR); |
| 971 | psa_set_key_bits(&attributes, mbedtls_pk_get_bitlen(pk)); |
| 972 | psa_set_key_usage_flags(&attributes, usage); |
| 973 | psa_set_key_algorithm(&attributes, alg); |
| 974 | if (alg2 != PSA_ALG_NONE) { |
| 975 | psa_set_key_enrollment_algorithm(&attributes, alg2); |
| 976 | } |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 977 | |
| 978 | /* import private key into PSA */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 979 | status = psa_import_key(&attributes, |
| 980 | buf + sizeof(buf) - key_len, |
| 981 | key_len, key); |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 982 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 983 | mbedtls_platform_zeroize(buf, sizeof(buf)); |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 984 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 985 | if (status != PSA_SUCCESS) { |
Andrzej Kurek | 8a045ce | 2022-12-23 11:00:06 -0500 | [diff] [blame] | 986 | return PSA_PK_TO_MBEDTLS_ERR(status); |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 987 | } |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 988 | |
| 989 | /* make PK context wrap the key slot */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 990 | mbedtls_pk_free(pk); |
| 991 | mbedtls_pk_init(pk); |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 992 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 993 | return mbedtls_pk_setup_opaque(pk, *key); |
| 994 | } else |
Neil Armstrong | ca5b55f | 2022-03-15 15:00:55 +0100 | [diff] [blame] | 995 | #endif /* MBEDTLS_RSA_C */ |
Valerio Setti | 81d7512 | 2023-06-14 14:49:33 +0200 | [diff] [blame] | 996 | #endif /* !MBEDTLS_PK_HAVE_ECC_KEYS && !MBEDTLS_RSA_C */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 997 | return MBEDTLS_ERR_PK_TYPE_MISMATCH; |
Manuel Pégourié-Gonnard | 347a00e | 2018-11-19 12:25:37 +0100 | [diff] [blame] | 998 | } |
| 999 | #endif /* MBEDTLS_USE_PSA_CRYPTO */ |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 1000 | #endif /* MBEDTLS_PK_C */ |