blob: a2191c66438c96025a18b3907d804f540e6a23bc [file] [log] [blame]
Gilles Peskinee59236f2018-01-27 23:32:46 +01001/**
2 * \file psa/crypto.h
3 * \brief Platform Security Architecture cryptography module
4 */
Jaeden Amerocab54942018-07-25 13:26:13 +01005/*
6 * Copyright (C) 2018, ARM Limited, All Rights Reserved
7 * SPDX-License-Identifier: Apache-2.0
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License"); you may
10 * not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
17 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 */
Gilles Peskinee59236f2018-01-27 23:32:46 +010021
22#ifndef PSA_CRYPTO_H
23#define PSA_CRYPTO_H
24
25#include "crypto_platform.h"
26
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +010027#include <stddef.h>
28
Gilles Peskine62a7e7e2018-02-07 21:54:47 +010029#ifdef __DOXYGEN_ONLY__
Gilles Peskinef5b9fa12018-03-07 16:40:18 +010030/* This __DOXYGEN_ONLY__ block contains mock definitions for things that
31 * must be defined in the crypto_platform.h header. These mock definitions
32 * are present in this file as a convenience to generate pretty-printed
33 * documentation that includes those definitions. */
34
Gilles Peskine62a7e7e2018-02-07 21:54:47 +010035/** \defgroup platform Implementation-specific definitions
36 * @{
37 */
38
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +010039/** \brief Key slot number.
40 *
41 * This type represents key slots. It must be an unsigned integral
Gilles Peskine308b91d2018-02-08 09:47:44 +010042 * type. The choice of type is implementation-dependent.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +010043 * 0 is not a valid key slot number. The meaning of other values is
44 * implementation dependent.
45 *
46 * At any given point in time, each key slot either contains a
47 * cryptographic object, or is empty. Key slots are persistent:
48 * once set, the cryptographic object remains in the key slot until
49 * explicitly destroyed.
50 */
51typedef _unsigned_integral_type_ psa_key_slot_t;
52
Gilles Peskine62a7e7e2018-02-07 21:54:47 +010053/**@}*/
Gilles Peskinef5b9fa12018-03-07 16:40:18 +010054#endif /* __DOXYGEN_ONLY__ */
Gilles Peskine62a7e7e2018-02-07 21:54:47 +010055
Gilles Peskinee59236f2018-01-27 23:32:46 +010056#ifdef __cplusplus
57extern "C" {
58#endif
59
60/** \defgroup basic Basic definitions
61 * @{
62 */
63
Gilles Peskinee9a0a9d2018-06-20 13:59:04 +020064#if defined(PSA_SUCCESS)
65/* If PSA_SUCCESS is defined, assume that PSA crypto is being used
66 * together with PSA IPC, which also defines the identifier
67 * PSA_SUCCESS. We must not define PSA_SUCCESS ourselves in that case;
68 * the other error code names don't clash. Also define psa_status_t as
69 * an alias for the type used by PSA IPC. This is a temporary hack
mohammad160313f43942018-08-05 12:09:44 +030070 * until we unify error reporting in PSA IPC and PSA crypto.
Gilles Peskinee9a0a9d2018-06-20 13:59:04 +020071 *
72 * Note that psa_defs.h must be included before this header!
73 */
74typedef psa_error_t psa_status_t;
75
76#else /* defined(PSA_SUCCESS) */
77
Gilles Peskinee59236f2018-01-27 23:32:46 +010078/**
79 * \brief Function return status.
80 *
Gilles Peskinee9a0a9d2018-06-20 13:59:04 +020081 * This is either #PSA_SUCCESS (which is zero), indicating success,
82 * or a nonzero value indicating that an error occurred. Errors are
83 * encoded as one of the \c PSA_ERROR_xxx values defined here.
Gilles Peskinee59236f2018-01-27 23:32:46 +010084 */
itayzafrirc2a79762018-06-18 16:20:16 +030085typedef int32_t psa_status_t;
Gilles Peskinee9a0a9d2018-06-20 13:59:04 +020086
itayzafrirc2a79762018-06-18 16:20:16 +030087/** The action was completed successfully. */
88#define PSA_SUCCESS ((psa_status_t)0)
Gilles Peskinee9a0a9d2018-06-20 13:59:04 +020089
90#endif /* !defined(PSA_SUCCESS) */
itayzafrirc2a79762018-06-18 16:20:16 +030091
itayzafrirf26dbfc2018-08-01 16:09:08 +030092/** An error occurred that does not correspond to any defined
93 * failure cause.
94 *
95 * Implementations may use this error code if none of the other standard
96 * error codes are applicable. */
97#define PSA_ERROR_UNKNOWN_ERROR ((psa_status_t)1)
98
itayzafrirc2a79762018-06-18 16:20:16 +030099/** The requested operation or a parameter is not supported
100 * by this implementation.
101 *
102 * Implementations should return this error code when an enumeration
103 * parameter such as a key type, algorithm, etc. is not recognized.
104 * If a combination of parameters is recognized and identified as
105 * not valid, return #PSA_ERROR_INVALID_ARGUMENT instead. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300106#define PSA_ERROR_NOT_SUPPORTED ((psa_status_t)2)
itayzafrirc2a79762018-06-18 16:20:16 +0300107
108/** The requested action is denied by a policy.
109 *
110 * Implementations should return this error code when the parameters
111 * are recognized as valid and supported, and a policy explicitly
112 * denies the requested operation.
113 *
114 * If a subset of the parameters of a function call identify a
115 * forbidden operation, and another subset of the parameters are
116 * not valid or not supported, it is unspecified whether the function
117 * returns #PSA_ERROR_NOT_PERMITTED, #PSA_ERROR_NOT_SUPPORTED or
118 * #PSA_ERROR_INVALID_ARGUMENT. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300119#define PSA_ERROR_NOT_PERMITTED ((psa_status_t)3)
itayzafrirc2a79762018-06-18 16:20:16 +0300120
121/** An output buffer is too small.
122 *
Gilles Peskinebe42f312018-07-13 14:38:15 +0200123 * Applications can call the \c PSA_xxx_SIZE macro listed in the function
itayzafrirc2a79762018-06-18 16:20:16 +0300124 * description to determine a sufficient buffer size.
125 *
126 * Implementations should preferably return this error code only
127 * in cases when performing the operation with a larger output
128 * buffer would succeed. However implementations may return this
129 * error if a function has invalid or unsupported parameters in addition
130 * to the parameters that determine the necessary output buffer size. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300131#define PSA_ERROR_BUFFER_TOO_SMALL ((psa_status_t)4)
itayzafrirc2a79762018-06-18 16:20:16 +0300132
133/** A slot is occupied, but must be empty to carry out the
134 * requested action.
135 *
136 * If the slot number is invalid (i.e. the requested action could
137 * not be performed even after erasing the slot's content),
138 * implementations shall return #PSA_ERROR_INVALID_ARGUMENT instead. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300139#define PSA_ERROR_OCCUPIED_SLOT ((psa_status_t)5)
itayzafrirc2a79762018-06-18 16:20:16 +0300140
141/** A slot is empty, but must be occupied to carry out the
142 * requested action.
143 *
144 * If the slot number is invalid (i.e. the requested action could
145 * not be performed even after creating appropriate content in the slot),
146 * implementations shall return #PSA_ERROR_INVALID_ARGUMENT instead. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300147#define PSA_ERROR_EMPTY_SLOT ((psa_status_t)6)
itayzafrirc2a79762018-06-18 16:20:16 +0300148
149/** The requested action cannot be performed in the current state.
150 *
151 * Multipart operations return this error when one of the
152 * functions is called out of sequence. Refer to the function
153 * descriptions for permitted sequencing of functions.
154 *
155 * Implementations shall not return this error code to indicate
156 * that a key slot is occupied when it needs to be free or vice versa,
157 * but shall return #PSA_ERROR_OCCUPIED_SLOT or #PSA_ERROR_EMPTY_SLOT
158 * as applicable. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300159#define PSA_ERROR_BAD_STATE ((psa_status_t)7)
itayzafrirc2a79762018-06-18 16:20:16 +0300160
161/** The parameters passed to the function are invalid.
162 *
163 * Implementations may return this error any time a parameter or
164 * combination of parameters are recognized as invalid.
165 *
166 * Implementations shall not return this error code to indicate
167 * that a key slot is occupied when it needs to be free or vice versa,
168 * but shall return #PSA_ERROR_OCCUPIED_SLOT or #PSA_ERROR_EMPTY_SLOT
169 * as applicable. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300170#define PSA_ERROR_INVALID_ARGUMENT ((psa_status_t)8)
itayzafrirc2a79762018-06-18 16:20:16 +0300171
172/** There is not enough runtime memory.
173 *
174 * If the action is carried out across multiple security realms, this
175 * error can refer to available memory in any of the security realms. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300176#define PSA_ERROR_INSUFFICIENT_MEMORY ((psa_status_t)9)
itayzafrirc2a79762018-06-18 16:20:16 +0300177
178/** There is not enough persistent storage.
179 *
180 * Functions that modify the key storage return this error code if
181 * there is insufficient storage space on the host media. In addition,
182 * many functions that do not otherwise access storage may return this
183 * error code if the implementation requires a mandatory log entry for
184 * the requested action and the log storage space is full. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300185#define PSA_ERROR_INSUFFICIENT_STORAGE ((psa_status_t)10)
itayzafrirc2a79762018-06-18 16:20:16 +0300186
187/** There was a communication failure inside the implementation.
188 *
189 * This can indicate a communication failure between the application
190 * and an external cryptoprocessor or between the cryptoprocessor and
191 * an external volatile or persistent memory. A communication failure
192 * may be transient or permanent depending on the cause.
193 *
194 * \warning If a function returns this error, it is undetermined
195 * whether the requested action has completed or not. Implementations
196 * should return #PSA_SUCCESS on successful completion whenver
197 * possible, however functions may return #PSA_ERROR_COMMUNICATION_FAILURE
198 * if the requested action was completed successfully in an external
199 * cryptoprocessor but there was a breakdown of communication before
200 * the cryptoprocessor could report the status to the application.
201 */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300202#define PSA_ERROR_COMMUNICATION_FAILURE ((psa_status_t)11)
itayzafrirc2a79762018-06-18 16:20:16 +0300203
204/** There was a storage failure that may have led to data loss.
205 *
206 * This error indicates that some persistent storage is corrupted.
207 * It should not be used for a corruption of volatile memory
208 * (use #PSA_ERROR_TAMPERING_DETECTED), for a communication error
209 * between the cryptoprocessor and its external storage (use
210 * #PSA_ERROR_COMMUNICATION_FAILURE), or when the storage is
211 * in a valid state but is full (use #PSA_ERROR_INSUFFICIENT_STORAGE).
212 *
213 * Note that a storage failure does not indicate that any data that was
214 * previously read is invalid. However this previously read data may no
215 * longer be readable from storage.
216 *
217 * When a storage failure occurs, it is no longer possible to ensure
218 * the global integrity of the keystore. Depending on the global
219 * integrity guarantees offered by the implementation, access to other
220 * data may or may not fail even if the data is still readable but
221 * its integrity canont be guaranteed.
222 *
223 * Implementations should only use this error code to report a
224 * permanent storage corruption. However application writers should
225 * keep in mind that transient errors while reading the storage may be
226 * reported using this error code. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300227#define PSA_ERROR_STORAGE_FAILURE ((psa_status_t)12)
itayzafrirc2a79762018-06-18 16:20:16 +0300228
229/** A hardware failure was detected.
230 *
231 * A hardware failure may be transient or permanent depending on the
232 * cause. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300233#define PSA_ERROR_HARDWARE_FAILURE ((psa_status_t)13)
itayzafrirc2a79762018-06-18 16:20:16 +0300234
235/** A tampering attempt was detected.
236 *
237 * If an application receives this error code, there is no guarantee
238 * that previously accessed or computed data was correct and remains
239 * confidential. Applications should not perform any security function
240 * and should enter a safe failure state.
241 *
242 * Implementations may return this error code if they detect an invalid
243 * state that cannot happen during normal operation and that indicates
244 * that the implementation's security guarantees no longer hold. Depending
245 * on the implementation architecture and on its security and safety goals,
246 * the implementation may forcibly terminate the application.
247 *
248 * This error code is intended as a last resort when a security breach
249 * is detected and it is unsure whether the keystore data is still
250 * protected. Implementations shall only return this error code
251 * to report an alarm from a tampering detector, to indicate that
252 * the confidentiality of stored data can no longer be guaranteed,
253 * or to indicate that the integrity of previously returned data is now
254 * considered compromised. Implementations shall not use this error code
255 * to indicate a hardware failure that merely makes it impossible to
256 * perform the requested operation (use #PSA_ERROR_COMMUNICATION_FAILURE,
257 * #PSA_ERROR_STORAGE_FAILURE, #PSA_ERROR_HARDWARE_FAILURE,
258 * #PSA_ERROR_INSUFFICIENT_ENTROPY or other applicable error code
259 * instead).
260 *
261 * This error indicates an attack against the application. Implementations
262 * shall not return this error code as a consequence of the behavior of
263 * the application itself. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300264#define PSA_ERROR_TAMPERING_DETECTED ((psa_status_t)14)
itayzafrirc2a79762018-06-18 16:20:16 +0300265
266/** There is not enough entropy to generate random data needed
267 * for the requested action.
268 *
269 * This error indicates a failure of a hardware random generator.
270 * Application writers should note that this error can be returned not
271 * only by functions whose purpose is to generate random data, such
272 * as key, IV or nonce generation, but also by functions that execute
273 * an algorithm with a randomized result, as well as functions that
274 * use randomization of intermediate computations as a countermeasure
275 * to certain attacks.
276 *
277 * Implementations should avoid returning this error after psa_crypto_init()
278 * has succeeded. Implementations should generate sufficient
279 * entropy during initialization and subsequently use a cryptographically
280 * secure pseudorandom generator (PRNG). However implementations may return
281 * this error at any time if a policy requires the PRNG to be reseeded
282 * during normal operation. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300283#define PSA_ERROR_INSUFFICIENT_ENTROPY ((psa_status_t)15)
itayzafrirc2a79762018-06-18 16:20:16 +0300284
285/** The signature, MAC or hash is incorrect.
286 *
287 * Verification functions return this error if the verification
288 * calculations completed successfully, and the value to be verified
289 * was determined to be incorrect.
290 *
291 * If the value to verify has an invalid size, implementations may return
292 * either #PSA_ERROR_INVALID_ARGUMENT or #PSA_ERROR_INVALID_SIGNATURE. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300293#define PSA_ERROR_INVALID_SIGNATURE ((psa_status_t)16)
itayzafrirc2a79762018-06-18 16:20:16 +0300294
295/** The decrypted padding is incorrect.
296 *
297 * \warning In some protocols, when decrypting data, it is essential that
298 * the behavior of the application does not depend on whether the padding
299 * is correct, down to precise timing. Applications should prefer
300 * protocols that use authenticated encryption rather than plain
301 * encryption. If the application must perform a decryption of
302 * unauthenticated data, the application writer should take care not
303 * to reveal whether the padding is invalid.
304 *
305 * Implementations should strive to make valid and invalid padding
306 * as close as possible to indistinguishable to an external observer.
307 * In particular, the timing of a decryption operation should not
308 * depend on the validity of the padding. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300309#define PSA_ERROR_INVALID_PADDING ((psa_status_t)17)
itayzafrirc2a79762018-06-18 16:20:16 +0300310
Gilles Peskineeab56e42018-07-12 17:12:33 +0200311/** The generator has insufficient capacity left.
312 *
313 * Once a function returns this error, attempts to read from the
314 * generator will always return this error. */
itayzafrirf26dbfc2018-08-01 16:09:08 +0300315#define PSA_ERROR_INSUFFICIENT_CAPACITY ((psa_status_t)18)
Gilles Peskinee59236f2018-01-27 23:32:46 +0100316
317/**
318 * \brief Library initialization.
319 *
320 * Applications must call this function before calling any other
321 * function in this module.
322 *
323 * Applications may call this function more than once. Once a call
324 * succeeds, subsequent calls are guaranteed to succeed.
325 *
itayzafrir18617092018-09-16 12:22:41 +0300326 * If the application calls other functions before calling psa_crypto_init(),
327 * the behavior is undefined. Implementations are encouraged to either perform
328 * the operation as if the library had been initialized or to return
329 * #PSA_ERROR_BAD_STATE or some other applicable error. In particular,
330 * implementations should not return a success status if the lack of
331 * initialization may have security implications, for example due to improper
332 * seeding of the random number generator.
333 *
Gilles Peskine28538492018-07-11 17:34:00 +0200334 * \retval #PSA_SUCCESS
335 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
336 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
337 * \retval #PSA_ERROR_HARDWARE_FAILURE
338 * \retval #PSA_ERROR_TAMPERING_DETECTED
339 * \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
Gilles Peskinee59236f2018-01-27 23:32:46 +0100340 */
341psa_status_t psa_crypto_init(void);
342
Gilles Peskine2905a7a2018-03-07 16:39:31 +0100343#define PSA_BITS_TO_BYTES(bits) (((bits) + 7) / 8)
344#define PSA_BYTES_TO_BITS(bytes) ((bytes) * 8)
Gilles Peskine0189e752018-02-03 23:57:22 +0100345
Gilles Peskinee59236f2018-01-27 23:32:46 +0100346/**@}*/
347
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100348/** \defgroup crypto_types Key and algorithm types
349 * @{
350 */
351
Gilles Peskine308b91d2018-02-08 09:47:44 +0100352/** \brief Encoding of a key type.
353 */
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100354typedef uint32_t psa_key_type_t;
355
Gilles Peskinef5b9fa12018-03-07 16:40:18 +0100356/** An invalid key type value.
357 *
358 * Zero is not the encoding of any key type.
359 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100360#define PSA_KEY_TYPE_NONE ((psa_key_type_t)0x00000000)
Gilles Peskinef5b9fa12018-03-07 16:40:18 +0100361
362/** Vendor-defined flag
363 *
364 * Key types defined by this standard will never have the
365 * #PSA_KEY_TYPE_VENDOR_FLAG bit set. Vendors who define additional key types
366 * must use an encoding with the #PSA_KEY_TYPE_VENDOR_FLAG bit set and should
367 * respect the bitwise structure used by standard encodings whenever practical.
368 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100369#define PSA_KEY_TYPE_VENDOR_FLAG ((psa_key_type_t)0x80000000)
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100370
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200371#define PSA_KEY_TYPE_CATEGORY_MASK ((psa_key_type_t)0x70000000)
372#define PSA_KEY_TYPE_CATEGORY_SYMMETRIC ((psa_key_type_t)0x40000000)
373#define PSA_KEY_TYPE_CATEGORY_RAW ((psa_key_type_t)0x50000000)
374#define PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY ((psa_key_type_t)0x60000000)
375#define PSA_KEY_TYPE_CATEGORY_KEY_PAIR ((psa_key_type_t)0x70000000)
376
377#define PSA_KEY_TYPE_CATEGORY_FLAG_PAIR ((psa_key_type_t)0x10000000)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200378
Gilles Peskinee8779742018-08-10 16:10:56 +0200379/** Whether a key type is vendor-defined. */
380#define PSA_KEY_TYPE_IS_VENDOR_DEFINED(type) \
381 (((type) & PSA_KEY_TYPE_VENDOR_FLAG) != 0)
382
383/** Whether a key type is an unstructured array of bytes.
384 *
385 * This encompasses both symmetric keys and non-key data.
386 */
387#define PSA_KEY_TYPE_IS_UNSTRUCTURED(type) \
388 (((type) & PSA_KEY_TYPE_CATEGORY_MASK & ~(psa_key_type_t)0x10000000) == \
389 PSA_KEY_TYPE_CATEGORY_SYMMETRIC)
390
391/** Whether a key type is asymmetric: either a key pair or a public key. */
392#define PSA_KEY_TYPE_IS_ASYMMETRIC(type) \
393 (((type) & PSA_KEY_TYPE_CATEGORY_MASK \
394 & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR) == \
395 PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)
396/** Whether a key type is the public part of a key pair. */
397#define PSA_KEY_TYPE_IS_PUBLIC_KEY(type) \
398 (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_PUBLIC_KEY)
399/** Whether a key type is a key pair containing a private part and a public
400 * part. */
401#define PSA_KEY_TYPE_IS_KEYPAIR(type) \
402 (((type) & PSA_KEY_TYPE_CATEGORY_MASK) == PSA_KEY_TYPE_CATEGORY_KEY_PAIR)
403/** The key pair type corresponding to a public key type.
404 *
405 * You may also pass a key pair type as \p type, it will be left unchanged.
406 *
407 * \param type A public key type or key pair type.
408 *
409 * \return The corresponding key pair type.
410 * If \p type is not a public key or a key pair,
411 * the return value is undefined.
412 */
413#define PSA_KEY_TYPE_KEYPAIR_OF_PUBLIC_KEY(type) \
414 ((type) | PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)
415/** The public key type corresponding to a key pair type.
416 *
417 * You may also pass a key pair type as \p type, it will be left unchanged.
418 *
419 * \param type A public key type or key pair type.
420 *
421 * \return The corresponding public key type.
422 * If \p type is not a public key or a key pair,
423 * the return value is undefined.
424 */
425#define PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) \
426 ((type) & ~PSA_KEY_TYPE_CATEGORY_FLAG_PAIR)
Gilles Peskinee8779742018-08-10 16:10:56 +0200427
Gilles Peskine35855962018-04-19 08:39:16 +0200428/** Raw data.
429 *
430 * A "key" of this type cannot be used for any cryptographic operation.
431 * Applications may use this type to store arbitrary data in the keystore. */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200432#define PSA_KEY_TYPE_RAW_DATA ((psa_key_type_t)0x50000001)
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100433
Gilles Peskine35855962018-04-19 08:39:16 +0200434/** HMAC key.
435 *
436 * The key policy determines which underlying hash algorithm the key can be
437 * used for.
438 *
439 * HMAC keys should generally have the same size as the underlying hash.
Gilles Peskinebe42f312018-07-13 14:38:15 +0200440 * This size can be calculated with #PSA_HASH_SIZE(\c alg) where
441 * \c alg is the HMAC algorithm or the underlying hash algorithm. */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200442#define PSA_KEY_TYPE_HMAC ((psa_key_type_t)0x51000000)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200443
Gilles Peskineea0fb492018-07-12 17:17:20 +0200444/** A secret for key derivation.
445 *
446 * The key policy determines which key derivation algorithm the key
447 * can be used for.
448 */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200449#define PSA_KEY_TYPE_DERIVE ((psa_key_type_t)0x52000000)
Gilles Peskineea0fb492018-07-12 17:17:20 +0200450
Gilles Peskine35855962018-04-19 08:39:16 +0200451/** Key for an cipher, AEAD or MAC algorithm based on the AES block cipher.
452 *
453 * The size of the key can be 16 bytes (AES-128), 24 bytes (AES-192) or
454 * 32 bytes (AES-256).
455 */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200456#define PSA_KEY_TYPE_AES ((psa_key_type_t)0x40000001)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200457
Gilles Peskine35855962018-04-19 08:39:16 +0200458/** Key for a cipher or MAC algorithm based on DES or 3DES (Triple-DES).
459 *
460 * The size of the key can be 8 bytes (single DES), 16 bytes (2-key 3DES) or
461 * 24 bytes (3-key 3DES).
462 *
463 * Note that single DES and 2-key 3DES are weak and strongly
464 * deprecated and should only be used to decrypt legacy data. 3-key 3DES
465 * is weak and deprecated and should only be used in legacy protocols.
466 */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200467#define PSA_KEY_TYPE_DES ((psa_key_type_t)0x40000002)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200468
Gilles Peskine35855962018-04-19 08:39:16 +0200469/** Key for an cipher, AEAD or MAC algorithm based on the
470 * Camellia block cipher. */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200471#define PSA_KEY_TYPE_CAMELLIA ((psa_key_type_t)0x40000003)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200472
Gilles Peskine35855962018-04-19 08:39:16 +0200473/** Key for the RC4 stream cipher.
474 *
475 * Note that RC4 is weak and deprecated and should only be used in
476 * legacy protocols. */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200477#define PSA_KEY_TYPE_ARC4 ((psa_key_type_t)0x40000004)
Gilles Peskine98f0a242018-02-06 18:57:29 +0100478
Gilles Peskine308b91d2018-02-08 09:47:44 +0100479/** RSA public key. */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200480#define PSA_KEY_TYPE_RSA_PUBLIC_KEY ((psa_key_type_t)0x60010000)
Gilles Peskine308b91d2018-02-08 09:47:44 +0100481/** RSA key pair (private and public key). */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200482#define PSA_KEY_TYPE_RSA_KEYPAIR ((psa_key_type_t)0x70010000)
Gilles Peskine583b55d2018-08-22 18:21:32 +0200483/** Whether a key type is an RSA key (pair or public-only). */
484#define PSA_KEY_TYPE_IS_RSA(type) \
485 (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_RSA_PUBLIC_KEY)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200486
Gilles Peskine06dc2632018-03-08 07:47:25 +0100487/** DSA public key. */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200488#define PSA_KEY_TYPE_DSA_PUBLIC_KEY ((psa_key_type_t)0x60020000)
Gilles Peskine06dc2632018-03-08 07:47:25 +0100489/** DSA key pair (private and public key). */
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200490#define PSA_KEY_TYPE_DSA_KEYPAIR ((psa_key_type_t)0x70020000)
Gilles Peskine583b55d2018-08-22 18:21:32 +0200491/** Whether a key type is an DSA key (pair or public-only). */
492#define PSA_KEY_TYPE_IS_DSA(type) \
493 (PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) == PSA_KEY_TYPE_DSA_PUBLIC_KEY)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200494
Gilles Peskine78b3bb62018-08-10 16:03:41 +0200495#define PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE ((psa_key_type_t)0x60030000)
496#define PSA_KEY_TYPE_ECC_KEYPAIR_BASE ((psa_key_type_t)0x70030000)
Gilles Peskine98f0a242018-02-06 18:57:29 +0100497#define PSA_KEY_TYPE_ECC_CURVE_MASK ((psa_key_type_t)0x0000ffff)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200498/** Elliptic curve key pair. */
Gilles Peskine06dc2632018-03-08 07:47:25 +0100499#define PSA_KEY_TYPE_ECC_KEYPAIR(curve) \
500 (PSA_KEY_TYPE_ECC_KEYPAIR_BASE | (curve))
Gilles Peskinedcd14942018-07-12 00:30:52 +0200501/** Elliptic curve public key. */
Gilles Peskine06dc2632018-03-08 07:47:25 +0100502#define PSA_KEY_TYPE_ECC_PUBLIC_KEY(curve) \
503 (PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE | (curve))
Gilles Peskine98f0a242018-02-06 18:57:29 +0100504
Gilles Peskined8008d62018-06-29 19:51:51 +0200505/** Whether a key type is an elliptic curve key (pair or public-only). */
Gilles Peskinec66ea6a2018-02-03 22:43:28 +0100506#define PSA_KEY_TYPE_IS_ECC(type) \
Gilles Peskine06dc2632018-03-08 07:47:25 +0100507 ((PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(type) & \
508 ~PSA_KEY_TYPE_ECC_CURVE_MASK) == PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)
Gilles Peskine55728b02018-07-16 23:08:16 +0200509#define PSA_KEY_TYPE_IS_ECC_KEYPAIR(type) \
510 (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \
511 PSA_KEY_TYPE_ECC_KEYPAIR_BASE)
512#define PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY(type) \
513 (((type) & ~PSA_KEY_TYPE_ECC_CURVE_MASK) == \
514 PSA_KEY_TYPE_ECC_PUBLIC_KEY_BASE)
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +0100515
Gilles Peskinee1fed0d2018-06-18 20:45:45 +0200516/** The type of PSA elliptic curve identifiers. */
517typedef uint16_t psa_ecc_curve_t;
518/** Extract the curve from an elliptic curve key type. */
519#define PSA_KEY_TYPE_GET_CURVE(type) \
520 ((psa_ecc_curve_t) (PSA_KEY_TYPE_IS_ECC(type) ? \
521 ((type) & PSA_KEY_TYPE_ECC_CURVE_MASK) : \
522 0))
523
524/* The encoding of curve identifiers is currently aligned with the
525 * TLS Supported Groups Registry (formerly known as the
526 * TLS EC Named Curve Registry)
527 * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8
Gilles Peskine70ce2c62018-08-22 18:21:57 +0200528 * The values are defined by RFC 8422 and RFC 7027. */
Gilles Peskinee1fed0d2018-06-18 20:45:45 +0200529#define PSA_ECC_CURVE_SECT163K1 ((psa_ecc_curve_t) 0x0001)
530#define PSA_ECC_CURVE_SECT163R1 ((psa_ecc_curve_t) 0x0002)
531#define PSA_ECC_CURVE_SECT163R2 ((psa_ecc_curve_t) 0x0003)
532#define PSA_ECC_CURVE_SECT193R1 ((psa_ecc_curve_t) 0x0004)
533#define PSA_ECC_CURVE_SECT193R2 ((psa_ecc_curve_t) 0x0005)
534#define PSA_ECC_CURVE_SECT233K1 ((psa_ecc_curve_t) 0x0006)
535#define PSA_ECC_CURVE_SECT233R1 ((psa_ecc_curve_t) 0x0007)
536#define PSA_ECC_CURVE_SECT239K1 ((psa_ecc_curve_t) 0x0008)
537#define PSA_ECC_CURVE_SECT283K1 ((psa_ecc_curve_t) 0x0009)
538#define PSA_ECC_CURVE_SECT283R1 ((psa_ecc_curve_t) 0x000a)
539#define PSA_ECC_CURVE_SECT409K1 ((psa_ecc_curve_t) 0x000b)
540#define PSA_ECC_CURVE_SECT409R1 ((psa_ecc_curve_t) 0x000c)
541#define PSA_ECC_CURVE_SECT571K1 ((psa_ecc_curve_t) 0x000d)
542#define PSA_ECC_CURVE_SECT571R1 ((psa_ecc_curve_t) 0x000e)
543#define PSA_ECC_CURVE_SECP160K1 ((psa_ecc_curve_t) 0x000f)
544#define PSA_ECC_CURVE_SECP160R1 ((psa_ecc_curve_t) 0x0010)
545#define PSA_ECC_CURVE_SECP160R2 ((psa_ecc_curve_t) 0x0011)
546#define PSA_ECC_CURVE_SECP192K1 ((psa_ecc_curve_t) 0x0012)
547#define PSA_ECC_CURVE_SECP192R1 ((psa_ecc_curve_t) 0x0013)
548#define PSA_ECC_CURVE_SECP224K1 ((psa_ecc_curve_t) 0x0014)
549#define PSA_ECC_CURVE_SECP224R1 ((psa_ecc_curve_t) 0x0015)
550#define PSA_ECC_CURVE_SECP256K1 ((psa_ecc_curve_t) 0x0016)
551#define PSA_ECC_CURVE_SECP256R1 ((psa_ecc_curve_t) 0x0017)
552#define PSA_ECC_CURVE_SECP384R1 ((psa_ecc_curve_t) 0x0018)
553#define PSA_ECC_CURVE_SECP521R1 ((psa_ecc_curve_t) 0x0019)
554#define PSA_ECC_CURVE_BRAINPOOL_P256R1 ((psa_ecc_curve_t) 0x001a)
555#define PSA_ECC_CURVE_BRAINPOOL_P384R1 ((psa_ecc_curve_t) 0x001b)
556#define PSA_ECC_CURVE_BRAINPOOL_P512R1 ((psa_ecc_curve_t) 0x001c)
557#define PSA_ECC_CURVE_CURVE25519 ((psa_ecc_curve_t) 0x001d)
558#define PSA_ECC_CURVE_CURVE448 ((psa_ecc_curve_t) 0x001e)
Gilles Peskinee1fed0d2018-06-18 20:45:45 +0200559
Gilles Peskine7e198532018-03-08 07:50:30 +0100560/** The block size of a block cipher.
561 *
562 * \param type A cipher key type (value of type #psa_key_type_t).
563 *
564 * \return The block size for a block cipher, or 1 for a stream cipher.
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200565 * The return value is undefined if \p type is not a supported
Gilles Peskine35855962018-04-19 08:39:16 +0200566 * cipher key type.
567 *
568 * \note It is possible to build stream cipher algorithms on top of a block
569 * cipher, for example CTR mode (#PSA_ALG_CTR).
570 * This macro only takes the key type into account, so it cannot be
571 * used to determine the size of the data that #psa_cipher_update()
572 * might buffer for future processing in general.
Gilles Peskine7e198532018-03-08 07:50:30 +0100573 *
574 * \note This macro returns a compile-time constant if its argument is one.
575 *
576 * \warning This macro may evaluate its argument multiple times.
577 */
Gilles Peskine03182e92018-03-07 16:40:52 +0100578#define PSA_BLOCK_CIPHER_BLOCK_SIZE(type) \
Gilles Peskine8c9def32018-02-08 10:02:12 +0100579 ( \
580 (type) == PSA_KEY_TYPE_AES ? 16 : \
581 (type) == PSA_KEY_TYPE_DES ? 8 : \
582 (type) == PSA_KEY_TYPE_CAMELLIA ? 16 : \
Gilles Peskine7e198532018-03-08 07:50:30 +0100583 (type) == PSA_KEY_TYPE_ARC4 ? 1 : \
Gilles Peskine8c9def32018-02-08 10:02:12 +0100584 0)
585
Gilles Peskine308b91d2018-02-08 09:47:44 +0100586/** \brief Encoding of a cryptographic algorithm.
587 *
588 * For algorithms that can be applied to multiple key types, this type
589 * does not encode the key type. For example, for symmetric ciphers
590 * based on a block cipher, #psa_algorithm_t encodes the block cipher
591 * mode and the padding mode while the block cipher itself is encoded
592 * via #psa_key_type_t.
593 */
Gilles Peskine20035e32018-02-03 22:44:14 +0100594typedef uint32_t psa_algorithm_t;
595
Gilles Peskine98f0a242018-02-06 18:57:29 +0100596#define PSA_ALG_VENDOR_FLAG ((psa_algorithm_t)0x80000000)
597#define PSA_ALG_CATEGORY_MASK ((psa_algorithm_t)0x7f000000)
598#define PSA_ALG_CATEGORY_HASH ((psa_algorithm_t)0x01000000)
599#define PSA_ALG_CATEGORY_MAC ((psa_algorithm_t)0x02000000)
600#define PSA_ALG_CATEGORY_CIPHER ((psa_algorithm_t)0x04000000)
601#define PSA_ALG_CATEGORY_AEAD ((psa_algorithm_t)0x06000000)
602#define PSA_ALG_CATEGORY_SIGN ((psa_algorithm_t)0x10000000)
603#define PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION ((psa_algorithm_t)0x12000000)
604#define PSA_ALG_CATEGORY_KEY_AGREEMENT ((psa_algorithm_t)0x22000000)
605#define PSA_ALG_CATEGORY_KEY_DERIVATION ((psa_algorithm_t)0x30000000)
Gilles Peskinee8f0e3d2018-09-18 11:52:10 +0200606#define PSA_ALG_CATEGORY_KEY_SELECTION ((psa_algorithm_t)0x31000000)
Gilles Peskine20035e32018-02-03 22:44:14 +0100607
Gilles Peskine98f0a242018-02-06 18:57:29 +0100608#define PSA_ALG_IS_VENDOR_DEFINED(alg) \
609 (((alg) & PSA_ALG_VENDOR_FLAG) != 0)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200610
Gilles Peskine308b91d2018-02-08 09:47:44 +0100611/** Whether the specified algorithm is a hash algorithm.
612 *
Gilles Peskine7e198532018-03-08 07:50:30 +0100613 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
Gilles Peskine308b91d2018-02-08 09:47:44 +0100614 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200615 * \return 1 if \p alg is a hash algorithm, 0 otherwise.
616 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskine7e198532018-03-08 07:50:30 +0100617 * algorithm identifier.
618 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100619#define PSA_ALG_IS_HASH(alg) \
620 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_HASH)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200621
622/** Whether the specified algorithm is a MAC algorithm.
623 *
624 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
625 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200626 * \return 1 if \p alg is a MAC algorithm, 0 otherwise.
627 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200628 * algorithm identifier.
629 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100630#define PSA_ALG_IS_MAC(alg) \
631 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_MAC)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200632
633/** Whether the specified algorithm is a symmetric cipher algorithm.
634 *
635 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
636 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200637 * \return 1 if \p alg is a symmetric cipher algorithm, 0 otherwise.
638 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200639 * algorithm identifier.
640 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100641#define PSA_ALG_IS_CIPHER(alg) \
642 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_CIPHER)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200643
644/** Whether the specified algorithm is an authenticated encryption
645 * with associated data (AEAD) algorithm.
646 *
647 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
648 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200649 * \return 1 if \p alg is an AEAD algorithm, 0 otherwise.
650 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200651 * algorithm identifier.
652 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100653#define PSA_ALG_IS_AEAD(alg) \
654 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_AEAD)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200655
656/** Whether the specified algorithm is a public-key signature algorithm.
657 *
658 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
659 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200660 * \return 1 if \p alg is a public-key signature algorithm, 0 otherwise.
661 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200662 * algorithm identifier.
663 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100664#define PSA_ALG_IS_SIGN(alg) \
665 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_SIGN)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200666
667/** Whether the specified algorithm is a public-key encryption algorithm.
668 *
669 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
670 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200671 * \return 1 if \p alg is a public-key encryption algorithm, 0 otherwise.
672 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200673 * algorithm identifier.
674 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100675#define PSA_ALG_IS_ASYMMETRIC_ENCRYPTION(alg) \
676 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_ASYMMETRIC_ENCRYPTION)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200677
Gilles Peskinee8f0e3d2018-09-18 11:52:10 +0200678#define PSA_ALG_KEY_SELECTION_FLAG ((psa_algorithm_t)0x01000000)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200679/** Whether the specified algorithm is a key agreement algorithm.
680 *
681 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
682 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200683 * \return 1 if \p alg is a key agreement algorithm, 0 otherwise.
684 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200685 * algorithm identifier.
686 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100687#define PSA_ALG_IS_KEY_AGREEMENT(alg) \
Gilles Peskinee8f0e3d2018-09-18 11:52:10 +0200688 (((alg) & PSA_ALG_CATEGORY_MASK & ~PSA_ALG_KEY_SELECTION_FLAG) == \
689 PSA_ALG_CATEGORY_KEY_AGREEMENT)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200690
691/** Whether the specified algorithm is a key derivation algorithm.
692 *
693 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
694 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200695 * \return 1 if \p alg is a key derivation algorithm, 0 otherwise.
696 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200697 * algorithm identifier.
698 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100699#define PSA_ALG_IS_KEY_DERIVATION(alg) \
700 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_DERIVATION)
701
Gilles Peskinee8f0e3d2018-09-18 11:52:10 +0200702/** Whether the specified algorithm is a key selection algorithm.
703 *
704 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
705 *
706 * \return 1 if \p alg is a key selection algorithm, 0 otherwise.
707 * This macro may return either 0 or 1 if \p alg is not a supported
708 * algorithm identifier.
709 */
710#define PSA_ALG_IS_KEY_SELECTION(alg) \
711 (((alg) & PSA_ALG_CATEGORY_MASK) == PSA_ALG_CATEGORY_KEY_SELECTION)
712
Gilles Peskine98f0a242018-02-06 18:57:29 +0100713#define PSA_ALG_HASH_MASK ((psa_algorithm_t)0x000000ff)
714#define PSA_ALG_MD2 ((psa_algorithm_t)0x01000001)
715#define PSA_ALG_MD4 ((psa_algorithm_t)0x01000002)
716#define PSA_ALG_MD5 ((psa_algorithm_t)0x01000003)
Gilles Peskinee3f694f2018-03-08 07:48:40 +0100717#define PSA_ALG_RIPEMD160 ((psa_algorithm_t)0x01000004)
718#define PSA_ALG_SHA_1 ((psa_algorithm_t)0x01000005)
Gilles Peskineedd76872018-07-20 17:42:05 +0200719/** SHA2-224 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100720#define PSA_ALG_SHA_224 ((psa_algorithm_t)0x01000008)
Gilles Peskineedd76872018-07-20 17:42:05 +0200721/** SHA2-256 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100722#define PSA_ALG_SHA_256 ((psa_algorithm_t)0x01000009)
Gilles Peskineedd76872018-07-20 17:42:05 +0200723/** SHA2-384 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100724#define PSA_ALG_SHA_384 ((psa_algorithm_t)0x0100000a)
Gilles Peskineedd76872018-07-20 17:42:05 +0200725/** SHA2-512 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100726#define PSA_ALG_SHA_512 ((psa_algorithm_t)0x0100000b)
Gilles Peskineedd76872018-07-20 17:42:05 +0200727/** SHA2-512/224 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100728#define PSA_ALG_SHA_512_224 ((psa_algorithm_t)0x0100000c)
Gilles Peskineedd76872018-07-20 17:42:05 +0200729/** SHA2-512/256 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100730#define PSA_ALG_SHA_512_256 ((psa_algorithm_t)0x0100000d)
Gilles Peskineedd76872018-07-20 17:42:05 +0200731/** SHA3-224 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100732#define PSA_ALG_SHA3_224 ((psa_algorithm_t)0x01000010)
Gilles Peskineedd76872018-07-20 17:42:05 +0200733/** SHA3-256 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100734#define PSA_ALG_SHA3_256 ((psa_algorithm_t)0x01000011)
Gilles Peskineedd76872018-07-20 17:42:05 +0200735/** SHA3-384 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100736#define PSA_ALG_SHA3_384 ((psa_algorithm_t)0x01000012)
Gilles Peskineedd76872018-07-20 17:42:05 +0200737/** SHA3-512 */
Gilles Peskine98f0a242018-02-06 18:57:29 +0100738#define PSA_ALG_SHA3_512 ((psa_algorithm_t)0x01000013)
739
Gilles Peskine8c9def32018-02-08 10:02:12 +0100740#define PSA_ALG_MAC_SUBCATEGORY_MASK ((psa_algorithm_t)0x00c00000)
Gilles Peskine98f0a242018-02-06 18:57:29 +0100741#define PSA_ALG_HMAC_BASE ((psa_algorithm_t)0x02800000)
Gilles Peskine35855962018-04-19 08:39:16 +0200742/** Macro to build an HMAC algorithm.
743 *
Gilles Peskinedda3bd32018-07-12 19:40:46 +0200744 * For example, #PSA_ALG_HMAC(#PSA_ALG_SHA_256) is HMAC-SHA-256.
Gilles Peskine35855962018-04-19 08:39:16 +0200745 *
Gilles Peskineea4469f2018-06-28 13:57:23 +0200746 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +0200747 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
Gilles Peskine35855962018-04-19 08:39:16 +0200748 *
Gilles Peskineea4469f2018-06-28 13:57:23 +0200749 * \return The corresponding HMAC algorithm.
750 * \return Unspecified if \p alg is not a supported
751 * hash algorithm.
Gilles Peskine35855962018-04-19 08:39:16 +0200752 */
753#define PSA_ALG_HMAC(hash_alg) \
Gilles Peskine8c9def32018-02-08 10:02:12 +0100754 (PSA_ALG_HMAC_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
Gilles Peskinedcd14942018-07-12 00:30:52 +0200755
Gilles Peskine00709fa2018-08-22 18:25:41 +0200756#define PSA_ALG_HMAC_GET_HASH(hmac_alg) \
Gilles Peskine8c9def32018-02-08 10:02:12 +0100757 (PSA_ALG_CATEGORY_HASH | ((hmac_alg) & PSA_ALG_HASH_MASK))
Gilles Peskinedcd14942018-07-12 00:30:52 +0200758
759/** Whether the specified algorithm is an HMAC algorithm.
760 *
761 * HMAC is a family of MAC algorithms that are based on a hash function.
762 *
763 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
764 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200765 * \return 1 if \p alg is an HMAC algorithm, 0 otherwise.
766 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200767 * algorithm identifier.
768 */
Gilles Peskine8c9def32018-02-08 10:02:12 +0100769#define PSA_ALG_IS_HMAC(alg) \
770 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \
771 PSA_ALG_HMAC_BASE)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200772
Gilles Peskinee1f2d7d2018-08-21 14:54:54 +0200773/* In the encoding of a MAC algorithm, the bits corresponding to
774 * PSA_ALG_MAC_TRUNCATION_MASK encode the length to which the MAC is
775 * truncated. As an exception, the value 0 means the untruncated algorithm,
776 * whatever its length is. The length is encoded in 6 bits, so it can
777 * reach up to 63; the largest MAC is 64 bytes so its trivial truncation
778 * to full length is correctly encoded as 0 and any non-trivial truncation
779 * is correctly encoded as a value between 1 and 63. */
Gilles Peskined911eb72018-08-14 15:18:45 +0200780#define PSA_ALG_MAC_TRUNCATION_MASK ((psa_algorithm_t)0x00003f00)
781#define PSA_MAC_TRUNCATION_OFFSET 8
782
783/** Macro to build a truncated MAC algorithm.
784 *
785 * A truncated MAC algorithm is identical to the corresponding MAC
786 * algorithm except that the MAC value for the truncated algorithm
787 * consists of only the first \p mac_length bytes of the MAC value
788 * for the untruncated algorithm.
789 *
790 * \note This macro may allow constructing algorithm identifiers that
791 * are not valid, either because the specified length is larger
792 * than the untruncated MAC or because the specified length is
793 * smaller than permitted by the implementation.
794 *
795 * \note It is implementation-defined whether a truncated MAC that
796 * is truncated to the same length as the MAC of the untruncated
797 * algorithm is considered identical to the untruncated algorithm
798 * for policy comparison purposes.
799 *
800 * \param alg A MAC algorithm identifier (value of type
801 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p alg)
802 * is true). This may be a truncated or untruncated
803 * MAC algorithm.
804 * \param mac_length Desired length of the truncated MAC in bytes.
Gilles Peskine6d72ff92018-08-21 14:55:08 +0200805 * This must be at most the full length of the MAC
806 * and must be at least an implementation-specified
807 * minimum. The implementation-specified minimum
808 * shall not be zero.
Gilles Peskined911eb72018-08-14 15:18:45 +0200809 *
810 * \return The corresponding MAC algorithm with the specified
811 * length.
812 * \return Unspecified if \p alg is not a supported
813 * MAC algorithm or if \p mac_length is too small or
814 * too large for the specified MAC algorithm.
815 */
816#define PSA_ALG_TRUNCATED_MAC(alg, mac_length) \
817 (((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK) | \
818 ((mac_length) << PSA_MAC_TRUNCATION_OFFSET & PSA_ALG_MAC_TRUNCATION_MASK))
819
Gilles Peskinee0e9c7c2018-10-17 18:28:05 +0200820/** Macro to build the base MAC algorithm corresponding to a truncated
821 * MAC algorithm.
822 *
823 * \param alg A MAC algorithm identifier (value of type
824 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p alg)
825 * is true). This may be a truncated or untruncated
826 * MAC algorithm.
827 *
828 * \return The corresponding base MAC algorithm.
829 * \return Unspecified if \p alg is not a supported
830 * MAC algorithm.
831 */
832#define PSA_ALG_FULL_LENGTH_MAC(alg) \
833 ((alg) & ~PSA_ALG_MAC_TRUNCATION_MASK)
834
Gilles Peskined911eb72018-08-14 15:18:45 +0200835/** Length to which a MAC algorithm is truncated.
836 *
837 * \param alg A MAC algorithm identifier (value of type
838 * #psa_algorithm_t such that #PSA_ALG_IS_MAC(\p alg)
839 * is true).
840 *
841 * \return Length of the truncated MAC in bytes.
842 * \return 0 if \p alg is a non-truncated MAC algorithm.
843 * \return Unspecified if \p alg is not a supported
844 * MAC algorithm.
845 */
846#define PSA_MAC_TRUNCATED_LENGTH(alg) \
847 (((alg) & PSA_ALG_MAC_TRUNCATION_MASK) >> PSA_MAC_TRUNCATION_OFFSET)
848
Gilles Peskine8c9def32018-02-08 10:02:12 +0100849#define PSA_ALG_CIPHER_MAC_BASE ((psa_algorithm_t)0x02c00000)
850#define PSA_ALG_CBC_MAC ((psa_algorithm_t)0x02c00001)
851#define PSA_ALG_CMAC ((psa_algorithm_t)0x02c00002)
852#define PSA_ALG_GMAC ((psa_algorithm_t)0x02c00003)
Gilles Peskinedcd14942018-07-12 00:30:52 +0200853
854/** Whether the specified algorithm is a MAC algorithm based on a block cipher.
855 *
Gilles Peskine6ac73a92018-07-12 19:47:19 +0200856 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
857 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200858 * \return 1 if \p alg is a MAC algorithm based on a block cipher, 0 otherwise.
859 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200860 * algorithm identifier.
861 */
Gilles Peskine9df2dc82018-08-22 18:24:17 +0200862#define PSA_ALG_IS_BLOCK_CIPHER_MAC(alg) \
Gilles Peskine8c9def32018-02-08 10:02:12 +0100863 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_MAC_SUBCATEGORY_MASK)) == \
864 PSA_ALG_CIPHER_MAC_BASE)
Gilles Peskine98f0a242018-02-06 18:57:29 +0100865
Gilles Peskinedaea26f2018-08-21 14:02:45 +0200866#define PSA_ALG_CIPHER_STREAM_FLAG ((psa_algorithm_t)0x00800000)
867#define PSA_ALG_CIPHER_FROM_BLOCK_FLAG ((psa_algorithm_t)0x00400000)
Gilles Peskine98f0a242018-02-06 18:57:29 +0100868
Gilles Peskinedcd14942018-07-12 00:30:52 +0200869/** Whether the specified algorithm is a stream cipher.
870 *
871 * A stream cipher is a symmetric cipher that encrypts or decrypts messages
872 * by applying a bitwise-xor with a stream of bytes that is generated
873 * from a key.
874 *
875 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
876 *
Gilles Peskinefa4070c2018-07-12 19:23:03 +0200877 * \return 1 if \p alg is a stream cipher algorithm, 0 otherwise.
878 * This macro may return either 0 or 1 if \p alg is not a supported
Gilles Peskinedcd14942018-07-12 00:30:52 +0200879 * algorithm identifier or if it is not a symmetric cipher algorithm.
880 */
Moran Pekerbed71a22018-04-22 20:19:20 +0300881#define PSA_ALG_IS_STREAM_CIPHER(alg) \
Gilles Peskinedaea26f2018-08-21 14:02:45 +0200882 (((alg) & (PSA_ALG_CATEGORY_MASK | PSA_ALG_CIPHER_STREAM_FLAG)) == \
883 (PSA_ALG_CATEGORY_CIPHER | PSA_ALG_CIPHER_STREAM_FLAG))
884
885/** The ARC4 stream cipher algorithm.
886 */
887#define PSA_ALG_ARC4 ((psa_algorithm_t)0x04800001)
888
889/** The CTR stream cipher mode.
890 *
891 * CTR is a stream cipher which is built from a block cipher.
892 * The underlying block cipher is determined by the key type.
893 * For example, to use AES-128-CTR, use this algorithm with
894 * a key of type #PSA_KEY_TYPE_AES and a length of 128 bits (16 bytes).
895 */
896#define PSA_ALG_CTR ((psa_algorithm_t)0x04c00001)
897
898#define PSA_ALG_CFB ((psa_algorithm_t)0x04c00002)
899
900#define PSA_ALG_OFB ((psa_algorithm_t)0x04c00003)
901
902/** The XTS cipher mode.
903 *
904 * XTS is a cipher mode which is built from a block cipher. It requires at
905 * least one full block of input, but beyond this minimum the input
906 * does not need to be a whole number of blocks.
907 */
908#define PSA_ALG_XTS ((psa_algorithm_t)0x044000ff)
909
910/** The CBC block cipher chaining mode, with no padding.
911 *
912 * The underlying block cipher is determined by the key type.
913 *
914 * This symmetric cipher mode can only be used with messages whose lengths
915 * are whole number of blocks for the chosen block cipher.
916 */
917#define PSA_ALG_CBC_NO_PADDING ((psa_algorithm_t)0x04600100)
918
919/** The CBC block cipher chaining mode with PKCS#7 padding.
920 *
921 * The underlying block cipher is determined by the key type.
922 *
923 * This is the padding method defined by PKCS#7 (RFC 2315) &sect;10.3.
924 */
925#define PSA_ALG_CBC_PKCS7 ((psa_algorithm_t)0x04600101)
Moran Pekerbed71a22018-04-22 20:19:20 +0300926
Gilles Peskine23cc2ff2018-08-17 19:47:52 +0200927#define PSA_ALG_CCM ((psa_algorithm_t)0x06001001)
928#define PSA_ALG_GCM ((psa_algorithm_t)0x06001002)
929
Gilles Peskinee1f2d7d2018-08-21 14:54:54 +0200930/* In the encoding of a AEAD algorithm, the bits corresponding to
931 * PSA_ALG_AEAD_TAG_LENGTH_MASK encode the length of the AEAD tag.
932 * The constants for default lengths follow this encoding.
933 */
Gilles Peskine23cc2ff2018-08-17 19:47:52 +0200934#define PSA_ALG_AEAD_TAG_LENGTH_MASK ((psa_algorithm_t)0x00003f00)
935#define PSA_AEAD_TAG_LENGTH_OFFSET 8
936
937/** Macro to build a shortened AEAD algorithm.
938 *
939 * A shortened AEAD algorithm is similar to the corresponding AEAD
940 * algorithm, but has an authentication tag that consists of fewer bytes.
941 * Depending on the algorithm, the tag length may affect the calculation
942 * of the ciphertext.
943 *
944 * \param alg A AEAD algorithm identifier (value of type
945 * #psa_algorithm_t such that #PSA_ALG_IS_AEAD(\p alg)
946 * is true).
Gilles Peskine31119812018-08-21 14:47:48 +0200947 * \param tag_length Desired length of the authentication tag in bytes.
Gilles Peskine23cc2ff2018-08-17 19:47:52 +0200948 *
949 * \return The corresponding AEAD algorithm with the specified
950 * length.
951 * \return Unspecified if \p alg is not a supported
952 * AEAD algorithm or if \p tag_length is not valid
953 * for the specified AEAD algorithm.
954 */
955#define PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, tag_length) \
956 (((alg) & ~PSA_ALG_AEAD_TAG_LENGTH_MASK) | \
957 ((tag_length) << PSA_AEAD_TAG_LENGTH_OFFSET & \
958 PSA_ALG_AEAD_TAG_LENGTH_MASK))
Gilles Peskine98f0a242018-02-06 18:57:29 +0100959
Gilles Peskine70f46e12018-08-20 15:07:53 +0200960/** Calculate the corresponding AEAD algorithm with the default tag length.
961 *
962 * \param alg An AEAD algorithm (\c PSA_ALG_XXX value such that
963 * #PSA_ALG_IS_AEAD(\p alg) is true).
964 *
965 * \return The corresponding AEAD algorithm with the default tag length
966 * for that algorithm.
967 */
968#define PSA_ALG_AEAD_WITH_DEFAULT_TAG_LENGTH(alg) \
969 ( \
970 PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, PSA_ALG_CCM) \
971 PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, PSA_ALG_GCM) \
972 0)
973#define PSA__ALG_AEAD_WITH_DEFAULT_TAG_LENGTH__CASE(alg, ref) \
974 PSA_ALG_AEAD_WITH_TAG_LENGTH(alg, 0) == \
975 PSA_ALG_AEAD_WITH_TAG_LENGTH(ref, 0) ? \
976 ref :
977
Gilles Peskine55bf3d12018-06-26 15:53:48 +0200978#define PSA_ALG_RSA_PKCS1V15_SIGN_BASE ((psa_algorithm_t)0x10020000)
979/** RSA PKCS#1 v1.5 signature with hashing.
980 *
981 * This is the signature scheme defined by RFC 8017
982 * (PKCS#1: RSA Cryptography Specifications) under the name
983 * RSASSA-PKCS1-v1_5.
984 *
985 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +0200986 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
Gilles Peskine55bf3d12018-06-26 15:53:48 +0200987 *
988 * \return The corresponding RSA PKCS#1 v1.5 signature algorithm.
989 * \return Unspecified if \p alg is not a supported
990 * hash algorithm.
991 */
Gilles Peskinea5926232018-03-28 14:16:50 +0200992#define PSA_ALG_RSA_PKCS1V15_SIGN(hash_alg) \
Gilles Peskine55bf3d12018-06-26 15:53:48 +0200993 (PSA_ALG_RSA_PKCS1V15_SIGN_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
994/** Raw PKCS#1 v1.5 signature.
995 *
996 * The input to this algorithm is the DigestInfo structure used by
997 * RFC 8017 (PKCS#1: RSA Cryptography Specifications), &sect;9.2
998 * steps 3&ndash;6.
999 */
1000#define PSA_ALG_RSA_PKCS1V15_SIGN_RAW PSA_ALG_RSA_PKCS1V15_SIGN_BASE
Gilles Peskinea5926232018-03-28 14:16:50 +02001001#define PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) \
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001002 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PKCS1V15_SIGN_BASE)
Gilles Peskinedcd14942018-07-12 00:30:52 +02001003
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001004#define PSA_ALG_RSA_PSS_BASE ((psa_algorithm_t)0x10030000)
1005/** RSA PSS signature with hashing.
1006 *
1007 * This is the signature scheme defined by RFC 8017
1008 * (PKCS#1: RSA Cryptography Specifications) under the name
Gilles Peskinea4d20bd2018-06-29 23:35:02 +02001009 * RSASSA-PSS, with the message generation function MGF1, and with
1010 * a salt length equal to the length of the hash. The specified
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001011 * hash algorithm is used to hash the input message, to create the
1012 * salted hash, and for the mask generation.
1013 *
1014 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02001015 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001016 *
1017 * \return The corresponding RSA PSS signature algorithm.
1018 * \return Unspecified if \p alg is not a supported
1019 * hash algorithm.
1020 */
1021#define PSA_ALG_RSA_PSS(hash_alg) \
1022 (PSA_ALG_RSA_PSS_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1023#define PSA_ALG_IS_RSA_PSS(alg) \
1024 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_PSS_BASE)
1025
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001026#define PSA_ALG_DSA_BASE ((psa_algorithm_t)0x10040000)
1027/** DSA signature with hashing.
1028 *
1029 * This is the signature scheme defined by FIPS 186-4,
1030 * with a random per-message secret number (*k*).
1031 *
1032 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02001033 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001034 *
1035 * \return The corresponding DSA signature algorithm.
1036 * \return Unspecified if \p alg is not a supported
1037 * hash algorithm.
1038 */
1039#define PSA_ALG_DSA(hash_alg) \
1040 (PSA_ALG_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1041#define PSA_ALG_DETERMINISTIC_DSA_BASE ((psa_algorithm_t)0x10050000)
1042#define PSA_ALG_DSA_DETERMINISTIC_FLAG ((psa_algorithm_t)0x00010000)
1043#define PSA_ALG_DETERMINISTIC_DSA(hash_alg) \
1044 (PSA_ALG_DETERMINISTIC_DSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1045#define PSA_ALG_IS_DSA(alg) \
1046 (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \
1047 PSA_ALG_DSA_BASE)
1048#define PSA_ALG_DSA_IS_DETERMINISTIC(alg) \
1049 (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)
Gilles Peskine55728b02018-07-16 23:08:16 +02001050#define PSA_ALG_IS_DETERMINISTIC_DSA(alg) \
1051 (PSA_ALG_IS_DSA(alg) && PSA_ALG_DSA_IS_DETERMINISTIC(alg))
1052#define PSA_ALG_IS_RANDOMIZED_DSA(alg) \
1053 (PSA_ALG_IS_DSA(alg) && !PSA_ALG_DSA_IS_DETERMINISTIC(alg))
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001054
1055#define PSA_ALG_ECDSA_BASE ((psa_algorithm_t)0x10060000)
1056/** ECDSA signature with hashing.
1057 *
1058 * This is the ECDSA signature scheme defined by ANSI X9.62,
1059 * with a random per-message secret number (*k*).
1060 *
Gilles Peskineeae6eee2018-06-28 13:56:01 +02001061 * The representation of the signature as a byte string consists of
1062 * the concatentation of the signature values *r* and *s*. Each of
1063 * *r* and *s* is encoded as an *N*-octet string, where *N* is the length
1064 * of the base point of the curve in octets. Each value is represented
1065 * in big-endian order (most significant octet first).
1066 *
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001067 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02001068 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001069 *
1070 * \return The corresponding ECDSA signature algorithm.
1071 * \return Unspecified if \p alg is not a supported
1072 * hash algorithm.
1073 */
1074#define PSA_ALG_ECDSA(hash_alg) \
1075 (PSA_ALG_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1076/** ECDSA signature without hashing.
1077 *
Gilles Peskineeae6eee2018-06-28 13:56:01 +02001078 * This is the same signature scheme as #PSA_ALG_ECDSA(), but
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001079 * without specifying a hash algorithm. This algorithm may only be
1080 * used to sign or verify a sequence of bytes that should be an
1081 * already-calculated hash. Note that the input is padded with
1082 * zeros on the left or truncated on the left as required to fit
1083 * the curve size.
1084 */
1085#define PSA_ALG_ECDSA_ANY PSA_ALG_ECDSA_BASE
1086#define PSA_ALG_DETERMINISTIC_ECDSA_BASE ((psa_algorithm_t)0x10070000)
1087/** Deterministic ECDSA signature with hashing.
1088 *
1089 * This is the deterministic ECDSA signature scheme defined by RFC 6979.
1090 *
Gilles Peskineeae6eee2018-06-28 13:56:01 +02001091 * The representation of a signature is the same as with #PSA_ALG_ECDSA().
1092 *
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001093 * Note that when this algorithm is used for verification, signatures
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001094 * made with randomized ECDSA (#PSA_ALG_ECDSA(\p hash_alg)) with the
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001095 * same private key are accepted. In other words,
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001096 * #PSA_ALG_DETERMINISTIC_ECDSA(\p hash_alg) differs from
1097 * #PSA_ALG_ECDSA(\p hash_alg) only for signature, not for verification.
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001098 *
1099 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02001100 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001101 *
1102 * \return The corresponding deterministic ECDSA signature
1103 * algorithm.
1104 * \return Unspecified if \p alg is not a supported
1105 * hash algorithm.
1106 */
1107#define PSA_ALG_DETERMINISTIC_ECDSA(hash_alg) \
1108 (PSA_ALG_DETERMINISTIC_ECDSA_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1109#define PSA_ALG_IS_ECDSA(alg) \
1110 (((alg) & ~PSA_ALG_HASH_MASK & ~PSA_ALG_DSA_DETERMINISTIC_FLAG) == \
1111 PSA_ALG_ECDSA_BASE)
1112#define PSA_ALG_ECDSA_IS_DETERMINISTIC(alg) \
1113 (((alg) & PSA_ALG_DSA_DETERMINISTIC_FLAG) != 0)
Gilles Peskine55728b02018-07-16 23:08:16 +02001114#define PSA_ALG_IS_DETERMINISTIC_ECDSA(alg) \
1115 (PSA_ALG_IS_ECDSA(alg) && PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))
1116#define PSA_ALG_IS_RANDOMIZED_ECDSA(alg) \
1117 (PSA_ALG_IS_ECDSA(alg) && !PSA_ALG_ECDSA_IS_DETERMINISTIC(alg))
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001118
Gilles Peskine7ed29c52018-06-26 15:50:08 +02001119/** Get the hash used by a hash-and-sign signature algorithm.
1120 *
1121 * A hash-and-sign algorithm is a signature algorithm which is
1122 * composed of two phases: first a hashing phase which does not use
1123 * the key and produces a hash of the input message, then a signing
1124 * phase which only uses the hash and the key and not the message
1125 * itself.
1126 *
1127 * \param alg A signature algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02001128 * #PSA_ALG_IS_SIGN(\p alg) is true).
Gilles Peskine7ed29c52018-06-26 15:50:08 +02001129 *
1130 * \return The underlying hash algorithm if \p alg is a hash-and-sign
1131 * algorithm.
1132 * \return 0 if \p alg is a signature algorithm that does not
1133 * follow the hash-and-sign structure.
1134 * \return Unspecified if \p alg is not a signature algorithm or
1135 * if it is not supported by the implementation.
1136 */
1137#define PSA_ALG_SIGN_GET_HASH(alg) \
Gilles Peskinea81d85b2018-06-26 16:10:23 +02001138 (PSA_ALG_IS_RSA_PSS(alg) || PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || \
1139 PSA_ALG_IS_DSA(alg) || PSA_ALG_IS_ECDSA(alg) ? \
Gilles Peskine54622ae2018-06-29 22:24:24 +02001140 ((alg) & PSA_ALG_HASH_MASK) == 0 ? /*"raw" algorithm*/ 0 : \
Gilles Peskine7ed29c52018-06-26 15:50:08 +02001141 ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \
1142 0)
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001143
Gilles Peskinedcd14942018-07-12 00:30:52 +02001144/** RSA PKCS#1 v1.5 encryption.
1145 */
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001146#define PSA_ALG_RSA_PKCS1V15_CRYPT ((psa_algorithm_t)0x12020000)
Gilles Peskinedcd14942018-07-12 00:30:52 +02001147
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001148#define PSA_ALG_RSA_OAEP_BASE ((psa_algorithm_t)0x12030000)
Gilles Peskinedcd14942018-07-12 00:30:52 +02001149/** RSA OAEP encryption.
1150 *
1151 * This is the encryption scheme defined by RFC 8017
1152 * (PKCS#1: RSA Cryptography Specifications) under the name
1153 * RSAES-OAEP, with the message generation function MGF1.
1154 *
1155 * \param hash_alg The hash algorithm (\c PSA_ALG_XXX value such that
1156 * #PSA_ALG_IS_HASH(\p hash_alg) is true) to use
1157 * for MGF1.
1158 *
1159 * \return The corresponding RSA OAEP signature algorithm.
1160 * \return Unspecified if \p alg is not a supported
1161 * hash algorithm.
1162 */
Gilles Peskine55bf3d12018-06-26 15:53:48 +02001163#define PSA_ALG_RSA_OAEP(hash_alg) \
1164 (PSA_ALG_RSA_OAEP_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1165#define PSA_ALG_IS_RSA_OAEP(alg) \
1166 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_RSA_OAEP_BASE)
Gilles Peskine072ac562018-06-30 00:21:29 +02001167#define PSA_ALG_RSA_OAEP_GET_HASH(alg) \
1168 (PSA_ALG_IS_RSA_OAEP(alg) ? \
1169 ((alg) & PSA_ALG_HASH_MASK) | PSA_ALG_CATEGORY_HASH : \
1170 0)
Gilles Peskined1e8e412018-06-07 09:49:39 +02001171
Gilles Peskinebef7f142018-07-12 17:22:21 +02001172#define PSA_ALG_HKDF_BASE ((psa_algorithm_t)0x30000100)
1173/** Macro to build an HKDF algorithm.
1174 *
1175 * For example, `PSA_ALG_HKDF(PSA_ALG_SHA256)` is HKDF using HMAC-SHA-256.
1176 *
1177 * \param hash_alg A hash algorithm (\c PSA_ALG_XXX value such that
1178 * #PSA_ALG_IS_HASH(\p hash_alg) is true).
1179 *
1180 * \return The corresponding HKDF algorithm.
1181 * \return Unspecified if \p alg is not a supported
1182 * hash algorithm.
1183 */
1184#define PSA_ALG_HKDF(hash_alg) \
1185 (PSA_ALG_HKDF_BASE | ((hash_alg) & PSA_ALG_HASH_MASK))
1186/** Whether the specified algorithm is an HKDF algorithm.
1187 *
1188 * HKDF is a family of key derivation algorithms that are based on a hash
1189 * function and the HMAC construction.
1190 *
1191 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1192 *
1193 * \return 1 if \c alg is an HKDF algorithm, 0 otherwise.
1194 * This macro may return either 0 or 1 if \c alg is not a supported
1195 * key derivation algorithm identifier.
1196 */
1197#define PSA_ALG_IS_HKDF(alg) \
1198 (((alg) & ~PSA_ALG_HASH_MASK) == PSA_ALG_HKDF_BASE)
1199#define PSA_ALG_HKDF_GET_HASH(hkdf_alg) \
1200 (PSA_ALG_CATEGORY_HASH | ((hkdf_alg) & PSA_ALG_HASH_MASK))
1201
Gilles Peskinee8f0e3d2018-09-18 11:52:10 +02001202#define PSA_ALG_KEY_DERIVATION_MASK ((psa_algorithm_t)0x010fffff)
1203
1204/** Use a shared secret as is.
1205 *
1206 * Specify this algorithm as the selection component of a key agreement
1207 * to use the raw result of the key agreement as key material.
1208 *
1209 * \warning The raw result of a key agreement algorithm such as finite-field
1210 * Diffie-Hellman or elliptic curve Diffie-Hellman has biases and should
1211 * not be used directly as key material. It can however be used as the secret
1212 * input in a key derivation algorithm.
1213 */
1214#define PSA_ALG_SELECT_RAW ((psa_algorithm_t)0x31000001)
1215
1216#define PSA_ALG_KEY_AGREEMENT_GET_KDF(alg) \
1217 (((alg) & PSA_ALG_KEY_DERIVATION_MASK) | PSA_ALG_CATEGORY_KEY_DERIVATION)
1218
1219#define PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) \
1220 ((alg) & ~PSA_ALG_KEY_DERIVATION_MASK)
Gilles Peskine93098fd2018-09-18 11:54:43 +02001221
1222#define PSA_ALG_FFDH_BASE ((psa_algorithm_t)0x22100000)
1223/** The Diffie-Hellman key agreement algorithm.
1224 *
Gilles Peskine2607bca2018-10-25 22:21:03 +02001225 * This algorithm combines the finite-field Diffie-Hellman (DH) key
1226 * agreement, also known as Diffie-Hellman-Merkle (DHM) key agreement,
1227 * to produce a shared secret from a private key and the peer's
Gilles Peskine93098fd2018-09-18 11:54:43 +02001228 * public key, with a key selection or key derivation algorithm to produce
1229 * one or more shared keys and other shared cryptographic material.
1230 *
Gilles Peskine79dd6222018-10-25 22:22:11 +02001231 * The input to \p kdf_alg is the shared secret `g^{ab}` in big-endian format.
1232 * It is `ceiling(n / 8)` bytes long where `n` is the size of the prime `p`.
1233 *
Gilles Peskine93098fd2018-09-18 11:54:43 +02001234 * \param kdf_alg A key derivation algorithm (\c PSA_ALG_XXX value such
1235 * that #PSA_ALG_IS_KEY_DERIVATION(\p hash_alg) is true)
1236 * or a key selection algorithm (\c PSA_ALG_XXX value such
1237 * that #PSA_ALG_IS_SELECTION(\p hash_alg) is true).
1238 *
1239 * \return The Diffie-Hellman algorithm with the specified
1240 * selection or derivation algorithm.
1241 */
1242#define PSA_ALG_FFDH(kdf_alg) \
1243 (PSA_ALG_FFDH_BASE | ((kdf_alg) & PSA_ALG_KEY_DERIVATION_MASK))
1244/** Whether the specified algorithm is a finite field Diffie-Hellman algorithm.
1245 *
1246 * This includes every supported key selection or key agreement algorithm
1247 * for the output of the Diffie-Hellman calculation.
1248 *
1249 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1250 *
1251 * \return 1 if \c alg is a finite field Diffie-Hellman algorithm, 0 otherwise.
1252 * This macro may return either 0 or 1 if \c alg is not a supported
1253 * key agreement algorithm identifier.
1254 */
1255#define PSA_ALG_IS_FFDH(alg) \
1256 (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_FFDH_BASE)
1257
1258#define PSA_ALG_ECDH_BASE ((psa_algorithm_t)0x22200000)
Gilles Peskine2607bca2018-10-25 22:21:03 +02001259/** The elliptic curve Diffie-Hellman (ECDH) key agreement algorithm.
Gilles Peskine93098fd2018-09-18 11:54:43 +02001260 *
1261 * This algorithm combines the elliptic curve Diffie-Hellman key
1262 * agreement to produce a shared secret from a private key and the peer's
1263 * public key, with a key selection or key derivation algorithm to produce
1264 * one or more shared keys and other shared cryptographic material.
1265 *
Gilles Peskine7b5b4a02018-11-14 21:05:10 +01001266 * The shared secret produced by key agreement and passed as input to the
1267 * derivation or selection algorithm \p kdf_alg is the x-coordinate of
Gilles Peskine6c6a0232018-11-15 17:44:43 +01001268 * the shared secret point. It is always `ceiling(m / 8)` bytes long where
1269 * `m` is the bit size associated with the curve, i.e. the bit size of the
1270 * order of the curve's coordinate field. When `m` is not a multiple of 8,
Gilles Peskine7b5b4a02018-11-14 21:05:10 +01001271 * the byte containing the most significant bit of the shared secret
1272 * is padded with zero bits. The byte order is either little-endian
1273 * or big-endian depending on the curve type.
1274 *
1275 * - For Montgomery curves (curve types `PSA_ECC_CURVE_CURVEXXX`),
1276 * the shared secret is the x-coordinate of `d_A Q_B = d_B Q_A`
1277 * in little-endian byte order.
1278 * The bit size is 448 for Curve448 and 255 for Curve25519.
1279 * - For Weierstrass curves over prime fields (curve types
1280 * `PSA_ECC_CURVE_SECPXXX` and `PSA_ECC_CURVE_BRAINPOOL_PXXX`),
1281 * the shared secret is the x-coordinate of `d_A Q_B = d_B Q_A`
1282 * in big-endian byte order.
Gilles Peskine6c6a0232018-11-15 17:44:43 +01001283 * The bit size is `m = ceiling(log_2(p))` for the field `F_p`.
Gilles Peskine7b5b4a02018-11-14 21:05:10 +01001284 * - For Weierstrass curves over binary fields (curve types
1285 * `PSA_ECC_CURVE_SECTXXX`),
1286 * the shared secret is the x-coordinate of `d_A Q_B = d_B Q_A`
1287 * in big-endian byte order.
Gilles Peskine6c6a0232018-11-15 17:44:43 +01001288 * The bit size is `m` for the field `F_{2^m}`.
Gilles Peskine79dd6222018-10-25 22:22:11 +02001289 *
Gilles Peskine93098fd2018-09-18 11:54:43 +02001290 * \param kdf_alg A key derivation algorithm (\c PSA_ALG_XXX value such
1291 * that #PSA_ALG_IS_KEY_DERIVATION(\p hash_alg) is true)
1292 * or a selection algorithm (\c PSA_ALG_XXX value such
1293 * that #PSA_ALG_IS_KEY_SELECTION(\p hash_alg) is true).
1294 *
1295 * \return The Diffie-Hellman algorithm with the specified
1296 * selection or derivation algorithm.
1297 */
1298#define PSA_ALG_ECDH(kdf_alg) \
1299 (PSA_ALG_ECDH_BASE | ((kdf_alg) & PSA_ALG_KEY_DERIVATION_MASK))
1300/** Whether the specified algorithm is an elliptic curve Diffie-Hellman
1301 * algorithm.
1302 *
1303 * This includes every supported key selection or key agreement algorithm
1304 * for the output of the Diffie-Hellman calculation.
1305 *
1306 * \param alg An algorithm identifier (value of type #psa_algorithm_t).
1307 *
1308 * \return 1 if \c alg is an elliptic curve Diffie-Hellman algorithm,
1309 * 0 otherwise.
1310 * This macro may return either 0 or 1 if \c alg is not a supported
1311 * key agreement algorithm identifier.
1312 */
1313#define PSA_ALG_IS_ECDH(alg) \
1314 (PSA_ALG_KEY_AGREEMENT_GET_BASE(alg) == PSA_ALG_ECDH_BASE)
1315
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001316/**@}*/
1317
1318/** \defgroup key_management Key management
1319 * @{
1320 */
1321
1322/**
1323 * \brief Import a key in binary format.
1324 *
Gilles Peskinef5b9fa12018-03-07 16:40:18 +01001325 * This function supports any output from psa_export_key(). Refer to the
Gilles Peskinef7933932018-10-31 14:07:52 +01001326 * documentation of psa_export_public_key() for the format of public keys
1327 * and to the documentation of psa_export_key() for the format for
1328 * other key types.
1329 *
1330 * This specification supports a single format for each key type.
1331 * Implementations may support other formats as long as the standard
1332 * format is supported. Implementations that support other formats
1333 * should ensure that the formats are clearly unambiguous so as to
1334 * minimize the risk that an invalid input is accidentally interpreted
1335 * according to a different format.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001336 *
Gilles Peskine308b91d2018-02-08 09:47:44 +01001337 * \param key Slot where the key will be stored. This must be a
1338 * valid slot for a key of the chosen type. It must
1339 * be unoccupied.
Gilles Peskinef7933932018-10-31 14:07:52 +01001340 * \param type Key type (a \c PSA_KEY_TYPE_XXX value). On a successful
1341 * import, the key slot will contain a key of this type.
1342 * \param[in] data Buffer containing the key data. The content of this
1343 * buffer is interpreted according to \p type. It must
1344 * contain the format described in the documentation
1345 * of psa_export_key() or psa_export_public_key() for
1346 * the chosen type.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001347 * \param data_length Size of the \p data buffer in bytes.
Gilles Peskine308b91d2018-02-08 09:47:44 +01001348 *
Gilles Peskine28538492018-07-11 17:34:00 +02001349 * \retval #PSA_SUCCESS
Gilles Peskine308b91d2018-02-08 09:47:44 +01001350 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02001351 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskine65eb8582018-04-19 08:28:58 +02001352 * The key type or key size is not supported, either by the
1353 * implementation in general or in this particular slot.
Gilles Peskine28538492018-07-11 17:34:00 +02001354 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskine308b91d2018-02-08 09:47:44 +01001355 * The key slot is invalid,
1356 * or the key data is not correctly formatted.
Gilles Peskine28538492018-07-11 17:34:00 +02001357 * \retval #PSA_ERROR_OCCUPIED_SLOT
Gilles Peskine65eb8582018-04-19 08:28:58 +02001358 * There is already a key in the specified slot.
Gilles Peskine28538492018-07-11 17:34:00 +02001359 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
1360 * \retval #PSA_ERROR_INSUFFICIENT_STORAGE
1361 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1362 * \retval #PSA_ERROR_HARDWARE_FAILURE
1363 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001364 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001365 * The library has not been previously initialized by psa_crypto_init().
1366 * It is implementation-dependent whether a failure to initialize
1367 * results in this error code.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001368 */
1369psa_status_t psa_import_key(psa_key_slot_t key,
1370 psa_key_type_t type,
1371 const uint8_t *data,
1372 size_t data_length);
1373
1374/**
Gilles Peskine154bd952018-04-19 08:38:16 +02001375 * \brief Destroy a key and restore the slot to its default state.
1376 *
1377 * This function destroys the content of the key slot from both volatile
1378 * memory and, if applicable, non-volatile storage. Implementations shall
1379 * make a best effort to ensure that any previous content of the slot is
1380 * unrecoverable.
1381 *
1382 * This function also erases any metadata such as policies. It returns the
1383 * specified slot to its default state.
1384 *
1385 * \param key The key slot to erase.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001386 *
Gilles Peskine28538492018-07-11 17:34:00 +02001387 * \retval #PSA_SUCCESS
Gilles Peskine65eb8582018-04-19 08:28:58 +02001388 * The slot's content, if any, has been erased.
Gilles Peskine28538492018-07-11 17:34:00 +02001389 * \retval #PSA_ERROR_NOT_PERMITTED
Gilles Peskine65eb8582018-04-19 08:28:58 +02001390 * The slot holds content and cannot be erased because it is
1391 * read-only, either due to a policy or due to physical restrictions.
Gilles Peskine28538492018-07-11 17:34:00 +02001392 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskine65eb8582018-04-19 08:28:58 +02001393 * The specified slot number does not designate a valid slot.
Gilles Peskine28538492018-07-11 17:34:00 +02001394 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
Gilles Peskine65eb8582018-04-19 08:28:58 +02001395 * There was an failure in communication with the cryptoprocessor.
1396 * The key material may still be present in the cryptoprocessor.
Gilles Peskine28538492018-07-11 17:34:00 +02001397 * \retval #PSA_ERROR_STORAGE_FAILURE
Gilles Peskine65eb8582018-04-19 08:28:58 +02001398 * The storage is corrupted. Implementations shall make a best effort
1399 * to erase key material even in this stage, however applications
1400 * should be aware that it may be impossible to guarantee that the
1401 * key material is not recoverable in such cases.
Gilles Peskine28538492018-07-11 17:34:00 +02001402 * \retval #PSA_ERROR_TAMPERING_DETECTED
Gilles Peskine65eb8582018-04-19 08:28:58 +02001403 * An unexpected condition which is not a storage corruption or
1404 * a communication failure occurred. The cryptoprocessor may have
1405 * been compromised.
itayzafrir90d8c7a2018-09-12 11:44:52 +03001406 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001407 * The library has not been previously initialized by psa_crypto_init().
1408 * It is implementation-dependent whether a failure to initialize
1409 * results in this error code.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001410 */
1411psa_status_t psa_destroy_key(psa_key_slot_t key);
1412
1413/**
1414 * \brief Get basic metadata about a key.
1415 *
Gilles Peskine308b91d2018-02-08 09:47:44 +01001416 * \param key Slot whose content is queried. This must
1417 * be an occupied key slot.
Gilles Peskineedd11a12018-07-12 01:08:58 +02001418 * \param[out] type On success, the key type (a \c PSA_KEY_TYPE_XXX value).
Gilles Peskine308b91d2018-02-08 09:47:44 +01001419 * This may be a null pointer, in which case the key type
1420 * is not written.
Gilles Peskineedd11a12018-07-12 01:08:58 +02001421 * \param[out] bits On success, the key size in bits.
Gilles Peskine9a1ba0d2018-03-21 20:49:16 +01001422 * This may be a null pointer, in which case the key size
Gilles Peskine308b91d2018-02-08 09:47:44 +01001423 * is not written.
1424 *
Gilles Peskine28538492018-07-11 17:34:00 +02001425 * \retval #PSA_SUCCESS
1426 * \retval #PSA_ERROR_EMPTY_SLOT
1427 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1428 * \retval #PSA_ERROR_HARDWARE_FAILURE
1429 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001430 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001431 * The library has not been previously initialized by psa_crypto_init().
1432 * It is implementation-dependent whether a failure to initialize
1433 * results in this error code.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001434 */
1435psa_status_t psa_get_key_information(psa_key_slot_t key,
1436 psa_key_type_t *type,
1437 size_t *bits);
1438
1439/**
1440 * \brief Export a key in binary format.
1441 *
1442 * The output of this function can be passed to psa_import_key() to
1443 * create an equivalent object.
1444 *
Gilles Peskinef7933932018-10-31 14:07:52 +01001445 * If the implementation of psa_import_key() supports other formats
1446 * beyond the format specified here, the output from psa_export_key()
1447 * must use the representation specified here, not the original
1448 * representation.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001449 *
Gilles Peskine308b91d2018-02-08 09:47:44 +01001450 * For standard key types, the output format is as follows:
1451 *
1452 * - For symmetric keys (including MAC keys), the format is the
1453 * raw bytes of the key.
1454 * - For DES, the key data consists of 8 bytes. The parity bits must be
1455 * correct.
1456 * - For Triple-DES, the format is the concatenation of the
1457 * two or three DES keys.
Gilles Peskine92b30732018-03-03 21:29:30 +01001458 * - For RSA key pairs (#PSA_KEY_TYPE_RSA_KEYPAIR), the format
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001459 * is the non-encrypted DER encoding of the representation defined by
1460 * PKCS\#1 (RFC 8017) as `RSAPrivateKey`, version 0.
1461 * ```
1462 * RSAPrivateKey ::= SEQUENCE {
Gilles Peskine4f6c77b2018-08-11 01:17:53 +02001463 * version INTEGER, -- must be 0
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001464 * modulus INTEGER, -- n
1465 * publicExponent INTEGER, -- e
1466 * privateExponent INTEGER, -- d
1467 * prime1 INTEGER, -- p
1468 * prime2 INTEGER, -- q
1469 * exponent1 INTEGER, -- d mod (p-1)
1470 * exponent2 INTEGER, -- d mod (q-1)
1471 * coefficient INTEGER, -- (inverse of q) mod p
1472 * }
1473 * ```
1474 * - For DSA private keys (#PSA_KEY_TYPE_DSA_KEYPAIR), the format
1475 * is the non-encrypted DER encoding of the representation used by
Gilles Peskinec6290c02018-08-13 17:24:59 +02001476 * OpenSSL and OpenSSH, whose structure is described in ASN.1 as follows:
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001477 * ```
1478 * DSAPrivateKey ::= SEQUENCE {
Gilles Peskine4f6c77b2018-08-11 01:17:53 +02001479 * version INTEGER, -- must be 0
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001480 * prime INTEGER, -- p
1481 * subprime INTEGER, -- q
1482 * generator INTEGER, -- g
1483 * public INTEGER, -- y
1484 * private INTEGER, -- x
1485 * }
1486 * ```
1487 * - For elliptic curve key pairs (key types for which
Gilles Peskinef76aa772018-10-29 19:24:33 +01001488 * #PSA_KEY_TYPE_IS_ECC_KEYPAIR is true), the format is
Gilles Peskine6c6a0232018-11-15 17:44:43 +01001489 * a representation of the private value as a `ceiling(m/8)`-byte string
1490 * where `m` is the bit size associated with the curve, i.e. the bit size
1491 * of the order of the curve's coordinate field. This byte string is
1492 * in little-endian order for Montgomery curves (curve types
1493 * `PSA_ECC_CURVE_CURVEXXX`), and in big-endian order for Weierstrass
1494 * curves (curve types `PSA_ECC_CURVE_SECTXXX`, `PSA_ECC_CURVE_SECPXXX`
1495 * and `PSA_ECC_CURVE_BRAINPOOL_PXXX`).
Gilles Peskinef76aa772018-10-29 19:24:33 +01001496 * This is the content of the `privateKey` field of the `ECPrivateKey`
1497 * format defined by RFC 5915.
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001498 * - For public keys (key types for which #PSA_KEY_TYPE_IS_PUBLIC_KEY is
1499 * true), the format is the same as for psa_export_public_key().
Gilles Peskine308b91d2018-02-08 09:47:44 +01001500 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02001501 * \param key Slot whose content is to be exported. This must
1502 * be an occupied key slot.
1503 * \param[out] data Buffer where the key data is to be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001504 * \param data_size Size of the \p data buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02001505 * \param[out] data_length On success, the number of bytes
1506 * that make up the key data.
Gilles Peskine308b91d2018-02-08 09:47:44 +01001507 *
Gilles Peskine28538492018-07-11 17:34:00 +02001508 * \retval #PSA_SUCCESS
1509 * \retval #PSA_ERROR_EMPTY_SLOT
1510 * \retval #PSA_ERROR_NOT_PERMITTED
Darryl Green9e2d7a02018-07-24 16:33:30 +01001511 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskine1be949b2018-08-10 19:06:59 +02001512 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
1513 * The size of the \p data buffer is too small. You can determine a
1514 * sufficient buffer size by calling
1515 * #PSA_KEY_EXPORT_MAX_SIZE(\c type, \c bits)
1516 * where \c type is the key type
1517 * and \c bits is the key size in bits.
Gilles Peskine28538492018-07-11 17:34:00 +02001518 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1519 * \retval #PSA_ERROR_HARDWARE_FAILURE
1520 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001521 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001522 * The library has not been previously initialized by psa_crypto_init().
1523 * It is implementation-dependent whether a failure to initialize
1524 * results in this error code.
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01001525 */
1526psa_status_t psa_export_key(psa_key_slot_t key,
1527 uint8_t *data,
1528 size_t data_size,
1529 size_t *data_length);
1530
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001531/**
1532 * \brief Export a public key or the public part of a key pair in binary format.
1533 *
1534 * The output of this function can be passed to psa_import_key() to
1535 * create an object that is equivalent to the public key.
1536 *
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001537 * The format is the DER representation defined by RFC 5280 as
1538 * `SubjectPublicKeyInfo`, with the `subjectPublicKey` format
1539 * specified below.
1540 * ```
1541 * SubjectPublicKeyInfo ::= SEQUENCE {
1542 * algorithm AlgorithmIdentifier,
1543 * subjectPublicKey BIT STRING }
1544 * AlgorithmIdentifier ::= SEQUENCE {
1545 * algorithm OBJECT IDENTIFIER,
1546 * parameters ANY DEFINED BY algorithm OPTIONAL }
1547 * ```
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001548 *
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001549 * - For RSA public keys (#PSA_KEY_TYPE_RSA_PUBLIC_KEY),
1550 * the `subjectPublicKey` format is defined by RFC 3279 &sect;2.3.1 as
1551 * `RSAPublicKey`,
1552 * with the OID `rsaEncryption`,
1553 * and with the parameters `NULL`.
1554 * ```
1555 * pkcs-1 OBJECT IDENTIFIER ::= { iso(1) member-body(2) us(840)
1556 * rsadsi(113549) pkcs(1) 1 }
1557 * rsaEncryption OBJECT IDENTIFIER ::= { pkcs-1 1 }
1558 *
1559 * RSAPublicKey ::= SEQUENCE {
1560 * modulus INTEGER, -- n
1561 * publicExponent INTEGER } -- e
1562 * ```
1563 * - For DSA public keys (#PSA_KEY_TYPE_DSA_PUBLIC_KEY),
1564 * the `subjectPublicKey` format is defined by RFC 3279 &sect;2.3.2 as
1565 * `DSAPublicKey`,
1566 * with the OID `id-dsa`,
1567 * and with the parameters `DSS-Parms`.
1568 * ```
1569 * id-dsa OBJECT IDENTIFIER ::= {
1570 * iso(1) member-body(2) us(840) x9-57(10040) x9cm(4) 1 }
1571 *
1572 * Dss-Parms ::= SEQUENCE {
1573 * p INTEGER,
1574 * q INTEGER,
1575 * g INTEGER }
1576 * DSAPublicKey ::= INTEGER -- public key, Y
1577 * ```
1578 * - For elliptic curve public keys (key types for which
1579 * #PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY is true),
1580 * the `subjectPublicKey` format is defined by RFC 3279 &sect;2.3.5 as
Gilles Peskine4f6c77b2018-08-11 01:17:53 +02001581 * `ECPoint`, which contains the uncompressed
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001582 * representation defined by SEC1 &sect;2.3.3.
1583 * The OID is `id-ecPublicKey`,
Gilles Peskine4f6c77b2018-08-11 01:17:53 +02001584 * and the parameters must be given as a `namedCurve` OID as specified in
Gilles Peskinec6290c02018-08-13 17:24:59 +02001585 * RFC 5480 &sect;2.1.1.1 or other applicable standards.
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001586 * ```
1587 * ansi-X9-62 OBJECT IDENTIFIER ::=
1588 * { iso(1) member-body(2) us(840) 10045 }
1589 * id-public-key-type OBJECT IDENTIFIER ::= { ansi-X9.62 2 }
1590 * id-ecPublicKey OBJECT IDENTIFIER ::= { id-publicKeyType 1 }
1591 *
Gilles Peskine4f6c77b2018-08-11 01:17:53 +02001592 * ECPoint ::= ...
1593 * -- first 8 bits: 0x04;
Gilles Peskine6c6a0232018-11-15 17:44:43 +01001594 * -- then x_P as a `ceiling(m/8)`-byte string, big endian;
1595 * -- then y_P as a `ceiling(m/8)`-byte string, big endian;
1596 * -- where `m` is the bit size associated with the curve,
Gilles Peskine7b5b4a02018-11-14 21:05:10 +01001597 * -- i.e. the bit size of `q` for a curve over `F_q`.
Gilles Peskine4e1e9be2018-08-10 18:57:40 +02001598 *
1599 * EcpkParameters ::= CHOICE { -- other choices are not allowed
1600 * namedCurve OBJECT IDENTIFIER }
1601 * ```
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001602 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02001603 * \param key Slot whose content is to be exported. This must
1604 * be an occupied key slot.
1605 * \param[out] data Buffer where the key data is to be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001606 * \param data_size Size of the \p data buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02001607 * \param[out] data_length On success, the number of bytes
1608 * that make up the key data.
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001609 *
Gilles Peskine28538492018-07-11 17:34:00 +02001610 * \retval #PSA_SUCCESS
1611 * \retval #PSA_ERROR_EMPTY_SLOT
1612 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskine1be949b2018-08-10 19:06:59 +02001613 * The key is neither a public key nor a key pair.
1614 * \retval #PSA_ERROR_NOT_SUPPORTED
1615 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
1616 * The size of the \p data buffer is too small. You can determine a
1617 * sufficient buffer size by calling
1618 * #PSA_KEY_EXPORT_MAX_SIZE(#PSA_KEY_TYPE_PUBLIC_KEY_OF_KEYPAIR(\c type), \c bits)
1619 * where \c type is the key type
1620 * and \c bits is the key size in bits.
Gilles Peskine28538492018-07-11 17:34:00 +02001621 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1622 * \retval #PSA_ERROR_HARDWARE_FAILURE
1623 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001624 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001625 * The library has not been previously initialized by psa_crypto_init().
1626 * It is implementation-dependent whether a failure to initialize
1627 * results in this error code.
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001628 */
1629psa_status_t psa_export_public_key(psa_key_slot_t key,
1630 uint8_t *data,
1631 size_t data_size,
1632 size_t *data_length);
1633
1634/**@}*/
1635
1636/** \defgroup policy Key policies
1637 * @{
1638 */
1639
1640/** \brief Encoding of permitted usage on a key. */
1641typedef uint32_t psa_key_usage_t;
1642
Gilles Peskine7e198532018-03-08 07:50:30 +01001643/** Whether the key may be exported.
1644 *
1645 * A public key or the public part of a key pair may always be exported
1646 * regardless of the value of this permission flag.
1647 *
1648 * If a key does not have export permission, implementations shall not
1649 * allow the key to be exported in plain form from the cryptoprocessor,
1650 * whether through psa_export_key() or through a proprietary interface.
1651 * The key may however be exportable in a wrapped form, i.e. in a form
1652 * where it is encrypted by another key.
1653 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001654#define PSA_KEY_USAGE_EXPORT ((psa_key_usage_t)0x00000001)
1655
Gilles Peskine7e198532018-03-08 07:50:30 +01001656/** Whether the key may be used to encrypt a message.
1657 *
Gilles Peskinedcd14942018-07-12 00:30:52 +02001658 * This flag allows the key to be used for a symmetric encryption operation,
1659 * for an AEAD encryption-and-authentication operation,
1660 * or for an asymmetric encryption operation,
1661 * if otherwise permitted by the key's type and policy.
1662 *
Gilles Peskine7e198532018-03-08 07:50:30 +01001663 * For a key pair, this concerns the public key.
1664 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001665#define PSA_KEY_USAGE_ENCRYPT ((psa_key_usage_t)0x00000100)
Gilles Peskine7e198532018-03-08 07:50:30 +01001666
1667/** Whether the key may be used to decrypt a message.
1668 *
Gilles Peskinedcd14942018-07-12 00:30:52 +02001669 * This flag allows the key to be used for a symmetric decryption operation,
1670 * for an AEAD decryption-and-verification operation,
1671 * or for an asymmetric decryption operation,
1672 * if otherwise permitted by the key's type and policy.
1673 *
Gilles Peskine7e198532018-03-08 07:50:30 +01001674 * For a key pair, this concerns the private key.
1675 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001676#define PSA_KEY_USAGE_DECRYPT ((psa_key_usage_t)0x00000200)
Gilles Peskine7e198532018-03-08 07:50:30 +01001677
1678/** Whether the key may be used to sign a message.
1679 *
Gilles Peskinedcd14942018-07-12 00:30:52 +02001680 * This flag allows the key to be used for a MAC calculation operation
1681 * or for an asymmetric signature operation,
1682 * if otherwise permitted by the key's type and policy.
1683 *
Gilles Peskine7e198532018-03-08 07:50:30 +01001684 * For a key pair, this concerns the private key.
1685 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001686#define PSA_KEY_USAGE_SIGN ((psa_key_usage_t)0x00000400)
Gilles Peskine7e198532018-03-08 07:50:30 +01001687
1688/** Whether the key may be used to verify a message signature.
1689 *
Gilles Peskinedcd14942018-07-12 00:30:52 +02001690 * This flag allows the key to be used for a MAC verification operation
1691 * or for an asymmetric signature verification operation,
1692 * if otherwise permitted by by the key's type and policy.
1693 *
Gilles Peskine7e198532018-03-08 07:50:30 +01001694 * For a key pair, this concerns the public key.
1695 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001696#define PSA_KEY_USAGE_VERIFY ((psa_key_usage_t)0x00000800)
1697
Gilles Peskineea0fb492018-07-12 17:17:20 +02001698/** Whether the key may be used to derive other keys.
1699 */
1700#define PSA_KEY_USAGE_DERIVE ((psa_key_usage_t)0x00001000)
1701
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001702/** The type of the key policy data structure.
1703 *
1704 * This is an implementation-defined \c struct. Applications should not
1705 * make any assumptions about the content of this structure except
1706 * as directed by the documentation of a specific implementation. */
1707typedef struct psa_key_policy_s psa_key_policy_t;
1708
1709/** \brief Initialize a key policy structure to a default that forbids all
Gilles Peskine6ac73a92018-07-12 19:47:19 +02001710 * usage of the key.
1711 *
1712 * \param[out] policy The policy object to initialize.
1713 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001714void psa_key_policy_init(psa_key_policy_t *policy);
1715
Gilles Peskine7e198532018-03-08 07:50:30 +01001716/** \brief Set the standard fields of a policy structure.
1717 *
1718 * Note that this function does not make any consistency check of the
1719 * parameters. The values are only checked when applying the policy to
1720 * a key slot with psa_set_key_policy().
Gilles Peskine6ac73a92018-07-12 19:47:19 +02001721 *
1722 * \param[out] policy The policy object to modify.
1723 * \param usage The permitted uses for the key.
1724 * \param alg The algorithm that the key may be used for.
Gilles Peskine7e198532018-03-08 07:50:30 +01001725 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001726void psa_key_policy_set_usage(psa_key_policy_t *policy,
1727 psa_key_usage_t usage,
1728 psa_algorithm_t alg);
1729
Gilles Peskine6ac73a92018-07-12 19:47:19 +02001730/** \brief Retrieve the usage field of a policy structure.
1731 *
1732 * \param[in] policy The policy object to query.
1733 *
1734 * \return The permitted uses for a key with this policy.
1735 */
Gilles Peskineaa7bc472018-07-12 00:54:56 +02001736psa_key_usage_t psa_key_policy_get_usage(const psa_key_policy_t *policy);
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001737
Gilles Peskine6ac73a92018-07-12 19:47:19 +02001738/** \brief Retrieve the algorithm field of a policy structure.
1739 *
1740 * \param[in] policy The policy object to query.
1741 *
1742 * \return The permitted algorithm for a key with this policy.
1743 */
Gilles Peskineaa7bc472018-07-12 00:54:56 +02001744psa_algorithm_t psa_key_policy_get_algorithm(const psa_key_policy_t *policy);
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001745
1746/** \brief Set the usage policy on a key slot.
1747 *
1748 * This function must be called on an empty key slot, before importing,
1749 * generating or creating a key in the slot. Changing the policy of an
1750 * existing key is not permitted.
Gilles Peskine7e198532018-03-08 07:50:30 +01001751 *
1752 * Implementations may set restrictions on supported key policies
1753 * depending on the key type and the key slot.
Gilles Peskine6ac73a92018-07-12 19:47:19 +02001754 *
1755 * \param key The key slot whose policy is to be changed.
1756 * \param[in] policy The policy object to query.
1757 *
1758 * \retval #PSA_SUCCESS
1759 * \retval #PSA_ERROR_OCCUPIED_SLOT
1760 * \retval #PSA_ERROR_NOT_SUPPORTED
1761 * \retval #PSA_ERROR_INVALID_ARGUMENT
1762 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1763 * \retval #PSA_ERROR_HARDWARE_FAILURE
1764 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001765 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001766 * The library has not been previously initialized by psa_crypto_init().
1767 * It is implementation-dependent whether a failure to initialize
1768 * results in this error code.
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001769 */
1770psa_status_t psa_set_key_policy(psa_key_slot_t key,
1771 const psa_key_policy_t *policy);
1772
Gilles Peskine7e198532018-03-08 07:50:30 +01001773/** \brief Get the usage policy for a key slot.
Gilles Peskine6ac73a92018-07-12 19:47:19 +02001774 *
1775 * \param key The key slot whose policy is being queried.
1776 * \param[out] policy On success, the key's policy.
1777 *
1778 * \retval #PSA_SUCCESS
1779 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1780 * \retval #PSA_ERROR_HARDWARE_FAILURE
1781 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001782 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001783 * The library has not been previously initialized by psa_crypto_init().
1784 * It is implementation-dependent whether a failure to initialize
1785 * results in this error code.
Gilles Peskine7e198532018-03-08 07:50:30 +01001786 */
Gilles Peskine7698bcf2018-03-03 21:30:44 +01001787psa_status_t psa_get_key_policy(psa_key_slot_t key,
1788 psa_key_policy_t *policy);
Gilles Peskine20035e32018-02-03 22:44:14 +01001789
1790/**@}*/
1791
Gilles Peskine609b6a52018-03-03 21:31:50 +01001792/** \defgroup persistence Key lifetime
1793 * @{
1794 */
1795
1796/** Encoding of key lifetimes.
1797 */
1798typedef uint32_t psa_key_lifetime_t;
1799
1800/** A volatile key slot retains its content as long as the application is
1801 * running. It is guaranteed to be erased on a power reset.
1802 */
1803#define PSA_KEY_LIFETIME_VOLATILE ((psa_key_lifetime_t)0x00000000)
1804
1805/** A persistent key slot retains its content as long as it is not explicitly
1806 * destroyed.
1807 */
1808#define PSA_KEY_LIFETIME_PERSISTENT ((psa_key_lifetime_t)0x00000001)
1809
1810/** A write-once key slot may not be modified once a key has been set.
1811 * It will retain its content as long as the device remains operational.
1812 */
1813#define PSA_KEY_LIFETIME_WRITE_ONCE ((psa_key_lifetime_t)0x7fffffff)
1814
Gilles Peskined393e182018-03-08 07:49:16 +01001815/** \brief Retrieve the lifetime of a key slot.
1816 *
1817 * The assignment of lifetimes to slots is implementation-dependent.
Gilles Peskine8ca56022018-04-17 14:07:59 +02001818 *
Gilles Peskine9bb53d72018-04-17 14:09:24 +02001819 * \param key Slot to query.
Gilles Peskineedd11a12018-07-12 01:08:58 +02001820 * \param[out] lifetime On success, the lifetime value.
Gilles Peskine8ca56022018-04-17 14:07:59 +02001821 *
Gilles Peskine28538492018-07-11 17:34:00 +02001822 * \retval #PSA_SUCCESS
mohammad1603804cd712018-03-20 22:44:08 +02001823 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02001824 * \retval #PSA_ERROR_INVALID_ARGUMENT
mohammad1603a7d245a2018-04-17 00:40:08 -07001825 * The key slot is invalid.
Gilles Peskine28538492018-07-11 17:34:00 +02001826 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1827 * \retval #PSA_ERROR_HARDWARE_FAILURE
1828 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001829 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001830 * The library has not been previously initialized by psa_crypto_init().
1831 * It is implementation-dependent whether a failure to initialize
1832 * results in this error code.
Gilles Peskined393e182018-03-08 07:49:16 +01001833 */
Gilles Peskine609b6a52018-03-03 21:31:50 +01001834psa_status_t psa_get_key_lifetime(psa_key_slot_t key,
1835 psa_key_lifetime_t *lifetime);
1836
Gilles Peskined393e182018-03-08 07:49:16 +01001837/** \brief Change the lifetime of a key slot.
1838 *
1839 * Whether the lifetime of a key slot can be changed at all, and if so
Gilles Peskine19067982018-03-20 17:54:53 +01001840 * whether the lifetime of an occupied key slot can be changed, is
Gilles Peskined393e182018-03-08 07:49:16 +01001841 * implementation-dependent.
Gilles Peskine8ca56022018-04-17 14:07:59 +02001842 *
Gilles Peskine9bb53d72018-04-17 14:09:24 +02001843 * \param key Slot whose lifetime is to be changed.
1844 * \param lifetime The lifetime value to set for the given key slot.
Gilles Peskine8ca56022018-04-17 14:07:59 +02001845 *
Gilles Peskine28538492018-07-11 17:34:00 +02001846 * \retval #PSA_SUCCESS
mohammad1603804cd712018-03-20 22:44:08 +02001847 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02001848 * \retval #PSA_ERROR_INVALID_ARGUMENT
mohammad1603804cd712018-03-20 22:44:08 +02001849 * The key slot is invalid,
mohammad1603a7d245a2018-04-17 00:40:08 -07001850 * or the lifetime value is invalid.
Gilles Peskine28538492018-07-11 17:34:00 +02001851 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinef0c9dd32018-04-17 14:11:07 +02001852 * The implementation does not support the specified lifetime value,
1853 * at least for the specified key slot.
Gilles Peskine28538492018-07-11 17:34:00 +02001854 * \retval #PSA_ERROR_OCCUPIED_SLOT
Gilles Peskinef0c9dd32018-04-17 14:11:07 +02001855 * The slot contains a key, and the implementation does not support
1856 * changing the lifetime of an occupied slot.
Gilles Peskine28538492018-07-11 17:34:00 +02001857 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1858 * \retval #PSA_ERROR_HARDWARE_FAILURE
1859 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03001860 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03001861 * The library has not been previously initialized by psa_crypto_init().
1862 * It is implementation-dependent whether a failure to initialize
1863 * results in this error code.
Gilles Peskined393e182018-03-08 07:49:16 +01001864 */
1865psa_status_t psa_set_key_lifetime(psa_key_slot_t key,
mohammad1603ea050092018-04-17 00:31:34 -07001866 psa_key_lifetime_t lifetime);
Gilles Peskined393e182018-03-08 07:49:16 +01001867
Gilles Peskine609b6a52018-03-03 21:31:50 +01001868/**@}*/
1869
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001870/** \defgroup hash Message digests
1871 * @{
1872 */
1873
Gilles Peskine308b91d2018-02-08 09:47:44 +01001874/** The type of the state data structure for multipart hash operations.
1875 *
Gilles Peskine92b30732018-03-03 21:29:30 +01001876 * This is an implementation-defined \c struct. Applications should not
Gilles Peskine308b91d2018-02-08 09:47:44 +01001877 * make any assumptions about the content of this structure except
1878 * as directed by the documentation of a specific implementation. */
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001879typedef struct psa_hash_operation_s psa_hash_operation_t;
1880
Gilles Peskine308b91d2018-02-08 09:47:44 +01001881/** The size of the output of psa_hash_finish(), in bytes.
1882 *
1883 * This is also the hash size that psa_hash_verify() expects.
1884 *
1885 * \param alg A hash algorithm (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02001886 * #PSA_ALG_IS_HASH(\p alg) is true), or an HMAC algorithm
Gilles Peskinebe42f312018-07-13 14:38:15 +02001887 * (#PSA_ALG_HMAC(\c hash_alg) where \c hash_alg is a
Gilles Peskine35855962018-04-19 08:39:16 +02001888 * hash algorithm).
Gilles Peskine308b91d2018-02-08 09:47:44 +01001889 *
1890 * \return The hash size for the specified hash algorithm.
1891 * If the hash algorithm is not recognized, return 0.
1892 * An implementation may return either 0 or the correct size
1893 * for a hash algorithm that it recognizes, but does not support.
1894 */
Gilles Peskine7ed29c52018-06-26 15:50:08 +02001895#define PSA_HASH_SIZE(alg) \
1896 ( \
Gilles Peskine00709fa2018-08-22 18:25:41 +02001897 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD2 ? 16 : \
1898 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD4 ? 16 : \
1899 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_MD5 ? 16 : \
1900 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_RIPEMD160 ? 20 : \
1901 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_1 ? 20 : \
1902 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_224 ? 28 : \
1903 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_256 ? 32 : \
1904 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_384 ? 48 : \
1905 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512 ? 64 : \
1906 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_224 ? 28 : \
1907 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA_512_256 ? 32 : \
1908 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_224 ? 28 : \
1909 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_256 ? 32 : \
1910 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_384 ? 48 : \
1911 PSA_ALG_HMAC_GET_HASH(alg) == PSA_ALG_SHA3_512 ? 64 : \
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001912 0)
1913
Gilles Peskine308b91d2018-02-08 09:47:44 +01001914/** Start a multipart hash operation.
1915 *
1916 * The sequence of operations to calculate a hash (message digest)
1917 * is as follows:
1918 * -# Allocate an operation object which will be passed to all the functions
1919 * listed here.
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001920 * -# Call psa_hash_setup() to specify the algorithm.
Gilles Peskine7e4acc52018-02-16 21:24:11 +01001921 * -# Call psa_hash_update() zero, one or more times, passing a fragment
Gilles Peskine308b91d2018-02-08 09:47:44 +01001922 * of the message each time. The hash that is calculated is the hash
1923 * of the concatenation of these messages in order.
1924 * -# To calculate the hash, call psa_hash_finish().
1925 * To compare the hash with an expected value, call psa_hash_verify().
1926 *
1927 * The application may call psa_hash_abort() at any time after the operation
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001928 * has been initialized with psa_hash_setup().
Gilles Peskine308b91d2018-02-08 09:47:44 +01001929 *
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001930 * After a successful call to psa_hash_setup(), the application must
Gilles Peskineed522972018-03-20 17:54:15 +01001931 * eventually terminate the operation. The following events terminate an
1932 * operation:
Gilles Peskine308b91d2018-02-08 09:47:44 +01001933 * - A failed call to psa_hash_update().
Gilles Peskine19067982018-03-20 17:54:53 +01001934 * - A call to psa_hash_finish(), psa_hash_verify() or psa_hash_abort().
Gilles Peskine308b91d2018-02-08 09:47:44 +01001935 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02001936 * \param[out] operation The operation object to use.
1937 * \param alg The hash algorithm to compute (\c PSA_ALG_XXX value
1938 * such that #PSA_ALG_IS_HASH(\p alg) is true).
Gilles Peskine308b91d2018-02-08 09:47:44 +01001939 *
Gilles Peskine28538492018-07-11 17:34:00 +02001940 * \retval #PSA_SUCCESS
Gilles Peskine308b91d2018-02-08 09:47:44 +01001941 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02001942 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001943 * \p alg is not supported or is not a hash algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02001944 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
1945 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1946 * \retval #PSA_ERROR_HARDWARE_FAILURE
1947 * \retval #PSA_ERROR_TAMPERING_DETECTED
Gilles Peskine308b91d2018-02-08 09:47:44 +01001948 */
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001949psa_status_t psa_hash_setup(psa_hash_operation_t *operation,
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001950 psa_algorithm_t alg);
1951
Gilles Peskine308b91d2018-02-08 09:47:44 +01001952/** Add a message fragment to a multipart hash operation.
1953 *
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001954 * The application must call psa_hash_setup() before calling this function.
Gilles Peskine308b91d2018-02-08 09:47:44 +01001955 *
1956 * If this function returns an error status, the operation becomes inactive.
1957 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02001958 * \param[in,out] operation Active hash operation.
1959 * \param[in] input Buffer containing the message fragment to hash.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02001960 * \param input_length Size of the \p input buffer in bytes.
Gilles Peskine308b91d2018-02-08 09:47:44 +01001961 *
Gilles Peskine28538492018-07-11 17:34:00 +02001962 * \retval #PSA_SUCCESS
Gilles Peskine308b91d2018-02-08 09:47:44 +01001963 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02001964 * \retval #PSA_ERROR_BAD_STATE
Gilles Peskine308b91d2018-02-08 09:47:44 +01001965 * The operation state is not valid (not started, or already completed).
Gilles Peskine28538492018-07-11 17:34:00 +02001966 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
1967 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
1968 * \retval #PSA_ERROR_HARDWARE_FAILURE
1969 * \retval #PSA_ERROR_TAMPERING_DETECTED
Gilles Peskine308b91d2018-02-08 09:47:44 +01001970 */
Gilles Peskine9ef733f2018-02-07 21:05:37 +01001971psa_status_t psa_hash_update(psa_hash_operation_t *operation,
1972 const uint8_t *input,
1973 size_t input_length);
1974
Gilles Peskine308b91d2018-02-08 09:47:44 +01001975/** Finish the calculation of the hash of a message.
1976 *
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02001977 * The application must call psa_hash_setup() before calling this function.
Gilles Peskine308b91d2018-02-08 09:47:44 +01001978 * This function calculates the hash of the message formed by concatenating
1979 * the inputs passed to preceding calls to psa_hash_update().
1980 *
1981 * When this function returns, the operation becomes inactive.
1982 *
1983 * \warning Applications should not call this function if they expect
1984 * a specific value for the hash. Call psa_hash_verify() instead.
1985 * Beware that comparing integrity or authenticity data such as
1986 * hash values with a function such as \c memcmp is risky
1987 * because the time taken by the comparison may leak information
1988 * about the hashed data which could allow an attacker to guess
1989 * a valid hash and thereby bypass security controls.
1990 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02001991 * \param[in,out] operation Active hash operation.
1992 * \param[out] hash Buffer where the hash is to be written.
1993 * \param hash_size Size of the \p hash buffer in bytes.
1994 * \param[out] hash_length On success, the number of bytes
1995 * that make up the hash value. This is always
Gilles Peskinebe42f312018-07-13 14:38:15 +02001996 * #PSA_HASH_SIZE(\c alg) where \c alg is the
Gilles Peskineedd11a12018-07-12 01:08:58 +02001997 * hash algorithm that is calculated.
Gilles Peskine308b91d2018-02-08 09:47:44 +01001998 *
Gilles Peskine28538492018-07-11 17:34:00 +02001999 * \retval #PSA_SUCCESS
Gilles Peskine308b91d2018-02-08 09:47:44 +01002000 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002001 * \retval #PSA_ERROR_BAD_STATE
Gilles Peskine308b91d2018-02-08 09:47:44 +01002002 * The operation state is not valid (not started, or already completed).
Gilles Peskine28538492018-07-11 17:34:00 +02002003 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002004 * The size of the \p hash buffer is too small. You can determine a
Gilles Peskine7256e6c2018-07-12 00:34:26 +02002005 * sufficient buffer size by calling #PSA_HASH_SIZE(\c alg)
Gilles Peskine308b91d2018-02-08 09:47:44 +01002006 * where \c alg is the hash algorithm that is calculated.
Gilles Peskine28538492018-07-11 17:34:00 +02002007 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2008 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2009 * \retval #PSA_ERROR_HARDWARE_FAILURE
2010 * \retval #PSA_ERROR_TAMPERING_DETECTED
Gilles Peskine308b91d2018-02-08 09:47:44 +01002011 */
Gilles Peskine9ef733f2018-02-07 21:05:37 +01002012psa_status_t psa_hash_finish(psa_hash_operation_t *operation,
2013 uint8_t *hash,
2014 size_t hash_size,
2015 size_t *hash_length);
2016
Gilles Peskine308b91d2018-02-08 09:47:44 +01002017/** Finish the calculation of the hash of a message and compare it with
2018 * an expected value.
2019 *
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02002020 * The application must call psa_hash_setup() before calling this function.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002021 * This function calculates the hash of the message formed by concatenating
2022 * the inputs passed to preceding calls to psa_hash_update(). It then
2023 * compares the calculated hash with the expected hash passed as a
2024 * parameter to this function.
2025 *
2026 * When this function returns, the operation becomes inactive.
2027 *
Gilles Peskine19067982018-03-20 17:54:53 +01002028 * \note Implementations shall make the best effort to ensure that the
Gilles Peskine308b91d2018-02-08 09:47:44 +01002029 * comparison between the actual hash and the expected hash is performed
2030 * in constant time.
2031 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002032 * \param[in,out] operation Active hash operation.
2033 * \param[in] hash Buffer containing the expected hash value.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002034 * \param hash_length Size of the \p hash buffer in bytes.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002035 *
Gilles Peskine28538492018-07-11 17:34:00 +02002036 * \retval #PSA_SUCCESS
Gilles Peskine308b91d2018-02-08 09:47:44 +01002037 * The expected hash is identical to the actual hash of the message.
Gilles Peskine28538492018-07-11 17:34:00 +02002038 * \retval #PSA_ERROR_INVALID_SIGNATURE
Gilles Peskine308b91d2018-02-08 09:47:44 +01002039 * The hash of the message was calculated successfully, but it
2040 * differs from the expected hash.
Gilles Peskine28538492018-07-11 17:34:00 +02002041 * \retval #PSA_ERROR_BAD_STATE
Gilles Peskine308b91d2018-02-08 09:47:44 +01002042 * The operation state is not valid (not started, or already completed).
Gilles Peskine28538492018-07-11 17:34:00 +02002043 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2044 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2045 * \retval #PSA_ERROR_HARDWARE_FAILURE
2046 * \retval #PSA_ERROR_TAMPERING_DETECTED
Gilles Peskine308b91d2018-02-08 09:47:44 +01002047 */
Gilles Peskine9ef733f2018-02-07 21:05:37 +01002048psa_status_t psa_hash_verify(psa_hash_operation_t *operation,
2049 const uint8_t *hash,
2050 size_t hash_length);
2051
Gilles Peskine308b91d2018-02-08 09:47:44 +01002052/** Abort a hash operation.
2053 *
Gilles Peskine308b91d2018-02-08 09:47:44 +01002054 * Aborting an operation frees all associated resources except for the
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002055 * \p operation structure itself. Once aborted, the operation object
2056 * can be reused for another operation by calling
2057 * psa_hash_setup() again.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002058 *
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002059 * You may call this function any time after the operation object has
2060 * been initialized by any of the following methods:
2061 * - A call to psa_hash_setup(), whether it succeeds or not.
2062 * - Initializing the \c struct to all-bits-zero.
2063 * - Initializing the \c struct to logical zeros, e.g.
2064 * `psa_hash_operation_t operation = {0}`.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002065 *
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002066 * In particular, calling psa_hash_abort() after the operation has been
2067 * terminated by a call to psa_hash_abort(), psa_hash_finish() or
2068 * psa_hash_verify() is safe and has no effect.
2069 *
2070 * \param[in,out] operation Initialized hash operation.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002071 *
Gilles Peskine28538492018-07-11 17:34:00 +02002072 * \retval #PSA_SUCCESS
2073 * \retval #PSA_ERROR_BAD_STATE
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002074 * \p operation is not an active hash operation.
Gilles Peskine28538492018-07-11 17:34:00 +02002075 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2076 * \retval #PSA_ERROR_HARDWARE_FAILURE
2077 * \retval #PSA_ERROR_TAMPERING_DETECTED
Gilles Peskine308b91d2018-02-08 09:47:44 +01002078 */
2079psa_status_t psa_hash_abort(psa_hash_operation_t *operation);
Gilles Peskine9ef733f2018-02-07 21:05:37 +01002080
2081/**@}*/
2082
Gilles Peskine8c9def32018-02-08 10:02:12 +01002083/** \defgroup MAC Message authentication codes
2084 * @{
2085 */
2086
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002087/** The type of the state data structure for multipart MAC operations.
2088 *
Gilles Peskine92b30732018-03-03 21:29:30 +01002089 * This is an implementation-defined \c struct. Applications should not
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002090 * make any assumptions about the content of this structure except
2091 * as directed by the documentation of a specific implementation. */
Gilles Peskine8c9def32018-02-08 10:02:12 +01002092typedef struct psa_mac_operation_s psa_mac_operation_t;
2093
Gilles Peskine89167cb2018-07-08 20:12:23 +02002094/** Start a multipart MAC calculation operation.
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002095 *
Gilles Peskine89167cb2018-07-08 20:12:23 +02002096 * This function sets up the calculation of the MAC
2097 * (message authentication code) of a byte string.
2098 * To verify the MAC of a message against an
2099 * expected value, use psa_mac_verify_setup() instead.
2100 *
2101 * The sequence of operations to calculate a MAC is as follows:
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002102 * -# Allocate an operation object which will be passed to all the functions
2103 * listed here.
Gilles Peskine89167cb2018-07-08 20:12:23 +02002104 * -# Call psa_mac_sign_setup() to specify the algorithm and key.
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002105 * The key remains associated with the operation even if the content
2106 * of the key slot changes.
2107 * -# Call psa_mac_update() zero, one or more times, passing a fragment
2108 * of the message each time. The MAC that is calculated is the MAC
2109 * of the concatenation of these messages in order.
Gilles Peskine89167cb2018-07-08 20:12:23 +02002110 * -# At the end of the message, call psa_mac_sign_finish() to finish
2111 * calculating the MAC value and retrieve it.
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002112 *
2113 * The application may call psa_mac_abort() at any time after the operation
Gilles Peskine89167cb2018-07-08 20:12:23 +02002114 * has been initialized with psa_mac_sign_setup().
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002115 *
Gilles Peskine89167cb2018-07-08 20:12:23 +02002116 * After a successful call to psa_mac_sign_setup(), the application must
2117 * eventually terminate the operation through one of the following methods:
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002118 * - A failed call to psa_mac_update().
Gilles Peskine89167cb2018-07-08 20:12:23 +02002119 * - A call to psa_mac_sign_finish() or psa_mac_abort().
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002120 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002121 * \param[out] operation The operation object to use.
2122 * \param key Slot containing the key to use for the operation.
2123 * \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
2124 * such that #PSA_ALG_IS_MAC(alg) is true).
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002125 *
Gilles Peskine28538492018-07-11 17:34:00 +02002126 * \retval #PSA_SUCCESS
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002127 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002128 * \retval #PSA_ERROR_EMPTY_SLOT
2129 * \retval #PSA_ERROR_NOT_PERMITTED
2130 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002131 * \p key is not compatible with \p alg.
Gilles Peskine28538492018-07-11 17:34:00 +02002132 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002133 * \p alg is not supported or is not a MAC algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02002134 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2135 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2136 * \retval #PSA_ERROR_HARDWARE_FAILURE
2137 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002138 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002139 * The library has not been previously initialized by psa_crypto_init().
2140 * It is implementation-dependent whether a failure to initialize
2141 * results in this error code.
Gilles Peskine7e4acc52018-02-16 21:24:11 +01002142 */
Gilles Peskine89167cb2018-07-08 20:12:23 +02002143psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation,
2144 psa_key_slot_t key,
2145 psa_algorithm_t alg);
2146
2147/** Start a multipart MAC verification operation.
2148 *
2149 * This function sets up the verification of the MAC
2150 * (message authentication code) of a byte string against an expected value.
2151 *
2152 * The sequence of operations to verify a MAC is as follows:
2153 * -# Allocate an operation object which will be passed to all the functions
2154 * listed here.
2155 * -# Call psa_mac_verify_setup() to specify the algorithm and key.
2156 * The key remains associated with the operation even if the content
2157 * of the key slot changes.
2158 * -# Call psa_mac_update() zero, one or more times, passing a fragment
2159 * of the message each time. The MAC that is calculated is the MAC
2160 * of the concatenation of these messages in order.
2161 * -# At the end of the message, call psa_mac_verify_finish() to finish
2162 * calculating the actual MAC of the message and verify it against
2163 * the expected value.
2164 *
2165 * The application may call psa_mac_abort() at any time after the operation
2166 * has been initialized with psa_mac_verify_setup().
2167 *
2168 * After a successful call to psa_mac_verify_setup(), the application must
2169 * eventually terminate the operation through one of the following methods:
2170 * - A failed call to psa_mac_update().
2171 * - A call to psa_mac_verify_finish() or psa_mac_abort().
2172 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002173 * \param[out] operation The operation object to use.
2174 * \param key Slot containing the key to use for the operation.
2175 * \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
2176 * such that #PSA_ALG_IS_MAC(\p alg) is true).
Gilles Peskine89167cb2018-07-08 20:12:23 +02002177 *
Gilles Peskine28538492018-07-11 17:34:00 +02002178 * \retval #PSA_SUCCESS
Gilles Peskine89167cb2018-07-08 20:12:23 +02002179 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002180 * \retval #PSA_ERROR_EMPTY_SLOT
2181 * \retval #PSA_ERROR_NOT_PERMITTED
2182 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskine89167cb2018-07-08 20:12:23 +02002183 * \c key is not compatible with \c alg.
Gilles Peskine28538492018-07-11 17:34:00 +02002184 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskine89167cb2018-07-08 20:12:23 +02002185 * \c alg is not supported or is not a MAC algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02002186 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2187 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2188 * \retval #PSA_ERROR_HARDWARE_FAILURE
2189 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002190 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002191 * The library has not been previously initialized by psa_crypto_init().
2192 * It is implementation-dependent whether a failure to initialize
2193 * results in this error code.
Gilles Peskine89167cb2018-07-08 20:12:23 +02002194 */
2195psa_status_t psa_mac_verify_setup(psa_mac_operation_t *operation,
2196 psa_key_slot_t key,
2197 psa_algorithm_t alg);
Gilles Peskine8c9def32018-02-08 10:02:12 +01002198
Gilles Peskinedcd14942018-07-12 00:30:52 +02002199/** Add a message fragment to a multipart MAC operation.
2200 *
2201 * The application must call psa_mac_sign_setup() or psa_mac_verify_setup()
2202 * before calling this function.
2203 *
2204 * If this function returns an error status, the operation becomes inactive.
2205 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002206 * \param[in,out] operation Active MAC operation.
2207 * \param[in] input Buffer containing the message fragment to add to
2208 * the MAC calculation.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002209 * \param input_length Size of the \p input buffer in bytes.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002210 *
2211 * \retval #PSA_SUCCESS
2212 * Success.
2213 * \retval #PSA_ERROR_BAD_STATE
2214 * The operation state is not valid (not started, or already completed).
2215 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2216 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2217 * \retval #PSA_ERROR_HARDWARE_FAILURE
2218 * \retval #PSA_ERROR_TAMPERING_DETECTED
2219 */
Gilles Peskine8c9def32018-02-08 10:02:12 +01002220psa_status_t psa_mac_update(psa_mac_operation_t *operation,
2221 const uint8_t *input,
2222 size_t input_length);
2223
Gilles Peskinedcd14942018-07-12 00:30:52 +02002224/** Finish the calculation of the MAC of a message.
2225 *
2226 * The application must call psa_mac_sign_setup() before calling this function.
2227 * This function calculates the MAC of the message formed by concatenating
2228 * the inputs passed to preceding calls to psa_mac_update().
2229 *
2230 * When this function returns, the operation becomes inactive.
2231 *
2232 * \warning Applications should not call this function if they expect
2233 * a specific value for the MAC. Call psa_mac_verify_finish() instead.
2234 * Beware that comparing integrity or authenticity data such as
2235 * MAC values with a function such as \c memcmp is risky
2236 * because the time taken by the comparison may leak information
2237 * about the MAC value which could allow an attacker to guess
2238 * a valid MAC and thereby bypass security controls.
2239 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002240 * \param[in,out] operation Active MAC operation.
2241 * \param[out] mac Buffer where the MAC value is to be written.
2242 * \param mac_size Size of the \p mac buffer in bytes.
2243 * \param[out] mac_length On success, the number of bytes
2244 * that make up the MAC value. This is always
Gilles Peskinedda3bd32018-07-12 19:40:46 +02002245 * #PSA_MAC_FINAL_SIZE(\c key_type, \c key_bits, \c alg)
Gilles Peskineedd11a12018-07-12 01:08:58 +02002246 * where \c key_type and \c key_bits are the type and
Gilles Peskinedda3bd32018-07-12 19:40:46 +02002247 * bit-size respectively of the key and \c alg is the
Gilles Peskineedd11a12018-07-12 01:08:58 +02002248 * MAC algorithm that is calculated.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002249 *
2250 * \retval #PSA_SUCCESS
2251 * Success.
2252 * \retval #PSA_ERROR_BAD_STATE
2253 * The operation state is not valid (not started, or already completed).
2254 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002255 * The size of the \p mac buffer is too small. You can determine a
Gilles Peskinedcd14942018-07-12 00:30:52 +02002256 * sufficient buffer size by calling PSA_MAC_FINAL_SIZE().
2257 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2258 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2259 * \retval #PSA_ERROR_HARDWARE_FAILURE
2260 * \retval #PSA_ERROR_TAMPERING_DETECTED
2261 */
Gilles Peskineacd4be32018-07-08 19:56:25 +02002262psa_status_t psa_mac_sign_finish(psa_mac_operation_t *operation,
2263 uint8_t *mac,
2264 size_t mac_size,
2265 size_t *mac_length);
Gilles Peskine8c9def32018-02-08 10:02:12 +01002266
Gilles Peskinedcd14942018-07-12 00:30:52 +02002267/** Finish the calculation of the MAC of a message and compare it with
2268 * an expected value.
2269 *
2270 * The application must call psa_mac_verify_setup() before calling this function.
2271 * This function calculates the MAC of the message formed by concatenating
2272 * the inputs passed to preceding calls to psa_mac_update(). It then
2273 * compares the calculated MAC with the expected MAC passed as a
2274 * parameter to this function.
2275 *
2276 * When this function returns, the operation becomes inactive.
2277 *
2278 * \note Implementations shall make the best effort to ensure that the
2279 * comparison between the actual MAC and the expected MAC is performed
2280 * in constant time.
2281 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002282 * \param[in,out] operation Active MAC operation.
2283 * \param[in] mac Buffer containing the expected MAC value.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002284 * \param mac_length Size of the \p mac buffer in bytes.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002285 *
2286 * \retval #PSA_SUCCESS
2287 * The expected MAC is identical to the actual MAC of the message.
2288 * \retval #PSA_ERROR_INVALID_SIGNATURE
2289 * The MAC of the message was calculated successfully, but it
2290 * differs from the expected MAC.
2291 * \retval #PSA_ERROR_BAD_STATE
2292 * The operation state is not valid (not started, or already completed).
2293 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2294 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2295 * \retval #PSA_ERROR_HARDWARE_FAILURE
2296 * \retval #PSA_ERROR_TAMPERING_DETECTED
2297 */
Gilles Peskineacd4be32018-07-08 19:56:25 +02002298psa_status_t psa_mac_verify_finish(psa_mac_operation_t *operation,
2299 const uint8_t *mac,
2300 size_t mac_length);
Gilles Peskine8c9def32018-02-08 10:02:12 +01002301
Gilles Peskinedcd14942018-07-12 00:30:52 +02002302/** Abort a MAC operation.
2303 *
Gilles Peskinedcd14942018-07-12 00:30:52 +02002304 * Aborting an operation frees all associated resources except for the
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002305 * \p operation structure itself. Once aborted, the operation object
2306 * can be reused for another operation by calling
2307 * psa_mac_sign_setup() or psa_mac_verify_setup() again.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002308 *
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002309 * You may call this function any time after the operation object has
2310 * been initialized by any of the following methods:
2311 * - A call to psa_mac_sign_setup() or psa_mac_verify_setup(), whether
2312 * it succeeds or not.
2313 * - Initializing the \c struct to all-bits-zero.
2314 * - Initializing the \c struct to logical zeros, e.g.
2315 * `psa_mac_operation_t operation = {0}`.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002316 *
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002317 * In particular, calling psa_mac_abort() after the operation has been
2318 * terminated by a call to psa_mac_abort(), psa_mac_sign_finish() or
2319 * psa_mac_verify_finish() is safe and has no effect.
2320 *
2321 * \param[in,out] operation Initialized MAC operation.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002322 *
2323 * \retval #PSA_SUCCESS
2324 * \retval #PSA_ERROR_BAD_STATE
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002325 * \p operation is not an active MAC operation.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002326 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2327 * \retval #PSA_ERROR_HARDWARE_FAILURE
2328 * \retval #PSA_ERROR_TAMPERING_DETECTED
2329 */
Gilles Peskine8c9def32018-02-08 10:02:12 +01002330psa_status_t psa_mac_abort(psa_mac_operation_t *operation);
2331
2332/**@}*/
2333
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002334/** \defgroup cipher Symmetric ciphers
2335 * @{
2336 */
2337
2338/** The type of the state data structure for multipart cipher operations.
2339 *
2340 * This is an implementation-defined \c struct. Applications should not
2341 * make any assumptions about the content of this structure except
2342 * as directed by the documentation of a specific implementation. */
2343typedef struct psa_cipher_operation_s psa_cipher_operation_t;
2344
2345/** Set the key for a multipart symmetric encryption operation.
2346 *
2347 * The sequence of operations to encrypt a message with a symmetric cipher
2348 * is as follows:
2349 * -# Allocate an operation object which will be passed to all the functions
2350 * listed here.
Gilles Peskinefe119512018-07-08 21:39:34 +02002351 * -# Call psa_cipher_encrypt_setup() to specify the algorithm and key.
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002352 * The key remains associated with the operation even if the content
2353 * of the key slot changes.
itayzafrired7382f2018-08-02 14:19:33 +03002354 * -# Call either psa_cipher_generate_iv() or psa_cipher_set_iv() to
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002355 * generate or set the IV (initialization vector). You should use
itayzafrired7382f2018-08-02 14:19:33 +03002356 * psa_cipher_generate_iv() unless the protocol you are implementing
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002357 * requires a specific IV value.
2358 * -# Call psa_cipher_update() zero, one or more times, passing a fragment
2359 * of the message each time.
2360 * -# Call psa_cipher_finish().
2361 *
2362 * The application may call psa_cipher_abort() at any time after the operation
Gilles Peskinefe119512018-07-08 21:39:34 +02002363 * has been initialized with psa_cipher_encrypt_setup().
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002364 *
Gilles Peskinefe119512018-07-08 21:39:34 +02002365 * After a successful call to psa_cipher_encrypt_setup(), the application must
Gilles Peskineed522972018-03-20 17:54:15 +01002366 * eventually terminate the operation. The following events terminate an
2367 * operation:
itayzafrired7382f2018-08-02 14:19:33 +03002368 * - A failed call to psa_cipher_generate_iv(), psa_cipher_set_iv()
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002369 * or psa_cipher_update().
Gilles Peskine19067982018-03-20 17:54:53 +01002370 * - A call to psa_cipher_finish() or psa_cipher_abort().
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002371 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002372 * \param[out] operation The operation object to use.
2373 * \param key Slot containing the key to use for the operation.
2374 * \param alg The cipher algorithm to compute
2375 * (\c PSA_ALG_XXX value such that
2376 * #PSA_ALG_IS_CIPHER(\p alg) is true).
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002377 *
Gilles Peskine28538492018-07-11 17:34:00 +02002378 * \retval #PSA_SUCCESS
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002379 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002380 * \retval #PSA_ERROR_EMPTY_SLOT
2381 * \retval #PSA_ERROR_NOT_PERMITTED
2382 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002383 * \p key is not compatible with \p alg.
Gilles Peskine28538492018-07-11 17:34:00 +02002384 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002385 * \p alg is not supported or is not a cipher algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02002386 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2387 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2388 * \retval #PSA_ERROR_HARDWARE_FAILURE
2389 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002390 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002391 * The library has not been previously initialized by psa_crypto_init().
2392 * It is implementation-dependent whether a failure to initialize
2393 * results in this error code.
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002394 */
Gilles Peskinefe119512018-07-08 21:39:34 +02002395psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation,
2396 psa_key_slot_t key,
2397 psa_algorithm_t alg);
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002398
2399/** Set the key for a multipart symmetric decryption operation.
2400 *
2401 * The sequence of operations to decrypt a message with a symmetric cipher
2402 * is as follows:
2403 * -# Allocate an operation object which will be passed to all the functions
2404 * listed here.
Gilles Peskinefe119512018-07-08 21:39:34 +02002405 * -# Call psa_cipher_decrypt_setup() to specify the algorithm and key.
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002406 * The key remains associated with the operation even if the content
2407 * of the key slot changes.
2408 * -# Call psa_cipher_update() with the IV (initialization vector) for the
2409 * decryption. If the IV is prepended to the ciphertext, you can call
2410 * psa_cipher_update() on a buffer containing the IV followed by the
2411 * beginning of the message.
2412 * -# Call psa_cipher_update() zero, one or more times, passing a fragment
2413 * of the message each time.
2414 * -# Call psa_cipher_finish().
2415 *
2416 * The application may call psa_cipher_abort() at any time after the operation
Gilles Peskinefe119512018-07-08 21:39:34 +02002417 * has been initialized with psa_cipher_decrypt_setup().
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002418 *
Gilles Peskinefe119512018-07-08 21:39:34 +02002419 * After a successful call to psa_cipher_decrypt_setup(), the application must
Gilles Peskineed522972018-03-20 17:54:15 +01002420 * eventually terminate the operation. The following events terminate an
2421 * operation:
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002422 * - A failed call to psa_cipher_update().
Gilles Peskine19067982018-03-20 17:54:53 +01002423 * - A call to psa_cipher_finish() or psa_cipher_abort().
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002424 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002425 * \param[out] operation The operation object to use.
2426 * \param key Slot containing the key to use for the operation.
2427 * \param alg The cipher algorithm to compute
2428 * (\c PSA_ALG_XXX value such that
2429 * #PSA_ALG_IS_CIPHER(\p alg) is true).
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002430 *
Gilles Peskine28538492018-07-11 17:34:00 +02002431 * \retval #PSA_SUCCESS
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002432 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002433 * \retval #PSA_ERROR_EMPTY_SLOT
2434 * \retval #PSA_ERROR_NOT_PERMITTED
2435 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002436 * \p key is not compatible with \p alg.
Gilles Peskine28538492018-07-11 17:34:00 +02002437 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002438 * \p alg is not supported or is not a cipher algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02002439 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2440 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2441 * \retval #PSA_ERROR_HARDWARE_FAILURE
2442 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002443 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002444 * The library has not been previously initialized by psa_crypto_init().
2445 * It is implementation-dependent whether a failure to initialize
2446 * results in this error code.
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002447 */
Gilles Peskinefe119512018-07-08 21:39:34 +02002448psa_status_t psa_cipher_decrypt_setup(psa_cipher_operation_t *operation,
2449 psa_key_slot_t key,
2450 psa_algorithm_t alg);
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002451
Gilles Peskinedcd14942018-07-12 00:30:52 +02002452/** Generate an IV for a symmetric encryption operation.
2453 *
2454 * This function generates a random IV (initialization vector), nonce
2455 * or initial counter value for the encryption operation as appropriate
2456 * for the chosen algorithm, key type and key size.
2457 *
2458 * The application must call psa_cipher_encrypt_setup() before
2459 * calling this function.
2460 *
2461 * If this function returns an error status, the operation becomes inactive.
2462 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002463 * \param[in,out] operation Active cipher operation.
2464 * \param[out] iv Buffer where the generated IV is to be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002465 * \param iv_size Size of the \p iv buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002466 * \param[out] iv_length On success, the number of bytes of the
2467 * generated IV.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002468 *
2469 * \retval #PSA_SUCCESS
2470 * Success.
2471 * \retval #PSA_ERROR_BAD_STATE
2472 * The operation state is not valid (not started, or IV already set).
2473 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
Gilles Peskinedda3bd32018-07-12 19:40:46 +02002474 * The size of the \p iv buffer is too small.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002475 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2476 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2477 * \retval #PSA_ERROR_HARDWARE_FAILURE
2478 * \retval #PSA_ERROR_TAMPERING_DETECTED
2479 */
Gilles Peskinefe119512018-07-08 21:39:34 +02002480psa_status_t psa_cipher_generate_iv(psa_cipher_operation_t *operation,
2481 unsigned char *iv,
2482 size_t iv_size,
2483 size_t *iv_length);
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002484
Gilles Peskinedcd14942018-07-12 00:30:52 +02002485/** Set the IV for a symmetric encryption or decryption operation.
2486 *
2487 * This function sets the random IV (initialization vector), nonce
2488 * or initial counter value for the encryption or decryption operation.
2489 *
2490 * The application must call psa_cipher_encrypt_setup() before
2491 * calling this function.
2492 *
2493 * If this function returns an error status, the operation becomes inactive.
2494 *
2495 * \note When encrypting, applications should use psa_cipher_generate_iv()
2496 * instead of this function, unless implementing a protocol that requires
2497 * a non-random IV.
2498 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002499 * \param[in,out] operation Active cipher operation.
2500 * \param[in] iv Buffer containing the IV to use.
2501 * \param iv_length Size of the IV in bytes.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002502 *
2503 * \retval #PSA_SUCCESS
2504 * Success.
2505 * \retval #PSA_ERROR_BAD_STATE
2506 * The operation state is not valid (not started, or IV already set).
2507 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002508 * The size of \p iv is not acceptable for the chosen algorithm,
Gilles Peskinedcd14942018-07-12 00:30:52 +02002509 * or the chosen algorithm does not use an IV.
2510 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2511 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2512 * \retval #PSA_ERROR_HARDWARE_FAILURE
2513 * \retval #PSA_ERROR_TAMPERING_DETECTED
2514 */
Gilles Peskinefe119512018-07-08 21:39:34 +02002515psa_status_t psa_cipher_set_iv(psa_cipher_operation_t *operation,
2516 const unsigned char *iv,
2517 size_t iv_length);
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002518
Gilles Peskinedcd14942018-07-12 00:30:52 +02002519/** Encrypt or decrypt a message fragment in an active cipher operation.
2520 *
Gilles Peskine9ac94262018-07-12 20:15:32 +02002521 * Before calling this function, you must:
2522 * 1. Call either psa_cipher_encrypt_setup() or psa_cipher_decrypt_setup().
2523 * The choice of setup function determines whether this function
2524 * encrypts or decrypts its input.
2525 * 2. If the algorithm requires an IV, call psa_cipher_generate_iv()
2526 * (recommended when encrypting) or psa_cipher_set_iv().
Gilles Peskinedcd14942018-07-12 00:30:52 +02002527 *
2528 * If this function returns an error status, the operation becomes inactive.
2529 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002530 * \param[in,out] operation Active cipher operation.
2531 * \param[in] input Buffer containing the message fragment to
2532 * encrypt or decrypt.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002533 * \param input_length Size of the \p input buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002534 * \param[out] output Buffer where the output is to be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002535 * \param output_size Size of the \p output buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002536 * \param[out] output_length On success, the number of bytes
2537 * that make up the returned output.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002538 *
2539 * \retval #PSA_SUCCESS
2540 * Success.
2541 * \retval #PSA_ERROR_BAD_STATE
2542 * The operation state is not valid (not started, IV required but
2543 * not set, or already completed).
2544 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
2545 * The size of the \p output buffer is too small.
2546 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2547 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2548 * \retval #PSA_ERROR_HARDWARE_FAILURE
2549 * \retval #PSA_ERROR_TAMPERING_DETECTED
2550 */
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002551psa_status_t psa_cipher_update(psa_cipher_operation_t *operation,
2552 const uint8_t *input,
mohammad1603503973b2018-03-12 15:59:30 +02002553 size_t input_length,
Gilles Peskine2d277862018-06-18 15:41:12 +02002554 unsigned char *output,
2555 size_t output_size,
mohammad1603503973b2018-03-12 15:59:30 +02002556 size_t *output_length);
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002557
Gilles Peskinedcd14942018-07-12 00:30:52 +02002558/** Finish encrypting or decrypting a message in a cipher operation.
2559 *
2560 * The application must call psa_cipher_encrypt_setup() or
2561 * psa_cipher_decrypt_setup() before calling this function. The choice
2562 * of setup function determines whether this function encrypts or
2563 * decrypts its input.
2564 *
2565 * This function finishes the encryption or decryption of the message
2566 * formed by concatenating the inputs passed to preceding calls to
2567 * psa_cipher_update().
2568 *
2569 * When this function returns, the operation becomes inactive.
2570 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002571 * \param[in,out] operation Active cipher operation.
2572 * \param[out] output Buffer where the output is to be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002573 * \param output_size Size of the \p output buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002574 * \param[out] output_length On success, the number of bytes
2575 * that make up the returned output.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002576 *
2577 * \retval #PSA_SUCCESS
2578 * Success.
2579 * \retval #PSA_ERROR_BAD_STATE
2580 * The operation state is not valid (not started, IV required but
2581 * not set, or already completed).
2582 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
2583 * The size of the \p output buffer is too small.
2584 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2585 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2586 * \retval #PSA_ERROR_HARDWARE_FAILURE
2587 * \retval #PSA_ERROR_TAMPERING_DETECTED
2588 */
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002589psa_status_t psa_cipher_finish(psa_cipher_operation_t *operation,
mohammad1603503973b2018-03-12 15:59:30 +02002590 uint8_t *output,
Moran Peker0071b872018-04-22 20:16:58 +03002591 size_t output_size,
mohammad1603503973b2018-03-12 15:59:30 +02002592 size_t *output_length);
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002593
Gilles Peskinedcd14942018-07-12 00:30:52 +02002594/** Abort a cipher operation.
2595 *
Gilles Peskinedcd14942018-07-12 00:30:52 +02002596 * Aborting an operation frees all associated resources except for the
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002597 * \p operation structure itself. Once aborted, the operation object
2598 * can be reused for another operation by calling
2599 * psa_cipher_encrypt_setup() or psa_cipher_decrypt_setup() again.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002600 *
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002601 * You may call this function any time after the operation object has
2602 * been initialized by any of the following methods:
2603 * - A call to psa_cipher_encrypt_setup() or psa_cipher_decrypt_setup(),
2604 * whether it succeeds or not.
2605 * - Initializing the \c struct to all-bits-zero.
2606 * - Initializing the \c struct to logical zeros, e.g.
2607 * `psa_cipher_operation_t operation = {0}`.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002608 *
Gilles Peskineb82ab6f2018-07-13 15:33:43 +02002609 * In particular, calling psa_cipher_abort() after the operation has been
2610 * terminated by a call to psa_cipher_abort() or psa_cipher_finish()
2611 * is safe and has no effect.
2612 *
2613 * \param[in,out] operation Initialized cipher operation.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002614 *
2615 * \retval #PSA_SUCCESS
2616 * \retval #PSA_ERROR_BAD_STATE
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002617 * \p operation is not an active cipher operation.
Gilles Peskinedcd14942018-07-12 00:30:52 +02002618 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2619 * \retval #PSA_ERROR_HARDWARE_FAILURE
2620 * \retval #PSA_ERROR_TAMPERING_DETECTED
2621 */
Gilles Peskine428dc5a2018-03-03 21:27:18 +01002622psa_status_t psa_cipher_abort(psa_cipher_operation_t *operation);
2623
2624/**@}*/
2625
Gilles Peskine3b555712018-03-03 21:27:57 +01002626/** \defgroup aead Authenticated encryption with associated data (AEAD)
2627 * @{
2628 */
2629
Gilles Peskine5e39dc92018-06-08 11:41:57 +02002630/** The tag size for an AEAD algorithm, in bytes.
Gilles Peskine3b555712018-03-03 21:27:57 +01002631 *
Gilles Peskine5e39dc92018-06-08 11:41:57 +02002632 * \param alg An AEAD algorithm
2633 * (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02002634 * #PSA_ALG_IS_AEAD(\p alg) is true).
Gilles Peskine5e39dc92018-06-08 11:41:57 +02002635 *
2636 * \return The tag size for the specified algorithm.
2637 * If the AEAD algorithm does not have an identified
2638 * tag that can be distinguished from the rest of
2639 * the ciphertext, return 0.
2640 * If the AEAD algorithm is not recognized, return 0.
2641 * An implementation may return either 0 or a
2642 * correct size for an AEAD algorithm that it
2643 * recognizes, but does not support.
2644 */
Gilles Peskine23cc2ff2018-08-17 19:47:52 +02002645#define PSA_AEAD_TAG_LENGTH(alg) \
2646 (PSA_ALG_IS_AEAD(alg) ? \
2647 (((alg) & PSA_ALG_AEAD_TAG_LENGTH_MASK) >> PSA_AEAD_TAG_LENGTH_OFFSET) : \
Gilles Peskine5e39dc92018-06-08 11:41:57 +02002648 0)
Gilles Peskine3b555712018-03-03 21:27:57 +01002649
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002650/** Process an authenticated encryption operation.
Gilles Peskine3b555712018-03-03 21:27:57 +01002651 *
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002652 * \param key Slot containing the key to use.
2653 * \param alg The AEAD algorithm to compute
2654 * (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02002655 * #PSA_ALG_IS_AEAD(\p alg) is true).
Gilles Peskineedd11a12018-07-12 01:08:58 +02002656 * \param[in] nonce Nonce or IV to use.
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002657 * \param nonce_length Size of the \p nonce buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002658 * \param[in] additional_data Additional data that will be authenticated
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002659 * but not encrypted.
2660 * \param additional_data_length Size of \p additional_data in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002661 * \param[in] plaintext Data that will be authenticated and
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002662 * encrypted.
2663 * \param plaintext_length Size of \p plaintext in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002664 * \param[out] ciphertext Output buffer for the authenticated and
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002665 * encrypted data. The additional data is not
2666 * part of this output. For algorithms where the
2667 * encrypted data and the authentication tag
2668 * are defined as separate outputs, the
2669 * authentication tag is appended to the
2670 * encrypted data.
2671 * \param ciphertext_size Size of the \p ciphertext buffer in bytes.
2672 * This must be at least
2673 * #PSA_AEAD_ENCRYPT_OUTPUT_SIZE(\p alg,
2674 * \p plaintext_length).
Gilles Peskineedd11a12018-07-12 01:08:58 +02002675 * \param[out] ciphertext_length On success, the size of the output
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002676 * in the \b ciphertext buffer.
Gilles Peskine3b555712018-03-03 21:27:57 +01002677 *
Gilles Peskine28538492018-07-11 17:34:00 +02002678 * \retval #PSA_SUCCESS
Gilles Peskine3b555712018-03-03 21:27:57 +01002679 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002680 * \retval #PSA_ERROR_EMPTY_SLOT
2681 * \retval #PSA_ERROR_NOT_PERMITTED
2682 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002683 * \p key is not compatible with \p alg.
Gilles Peskine28538492018-07-11 17:34:00 +02002684 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002685 * \p alg is not supported or is not an AEAD algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02002686 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2687 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2688 * \retval #PSA_ERROR_HARDWARE_FAILURE
2689 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002690 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002691 * The library has not been previously initialized by psa_crypto_init().
2692 * It is implementation-dependent whether a failure to initialize
2693 * results in this error code.
Gilles Peskine3b555712018-03-03 21:27:57 +01002694 */
Gilles Peskine9fb0e012018-07-19 15:51:49 +02002695psa_status_t psa_aead_encrypt(psa_key_slot_t key,
2696 psa_algorithm_t alg,
2697 const uint8_t *nonce,
2698 size_t nonce_length,
2699 const uint8_t *additional_data,
2700 size_t additional_data_length,
2701 const uint8_t *plaintext,
2702 size_t plaintext_length,
2703 uint8_t *ciphertext,
2704 size_t ciphertext_size,
2705 size_t *ciphertext_length);
Gilles Peskine3b555712018-03-03 21:27:57 +01002706
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002707/** Process an authenticated decryption operation.
Gilles Peskine3b555712018-03-03 21:27:57 +01002708 *
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002709 * \param key Slot containing the key to use.
2710 * \param alg The AEAD algorithm to compute
2711 * (\c PSA_ALG_XXX value such that
Gilles Peskine7256e6c2018-07-12 00:34:26 +02002712 * #PSA_ALG_IS_AEAD(\p alg) is true).
Gilles Peskineedd11a12018-07-12 01:08:58 +02002713 * \param[in] nonce Nonce or IV to use.
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002714 * \param nonce_length Size of the \p nonce buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002715 * \param[in] additional_data Additional data that has been authenticated
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002716 * but not encrypted.
2717 * \param additional_data_length Size of \p additional_data in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002718 * \param[in] ciphertext Data that has been authenticated and
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002719 * encrypted. For algorithms where the
2720 * encrypted data and the authentication tag
2721 * are defined as separate inputs, the buffer
2722 * must contain the encrypted data followed
2723 * by the authentication tag.
2724 * \param ciphertext_length Size of \p ciphertext in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002725 * \param[out] plaintext Output buffer for the decrypted data.
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002726 * \param plaintext_size Size of the \p plaintext buffer in bytes.
2727 * This must be at least
2728 * #PSA_AEAD_DECRYPT_OUTPUT_SIZE(\p alg,
2729 * \p ciphertext_length).
Gilles Peskineedd11a12018-07-12 01:08:58 +02002730 * \param[out] plaintext_length On success, the size of the output
mohammad1603fb5b9cb2018-06-06 13:44:27 +03002731 * in the \b plaintext buffer.
Gilles Peskine3b555712018-03-03 21:27:57 +01002732 *
Gilles Peskine28538492018-07-11 17:34:00 +02002733 * \retval #PSA_SUCCESS
Gilles Peskine3b555712018-03-03 21:27:57 +01002734 * Success.
Gilles Peskine28538492018-07-11 17:34:00 +02002735 * \retval #PSA_ERROR_EMPTY_SLOT
2736 * \retval #PSA_ERROR_INVALID_SIGNATURE
Gilles Peskine1e7d8f12018-06-01 16:29:38 +02002737 * The ciphertext is not authentic.
Gilles Peskine28538492018-07-11 17:34:00 +02002738 * \retval #PSA_ERROR_NOT_PERMITTED
2739 * \retval #PSA_ERROR_INVALID_ARGUMENT
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002740 * \p key is not compatible with \p alg.
Gilles Peskine28538492018-07-11 17:34:00 +02002741 * \retval #PSA_ERROR_NOT_SUPPORTED
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002742 * \p alg is not supported or is not an AEAD algorithm.
Gilles Peskine28538492018-07-11 17:34:00 +02002743 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2744 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2745 * \retval #PSA_ERROR_HARDWARE_FAILURE
2746 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002747 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002748 * The library has not been previously initialized by psa_crypto_init().
2749 * It is implementation-dependent whether a failure to initialize
2750 * results in this error code.
Gilles Peskine3b555712018-03-03 21:27:57 +01002751 */
Gilles Peskine9fb0e012018-07-19 15:51:49 +02002752psa_status_t psa_aead_decrypt(psa_key_slot_t key,
2753 psa_algorithm_t alg,
2754 const uint8_t *nonce,
2755 size_t nonce_length,
2756 const uint8_t *additional_data,
2757 size_t additional_data_length,
2758 const uint8_t *ciphertext,
2759 size_t ciphertext_length,
2760 uint8_t *plaintext,
2761 size_t plaintext_size,
2762 size_t *plaintext_length);
Gilles Peskine3b555712018-03-03 21:27:57 +01002763
2764/**@}*/
2765
Gilles Peskine20035e32018-02-03 22:44:14 +01002766/** \defgroup asymmetric Asymmetric cryptography
2767 * @{
2768 */
2769
2770/**
Gilles Peskineeae6eee2018-06-28 13:56:01 +02002771 * \brief ECDSA signature size for a given curve bit size
Gilles Peskine0189e752018-02-03 23:57:22 +01002772 *
Gilles Peskineeae6eee2018-06-28 13:56:01 +02002773 * \param curve_bits Curve size in bits.
2774 * \return Signature size in bytes.
Gilles Peskine0189e752018-02-03 23:57:22 +01002775 *
2776 * \note This macro returns a compile-time constant if its argument is one.
Gilles Peskine0189e752018-02-03 23:57:22 +01002777 */
Gilles Peskineeae6eee2018-06-28 13:56:01 +02002778#define PSA_ECDSA_SIGNATURE_SIZE(curve_bits) \
2779 (PSA_BITS_TO_BYTES(curve_bits) * 2)
Gilles Peskine0189e752018-02-03 23:57:22 +01002780
Gilles Peskine0189e752018-02-03 23:57:22 +01002781/**
Gilles Peskine20035e32018-02-03 22:44:14 +01002782 * \brief Sign a hash or short message with a private key.
2783 *
Gilles Peskine08bac712018-06-26 16:14:46 +02002784 * Note that to perform a hash-and-sign signature algorithm, you must
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02002785 * first calculate the hash by calling psa_hash_setup(), psa_hash_update()
Gilles Peskine08bac712018-06-26 16:14:46 +02002786 * and psa_hash_finish(). Then pass the resulting hash as the \p hash
2787 * parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg)
2788 * to determine the hash algorithm to use.
2789 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002790 * \param key Key slot containing an asymmetric key pair.
2791 * \param alg A signature algorithm that is compatible with
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002792 * the type of \p key.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002793 * \param[in] hash The hash or message to sign.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002794 * \param hash_length Size of the \p hash buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002795 * \param[out] signature Buffer where the signature is to be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002796 * \param signature_size Size of the \p signature buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002797 * \param[out] signature_length On success, the number of bytes
2798 * that make up the returned signature value.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002799 *
Gilles Peskine28538492018-07-11 17:34:00 +02002800 * \retval #PSA_SUCCESS
2801 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002802 * The size of the \p signature buffer is too small. You can
Gilles Peskine308b91d2018-02-08 09:47:44 +01002803 * determine a sufficient buffer size by calling
Gilles Peskine7256e6c2018-07-12 00:34:26 +02002804 * #PSA_ASYMMETRIC_SIGN_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
Gilles Peskine308b91d2018-02-08 09:47:44 +01002805 * where \c key_type and \c key_bits are the type and bit-size
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002806 * respectively of \p key.
Gilles Peskine28538492018-07-11 17:34:00 +02002807 * \retval #PSA_ERROR_NOT_SUPPORTED
2808 * \retval #PSA_ERROR_INVALID_ARGUMENT
2809 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2810 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2811 * \retval #PSA_ERROR_HARDWARE_FAILURE
2812 * \retval #PSA_ERROR_TAMPERING_DETECTED
2813 * \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
itayzafrir90d8c7a2018-09-12 11:44:52 +03002814 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002815 * The library has not been previously initialized by psa_crypto_init().
2816 * It is implementation-dependent whether a failure to initialize
2817 * results in this error code.
Gilles Peskine20035e32018-02-03 22:44:14 +01002818 */
2819psa_status_t psa_asymmetric_sign(psa_key_slot_t key,
2820 psa_algorithm_t alg,
2821 const uint8_t *hash,
2822 size_t hash_length,
Gilles Peskine20035e32018-02-03 22:44:14 +01002823 uint8_t *signature,
2824 size_t signature_size,
2825 size_t *signature_length);
2826
2827/**
2828 * \brief Verify the signature a hash or short message using a public key.
2829 *
Gilles Peskine08bac712018-06-26 16:14:46 +02002830 * Note that to perform a hash-and-sign signature algorithm, you must
Gilles Peskineda8191d1c2018-07-08 19:46:38 +02002831 * first calculate the hash by calling psa_hash_setup(), psa_hash_update()
Gilles Peskine08bac712018-06-26 16:14:46 +02002832 * and psa_hash_finish(). Then pass the resulting hash as the \p hash
2833 * parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg)
2834 * to determine the hash algorithm to use.
2835 *
Gilles Peskine308b91d2018-02-08 09:47:44 +01002836 * \param key Key slot containing a public key or an
2837 * asymmetric key pair.
2838 * \param alg A signature algorithm that is compatible with
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002839 * the type of \p key.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002840 * \param[in] hash The hash or message whose signature is to be
Gilles Peskine08bac712018-06-26 16:14:46 +02002841 * verified.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002842 * \param hash_length Size of the \p hash buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002843 * \param[in] signature Buffer containing the signature to verify.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002844 * \param signature_length Size of the \p signature buffer in bytes.
Gilles Peskine308b91d2018-02-08 09:47:44 +01002845 *
Gilles Peskine28538492018-07-11 17:34:00 +02002846 * \retval #PSA_SUCCESS
Gilles Peskine308b91d2018-02-08 09:47:44 +01002847 * The signature is valid.
Gilles Peskine28538492018-07-11 17:34:00 +02002848 * \retval #PSA_ERROR_INVALID_SIGNATURE
Gilles Peskine308b91d2018-02-08 09:47:44 +01002849 * The calculation was perfomed successfully, but the passed
2850 * signature is not a valid signature.
Gilles Peskine28538492018-07-11 17:34:00 +02002851 * \retval #PSA_ERROR_NOT_SUPPORTED
2852 * \retval #PSA_ERROR_INVALID_ARGUMENT
2853 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2854 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2855 * \retval #PSA_ERROR_HARDWARE_FAILURE
2856 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03002857 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002858 * The library has not been previously initialized by psa_crypto_init().
2859 * It is implementation-dependent whether a failure to initialize
2860 * results in this error code.
Gilles Peskine20035e32018-02-03 22:44:14 +01002861 */
2862psa_status_t psa_asymmetric_verify(psa_key_slot_t key,
2863 psa_algorithm_t alg,
2864 const uint8_t *hash,
2865 size_t hash_length,
Gilles Peskinee9191ff2018-06-27 14:58:41 +02002866 const uint8_t *signature,
Gilles Peskine526fab02018-06-27 18:19:40 +02002867 size_t signature_length);
Gilles Peskine20035e32018-02-03 22:44:14 +01002868
Gilles Peskine723feff2018-05-31 20:08:13 +02002869#define PSA_RSA_MINIMUM_PADDING_SIZE(alg) \
Gilles Peskine072ac562018-06-30 00:21:29 +02002870 (PSA_ALG_IS_RSA_OAEP(alg) ? \
2871 2 * PSA_HASH_FINAL_SIZE(PSA_ALG_RSA_OAEP_GET_HASH(alg)) + 1 : \
Gilles Peskine723feff2018-05-31 20:08:13 +02002872 11 /*PKCS#1v1.5*/)
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002873
2874/**
2875 * \brief Encrypt a short message with a public key.
2876 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002877 * \param key Key slot containing a public key or an
2878 * asymmetric key pair.
2879 * \param alg An asymmetric encryption algorithm that is
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002880 * compatible with the type of \p key.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002881 * \param[in] input The message to encrypt.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002882 * \param input_length Size of the \p input buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002883 * \param[in] salt A salt or label, if supported by the
2884 * encryption algorithm.
2885 * If the algorithm does not support a
2886 * salt, pass \c NULL.
2887 * If the algorithm supports an optional
2888 * salt and you do not want to pass a salt,
2889 * pass \c NULL.
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002890 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002891 * - For #PSA_ALG_RSA_PKCS1V15_CRYPT, no salt is
2892 * supported.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002893 * \param salt_length Size of the \p salt buffer in bytes.
2894 * If \p salt is \c NULL, pass 0.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002895 * \param[out] output Buffer where the encrypted message is to
2896 * be written.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002897 * \param output_size Size of the \p output buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002898 * \param[out] output_length On success, the number of bytes
2899 * that make up the returned output.
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002900 *
Gilles Peskine28538492018-07-11 17:34:00 +02002901 * \retval #PSA_SUCCESS
2902 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002903 * The size of the \p output buffer is too small. You can
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002904 * determine a sufficient buffer size by calling
Gilles Peskine7256e6c2018-07-12 00:34:26 +02002905 * #PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002906 * where \c key_type and \c key_bits are the type and bit-size
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002907 * respectively of \p key.
Gilles Peskine28538492018-07-11 17:34:00 +02002908 * \retval #PSA_ERROR_NOT_SUPPORTED
2909 * \retval #PSA_ERROR_INVALID_ARGUMENT
2910 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2911 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2912 * \retval #PSA_ERROR_HARDWARE_FAILURE
2913 * \retval #PSA_ERROR_TAMPERING_DETECTED
2914 * \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
itayzafrir90d8c7a2018-09-12 11:44:52 +03002915 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002916 * The library has not been previously initialized by psa_crypto_init().
2917 * It is implementation-dependent whether a failure to initialize
2918 * results in this error code.
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002919 */
2920psa_status_t psa_asymmetric_encrypt(psa_key_slot_t key,
2921 psa_algorithm_t alg,
2922 const uint8_t *input,
2923 size_t input_length,
2924 const uint8_t *salt,
2925 size_t salt_length,
2926 uint8_t *output,
2927 size_t output_size,
2928 size_t *output_length);
2929
2930/**
2931 * \brief Decrypt a short message with a private key.
2932 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002933 * \param key Key slot containing an asymmetric key pair.
2934 * \param alg An asymmetric encryption algorithm that is
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002935 * compatible with the type of \p key.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002936 * \param[in] input The message to decrypt.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002937 * \param input_length Size of the \p input buffer in bytes.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002938 * \param[in] salt A salt or label, if supported by the
2939 * encryption algorithm.
2940 * If the algorithm does not support a
2941 * salt, pass \c NULL.
2942 * If the algorithm supports an optional
2943 * salt and you do not want to pass a salt,
2944 * pass \c NULL.
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002945 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02002946 * - For #PSA_ALG_RSA_PKCS1V15_CRYPT, no salt is
2947 * supported.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002948 * \param salt_length Size of the \p salt buffer in bytes.
2949 * If \p salt is \c NULL, pass 0.
Gilles Peskineedd11a12018-07-12 01:08:58 +02002950 * \param[out] output Buffer where the decrypted message is to
2951 * be written.
2952 * \param output_size Size of the \c output buffer in bytes.
2953 * \param[out] output_length On success, the number of bytes
2954 * that make up the returned output.
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002955 *
Gilles Peskine28538492018-07-11 17:34:00 +02002956 * \retval #PSA_SUCCESS
2957 * \retval #PSA_ERROR_BUFFER_TOO_SMALL
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002958 * The size of the \p output buffer is too small. You can
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002959 * determine a sufficient buffer size by calling
Gilles Peskinedda3bd32018-07-12 19:40:46 +02002960 * #PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002961 * where \c key_type and \c key_bits are the type and bit-size
Gilles Peskinefa4070c2018-07-12 19:23:03 +02002962 * respectively of \p key.
Gilles Peskine28538492018-07-11 17:34:00 +02002963 * \retval #PSA_ERROR_NOT_SUPPORTED
2964 * \retval #PSA_ERROR_INVALID_ARGUMENT
2965 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
2966 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
2967 * \retval #PSA_ERROR_HARDWARE_FAILURE
2968 * \retval #PSA_ERROR_TAMPERING_DETECTED
2969 * \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
2970 * \retval #PSA_ERROR_INVALID_PADDING
itayzafrir90d8c7a2018-09-12 11:44:52 +03002971 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03002972 * The library has not been previously initialized by psa_crypto_init().
2973 * It is implementation-dependent whether a failure to initialize
2974 * results in this error code.
Gilles Peskine6944f9a2018-03-28 14:18:39 +02002975 */
2976psa_status_t psa_asymmetric_decrypt(psa_key_slot_t key,
2977 psa_algorithm_t alg,
2978 const uint8_t *input,
2979 size_t input_length,
2980 const uint8_t *salt,
2981 size_t salt_length,
2982 uint8_t *output,
2983 size_t output_size,
2984 size_t *output_length);
2985
Gilles Peskine2f9c4dc2018-01-28 13:16:24 +01002986/**@}*/
2987
Gilles Peskineedd76872018-07-20 17:42:05 +02002988/** \defgroup generators Generators
Gilles Peskineeab56e42018-07-12 17:12:33 +02002989 * @{
2990 */
2991
2992/** The type of the state data structure for generators.
2993 *
2994 * Before calling any function on a generator, the application must
2995 * initialize it by any of the following means:
2996 * - Set the structure to all-bits-zero, for example:
2997 * \code
2998 * psa_crypto_generator_t generator;
2999 * memset(&generator, 0, sizeof(generator));
3000 * \endcode
3001 * - Initialize the structure to logical zero values, for example:
3002 * \code
3003 * psa_crypto_generator_t generator = {0};
3004 * \endcode
3005 * - Initialize the structure to the initializer #PSA_CRYPTO_GENERATOR_INIT,
3006 * for example:
3007 * \code
3008 * psa_crypto_generator_t generator = PSA_CRYPTO_GENERATOR_INIT;
3009 * \endcode
3010 * - Assign the result of the function psa_crypto_generator_init()
3011 * to the structure, for example:
3012 * \code
3013 * psa_crypto_generator_t generator;
3014 * generator = psa_crypto_generator_init();
3015 * \endcode
3016 *
3017 * This is an implementation-defined \c struct. Applications should not
3018 * make any assumptions about the content of this structure except
3019 * as directed by the documentation of a specific implementation.
3020 */
3021typedef struct psa_crypto_generator_s psa_crypto_generator_t;
3022
3023/** \def PSA_CRYPTO_GENERATOR_INIT
3024 *
3025 * This macro returns a suitable initializer for a generator object
3026 * of type #psa_crypto_generator_t.
3027 */
3028#ifdef __DOXYGEN_ONLY__
3029/* This is an example definition for documentation purposes.
3030 * Implementations should define a suitable value in `crypto_struct.h`.
3031 */
3032#define PSA_CRYPTO_GENERATOR_INIT {0}
3033#endif
3034
3035/** Return an initial value for a generator object.
3036 */
3037static psa_crypto_generator_t psa_crypto_generator_init(void);
3038
3039/** Retrieve the current capacity of a generator.
3040 *
3041 * The capacity of a generator is the maximum number of bytes that it can
3042 * return. Reading *N* bytes from a generator reduces its capacity by *N*.
3043 *
3044 * \param[in] generator The generator to query.
3045 * \param[out] capacity On success, the capacity of the generator.
3046 *
3047 * \retval PSA_SUCCESS
3048 * \retval PSA_ERROR_BAD_STATE
3049 * \retval PSA_ERROR_COMMUNICATION_FAILURE
3050 */
3051psa_status_t psa_get_generator_capacity(const psa_crypto_generator_t *generator,
3052 size_t *capacity);
3053
3054/** Read some data from a generator.
3055 *
3056 * This function reads and returns a sequence of bytes from a generator.
3057 * The data that is read is discarded from the generator. The generator's
3058 * capacity is decreased by the number of bytes read.
3059 *
3060 * \param[in,out] generator The generator object to read from.
3061 * \param[out] output Buffer where the generator output will be
3062 * written.
3063 * \param output_length Number of bytes to output.
3064 *
3065 * \retval PSA_SUCCESS
3066 * \retval PSA_ERROR_INSUFFICIENT_CAPACITY
3067 * There were fewer than \p output_length bytes
3068 * in the generator. Note that in this case, no
3069 * output is written to the output buffer.
3070 * The generator's capacity is set to 0, thus
3071 * subsequent calls to this function will not
3072 * succeed, even with a smaller output buffer.
3073 * \retval PSA_ERROR_BAD_STATE
3074 * \retval PSA_ERROR_INSUFFICIENT_MEMORY
3075 * \retval PSA_ERROR_COMMUNICATION_FAILURE
3076 * \retval PSA_ERROR_HARDWARE_FAILURE
3077 * \retval PSA_ERROR_TAMPERING_DETECTED
3078 */
3079psa_status_t psa_generator_read(psa_crypto_generator_t *generator,
3080 uint8_t *output,
3081 size_t output_length);
3082
3083/** Create a symmetric key from data read from a generator.
3084 *
3085 * This function reads a sequence of bytes from a generator and imports
3086 * these bytes as a key.
3087 * The data that is read is discarded from the generator. The generator's
3088 * capacity is decreased by the number of bytes read.
3089 *
3090 * This function is equivalent to calling #psa_generator_read and
3091 * passing the resulting output to #psa_import_key, but
3092 * if the implementation provides an isolation boundary then
3093 * the key material is not exposed outside the isolation boundary.
3094 *
3095 * \param key Slot where the key will be stored. This must be a
3096 * valid slot for a key of the chosen type. It must
3097 * be unoccupied.
3098 * \param type Key type (a \c PSA_KEY_TYPE_XXX value).
3099 * This must be a symmetric key type.
3100 * \param bits Key size in bits.
3101 * \param[in,out] generator The generator object to read from.
3102 *
3103 * \retval PSA_SUCCESS
3104 * Success.
3105 * \retval PSA_ERROR_INSUFFICIENT_CAPACITY
3106 * There were fewer than \p output_length bytes
3107 * in the generator. Note that in this case, no
3108 * output is written to the output buffer.
3109 * The generator's capacity is set to 0, thus
3110 * subsequent calls to this function will not
3111 * succeed, even with a smaller output buffer.
3112 * \retval PSA_ERROR_NOT_SUPPORTED
3113 * The key type or key size is not supported, either by the
3114 * implementation in general or in this particular slot.
3115 * \retval PSA_ERROR_BAD_STATE
3116 * \retval PSA_ERROR_INVALID_ARGUMENT
3117 * The key slot is invalid.
3118 * \retval PSA_ERROR_OCCUPIED_SLOT
3119 * There is already a key in the specified slot.
3120 * \retval PSA_ERROR_INSUFFICIENT_MEMORY
3121 * \retval PSA_ERROR_INSUFFICIENT_STORAGE
3122 * \retval PSA_ERROR_COMMUNICATION_FAILURE
3123 * \retval PSA_ERROR_HARDWARE_FAILURE
3124 * \retval PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03003125 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03003126 * The library has not been previously initialized by psa_crypto_init().
3127 * It is implementation-dependent whether a failure to initialize
3128 * results in this error code.
Gilles Peskineeab56e42018-07-12 17:12:33 +02003129 */
3130psa_status_t psa_generator_import_key(psa_key_slot_t key,
3131 psa_key_type_t type,
3132 size_t bits,
3133 psa_crypto_generator_t *generator);
3134
3135/** Abort a generator.
3136 *
3137 * Once a generator has been aborted, its capacity is zero.
3138 * Aborting a generator frees all associated resources except for the
3139 * \c generator structure itself.
3140 *
3141 * This function may be called at any time as long as the generator
3142 * object has been initialized to #PSA_CRYPTO_GENERATOR_INIT, to
3143 * psa_crypto_generator_init() or a zero value. In particular, it is valid
3144 * to call psa_generator_abort() twice, or to call psa_generator_abort()
3145 * on a generator that has not been set up.
3146 *
3147 * Once aborted, the generator object may be called.
3148 *
3149 * \param[in,out] generator The generator to abort.
3150 *
3151 * \retval PSA_SUCCESS
3152 * \retval PSA_ERROR_BAD_STATE
3153 * \retval PSA_ERROR_COMMUNICATION_FAILURE
3154 * \retval PSA_ERROR_HARDWARE_FAILURE
3155 * \retval PSA_ERROR_TAMPERING_DETECTED
3156 */
3157psa_status_t psa_generator_abort(psa_crypto_generator_t *generator);
3158
Gilles Peskine8feb3a82018-09-18 12:06:11 +02003159/** Use the maximum possible capacity for a generator.
3160 *
3161 * Use this value as the capacity argument when setting up a generator
3162 * to indicate that the generator should have the maximum possible capacity.
3163 * The value of the maximum possible capacity depends on the generator
3164 * algorithm.
3165 */
3166#define PSA_GENERATOR_UNBRIDLED_CAPACITY ((size_t)(-1))
3167
Gilles Peskineeab56e42018-07-12 17:12:33 +02003168/**@}*/
3169
Gilles Peskineea0fb492018-07-12 17:17:20 +02003170/** \defgroup derivation Key derivation
3171 * @{
3172 */
3173
3174/** Set up a key derivation operation.
3175 *
3176 * A key derivation algorithm takes three inputs: a secret input \p key and
3177 * two non-secret inputs \p label and p salt.
3178 * The result of this function is a byte generator which can
3179 * be used to produce keys and other cryptographic material.
3180 *
3181 * The role of \p label and \p salt is as follows:
Gilles Peskinebef7f142018-07-12 17:22:21 +02003182 * - For HKDF (#PSA_ALG_HKDF), \p salt is the salt used in the "extract" step
3183 * and \p label is the info string used in the "expand" step.
Gilles Peskineea0fb492018-07-12 17:17:20 +02003184 *
3185 * \param[in,out] generator The generator object to set up. It must
Gilles Peskine92587db2018-09-18 12:12:42 +02003186 * have been initialized to all-bits-zero,
3187 * a logical zero (`{0}`),
3188 * \c PSA_CRYPTO_GENERATOR_INIT or
3189 * psa_crypto_generator_init().
Gilles Peskineea0fb492018-07-12 17:17:20 +02003190 * \param key Slot containing the secret key to use.
3191 * \param alg The key derivation algorithm to compute
3192 * (\c PSA_ALG_XXX value such that
3193 * #PSA_ALG_IS_KEY_DERIVATION(\p alg) is true).
3194 * \param[in] salt Salt to use.
3195 * \param salt_length Size of the \p salt buffer in bytes.
3196 * \param[in] label Label to use.
3197 * \param label_length Size of the \p label buffer in bytes.
3198 * \param capacity The maximum number of bytes that the
3199 * generator will be able to provide.
3200 *
3201 * \retval #PSA_SUCCESS
3202 * Success.
3203 * \retval #PSA_ERROR_EMPTY_SLOT
3204 * \retval #PSA_ERROR_NOT_PERMITTED
3205 * \retval #PSA_ERROR_INVALID_ARGUMENT
3206 * \c key is not compatible with \c alg,
3207 * or \p capacity is too large for the specified algorithm and key.
3208 * \retval #PSA_ERROR_NOT_SUPPORTED
3209 * \c alg is not supported or is not a key derivation algorithm.
3210 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
3211 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
3212 * \retval #PSA_ERROR_HARDWARE_FAILURE
3213 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03003214 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03003215 * The library has not been previously initialized by psa_crypto_init().
3216 * It is implementation-dependent whether a failure to initialize
3217 * results in this error code.
Gilles Peskineea0fb492018-07-12 17:17:20 +02003218 */
3219psa_status_t psa_key_derivation(psa_crypto_generator_t *generator,
Darryl Green88001362018-07-26 13:59:04 +01003220 psa_key_slot_t key,
Gilles Peskineea0fb492018-07-12 17:17:20 +02003221 psa_algorithm_t alg,
3222 const uint8_t *salt,
3223 size_t salt_length,
3224 const uint8_t *label,
3225 size_t label_length,
3226 size_t capacity);
3227
Gilles Peskine01d718c2018-09-18 12:01:02 +02003228/** Set up a key agreement operation.
3229 *
3230 * A key agreement algorithm takes two inputs: a private key \p private_key
3231 * a public key \p peer_key.
3232 * The result of this function is a byte generator which can
3233 * be used to produce keys and other cryptographic material.
3234 *
Gilles Peskine211a4362018-10-25 22:22:31 +02003235 * The resulting generator always has the maximum capacity permitted by
3236 * the algorithm.
3237 *
Gilles Peskine01d718c2018-09-18 12:01:02 +02003238 * \param[in,out] generator The generator object to set up. It must
3239 * have been initialized to all-bits-zero,
3240 * a logical zero (`{0}`),
3241 * \c PSA_CRYPTO_GENERATOR_INIT or
3242 * psa_crypto_generator_init().
3243 * \param private_key Slot containing the private key to use.
Gilles Peskined171e782018-11-15 17:46:21 +01003244 * \param[in] peer_key Public key of the peer. It must be
3245 * in the same format that psa_import_key()
3246 * accepts. The standard formats for public
3247 * keys are documented in the documentation
3248 * of psa_export_public_key().
Gilles Peskine01d718c2018-09-18 12:01:02 +02003249 * \param peer_key_length Size of \p peer_key in bytes.
3250 * \param alg The key agreement algorithm to compute
3251 * (\c PSA_ALG_XXX value such that
3252 * #PSA_ALG_IS_KEY_AGREEMENT(\p alg) is true).
3253 *
3254 * \retval #PSA_SUCCESS
3255 * Success.
3256 * \retval #PSA_ERROR_EMPTY_SLOT
3257 * \retval #PSA_ERROR_NOT_PERMITTED
3258 * \retval #PSA_ERROR_INVALID_ARGUMENT
3259 * \c private_key is not compatible with \c alg,
3260 * or \p peer_key is not valid for \c alg or not compatible with
3261 * \c private_key.
3262 * \retval #PSA_ERROR_NOT_SUPPORTED
3263 * \c alg is not supported or is not a key derivation algorithm.
3264 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
3265 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
3266 * \retval #PSA_ERROR_HARDWARE_FAILURE
3267 * \retval #PSA_ERROR_TAMPERING_DETECTED
3268 */
3269psa_status_t psa_key_agreement(psa_crypto_generator_t *generator,
3270 psa_key_slot_t private_key,
3271 const uint8_t *peer_key,
3272 size_t peer_key_length,
3273 psa_algorithm_t alg);
3274
Gilles Peskineea0fb492018-07-12 17:17:20 +02003275/**@}*/
3276
Gilles Peskineedd76872018-07-20 17:42:05 +02003277/** \defgroup random Random generation
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003278 * @{
3279 */
3280
3281/**
3282 * \brief Generate random bytes.
3283 *
3284 * \warning This function **can** fail! Callers MUST check the return status
3285 * and MUST NOT use the content of the output buffer if the return
3286 * status is not #PSA_SUCCESS.
3287 *
3288 * \note To generate a key, use psa_generate_key() instead.
3289 *
Gilles Peskineedd11a12018-07-12 01:08:58 +02003290 * \param[out] output Output buffer for the generated data.
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003291 * \param output_size Number of bytes to generate and output.
3292 *
Gilles Peskine28538492018-07-11 17:34:00 +02003293 * \retval #PSA_SUCCESS
3294 * \retval #PSA_ERROR_NOT_SUPPORTED
3295 * \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
3296 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
3297 * \retval #PSA_ERROR_HARDWARE_FAILURE
3298 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir0adf0fc2018-09-06 16:24:41 +03003299 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03003300 * The library has not been previously initialized by psa_crypto_init().
3301 * It is implementation-dependent whether a failure to initialize
3302 * results in this error code.
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003303 */
3304psa_status_t psa_generate_random(uint8_t *output,
3305 size_t output_size);
3306
Gilles Peskine4c317f42018-07-12 01:24:09 +02003307/** Extra parameters for RSA key generation.
3308 *
Gilles Peskinebe42f312018-07-13 14:38:15 +02003309 * You may pass a pointer to a structure of this type as the \c extra
Gilles Peskine4c317f42018-07-12 01:24:09 +02003310 * parameter to psa_generate_key().
3311 */
3312typedef struct {
Gilles Peskineedd76872018-07-20 17:42:05 +02003313 uint32_t e; /**< Public exponent value. Default: 65537. */
Gilles Peskine4c317f42018-07-12 01:24:09 +02003314} psa_generate_key_extra_rsa;
3315
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003316/**
3317 * \brief Generate a key or key pair.
3318 *
Gilles Peskine4e69d7a2018-06-19 20:19:14 +02003319 * \param key Slot where the key will be stored. This must be a
3320 * valid slot for a key of the chosen type. It must
3321 * be unoccupied.
3322 * \param type Key type (a \c PSA_KEY_TYPE_XXX value).
3323 * \param bits Key size in bits.
Gilles Peskine53d991e2018-07-12 01:14:59 +02003324 * \param[in] extra Extra parameters for key generation. The
Gilles Peskine4e69d7a2018-06-19 20:19:14 +02003325 * interpretation of this parameter depends on
Gilles Peskinefa4070c2018-07-12 19:23:03 +02003326 * \p type. All types support \c NULL to use
Gilles Peskine3fa675c2018-07-12 01:31:03 +02003327 * default parameters. Implementation that support
3328 * the generation of vendor-specific key types
3329 * that allow extra parameters shall document
3330 * the format of these extra parameters and
3331 * the default values. For standard parameters,
3332 * the meaning of \p extra is as follows:
Gilles Peskinefa4070c2018-07-12 19:23:03 +02003333 * - For a symmetric key type (a type such
Gilles Peskine3fa675c2018-07-12 01:31:03 +02003334 * that #PSA_KEY_TYPE_IS_ASYMMETRIC(\p type) is
3335 * false), \p extra must be \c NULL.
Gilles Peskinefa4070c2018-07-12 19:23:03 +02003336 * - For an elliptic curve key type (a type
Gilles Peskine3fa675c2018-07-12 01:31:03 +02003337 * such that #PSA_KEY_TYPE_IS_ECC(\p type) is
3338 * false), \p extra must be \c NULL.
Gilles Peskinedda3bd32018-07-12 19:40:46 +02003339 * - For an RSA key (\p type is
3340 * #PSA_KEY_TYPE_RSA_KEYPAIR), \p extra is an
3341 * optional #psa_generate_key_extra_rsa structure
Gilles Peskine3fa675c2018-07-12 01:31:03 +02003342 * specifying the public exponent. The
3343 * default public exponent used when \p extra
3344 * is \c NULL is 65537.
Gilles Peskine53d991e2018-07-12 01:14:59 +02003345 * \param extra_size Size of the buffer that \p extra
3346 * points to, in bytes. Note that if \p extra is
3347 * \c NULL then \p extra_size must be zero.
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003348 *
Gilles Peskine28538492018-07-11 17:34:00 +02003349 * \retval #PSA_SUCCESS
3350 * \retval #PSA_ERROR_NOT_SUPPORTED
3351 * \retval #PSA_ERROR_INVALID_ARGUMENT
3352 * \retval #PSA_ERROR_INSUFFICIENT_MEMORY
3353 * \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
3354 * \retval #PSA_ERROR_COMMUNICATION_FAILURE
3355 * \retval #PSA_ERROR_HARDWARE_FAILURE
3356 * \retval #PSA_ERROR_TAMPERING_DETECTED
itayzafrir90d8c7a2018-09-12 11:44:52 +03003357 * \retval #PSA_ERROR_BAD_STATE
itayzafrir18617092018-09-16 12:22:41 +03003358 * The library has not been previously initialized by psa_crypto_init().
3359 * It is implementation-dependent whether a failure to initialize
3360 * results in this error code.
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003361 */
3362psa_status_t psa_generate_key(psa_key_slot_t key,
3363 psa_key_type_t type,
3364 size_t bits,
Gilles Peskine53d991e2018-07-12 01:14:59 +02003365 const void *extra,
3366 size_t extra_size);
Gilles Peskine9e7dc712018-03-28 14:18:50 +02003367
3368/**@}*/
3369
Gilles Peskinee59236f2018-01-27 23:32:46 +01003370#ifdef __cplusplus
3371}
3372#endif
3373
Gilles Peskine0cad07c2018-06-27 19:49:02 +02003374/* The file "crypto_sizes.h" contains definitions for size calculation
3375 * macros whose definitions are implementation-specific. */
3376#include "crypto_sizes.h"
3377
Gilles Peskine9ef733f2018-02-07 21:05:37 +01003378/* The file "crypto_struct.h" contains definitions for
3379 * implementation-specific structs that are declared above. */
3380#include "crypto_struct.h"
3381
3382/* The file "crypto_extra.h" contains vendor-specific definitions. This
3383 * can include vendor-defined algorithms, extra functions, etc. */
Gilles Peskinee59236f2018-01-27 23:32:46 +01003384#include "crypto_extra.h"
3385
3386#endif /* PSA_CRYPTO_H */