Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 1 | /* |
| 2 | * PSA MAC layer on top of Mbed TLS software crypto |
| 3 | */ |
| 4 | /* |
| 5 | * Copyright The Mbed TLS Contributors |
Dave Rodgman | 16799db | 2023-11-02 19:47:20 +0000 | [diff] [blame] | 6 | * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 7 | */ |
| 8 | |
| 9 | #include "common.h" |
| 10 | |
| 11 | #if defined(MBEDTLS_PSA_CRYPTO_C) |
| 12 | |
| 13 | #include <psa/crypto.h> |
| 14 | #include "psa_crypto_core.h" |
Dave Rodgman | 1630447 | 2022-11-02 09:25:38 +0000 | [diff] [blame] | 15 | #include "psa_crypto_cipher.h" |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 16 | #include "psa_crypto_mac.h" |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 17 | #include <mbedtls/md.h> |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 18 | |
| 19 | #include <mbedtls/error.h> |
Dave Rodgman | 7870115 | 2023-08-29 14:20:18 +0100 | [diff] [blame] | 20 | #include "mbedtls/constant_time.h" |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 21 | #include <string.h> |
| 22 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 23 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) |
Steven Cooreman | a6df604 | 2021-04-29 19:32:25 +0200 | [diff] [blame] | 24 | static psa_status_t psa_hmac_abort_internal( |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 25 | mbedtls_psa_hmac_operation_t *hmac) |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 26 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 27 | mbedtls_platform_zeroize(hmac->opad, sizeof(hmac->opad)); |
| 28 | return psa_hash_abort(&hmac->hash_ctx); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 29 | } |
| 30 | |
Steven Cooreman | a6df604 | 2021-04-29 19:32:25 +0200 | [diff] [blame] | 31 | static psa_status_t psa_hmac_setup_internal( |
| 32 | mbedtls_psa_hmac_operation_t *hmac, |
| 33 | const uint8_t *key, |
| 34 | size_t key_length, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 35 | psa_algorithm_t hash_alg) |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 36 | { |
| 37 | uint8_t ipad[PSA_HMAC_MAX_HASH_BLOCK_SIZE]; |
| 38 | size_t i; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 39 | size_t hash_size = PSA_HASH_LENGTH(hash_alg); |
| 40 | size_t block_size = PSA_HASH_BLOCK_LENGTH(hash_alg); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 41 | psa_status_t status; |
| 42 | |
| 43 | hmac->alg = hash_alg; |
| 44 | |
| 45 | /* Sanity checks on block_size, to guarantee that there won't be a buffer |
| 46 | * overflow below. This should never trigger if the hash algorithm |
| 47 | * is implemented correctly. */ |
| 48 | /* The size checks against the ipad and opad buffers cannot be written |
| 49 | * `block_size > sizeof( ipad ) || block_size > sizeof( hmac->opad )` |
| 50 | * because that triggers -Wlogical-op on GCC 7.3. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 51 | if (block_size > sizeof(ipad)) { |
| 52 | return PSA_ERROR_NOT_SUPPORTED; |
| 53 | } |
| 54 | if (block_size > sizeof(hmac->opad)) { |
| 55 | return PSA_ERROR_NOT_SUPPORTED; |
| 56 | } |
| 57 | if (block_size < hash_size) { |
| 58 | return PSA_ERROR_NOT_SUPPORTED; |
| 59 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 60 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 61 | if (key_length > block_size) { |
| 62 | status = psa_hash_compute(hash_alg, key, key_length, |
| 63 | ipad, sizeof(ipad), &key_length); |
| 64 | if (status != PSA_SUCCESS) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 65 | goto cleanup; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 66 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 67 | } |
| 68 | /* A 0-length key is not commonly used in HMAC when used as a MAC, |
| 69 | * but it is permitted. It is common when HMAC is used in HKDF, for |
| 70 | * example. Don't call `memcpy` in the 0-length because `key` could be |
| 71 | * an invalid pointer which would make the behavior undefined. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 72 | else if (key_length != 0) { |
| 73 | memcpy(ipad, key, key_length); |
| 74 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 75 | |
| 76 | /* ipad contains the key followed by garbage. Xor and fill with 0x36 |
| 77 | * to create the ipad value. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 78 | for (i = 0; i < key_length; i++) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 79 | ipad[i] ^= 0x36; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 80 | } |
| 81 | memset(ipad + key_length, 0x36, block_size - key_length); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 82 | |
| 83 | /* Copy the key material from ipad to opad, flipping the requisite bits, |
| 84 | * and filling the rest of opad with the requisite constant. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 85 | for (i = 0; i < key_length; i++) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 86 | hmac->opad[i] = ipad[i] ^ 0x36 ^ 0x5C; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 87 | } |
| 88 | memset(hmac->opad + key_length, 0x5C, block_size - key_length); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 89 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 90 | status = psa_hash_setup(&hmac->hash_ctx, hash_alg); |
| 91 | if (status != PSA_SUCCESS) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 92 | goto cleanup; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 93 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 94 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 95 | status = psa_hash_update(&hmac->hash_ctx, ipad, block_size); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 96 | |
| 97 | cleanup: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 98 | mbedtls_platform_zeroize(ipad, sizeof(ipad)); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 99 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 100 | return status; |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 101 | } |
| 102 | |
Steven Cooreman | a6df604 | 2021-04-29 19:32:25 +0200 | [diff] [blame] | 103 | static psa_status_t psa_hmac_update_internal( |
| 104 | mbedtls_psa_hmac_operation_t *hmac, |
| 105 | const uint8_t *data, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 106 | size_t data_length) |
Steven Cooreman | 4fdf060 | 2021-03-22 12:21:10 +0100 | [diff] [blame] | 107 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 108 | return psa_hash_update(&hmac->hash_ctx, data, data_length); |
Steven Cooreman | 4fdf060 | 2021-03-22 12:21:10 +0100 | [diff] [blame] | 109 | } |
| 110 | |
Steven Cooreman | a6df604 | 2021-04-29 19:32:25 +0200 | [diff] [blame] | 111 | static psa_status_t psa_hmac_finish_internal( |
| 112 | mbedtls_psa_hmac_operation_t *hmac, |
| 113 | uint8_t *mac, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 114 | size_t mac_size) |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 115 | { |
Ronald Cron | 69a6342 | 2021-10-18 09:47:58 +0200 | [diff] [blame] | 116 | uint8_t tmp[PSA_HASH_MAX_SIZE]; |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 117 | psa_algorithm_t hash_alg = hmac->alg; |
| 118 | size_t hash_size = 0; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 119 | size_t block_size = PSA_HASH_BLOCK_LENGTH(hash_alg); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 120 | psa_status_t status; |
| 121 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 122 | status = psa_hash_finish(&hmac->hash_ctx, tmp, sizeof(tmp), &hash_size); |
| 123 | if (status != PSA_SUCCESS) { |
| 124 | return status; |
| 125 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 126 | /* From here on, tmp needs to be wiped. */ |
| 127 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 128 | status = psa_hash_setup(&hmac->hash_ctx, hash_alg); |
| 129 | if (status != PSA_SUCCESS) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 130 | goto exit; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 131 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 132 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 133 | status = psa_hash_update(&hmac->hash_ctx, hmac->opad, block_size); |
| 134 | if (status != PSA_SUCCESS) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 135 | goto exit; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 136 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 137 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 138 | status = psa_hash_update(&hmac->hash_ctx, tmp, hash_size); |
| 139 | if (status != PSA_SUCCESS) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 140 | goto exit; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 141 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 142 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 143 | status = psa_hash_finish(&hmac->hash_ctx, tmp, sizeof(tmp), &hash_size); |
| 144 | if (status != PSA_SUCCESS) { |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 145 | goto exit; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 146 | } |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 147 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 148 | memcpy(mac, tmp, mac_size); |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 149 | |
| 150 | exit: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 151 | mbedtls_platform_zeroize(tmp, hash_size); |
| 152 | return status; |
Steven Cooreman | 82c66b6 | 2021-03-19 17:39:17 +0100 | [diff] [blame] | 153 | } |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 154 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC */ |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 155 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 156 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 157 | static psa_status_t cmac_setup(mbedtls_psa_mac_operation_t *operation, |
| 158 | const psa_key_attributes_t *attributes, |
| 159 | const uint8_t *key_buffer) |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 160 | { |
| 161 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
Steven Cooreman | 0c23965 | 2021-05-07 17:27:27 +0200 | [diff] [blame] | 162 | |
| 163 | #if defined(PSA_WANT_KEY_TYPE_DES) |
| 164 | /* Mbed TLS CMAC does not accept 3DES with only two keys, nor does it accept |
| 165 | * to do CMAC with pure DES, so return NOT_SUPPORTED here. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 166 | if (psa_get_key_type(attributes) == PSA_KEY_TYPE_DES && |
| 167 | (psa_get_key_bits(attributes) == 64 || |
| 168 | psa_get_key_bits(attributes) == 128)) { |
| 169 | return PSA_ERROR_NOT_SUPPORTED; |
| 170 | } |
Steven Cooreman | 0c23965 | 2021-05-07 17:27:27 +0200 | [diff] [blame] | 171 | #endif |
| 172 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 173 | const mbedtls_cipher_info_t *cipher_info = |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 174 | mbedtls_cipher_info_from_psa( |
| 175 | PSA_ALG_CMAC, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 176 | psa_get_key_type(attributes), |
| 177 | psa_get_key_bits(attributes), |
| 178 | NULL); |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 179 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 180 | if (cipher_info == NULL) { |
| 181 | return PSA_ERROR_NOT_SUPPORTED; |
| 182 | } |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 183 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 184 | ret = mbedtls_cipher_setup(&operation->ctx.cmac, cipher_info); |
| 185 | if (ret != 0) { |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 186 | goto exit; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 187 | } |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 188 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 189 | ret = mbedtls_cipher_cmac_starts(&operation->ctx.cmac, |
| 190 | key_buffer, |
| 191 | psa_get_key_bits(attributes)); |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 192 | exit: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 193 | return mbedtls_to_psa_error(ret); |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 194 | } |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 195 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 196 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 197 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) || \ |
| 198 | defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Steven Cooreman | 02865f5 | 2021-05-07 15:55:27 +0200 | [diff] [blame] | 199 | |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 200 | /* Initialize this driver's MAC operation structure. Once this function has been |
| 201 | * called, mbedtls_psa_mac_abort can run and will do the right thing. */ |
| 202 | static psa_status_t mac_init( |
| 203 | mbedtls_psa_mac_operation_t *operation, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 204 | psa_algorithm_t alg) |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 205 | { |
Steven Cooreman | ba9a5bf | 2021-04-29 16:21:24 +0200 | [diff] [blame] | 206 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 207 | |
Steven Cooreman | 72f736a | 2021-05-07 14:14:37 +0200 | [diff] [blame] | 208 | operation->alg = alg; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 209 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 210 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 211 | if (PSA_ALG_FULL_LENGTH_MAC(operation->alg) == PSA_ALG_CMAC) { |
| 212 | mbedtls_cipher_init(&operation->ctx.cmac); |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 213 | status = PSA_SUCCESS; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 214 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 215 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
| 216 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 217 | if (PSA_ALG_IS_HMAC(operation->alg)) { |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 218 | /* We'll set up the hash operation later in psa_hmac_setup_internal. */ |
| 219 | operation->ctx.hmac.alg = 0; |
| 220 | status = PSA_SUCCESS; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 221 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 222 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC */ |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 223 | { |
Ronald Cron | 7a55deb | 2021-04-28 14:29:00 +0200 | [diff] [blame] | 224 | (void) operation; |
Steven Cooreman | ba9a5bf | 2021-04-29 16:21:24 +0200 | [diff] [blame] | 225 | status = PSA_ERROR_NOT_SUPPORTED; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 226 | } |
| 227 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 228 | if (status != PSA_SUCCESS) { |
| 229 | memset(operation, 0, sizeof(*operation)); |
| 230 | } |
| 231 | return status; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 232 | } |
| 233 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 234 | psa_status_t mbedtls_psa_mac_abort(mbedtls_psa_mac_operation_t *operation) |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 235 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 236 | if (operation->alg == 0) { |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 237 | /* The object has (apparently) been initialized but it is not |
| 238 | * in use. It's ok to call abort on such an object, and there's |
| 239 | * nothing to do. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 240 | return PSA_SUCCESS; |
| 241 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 242 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 243 | if (PSA_ALG_FULL_LENGTH_MAC(operation->alg) == PSA_ALG_CMAC) { |
| 244 | mbedtls_cipher_free(&operation->ctx.cmac); |
| 245 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 246 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
| 247 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 248 | if (PSA_ALG_IS_HMAC(operation->alg)) { |
| 249 | psa_hmac_abort_internal(&operation->ctx.hmac); |
| 250 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 251 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC */ |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 252 | { |
| 253 | /* Sanity check (shouldn't happen: operation->alg should |
| 254 | * always have been initialized to a valid value). */ |
| 255 | goto bad_state; |
| 256 | } |
| 257 | |
| 258 | operation->alg = 0; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 259 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 260 | return PSA_SUCCESS; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 261 | |
| 262 | bad_state: |
| 263 | /* If abort is called on an uninitialized object, we can't trust |
| 264 | * anything. Wipe the object in case it contains confidential data. |
| 265 | * This may result in a memory leak if a pointer gets overwritten, |
| 266 | * but it's too late to do anything about this. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 267 | memset(operation, 0, sizeof(*operation)); |
| 268 | return PSA_ERROR_BAD_STATE; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 269 | } |
| 270 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 271 | static psa_status_t psa_mac_setup(mbedtls_psa_mac_operation_t *operation, |
| 272 | const psa_key_attributes_t *attributes, |
| 273 | const uint8_t *key_buffer, |
| 274 | size_t key_buffer_size, |
| 275 | psa_algorithm_t alg) |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 276 | { |
| 277 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
| 278 | |
| 279 | /* A context must be freshly initialized before it can be set up. */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 280 | if (operation->alg != 0) { |
| 281 | return PSA_ERROR_BAD_STATE; |
| 282 | } |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 283 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 284 | status = mac_init(operation, alg); |
| 285 | if (status != PSA_SUCCESS) { |
| 286 | return status; |
| 287 | } |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 288 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 289 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 290 | if (PSA_ALG_FULL_LENGTH_MAC(alg) == PSA_ALG_CMAC) { |
Steven Cooreman | dcd0811 | 2021-05-06 18:00:37 +0200 | [diff] [blame] | 291 | /* Key buffer size for CMAC is dictated by the key bits set on the |
| 292 | * attributes, and previously validated by the core on key import. */ |
| 293 | (void) key_buffer_size; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 294 | status = cmac_setup(operation, attributes, key_buffer); |
| 295 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 296 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
| 297 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 298 | if (PSA_ALG_IS_HMAC(alg)) { |
| 299 | status = psa_hmac_setup_internal(&operation->ctx.hmac, |
| 300 | key_buffer, |
| 301 | key_buffer_size, |
| 302 | PSA_ALG_HMAC_GET_HASH(alg)); |
| 303 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 304 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC */ |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 305 | { |
Steven Cooreman | b29902a | 2021-05-10 09:47:05 +0200 | [diff] [blame] | 306 | (void) attributes; |
| 307 | (void) key_buffer; |
| 308 | (void) key_buffer_size; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 309 | status = PSA_ERROR_NOT_SUPPORTED; |
| 310 | } |
| 311 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 312 | if (status != PSA_SUCCESS) { |
| 313 | mbedtls_psa_mac_abort(operation); |
| 314 | } |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 315 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 316 | return status; |
Steven Cooreman | e680419 | 2021-03-19 18:28:56 +0100 | [diff] [blame] | 317 | } |
| 318 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 319 | psa_status_t mbedtls_psa_mac_sign_setup( |
| 320 | mbedtls_psa_mac_operation_t *operation, |
| 321 | const psa_key_attributes_t *attributes, |
| 322 | const uint8_t *key_buffer, |
| 323 | size_t key_buffer_size, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 324 | psa_algorithm_t alg) |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 325 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 326 | return psa_mac_setup(operation, attributes, |
| 327 | key_buffer, key_buffer_size, alg); |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 328 | } |
| 329 | |
| 330 | psa_status_t mbedtls_psa_mac_verify_setup( |
| 331 | mbedtls_psa_mac_operation_t *operation, |
| 332 | const psa_key_attributes_t *attributes, |
| 333 | const uint8_t *key_buffer, |
| 334 | size_t key_buffer_size, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 335 | psa_algorithm_t alg) |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 336 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 337 | return psa_mac_setup(operation, attributes, |
| 338 | key_buffer, key_buffer_size, alg); |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 339 | } |
| 340 | |
| 341 | psa_status_t mbedtls_psa_mac_update( |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 342 | mbedtls_psa_mac_operation_t *operation, |
| 343 | const uint8_t *input, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 344 | size_t input_length) |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 345 | { |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 346 | if (operation->alg == 0) { |
| 347 | return PSA_ERROR_BAD_STATE; |
| 348 | } |
Steven Cooreman | 6e7f291 | 2021-03-19 18:38:46 +0100 | [diff] [blame] | 349 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 350 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 351 | if (PSA_ALG_FULL_LENGTH_MAC(operation->alg) == PSA_ALG_CMAC) { |
| 352 | return mbedtls_to_psa_error( |
| 353 | mbedtls_cipher_cmac_update(&operation->ctx.cmac, |
| 354 | input, input_length)); |
| 355 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 356 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
| 357 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 358 | if (PSA_ALG_IS_HMAC(operation->alg)) { |
| 359 | return psa_hmac_update_internal(&operation->ctx.hmac, |
| 360 | input, input_length); |
| 361 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 362 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC */ |
Steven Cooreman | 6e7f291 | 2021-03-19 18:38:46 +0100 | [diff] [blame] | 363 | { |
| 364 | /* This shouldn't happen if `operation` was initialized by |
| 365 | * a setup function. */ |
Steven Cooreman | b29902a | 2021-05-10 09:47:05 +0200 | [diff] [blame] | 366 | (void) input; |
| 367 | (void) input_length; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 368 | return PSA_ERROR_BAD_STATE; |
Steven Cooreman | 6e7f291 | 2021-03-19 18:38:46 +0100 | [diff] [blame] | 369 | } |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 370 | } |
| 371 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 372 | static psa_status_t psa_mac_finish_internal( |
| 373 | mbedtls_psa_mac_operation_t *operation, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 374 | uint8_t *mac, size_t mac_size) |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 375 | { |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 376 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_CMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 377 | if (PSA_ALG_FULL_LENGTH_MAC(operation->alg) == PSA_ALG_CMAC) { |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 378 | uint8_t tmp[PSA_BLOCK_CIPHER_BLOCK_MAX_SIZE]; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 379 | int ret = mbedtls_cipher_cmac_finish(&operation->ctx.cmac, tmp); |
| 380 | if (ret == 0) { |
| 381 | memcpy(mac, tmp, mac_size); |
| 382 | } |
| 383 | mbedtls_platform_zeroize(tmp, sizeof(tmp)); |
| 384 | return mbedtls_to_psa_error(ret); |
| 385 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 386 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
| 387 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HMAC) |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 388 | if (PSA_ALG_IS_HMAC(operation->alg)) { |
| 389 | return psa_hmac_finish_internal(&operation->ctx.hmac, |
| 390 | mac, mac_size); |
| 391 | } else |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 392 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC */ |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 393 | { |
| 394 | /* This shouldn't happen if `operation` was initialized by |
| 395 | * a setup function. */ |
Steven Cooreman | 72f736a | 2021-05-07 14:14:37 +0200 | [diff] [blame] | 396 | (void) operation; |
| 397 | (void) mac; |
| 398 | (void) mac_size; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 399 | return PSA_ERROR_BAD_STATE; |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 400 | } |
| 401 | } |
| 402 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 403 | psa_status_t mbedtls_psa_mac_sign_finish( |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 404 | mbedtls_psa_mac_operation_t *operation, |
| 405 | uint8_t *mac, |
| 406 | size_t mac_size, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 407 | size_t *mac_length) |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 408 | { |
Steven Cooreman | 094a77e | 2021-05-06 17:58:36 +0200 | [diff] [blame] | 409 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 410 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 411 | if (operation->alg == 0) { |
| 412 | return PSA_ERROR_BAD_STATE; |
| 413 | } |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 414 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 415 | status = psa_mac_finish_internal(operation, mac, mac_size); |
| 416 | if (status == PSA_SUCCESS) { |
Steven Cooreman | 72f736a | 2021-05-07 14:14:37 +0200 | [diff] [blame] | 417 | *mac_length = mac_size; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 418 | } |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 419 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 420 | return status; |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 421 | } |
| 422 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 423 | psa_status_t mbedtls_psa_mac_verify_finish( |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 424 | mbedtls_psa_mac_operation_t *operation, |
| 425 | const uint8_t *mac, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 426 | size_t mac_length) |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 427 | { |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 428 | uint8_t actual_mac[PSA_MAC_MAX_SIZE]; |
Steven Cooreman | 094a77e | 2021-05-06 17:58:36 +0200 | [diff] [blame] | 429 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 430 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 431 | if (operation->alg == 0) { |
| 432 | return PSA_ERROR_BAD_STATE; |
| 433 | } |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 434 | |
Steven Cooreman | 72f736a | 2021-05-07 14:14:37 +0200 | [diff] [blame] | 435 | /* Consistency check: requested MAC length fits our local buffer */ |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 436 | if (mac_length > sizeof(actual_mac)) { |
| 437 | return PSA_ERROR_INVALID_ARGUMENT; |
| 438 | } |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 439 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 440 | status = psa_mac_finish_internal(operation, actual_mac, mac_length); |
| 441 | if (status != PSA_SUCCESS) { |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 442 | goto cleanup; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 443 | } |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 444 | |
Dave Rodgman | 7870115 | 2023-08-29 14:20:18 +0100 | [diff] [blame] | 445 | if (mbedtls_ct_memcmp(mac, actual_mac, mac_length) != 0) { |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 446 | status = PSA_ERROR_INVALID_SIGNATURE; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 447 | } |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 448 | |
| 449 | cleanup: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 450 | mbedtls_platform_zeroize(actual_mac, sizeof(actual_mac)); |
Steven Cooreman | a5b860a | 2021-03-19 19:04:39 +0100 | [diff] [blame] | 451 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 452 | return status; |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 453 | } |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 454 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 455 | psa_status_t mbedtls_psa_mac_compute( |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 456 | const psa_key_attributes_t *attributes, |
| 457 | const uint8_t *key_buffer, |
| 458 | size_t key_buffer_size, |
| 459 | psa_algorithm_t alg, |
| 460 | const uint8_t *input, |
| 461 | size_t input_length, |
| 462 | uint8_t *mac, |
| 463 | size_t mac_size, |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 464 | size_t *mac_length) |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 465 | { |
| 466 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
| 467 | mbedtls_psa_mac_operation_t operation = MBEDTLS_PSA_MAC_OPERATION_INIT; |
Gilles Peskine | 91b29a0 | 2025-05-13 11:53:31 +0200 | [diff] [blame^] | 468 | /* Make sure the whole operation is zeroed. |
Gilles Peskine | 0e4907d | 2025-02-05 19:53:54 +0100 | [diff] [blame] | 469 | * PSA_MAC_OPERATION_INIT does not necessarily do it fully, |
| 470 | * since one field is a union and initializing a union does not |
| 471 | * necessarily initialize all of its members. |
| 472 | * In multipart operations, this is done in the API functions, |
| 473 | * before driver dispatch, since it needs to be done before calling |
| 474 | * the driver entry point. Here, we bypass the multipart API, |
| 475 | * so it's our job. */ |
| 476 | memset(&operation, 0, sizeof(operation)); |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 477 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 478 | status = psa_mac_setup(&operation, |
| 479 | attributes, key_buffer, key_buffer_size, |
| 480 | alg); |
| 481 | if (status != PSA_SUCCESS) { |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 482 | goto exit; |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 483 | } |
| 484 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 485 | if (input_length > 0) { |
| 486 | status = mbedtls_psa_mac_update(&operation, input, input_length); |
| 487 | if (status != PSA_SUCCESS) { |
| 488 | goto exit; |
| 489 | } |
| 490 | } |
| 491 | |
| 492 | status = psa_mac_finish_internal(&operation, mac, mac_size); |
| 493 | if (status == PSA_SUCCESS) { |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 494 | *mac_length = mac_size; |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 495 | } |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 496 | |
| 497 | exit: |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 498 | mbedtls_psa_mac_abort(&operation); |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 499 | |
Gilles Peskine | 449bd83 | 2023-01-11 14:50:10 +0100 | [diff] [blame] | 500 | return status; |
Ronald Cron | 76be3e0 | 2021-06-17 17:34:43 +0200 | [diff] [blame] | 501 | } |
| 502 | |
Ronald Cron | 0266cfe | 2021-03-13 18:50:11 +0100 | [diff] [blame] | 503 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HMAC || MBEDTLS_PSA_BUILTIN_ALG_CMAC */ |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 504 | |
| 505 | #endif /* MBEDTLS_PSA_CRYPTO_C */ |