1 /**
2 * \file psa/crypto_struct.h
3 *
4 * \brief PSA cryptography module: Mbed TLS structured type implementations
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.
15 *
16 * <h3>Design notes about multipart operation structures</h3>
17 *
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`.
23 *
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.
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.
43 */
44 /*
45 * Copyright The Mbed TLS Contributors
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.
59 */
60
61 #ifndef PSA_CRYPTO_STRUCT_H
62 #define PSA_CRYPTO_STRUCT_H
63 #include "mbedtls/private_access.h"
64
65 #ifdef __cplusplus
66 extern "C" {
67 #endif
68
69 /* Include the Mbed TLS configuration file, the way Mbed TLS does it
70 * in each of its header files. */
71 #include "mbedtls/build_info.h"
72
73 #include "mbedtls/cmac.h"
74 #include "mbedtls/gcm.h"
75 #include "mbedtls/ccm.h"
76 #include "mbedtls/chachapoly.h"
77
78 /* Include the context definition for the compiled-in drivers for the primitive
79 * algorithms. */
80 #include "psa/crypto_driver_contexts_primitives.h"
81
82 struct psa_hash_operation_s
83 {
84 /** Unique ID indicating which driver got assigned to do the
85 * operation. Since driver contexts are driver-specific, swapping
86 * drivers halfway through the operation is not supported.
87 * ID values are auto-generated in psa_driver_wrappers.h.
88 * ID value zero means the context is not valid or not assigned to
89 * any driver (i.e. the driver context is not active, in use). */
90 unsigned int MBEDTLS_PRIVATE(id);
91 psa_driver_hash_context_t MBEDTLS_PRIVATE(ctx);
92 };
93
94 #define PSA_HASH_OPERATION_INIT { 0, { 0 } }
psa_hash_operation_init(void)95 static inline struct psa_hash_operation_s psa_hash_operation_init( void )
96 {
97 const struct psa_hash_operation_s v = PSA_HASH_OPERATION_INIT;
98 return( v );
99 }
100
101 struct psa_cipher_operation_s
102 {
103 /** Unique ID indicating which driver got assigned to do the
104 * operation. Since driver contexts are driver-specific, swapping
105 * drivers halfway through the operation is not supported.
106 * ID values are auto-generated in psa_crypto_driver_wrappers.h
107 * ID value zero means the context is not valid or not assigned to
108 * any driver (i.e. none of the driver contexts are active). */
109 unsigned int MBEDTLS_PRIVATE(id);
110
111 unsigned int MBEDTLS_PRIVATE(iv_required) : 1;
112 unsigned int MBEDTLS_PRIVATE(iv_set) : 1;
113
114 uint8_t MBEDTLS_PRIVATE(default_iv_length);
115
116 psa_driver_cipher_context_t MBEDTLS_PRIVATE(ctx);
117 };
118
119 #define PSA_CIPHER_OPERATION_INIT { 0, 0, 0, 0, { 0 } }
psa_cipher_operation_init(void)120 static inline struct psa_cipher_operation_s psa_cipher_operation_init( void )
121 {
122 const struct psa_cipher_operation_s v = PSA_CIPHER_OPERATION_INIT;
123 return( v );
124 }
125
126 /* Include the context definition for the compiled-in drivers for the composite
127 * algorithms. */
128 #include "psa/crypto_driver_contexts_composites.h"
129
130 struct psa_mac_operation_s
131 {
132 /** Unique ID indicating which driver got assigned to do the
133 * operation. Since driver contexts are driver-specific, swapping
134 * drivers halfway through the operation is not supported.
135 * ID values are auto-generated in psa_driver_wrappers.h
136 * ID value zero means the context is not valid or not assigned to
137 * any driver (i.e. none of the driver contexts are active). */
138 unsigned int MBEDTLS_PRIVATE(id);
139 uint8_t MBEDTLS_PRIVATE(mac_size);
140 unsigned int MBEDTLS_PRIVATE(is_sign) : 1;
141 psa_driver_mac_context_t MBEDTLS_PRIVATE(ctx);
142 };
143
144 #define PSA_MAC_OPERATION_INIT { 0, 0, 0, { 0 } }
psa_mac_operation_init(void)145 static inline struct psa_mac_operation_s psa_mac_operation_init( void )
146 {
147 const struct psa_mac_operation_s v = PSA_MAC_OPERATION_INIT;
148 return( v );
149 }
150
151 struct psa_aead_operation_s
152 {
153
154 /** Unique ID indicating which driver got assigned to do the
155 * operation. Since driver contexts are driver-specific, swapping
156 * drivers halfway through the operation is not supported.
157 * ID values are auto-generated in psa_crypto_driver_wrappers.h
158 * ID value zero means the context is not valid or not assigned to
159 * any driver (i.e. none of the driver contexts are active). */
160 unsigned int MBEDTLS_PRIVATE(id);
161
162 psa_algorithm_t MBEDTLS_PRIVATE(alg);
163 psa_key_type_t MBEDTLS_PRIVATE(key_type);
164
165 size_t MBEDTLS_PRIVATE(ad_remaining);
166 size_t MBEDTLS_PRIVATE(body_remaining);
167
168 unsigned int MBEDTLS_PRIVATE(nonce_set) : 1;
169 unsigned int MBEDTLS_PRIVATE(lengths_set) : 1;
170 unsigned int MBEDTLS_PRIVATE(ad_started) : 1;
171 unsigned int MBEDTLS_PRIVATE(body_started) : 1;
172 unsigned int MBEDTLS_PRIVATE(is_encrypt) : 1;
173
174 psa_driver_aead_context_t MBEDTLS_PRIVATE(ctx);
175 };
176
177 #define PSA_AEAD_OPERATION_INIT {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0}}
psa_aead_operation_init(void)178 static inline struct psa_aead_operation_s psa_aead_operation_init( void )
179 {
180 const struct psa_aead_operation_s v = PSA_AEAD_OPERATION_INIT;
181 return( v );
182 }
183
184 #if defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF) || \
185 defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF_EXTRACT) || \
186 defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF_EXPAND)
187 typedef struct
188 {
189 uint8_t *MBEDTLS_PRIVATE(info);
190 size_t MBEDTLS_PRIVATE(info_length);
191 #if PSA_HASH_MAX_SIZE > 0xff
192 #error "PSA_HASH_MAX_SIZE does not fit in uint8_t"
193 #endif
194 uint8_t MBEDTLS_PRIVATE(offset_in_block);
195 uint8_t MBEDTLS_PRIVATE(block_number);
196 unsigned int MBEDTLS_PRIVATE(state) : 2;
197 unsigned int MBEDTLS_PRIVATE(info_set) : 1;
198 uint8_t MBEDTLS_PRIVATE(output_block)[PSA_HASH_MAX_SIZE];
199 uint8_t MBEDTLS_PRIVATE(prk)[PSA_HASH_MAX_SIZE];
200 struct psa_mac_operation_s MBEDTLS_PRIVATE(hmac);
201 } psa_hkdf_key_derivation_t;
202 #endif /* MBEDTLS_PSA_BUILTIN_ALG_HKDF ||
203 MBEDTLS_PSA_BUILTIN_ALG_HKDF_EXTRACT ||
204 MBEDTLS_PSA_BUILTIN_ALG_HKDF_EXPAND */
205 #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_ECJPAKE_TO_PMS)
206 typedef struct
207 {
208 uint8_t MBEDTLS_PRIVATE(data)[PSA_TLS12_ECJPAKE_TO_PMS_DATA_SIZE];
209 } psa_tls12_ecjpake_to_pms_t;
210 #endif /* MBEDTLS_PSA_BUILTIN_ALG_TLS12_ECJPAKE_TO_PMS */
211
212 #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PRF) || \
213 defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS)
214 typedef enum
215 {
216 PSA_TLS12_PRF_STATE_INIT, /* no input provided */
217 PSA_TLS12_PRF_STATE_SEED_SET, /* seed has been set */
218 PSA_TLS12_PRF_STATE_OTHER_KEY_SET, /* other key has been set - optional */
219 PSA_TLS12_PRF_STATE_KEY_SET, /* key has been set */
220 PSA_TLS12_PRF_STATE_LABEL_SET, /* label has been set */
221 PSA_TLS12_PRF_STATE_OUTPUT /* output has been started */
222 } psa_tls12_prf_key_derivation_state_t;
223
224 typedef struct psa_tls12_prf_key_derivation_s
225 {
226 #if PSA_HASH_MAX_SIZE > 0xff
227 #error "PSA_HASH_MAX_SIZE does not fit in uint8_t"
228 #endif
229
230 /* Indicates how many bytes in the current HMAC block have
231 * not yet been read by the user. */
232 uint8_t MBEDTLS_PRIVATE(left_in_block);
233
234 /* The 1-based number of the block. */
235 uint8_t MBEDTLS_PRIVATE(block_number);
236
237 psa_tls12_prf_key_derivation_state_t MBEDTLS_PRIVATE(state);
238
239 uint8_t *MBEDTLS_PRIVATE(secret);
240 size_t MBEDTLS_PRIVATE(secret_length);
241 uint8_t *MBEDTLS_PRIVATE(seed);
242 size_t MBEDTLS_PRIVATE(seed_length);
243 uint8_t *MBEDTLS_PRIVATE(label);
244 size_t MBEDTLS_PRIVATE(label_length);
245 #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS)
246 uint8_t *MBEDTLS_PRIVATE(other_secret);
247 size_t MBEDTLS_PRIVATE(other_secret_length);
248 #endif /* MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS */
249
250 uint8_t MBEDTLS_PRIVATE(Ai)[PSA_HASH_MAX_SIZE];
251
252 /* `HMAC_hash( prk, A( i ) + seed )` in the notation of RFC 5246, Sect. 5. */
253 uint8_t MBEDTLS_PRIVATE(output_block)[PSA_HASH_MAX_SIZE];
254 } psa_tls12_prf_key_derivation_t;
255 #endif /* MBEDTLS_PSA_BUILTIN_ALG_TLS12_PRF) ||
256 * MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS */
257
258 struct psa_key_derivation_s
259 {
260 psa_algorithm_t MBEDTLS_PRIVATE(alg);
261 unsigned int MBEDTLS_PRIVATE(can_output_key) : 1;
262 size_t MBEDTLS_PRIVATE(capacity);
263 union
264 {
265 /* Make the union non-empty even with no supported algorithms. */
266 uint8_t MBEDTLS_PRIVATE(dummy);
267 #if defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF) || \
268 defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF_EXTRACT) || \
269 defined(MBEDTLS_PSA_BUILTIN_ALG_HKDF_EXPAND)
270 psa_hkdf_key_derivation_t MBEDTLS_PRIVATE(hkdf);
271 #endif
272 #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PRF) || \
273 defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_PSK_TO_MS)
274 psa_tls12_prf_key_derivation_t MBEDTLS_PRIVATE(tls12_prf);
275 #endif
276 #if defined(MBEDTLS_PSA_BUILTIN_ALG_TLS12_ECJPAKE_TO_PMS)
277 psa_tls12_ecjpake_to_pms_t MBEDTLS_PRIVATE(tls12_ecjpake_to_pms);
278 #endif
279 } MBEDTLS_PRIVATE(ctx);
280 };
281
282 /* This only zeroes out the first byte in the union, the rest is unspecified. */
283 #define PSA_KEY_DERIVATION_OPERATION_INIT { 0, 0, 0, { 0 } }
psa_key_derivation_operation_init(void)284 static inline struct psa_key_derivation_s psa_key_derivation_operation_init(
285 void )
286 {
287 const struct psa_key_derivation_s v = PSA_KEY_DERIVATION_OPERATION_INIT;
288 return( v );
289 }
290
291 struct psa_key_policy_s
292 {
293 psa_key_usage_t MBEDTLS_PRIVATE(usage);
294 psa_algorithm_t MBEDTLS_PRIVATE(alg);
295 psa_algorithm_t MBEDTLS_PRIVATE(alg2);
296 };
297 typedef struct psa_key_policy_s psa_key_policy_t;
298
299 #define PSA_KEY_POLICY_INIT { 0, 0, 0 }
psa_key_policy_init(void)300 static inline struct psa_key_policy_s psa_key_policy_init( void )
301 {
302 const struct psa_key_policy_s v = PSA_KEY_POLICY_INIT;
303 return( v );
304 }
305
306 /* The type used internally for key sizes.
307 * Public interfaces use size_t, but internally we use a smaller type. */
308 typedef uint16_t psa_key_bits_t;
309 /* The maximum value of the type used to represent bit-sizes.
310 * This is used to mark an invalid key size. */
311 #define PSA_KEY_BITS_TOO_LARGE ( ( psa_key_bits_t ) -1 )
312 /* The maximum size of a key in bits.
313 * Currently defined as the maximum that can be represented, rounded down
314 * to a whole number of bytes.
315 * This is an uncast value so that it can be used in preprocessor
316 * conditionals. */
317 #define PSA_MAX_KEY_BITS 0xfff8
318
319 /** A mask of flags that can be stored in key attributes.
320 *
321 * This type is also used internally to store flags in slots. Internal
322 * flags are defined in library/psa_crypto_core.h. Internal flags may have
323 * the same value as external flags if they are properly handled during
324 * key creation and in psa_get_key_attributes.
325 */
326 typedef uint16_t psa_key_attributes_flag_t;
327
328 #define MBEDTLS_PSA_KA_FLAG_HAS_SLOT_NUMBER \
329 ( (psa_key_attributes_flag_t) 0x0001 )
330
331 /* A mask of key attribute flags used externally only.
332 * Only meant for internal checks inside the library. */
333 #define MBEDTLS_PSA_KA_MASK_EXTERNAL_ONLY ( \
334 MBEDTLS_PSA_KA_FLAG_HAS_SLOT_NUMBER | \
335 0 )
336
337 /* A mask of key attribute flags used both internally and externally.
338 * Currently there aren't any. */
339 #define MBEDTLS_PSA_KA_MASK_DUAL_USE ( \
340 0 )
341
342 typedef struct
343 {
344 psa_key_type_t MBEDTLS_PRIVATE(type);
345 psa_key_bits_t MBEDTLS_PRIVATE(bits);
346 psa_key_lifetime_t MBEDTLS_PRIVATE(lifetime);
347 mbedtls_svc_key_id_t MBEDTLS_PRIVATE(id);
348 psa_key_policy_t MBEDTLS_PRIVATE(policy);
349 psa_key_attributes_flag_t MBEDTLS_PRIVATE(flags);
350 } psa_core_key_attributes_t;
351
352 #define PSA_CORE_KEY_ATTRIBUTES_INIT { PSA_KEY_TYPE_NONE, 0, \
353 PSA_KEY_LIFETIME_VOLATILE, \
354 MBEDTLS_SVC_KEY_ID_INIT, \
355 PSA_KEY_POLICY_INIT, 0 }
356
357 struct psa_key_attributes_s
358 {
359 psa_core_key_attributes_t MBEDTLS_PRIVATE(core);
360 #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
361 psa_key_slot_number_t MBEDTLS_PRIVATE(slot_number);
362 #endif /* MBEDTLS_PSA_CRYPTO_SE_C */
363 void *MBEDTLS_PRIVATE(domain_parameters);
364 size_t MBEDTLS_PRIVATE(domain_parameters_size);
365 };
366
367 #if defined(MBEDTLS_PSA_CRYPTO_SE_C)
368 #define PSA_KEY_ATTRIBUTES_INIT { PSA_CORE_KEY_ATTRIBUTES_INIT, 0, NULL, 0 }
369 #else
370 #define PSA_KEY_ATTRIBUTES_INIT { PSA_CORE_KEY_ATTRIBUTES_INIT, NULL, 0 }
371 #endif
372
psa_key_attributes_init(void)373 static inline struct psa_key_attributes_s psa_key_attributes_init( void )
374 {
375 const struct psa_key_attributes_s v = PSA_KEY_ATTRIBUTES_INIT;
376 return( v );
377 }
378
psa_set_key_id(psa_key_attributes_t * attributes,mbedtls_svc_key_id_t key)379 static inline void psa_set_key_id( psa_key_attributes_t *attributes,
380 mbedtls_svc_key_id_t key )
381 {
382 psa_key_lifetime_t lifetime = attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime);
383
384 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id) = key;
385
386 if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
387 {
388 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime) =
389 PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(
390 PSA_KEY_LIFETIME_PERSISTENT,
391 PSA_KEY_LIFETIME_GET_LOCATION( lifetime ) );
392 }
393 }
394
psa_get_key_id(const psa_key_attributes_t * attributes)395 static inline mbedtls_svc_key_id_t psa_get_key_id(
396 const psa_key_attributes_t *attributes )
397 {
398 return( attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id) );
399 }
400
401 #ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER
mbedtls_set_key_owner_id(psa_key_attributes_t * attributes,mbedtls_key_owner_id_t owner)402 static inline void mbedtls_set_key_owner_id( psa_key_attributes_t *attributes,
403 mbedtls_key_owner_id_t owner )
404 {
405 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id).MBEDTLS_PRIVATE(owner) = owner;
406 }
407 #endif
408
psa_set_key_lifetime(psa_key_attributes_t * attributes,psa_key_lifetime_t lifetime)409 static inline void psa_set_key_lifetime( psa_key_attributes_t *attributes,
410 psa_key_lifetime_t lifetime )
411 {
412 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime) = lifetime;
413 if( PSA_KEY_LIFETIME_IS_VOLATILE( lifetime ) )
414 {
415 #ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER
416 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id).MBEDTLS_PRIVATE(key_id) = 0;
417 #else
418 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(id) = 0;
419 #endif
420 }
421 }
422
psa_get_key_lifetime(const psa_key_attributes_t * attributes)423 static inline psa_key_lifetime_t psa_get_key_lifetime(
424 const psa_key_attributes_t *attributes )
425 {
426 return( attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(lifetime) );
427 }
428
psa_extend_key_usage_flags(psa_key_usage_t * usage_flags)429 static inline void psa_extend_key_usage_flags( psa_key_usage_t *usage_flags )
430 {
431 if( *usage_flags & PSA_KEY_USAGE_SIGN_HASH )
432 *usage_flags |= PSA_KEY_USAGE_SIGN_MESSAGE;
433
434 if( *usage_flags & PSA_KEY_USAGE_VERIFY_HASH )
435 *usage_flags |= PSA_KEY_USAGE_VERIFY_MESSAGE;
436 }
437
psa_set_key_usage_flags(psa_key_attributes_t * attributes,psa_key_usage_t usage_flags)438 static inline void psa_set_key_usage_flags(psa_key_attributes_t *attributes,
439 psa_key_usage_t usage_flags)
440 {
441 psa_extend_key_usage_flags( &usage_flags );
442 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(usage) = usage_flags;
443 }
444
psa_get_key_usage_flags(const psa_key_attributes_t * attributes)445 static inline psa_key_usage_t psa_get_key_usage_flags(
446 const psa_key_attributes_t *attributes )
447 {
448 return( attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(usage) );
449 }
450
psa_set_key_algorithm(psa_key_attributes_t * attributes,psa_algorithm_t alg)451 static inline void psa_set_key_algorithm( psa_key_attributes_t *attributes,
452 psa_algorithm_t alg )
453 {
454 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(alg) = alg;
455 }
456
psa_get_key_algorithm(const psa_key_attributes_t * attributes)457 static inline psa_algorithm_t psa_get_key_algorithm(
458 const psa_key_attributes_t *attributes )
459 {
460 return( attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(policy).MBEDTLS_PRIVATE(alg) );
461 }
462
463 /* This function is declared in crypto_extra.h, which comes after this
464 * header file, but we need the function here, so repeat the declaration. */
465 psa_status_t psa_set_key_domain_parameters( psa_key_attributes_t *attributes,
466 psa_key_type_t type,
467 const uint8_t *data,
468 size_t data_length );
469
psa_set_key_type(psa_key_attributes_t * attributes,psa_key_type_t type)470 static inline void psa_set_key_type( psa_key_attributes_t *attributes,
471 psa_key_type_t type )
472 {
473 if( attributes->MBEDTLS_PRIVATE(domain_parameters) == NULL )
474 {
475 /* Common case: quick path */
476 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(type) = type;
477 }
478 else
479 {
480 /* Call the bigger function to free the old domain parameters.
481 * Ignore any errors which may arise due to type requiring
482 * non-default domain parameters, since this function can't
483 * report errors. */
484 (void) psa_set_key_domain_parameters( attributes, type, NULL, 0 );
485 }
486 }
487
psa_get_key_type(const psa_key_attributes_t * attributes)488 static inline psa_key_type_t psa_get_key_type(
489 const psa_key_attributes_t *attributes )
490 {
491 return( attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(type) );
492 }
493
psa_set_key_bits(psa_key_attributes_t * attributes,size_t bits)494 static inline void psa_set_key_bits( psa_key_attributes_t *attributes,
495 size_t bits )
496 {
497 if( bits > PSA_MAX_KEY_BITS )
498 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(bits) = PSA_KEY_BITS_TOO_LARGE;
499 else
500 attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(bits) = (psa_key_bits_t) bits;
501 }
502
psa_get_key_bits(const psa_key_attributes_t * attributes)503 static inline size_t psa_get_key_bits(
504 const psa_key_attributes_t *attributes )
505 {
506 return( attributes->MBEDTLS_PRIVATE(core).MBEDTLS_PRIVATE(bits) );
507 }
508
509 #ifdef __cplusplus
510 }
511 #endif
512
513 #endif /* PSA_CRYPTO_STRUCT_H */
514
