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