1 /**
2 * \file psa/crypto_values.h
3 *
4 * \brief PSA cryptography module: macros to build and analyze integer values.
5 *
6 * \note This file may not be included directly. Applications must
7 * include psa/crypto.h. Drivers must include the appropriate driver
8 * header file.
9 *
10 * This file contains portable definitions of macros to build and analyze
11 * values of integral types that encode properties of cryptographic keys,
12 * designations of cryptographic algorithms, and error codes returned by
13 * the library.
14 *
15 * This header file only defines preprocessor macros.
16 */
17 /*
18 * Copyright The Mbed TLS Contributors
19 * SPDX-License-Identifier: Apache-2.0
20 *
21 * Licensed under the Apache License, Version 2.0 (the "License"); you may
22 * not use this file except in compliance with the License.
23 * You may obtain a copy of the License at
24 *
25 * http://www.apache.org/licenses/LICENSE-2.0
26 *
27 * Unless required by applicable law or agreed to in writing, software
28 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
29 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
30 * See the License for the specific language governing permissions and
31 * limitations under the License.
32 */
33
34 #ifndef PSA_CRYPTO_VALUES_H
35 #define PSA_CRYPTO_VALUES_H
36 #include "mbedtls/private_access.h"
37
38 /** \defgroup error Error codes
39 * @{
40 */
41
42 /* PSA error codes */
43
44 /** The action was completed successfully. */
45 #define PSA_SUCCESS ((psa_status_t)0)
46
47 /** An error occurred that does not correspond to any defined
48 * failure cause.
49 *
50 * Implementations may use this error code if none of the other standard
51 * error codes are applicable. */
52 #define PSA_ERROR_GENERIC_ERROR ((psa_status_t)-132)
53
54 /** The requested operation or a parameter is not supported
55 * by this implementation.
56 *
57 * Implementations should return this error code when an enumeration
58 * parameter such as a key type, algorithm, etc. is not recognized.
59 * If a combination of parameters is recognized and identified as
60 * not valid, return #PSA_ERROR_INVALID_ARGUMENT instead. */
61 #define PSA_ERROR_NOT_SUPPORTED ((psa_status_t)-134)
62
63 /** The requested action is denied by a policy.
64 *
65 * Implementations should return this error code when the parameters
66 * are recognized as valid and supported, and a policy explicitly
67 * denies the requested operation.
68 *
69 * If a subset of the parameters of a function call identify a
70 * forbidden operation, and another subset of the parameters are
71 * not valid or not supported, it is unspecified whether the function
72 * returns #PSA_ERROR_NOT_PERMITTED, #PSA_ERROR_NOT_SUPPORTED or
73 * #PSA_ERROR_INVALID_ARGUMENT. */
74 #define PSA_ERROR_NOT_PERMITTED ((psa_status_t)-133)
75
76 /** An output buffer is too small.
77 *
78 * Applications can call the \c PSA_xxx_SIZE macro listed in the function
79 * description to determine a sufficient buffer size.
80 *
81 * Implementations should preferably return this error code only
82 * in cases when performing the operation with a larger output
83 * buffer would succeed. However implementations may return this
84 * error if a function has invalid or unsupported parameters in addition
85 * to the parameters that determine the necessary output buffer size. */
86 #define PSA_ERROR_BUFFER_TOO_SMALL ((psa_status_t)-138)
87
88 /** Asking for an item that already exists
89 *
90 * Implementations should return this error, when attempting
91 * to write an item (like a key) that already exists. */
92 #define PSA_ERROR_ALREADY_EXISTS ((psa_status_t)-139)
93
94 /** Asking for an item that doesn't exist
95 *
96 * Implementations should return this error, if a requested item (like
97 * a key) does not exist. */
98 #define PSA_ERROR_DOES_NOT_EXIST ((psa_status_t)-140)
99
100 /** The requested action cannot be performed in the current state.
101 *
102 * Multipart operations return this error when one of the
103 * functions is called out of sequence. Refer to the function
104 * descriptions for permitted sequencing of functions.
105 *
106 * Implementations shall not return this error code to indicate
107 * that a key either exists or not,
108 * but shall instead return #PSA_ERROR_ALREADY_EXISTS or #PSA_ERROR_DOES_NOT_EXIST
109 * as applicable.
110 *
111 * Implementations shall not return this error code to indicate that a
112 * key identifier is invalid, but shall return #PSA_ERROR_INVALID_HANDLE
113 * instead. */
114 #define PSA_ERROR_BAD_STATE ((psa_status_t)-137)
115
116 /** The parameters passed to the function are invalid.
117 *
118 * Implementations may return this error any time a parameter or
119 * combination of parameters are recognized as invalid.
120 *
121 * Implementations shall not return this error code to indicate that a
122 * key identifier is invalid, but shall return #PSA_ERROR_INVALID_HANDLE
123 * instead.
124 */
125 #define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)-135)
126
127 /** There is not enough runtime memory.
128 *
129 * If the action is carried out across multiple security realms, this
130 * error can refer to available memory in any of the security realms. */
131 #define PSA_ERROR_INSUFFICIENT_MEMORY ((psa_status_t)-141)
132
133 /** There is not enough persistent storage.
134 *
135 * Functions that modify the key storage return this error code if
136 * there is insufficient storage space on the host media. In addition,
137 * many functions that do not otherwise access storage may return this
138 * error code if the implementation requires a mandatory log entry for
139 * the requested action and the log storage space is full. */
140 #define PSA_ERROR_INSUFFICIENT_STORAGE ((psa_status_t)-142)
141
142 /** There was a communication failure inside the implementation.
143 *
144 * This can indicate a communication failure between the application
145 * and an external cryptoprocessor or between the cryptoprocessor and
146 * an external volatile or persistent memory. A communication failure
147 * may be transient or permanent depending on the cause.
148 *
149 * \warning If a function returns this error, it is undetermined
150 * whether the requested action has completed or not. Implementations
151 * should return #PSA_SUCCESS on successful completion whenever
152 * possible, however functions may return #PSA_ERROR_COMMUNICATION_FAILURE
153 * if the requested action was completed successfully in an external
154 * cryptoprocessor but there was a breakdown of communication before
155 * the cryptoprocessor could report the status to the application.
156 */
157 #define PSA_ERROR_COMMUNICATION_FAILURE ((psa_status_t)-145)
158
159 /** There was a storage failure that may have led to data loss.
160 *
161 * This error indicates that some persistent storage is corrupted.
162 * It should not be used for a corruption of volatile memory
163 * (use #PSA_ERROR_CORRUPTION_DETECTED), for a communication error
164 * between the cryptoprocessor and its external storage (use
165 * #PSA_ERROR_COMMUNICATION_FAILURE), or when the storage is
166 * in a valid state but is full (use #PSA_ERROR_INSUFFICIENT_STORAGE).
167 *
168 * Note that a storage failure does not indicate that any data that was
169 * previously read is invalid. However this previously read data may no
170 * longer be readable from storage.
171 *
172 * When a storage failure occurs, it is no longer possible to ensure
173 * the global integrity of the keystore. Depending on the global
174 * integrity guarantees offered by the implementation, access to other
175 * data may or may not fail even if the data is still readable but
176 * its integrity cannot be guaranteed.
177 *
178 * Implementations should only use this error code to report a
179 * permanent storage corruption. However application writers should
180 * keep in mind that transient errors while reading the storage may be
181 * reported using this error code. */
182 #define PSA_ERROR_STORAGE_FAILURE ((psa_status_t)-146)
183
184 /** A hardware failure was detected.
185 *
186 * A hardware failure may be transient or permanent depending on the
187 * cause. */
188 #define PSA_ERROR_HARDWARE_FAILURE ((psa_status_t)-147)
189
190 /** A tampering attempt was detected.
191 *
192 * If an application receives this error code, there is no guarantee
193 * that previously accessed or computed data was correct and remains
194 * confidential. Applications should not perform any security function
195 * and should enter a safe failure state.
196 *
197 * Implementations may return this error code if they detect an invalid
198 * state that cannot happen during normal operation and that indicates
199 * that the implementation's security guarantees no longer hold. Depending
200 * on the implementation architecture and on its security and safety goals,
201 * the implementation may forcibly terminate the application.
202 *
203 * This error code is intended as a last resort when a security breach
204 * is detected and it is unsure whether the keystore data is still
205 * protected. Implementations shall only return this error code
206 * to report an alarm from a tampering detector, to indicate that
207 * the confidentiality of stored data can no longer be guaranteed,
208 * or to indicate that the integrity of previously returned data is now
209 * considered compromised. Implementations shall not use this error code
210 * to indicate a hardware failure that merely makes it impossible to
211 * perform the requested operation (use #PSA_ERROR_COMMUNICATION_FAILURE,
212 * #PSA_ERROR_STORAGE_FAILURE, #PSA_ERROR_HARDWARE_FAILURE,
213 * #PSA_ERROR_INSUFFICIENT_ENTROPY or other applicable error code
214 * instead).
215 *
216 * This error indicates an attack against the application. Implementations
217 * shall not return this error code as a consequence of the behavior of
218 * the application itself. */
219 #define PSA_ERROR_CORRUPTION_DETECTED ((psa_status_t)-151)
220
221 /** There is not enough entropy to generate random data needed
222 * for the requested action.
223 *
224 * This error indicates a failure of a hardware random generator.
225 * Application writers should note that this error can be returned not
226 * only by functions whose purpose is to generate random data, such
227 * as key, IV or nonce generation, but also by functions that execute
228 * an algorithm with a randomized result, as well as functions that
229 * use randomization of intermediate computations as a countermeasure
230 * to certain attacks.
231 *
232 * Implementations should avoid returning this error after psa_crypto_init()
233 * has succeeded. Implementations should generate sufficient
234 * entropy during initialization and subsequently use a cryptographically
235 * secure pseudorandom generator (PRNG). However implementations may return
236 * this error at any time if a policy requires the PRNG to be reseeded
237 * during normal operation. */
238 #define PSA_ERROR_INSUFFICIENT_ENTROPY ((psa_status_t)-148)
239
240 /** The signature, MAC or hash is incorrect.
241 *
242 * Verification functions return this error if the verification
243 * calculations completed successfully, and the value to be verified
244 * was determined to be incorrect.
245 *
246 * If the value to verify has an invalid size, implementations may return
247 * either #PSA_ERROR_INVALID_ARGUMENT or #PSA_ERROR_INVALID_SIGNATURE. */
248 #define PSA_ERROR_INVALID_SIGNATURE ((psa_status_t)-149)
249
250 /** The decrypted padding is incorrect.
251 *
252 * \warning In some protocols, when decrypting data, it is essential that
253 * the behavior of the application does not depend on whether the padding
254 * is correct, down to precise timing. Applications should prefer
255 * protocols that use authenticated encryption rather than plain
256 * encryption. If the application must perform a decryption of
257 * unauthenticated data, the application writer should take care not
258 * to reveal whether the padding is invalid.
259 *
260 * Implementations should strive to make valid and invalid padding
261 * as close as possible to indistinguishable to an external observer.
262 * In particular, the timing of a decryption operation should not
263 * depend on the validity of the padding. */
264 #define PSA_ERROR_INVALID_PADDING ((psa_status_t)-150)
265
266 /** Return this error when there's insufficient data when attempting
267 * to read from a resource. */
268 #define PSA_ERROR_INSUFFICIENT_DATA ((psa_status_t)-143)
269
270 /** The key identifier is not valid. See also :ref:\`key-handles\`.
271 */
272 #define PSA_ERROR_INVALID_HANDLE ((psa_status_t)-136)
273
274 /** Stored data has been corrupted.
275 *
276 * This error indicates that some persistent storage has suffered corruption.
277 * It does not indicate the following situations, which have specific error
278 * codes:
279 *
280 * - A corruption of volatile memory - use #PSA_ERROR_CORRUPTION_DETECTED.
281 * - A communication error between the cryptoprocessor and its external
282 * storage - use #PSA_ERROR_COMMUNICATION_FAILURE.
283 * - When the storage is in a valid state but is full - use
284 * #PSA_ERROR_INSUFFICIENT_STORAGE.
285 * - When the storage fails for other reasons - use
286 * #PSA_ERROR_STORAGE_FAILURE.
287 * - When the stored data is not valid - use #PSA_ERROR_DATA_INVALID.
288 *
289 * \note A storage corruption does not indicate that any data that was
290 * previously read is invalid. However this previously read data might no
291 * longer be readable from storage.
292 *
293 * When a storage failure occurs, it is no longer possible to ensure the
294 * global integrity of the keystore.
295 */
296 #define PSA_ERROR_DATA_CORRUPT ((psa_status_t)-152)
297
298 /** Data read from storage is not valid for the implementation.
299 *
300 * This error indicates that some data read from storage does not have a valid
301 * format. It does not indicate the following situations, which have specific
302 * error codes:
303 *
304 * - When the storage or stored data is corrupted - use #PSA_ERROR_DATA_CORRUPT
305 * - When the storage fails for other reasons - use #PSA_ERROR_STORAGE_FAILURE
306 * - An invalid argument to the API - use #PSA_ERROR_INVALID_ARGUMENT
307 *
308 * This error is typically a result of either storage corruption on a
309 * cleartext storage backend, or an attempt to read data that was
310 * written by an incompatible version of the library.
311 */
312 #define PSA_ERROR_DATA_INVALID ((psa_status_t)-153)
313
314 /**@}*/
315
316 /** \defgroup crypto_types Key and algorithm types
317 * @{
318 */
319
320 /** An invalid key type value.
321 *
322 * Zero is not the encoding of any key type.
323 */
324 #define PSA_KEY_TYPE_NONE ((psa_key_type_t)0x0000)
325
326 /** Vendor-defined key type flag.
327 *
328 * Key types defined by this standard will never have the
329 * #PSA_KEY_TYPE_VENDOR_FLAG bit set. Vendors who define additional key types
330 * must use an encoding with the #PSA_KEY_TYPE_VENDOR_FLAG bit set and should
331 * respect the bitwise structure used by standard encodings whenever practical.
332 */
333 #define PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x8000)
334
335 #define PSA_KEY_TYPE_CATEGORY_MASK ((psa_key_type_t)0x7000)
336 #define PSA_KEY_TYPE_CATEGORY_RAW ((psa_key_type_t)0x1000)
337 #define PSA_KEY_TYPE_CATEGORY_SYMMETRIC ((psa_key_type_t)0x2000)
338 #define PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY ((psa_key_type_t)0x4000)
339 #define PSA_KEY_TYPE_CATEGORY_KEY_PAIR ((psa_key_type_t)0x7000)
340
341 #define PSA_KEY_TYPE_CATEGORY_FLAG_PAIR ((psa_key_type_t)0x3000)
342
343 /** Whether a key type is vendor-defined.
344 *
345 * See also #PSA_KEY_TYPE_VENDOR_FLAG.
346 */
347 #define PSA_KEY_TYPE_IS_VENDOR_DEFINED(type) \
348 (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0)
349
350 /** Whether a key type is an unstructured array of bytes.
351 *
352 * This encompasses both symmetric keys and non-key data.
353 */
354 #define PSA_KEY_TYPE_IS_UNSTRUCTURED(type) \
355 (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_RAW || \
356 ((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_SYMMETRIC)
357
358 /** Whether a key type is asymmetric: either a key pair or a public key. */
359 #define PSA_KEY_TYPE_IS_ASYMMETRIC(type) \
360 (((type) & PSA_KEY_TYPE_CATEGORY_MASK \
361 & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) == \
362 PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)
363 /** Whether a key type is the public part of a key pair. */
364 #define PSA_KEY_TYPE_IS_PUBLIC_KEY(type) \
365 (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)
366 /** Whether a key type is a key pair containing a private part and a public
367 * part. */
368 #define PSA_KEY_TYPE_IS_KEY_PAIR(type) \
369 (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)
370 /** The key pair type corresponding to a public key type.
371 *
372 * You may also pass a key pair type as \p type, it will be left unchanged.
373 *
374 * \param type A public key type or key pair type.
375 *
376 * \return The corresponding key pair type.
377 * If \p type is not a public key or a key pair,
378 * the return value is undefined.
379 */
380 #define PSA_KEY_TYPE_KEY_PAIR_OF_PUBLIC_KEY(type) \
381 ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)
382 /** The public key type corresponding to a key pair type.
383 *
384 * You may also pass a key pair type as \p type, it will be left unchanged.
385 *
386 * \param type A public key type or key pair type.
387 *
388 * \return The corresponding public key type.
389 * If \p type is not a public key or a key pair,
390 * the return value is undefined.
391 */
392 #define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) \
393 ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)
394
395 /** Raw data.
396 *
397 * A "key" of this type cannot be used for any cryptographic operation.
398 * Applications may use this type to store arbitrary data in the keystore. */
399 #define PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x1001)
400
401 /** HMAC key.
402 *
403 * The key policy determines which underlying hash algorithm the key can be
404 * used for.
405 *
406 * HMAC keys should generally have the same size as the underlying hash.
407 * This size can be calculated with #PSA_HASH_LENGTH(\c alg) where
408 * \c alg is the HMAC algorithm or the underlying hash algorithm. */
409 #define PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x1100)
410
411 /** A secret for key derivation.
412 *
413 * This key type is for high-entropy secrets only. For low-entropy secrets,
414 * #PSA_KEY_TYPE_PASSWORD should be used instead.
415 *
416 * These keys can be used as the #PSA_KEY_DERIVATION_INPUT_SECRET or
417 * #PSA_KEY_DERIVATION_INPUT_PASSWORD input of key derivation algorithms.
418 *
419 * The key policy determines which key derivation algorithm the key
420 * can be used for.
421 */
422 #define PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x1200)
423
424 /** A low-entropy secret for password hashing or key derivation.
425 *
426 * This key type is suitable for passwords and passphrases which are typically
427 * intended to be memorizable by humans, and have a low entropy relative to
428 * their size. It can be used for randomly generated or derived keys with
429 * maximum or near-maximum entropy, but #PSA_KEY_TYPE_DERIVE is more suitable
430 * for such keys. It is not suitable for passwords with extremely low entropy,
431 * such as numerical PINs.
432 *
433 * These keys can be used as the #PSA_KEY_DERIVATION_INPUT_PASSWORD input of
434 * key derivation algorithms. Algorithms that accept such an input were
435 * designed to accept low-entropy secret and are known as password hashing or
436 * key stretching algorithms.
437 *
438 * These keys cannot be used as the #PSA_KEY_DERIVATION_INPUT_SECRET input of
439 * key derivation algorithms, as the algorithms that take such an input expect
440 * it to be high-entropy.
441 *
442 * The key policy determines which key derivation algorithm the key can be
443 * used for, among the permissible subset defined above.
444 */
445 #define PSA_KEY_TYPE_PASSWORD ((psa_key_type_t)0x1203)
446
447 /** A secret value that can be used to verify a password hash.
448 *
449 * The key policy determines which key derivation algorithm the key
450 * can be used for, among the same permissible subset as for
451 * #PSA_KEY_TYPE_PASSWORD.
452 */
453 #define PSA_KEY_TYPE_PASSWORD_HASH ((psa_key_type_t)0x1205)
454
455 /** A secret value that can be used in when computing a password hash.
456 *
457 * The key policy determines which key derivation algorithm the key
458 * can be used for, among the subset of algorithms that can use pepper.
459 */
460 #define PSA_KEY_TYPE_PEPPER ((psa_key_type_t)0x1206)
461
462 /** Key for a cipher, AEAD or MAC algorithm based on the AES block cipher.
463 *
464 * The size of the key can be 16 bytes (AES-128), 24 bytes (AES-192) or
465 * 32 bytes (AES-256).
466 */
467 #define PSA_KEY_TYPE_AES ((psa_key_type_t)0x2400)
468
469 /** Key for a cipher, AEAD or MAC algorithm based on the
470 * ARIA block cipher. */
471 #define PSA_KEY_TYPE_ARIA ((psa_key_type_t)0x2406)
472
473 /** Key for a cipher or MAC algorithm based on DES or 3DES (Triple-DES).
474 *
475 * The size of the key can be 64 bits (single DES), 128 bits (2-key 3DES) or
476 * 192 bits (3-key 3DES).
477 *
478 * Note that single DES and 2-key 3DES are weak and strongly
479 * deprecated and should only be used to decrypt legacy data. 3-key 3DES
480 * is weak and deprecated and should only be used in legacy protocols.
481 */
482 #define PSA_KEY_TYPE_DES ((psa_key_type_t)0x2301)
483
484 /** Key for a cipher, AEAD or MAC algorithm based on the
485 * Camellia block cipher. */
486 #define PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x2403)
487
488 /** Key for the ChaCha20 stream cipher or the Chacha20-Poly1305 AEAD algorithm.
489 *
490 * ChaCha20 and the ChaCha20_Poly1305 construction are defined in RFC 7539.
491 *
492 * Implementations must support 12-byte nonces, may support 8-byte nonces,
493 * and should reject other sizes.
494 */
495 #define PSA_KEY_TYPE_CHACHA20 ((psa_key_type_t)0x2004)
496
497 /** RSA public key.
498 *
499 * The size of an RSA key is the bit size of the modulus.
500 */
501 #define PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x4001)
502 /** RSA key pair (private and public key).
503 *
504 * The size of an RSA key is the bit size of the modulus.
505 */
506 #define PSA_KEY_TYPE_RSA_KEY_PAIR ((psa_key_type_t)0x7001)
507 /** Whether a key type is an RSA key (pair or public-only). */
508 #define PSA_KEY_TYPE_IS_RSA(type) \
509 (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY)
510
511 #define PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE ((psa_key_type_t)0x4100)
512 #define PSA_KEY_TYPE_ECC_KEY_PAIR_BASE ((psa_key_type_t)0x7100)
513 #define PSA_KEY_TYPE_ECC_CURVE_MASK ((psa_key_type_t)0x00ff)
514 /** Elliptic curve key pair.
515 *
516 * The size of an elliptic curve key is the bit size associated with the curve,
517 * i.e. the bit size of *q* for a curve over a field *F<sub>q</sub>*.
518 * See the documentation of `PSA_ECC_FAMILY_xxx` curve families for details.
519 *
520 * \param curve A value of type ::psa_ecc_family_t that
521 * identifies the ECC curve to be used.
522 */
523 #define PSA_KEY_TYPE_ECC_KEY_PAIR(curve) \
524 (PSA_KEY_TYPE_ECC_KEY_PAIR_BASE | (curve))
525 /** Elliptic curve public key.
526 *
527 * The size of an elliptic curve public key is the same as the corresponding
528 * private key (see #PSA_KEY_TYPE_ECC_KEY_PAIR and the documentation of
529 * `PSA_ECC_FAMILY_xxx` curve families).
530 *
531 * \param curve A value of type ::psa_ecc_family_t that
532 * identifies the ECC curve to be used.
533 */
534 #define PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve) \
535 (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))
536
537 /** Whether a key type is an elliptic curve key (pair or public-only). */
538 #define PSA_KEY_TYPE_IS_ECC(type) \
539 ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) & \
540 ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)
541 /** Whether a key type is an elliptic curve key pair. */
542 #define PSA_KEY_TYPE_IS_ECC_KEY_PAIR(type) \
543 (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \
544 PSA_KEY_TYPE_ECC_KEY_PAIR_BASE)
545 /** Whether a key type is an elliptic curve public key. */
546 #define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type) \
547 (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \
548 PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)
549
550 /** Extract the curve from an elliptic curve key type. */
551 #define PSA_KEY_TYPE_ECC_GET_FAMILY(type) \
552 ((psa_ecc_family_t) (PSA_KEY_TYPE_IS_ECC(type) ? \
553 ((type) & PSA_KEY_TYPE_ECC_CURVE_MASK) : \
554 0))
555
556 /** SEC Koblitz curves over prime fields.
557 *
558 * This family comprises the following curves:
559 * secp192k1, secp224k1, secp256k1.
560 * They are defined in _Standards for Efficient Cryptography_,
561 * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
562 * https://www.secg.org/sec2-v2.pdf
563 */
564 #define PSA_ECC_FAMILY_SECP_K1 ((psa_ecc_family_t) 0x17)
565
566 /** SEC random curves over prime fields.
567 *
568 * This family comprises the following curves:
569 * secp192k1, secp224r1, secp256r1, secp384r1, secp521r1.
570 * They are defined in _Standards for Efficient Cryptography_,
571 * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
572 * https://www.secg.org/sec2-v2.pdf
573 */
574 #define PSA_ECC_FAMILY_SECP_R1 ((psa_ecc_family_t) 0x12)
575 /* SECP160R2 (SEC2 v1, obsolete) */
576 #define PSA_ECC_FAMILY_SECP_R2 ((psa_ecc_family_t) 0x1b)
577
578 /** SEC Koblitz curves over binary fields.
579 *
580 * This family comprises the following curves:
581 * sect163k1, sect233k1, sect239k1, sect283k1, sect409k1, sect571k1.
582 * They are defined in _Standards for Efficient Cryptography_,
583 * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
584 * https://www.secg.org/sec2-v2.pdf
585 */
586 #define PSA_ECC_FAMILY_SECT_K1 ((psa_ecc_family_t) 0x27)
587
588 /** SEC random curves over binary fields.
589 *
590 * This family comprises the following curves:
591 * sect163r1, sect233r1, sect283r1, sect409r1, sect571r1.
592 * They are defined in _Standards for Efficient Cryptography_,
593 * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
594 * https://www.secg.org/sec2-v2.pdf
595 */
596 #define PSA_ECC_FAMILY_SECT_R1 ((psa_ecc_family_t) 0x22)
597
598 /** SEC additional random curves over binary fields.
599 *
600 * This family comprises the following curve:
601 * sect163r2.
602 * It is defined in _Standards for Efficient Cryptography_,
603 * _SEC 2: Recommended Elliptic Curve Domain Parameters_.
604 * https://www.secg.org/sec2-v2.pdf
605 */
606 #define PSA_ECC_FAMILY_SECT_R2 ((psa_ecc_family_t) 0x2b)
607
608 /** Brainpool P random curves.
609 *
610 * This family comprises the following curves:
611 * brainpoolP160r1, brainpoolP192r1, brainpoolP224r1, brainpoolP256r1,
612 * brainpoolP320r1, brainpoolP384r1, brainpoolP512r1.
613 * It is defined in RFC 5639.
614 */
615 #define PSA_ECC_FAMILY_BRAINPOOL_P_R1 ((psa_ecc_family_t) 0x30)
616
617 /** Curve25519 and Curve448.
618 *
619 * This family comprises the following Montgomery curves:
620 * - 255-bit: Bernstein et al.,
621 * _Curve25519: new Diffie-Hellman speed records_, LNCS 3958, 2006.
622 * The algorithm #PSA_ALG_ECDH performs X25519 when used with this curve.
623 * - 448-bit: Hamburg,
624 * _Ed448-Goldilocks, a new elliptic curve_, NIST ECC Workshop, 2015.
625 * The algorithm #PSA_ALG_ECDH performs X448 when used with this curve.
626 */
627 #define PSA_ECC_FAMILY_MONTGOMERY ((psa_ecc_family_t) 0x41)
628
629 /** The twisted Edwards curves Ed25519 and Ed448.
630 *
631 * These curves are suitable for EdDSA (#PSA_ALG_PURE_EDDSA for both curves,
632 * #PSA_ALG_ED25519PH for the 255-bit curve,
633 * #PSA_ALG_ED448PH for the 448-bit curve).
634 *
635 * This family comprises the following twisted Edwards curves:
636 * - 255-bit: Edwards25519, the twisted Edwards curve birationally equivalent
637 * to Curve25519.
638 * Bernstein et al., _Twisted Edwards curves_, Africacrypt 2008.
639 * - 448-bit: Edwards448, the twisted Edwards curve birationally equivalent
640 * to Curve448.
641 * Hamburg, _Ed448-Goldilocks, a new elliptic curve_, NIST ECC Workshop, 2015.
642 */
643 #define PSA_ECC_FAMILY_TWISTED_EDWARDS ((psa_ecc_family_t) 0x42)
644
645 #define PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE ((psa_key_type_t)0x4200)
646 #define PSA_KEY_TYPE_DH_KEY_PAIR_BASE ((psa_key_type_t)0x7200)
647 #define PSA_KEY_TYPE_DH_GROUP_MASK ((psa_key_type_t)0x00ff)
648 /** Diffie-Hellman key pair.
649 *
650 * \param group A value of type ::psa_dh_family_t that identifies the
651 * Diffie-Hellman group to be used.
652 */
653 #define PSA_KEY_TYPE_DH_KEY_PAIR(group) \
654 (PSA_KEY_TYPE_DH_KEY_PAIR_BASE | (group))
655 /** Diffie-Hellman public key.
656 *
657 * \param group A value of type ::psa_dh_family_t that identifies the
658 * Diffie-Hellman group to be used.
659 */
660 #define PSA_KEY_TYPE_DH_PUBLIC_KEY(group) \
661 (PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE | (group))
662
663 /** Whether a key type is a Diffie-Hellman key (pair or public-only). */
664 #define PSA_KEY_TYPE_IS_DH(type) \
665 ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(type) & \
666 ~PSA_KEY_TYPE_DH_GROUP_MASK) == PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE)
667 /** Whether a key type is a Diffie-Hellman key pair. */
668 #define PSA_KEY_TYPE_IS_DH_KEY_PAIR(type) \
669 (((type) & ~PSA_KEY_TYPE_DH_GROUP_MASK) == \
670 PSA_KEY_TYPE_DH_KEY_PAIR_BASE)
671 /** Whether a key type is a Diffie-Hellman public key. */
672 #define PSA_KEY_TYPE_IS_DH_PUBLIC_KEY(type) \
673 (((type) & ~PSA_KEY_TYPE_DH_GROUP_MASK) == \
674 PSA_KEY_TYPE_DH_PUBLIC_KEY_BASE)
675
676 /** Extract the group from a Diffie-Hellman key type. */
677 #define PSA_KEY_TYPE_DH_GET_FAMILY(type) \
678 ((psa_dh_family_t) (PSA_KEY_TYPE_IS_DH(type) ? \
679 ((type) & PSA_KEY_TYPE_DH_GROUP_MASK) : \
680 0))
681
682 /** Diffie-Hellman groups defined in RFC 7919 Appendix A.
683 *
684 * This family includes groups with the following key sizes (in bits):
685 * 2048, 3072, 4096, 6144, 8192. A given implementation may support
686 * all of these sizes or only a subset.
687 */
688 #define PSA_DH_FAMILY_RFC7919 ((psa_dh_family_t) 0x03)
689
690 #define PSA_GET_KEY_TYPE_BLOCK_SIZE_EXPONENT(type) \
691 (((type) >> 8) & 7)
692 /** The block size of a block cipher.
693 *
694 * \param type A cipher key type (value of type #psa_key_type_t).
695 *
696 * \return The block size for a block cipher, or 1 for a stream cipher.
697 * The return value is undefined if \p type is not a supported
698 * cipher key type.
699 *
700 * \note It is possible to build stream cipher algorithms on top of a block
701 * cipher, for example CTR mode (#PSA_ALG_CTR).
702 * This macro only takes the key type into account, so it cannot be
703 * used to determine the size of the data that #psa_cipher_update()
704 * might buffer for future processing in general.
705 *
706 * \note This macro returns a compile-time constant if its argument is one.
707 *
708 * \warning This macro may evaluate its argument multiple times.
709 */
710 #define PSA_BLOCK_CIPHER_BLOCK_LENGTH(type) \
711 (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_SYMMETRIC ? \
712 1u << PSA_GET_KEY_TYPE_BLOCK_SIZE_EXPONENT(type) : \
713 0u)
714
715 /** Vendor-defined algorithm flag.
716 *
717 * Algorithms defined by this standard will never have the #PSA_ALG_VENDOR_FLAG
718 * bit set. Vendors who define additional algorithms must use an encoding with
719 * the #PSA_ALG_VENDOR_FLAG bit set and should respect the bitwise structure
720 * used by standard encodings whenever practical.
721 */
722 #define PSA_ALG_VENDOR_FLAG ((psa_algorithm_t)0x80000000)
723
724 #define PSA_ALG_CATEGORY_MASK ((psa_algorithm_t)0x7f000000)
725 #define PSA_ALG_CATEGORY_HASH ((psa_algorithm_t)0x02000000)
726 #define PSA_ALG_CATEGORY_MAC ((psa_algorithm_t)0x03000000)
727 #define PSA_ALG_CATEGORY_CIPHER ((psa_algorithm_t)0x04000000)
728 #define PSA_ALG_CATEGORY_AEAD ((psa_algorithm_t)0x05000000)
729 #define PSA_ALG_CATEGORY_SIGN ((psa_algorithm_t)0x06000000)
730 #define PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION ((psa_algorithm_t)0x07000000)
731 #define PSA_ALG_CATEGORY_KEY_DERIVATION ((psa_algorithm_t)0x08000000)
732 #define PSA_ALG_CATEGORY_KEY_AGREEMENT ((psa_algorithm_t)0x09000000)
733
734 /** Whether an algorithm is vendor-defined.
735 *
736 * See also #PSA_ALG_VENDOR_FLAG.
737 */
738 #define PSA_ALG_IS_VENDOR_DEFINED(alg) \
739 (((alg) & PSA_ALG_VENDOR_FLAG) != 0)
740
741 /** Whether the specified algorithm is a hash algorithm.
742 *
743 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
744 *
745 * \return 1 if \p alg is a hash algorithm, 0 otherwise.
746 * This macro may return either 0 or 1 if \p alg is not a supported
747 * algorithm identifier.
748 */
749 #define PSA_ALG_IS_HASH(alg) \
750 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)
751
752 /** Whether the specified algorithm is a MAC algorithm.
753 *
754 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
755 *
756 * \return 1 if \p alg is a MAC algorithm, 0 otherwise.
757 * This macro may return either 0 or 1 if \p alg is not a supported
758 * algorithm identifier.
759 */
760 #define PSA_ALG_IS_MAC(alg) \
761 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)
762
763 /** Whether the specified algorithm is a symmetric cipher algorithm.
764 *
765 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
766 *
767 * \return 1 if \p alg is a symmetric cipher algorithm, 0 otherwise.
768 * This macro may return either 0 or 1 if \p alg is not a supported
769 * algorithm identifier.
770 */
771 #define PSA_ALG_IS_CIPHER(alg) \
772 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)
773
774 /** Whether the specified algorithm is an authenticated encryption
775 * with associated data (AEAD) algorithm.
776 *
777 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
778 *
779 * \return 1 if \p alg is an AEAD algorithm, 0 otherwise.
780 * This macro may return either 0 or 1 if \p alg is not a supported
781 * algorithm identifier.
782 */
783 #define PSA_ALG_IS_AEAD(alg) \
784 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)
785
786 /** Whether the specified algorithm is an asymmetric signature algorithm,
787 * also known as public-key signature algorithm.
788 *
789 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
790 *
791 * \return 1 if \p alg is an asymmetric signature algorithm, 0 otherwise.
792 * This macro may return either 0 or 1 if \p alg is not a supported
793 * algorithm identifier.
794 */
795 #define PSA_ALG_IS_SIGN(alg) \
796 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)
797
798 /** Whether the specified algorithm is an asymmetric encryption algorithm,
799 * also known as public-key encryption algorithm.
800 *
801 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
802 *
803 * \return 1 if \p alg is an asymmetric encryption algorithm, 0 otherwise.
804 * This macro may return either 0 or 1 if \p alg is not a supported
805 * algorithm identifier.
806 */
807 #define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg) \
808 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)
809
810 /** Whether the specified algorithm is a key agreement algorithm.
811 *
812 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
813 *
814 * \return 1 if \p alg is a key agreement algorithm, 0 otherwise.
815 * This macro may return either 0 or 1 if \p alg is not a supported
816 * algorithm identifier.
817 */
818 #define PSA_ALG_IS_KEY_AGREEMENT(alg) \
819 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_AGREEMENT)
820
821 /** Whether the specified algorithm is a key derivation algorithm.
822 *
823 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
824 *
825 * \return 1 if \p alg is a key derivation algorithm, 0 otherwise.
826 * This macro may return either 0 or 1 if \p alg is not a supported
827 * algorithm identifier.
828 */
829 #define PSA_ALG_IS_KEY_DERIVATION(alg) \
830 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)
831
832 /** Whether the specified algorithm is a key stretching / password hashing
833 * algorithm.
834 *
835 * A key stretching / password hashing algorithm is a key derivation algorithm
836 * that is suitable for use with a low-entropy secret such as a password.
837 * Equivalently, it's a key derivation algorithm that uses a
838 * #PSA_KEY_DERIVATION_INPUT_PASSWORD input step.
839 *
840 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
841 *
842 * \return 1 if \p alg is a key stretching / password hashing algorithm, 0
843 * otherwise. This macro may return either 0 or 1 if \p alg is not a
844 * supported algorithm identifier.
845 */
846 #define PSA_ALG_IS_KEY_DERIVATION_STRETCHING(alg) \
847 (PSA_ALG_IS_KEY_DERIVATION(alg) && \
848 (alg) & PSA_ALG_KEY_DERIVATION_STRETCHING_FLAG)
849
850 /** An invalid algorithm identifier value. */
851 #define PSA_ALG_NONE ((psa_algorithm_t)0)
852
853 #define PSA_ALG_HASH_MASK ((psa_algorithm_t)0x000000ff)
854 /** MD5 */
855 #define PSA_ALG_MD5 ((psa_algorithm_t)0x02000003)
856 /** PSA_ALG_RIPEMD160 */
857 #define PSA_ALG_RIPEMD160 ((psa_algorithm_t)0x02000004)
858 /** SHA1 */
859 #define PSA_ALG_SHA_1 ((psa_algorithm_t)0x02000005)
860 /** SHA2-224 */
861 #define PSA_ALG_SHA_224 ((psa_algorithm_t)0x02000008)
862 /** SHA2-256 */
863 #define PSA_ALG_SHA_256 ((psa_algorithm_t)0x02000009)
864 /** SHA2-384 */
865 #define PSA_ALG_SHA_384 ((psa_algorithm_t)0x0200000a)
866 /** SHA2-512 */
867 #define PSA_ALG_SHA_512 ((psa_algorithm_t)0x0200000b)
868 /** SHA2-512/224 */
869 #define PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0200000c)
870 /** SHA2-512/256 */
871 #define PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0200000d)
872 /** SHA3-224 */
873 #define PSA_ALG_SHA3_224 ((psa_algorithm_t)0x02000010)
874 /** SHA3-256 */
875 #define PSA_ALG_SHA3_256 ((psa_algorithm_t)0x02000011)
876 /** SHA3-384 */
877 #define PSA_ALG_SHA3_384 ((psa_algorithm_t)0x02000012)
878 /** SHA3-512 */
879 #define PSA_ALG_SHA3_512 ((psa_algorithm_t)0x02000013)
880 /** The first 512 bits (64 bytes) of the SHAKE256 output.
881 *
882 * This is the prehashing for Ed448ph (see #PSA_ALG_ED448PH). For other
883 * scenarios where a hash function based on SHA3/SHAKE is desired, SHA3-512
884 * has the same output size and a (theoretically) higher security strength.
885 */
886 #define PSA_ALG_SHAKE256_512 ((psa_algorithm_t)0x02000015)
887
888 /** In a hash-and-sign algorithm policy, allow any hash algorithm.
889 *
890 * This value may be used to form the algorithm usage field of a policy
891 * for a signature algorithm that is parametrized by a hash. The key
892 * may then be used to perform operations using the same signature
893 * algorithm parametrized with any supported hash.
894 *
895 * That is, suppose that `PSA_xxx_SIGNATURE` is one of the following macros:
896 * - #PSA_ALG_RSA_PKCS1V15_SIGN, #PSA_ALG_RSA_PSS, #PSA_ALG_RSA_PSS_ANY_SALT,
897 * - #PSA_ALG_ECDSA, #PSA_ALG_DETERMINISTIC_ECDSA.
898 * Then you may create and use a key as follows:
899 * - Set the key usage field using #PSA_ALG_ANY_HASH, for example:
900 * ```
901 * psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_SIGN_HASH); // or VERIFY
902 * psa_set_key_algorithm(&attributes, PSA_xxx_SIGNATURE(PSA_ALG_ANY_HASH));
903 * ```
904 * - Import or generate key material.
905 * - Call psa_sign_hash() or psa_verify_hash(), passing
906 * an algorithm built from `PSA_xxx_SIGNATURE` and a specific hash. Each
907 * call to sign or verify a message may use a different hash.
908 * ```
909 * psa_sign_hash(key, PSA_xxx_SIGNATURE(PSA_ALG_SHA_256), ...);
910 * psa_sign_hash(key, PSA_xxx_SIGNATURE(PSA_ALG_SHA_512), ...);
911 * psa_sign_hash(key, PSA_xxx_SIGNATURE(PSA_ALG_SHA3_256), ...);
912 * ```
913 *
914 * This value may not be used to build other algorithms that are
915 * parametrized over a hash. For any valid use of this macro to build
916 * an algorithm \c alg, #PSA_ALG_IS_HASH_AND_SIGN(\c alg) is true.
917 *
918 * This value may not be used to build an algorithm specification to
919 * perform an operation. It is only valid to build policies.
920 */
921 #define PSA_ALG_ANY_HASH ((psa_algorithm_t)0x020000ff)
922
923 #define PSA_ALG_MAC_SUBCATEGORY_MASK ((psa_algorithm_t)0x00c00000)
924 #define PSA_ALG_HMAC_BASE ((psa_algorithm_t)0x03800000)
925 /** Macro to build an HMAC algorithm.
926 *
927 * For example, #PSA_ALG_HMAC(#PSA_ALG_SHA_256) is HMAC-SHA-256.
928 *
929 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
930 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
931 *
932 * \return The corresponding HMAC algorithm.
933 * \return Unspecified if \p hash_alg is not a supported
934 * hash algorithm.
935 */
936 #define PSA_ALG_HMAC(hash_alg) \
937 (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
938
939 #define PSA_ALG_HMAC_GET_HASH(hmac_alg) \
940 (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))
941
942 /** Whether the specified algorithm is an HMAC algorithm.
943 *
944 * HMAC is a family of MAC algorithms that are based on a hash function.
945 *
946 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
947 *
948 * \return 1 if \p alg is an HMAC algorithm, 0 otherwise.
949 * This macro may return either 0 or 1 if \p alg is not a supported
950 * algorithm identifier.
951 */
952 #define PSA_ALG_IS_HMAC(alg) \
953 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \
954 PSA_ALG_HMAC_BASE)
955
956 /* In the encoding of a MAC algorithm, the bits corresponding to
957 * PSA_ALG_MAC_TRUNCATION_MASK encode the length to which the MAC is
958 * truncated. As an exception, the value 0 means the untruncated algorithm,
959 * whatever its length is. The length is encoded in 6 bits, so it can
960 * reach up to 63; the largest MAC is 64 bytes so its trivial truncation
961 * to full length is correctly encoded as 0 and any non-trivial truncation
962 * is correctly encoded as a value between 1 and 63. */
963 #define PSA_ALG_MAC_TRUNCATION_MASK ((psa_algorithm_t)0x003f0000)
964 #define PSA_MAC_TRUNCATION_OFFSET 16
965
966 /* In the encoding of a MAC algorithm, the bit corresponding to
967 * #PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG encodes the fact that the algorithm
968 * is a wildcard algorithm. A key with such wildcard algorithm as permitted
969 * algorithm policy can be used with any algorithm corresponding to the
970 * same base class and having a (potentially truncated) MAC length greater or
971 * equal than the one encoded in #PSA_ALG_MAC_TRUNCATION_MASK. */
972 #define PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG ((psa_algorithm_t)0x00008000)
973
974 /** Macro to build a truncated MAC algorithm.
975 *
976 * A truncated MAC algorithm is identical to the corresponding MAC
977 * algorithm except that the MAC value for the truncated algorithm
978 * consists of only the first \p mac_length bytes of the MAC value
979 * for the untruncated algorithm.
980 *
981 * \note This macro may allow constructing algorithm identifiers that
982 * are not valid, either because the specified length is larger
983 * than the untruncated MAC or because the specified length is
984 * smaller than permitted by the implementation.
985 *
986 * \note It is implementation-defined whether a truncated MAC that
987 * is truncated to the same length as the MAC of the untruncated
988 * algorithm is considered identical to the untruncated algorithm
989 * for policy comparison purposes.
990 *
991 * \param mac_alg A MAC algorithm identifier (value of type
992 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p mac_alg)
993 * is true). This may be a truncated or untruncated
994 * MAC algorithm.
995 * \param mac_length Desired length of the truncated MAC in bytes.
996 * This must be at most the full length of the MAC
997 * and must be at least an implementation-specified
998 * minimum. The implementation-specified minimum
999 * shall not be zero.
1000 *
1001 * \return The corresponding MAC algorithm with the specified
1002 * length.
1003 * \return Unspecified if \p mac_alg is not a supported
1004 * MAC algorithm or if \p mac_length is too small or
1005 * too large for the specified MAC algorithm.
1006 */
1007 #define PSA_ALG_TRUNCATED_MAC(mac_alg, mac_length) \
1008 (((mac_alg) & ~(PSA_ALG_MAC_TRUNCATION_MASK | \
1009 PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG)) | \
1010 ((mac_length) << PSA_MAC_TRUNCATION_OFFSET & PSA_ALG_MAC_TRUNCATION_MASK))
1011
1012 /** Macro to build the base MAC algorithm corresponding to a truncated
1013 * MAC algorithm.
1014 *
1015 * \param mac_alg A MAC algorithm identifier (value of type
1016 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p mac_alg)
1017 * is true). This may be a truncated or untruncated
1018 * MAC algorithm.
1019 *
1020 * \return The corresponding base MAC algorithm.
1021 * \return Unspecified if \p mac_alg is not a supported
1022 * MAC algorithm.
1023 */
1024 #define PSA_ALG_FULL_LENGTH_MAC(mac_alg) \
1025 ((mac_alg) & ~(PSA_ALG_MAC_TRUNCATION_MASK | \
1026 PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG))
1027
1028 /** Length to which a MAC algorithm is truncated.
1029 *
1030 * \param mac_alg A MAC algorithm identifier (value of type
1031 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p mac_alg)
1032 * is true).
1033 *
1034 * \return Length of the truncated MAC in bytes.
1035 * \return 0 if \p mac_alg is a non-truncated MAC algorithm.
1036 * \return Unspecified if \p mac_alg is not a supported
1037 * MAC algorithm.
1038 */
1039 #define PSA_MAC_TRUNCATED_LENGTH(mac_alg) \
1040 (((mac_alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)
1041
1042 /** Macro to build a MAC minimum-MAC-length wildcard algorithm.
1043 *
1044 * A minimum-MAC-length MAC wildcard algorithm permits all MAC algorithms
1045 * sharing the same base algorithm, and where the (potentially truncated) MAC
1046 * length of the specific algorithm is equal to or larger then the wildcard
1047 * algorithm's minimum MAC length.
1048 *
1049 * \note When setting the minimum required MAC length to less than the
1050 * smallest MAC length allowed by the base algorithm, this effectively
1051 * becomes an 'any-MAC-length-allowed' policy for that base algorithm.
1052 *
1053 * \param mac_alg A MAC algorithm identifier (value of type
1054 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p mac_alg)
1055 * is true).
1056 * \param min_mac_length Desired minimum length of the message authentication
1057 * code in bytes. This must be at most the untruncated
1058 * length of the MAC and must be at least 1.
1059 *
1060 * \return The corresponding MAC wildcard algorithm with the
1061 * specified minimum length.
1062 * \return Unspecified if \p mac_alg is not a supported MAC
1063 * algorithm or if \p min_mac_length is less than 1 or
1064 * too large for the specified MAC algorithm.
1065 */
1066 #define PSA_ALG_AT_LEAST_THIS_LENGTH_MAC(mac_alg, min_mac_length) \
1067 ( PSA_ALG_TRUNCATED_MAC(mac_alg, min_mac_length) | \
1068 PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG )
1069
1070 #define PSA_ALG_CIPHER_MAC_BASE ((psa_algorithm_t)0x03c00000)
1071 /** The CBC-MAC construction over a block cipher
1072 *
1073 * \warning CBC-MAC is insecure in many cases.
1074 * A more secure mode, such as #PSA_ALG_CMAC, is recommended.
1075 */
1076 #define PSA_ALG_CBC_MAC ((psa_algorithm_t)0x03c00100)
1077 /** The CMAC construction over a block cipher */
1078 #define PSA_ALG_CMAC ((psa_algorithm_t)0x03c00200)
1079
1080 /** Whether the specified algorithm is a MAC algorithm based on a block cipher.
1081 *
1082 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1083 *
1084 * \return 1 if \p alg is a MAC algorithm based on a block cipher, 0 otherwise.
1085 * This macro may return either 0 or 1 if \p alg is not a supported
1086 * algorithm identifier.
1087 */
1088 #define PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) \
1089 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \
1090 PSA_ALG_CIPHER_MAC_BASE)
1091
1092 #define PSA_ALG_CIPHER_STREAM_FLAG ((psa_algorithm_t)0x00800000)
1093 #define PSA_ALG_CIPHER_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)
1094
1095 /** Whether the specified algorithm is a stream cipher.
1096 *
1097 * A stream cipher is a symmetric cipher that encrypts or decrypts messages
1098 * by applying a bitwise-xor with a stream of bytes that is generated
1099 * from a key.
1100 *
1101 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1102 *
1103 * \return 1 if \p alg is a stream cipher algorithm, 0 otherwise.
1104 * This macro may return either 0 or 1 if \p alg is not a supported
1105 * algorithm identifier or if it is not a symmetric cipher algorithm.
1106 */
1107 #define PSA_ALG_IS_STREAM_CIPHER(alg) \
1108 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_CIPHER_STREAM_FLAG)) == \
1109 (PSA_ALG_CATEGORY_CIPHER | PSA_ALG_CIPHER_STREAM_FLAG))
1110
1111 /** The stream cipher mode of a stream cipher algorithm.
1112 *
1113 * The underlying stream cipher is determined by the key type.
1114 * - To use ChaCha20, use a key type of #PSA_KEY_TYPE_CHACHA20.
1115 */
1116 #define PSA_ALG_STREAM_CIPHER ((psa_algorithm_t)0x04800100)
1117
1118 /** The CTR stream cipher mode.
1119 *
1120 * CTR is a stream cipher which is built from a block cipher.
1121 * The underlying block cipher is determined by the key type.
1122 * For example, to use AES-128-CTR, use this algorithm with
1123 * a key of type #PSA_KEY_TYPE_AES and a length of 128 bits (16 bytes).
1124 */
1125 #define PSA_ALG_CTR ((psa_algorithm_t)0x04c01000)
1126
1127 /** The CFB stream cipher mode.
1128 *
1129 * The underlying block cipher is determined by the key type.
1130 */
1131 #define PSA_ALG_CFB ((psa_algorithm_t)0x04c01100)
1132
1133 /** The OFB stream cipher mode.
1134 *
1135 * The underlying block cipher is determined by the key type.
1136 */
1137 #define PSA_ALG_OFB ((psa_algorithm_t)0x04c01200)
1138
1139 /** The XTS cipher mode.
1140 *
1141 * XTS is a cipher mode which is built from a block cipher. It requires at
1142 * least one full block of input, but beyond this minimum the input
1143 * does not need to be a whole number of blocks.
1144 */
1145 #define PSA_ALG_XTS ((psa_algorithm_t)0x0440ff00)
1146
1147 /** The Electronic Code Book (ECB) mode of a block cipher, with no padding.
1148 *
1149 * \warning ECB mode does not protect the confidentiality of the encrypted data
1150 * except in extremely narrow circumstances. It is recommended that applications
1151 * only use ECB if they need to construct an operating mode that the
1152 * implementation does not provide. Implementations are encouraged to provide
1153 * the modes that applications need in preference to supporting direct access
1154 * to ECB.
1155 *
1156 * The underlying block cipher is determined by the key type.
1157 *
1158 * This symmetric cipher mode can only be used with messages whose lengths are a
1159 * multiple of the block size of the chosen block cipher.
1160 *
1161 * ECB mode does not accept an initialization vector (IV). When using a
1162 * multi-part cipher operation with this algorithm, psa_cipher_generate_iv()
1163 * and psa_cipher_set_iv() must not be called.
1164 */
1165 #define PSA_ALG_ECB_NO_PADDING ((psa_algorithm_t)0x04404400)
1166
1167 /** The CBC block cipher chaining mode, with no padding.
1168 *
1169 * The underlying block cipher is determined by the key type.
1170 *
1171 * This symmetric cipher mode can only be used with messages whose lengths
1172 * are whole number of blocks for the chosen block cipher.
1173 */
1174 #define PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04404000)
1175
1176 /** The CBC block cipher chaining mode with PKCS#7 padding.
1177 *
1178 * The underlying block cipher is determined by the key type.
1179 *
1180 * This is the padding method defined by PKCS#7 (RFC 2315) §10.3.
1181 */
1182 #define PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04404100)
1183
1184 #define PSA_ALG_AEAD_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)
1185
1186 /** Whether the specified algorithm is an AEAD mode on a block cipher.
1187 *
1188 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1189 *
1190 * \return 1 if \p alg is an AEAD algorithm which is an AEAD mode based on
1191 * a block cipher, 0 otherwise.
1192 * This macro may return either 0 or 1 if \p alg is not a supported
1193 * algorithm identifier.
1194 */
1195 #define PSA_ALG_IS_AEAD_ON_BLOCK_CIPHER(alg) \
1196 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_AEAD_FROM_BLOCK_FLAG)) == \
1197 (PSA_ALG_CATEGORY_AEAD | PSA_ALG_AEAD_FROM_BLOCK_FLAG))
1198
1199 /** The CCM authenticated encryption algorithm.
1200 *
1201 * The underlying block cipher is determined by the key type.
1202 */
1203 #define PSA_ALG_CCM ((psa_algorithm_t)0x05500100)
1204
1205 /** The CCM* cipher mode without authentication.
1206 *
1207 * This is CCM* as specified in IEEE 802.15.4 §7, with a tag length of 0.
1208 * For CCM* with a nonzero tag length, use the AEAD algorithm #PSA_ALG_CCM.
1209 *
1210 * The underlying block cipher is determined by the key type.
1211 *
1212 * Currently only 13-byte long IV's are supported.
1213 */
1214 #define PSA_ALG_CCM_STAR_NO_TAG ((psa_algorithm_t)0x04c01300)
1215
1216 /** The GCM authenticated encryption algorithm.
1217 *
1218 * The underlying block cipher is determined by the key type.
1219 */
1220 #define PSA_ALG_GCM ((psa_algorithm_t)0x05500200)
1221
1222 /** The Chacha20-Poly1305 AEAD algorithm.
1223 *
1224 * The ChaCha20_Poly1305 construction is defined in RFC 7539.
1225 *
1226 * Implementations must support 12-byte nonces, may support 8-byte nonces,
1227 * and should reject other sizes.
1228 *
1229 * Implementations must support 16-byte tags and should reject other sizes.
1230 */
1231 #define PSA_ALG_CHACHA20_POLY1305 ((psa_algorithm_t)0x05100500)
1232
1233 /* In the encoding of a AEAD algorithm, the bits corresponding to
1234 * PSA_ALG_AEAD_TAG_LENGTH_MASK encode the length of the AEAD tag.
1235 * The constants for default lengths follow this encoding.
1236 */
1237 #define PSA_ALG_AEAD_TAG_LENGTH_MASK ((psa_algorithm_t)0x003f0000)
1238 #define PSA_AEAD_TAG_LENGTH_OFFSET 16
1239
1240 /* In the encoding of an AEAD algorithm, the bit corresponding to
1241 * #PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG encodes the fact that the algorithm
1242 * is a wildcard algorithm. A key with such wildcard algorithm as permitted
1243 * algorithm policy can be used with any algorithm corresponding to the
1244 * same base class and having a tag length greater than or equal to the one
1245 * encoded in #PSA_ALG_AEAD_TAG_LENGTH_MASK. */
1246 #define PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG ((psa_algorithm_t)0x00008000)
1247
1248 /** Macro to build a shortened AEAD algorithm.
1249 *
1250 * A shortened AEAD algorithm is similar to the corresponding AEAD
1251 * algorithm, but has an authentication tag that consists of fewer bytes.
1252 * Depending on the algorithm, the tag length may affect the calculation
1253 * of the ciphertext.
1254 *
1255 * \param aead_alg An AEAD algorithm identifier (value of type
1256 * #psa_algorithm_t such that #PSA_ALG_IS_AEAD(\p aead_alg)
1257 * is true).
1258 * \param tag_length Desired length of the authentication tag in bytes.
1259 *
1260 * \return The corresponding AEAD algorithm with the specified
1261 * length.
1262 * \return Unspecified if \p aead_alg is not a supported
1263 * AEAD algorithm or if \p tag_length is not valid
1264 * for the specified AEAD algorithm.
1265 */
1266 #define PSA_ALG_AEAD_WITH_SHORTENED_TAG(aead_alg, tag_length) \
1267 (((aead_alg) & ~(PSA_ALG_AEAD_TAG_LENGTH_MASK | \
1268 PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG)) | \
1269 ((tag_length) << PSA_AEAD_TAG_LENGTH_OFFSET & \
1270 PSA_ALG_AEAD_TAG_LENGTH_MASK))
1271
1272 /** Retrieve the tag length of a specified AEAD algorithm
1273 *
1274 * \param aead_alg An AEAD algorithm identifier (value of type
1275 * #psa_algorithm_t such that #PSA_ALG_IS_AEAD(\p aead_alg)
1276 * is true).
1277 *
1278 * \return The tag length specified by the input algorithm.
1279 * \return Unspecified if \p aead_alg is not a supported
1280 * AEAD algorithm.
1281 */
1282 #define PSA_ALG_AEAD_GET_TAG_LENGTH(aead_alg) \
1283 (((aead_alg) & PSA_ALG_AEAD_TAG_LENGTH_MASK) >> \
1284 PSA_AEAD_TAG_LENGTH_OFFSET )
1285
1286 /** Calculate the corresponding AEAD algorithm with the default tag length.
1287 *
1288 * \param aead_alg An AEAD algorithm (\c PSA_ALG_XXX value such that
1289 * #PSA_ALG_IS_AEAD(\p aead_alg) is true).
1290 *
1291 * \return The corresponding AEAD algorithm with the default
1292 * tag length for that algorithm.
1293 */
1294 #define PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG(aead_alg) \
1295 ( \
1296 PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG_CASE(aead_alg, PSA_ALG_CCM) \
1297 PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG_CASE(aead_alg, PSA_ALG_GCM) \
1298 PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG_CASE(aead_alg, PSA_ALG_CHACHA20_POLY1305) \
1299 0)
1300 #define PSA_ALG_AEAD_WITH_DEFAULT_LENGTH_TAG_CASE(aead_alg, ref) \
1301 PSA_ALG_AEAD_WITH_SHORTENED_TAG(aead_alg, 0) == \
1302 PSA_ALG_AEAD_WITH_SHORTENED_TAG(ref, 0) ? \
1303 ref :
1304
1305 /** Macro to build an AEAD minimum-tag-length wildcard algorithm.
1306 *
1307 * A minimum-tag-length AEAD wildcard algorithm permits all AEAD algorithms
1308 * sharing the same base algorithm, and where the tag length of the specific
1309 * algorithm is equal to or larger then the minimum tag length specified by the
1310 * wildcard algorithm.
1311 *
1312 * \note When setting the minimum required tag length to less than the
1313 * smallest tag length allowed by the base algorithm, this effectively
1314 * becomes an 'any-tag-length-allowed' policy for that base algorithm.
1315 *
1316 * \param aead_alg An AEAD algorithm identifier (value of type
1317 * #psa_algorithm_t such that
1318 * #PSA_ALG_IS_AEAD(\p aead_alg) is true).
1319 * \param min_tag_length Desired minimum length of the authentication tag in
1320 * bytes. This must be at least 1 and at most the largest
1321 * allowed tag length of the algorithm.
1322 *
1323 * \return The corresponding AEAD wildcard algorithm with the
1324 * specified minimum length.
1325 * \return Unspecified if \p aead_alg is not a supported
1326 * AEAD algorithm or if \p min_tag_length is less than 1
1327 * or too large for the specified AEAD algorithm.
1328 */
1329 #define PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG(aead_alg, min_tag_length) \
1330 ( PSA_ALG_AEAD_WITH_SHORTENED_TAG(aead_alg, min_tag_length) | \
1331 PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG )
1332
1333 #define PSA_ALG_RSA_PKCS1V15_SIGN_BASE ((psa_algorithm_t)0x06000200)
1334 /** RSA PKCS#1 v1.5 signature with hashing.
1335 *
1336 * This is the signature scheme defined by RFC 8017
1337 * (PKCS#1: RSA Cryptography Specifications) under the name
1338 * RSASSA-PKCS1-v1_5.
1339 *
1340 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1341 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1342 * This includes #PSA_ALG_ANY_HASH
1343 * when specifying the algorithm in a usage policy.
1344 *
1345 * \return The corresponding RSA PKCS#1 v1.5 signature algorithm.
1346 * \return Unspecified if \p hash_alg is not a supported
1347 * hash algorithm.
1348 */
1349 #define PSA_ALG_RSA_PKCS1V15_SIGN(hash_alg) \
1350 (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1351 /** Raw PKCS#1 v1.5 signature.
1352 *
1353 * The input to this algorithm is the DigestInfo structure used by
1354 * RFC 8017 (PKCS#1: RSA Cryptography Specifications), §9.2
1355 * steps 3–6.
1356 */
1357 #define PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE
1358 #define PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) \
1359 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)
1360
1361 #define PSA_ALG_RSA_PSS_BASE ((psa_algorithm_t)0x06000300)
1362 #define PSA_ALG_RSA_PSS_ANY_SALT_BASE ((psa_algorithm_t)0x06001300)
1363 /** RSA PSS signature with hashing.
1364 *
1365 * This is the signature scheme defined by RFC 8017
1366 * (PKCS#1: RSA Cryptography Specifications) under the name
1367 * RSASSA-PSS, with the message generation function MGF1, and with
1368 * a salt length equal to the length of the hash. The specified
1369 * hash algorithm is used to hash the input message, to create the
1370 * salted hash, and for the mask generation.
1371 *
1372 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1373 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1374 * This includes #PSA_ALG_ANY_HASH
1375 * when specifying the algorithm in a usage policy.
1376 *
1377 * \return The corresponding RSA PSS signature algorithm.
1378 * \return Unspecified if \p hash_alg is not a supported
1379 * hash algorithm.
1380 */
1381 #define PSA_ALG_RSA_PSS(hash_alg) \
1382 (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1383
1384 /** RSA PSS signature with hashing with relaxed verification.
1385 *
1386 * This algorithm has the same behavior as #PSA_ALG_RSA_PSS when signing,
1387 * but allows an arbitrary salt length (including \c 0) when verifying a
1388 * signature.
1389 *
1390 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1391 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1392 * This includes #PSA_ALG_ANY_HASH
1393 * when specifying the algorithm in a usage policy.
1394 *
1395 * \return The corresponding RSA PSS signature algorithm.
1396 * \return Unspecified if \p hash_alg is not a supported
1397 * hash algorithm.
1398 */
1399 #define PSA_ALG_RSA_PSS_ANY_SALT(hash_alg) \
1400 (PSA_ALG_RSA_PSS_ANY_SALT_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1401
1402 /** Whether the specified algorithm is RSA PSS with standard salt.
1403 *
1404 * \param alg An algorithm value or an algorithm policy wildcard.
1405 *
1406 * \return 1 if \p alg is of the form
1407 * #PSA_ALG_RSA_PSS(\c hash_alg),
1408 * where \c hash_alg is a hash algorithm or
1409 * #PSA_ALG_ANY_HASH. 0 otherwise.
1410 * This macro may return either 0 or 1 if \p alg is not
1411 * a supported algorithm identifier or policy.
1412 */
1413 #define PSA_ALG_IS_RSA_PSS_STANDARD_SALT(alg) \
1414 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)
1415
1416 /** Whether the specified algorithm is RSA PSS with any salt.
1417 *
1418 * \param alg An algorithm value or an algorithm policy wildcard.
1419 *
1420 * \return 1 if \p alg is of the form
1421 * #PSA_ALG_RSA_PSS_ANY_SALT_BASE(\c hash_alg),
1422 * where \c hash_alg is a hash algorithm or
1423 * #PSA_ALG_ANY_HASH. 0 otherwise.
1424 * This macro may return either 0 or 1 if \p alg is not
1425 * a supported algorithm identifier or policy.
1426 */
1427 #define PSA_ALG_IS_RSA_PSS_ANY_SALT(alg) \
1428 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_ANY_SALT_BASE)
1429
1430 /** Whether the specified algorithm is RSA PSS.
1431 *
1432 * This includes any of the RSA PSS algorithm variants, regardless of the
1433 * constraints on salt length.
1434 *
1435 * \param alg An algorithm value or an algorithm policy wildcard.
1436 *
1437 * \return 1 if \p alg is of the form
1438 * #PSA_ALG_RSA_PSS(\c hash_alg) or
1439 * #PSA_ALG_RSA_PSS_ANY_SALT_BASE(\c hash_alg),
1440 * where \c hash_alg is a hash algorithm or
1441 * #PSA_ALG_ANY_HASH. 0 otherwise.
1442 * This macro may return either 0 or 1 if \p alg is not
1443 * a supported algorithm identifier or policy.
1444 */
1445 #define PSA_ALG_IS_RSA_PSS(alg) \
1446 (PSA_ALG_IS_RSA_PSS_STANDARD_SALT(alg) || \
1447 PSA_ALG_IS_RSA_PSS_ANY_SALT(alg))
1448
1449 #define PSA_ALG_ECDSA_BASE ((psa_algorithm_t)0x06000600)
1450 /** ECDSA signature with hashing.
1451 *
1452 * This is the ECDSA signature scheme defined by ANSI X9.62,
1453 * with a random per-message secret number (*k*).
1454 *
1455 * The representation of the signature as a byte string consists of
1456 * the concatentation of the signature values *r* and *s*. Each of
1457 * *r* and *s* is encoded as an *N*-octet string, where *N* is the length
1458 * of the base point of the curve in octets. Each value is represented
1459 * in big-endian order (most significant octet first).
1460 *
1461 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1462 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1463 * This includes #PSA_ALG_ANY_HASH
1464 * when specifying the algorithm in a usage policy.
1465 *
1466 * \return The corresponding ECDSA signature algorithm.
1467 * \return Unspecified if \p hash_alg is not a supported
1468 * hash algorithm.
1469 */
1470 #define PSA_ALG_ECDSA(hash_alg) \
1471 (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1472 /** ECDSA signature without hashing.
1473 *
1474 * This is the same signature scheme as #PSA_ALG_ECDSA(), but
1475 * without specifying a hash algorithm. This algorithm may only be
1476 * used to sign or verify a sequence of bytes that should be an
1477 * already-calculated hash. Note that the input is padded with
1478 * zeros on the left or truncated on the left as required to fit
1479 * the curve size.
1480 */
1481 #define PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE
1482 #define PSA_ALG_DETERMINISTIC_ECDSA_BASE ((psa_algorithm_t)0x06000700)
1483 /** Deterministic ECDSA signature with hashing.
1484 *
1485 * This is the deterministic ECDSA signature scheme defined by RFC 6979.
1486 *
1487 * The representation of a signature is the same as with #PSA_ALG_ECDSA().
1488 *
1489 * Note that when this algorithm is used for verification, signatures
1490 * made with randomized ECDSA (#PSA_ALG_ECDSA(\p hash_alg)) with the
1491 * same private key are accepted. In other words,
1492 * #PSA_ALG_DETERMINISTIC_ECDSA(\p hash_alg) differs from
1493 * #PSA_ALG_ECDSA(\p hash_alg) only for signature, not for verification.
1494 *
1495 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1496 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1497 * This includes #PSA_ALG_ANY_HASH
1498 * when specifying the algorithm in a usage policy.
1499 *
1500 * \return The corresponding deterministic ECDSA signature
1501 * algorithm.
1502 * \return Unspecified if \p hash_alg is not a supported
1503 * hash algorithm.
1504 */
1505 #define PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) \
1506 (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1507 #define PSA_ALG_ECDSA_DETERMINISTIC_FLAG ((psa_algorithm_t)0x00000100)
1508 #define PSA_ALG_IS_ECDSA(alg) \
1509 (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_ECDSA_DETERMINISTIC_FLAG) == \
1510 PSA_ALG_ECDSA_BASE)
1511 #define PSA_ALG_ECDSA_IS_DETERMINISTIC(alg) \
1512 (((alg) & PSA_ALG_ECDSA_DETERMINISTIC_FLAG) != 0)
1513 #define PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) \
1514 (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))
1515 #define PSA_ALG_IS_RANDOMIZED_ECDSA(alg) \
1516 (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))
1517
1518 /** Edwards-curve digital signature algorithm without prehashing (PureEdDSA),
1519 * using standard parameters.
1520 *
1521 * Contexts are not supported in the current version of this specification
1522 * because there is no suitable signature interface that can take the
1523 * context as a parameter. A future version of this specification may add
1524 * suitable functions and extend this algorithm to support contexts.
1525 *
1526 * PureEdDSA requires an elliptic curve key on a twisted Edwards curve.
1527 * In this specification, the following curves are supported:
1528 * - #PSA_ECC_FAMILY_TWISTED_EDWARDS, 255-bit: Ed25519 as specified
1529 * in RFC 8032.
1530 * The curve is Edwards25519.
1531 * The hash function used internally is SHA-512.
1532 * - #PSA_ECC_FAMILY_TWISTED_EDWARDS, 448-bit: Ed448 as specified
1533 * in RFC 8032.
1534 * The curve is Edwards448.
1535 * The hash function used internally is the first 114 bytes of the
1536 * SHAKE256 output.
1537 *
1538 * This algorithm can be used with psa_sign_message() and
1539 * psa_verify_message(). Since there is no prehashing, it cannot be used
1540 * with psa_sign_hash() or psa_verify_hash().
1541 *
1542 * The signature format is the concatenation of R and S as defined by
1543 * RFC 8032 §5.1.6 and §5.2.6 (a 64-byte string for Ed25519, a 114-byte
1544 * string for Ed448).
1545 */
1546 #define PSA_ALG_PURE_EDDSA ((psa_algorithm_t)0x06000800)
1547
1548 #define PSA_ALG_HASH_EDDSA_BASE ((psa_algorithm_t)0x06000900)
1549 #define PSA_ALG_IS_HASH_EDDSA(alg) \
1550 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HASH_EDDSA_BASE)
1551
1552 /** Edwards-curve digital signature algorithm with prehashing (HashEdDSA),
1553 * using SHA-512 and the Edwards25519 curve.
1554 *
1555 * See #PSA_ALG_PURE_EDDSA regarding context support and the signature format.
1556 *
1557 * This algorithm is Ed25519 as specified in RFC 8032.
1558 * The curve is Edwards25519.
1559 * The prehash is SHA-512.
1560 * The hash function used internally is SHA-512.
1561 *
1562 * This is a hash-and-sign algorithm: to calculate a signature,
1563 * you can either:
1564 * - call psa_sign_message() on the message;
1565 * - or calculate the SHA-512 hash of the message
1566 * with psa_hash_compute()
1567 * or with a multi-part hash operation started with psa_hash_setup(),
1568 * using the hash algorithm #PSA_ALG_SHA_512,
1569 * then sign the calculated hash with psa_sign_hash().
1570 * Verifying a signature is similar, using psa_verify_message() or
1571 * psa_verify_hash() instead of the signature function.
1572 */
1573 #define PSA_ALG_ED25519PH \
1574 (PSA_ALG_HASH_EDDSA_BASE | (PSA_ALG_SHA_512 & PSA_ALG_HASH_MASK))
1575
1576 /** Edwards-curve digital signature algorithm with prehashing (HashEdDSA),
1577 * using SHAKE256 and the Edwards448 curve.
1578 *
1579 * See #PSA_ALG_PURE_EDDSA regarding context support and the signature format.
1580 *
1581 * This algorithm is Ed448 as specified in RFC 8032.
1582 * The curve is Edwards448.
1583 * The prehash is the first 64 bytes of the SHAKE256 output.
1584 * The hash function used internally is the first 114 bytes of the
1585 * SHAKE256 output.
1586 *
1587 * This is a hash-and-sign algorithm: to calculate a signature,
1588 * you can either:
1589 * - call psa_sign_message() on the message;
1590 * - or calculate the first 64 bytes of the SHAKE256 output of the message
1591 * with psa_hash_compute()
1592 * or with a multi-part hash operation started with psa_hash_setup(),
1593 * using the hash algorithm #PSA_ALG_SHAKE256_512,
1594 * then sign the calculated hash with psa_sign_hash().
1595 * Verifying a signature is similar, using psa_verify_message() or
1596 * psa_verify_hash() instead of the signature function.
1597 */
1598 #define PSA_ALG_ED448PH \
1599 (PSA_ALG_HASH_EDDSA_BASE | (PSA_ALG_SHAKE256_512 & PSA_ALG_HASH_MASK))
1600
1601 /* Default definition, to be overridden if the library is extended with
1602 * more hash-and-sign algorithms that we want to keep out of this header
1603 * file. */
1604 #define PSA_ALG_IS_VENDOR_HASH_AND_SIGN(alg) 0
1605
1606 /** Whether the specified algorithm is a signature algorithm that can be used
1607 * with psa_sign_hash() and psa_verify_hash().
1608 *
1609 * This encompasses all strict hash-and-sign algorithms categorized by
1610 * PSA_ALG_IS_HASH_AND_SIGN(), as well as algorithms that follow the
1611 * paradigm more loosely:
1612 * - #PSA_ALG_RSA_PKCS1V15_SIGN_RAW (expects its input to be an encoded hash)
1613 * - #PSA_ALG_ECDSA_ANY (doesn't specify what kind of hash the input is)
1614 *
1615 * \param alg An algorithm identifier (value of type psa_algorithm_t).
1616 *
1617 * \return 1 if alg is a signature algorithm that can be used to sign a
1618 * hash. 0 if alg is a signature algorithm that can only be used
1619 * to sign a message. 0 if alg is not a signature algorithm.
1620 * This macro can return either 0 or 1 if alg is not a
1621 * supported algorithm identifier.
1622 */
1623 #define PSA_ALG_IS_SIGN_HASH(alg) \
1624 (PSA_ALG_IS_RSA_PSS(alg) || PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || \
1625 PSA_ALG_IS_ECDSA(alg) || PSA_ALG_IS_HASH_EDDSA(alg) || \
1626 PSA_ALG_IS_VENDOR_HASH_AND_SIGN(alg))
1627
1628 /** Whether the specified algorithm is a signature algorithm that can be used
1629 * with psa_sign_message() and psa_verify_message().
1630 *
1631 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1632 *
1633 * \return 1 if alg is a signature algorithm that can be used to sign a
1634 * message. 0 if \p alg is a signature algorithm that can only be used
1635 * to sign an already-calculated hash. 0 if \p alg is not a signature
1636 * algorithm. This macro can return either 0 or 1 if \p alg is not a
1637 * supported algorithm identifier.
1638 */
1639 #define PSA_ALG_IS_SIGN_MESSAGE(alg) \
1640 (PSA_ALG_IS_SIGN_HASH(alg) || (alg) == PSA_ALG_PURE_EDDSA )
1641
1642 /** Whether the specified algorithm is a hash-and-sign algorithm.
1643 *
1644 * Hash-and-sign algorithms are asymmetric (public-key) signature algorithms
1645 * structured in two parts: first the calculation of a hash in a way that
1646 * does not depend on the key, then the calculation of a signature from the
1647 * hash value and the key. Hash-and-sign algorithms encode the hash
1648 * used for the hashing step, and you can call #PSA_ALG_SIGN_GET_HASH
1649 * to extract this algorithm.
1650 *
1651 * Thus, for a hash-and-sign algorithm,
1652 * `psa_sign_message(key, alg, input, ...)` is equivalent to
1653 * ```
1654 * psa_hash_compute(PSA_ALG_SIGN_GET_HASH(alg), input, ..., hash, ...);
1655 * psa_sign_hash(key, alg, hash, ..., signature, ...);
1656 * ```
1657 * Most usefully, separating the hash from the signature allows the hash
1658 * to be calculated in multiple steps with psa_hash_setup(), psa_hash_update()
1659 * and psa_hash_finish(). Likewise psa_verify_message() is equivalent to
1660 * calculating the hash and then calling psa_verify_hash().
1661 *
1662 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1663 *
1664 * \return 1 if \p alg is a hash-and-sign algorithm, 0 otherwise.
1665 * This macro may return either 0 or 1 if \p alg is not a supported
1666 * algorithm identifier.
1667 */
1668 #define PSA_ALG_IS_HASH_AND_SIGN(alg) \
1669 (PSA_ALG_IS_SIGN_HASH(alg) && \
1670 ((alg) & PSA_ALG_HASH_MASK) != 0)
1671
1672 /** Get the hash used by a hash-and-sign signature algorithm.
1673 *
1674 * A hash-and-sign algorithm is a signature algorithm which is
1675 * composed of two phases: first a hashing phase which does not use
1676 * the key and produces a hash of the input message, then a signing
1677 * phase which only uses the hash and the key and not the message
1678 * itself.
1679 *
1680 * \param alg A signature algorithm (\c PSA_ALG_XXX value such that
1681 * #PSA_ALG_IS_SIGN(\p alg) is true).
1682 *
1683 * \return The underlying hash algorithm if \p alg is a hash-and-sign
1684 * algorithm.
1685 * \return 0 if \p alg is a signature algorithm that does not
1686 * follow the hash-and-sign structure.
1687 * \return Unspecified if \p alg is not a signature algorithm or
1688 * if it is not supported by the implementation.
1689 */
1690 #define PSA_ALG_SIGN_GET_HASH(alg) \
1691 (PSA_ALG_IS_HASH_AND_SIGN(alg) ? \
1692 ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \
1693 0)
1694
1695 /** RSA PKCS#1 v1.5 encryption.
1696 */
1697 #define PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x07000200)
1698
1699 #define PSA_ALG_RSA_OAEP_BASE ((psa_algorithm_t)0x07000300)
1700 /** RSA OAEP encryption.
1701 *
1702 * This is the encryption scheme defined by RFC 8017
1703 * (PKCS#1: RSA Cryptography Specifications) under the name
1704 * RSAES-OAEP, with the message generation function MGF1.
1705 *
1706 * \param hash_alg The hash algorithm (\c PSA_ALG_XXX value such that
1707 * #PSA_ALG_IS_HASH(\p hash_alg) is true) to use
1708 * for MGF1.
1709 *
1710 * \return The corresponding RSA OAEP encryption algorithm.
1711 * \return Unspecified if \p hash_alg is not a supported
1712 * hash algorithm.
1713 */
1714 #define PSA_ALG_RSA_OAEP(hash_alg) \
1715 (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1716 #define PSA_ALG_IS_RSA_OAEP(alg) \
1717 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)
1718 #define PSA_ALG_RSA_OAEP_GET_HASH(alg) \
1719 (PSA_ALG_IS_RSA_OAEP(alg) ? \
1720 ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \
1721 0)
1722
1723 #define PSA_ALG_HKDF_BASE ((psa_algorithm_t)0x08000100)
1724 /** Macro to build an HKDF algorithm.
1725 *
1726 * For example, `PSA_ALG_HKDF(PSA_ALG_SHA256)` is HKDF using HMAC-SHA-256.
1727 *
1728 * This key derivation algorithm uses the following inputs:
1729 * - #PSA_KEY_DERIVATION_INPUT_SALT is the salt used in the "extract" step.
1730 * It is optional; if omitted, the derivation uses an empty salt.
1731 * - #PSA_KEY_DERIVATION_INPUT_SECRET is the secret key used in the "extract" step.
1732 * - #PSA_KEY_DERIVATION_INPUT_INFO is the info string used in the "expand" step.
1733 * You must pass #PSA_KEY_DERIVATION_INPUT_SALT before #PSA_KEY_DERIVATION_INPUT_SECRET.
1734 * You may pass #PSA_KEY_DERIVATION_INPUT_INFO at any time after steup and before
1735 * starting to generate output.
1736 *
1737 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1738 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1739 *
1740 * \return The corresponding HKDF algorithm.
1741 * \return Unspecified if \p hash_alg is not a supported
1742 * hash algorithm.
1743 */
1744 #define PSA_ALG_HKDF(hash_alg) \
1745 (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1746 /** Whether the specified algorithm is an HKDF algorithm.
1747 *
1748 * HKDF is a family of key derivation algorithms that are based on a hash
1749 * function and the HMAC construction.
1750 *
1751 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1752 *
1753 * \return 1 if \c alg is an HKDF algorithm, 0 otherwise.
1754 * This macro may return either 0 or 1 if \c alg is not a supported
1755 * key derivation algorithm identifier.
1756 */
1757 #define PSA_ALG_IS_HKDF(alg) \
1758 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)
1759 #define PSA_ALG_HKDF_GET_HASH(hkdf_alg) \
1760 (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))
1761
1762 #define PSA_ALG_TLS12_PRF_BASE ((psa_algorithm_t)0x08000200)
1763 /** Macro to build a TLS-1.2 PRF algorithm.
1764 *
1765 * TLS 1.2 uses a custom pseudorandom function (PRF) for key schedule,
1766 * specified in Section 5 of RFC 5246. It is based on HMAC and can be
1767 * used with either SHA-256 or SHA-384.
1768 *
1769 * This key derivation algorithm uses the following inputs, which must be
1770 * passed in the order given here:
1771 * - #PSA_KEY_DERIVATION_INPUT_SEED is the seed.
1772 * - #PSA_KEY_DERIVATION_INPUT_SECRET is the secret key.
1773 * - #PSA_KEY_DERIVATION_INPUT_LABEL is the label.
1774 *
1775 * For the application to TLS-1.2 key expansion, the seed is the
1776 * concatenation of ServerHello.Random + ClientHello.Random,
1777 * and the label is "key expansion".
1778 *
1779 * For example, `PSA_ALG_TLS12_PRF(PSA_ALG_SHA256)` represents the
1780 * TLS 1.2 PRF using HMAC-SHA-256.
1781 *
1782 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1783 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1784 *
1785 * \return The corresponding TLS-1.2 PRF algorithm.
1786 * \return Unspecified if \p hash_alg is not a supported
1787 * hash algorithm.
1788 */
1789 #define PSA_ALG_TLS12_PRF(hash_alg) \
1790 (PSA_ALG_TLS12_PRF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1791
1792 /** Whether the specified algorithm is a TLS-1.2 PRF algorithm.
1793 *
1794 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1795 *
1796 * \return 1 if \c alg is a TLS-1.2 PRF algorithm, 0 otherwise.
1797 * This macro may return either 0 or 1 if \c alg is not a supported
1798 * key derivation algorithm identifier.
1799 */
1800 #define PSA_ALG_IS_TLS12_PRF(alg) \
1801 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PRF_BASE)
1802 #define PSA_ALG_TLS12_PRF_GET_HASH(hkdf_alg) \
1803 (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))
1804
1805 #define PSA_ALG_TLS12_PSK_TO_MS_BASE ((psa_algorithm_t)0x08000300)
1806 /** Macro to build a TLS-1.2 PSK-to-MasterSecret algorithm.
1807 *
1808 * In a pure-PSK handshake in TLS 1.2, the master secret is derived
1809 * from the PreSharedKey (PSK) through the application of padding
1810 * (RFC 4279, Section 2) and the TLS-1.2 PRF (RFC 5246, Section 5).
1811 * The latter is based on HMAC and can be used with either SHA-256
1812 * or SHA-384.
1813 *
1814 * This key derivation algorithm uses the following inputs, which must be
1815 * passed in the order given here:
1816 * - #PSA_KEY_DERIVATION_INPUT_SEED is the seed.
1817 * - #PSA_KEY_DERIVATION_INPUT_SECRET is the secret key.
1818 * - #PSA_KEY_DERIVATION_INPUT_LABEL is the label.
1819 *
1820 * For the application to TLS-1.2, the seed (which is
1821 * forwarded to the TLS-1.2 PRF) is the concatenation of the
1822 * ClientHello.Random + ServerHello.Random,
1823 * and the label is "master secret" or "extended master secret".
1824 *
1825 * For example, `PSA_ALG_TLS12_PSK_TO_MS(PSA_ALG_SHA256)` represents the
1826 * TLS-1.2 PSK to MasterSecret derivation PRF using HMAC-SHA-256.
1827 *
1828 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1829 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1830 *
1831 * \return The corresponding TLS-1.2 PSK to MS algorithm.
1832 * \return Unspecified if \p hash_alg is not a supported
1833 * hash algorithm.
1834 */
1835 #define PSA_ALG_TLS12_PSK_TO_MS(hash_alg) \
1836 (PSA_ALG_TLS12_PSK_TO_MS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1837
1838 /** Whether the specified algorithm is a TLS-1.2 PSK to MS algorithm.
1839 *
1840 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1841 *
1842 * \return 1 if \c alg is a TLS-1.2 PSK to MS algorithm, 0 otherwise.
1843 * This macro may return either 0 or 1 if \c alg is not a supported
1844 * key derivation algorithm identifier.
1845 */
1846 #define PSA_ALG_IS_TLS12_PSK_TO_MS(alg) \
1847 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_TLS12_PSK_TO_MS_BASE)
1848 #define PSA_ALG_TLS12_PSK_TO_MS_GET_HASH(hkdf_alg) \
1849 (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))
1850
1851 /* This flag indicates whether the key derivation algorithm is suitable for
1852 * use on low-entropy secrets such as password - these algorithms are also
1853 * known as key stretching or password hashing schemes. These are also the
1854 * algorithms that accepts inputs of type #PSA_KEY_DERIVATION_INPUT_PASSWORD.
1855 *
1856 * Those algorithms cannot be combined with a key agreement algorithm.
1857 */
1858 #define PSA_ALG_KEY_DERIVATION_STRETCHING_FLAG ((psa_algorithm_t)0x00800000)
1859
1860 #define PSA_ALG_PBKDF2_HMAC_BASE ((psa_algorithm_t)0x08800100)
1861 /** Macro to build a PBKDF2-HMAC password hashing / key stretching algorithm.
1862 *
1863 * PBKDF2 is defined by PKCS#5, republished as RFC 8018 (section 5.2).
1864 * This macro specifies the PBKDF2 algorithm constructed using a PRF based on
1865 * HMAC with the specified hash.
1866 * For example, `PSA_ALG_PBKDF2_HMAC(PSA_ALG_SHA256)` specifies PBKDF2
1867 * using the PRF HMAC-SHA-256.
1868 *
1869 * This key derivation algorithm uses the following inputs, which must be
1870 * provided in the following order:
1871 * - #PSA_KEY_DERIVATION_INPUT_COST is the iteration count.
1872 * This input step must be used exactly once.
1873 * - #PSA_KEY_DERIVATION_INPUT_SALT is the salt.
1874 * This input step must be used one or more times; if used several times, the
1875 * inputs will be concatenated. This can be used to build the final salt
1876 * from multiple sources, both public and secret (also known as pepper).
1877 * - #PSA_KEY_DERIVATION_INPUT_PASSWORD is the password to be hashed.
1878 * This input step must be used exactly once.
1879 *
1880 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1881 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1882 *
1883 * \return The corresponding PBKDF2-HMAC-XXX algorithm.
1884 * \return Unspecified if \p hash_alg is not a supported
1885 * hash algorithm.
1886 */
1887 #define PSA_ALG_PBKDF2_HMAC(hash_alg) \
1888 (PSA_ALG_PBKDF2_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1889
1890 /** Whether the specified algorithm is a PBKDF2-HMAC algorithm.
1891 *
1892 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1893 *
1894 * \return 1 if \c alg is a PBKDF2-HMAC algorithm, 0 otherwise.
1895 * This macro may return either 0 or 1 if \c alg is not a supported
1896 * key derivation algorithm identifier.
1897 */
1898 #define PSA_ALG_IS_PBKDF2_HMAC(alg) \
1899 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_PBKDF2_HMAC_BASE)
1900
1901 /** The PBKDF2-AES-CMAC-PRF-128 password hashing / key stretching algorithm.
1902 *
1903 * PBKDF2 is defined by PKCS#5, republished as RFC 8018 (section 5.2).
1904 * This macro specifies the PBKDF2 algorithm constructed using the
1905 * AES-CMAC-PRF-128 PRF specified by RFC 4615.
1906 *
1907 * This key derivation algorithm uses the same inputs as
1908 * #PSA_ALG_PBKDF2_HMAC() with the same constraints.
1909 */
1910 #define PSA_ALG_PBKDF2_AES_CMAC_PRF_128 ((psa_algorithm_t)0x08800200)
1911
1912 #define PSA_ALG_KEY_DERIVATION_MASK ((psa_algorithm_t)0xfe00ffff)
1913 #define PSA_ALG_KEY_AGREEMENT_MASK ((psa_algorithm_t)0xffff0000)
1914
1915 /** Macro to build a combined algorithm that chains a key agreement with
1916 * a key derivation.
1917 *
1918 * \param ka_alg A key agreement algorithm (\c PSA_ALG_XXX value such
1919 * that #PSA_ALG_IS_KEY_AGREEMENT(\p ka_alg) is true).
1920 * \param kdf_alg A key derivation algorithm (\c PSA_ALG_XXX value such
1921 * that #PSA_ALG_IS_KEY_DERIVATION(\p kdf_alg) is true).
1922 *
1923 * \return The corresponding key agreement and derivation
1924 * algorithm.
1925 * \return Unspecified if \p ka_alg is not a supported
1926 * key agreement algorithm or \p kdf_alg is not a
1927 * supported key derivation algorithm.
1928 */
1929 #define PSA_ALG_KEY_AGREEMENT(ka_alg, kdf_alg) \
1930 ((ka_alg) | (kdf_alg))
1931
1932 #define PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) \
1933 (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)
1934
1935 #define PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) \
1936 (((alg) & PSA_ALG_KEY_AGREEMENT_MASK) | PSA_ALG_CATEGORY_KEY_AGREEMENT)
1937
1938 /** Whether the specified algorithm is a raw key agreement algorithm.
1939 *
1940 * A raw key agreement algorithm is one that does not specify
1941 * a key derivation function.
1942 * Usually, raw key agreement algorithms are constructed directly with
1943 * a \c PSA_ALG_xxx macro while non-raw key agreement algorithms are
1944 * constructed with #PSA_ALG_KEY_AGREEMENT().
1945 *
1946 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1947 *
1948 * \return 1 if \p alg is a raw key agreement algorithm, 0 otherwise.
1949 * This macro may return either 0 or 1 if \p alg is not a supported
1950 * algorithm identifier.
1951 */
1952 #define PSA_ALG_IS_RAW_KEY_AGREEMENT(alg) \
1953 (PSA_ALG_IS_KEY_AGREEMENT(alg) && \
1954 PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) == PSA_ALG_CATEGORY_KEY_DERIVATION)
1955
1956 #define PSA_ALG_IS_KEY_DERIVATION_OR_AGREEMENT(alg) \
1957 ((PSA_ALG_IS_KEY_DERIVATION(alg) || PSA_ALG_IS_KEY_AGREEMENT(alg)))
1958
1959 /** The finite-field Diffie-Hellman (DH) key agreement algorithm.
1960 *
1961 * The shared secret produced by key agreement is
1962 * `g^{ab}` in big-endian format.
1963 * It is `ceiling(m / 8)` bytes long where `m` is the size of the prime `p`
1964 * in bits.
1965 */
1966 #define PSA_ALG_FFDH ((psa_algorithm_t)0x09010000)
1967
1968 /** Whether the specified algorithm is a finite field Diffie-Hellman algorithm.
1969 *
1970 * This includes the raw finite field Diffie-Hellman algorithm as well as
1971 * finite-field Diffie-Hellman followed by any supporter key derivation
1972 * algorithm.
1973 *
1974 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1975 *
1976 * \return 1 if \c alg is a finite field Diffie-Hellman algorithm, 0 otherwise.
1977 * This macro may return either 0 or 1 if \c alg is not a supported
1978 * key agreement algorithm identifier.
1979 */
1980 #define PSA_ALG_IS_FFDH(alg) \
1981 (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH)
1982
1983 /** The elliptic curve Diffie-Hellman (ECDH) key agreement algorithm.
1984 *
1985 * The shared secret produced by key agreement is the x-coordinate of
1986 * the shared secret point. It is always `ceiling(m / 8)` bytes long where
1987 * `m` is the bit size associated with the curve, i.e. the bit size of the
1988 * order of the curve's coordinate field. When `m` is not a multiple of 8,
1989 * the byte containing the most significant bit of the shared secret
1990 * is padded with zero bits. The byte order is either little-endian
1991 * or big-endian depending on the curve type.
1992 *
1993 * - For Montgomery curves (curve types `PSA_ECC_FAMILY_CURVEXXX`),
1994 * the shared secret is the x-coordinate of `d_A Q_B = d_B Q_A`
1995 * in little-endian byte order.
1996 * The bit size is 448 for Curve448 and 255 for Curve25519.
1997 * - For Weierstrass curves over prime fields (curve types
1998 * `PSA_ECC_FAMILY_SECPXXX` and `PSA_ECC_FAMILY_BRAINPOOL_PXXX`),
1999 * the shared secret is the x-coordinate of `d_A Q_B = d_B Q_A`
2000 * in big-endian byte order.
2001 * The bit size is `m = ceiling(log_2(p))` for the field `F_p`.
2002 * - For Weierstrass curves over binary fields (curve types
2003 * `PSA_ECC_FAMILY_SECTXXX`),
2004 * the shared secret is the x-coordinate of `d_A Q_B = d_B Q_A`
2005 * in big-endian byte order.
2006 * The bit size is `m` for the field `F_{2^m}`.
2007 */
2008 #define PSA_ALG_ECDH ((psa_algorithm_t)0x09020000)
2009
2010 /** Whether the specified algorithm is an elliptic curve Diffie-Hellman
2011 * algorithm.
2012 *
2013 * This includes the raw elliptic curve Diffie-Hellman algorithm as well as
2014 * elliptic curve Diffie-Hellman followed by any supporter key derivation
2015 * algorithm.
2016 *
2017 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
2018 *
2019 * \return 1 if \c alg is an elliptic curve Diffie-Hellman algorithm,
2020 * 0 otherwise.
2021 * This macro may return either 0 or 1 if \c alg is not a supported
2022 * key agreement algorithm identifier.
2023 */
2024 #define PSA_ALG_IS_ECDH(alg) \
2025 (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH)
2026
2027 /** Whether the specified algorithm encoding is a wildcard.
2028 *
2029 * Wildcard values may only be used to set the usage algorithm field in
2030 * a policy, not to perform an operation.
2031 *
2032 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
2033 *
2034 * \return 1 if \c alg is a wildcard algorithm encoding.
2035 * \return 0 if \c alg is a non-wildcard algorithm encoding (suitable for
2036 * an operation).
2037 * \return This macro may return either 0 or 1 if \c alg is not a supported
2038 * algorithm identifier.
2039 */
2040 #define PSA_ALG_IS_WILDCARD(alg) \
2041 (PSA_ALG_IS_HASH_AND_SIGN(alg) ? \
2042 PSA_ALG_SIGN_GET_HASH(alg) == PSA_ALG_ANY_HASH : \
2043 PSA_ALG_IS_MAC(alg) ? \
2044 (alg & PSA_ALG_MAC_AT_LEAST_THIS_LENGTH_FLAG) != 0 : \
2045 PSA_ALG_IS_AEAD(alg) ? \
2046 (alg & PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG) != 0 : \
2047 (alg) == PSA_ALG_ANY_HASH)
2048
2049 /** Get the hash used by a composite algorithm.
2050 *
2051 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
2052 *
2053 * \return The underlying hash algorithm if alg is a composite algorithm that
2054 * uses a hash algorithm.
2055 *
2056 * \return \c 0 if alg is not a composite algorithm that uses a hash.
2057 */
2058 #define PSA_ALG_GET_HASH(alg) \
2059 (((alg) & 0x000000ff) == 0 ? ((psa_algorithm_t)0) : 0x02000000 | ((alg) & 0x000000ff))
2060
2061 /**@}*/
2062
2063 /** \defgroup key_lifetimes Key lifetimes
2064 * @{
2065 */
2066
2067 /** The default lifetime for volatile keys.
2068 *
2069 * A volatile key only exists as long as the identifier to it is not destroyed.
2070 * The key material is guaranteed to be erased on a power reset.
2071 *
2072 * A key with this lifetime is typically stored in the RAM area of the
2073 * PSA Crypto subsystem. However this is an implementation choice.
2074 * If an implementation stores data about the key in a non-volatile memory,
2075 * it must release all the resources associated with the key and erase the
2076 * key material if the calling application terminates.
2077 */
2078 #define PSA_KEY_LIFETIME_VOLATILE ((psa_key_lifetime_t)0x00000000)
2079
2080 /** The default lifetime for persistent keys.
2081 *
2082 * A persistent key remains in storage until it is explicitly destroyed or
2083 * until the corresponding storage area is wiped. This specification does
2084 * not define any mechanism to wipe a storage area, but integrations may
2085 * provide their own mechanism (for example to perform a factory reset,
2086 * to prepare for device refurbishment, or to uninstall an application).
2087 *
2088 * This lifetime value is the default storage area for the calling
2089 * application. Integrations of Mbed TLS may support other persistent lifetimes.
2090 * See ::psa_key_lifetime_t for more information.
2091 */
2092 #define PSA_KEY_LIFETIME_PERSISTENT ((psa_key_lifetime_t)0x00000001)
2093
2094 /** The persistence level of volatile keys.
2095 *
2096 * See ::psa_key_persistence_t for more information.
2097 */
2098 #define PSA_KEY_PERSISTENCE_VOLATILE ((psa_key_persistence_t)0x00)
2099
2100 /** The default persistence level for persistent keys.
2101 *
2102 * See ::psa_key_persistence_t for more information.
2103 */
2104 #define PSA_KEY_PERSISTENCE_DEFAULT ((psa_key_persistence_t)0x01)
2105
2106 /** A persistence level indicating that a key is never destroyed.
2107 *
2108 * See ::psa_key_persistence_t for more information.
2109 */
2110 #define PSA_KEY_PERSISTENCE_READ_ONLY ((psa_key_persistence_t)0xff)
2111
2112 #define PSA_KEY_LIFETIME_GET_PERSISTENCE(lifetime) \
2113 ((psa_key_persistence_t)((lifetime) & 0x000000ff))
2114
2115 #define PSA_KEY_LIFETIME_GET_LOCATION(lifetime) \
2116 ((psa_key_location_t)((lifetime) >> 8))
2117
2118 /** Whether a key lifetime indicates that the key is volatile.
2119 *
2120 * A volatile key is automatically destroyed by the implementation when
2121 * the application instance terminates. In particular, a volatile key
2122 * is automatically destroyed on a power reset of the device.
2123 *
2124 * A key that is not volatile is persistent. Persistent keys are
2125 * preserved until the application explicitly destroys them or until an
2126 * implementation-specific device management event occurs (for example,
2127 * a factory reset).
2128 *
2129 * \param lifetime The lifetime value to query (value of type
2130 * ::psa_key_lifetime_t).
2131 *
2132 * \return \c 1 if the key is volatile, otherwise \c 0.
2133 */
2134 #define PSA_KEY_LIFETIME_IS_VOLATILE(lifetime) \
2135 (PSA_KEY_LIFETIME_GET_PERSISTENCE(lifetime) == \
2136 PSA_KEY_PERSISTENCE_VOLATILE)
2137
2138 /** Whether a key lifetime indicates that the key is read-only.
2139 *
2140 * Read-only keys cannot be created or destroyed through the PSA Crypto API.
2141 * They must be created through platform-specific means that bypass the API.
2142 *
2143 * Some platforms may offer ways to destroy read-only keys. For example,
2144 * consider a platform with multiple levels of privilege, where a
2145 * low-privilege application can use a key but is not allowed to destroy
2146 * it, and the platform exposes the key to the application with a read-only
2147 * lifetime. High-privilege code can destroy the key even though the
2148 * application sees the key as read-only.
2149 *
2150 * \param lifetime The lifetime value to query (value of type
2151 * ::psa_key_lifetime_t).
2152 *
2153 * \return \c 1 if the key is read-only, otherwise \c 0.
2154 */
2155 #define PSA_KEY_LIFETIME_IS_READ_ONLY(lifetime) \
2156 (PSA_KEY_LIFETIME_GET_PERSISTENCE(lifetime) == \
2157 PSA_KEY_PERSISTENCE_READ_ONLY)
2158
2159 /** Construct a lifetime from a persistence level and a location.
2160 *
2161 * \param persistence The persistence level
2162 * (value of type ::psa_key_persistence_t).
2163 * \param location The location indicator
2164 * (value of type ::psa_key_location_t).
2165 *
2166 * \return The constructed lifetime value.
2167 */
2168 #define PSA_KEY_LIFETIME_FROM_PERSISTENCE_AND_LOCATION(persistence, location) \
2169 ((location) << 8 | (persistence))
2170
2171 /** The local storage area for persistent keys.
2172 *
2173 * This storage area is available on all systems that can store persistent
2174 * keys without delegating the storage to a third-party cryptoprocessor.
2175 *
2176 * See ::psa_key_location_t for more information.
2177 */
2178 #define PSA_KEY_LOCATION_LOCAL_STORAGE ((psa_key_location_t)0x000000)
2179
2180 #define PSA_KEY_LOCATION_VENDOR_FLAG ((psa_key_location_t)0x800000)
2181
2182 /** The null key identifier.
2183 */
2184 #define PSA_KEY_ID_NULL ((psa_key_id_t)0)
2185 /** The minimum value for a key identifier chosen by the application.
2186 */
2187 #define PSA_KEY_ID_USER_MIN ((psa_key_id_t)0x00000001)
2188 /** The maximum value for a key identifier chosen by the application.
2189 */
2190 #define PSA_KEY_ID_USER_MAX ((psa_key_id_t)0x3fffffff)
2191 /** The minimum value for a key identifier chosen by the implementation.
2192 */
2193 #define PSA_KEY_ID_VENDOR_MIN ((psa_key_id_t)0x40000000)
2194 /** The maximum value for a key identifier chosen by the implementation.
2195 */
2196 #define PSA_KEY_ID_VENDOR_MAX ((psa_key_id_t)0x7fffffff)
2197
2198
2199 #if !defined(MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER)
2200
2201 #define MBEDTLS_SVC_KEY_ID_INIT ( (psa_key_id_t)0 )
2202 #define MBEDTLS_SVC_KEY_ID_GET_KEY_ID( id ) ( id )
2203 #define MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( id ) ( 0 )
2204
2205 /** Utility to initialize a key identifier at runtime.
2206 *
2207 * \param unused Unused parameter.
2208 * \param key_id Identifier of the key.
2209 */
mbedtls_svc_key_id_make(unsigned int unused,psa_key_id_t key_id)2210 static inline mbedtls_svc_key_id_t mbedtls_svc_key_id_make(
2211 unsigned int unused, psa_key_id_t key_id )
2212 {
2213 (void)unused;
2214
2215 return( key_id );
2216 }
2217
2218 /** Compare two key identifiers.
2219 *
2220 * \param id1 First key identifier.
2221 * \param id2 Second key identifier.
2222 *
2223 * \return Non-zero if the two key identifier are equal, zero otherwise.
2224 */
mbedtls_svc_key_id_equal(mbedtls_svc_key_id_t id1,mbedtls_svc_key_id_t id2)2225 static inline int mbedtls_svc_key_id_equal( mbedtls_svc_key_id_t id1,
2226 mbedtls_svc_key_id_t id2 )
2227 {
2228 return( id1 == id2 );
2229 }
2230
2231 /** Check whether a key identifier is null.
2232 *
2233 * \param key Key identifier.
2234 *
2235 * \return Non-zero if the key identifier is null, zero otherwise.
2236 */
mbedtls_svc_key_id_is_null(mbedtls_svc_key_id_t key)2237 static inline int mbedtls_svc_key_id_is_null( mbedtls_svc_key_id_t key )
2238 {
2239 return( key == 0 );
2240 }
2241
2242 #else /* MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */
2243
2244 #define MBEDTLS_SVC_KEY_ID_INIT ( (mbedtls_svc_key_id_t){ 0, 0 } )
2245 #define MBEDTLS_SVC_KEY_ID_GET_KEY_ID( id ) ( ( id ).key_id )
2246 #define MBEDTLS_SVC_KEY_ID_GET_OWNER_ID( id ) ( ( id ).owner )
2247
2248 /** Utility to initialize a key identifier at runtime.
2249 *
2250 * \param owner_id Identifier of the key owner.
2251 * \param key_id Identifier of the key.
2252 */
mbedtls_svc_key_id_make(mbedtls_key_owner_id_t owner_id,psa_key_id_t key_id)2253 static inline mbedtls_svc_key_id_t mbedtls_svc_key_id_make(
2254 mbedtls_key_owner_id_t owner_id, psa_key_id_t key_id )
2255 {
2256 return( (mbedtls_svc_key_id_t){ .MBEDTLS_PRIVATE(key_id) = key_id,
2257 .MBEDTLS_PRIVATE(owner) = owner_id } );
2258 }
2259
2260 /** Compare two key identifiers.
2261 *
2262 * \param id1 First key identifier.
2263 * \param id2 Second key identifier.
2264 *
2265 * \return Non-zero if the two key identifier are equal, zero otherwise.
2266 */
mbedtls_svc_key_id_equal(mbedtls_svc_key_id_t id1,mbedtls_svc_key_id_t id2)2267 static inline int mbedtls_svc_key_id_equal( mbedtls_svc_key_id_t id1,
2268 mbedtls_svc_key_id_t id2 )
2269 {
2270 return( ( id1.MBEDTLS_PRIVATE(key_id) == id2.MBEDTLS_PRIVATE(key_id) ) &&
2271 mbedtls_key_owner_id_equal( id1.MBEDTLS_PRIVATE(owner), id2.MBEDTLS_PRIVATE(owner) ) );
2272 }
2273
2274 /** Check whether a key identifier is null.
2275 *
2276 * \param key Key identifier.
2277 *
2278 * \return Non-zero if the key identifier is null, zero otherwise.
2279 */
mbedtls_svc_key_id_is_null(mbedtls_svc_key_id_t key)2280 static inline int mbedtls_svc_key_id_is_null( mbedtls_svc_key_id_t key )
2281 {
2282 return( key.MBEDTLS_PRIVATE(key_id) == 0 );
2283 }
2284
2285 #endif /* !MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER */
2286
2287 /**@}*/
2288
2289 /** \defgroup policy Key policies
2290 * @{
2291 */
2292
2293 /** Whether the key may be exported.
2294 *
2295 * A public key or the public part of a key pair may always be exported
2296 * regardless of the value of this permission flag.
2297 *
2298 * If a key does not have export permission, implementations shall not
2299 * allow the key to be exported in plain form from the cryptoprocessor,
2300 * whether through psa_export_key() or through a proprietary interface.
2301 * The key may however be exportable in a wrapped form, i.e. in a form
2302 * where it is encrypted by another key.
2303 */
2304 #define PSA_KEY_USAGE_EXPORT ((psa_key_usage_t)0x00000001)
2305
2306 /** Whether the key may be copied.
2307 *
2308 * This flag allows the use of psa_copy_key() to make a copy of the key
2309 * with the same policy or a more restrictive policy.
2310 *
2311 * For lifetimes for which the key is located in a secure element which
2312 * enforce the non-exportability of keys, copying a key outside the secure
2313 * element also requires the usage flag #PSA_KEY_USAGE_EXPORT.
2314 * Copying the key inside the secure element is permitted with just
2315 * #PSA_KEY_USAGE_COPY if the secure element supports it.
2316 * For keys with the lifetime #PSA_KEY_LIFETIME_VOLATILE or
2317 * #PSA_KEY_LIFETIME_PERSISTENT, the usage flag #PSA_KEY_USAGE_COPY
2318 * is sufficient to permit the copy.
2319 */
2320 #define PSA_KEY_USAGE_COPY ((psa_key_usage_t)0x00000002)
2321
2322 /** Whether the key may be used to encrypt a message.
2323 *
2324 * This flag allows the key to be used for a symmetric encryption operation,
2325 * for an AEAD encryption-and-authentication operation,
2326 * or for an asymmetric encryption operation,
2327 * if otherwise permitted by the key's type and policy.
2328 *
2329 * For a key pair, this concerns the public key.
2330 */
2331 #define PSA_KEY_USAGE_ENCRYPT ((psa_key_usage_t)0x00000100)
2332
2333 /** Whether the key may be used to decrypt a message.
2334 *
2335 * This flag allows the key to be used for a symmetric decryption operation,
2336 * for an AEAD decryption-and-verification operation,
2337 * or for an asymmetric decryption operation,
2338 * if otherwise permitted by the key's type and policy.
2339 *
2340 * For a key pair, this concerns the private key.
2341 */
2342 #define PSA_KEY_USAGE_DECRYPT ((psa_key_usage_t)0x00000200)
2343
2344 /** Whether the key may be used to sign a message.
2345 *
2346 * This flag allows the key to be used for a MAC calculation operation or for
2347 * an asymmetric message signature operation, if otherwise permitted by the
2348 * key’s type and policy.
2349 *
2350 * For a key pair, this concerns the private key.
2351 */
2352 #define PSA_KEY_USAGE_SIGN_MESSAGE ((psa_key_usage_t)0x00000400)
2353
2354 /** Whether the key may be used to verify a message.
2355 *
2356 * This flag allows the key to be used for a MAC verification operation or for
2357 * an asymmetric message signature verification operation, if otherwise
2358 * permitted by the key’s type and policy.
2359 *
2360 * For a key pair, this concerns the public key.
2361 */
2362 #define PSA_KEY_USAGE_VERIFY_MESSAGE ((psa_key_usage_t)0x00000800)
2363
2364 /** Whether the key may be used to sign a message.
2365 *
2366 * This flag allows the key to be used for a MAC calculation operation
2367 * or for an asymmetric signature operation,
2368 * if otherwise permitted by the key's type and policy.
2369 *
2370 * For a key pair, this concerns the private key.
2371 */
2372 #define PSA_KEY_USAGE_SIGN_HASH ((psa_key_usage_t)0x00001000)
2373
2374 /** Whether the key may be used to verify a message signature.
2375 *
2376 * This flag allows the key to be used for a MAC verification operation
2377 * or for an asymmetric signature verification operation,
2378 * if otherwise permitted by by the key's type and policy.
2379 *
2380 * For a key pair, this concerns the public key.
2381 */
2382 #define PSA_KEY_USAGE_VERIFY_HASH ((psa_key_usage_t)0x00002000)
2383
2384 /** Whether the key may be used to derive other keys or produce a password
2385 * hash.
2386 *
2387 * This flag allows the key to be used for a key derivation operation or for
2388 * a key agreement operation, if otherwise permitted by by the key's type and
2389 * policy.
2390 *
2391 * If this flag is present on all keys used in calls to
2392 * psa_key_derivation_input_key() for a key derivation operation, then it
2393 * permits calling psa_key_derivation_output_bytes() or
2394 * psa_key_derivation_output_key() at the end of the operation.
2395 */
2396 #define PSA_KEY_USAGE_DERIVE ((psa_key_usage_t)0x00004000)
2397
2398 /** Whether the key may be used to verify the result of a key derivation,
2399 * including password hashing.
2400 *
2401 * This flag allows the key to be used:
2402 *
2403 * This flag allows the key to be used in a key derivation operation, if
2404 * otherwise permitted by by the key's type and policy.
2405 *
2406 * If this flag is present on all keys used in calls to
2407 * psa_key_derivation_input_key() for a key derivation operation, then it
2408 * permits calling psa_key_derivation_verify_bytes() or
2409 * psa_key_derivation_verify_key() at the end of the operation.
2410 */
2411 #define PSA_KEY_USAGE_VERIFY_DERIVATION ((psa_key_usage_t)0x00008000)
2412
2413 /**@}*/
2414
2415 /** \defgroup derivation Key derivation
2416 * @{
2417 */
2418
2419 /** A secret input for key derivation.
2420 *
2421 * This should be a key of type #PSA_KEY_TYPE_DERIVE
2422 * (passed to psa_key_derivation_input_key())
2423 * or the shared secret resulting from a key agreement
2424 * (obtained via psa_key_derivation_key_agreement()).
2425 *
2426 * The secret can also be a direct input (passed to
2427 * key_derivation_input_bytes()). In this case, the derivation operation
2428 * may not be used to derive keys: the operation will only allow
2429 * psa_key_derivation_output_bytes(),
2430 * psa_key_derivation_verify_bytes(), or
2431 * psa_key_derivation_verify_key(), but not
2432 * psa_key_derivation_output_key().
2433 */
2434 #define PSA_KEY_DERIVATION_INPUT_SECRET ((psa_key_derivation_step_t)0x0101)
2435
2436 /** A low-entropy secret input for password hashing / key stretching.
2437 *
2438 * This is usually a key of type #PSA_KEY_TYPE_PASSWORD (passed to
2439 * psa_key_derivation_input_key()) or a direct input (passed to
2440 * psa_key_derivation_input_bytes()) that is a password or passphrase. It can
2441 * also be high-entropy secret such as a key of type #PSA_KEY_TYPE_DERIVE or
2442 * the shared secret resulting from a key agreement.
2443 *
2444 * The secret can also be a direct input (passed to
2445 * key_derivation_input_bytes()). In this case, the derivation operation
2446 * may not be used to derive keys: the operation will only allow
2447 * psa_key_derivation_output_bytes(),
2448 * psa_key_derivation_verify_bytes(), or
2449 * psa_key_derivation_verify_key(), but not
2450 * psa_key_derivation_output_key().
2451 */
2452 #define PSA_KEY_DERIVATION_INPUT_PASSWORD ((psa_key_derivation_step_t)0x0102)
2453
2454 /** A label for key derivation.
2455 *
2456 * This should be a direct input.
2457 * It can also be a key of type #PSA_KEY_TYPE_RAW_DATA.
2458 */
2459 #define PSA_KEY_DERIVATION_INPUT_LABEL ((psa_key_derivation_step_t)0x0201)
2460
2461 /** A salt for key derivation.
2462 *
2463 * This should be a direct input.
2464 * It can also be a key of type #PSA_KEY_TYPE_RAW_DATA or
2465 * #PSA_KEY_TYPE_PEPPER.
2466 */
2467 #define PSA_KEY_DERIVATION_INPUT_SALT ((psa_key_derivation_step_t)0x0202)
2468
2469 /** An information string for key derivation.
2470 *
2471 * This should be a direct input.
2472 * It can also be a key of type #PSA_KEY_TYPE_RAW_DATA.
2473 */
2474 #define PSA_KEY_DERIVATION_INPUT_INFO ((psa_key_derivation_step_t)0x0203)
2475
2476 /** A seed for key derivation.
2477 *
2478 * This should be a direct input.
2479 * It can also be a key of type #PSA_KEY_TYPE_RAW_DATA.
2480 */
2481 #define PSA_KEY_DERIVATION_INPUT_SEED ((psa_key_derivation_step_t)0x0204)
2482
2483 /** A cost parameter for password hashing / key stretching.
2484 *
2485 * This must be a direct input, passed to psa_key_derivation_input_integer().
2486 */
2487 #define PSA_KEY_DERIVATION_INPUT_COST ((psa_key_derivation_step_t)0x0205)
2488
2489 /**@}*/
2490
2491 /** \defgroup helper_macros Helper macros
2492 * @{
2493 */
2494
2495 /* Helper macros */
2496
2497 /** Check if two AEAD algorithm identifiers refer to the same AEAD algorithm
2498 * regardless of the tag length they encode.
2499 *
2500 * \param aead_alg_1 An AEAD algorithm identifier.
2501 * \param aead_alg_2 An AEAD algorithm identifier.
2502 *
2503 * \return 1 if both identifiers refer to the same AEAD algorithm,
2504 * 0 otherwise.
2505 * Unspecified if neither \p aead_alg_1 nor \p aead_alg_2 are
2506 * a supported AEAD algorithm.
2507 */
2508 #define MBEDTLS_PSA_ALG_AEAD_EQUAL(aead_alg_1, aead_alg_2) \
2509 (!(((aead_alg_1) ^ (aead_alg_2)) & \
2510 ~(PSA_ALG_AEAD_TAG_LENGTH_MASK | PSA_ALG_AEAD_AT_LEAST_THIS_LENGTH_FLAG)))
2511
2512 /**@}*/
2513
2514 #endif /* PSA_CRYPTO_VALUES_H */
2515