Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 1 | /** |
| 2 | * \file psa/crypto_struct.h |
| 3 | * |
| 4 | * \brief PSA cryptography module: Mbed TLS structured type implementations |
Gilles Peskine | 07c91f5 | 2018-06-28 18:02:53 +0200 | [diff] [blame] | 5 | * |
| 6 | * \note This file may not be included directly. Applications must |
| 7 | * include psa/crypto.h. |
| 8 | * |
| 9 | * This file contains the definitions of some data structures with |
| 10 | * implementation-specific definitions. |
| 11 | * |
| 12 | * In implementations with isolation between the application and the |
| 13 | * cryptography module, it is expected that the front-end and the back-end |
| 14 | * would have different versions of this file. |
Gilles Peskine | b4e73e9 | 2019-08-13 15:00:57 +0200 | [diff] [blame] | 15 | * |
| 16 | * <h3>Design notes about multipart operation structures</h3> |
| 17 | * |
Ronald Cron | 980230e | 2021-04-01 15:37:49 +0200 | [diff] [blame] | 18 | * For multipart operations without driver delegation support, each multipart |
| 19 | * operation structure contains a `psa_algorithm_t alg` field which indicates |
| 20 | * which specific algorithm the structure is for. When the structure is not in |
| 21 | * use, `alg` is 0. Most of the structure consists of a union which is |
| 22 | * discriminated by `alg`. |
Gilles Peskine | b4e73e9 | 2019-08-13 15:00:57 +0200 | [diff] [blame] | 23 | * |
Ronald Cron | 980230e | 2021-04-01 15:37:49 +0200 | [diff] [blame] | 24 | * For multipart operations with driver delegation support, each multipart |
| 25 | * operation structure contains an `unsigned int id` field indicating which |
| 26 | * driver got assigned to do the operation. When the structure is not in use, |
| 27 | * 'id' is 0. The structure contains also a driver context which is the union |
| 28 | * of the contexts of all drivers able to handle the type of multipart |
| 29 | * operation. |
| 30 | * |
| 31 | * Note that when `alg` or `id` is 0, the content of other fields is undefined. |
Gilles Peskine | b4e73e9 | 2019-08-13 15:00:57 +0200 | [diff] [blame] | 32 | * In particular, it is not guaranteed that a freshly-initialized structure |
| 33 | * is all-zero: we initialize structures to something like `{0, 0}`, which |
| 34 | * is only guaranteed to initializes the first member of the union; |
| 35 | * GCC and Clang initialize the whole structure to 0 (at the time of writing), |
| 36 | * but MSVC and CompCert don't. |
| 37 | * |
| 38 | * In Mbed Crypto, multipart operation structures live independently from |
| 39 | * the key. This allows Mbed Crypto to free the key objects when destroying |
| 40 | * a key slot. If a multipart operation needs to remember the key after |
| 41 | * the setup function returns, the operation structure needs to contain a |
| 42 | * copy of the key. |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 43 | */ |
| 44 | /* |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 45 | * Copyright The Mbed TLS Contributors |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 46 | * SPDX-License-Identifier: Apache-2.0 |
| 47 | * |
| 48 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 49 | * not use this file except in compliance with the License. |
| 50 | * You may obtain a copy of the License at |
| 51 | * |
| 52 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 53 | * |
| 54 | * Unless required by applicable law or agreed to in writing, software |
| 55 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 56 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 57 | * See the License for the specific language governing permissions and |
| 58 | * limitations under the License. |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 59 | */ |
| 60 | |
| 61 | #ifndef PSA_CRYPTO_STRUCT_H |
| 62 | #define PSA_CRYPTO_STRUCT_H |
| 63 | |
Jaeden Amero | 8013f44 | 2019-08-16 16:13:51 +0100 | [diff] [blame] | 64 | #ifdef __cplusplus |
| 65 | extern "C" { |
| 66 | #endif |
| 67 | |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 68 | /* Include the Mbed TLS configuration file, the way Mbed TLS does it |
| 69 | * in each of its header files. */ |
| 70 | #if !defined(MBEDTLS_CONFIG_FILE) |
Jaeden Amero | d58a00d | 2019-06-07 11:49:59 +0100 | [diff] [blame] | 71 | #include "mbedtls/config.h" |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 72 | #else |
| 73 | #include MBEDTLS_CONFIG_FILE |
| 74 | #endif |
| 75 | |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 76 | #include "mbedtls/cmac.h" |
| 77 | #include "mbedtls/gcm.h" |
Steven Cooreman | dbf8ced | 2021-03-04 13:01:18 +0100 | [diff] [blame] | 78 | |
Steven Cooreman | 61398ec | 2021-04-26 12:04:53 +0200 | [diff] [blame] | 79 | /* Include the context definition for the compiled-in drivers for the primitive |
| 80 | * algorithms. */ |
Steven Cooreman | 675501d | 2021-04-26 11:54:58 +0200 | [diff] [blame] | 81 | #include "psa/crypto_driver_contexts_primitives.h" |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 82 | |
| 83 | struct psa_hash_operation_s |
| 84 | { |
Steven Cooreman | dbf8ced | 2021-03-04 13:01:18 +0100 | [diff] [blame] | 85 | /** Unique ID indicating which driver got assigned to do the |
| 86 | * operation. Since driver contexts are driver-specific, swapping |
| 87 | * drivers halfway through the operation is not supported. |
Ronald Cron | 980230e | 2021-04-01 15:37:49 +0200 | [diff] [blame] | 88 | * ID values are auto-generated in psa_driver_wrappers.h. |
Steven Cooreman | dbf8ced | 2021-03-04 13:01:18 +0100 | [diff] [blame] | 89 | * ID value zero means the context is not valid or not assigned to |
Ronald Cron | 980230e | 2021-04-01 15:37:49 +0200 | [diff] [blame] | 90 | * any driver (i.e. the driver context is not active, in use). */ |
Steven Cooreman | dbf8ced | 2021-03-04 13:01:18 +0100 | [diff] [blame] | 91 | unsigned int id; |
Steven Cooreman | b177731 | 2021-03-04 15:22:38 +0100 | [diff] [blame] | 92 | psa_driver_hash_context_t ctx; |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 93 | }; |
| 94 | |
Steven Cooreman | dbf8ced | 2021-03-04 13:01:18 +0100 | [diff] [blame] | 95 | #define PSA_HASH_OPERATION_INIT {0, {0}} |
Jaeden Amero | 6a25b41 | 2019-01-04 11:47:44 +0000 | [diff] [blame] | 96 | static inline struct psa_hash_operation_s psa_hash_operation_init( void ) |
| 97 | { |
| 98 | const struct psa_hash_operation_s v = PSA_HASH_OPERATION_INIT; |
| 99 | return( v ); |
| 100 | } |
| 101 | |
Steven Cooreman | 61398ec | 2021-04-26 12:04:53 +0200 | [diff] [blame] | 102 | struct psa_cipher_operation_s |
| 103 | { |
| 104 | /** Unique ID indicating which driver got assigned to do the |
| 105 | * operation. Since driver contexts are driver-specific, swapping |
| 106 | * drivers halfway through the operation is not supported. |
| 107 | * ID values are auto-generated in psa_crypto_driver_wrappers.h |
| 108 | * ID value zero means the context is not valid or not assigned to |
| 109 | * any driver (i.e. none of the driver contexts are active). */ |
| 110 | unsigned int id; |
| 111 | |
| 112 | unsigned int iv_required : 1; |
| 113 | unsigned int iv_set : 1; |
| 114 | |
| 115 | uint8_t default_iv_length; |
| 116 | |
| 117 | psa_driver_cipher_context_t ctx; |
| 118 | }; |
| 119 | |
| 120 | #define PSA_CIPHER_OPERATION_INIT {0, 0, 0, 0, {0}} |
| 121 | static inline struct psa_cipher_operation_s psa_cipher_operation_init( void ) |
| 122 | { |
| 123 | const struct psa_cipher_operation_s v = PSA_CIPHER_OPERATION_INIT; |
| 124 | return( v ); |
| 125 | } |
| 126 | |
Steven Cooreman | 3c8dd63 | 2021-04-26 12:16:27 +0200 | [diff] [blame] | 127 | /* Include the context definition for the compiled-in drivers for the composite |
| 128 | * algorithms. */ |
| 129 | #include "psa/crypto_driver_contexts_composites.h" |
Nir Sonnenschein | dcd636a | 2018-06-04 16:03:32 +0300 | [diff] [blame] | 130 | |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 131 | struct psa_mac_operation_s |
| 132 | { |
Steven Cooreman | 77e2cc5 | 2021-03-19 17:05:52 +0100 | [diff] [blame] | 133 | /** Unique ID indicating which driver got assigned to do the |
| 134 | * operation. Since driver contexts are driver-specific, swapping |
| 135 | * drivers halfway through the operation is not supported. |
| 136 | * ID values are auto-generated in psa_driver_wrappers.h |
| 137 | * ID value zero means the context is not valid or not assigned to |
| 138 | * any driver (i.e. none of the driver contexts are active). */ |
Steven Cooreman | d13a70f | 2021-03-19 15:24:23 +0100 | [diff] [blame] | 139 | unsigned int id; |
Steven Cooreman | 77e2cc5 | 2021-03-19 17:05:52 +0100 | [diff] [blame] | 140 | psa_driver_mac_context_t ctx; |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 141 | }; |
| 142 | |
Steven Cooreman | 77e2cc5 | 2021-03-19 17:05:52 +0100 | [diff] [blame] | 143 | #define PSA_MAC_OPERATION_INIT {0, {0}} |
Jaeden Amero | 769ce27 | 2019-01-04 11:48:03 +0000 | [diff] [blame] | 144 | static inline struct psa_mac_operation_s psa_mac_operation_init( void ) |
| 145 | { |
| 146 | const struct psa_mac_operation_s v = PSA_MAC_OPERATION_INIT; |
| 147 | return( v ); |
| 148 | } |
| 149 | |
Gilles Peskine | 30a9e41 | 2019-01-14 18:36:12 +0100 | [diff] [blame] | 150 | struct psa_aead_operation_s |
| 151 | { |
| 152 | psa_algorithm_t alg; |
| 153 | unsigned int key_set : 1; |
| 154 | unsigned int iv_set : 1; |
| 155 | uint8_t iv_size; |
| 156 | uint8_t block_size; |
| 157 | union |
| 158 | { |
| 159 | unsigned dummy; /* Enable easier initializing of the union. */ |
| 160 | mbedtls_cipher_context_t cipher; |
| 161 | } ctx; |
| 162 | }; |
| 163 | |
| 164 | #define PSA_AEAD_OPERATION_INIT {0, 0, 0, 0, 0, {0}} |
| 165 | static inline struct psa_aead_operation_s psa_aead_operation_init( void ) |
| 166 | { |
| 167 | const struct psa_aead_operation_s v = PSA_AEAD_OPERATION_INIT; |
| 168 | return( v ); |
| 169 | } |
| 170 | |
Steven Cooreman | ac8d82a | 2021-04-29 18:01:53 +0200 | [diff] [blame] | 171 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF) |
Gilles Peskine | bef7f14 | 2018-07-12 17:22:21 +0200 | [diff] [blame] | 172 | typedef struct |
| 173 | { |
| 174 | uint8_t *info; |
| 175 | size_t info_length; |
Steven Cooreman | d1ed1d9 | 2021-04-29 19:11:25 +0200 | [diff] [blame] | 176 | psa_mac_operation_t hmac; |
Gilles Peskine | bef7f14 | 2018-07-12 17:22:21 +0200 | [diff] [blame] | 177 | uint8_t prk[PSA_HASH_MAX_SIZE]; |
| 178 | uint8_t output_block[PSA_HASH_MAX_SIZE]; |
| 179 | #if PSA_HASH_MAX_SIZE > 0xff |
| 180 | #error "PSA_HASH_MAX_SIZE does not fit in uint8_t" |
| 181 | #endif |
| 182 | uint8_t offset_in_block; |
| 183 | uint8_t block_number; |
Gilles Peskine | 22c5151 | 2019-04-12 15:07:32 +0200 | [diff] [blame] | 184 | unsigned int state : 2; |
| 185 | unsigned int info_set : 1; |
Gilles Peskine | cbe6650 | 2019-05-16 16:59:18 +0200 | [diff] [blame] | 186 | } psa_hkdf_key_derivation_t; |
Steven Cooreman | ac8d82a | 2021-04-29 18:01:53 +0200 | [diff] [blame] | 187 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_HKDF */ |
Gilles Peskine | bef7f14 | 2018-07-12 17:22:21 +0200 | [diff] [blame] | 188 | |
Steven Cooreman | ac8d82a | 2021-04-29 18:01:53 +0200 | [diff] [blame] | 189 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PRF) || \ |
| 190 | defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS) |
Janos Follath | 999f648 | 2019-06-11 12:04:10 +0100 | [diff] [blame] | 191 | typedef enum |
| 192 | { |
Gilles Peskine | 43f958b | 2020-12-13 14:55:14 +0100 | [diff] [blame] | 193 | PSA_TLS12_PRF_STATE_INIT, /* no input provided */ |
| 194 | PSA_TLS12_PRF_STATE_SEED_SET, /* seed has been set */ |
| 195 | PSA_TLS12_PRF_STATE_KEY_SET, /* key has been set */ |
| 196 | PSA_TLS12_PRF_STATE_LABEL_SET, /* label has been set */ |
| 197 | PSA_TLS12_PRF_STATE_OUTPUT /* output has been started */ |
Janos Follath | 999f648 | 2019-06-11 12:04:10 +0100 | [diff] [blame] | 198 | } psa_tls12_prf_key_derivation_state_t; |
| 199 | |
| 200 | typedef struct psa_tls12_prf_key_derivation_s |
| 201 | { |
| 202 | #if PSA_HASH_MAX_SIZE > 0xff |
| 203 | #error "PSA_HASH_MAX_SIZE does not fit in uint8_t" |
| 204 | #endif |
| 205 | |
| 206 | /* Indicates how many bytes in the current HMAC block have |
Janos Follath | 844eb0e | 2019-06-19 12:10:49 +0100 | [diff] [blame] | 207 | * not yet been read by the user. */ |
| 208 | uint8_t left_in_block; |
Janos Follath | 999f648 | 2019-06-11 12:04:10 +0100 | [diff] [blame] | 209 | |
| 210 | /* The 1-based number of the block. */ |
| 211 | uint8_t block_number; |
| 212 | |
| 213 | psa_tls12_prf_key_derivation_state_t state; |
| 214 | |
Steven Cooreman | a6df604 | 2021-04-29 19:32:25 +0200 | [diff] [blame^] | 215 | uint8_t *secret; |
| 216 | size_t secret_length; |
Janos Follath | 999f648 | 2019-06-11 12:04:10 +0100 | [diff] [blame] | 217 | uint8_t *seed; |
| 218 | size_t seed_length; |
| 219 | uint8_t *label; |
| 220 | size_t label_length; |
Steven Cooreman | a6df604 | 2021-04-29 19:32:25 +0200 | [diff] [blame^] | 221 | |
Janos Follath | 999f648 | 2019-06-11 12:04:10 +0100 | [diff] [blame] | 222 | uint8_t Ai[PSA_HASH_MAX_SIZE]; |
| 223 | |
| 224 | /* `HMAC_hash( prk, A(i) + seed )` in the notation of RFC 5246, Sect. 5. */ |
| 225 | uint8_t output_block[PSA_HASH_MAX_SIZE]; |
| 226 | } psa_tls12_prf_key_derivation_t; |
Steven Cooreman | ac8d82a | 2021-04-29 18:01:53 +0200 | [diff] [blame] | 227 | #endif /* MBEDTLS_PSA_BUILTIN_ALG_TLS12_PRF) || |
| 228 | * MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS */ |
Hanno Becker | c8a41d7 | 2018-10-09 17:33:01 +0100 | [diff] [blame] | 229 | |
Gilles Peskine | cbe6650 | 2019-05-16 16:59:18 +0200 | [diff] [blame] | 230 | struct psa_key_derivation_s |
Gilles Peskine | eab56e4 | 2018-07-12 17:12:33 +0200 | [diff] [blame] | 231 | { |
| 232 | psa_algorithm_t alg; |
Gilles Peskine | 178c9aa | 2019-09-24 18:21:06 +0200 | [diff] [blame] | 233 | unsigned int can_output_key : 1; |
Gilles Peskine | eab56e4 | 2018-07-12 17:12:33 +0200 | [diff] [blame] | 234 | size_t capacity; |
| 235 | union |
| 236 | { |
Janos Follath | adbec81 | 2019-06-14 11:05:39 +0100 | [diff] [blame] | 237 | /* Make the union non-empty even with no supported algorithms. */ |
| 238 | uint8_t dummy; |
Steven Cooreman | ac8d82a | 2021-04-29 18:01:53 +0200 | [diff] [blame] | 239 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF) |
Gilles Peskine | cbe6650 | 2019-05-16 16:59:18 +0200 | [diff] [blame] | 240 | psa_hkdf_key_derivation_t hkdf; |
Steven Cooreman | ac8d82a | 2021-04-29 18:01:53 +0200 | [diff] [blame] | 241 | #endif |
| 242 | #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PRF) || \ |
| 243 | defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS) |
Gilles Peskine | cbe6650 | 2019-05-16 16:59:18 +0200 | [diff] [blame] | 244 | psa_tls12_prf_key_derivation_t tls12_prf; |
Gilles Peskine | bef7f14 | 2018-07-12 17:22:21 +0200 | [diff] [blame] | 245 | #endif |
Gilles Peskine | eab56e4 | 2018-07-12 17:12:33 +0200 | [diff] [blame] | 246 | } ctx; |
| 247 | }; |
| 248 | |
Janos Follath | adbec81 | 2019-06-14 11:05:39 +0100 | [diff] [blame] | 249 | /* This only zeroes out the first byte in the union, the rest is unspecified. */ |
Gilles Peskine | 178c9aa | 2019-09-24 18:21:06 +0200 | [diff] [blame] | 250 | #define PSA_KEY_DERIVATION_OPERATION_INIT {0, 0, 0, {0}} |
Gilles Peskine | cbe6650 | 2019-05-16 16:59:18 +0200 | [diff] [blame] | 251 | static inline struct psa_key_derivation_s psa_key_derivation_operation_init( void ) |
Gilles Peskine | eab56e4 | 2018-07-12 17:12:33 +0200 | [diff] [blame] | 252 | { |
Gilles Peskine | cbe6650 | 2019-05-16 16:59:18 +0200 | [diff] [blame] | 253 | const struct psa_key_derivation_s v = PSA_KEY_DERIVATION_OPERATION_INIT; |
Gilles Peskine | eab56e4 | 2018-07-12 17:12:33 +0200 | [diff] [blame] | 254 | return( v ); |
| 255 | } |
| 256 | |
Gilles Peskine | 7698bcf | 2018-03-03 21:30:44 +0100 | [diff] [blame] | 257 | struct psa_key_policy_s |
| 258 | { |
| 259 | psa_key_usage_t usage; |
| 260 | psa_algorithm_t alg; |
Gilles Peskine | 96f0b3b | 2019-05-10 19:33:38 +0200 | [diff] [blame] | 261 | psa_algorithm_t alg2; |
Gilles Peskine | 7698bcf | 2018-03-03 21:30:44 +0100 | [diff] [blame] | 262 | }; |
Gilles Peskine | a3dd737 | 2019-04-19 19:42:26 +0200 | [diff] [blame] | 263 | typedef struct psa_key_policy_s psa_key_policy_t; |
Gilles Peskine | 7698bcf | 2018-03-03 21:30:44 +0100 | [diff] [blame] | 264 | |
Gilles Peskine | 96f0b3b | 2019-05-10 19:33:38 +0200 | [diff] [blame] | 265 | #define PSA_KEY_POLICY_INIT {0, 0, 0} |
Jaeden Amero | 70261c5 | 2019-01-04 11:47:20 +0000 | [diff] [blame] | 266 | static inline struct psa_key_policy_s psa_key_policy_init( void ) |
| 267 | { |
| 268 | const struct psa_key_policy_s v = PSA_KEY_POLICY_INIT; |
| 269 | return( v ); |
| 270 | } |
| 271 | |
Gilles Peskine | 68cc433b | 2019-07-30 17:42:47 +0200 | [diff] [blame] | 272 | /* The type used internally for key sizes. |
| 273 | * Public interfaces use size_t, but internally we use a smaller type. */ |
| 274 | typedef uint16_t psa_key_bits_t; |
| 275 | /* The maximum value of the type used to represent bit-sizes. |
| 276 | * This is used to mark an invalid key size. */ |
| 277 | #define PSA_KEY_BITS_TOO_LARGE ( (psa_key_bits_t) ( -1 ) ) |
Gilles Peskine | c744d99 | 2019-07-30 17:26:54 +0200 | [diff] [blame] | 278 | /* The maximum size of a key in bits. |
Gilles Peskine | 68cc433b | 2019-07-30 17:42:47 +0200 | [diff] [blame] | 279 | * Currently defined as the maximum that can be represented, rounded down |
| 280 | * to a whole number of bytes. |
| 281 | * This is an uncast value so that it can be used in preprocessor |
| 282 | * conditionals. */ |
Gilles Peskine | c744d99 | 2019-07-30 17:26:54 +0200 | [diff] [blame] | 283 | #define PSA_MAX_KEY_BITS 0xfff8 |
| 284 | |
Gilles Peskine | 91e8c33 | 2019-08-02 19:19:39 +0200 | [diff] [blame] | 285 | /** A mask of flags that can be stored in key attributes. |
| 286 | * |
| 287 | * This type is also used internally to store flags in slots. Internal |
| 288 | * flags are defined in library/psa_crypto_core.h. Internal flags may have |
| 289 | * the same value as external flags if they are properly handled during |
| 290 | * key creation and in psa_get_key_attributes. |
| 291 | */ |
| 292 | typedef uint16_t psa_key_attributes_flag_t; |
| 293 | |
Gilles Peskine | c8000c0 | 2019-08-02 20:15:51 +0200 | [diff] [blame] | 294 | #define MBEDTLS_PSA_KA_FLAG_HAS_SLOT_NUMBER \ |
| 295 | ( (psa_key_attributes_flag_t) 0x0001 ) |
Gilles Peskine | 91e8c33 | 2019-08-02 19:19:39 +0200 | [diff] [blame] | 296 | |
| 297 | /* A mask of key attribute flags used externally only. |
| 298 | * Only meant for internal checks inside the library. */ |
| 299 | #define MBEDTLS_PSA_KA_MASK_EXTERNAL_ONLY ( \ |
Gilles Peskine | c8000c0 | 2019-08-02 20:15:51 +0200 | [diff] [blame] | 300 | MBEDTLS_PSA_KA_FLAG_HAS_SLOT_NUMBER | \ |
Gilles Peskine | 91e8c33 | 2019-08-02 19:19:39 +0200 | [diff] [blame] | 301 | 0 ) |
| 302 | |
| 303 | /* A mask of key attribute flags used both internally and externally. |
| 304 | * Currently there aren't any. */ |
| 305 | #define MBEDTLS_PSA_KA_MASK_DUAL_USE ( \ |
| 306 | 0 ) |
| 307 | |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 308 | typedef struct |
| 309 | { |
| 310 | psa_key_type_t type; |
Gilles Peskine | f65ed6f | 2019-12-04 17:18:41 +0100 | [diff] [blame] | 311 | psa_key_bits_t bits; |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 312 | psa_key_lifetime_t lifetime; |
Ronald Cron | 71016a9 | 2020-08-28 19:01:50 +0200 | [diff] [blame] | 313 | mbedtls_svc_key_id_t id; |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 314 | psa_key_policy_t policy; |
Gilles Peskine | 91e8c33 | 2019-08-02 19:19:39 +0200 | [diff] [blame] | 315 | psa_key_attributes_flag_t flags; |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 316 | } psa_core_key_attributes_t; |
| 317 | |
Ronald Cron | 71016a9 | 2020-08-28 19:01:50 +0200 | [diff] [blame] | 318 | #define PSA_CORE_KEY_ATTRIBUTES_INIT {PSA_KEY_TYPE_NONE, 0, PSA_KEY_LIFETIME_VOLATILE, MBEDTLS_SVC_KEY_ID_INIT, PSA_KEY_POLICY_INIT, 0} |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 319 | |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 320 | struct psa_key_attributes_s |
| 321 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 322 | psa_core_key_attributes_t core; |
Gilles Peskine | c8000c0 | 2019-08-02 20:15:51 +0200 | [diff] [blame] | 323 | #if defined(MBEDTLS_PSA_CRYPTO_SE_C) |
| 324 | psa_key_slot_number_t slot_number; |
| 325 | #endif /* MBEDTLS_PSA_CRYPTO_SE_C */ |
Gilles Peskine | b699f07 | 2019-04-26 16:06:02 +0200 | [diff] [blame] | 326 | void *domain_parameters; |
| 327 | size_t domain_parameters_size; |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 328 | }; |
| 329 | |
Gilles Peskine | c8000c0 | 2019-08-02 20:15:51 +0200 | [diff] [blame] | 330 | #if defined(MBEDTLS_PSA_CRYPTO_SE_C) |
| 331 | #define PSA_KEY_ATTRIBUTES_INIT {PSA_CORE_KEY_ATTRIBUTES_INIT, 0, NULL, 0} |
| 332 | #else |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 333 | #define PSA_KEY_ATTRIBUTES_INIT {PSA_CORE_KEY_ATTRIBUTES_INIT, NULL, 0} |
Gilles Peskine | c8000c0 | 2019-08-02 20:15:51 +0200 | [diff] [blame] | 334 | #endif |
| 335 | |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 336 | static inline struct psa_key_attributes_s psa_key_attributes_init( void ) |
| 337 | { |
| 338 | const struct psa_key_attributes_s v = PSA_KEY_ATTRIBUTES_INIT; |
| 339 | return( v ); |
| 340 | } |
| 341 | |
Ronald Cron | 71016a9 | 2020-08-28 19:01:50 +0200 | [diff] [blame] | 342 | static inline void psa_set_key_id( psa_key_attributes_t *attributes, |
| 343 | mbedtls_svc_key_id_t key ) |
Gilles Peskine | dc8219a | 2019-05-15 16:11:15 +0200 | [diff] [blame] | 344 | { |
Ronald Cron | d98059d | 2020-10-23 18:00:55 +0200 | [diff] [blame] | 345 | psa_key_lifetime_t lifetime = attributes->core.lifetime; |
| 346 | |
Ronald Cron | 27238fc | 2020-07-23 12:30:41 +0200 | [diff] [blame] | 347 | attributes->core.id = key; |
Ronald Cron | d98059d | 2020-10-23 18:00:55 +0200 | [diff] [blame] | 348 | |
| 349 | if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) ) |
| 350 | { |
| 351 | attributes->core.lifetime = |
| 352 | PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION( |
| 353 | PSA_KEY_LIFETIME_PERSISTENT, |
| 354 | PSA_KEY_LIFETIME_GET_LOCATION( lifetime ) ); |
| 355 | } |
Gilles Peskine | dc8219a | 2019-05-15 16:11:15 +0200 | [diff] [blame] | 356 | } |
| 357 | |
Ronald Cron | 71016a9 | 2020-08-28 19:01:50 +0200 | [diff] [blame] | 358 | static inline mbedtls_svc_key_id_t psa_get_key_id( |
Gilles Peskine | db4b3ab | 2019-04-18 12:53:01 +0200 | [diff] [blame] | 359 | const psa_key_attributes_t *attributes) |
| 360 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 361 | return( attributes->core.id ); |
Gilles Peskine | db4b3ab | 2019-04-18 12:53:01 +0200 | [diff] [blame] | 362 | } |
| 363 | |
Ronald Cron | 6b5ff53 | 2020-10-16 14:38:19 +0200 | [diff] [blame] | 364 | #ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER |
| 365 | static inline void mbedtls_set_key_owner_id( psa_key_attributes_t *attributes, |
| 366 | mbedtls_key_owner_id_t owner ) |
| 367 | { |
| 368 | attributes->core.id.owner = owner; |
| 369 | } |
| 370 | #endif |
| 371 | |
Gilles Peskine | dc8219a | 2019-05-15 16:11:15 +0200 | [diff] [blame] | 372 | static inline void psa_set_key_lifetime(psa_key_attributes_t *attributes, |
| 373 | psa_key_lifetime_t lifetime) |
| 374 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 375 | attributes->core.lifetime = lifetime; |
Ronald Cron | d98059d | 2020-10-23 18:00:55 +0200 | [diff] [blame] | 376 | if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) ) |
Jaeden Amero | e3cdf28 | 2019-08-20 12:58:20 +0100 | [diff] [blame] | 377 | { |
Ronald Cron | 71016a9 | 2020-08-28 19:01:50 +0200 | [diff] [blame] | 378 | #ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER |
Jaeden Amero | e3cdf28 | 2019-08-20 12:58:20 +0100 | [diff] [blame] | 379 | attributes->core.id.key_id = 0; |
Jaeden Amero | e3cdf28 | 2019-08-20 12:58:20 +0100 | [diff] [blame] | 380 | #else |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 381 | attributes->core.id = 0; |
Jaeden Amero | e3cdf28 | 2019-08-20 12:58:20 +0100 | [diff] [blame] | 382 | #endif |
| 383 | } |
Gilles Peskine | dc8219a | 2019-05-15 16:11:15 +0200 | [diff] [blame] | 384 | } |
| 385 | |
Gilles Peskine | db4b3ab | 2019-04-18 12:53:01 +0200 | [diff] [blame] | 386 | static inline psa_key_lifetime_t psa_get_key_lifetime( |
| 387 | const psa_key_attributes_t *attributes) |
| 388 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 389 | return( attributes->core.lifetime ); |
Gilles Peskine | db4b3ab | 2019-04-18 12:53:01 +0200 | [diff] [blame] | 390 | } |
| 391 | |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 392 | static inline void psa_set_key_usage_flags(psa_key_attributes_t *attributes, |
| 393 | psa_key_usage_t usage_flags) |
| 394 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 395 | attributes->core.policy.usage = usage_flags; |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | static inline psa_key_usage_t psa_get_key_usage_flags( |
| 399 | const psa_key_attributes_t *attributes) |
| 400 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 401 | return( attributes->core.policy.usage ); |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 402 | } |
| 403 | |
| 404 | static inline void psa_set_key_algorithm(psa_key_attributes_t *attributes, |
| 405 | psa_algorithm_t alg) |
| 406 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 407 | attributes->core.policy.alg = alg; |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 408 | } |
| 409 | |
| 410 | static inline psa_algorithm_t psa_get_key_algorithm( |
| 411 | const psa_key_attributes_t *attributes) |
| 412 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 413 | return( attributes->core.policy.alg ); |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 414 | } |
| 415 | |
Gilles Peskine | 24f10f8 | 2019-05-16 12:18:32 +0200 | [diff] [blame] | 416 | /* This function is declared in crypto_extra.h, which comes after this |
| 417 | * header file, but we need the function here, so repeat the declaration. */ |
| 418 | psa_status_t psa_set_key_domain_parameters(psa_key_attributes_t *attributes, |
| 419 | psa_key_type_t type, |
| 420 | const uint8_t *data, |
| 421 | size_t data_length); |
| 422 | |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 423 | static inline void psa_set_key_type(psa_key_attributes_t *attributes, |
| 424 | psa_key_type_t type) |
| 425 | { |
Gilles Peskine | b699f07 | 2019-04-26 16:06:02 +0200 | [diff] [blame] | 426 | if( attributes->domain_parameters == NULL ) |
| 427 | { |
| 428 | /* Common case: quick path */ |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 429 | attributes->core.type = type; |
Gilles Peskine | b699f07 | 2019-04-26 16:06:02 +0200 | [diff] [blame] | 430 | } |
| 431 | else |
| 432 | { |
| 433 | /* Call the bigger function to free the old domain paramteres. |
| 434 | * Ignore any errors which may arise due to type requiring |
| 435 | * non-default domain parameters, since this function can't |
| 436 | * report errors. */ |
| 437 | (void) psa_set_key_domain_parameters( attributes, type, NULL, 0 ); |
| 438 | } |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 439 | } |
| 440 | |
| 441 | static inline psa_key_type_t psa_get_key_type( |
| 442 | const psa_key_attributes_t *attributes) |
| 443 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 444 | return( attributes->core.type ); |
Gilles Peskine | 4747d19 | 2019-04-17 15:05:45 +0200 | [diff] [blame] | 445 | } |
| 446 | |
Gilles Peskine | 3a4f1f8 | 2019-04-26 13:49:28 +0200 | [diff] [blame] | 447 | static inline void psa_set_key_bits(psa_key_attributes_t *attributes, |
| 448 | size_t bits) |
| 449 | { |
Gilles Peskine | 68cc433b | 2019-07-30 17:42:47 +0200 | [diff] [blame] | 450 | if( bits > PSA_MAX_KEY_BITS ) |
| 451 | attributes->core.bits = PSA_KEY_BITS_TOO_LARGE; |
| 452 | else |
| 453 | attributes->core.bits = (psa_key_bits_t) bits; |
Gilles Peskine | 3a4f1f8 | 2019-04-26 13:49:28 +0200 | [diff] [blame] | 454 | } |
| 455 | |
Gilles Peskine | db4b3ab | 2019-04-18 12:53:01 +0200 | [diff] [blame] | 456 | static inline size_t psa_get_key_bits( |
| 457 | const psa_key_attributes_t *attributes) |
| 458 | { |
Gilles Peskine | 7e0cff9 | 2019-07-30 13:48:52 +0200 | [diff] [blame] | 459 | return( attributes->core.bits ); |
Gilles Peskine | db4b3ab | 2019-04-18 12:53:01 +0200 | [diff] [blame] | 460 | } |
| 461 | |
Jaeden Amero | 8013f44 | 2019-08-16 16:13:51 +0100 | [diff] [blame] | 462 | #ifdef __cplusplus |
| 463 | } |
| 464 | #endif |
| 465 | |
Gilles Peskine | 9ef733f | 2018-02-07 21:05:37 +0100 | [diff] [blame] | 466 | #endif /* PSA_CRYPTO_STRUCT_H */ |