blob: 8216f28ba69bd6bd5d3cbafa1c95e3ea8b7fb39e [file] [log] [blame]
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001/**
2 * \file psa/crypto_struct.h
3 *
4 * \brief PSA cryptography module: Mbed TLS structured type implementations
Gilles Peskine07c91f52018-06-28 18:02:53 +02005 *
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 Peskineb4e73e92019-08-13 15:00:57 +020015 *
16 * <h3>Design notes about multipart operation structures</h3>
17 *
Ronald Cron980230e2021-04-01 15:37:49 +020018 * 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 Peskineb4e73e92019-08-13 15:00:57 +020023 *
Ronald Cron980230e2021-04-01 15:37:49 +020024 * 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 Peskineb4e73e92019-08-13 15:00:57 +020032 * 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 *
Fredrik Hessecc207bc2021-09-28 21:06:08 +020038 * In Mbed TLS, multipart operation structures live independently from
39 * the key. This allows Mbed TLS to free the key objects when destroying
Gilles Peskineb4e73e92019-08-13 15:00:57 +020040 * 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 Peskine9ef733f2018-02-07 21:05:37 +010043 */
44/*
Bence Szépkúti1e148272020-08-07 13:07:28 +020045 * Copyright The Mbed TLS Contributors
Dave Rodgman16799db2023-11-02 19:47:20 +000046 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
Gilles Peskine9ef733f2018-02-07 21:05:37 +010047 */
48
49#ifndef PSA_CRYPTO_STRUCT_H
50#define PSA_CRYPTO_STRUCT_H
Mateusz Starzyk846f0212021-05-19 19:44:07 +020051#include "mbedtls/private_access.h"
Gilles Peskine9ef733f2018-02-07 21:05:37 +010052
Jaeden Amero8013f442019-08-16 16:13:51 +010053#ifdef __cplusplus
54extern "C" {
55#endif
56
Ronald Cron7871cb12023-10-10 08:51:39 +020057/*
58 * Include the build-time configuration information header. Here, we do not
59 * include `"mbedtls/build_info.h"` directly but `"psa/build_info.h"`, which
60 * is basically just an alias to it. This is to ease the maintenance of the
61 * TF-PSA-Crypto repository which has a different build system and
62 * configuration.
63 */
64#include "psa/build_info.h"
Gilles Peskine9ef733f2018-02-07 21:05:37 +010065
Steven Cooreman61398ec2021-04-26 12:04:53 +020066/* Include the context definition for the compiled-in drivers for the primitive
67 * algorithms. */
Steven Cooreman675501d2021-04-26 11:54:58 +020068#include "psa/crypto_driver_contexts_primitives.h"
Gilles Peskine9ef733f2018-02-07 21:05:37 +010069
Gilles Peskine449bd832023-01-11 14:50:10 +010070struct psa_hash_operation_s {
Steven Cooremandbf8ced2021-03-04 13:01:18 +010071 /** Unique ID indicating which driver got assigned to do the
72 * operation. Since driver contexts are driver-specific, swapping
73 * drivers halfway through the operation is not supported.
Ronald Cron980230e2021-04-01 15:37:49 +020074 * ID values are auto-generated in psa_driver_wrappers.h.
Steven Cooremandbf8ced2021-03-04 13:01:18 +010075 * ID value zero means the context is not valid or not assigned to
Ronald Cron980230e2021-04-01 15:37:49 +020076 * any driver (i.e. the driver context is not active, in use). */
Mateusz Starzyk846f0212021-05-19 19:44:07 +020077 unsigned int MBEDTLS_PRIVATE(id);
78 psa_driver_hash_context_t MBEDTLS_PRIVATE(ctx);
Gilles Peskine9ef733f2018-02-07 21:05:37 +010079};
80
Janos Follath33434a92021-05-26 09:25:33 +010081#define PSA_HASH_OPERATION_INIT { 0, { 0 } }
Gilles Peskine449bd832023-01-11 14:50:10 +010082static inline struct psa_hash_operation_s psa_hash_operation_init(void)
Jaeden Amero6a25b412019-01-04 11:47:44 +000083{
84 const struct psa_hash_operation_s v = PSA_HASH_OPERATION_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +010085 return v;
Jaeden Amero6a25b412019-01-04 11:47:44 +000086}
87
Gilles Peskine449bd832023-01-11 14:50:10 +010088struct psa_cipher_operation_s {
Steven Cooreman61398ec2021-04-26 12:04:53 +020089 /** Unique ID indicating which driver got assigned to do the
90 * operation. Since driver contexts are driver-specific, swapping
91 * drivers halfway through the operation is not supported.
92 * ID values are auto-generated in psa_crypto_driver_wrappers.h
93 * ID value zero means the context is not valid or not assigned to
94 * any driver (i.e. none of the driver contexts are active). */
Mateusz Starzyk846f0212021-05-19 19:44:07 +020095 unsigned int MBEDTLS_PRIVATE(id);
Steven Cooreman61398ec2021-04-26 12:04:53 +020096
Mateusz Starzyk846f0212021-05-19 19:44:07 +020097 unsigned int MBEDTLS_PRIVATE(iv_required) : 1;
98 unsigned int MBEDTLS_PRIVATE(iv_set) : 1;
Steven Cooreman61398ec2021-04-26 12:04:53 +020099
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200100 uint8_t MBEDTLS_PRIVATE(default_iv_length);
Steven Cooreman61398ec2021-04-26 12:04:53 +0200101
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200102 psa_driver_cipher_context_t MBEDTLS_PRIVATE(ctx);
Steven Cooreman61398ec2021-04-26 12:04:53 +0200103};
104
Janos Follath33434a92021-05-26 09:25:33 +0100105#define PSA_CIPHER_OPERATION_INIT { 0, 0, 0, 0, { 0 } }
Gilles Peskine449bd832023-01-11 14:50:10 +0100106static inline struct psa_cipher_operation_s psa_cipher_operation_init(void)
Steven Cooreman61398ec2021-04-26 12:04:53 +0200107{
108 const struct psa_cipher_operation_s v = PSA_CIPHER_OPERATION_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +0100109 return v;
Steven Cooreman61398ec2021-04-26 12:04:53 +0200110}
111
Steven Cooreman3c8dd632021-04-26 12:16:27 +0200112/* Include the context definition for the compiled-in drivers for the composite
113 * algorithms. */
114#include "psa/crypto_driver_contexts_composites.h"
Nir Sonnenscheindcd636a2018-06-04 16:03:32 +0300115
Gilles Peskine449bd832023-01-11 14:50:10 +0100116struct psa_mac_operation_s {
Steven Cooreman77e2cc52021-03-19 17:05:52 +0100117 /** Unique ID indicating which driver got assigned to do the
118 * operation. Since driver contexts are driver-specific, swapping
119 * drivers halfway through the operation is not supported.
120 * ID values are auto-generated in psa_driver_wrappers.h
121 * ID value zero means the context is not valid or not assigned to
122 * any driver (i.e. none of the driver contexts are active). */
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200123 unsigned int MBEDTLS_PRIVATE(id);
124 uint8_t MBEDTLS_PRIVATE(mac_size);
125 unsigned int MBEDTLS_PRIVATE(is_sign) : 1;
126 psa_driver_mac_context_t MBEDTLS_PRIVATE(ctx);
Gilles Peskine9ef733f2018-02-07 21:05:37 +0100127};
128
Janos Follath33434a92021-05-26 09:25:33 +0100129#define PSA_MAC_OPERATION_INIT { 0, 0, 0, { 0 } }
Gilles Peskine449bd832023-01-11 14:50:10 +0100130static inline struct psa_mac_operation_s psa_mac_operation_init(void)
Jaeden Amero769ce272019-01-04 11:48:03 +0000131{
132 const struct psa_mac_operation_s v = PSA_MAC_OPERATION_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +0100133 return v;
Jaeden Amero769ce272019-01-04 11:48:03 +0000134}
135
Gilles Peskine449bd832023-01-11 14:50:10 +0100136struct psa_aead_operation_s {
Paul Elliottadb8b162021-04-20 16:06:57 +0100137
Paul Elliott6504aa62021-04-20 17:09:36 +0100138 /** Unique ID indicating which driver got assigned to do the
139 * operation. Since driver contexts are driver-specific, swapping
140 * drivers halfway through the operation is not supported.
141 * ID values are auto-generated in psa_crypto_driver_wrappers.h
142 * ID value zero means the context is not valid or not assigned to
143 * any driver (i.e. none of the driver contexts are active). */
Paul Elliottc7e7fe52021-09-27 09:23:40 +0100144 unsigned int MBEDTLS_PRIVATE(id);
Paul Elliott6504aa62021-04-20 17:09:36 +0100145
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200146 psa_algorithm_t MBEDTLS_PRIVATE(alg);
Paul Elliott71b05672021-09-24 11:18:13 +0100147 psa_key_type_t MBEDTLS_PRIVATE(key_type);
Paul Elliottcbbde5f2021-05-10 18:19:46 +0100148
Paul Elliott71b05672021-09-24 11:18:13 +0100149 size_t MBEDTLS_PRIVATE(ad_remaining);
150 size_t MBEDTLS_PRIVATE(body_remaining);
Paul Elliottee4ffe02021-05-20 17:25:06 +0100151
Paul Elliott71b05672021-09-24 11:18:13 +0100152 unsigned int MBEDTLS_PRIVATE(nonce_set) : 1;
153 unsigned int MBEDTLS_PRIVATE(lengths_set) : 1;
154 unsigned int MBEDTLS_PRIVATE(ad_started) : 1;
155 unsigned int MBEDTLS_PRIVATE(body_started) : 1;
156 unsigned int MBEDTLS_PRIVATE(is_encrypt) : 1;
Paul Elliott07a30c42021-04-20 14:13:23 +0100157
Paul Elliott71b05672021-09-24 11:18:13 +0100158 psa_driver_aead_context_t MBEDTLS_PRIVATE(ctx);
Gilles Peskine30a9e412019-01-14 18:36:12 +0100159};
160
Gilles Peskine449bd832023-01-11 14:50:10 +0100161#define PSA_AEAD_OPERATION_INIT { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, { 0 } }
162static inline struct psa_aead_operation_s psa_aead_operation_init(void)
Gilles Peskine30a9e412019-01-14 18:36:12 +0100163{
164 const struct psa_aead_operation_s v = PSA_AEAD_OPERATION_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +0100165 return v;
Gilles Peskine30a9e412019-01-14 18:36:12 +0100166}
167
Ronald Cron2f10fce2023-01-11 09:21:47 +0100168/* Include the context definition for the compiled-in drivers for the key
169 * derivation algorithms. */
170#include "psa/crypto_driver_contexts_key_derivation.h"
Hanno Beckerc8a41d72018-10-09 17:33:01 +0100171
Gilles Peskine449bd832023-01-11 14:50:10 +0100172struct psa_key_derivation_s {
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200173 psa_algorithm_t MBEDTLS_PRIVATE(alg);
174 unsigned int MBEDTLS_PRIVATE(can_output_key) : 1;
175 size_t MBEDTLS_PRIVATE(capacity);
Ronald Cron2f10fce2023-01-11 09:21:47 +0100176 psa_driver_key_derivation_context_t MBEDTLS_PRIVATE(ctx);
Gilles Peskineeab56e42018-07-12 17:12:33 +0200177};
178
Janos Follathadbec812019-06-14 11:05:39 +0100179/* This only zeroes out the first byte in the union, the rest is unspecified. */
Janos Follath33434a92021-05-26 09:25:33 +0100180#define PSA_KEY_DERIVATION_OPERATION_INIT { 0, 0, 0, { 0 } }
Janos Follath0dcda952021-06-07 14:52:13 +0100181static inline struct psa_key_derivation_s psa_key_derivation_operation_init(
Gilles Peskine449bd832023-01-11 14:50:10 +0100182 void)
Gilles Peskineeab56e42018-07-12 17:12:33 +0200183{
Gilles Peskinecbe66502019-05-16 16:59:18 +0200184 const struct psa_key_derivation_s v = PSA_KEY_DERIVATION_OPERATION_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +0100185 return v;
Gilles Peskineeab56e42018-07-12 17:12:33 +0200186}
187
Gilles Peskine449bd832023-01-11 14:50:10 +0100188struct psa_key_policy_s {
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200189 psa_key_usage_t MBEDTLS_PRIVATE(usage);
190 psa_algorithm_t MBEDTLS_PRIVATE(alg);
191 psa_algorithm_t MBEDTLS_PRIVATE(alg2);
Gilles Peskine7698bcf2018-03-03 21:30:44 +0100192};
Gilles Peskinea3dd7372019-04-19 19:42:26 +0200193typedef struct psa_key_policy_s psa_key_policy_t;
Gilles Peskine7698bcf2018-03-03 21:30:44 +0100194
Janos Follath33434a92021-05-26 09:25:33 +0100195#define PSA_KEY_POLICY_INIT { 0, 0, 0 }
Gilles Peskine449bd832023-01-11 14:50:10 +0100196static inline struct psa_key_policy_s psa_key_policy_init(void)
Jaeden Amero70261c52019-01-04 11:47:20 +0000197{
198 const struct psa_key_policy_s v = PSA_KEY_POLICY_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +0100199 return v;
Jaeden Amero70261c52019-01-04 11:47:20 +0000200}
201
Gilles Peskine68cc433b2019-07-30 17:42:47 +0200202/* The type used internally for key sizes.
203 * Public interfaces use size_t, but internally we use a smaller type. */
204typedef uint16_t psa_key_bits_t;
205/* The maximum value of the type used to represent bit-sizes.
206 * This is used to mark an invalid key size. */
Gilles Peskine449bd832023-01-11 14:50:10 +0100207#define PSA_KEY_BITS_TOO_LARGE ((psa_key_bits_t) -1)
Gilles Peskinec744d992019-07-30 17:26:54 +0200208/* The maximum size of a key in bits.
Gilles Peskine68cc433b2019-07-30 17:42:47 +0200209 * Currently defined as the maximum that can be represented, rounded down
210 * to a whole number of bytes.
211 * This is an uncast value so that it can be used in preprocessor
212 * conditionals. */
Gilles Peskinec744d992019-07-30 17:26:54 +0200213#define PSA_MAX_KEY_BITS 0xfff8
214
Gilles Peskine91e8c332019-08-02 19:19:39 +0200215/** A mask of flags that can be stored in key attributes.
216 *
217 * This type is also used internally to store flags in slots. Internal
218 * flags are defined in library/psa_crypto_core.h. Internal flags may have
219 * the same value as external flags if they are properly handled during
220 * key creation and in psa_get_key_attributes.
221 */
222typedef uint16_t psa_key_attributes_flag_t;
223
Gilles Peskinec8000c02019-08-02 20:15:51 +0200224#define MBEDTLS_PSA_KA_FLAG_HAS_SLOT_NUMBER \
Gilles Peskine449bd832023-01-11 14:50:10 +0100225 ((psa_key_attributes_flag_t) 0x0001)
Gilles Peskine91e8c332019-08-02 19:19:39 +0200226
227/* A mask of key attribute flags used externally only.
228 * Only meant for internal checks inside the library. */
229#define MBEDTLS_PSA_KA_MASK_EXTERNAL_ONLY ( \
Gilles Peskinec8000c02019-08-02 20:15:51 +0200230 MBEDTLS_PSA_KA_FLAG_HAS_SLOT_NUMBER | \
Gilles Peskine449bd832023-01-11 14:50:10 +0100231 0)
Gilles Peskine91e8c332019-08-02 19:19:39 +0200232
233/* A mask of key attribute flags used both internally and externally.
234 * Currently there aren't any. */
235#define MBEDTLS_PSA_KA_MASK_DUAL_USE ( \
Gilles Peskine449bd832023-01-11 14:50:10 +0100236 0)
Gilles Peskine91e8c332019-08-02 19:19:39 +0200237
Gilles Peskine449bd832023-01-11 14:50:10 +0100238typedef struct {
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200239 psa_key_type_t MBEDTLS_PRIVATE(type);
240 psa_key_bits_t MBEDTLS_PRIVATE(bits);
241 psa_key_lifetime_t MBEDTLS_PRIVATE(lifetime);
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200242 psa_key_policy_t MBEDTLS_PRIVATE(policy);
243 psa_key_attributes_flag_t MBEDTLS_PRIVATE(flags);
Antonio de Angelis6fb1be62024-02-02 14:05:32 +0000244 /* This type has a different layout in the client view wrt the
245 * service view of the key id, i.e. in service view usually is
246 * expected to have MBEDTLS_SVC_KEY_ID_ENCODES_OWNER defined
247 * thus adding an owner field to the standard psa_key_id_t. For
248 * implementations with client/service separation, this means the
249 * object will be marshalled through a transport channel and
250 * interpreted differently at each side of the transport. Placing
251 * it at the end of structures allows to interpret the structure
252 * at the client without reorganizing the memory layout of the
253 * struct
254 */
Antonio de Angelis667cad52024-01-24 13:34:46 +0000255 mbedtls_svc_key_id_t MBEDTLS_PRIVATE(id);
Gilles Peskine7e0cff92019-07-30 13:48:52 +0200256} psa_core_key_attributes_t;
257
Janos Follath33434a92021-05-26 09:25:33 +0100258#define PSA_CORE_KEY_ATTRIBUTES_INIT { PSA_KEY_TYPE_NONE, 0, \
259 PSA_KEY_LIFETIME_VOLATILE, \
Antonio de Angelis667cad52024-01-24 13:34:46 +0000260 PSA_KEY_POLICY_INIT, 0, \
261 MBEDTLS_SVC_KEY_ID_INIT }
Gilles Peskine7e0cff92019-07-30 13:48:52 +0200262
Gilles Peskine449bd832023-01-11 14:50:10 +0100263struct psa_key_attributes_s {
Gilles Peskinec8000c02019-08-02 20:15:51 +0200264#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200265 psa_key_slot_number_t MBEDTLS_PRIVATE(slot_number);
Gilles Peskinec8000c02019-08-02 20:15:51 +0200266#endif /* MBEDTLS_PSA_CRYPTO_SE_C */
Gilles Peskine9deb5492023-12-18 21:01:18 +0100267 /* Unlike normal buffers, there are three cases for domain_parameters
268 * and domain_parameters_size:
269 * - domain_parameters_size == SIZE_MAX && domain_parameters == NULL:
270 * Access to domain parameters is not supported for this key.
271 * This is a hack which should not exist, intended for keys managed
Gilles Peskine1a9e05b2023-12-19 12:23:22 +0100272 * by a driver, because drivers don't support domain parameters.
Gilles Peskine9deb5492023-12-18 21:01:18 +0100273 * - domain_parameters_size == 0 && domain_parameters == NULL:
274 * The domain parameters are empty.
275 * - domain_parameters_size > 0 &&
276 * domain_parameters == valid pointer to domain_parameters_size bytes:
277 * The domain parameters are non-empty.
278 */
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200279 void *MBEDTLS_PRIVATE(domain_parameters);
280 size_t MBEDTLS_PRIVATE(domain_parameters_size);
Antonio de Angelis6fb1be62024-02-02 14:05:32 +0000281 /* With client/service separation, struct psa_key_attributes_s is
282 * marshalled through a transport channel between the client and
283 * service side implementation of the PSA Crypto APIs, thus having
284 * the mbedtls_svc_key_id_t id as the last field of this structure
285 * allows for a more efficient marshalling/unmarshalling of parameters
286 */
Antonio de Angelis667cad52024-01-24 13:34:46 +0000287 psa_core_key_attributes_t MBEDTLS_PRIVATE(core);
Gilles Peskine4747d192019-04-17 15:05:45 +0200288};
289
Gilles Peskinec8000c02019-08-02 20:15:51 +0200290#if defined(MBEDTLS_PSA_CRYPTO_SE_C)
Antonio de Angelis667cad52024-01-24 13:34:46 +0000291#define PSA_KEY_ATTRIBUTES_INIT { 0, NULL, 0, PSA_CORE_KEY_ATTRIBUTES_INIT }
Gilles Peskinec8000c02019-08-02 20:15:51 +0200292#else
Antonio de Angelis667cad52024-01-24 13:34:46 +0000293#define PSA_KEY_ATTRIBUTES_INIT { NULL, 0, PSA_CORE_KEY_ATTRIBUTES_INIT }
Gilles Peskinec8000c02019-08-02 20:15:51 +0200294#endif
295
Gilles Peskine449bd832023-01-11 14:50:10 +0100296static inline struct psa_key_attributes_s psa_key_attributes_init(void)
Gilles Peskine4747d192019-04-17 15:05:45 +0200297{
298 const struct psa_key_attributes_s v = PSA_KEY_ATTRIBUTES_INIT;
Gilles Peskine449bd832023-01-11 14:50:10 +0100299 return v;
Gilles Peskine4747d192019-04-17 15:05:45 +0200300}
301
Gilles Peskine449bd832023-01-11 14:50:10 +0100302static inline void psa_set_key_id(psa_key_attributes_t *attributes,
303 mbedtls_svc_key_id_t key)
Gilles Peskinedc8219a2019-05-15 16:11:15 +0200304{
Mateusz Starzyk363eb292021-05-19 17:32:44 +0200305 psa_key_lifetime_t lifetime = attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime);
Ronald Crond98059d2020-10-23 18:00:55 +0200306
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200307 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id) = key;
Ronald Crond98059d2020-10-23 18:00:55 +0200308
Gilles Peskine449bd832023-01-11 14:50:10 +0100309 if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200310 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime) =
Ronald Crond98059d2020-10-23 18:00:55 +0200311 PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
312 PSA_KEY_LIFETIME_PERSISTENT,
Gilles Peskine449bd832023-01-11 14:50:10 +0100313 PSA_KEY_LIFETIME_GET_LOCATION(lifetime));
Ronald Crond98059d2020-10-23 18:00:55 +0200314 }
Gilles Peskinedc8219a2019-05-15 16:11:15 +0200315}
316
Ronald Cron71016a92020-08-28 19:01:50 +0200317static inline mbedtls_svc_key_id_t psa_get_key_id(
Gilles Peskine449bd832023-01-11 14:50:10 +0100318 const psa_key_attributes_t *attributes)
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200319{
Gilles Peskine449bd832023-01-11 14:50:10 +0100320 return attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id);
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200321}
322
Ronald Cron6b5ff532020-10-16 14:38:19 +0200323#ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER
Gilles Peskine449bd832023-01-11 14:50:10 +0100324static inline void mbedtls_set_key_owner_id(psa_key_attributes_t *attributes,
325 mbedtls_key_owner_id_t owner)
Ronald Cron6b5ff532020-10-16 14:38:19 +0200326{
Mateusz Starzyk363eb292021-05-19 17:32:44 +0200327 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id).MBEDTLS_PRIVATE(owner) = owner;
Ronald Cron6b5ff532020-10-16 14:38:19 +0200328}
329#endif
330
Gilles Peskine449bd832023-01-11 14:50:10 +0100331static inline void psa_set_key_lifetime(psa_key_attributes_t *attributes,
332 psa_key_lifetime_t lifetime)
Gilles Peskinedc8219a2019-05-15 16:11:15 +0200333{
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200334 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime) = lifetime;
Gilles Peskine449bd832023-01-11 14:50:10 +0100335 if (PSA_KEY_LIFETIME_IS_VOLATILE(lifetime)) {
Ronald Cron71016a92020-08-28 19:01:50 +0200336#ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER
Mateusz Starzyk363eb292021-05-19 17:32:44 +0200337 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id).MBEDTLS_PRIVATE(key_id) = 0;
Jaeden Ameroe3cdf282019-08-20 12:58:20 +0100338#else
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200339 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id) = 0;
Jaeden Ameroe3cdf282019-08-20 12:58:20 +0100340#endif
341 }
Gilles Peskinedc8219a2019-05-15 16:11:15 +0200342}
343
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200344static inline psa_key_lifetime_t psa_get_key_lifetime(
Gilles Peskine449bd832023-01-11 14:50:10 +0100345 const psa_key_attributes_t *attributes)
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200346{
Gilles Peskine449bd832023-01-11 14:50:10 +0100347 return attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime);
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200348}
349
Gilles Peskine449bd832023-01-11 14:50:10 +0100350static inline void psa_extend_key_usage_flags(psa_key_usage_t *usage_flags)
Gilles Peskine4747d192019-04-17 15:05:45 +0200351{
Gilles Peskine449bd832023-01-11 14:50:10 +0100352 if (*usage_flags & PSA_KEY_USAGE_SIGN_HASH) {
gabor-mezei-arm43110b62021-06-23 16:48:08 +0200353 *usage_flags |= PSA_KEY_USAGE_SIGN_MESSAGE;
Gilles Peskine449bd832023-01-11 14:50:10 +0100354 }
gabor-mezei-arm86bf0082021-04-29 15:57:57 +0200355
Gilles Peskine449bd832023-01-11 14:50:10 +0100356 if (*usage_flags & PSA_KEY_USAGE_VERIFY_HASH) {
gabor-mezei-arm43110b62021-06-23 16:48:08 +0200357 *usage_flags |= PSA_KEY_USAGE_VERIFY_MESSAGE;
Gilles Peskine449bd832023-01-11 14:50:10 +0100358 }
Gilles Peskine4747d192019-04-17 15:05:45 +0200359}
360
361static inline void psa_set_key_usage_flags(psa_key_attributes_t *attributes,
362 psa_key_usage_t usage_flags)
363{
Gilles Peskine449bd832023-01-11 14:50:10 +0100364 psa_extend_key_usage_flags(&usage_flags);
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200365 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(usage) = usage_flags;
Gilles Peskine4747d192019-04-17 15:05:45 +0200366}
367
368static inline psa_key_usage_t psa_get_key_usage_flags(
Gilles Peskine449bd832023-01-11 14:50:10 +0100369 const psa_key_attributes_t *attributes)
Gilles Peskine4747d192019-04-17 15:05:45 +0200370{
Gilles Peskine449bd832023-01-11 14:50:10 +0100371 return attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(usage);
Gilles Peskine4747d192019-04-17 15:05:45 +0200372}
373
Gilles Peskine449bd832023-01-11 14:50:10 +0100374static inline void psa_set_key_algorithm(psa_key_attributes_t *attributes,
375 psa_algorithm_t alg)
Gilles Peskine4747d192019-04-17 15:05:45 +0200376{
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200377 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(alg) = alg;
Gilles Peskine4747d192019-04-17 15:05:45 +0200378}
379
380static inline psa_algorithm_t psa_get_key_algorithm(
Gilles Peskine449bd832023-01-11 14:50:10 +0100381 const psa_key_attributes_t *attributes)
Gilles Peskine4747d192019-04-17 15:05:45 +0200382{
Gilles Peskine449bd832023-01-11 14:50:10 +0100383 return attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(alg);
Gilles Peskine4747d192019-04-17 15:05:45 +0200384}
385
Gilles Peskine24f10f82019-05-16 12:18:32 +0200386/* This function is declared in crypto_extra.h, which comes after this
387 * header file, but we need the function here, so repeat the declaration. */
Matthias Schulz5a39c4e2023-11-09 15:53:01 +0100388#if !defined(PSA_SET_KEY_DOMAIN_PARAMETERS)
389#define PSA_SET_KEY_DOMAIN_PARAMETERS
Gilles Peskine449bd832023-01-11 14:50:10 +0100390psa_status_t psa_set_key_domain_parameters(psa_key_attributes_t *attributes,
Gilles Peskine24f10f82019-05-16 12:18:32 +0200391 psa_key_type_t type,
392 const uint8_t *data,
Gilles Peskine449bd832023-01-11 14:50:10 +0100393 size_t data_length);
Matthias Schulz5a39c4e2023-11-09 15:53:01 +0100394#endif /* PSA_SET_KEY_DOMAIN_PARAMETERS */
Gilles Peskine24f10f82019-05-16 12:18:32 +0200395
Gilles Peskine449bd832023-01-11 14:50:10 +0100396static inline void psa_set_key_type(psa_key_attributes_t *attributes,
397 psa_key_type_t type)
Gilles Peskine4747d192019-04-17 15:05:45 +0200398{
Gilles Peskine449bd832023-01-11 14:50:10 +0100399 if (attributes->MBEDTLS_PRIVATE(domain_parameters) == NULL) {
Gilles Peskineb699f072019-04-26 16:06:02 +0200400 /* Common case: quick path */
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200401 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(type) = type;
Gilles Peskine449bd832023-01-11 14:50:10 +0100402 } else {
Shaun Case8b0ecbc2021-12-20 21:14:10 -0800403 /* Call the bigger function to free the old domain parameters.
Gilles Peskineb699f072019-04-26 16:06:02 +0200404 * Ignore any errors which may arise due to type requiring
405 * non-default domain parameters, since this function can't
406 * report errors. */
Gilles Peskine449bd832023-01-11 14:50:10 +0100407 (void) psa_set_key_domain_parameters(attributes, type, NULL, 0);
Gilles Peskineb699f072019-04-26 16:06:02 +0200408 }
Gilles Peskine4747d192019-04-17 15:05:45 +0200409}
410
411static inline psa_key_type_t psa_get_key_type(
Gilles Peskine449bd832023-01-11 14:50:10 +0100412 const psa_key_attributes_t *attributes)
Gilles Peskine4747d192019-04-17 15:05:45 +0200413{
Gilles Peskine449bd832023-01-11 14:50:10 +0100414 return attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(type);
Gilles Peskine4747d192019-04-17 15:05:45 +0200415}
416
Gilles Peskine449bd832023-01-11 14:50:10 +0100417static inline void psa_set_key_bits(psa_key_attributes_t *attributes,
418 size_t bits)
Gilles Peskine3a4f1f82019-04-26 13:49:28 +0200419{
Gilles Peskine449bd832023-01-11 14:50:10 +0100420 if (bits > PSA_MAX_KEY_BITS) {
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200421 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(bits) = PSA_KEY_BITS_TOO_LARGE;
Gilles Peskine449bd832023-01-11 14:50:10 +0100422 } else {
Mateusz Starzyk846f0212021-05-19 19:44:07 +0200423 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(bits) = (psa_key_bits_t) bits;
Gilles Peskine449bd832023-01-11 14:50:10 +0100424 }
Gilles Peskine3a4f1f82019-04-26 13:49:28 +0200425}
426
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200427static inline size_t psa_get_key_bits(
Gilles Peskine449bd832023-01-11 14:50:10 +0100428 const psa_key_attributes_t *attributes)
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200429{
Gilles Peskine449bd832023-01-11 14:50:10 +0100430 return attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(bits);
Gilles Peskinedb4b3ab2019-04-18 12:53:01 +0200431}
432
Paul Elliott1265f002022-09-09 17:15:43 +0100433/**
434 * \brief The context for PSA interruptible hash signing.
Paul Elliott1265f002022-09-09 17:15:43 +0100435 */
436struct psa_sign_hash_interruptible_operation_s {
Paul Elliott2d247922022-11-29 14:54:44 +0000437 /** Unique ID indicating which driver got assigned to do the
438 * operation. Since driver contexts are driver-specific, swapping
439 * drivers halfway through the operation is not supported.
440 * ID values are auto-generated in psa_crypto_driver_wrappers.h
441 * ID value zero means the context is not valid or not assigned to
442 * any driver (i.e. none of the driver contexts are active). */
443 unsigned int MBEDTLS_PRIVATE(id);
444
Paul Elliott588f8ed2022-12-02 18:10:26 +0000445 psa_driver_sign_hash_interruptible_context_t MBEDTLS_PRIVATE(ctx);
446
Paul Elliottc9774412023-02-06 15:14:07 +0000447 unsigned int MBEDTLS_PRIVATE(error_occurred) : 1;
448
Paul Elliott296ede92022-12-15 17:00:30 +0000449 uint32_t MBEDTLS_PRIVATE(num_ops);
Paul Elliott1265f002022-09-09 17:15:43 +0100450};
451
Paul Elliottc9774412023-02-06 15:14:07 +0000452#define PSA_SIGN_HASH_INTERRUPTIBLE_OPERATION_INIT { 0, { 0 }, 0, 0 }
Paul Elliott1265f002022-09-09 17:15:43 +0100453
454static inline struct psa_sign_hash_interruptible_operation_s
455psa_sign_hash_interruptible_operation_init(void)
456{
457 const struct psa_sign_hash_interruptible_operation_s v =
458 PSA_SIGN_HASH_INTERRUPTIBLE_OPERATION_INIT;
459
460 return v;
461}
462
463/**
464 * \brief The context for PSA interruptible hash verification.
Paul Elliott1265f002022-09-09 17:15:43 +0100465 */
466struct psa_verify_hash_interruptible_operation_s {
Paul Elliott2d247922022-11-29 14:54:44 +0000467 /** Unique ID indicating which driver got assigned to do the
468 * operation. Since driver contexts are driver-specific, swapping
469 * drivers halfway through the operation is not supported.
470 * ID values are auto-generated in psa_crypto_driver_wrappers.h
471 * ID value zero means the context is not valid or not assigned to
472 * any driver (i.e. none of the driver contexts are active). */
473 unsigned int MBEDTLS_PRIVATE(id);
474
Paul Elliott588f8ed2022-12-02 18:10:26 +0000475 psa_driver_verify_hash_interruptible_context_t MBEDTLS_PRIVATE(ctx);
476
Paul Elliottc9774412023-02-06 15:14:07 +0000477 unsigned int MBEDTLS_PRIVATE(error_occurred) : 1;
478
Paul Elliott296ede92022-12-15 17:00:30 +0000479 uint32_t MBEDTLS_PRIVATE(num_ops);
Paul Elliott1265f002022-09-09 17:15:43 +0100480};
481
Paul Elliottc9774412023-02-06 15:14:07 +0000482#define PSA_VERIFY_HASH_INTERRUPTIBLE_OPERATION_INIT { 0, { 0 }, 0, 0 }
Paul Elliott1265f002022-09-09 17:15:43 +0100483
484static inline struct psa_verify_hash_interruptible_operation_s
485psa_verify_hash_interruptible_operation_init(void)
486{
487 const struct psa_verify_hash_interruptible_operation_s v =
488 PSA_VERIFY_HASH_INTERRUPTIBLE_OPERATION_INIT;
489
490 return v;
491}
492
Jaeden Amero8013f442019-08-16 16:13:51 +0100493#ifdef __cplusplus
494}
495#endif
496
Gilles Peskine9ef733f2018-02-07 21:05:37 +0100497#endif /* PSA_CRYPTO_STRUCT_H */