4692 lines
214 KiB
C
4692 lines
214 KiB
C
/**
|
||
* \file psa/crypto.h
|
||
* \brief Platform Security Architecture cryptography module
|
||
*/
|
||
/*
|
||
* Copyright The Mbed TLS Contributors
|
||
* SPDX-License-Identifier: Apache-2.0
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License"); you may
|
||
* not use this file except in compliance with the License.
|
||
* You may obtain a copy of the License at
|
||
*
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software
|
||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
* See the License for the specific language governing permissions and
|
||
* limitations under the License.
|
||
*/
|
||
|
||
#ifndef PSA_CRYPTO_H
|
||
#define PSA_CRYPTO_H
|
||
|
||
#include "crypto_platform.h"
|
||
|
||
#include <stddef.h>
|
||
|
||
#ifdef __DOXYGEN_ONLY__
|
||
/* This __DOXYGEN_ONLY__ block contains mock definitions for things that
|
||
* must be defined in the crypto_platform.h header. These mock definitions
|
||
* are present in this file as a convenience to generate pretty-printed
|
||
* documentation that includes those definitions. */
|
||
|
||
/** \defgroup platform Implementation-specific definitions
|
||
* @{
|
||
*/
|
||
|
||
/**@}*/
|
||
#endif /* __DOXYGEN_ONLY__ */
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
/* The file "crypto_types.h" declares types that encode errors,
|
||
* algorithms, key types, policies, etc. */
|
||
#include "crypto_types.h"
|
||
|
||
/** \defgroup version API version
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* The major version of this implementation of the PSA Crypto API
|
||
*/
|
||
#define PSA_CRYPTO_API_VERSION_MAJOR 1
|
||
|
||
/**
|
||
* The minor version of this implementation of the PSA Crypto API
|
||
*/
|
||
#define PSA_CRYPTO_API_VERSION_MINOR 0
|
||
|
||
/**@}*/
|
||
|
||
/* The file "crypto_values.h" declares macros to build and analyze values
|
||
* of integral types defined in "crypto_types.h". */
|
||
#include "crypto_values.h"
|
||
|
||
/** \defgroup initialization Library initialization
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* \brief Library initialization.
|
||
*
|
||
* Applications must call this function before calling any other
|
||
* function in this module.
|
||
*
|
||
* Applications may call this function more than once. Once a call
|
||
* succeeds, subsequent calls are guaranteed to succeed.
|
||
*
|
||
* If the application calls other functions before calling psa_crypto_init(),
|
||
* the behavior is undefined. Implementations are encouraged to either perform
|
||
* the operation as if the library had been initialized or to return
|
||
* #PSA_ERROR_BAD_STATE or some other applicable error. In particular,
|
||
* implementations should not return a success status if the lack of
|
||
* initialization may have security implications, for example due to improper
|
||
* seeding of the random number generator.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_INSUFFICIENT_STORAGE
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
*/
|
||
psa_status_t psa_crypto_init(void);
|
||
|
||
/**@}*/
|
||
|
||
/** \addtogroup attributes
|
||
* @{
|
||
*/
|
||
|
||
/** \def PSA_KEY_ATTRIBUTES_INIT
|
||
*
|
||
* This macro returns a suitable initializer for a key attribute structure
|
||
* of type #psa_key_attributes_t.
|
||
*/
|
||
|
||
/** Return an initial value for a key attributes structure.
|
||
*/
|
||
static psa_key_attributes_t psa_key_attributes_init(void);
|
||
|
||
/** Declare a key as persistent and set its key identifier.
|
||
*
|
||
* If the attribute structure currently declares the key as volatile (which
|
||
* is the default content of an attribute structure), this function sets
|
||
* the lifetime attribute to #PSA_KEY_LIFETIME_PERSISTENT.
|
||
*
|
||
* This function does not access storage, it merely stores the given
|
||
* value in the structure.
|
||
* The persistent key will be written to storage when the attribute
|
||
* structure is passed to a key creation function such as
|
||
* psa_import_key(), psa_generate_key(),
|
||
* psa_key_derivation_output_key() or psa_copy_key().
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param key The persistent identifier for the key.
|
||
*/
|
||
static void psa_set_key_id( psa_key_attributes_t *attributes,
|
||
mbedtls_svc_key_id_t key );
|
||
|
||
#ifdef MBEDTLS_PSA_CRYPTO_KEY_ID_ENCODES_OWNER
|
||
/** Set the owner identifier of a key.
|
||
*
|
||
* When key identifiers encode key owner identifiers, psa_set_key_id() does
|
||
* not allow to define in key attributes the owner of volatile keys as
|
||
* psa_set_key_id() enforces the key to be persistent.
|
||
*
|
||
* This function allows to set in key attributes the owner identifier of a
|
||
* key. It is intended to be used for volatile keys. For persistent keys,
|
||
* it is recommended to use the PSA Cryptography API psa_set_key_id() to define
|
||
* the owner of a key.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param owner_id The key owner identifier.
|
||
*/
|
||
static void mbedtls_set_key_owner_id( psa_key_attributes_t *attributes,
|
||
mbedtls_key_owner_id_t owner_id );
|
||
#endif
|
||
|
||
/** Set the location of a persistent key.
|
||
*
|
||
* To make a key persistent, you must give it a persistent key identifier
|
||
* with psa_set_key_id(). By default, a key that has a persistent identifier
|
||
* is stored in the default storage area identifier by
|
||
* #PSA_KEY_LIFETIME_PERSISTENT. Call this function to choose a storage
|
||
* area, or to explicitly declare the key as volatile.
|
||
*
|
||
* This function does not access storage, it merely stores the given
|
||
* value in the structure.
|
||
* The persistent key will be written to storage when the attribute
|
||
* structure is passed to a key creation function such as
|
||
* psa_import_key(), psa_generate_key(),
|
||
* psa_key_derivation_output_key() or psa_copy_key().
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param lifetime The lifetime for the key.
|
||
* If this is #PSA_KEY_LIFETIME_VOLATILE, the
|
||
* key will be volatile, and the key identifier
|
||
* attribute is reset to 0.
|
||
*/
|
||
static void psa_set_key_lifetime(psa_key_attributes_t *attributes,
|
||
psa_key_lifetime_t lifetime);
|
||
|
||
/** Retrieve the key identifier from key attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] attributes The key attribute structure to query.
|
||
*
|
||
* \return The persistent identifier stored in the attribute structure.
|
||
* This value is unspecified if the attribute structure declares
|
||
* the key as volatile.
|
||
*/
|
||
static mbedtls_svc_key_id_t psa_get_key_id(
|
||
const psa_key_attributes_t *attributes);
|
||
|
||
/** Retrieve the lifetime from key attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] attributes The key attribute structure to query.
|
||
*
|
||
* \return The lifetime value stored in the attribute structure.
|
||
*/
|
||
static psa_key_lifetime_t psa_get_key_lifetime(
|
||
const psa_key_attributes_t *attributes);
|
||
|
||
/** Declare usage flags for a key.
|
||
*
|
||
* Usage flags are part of a key's usage policy. They encode what
|
||
* kind of operations are permitted on the key. For more details,
|
||
* refer to the documentation of the type #psa_key_usage_t.
|
||
*
|
||
* This function overwrites any usage flags
|
||
* previously set in \p attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param usage_flags The usage flags to write.
|
||
*/
|
||
static void psa_set_key_usage_flags(psa_key_attributes_t *attributes,
|
||
psa_key_usage_t usage_flags);
|
||
|
||
/** Retrieve the usage flags from key attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] attributes The key attribute structure to query.
|
||
*
|
||
* \return The usage flags stored in the attribute structure.
|
||
*/
|
||
static psa_key_usage_t psa_get_key_usage_flags(
|
||
const psa_key_attributes_t *attributes);
|
||
|
||
/** Declare the permitted algorithm policy for a key.
|
||
*
|
||
* The permitted algorithm policy of a key encodes which algorithm or
|
||
* algorithms are permitted to be used with this key. The following
|
||
* algorithm policies are supported:
|
||
* - 0 does not allow any cryptographic operation with the key. The key
|
||
* may be used for non-cryptographic actions such as exporting (if
|
||
* permitted by the usage flags).
|
||
* - An algorithm value permits this particular algorithm.
|
||
* - An algorithm wildcard built from #PSA_ALG_ANY_HASH allows the specified
|
||
* signature scheme with any hash algorithm.
|
||
* - An algorithm built from #PSA_ALG_AT_LEAST_THIS_LENGTH_MAC allows
|
||
* any MAC algorithm from the same base class (e.g. CMAC) which
|
||
* generates/verifies a MAC length greater than or equal to the length
|
||
* encoded in the wildcard algorithm.
|
||
* - An algorithm built from #PSA_ALG_AEAD_WITH_AT_LEAST_THIS_LENGTH_TAG
|
||
* allows any AEAD algorithm from the same base class (e.g. CCM) which
|
||
* generates/verifies a tag length greater than or equal to the length
|
||
* encoded in the wildcard algorithm.
|
||
*
|
||
* This function overwrites any algorithm policy
|
||
* previously set in \p attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param alg The permitted algorithm policy to write.
|
||
*/
|
||
static void psa_set_key_algorithm(psa_key_attributes_t *attributes,
|
||
psa_algorithm_t alg);
|
||
|
||
|
||
/** Retrieve the algorithm policy from key attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] attributes The key attribute structure to query.
|
||
*
|
||
* \return The algorithm stored in the attribute structure.
|
||
*/
|
||
static psa_algorithm_t psa_get_key_algorithm(
|
||
const psa_key_attributes_t *attributes);
|
||
|
||
/** Declare the type of a key.
|
||
*
|
||
* This function overwrites any key type
|
||
* previously set in \p attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param type The key type to write.
|
||
* If this is 0, the key type in \p attributes
|
||
* becomes unspecified.
|
||
*/
|
||
static void psa_set_key_type(psa_key_attributes_t *attributes,
|
||
psa_key_type_t type);
|
||
|
||
|
||
/** Declare the size of a key.
|
||
*
|
||
* This function overwrites any key size previously set in \p attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] attributes The attribute structure to write to.
|
||
* \param bits The key size in bits.
|
||
* If this is 0, the key size in \p attributes
|
||
* becomes unspecified. Keys of size 0 are
|
||
* not supported.
|
||
*/
|
||
static void psa_set_key_bits(psa_key_attributes_t *attributes,
|
||
size_t bits);
|
||
|
||
/** Retrieve the key type from key attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] attributes The key attribute structure to query.
|
||
*
|
||
* \return The key type stored in the attribute structure.
|
||
*/
|
||
static psa_key_type_t psa_get_key_type(const psa_key_attributes_t *attributes);
|
||
|
||
/** Retrieve the key size from key attributes.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] attributes The key attribute structure to query.
|
||
*
|
||
* \return The key size stored in the attribute structure, in bits.
|
||
*/
|
||
static size_t psa_get_key_bits(const psa_key_attributes_t *attributes);
|
||
|
||
/** Retrieve the attributes of a key.
|
||
*
|
||
* This function first resets the attribute structure as with
|
||
* psa_reset_key_attributes(). It then copies the attributes of
|
||
* the given key into the given attribute structure.
|
||
*
|
||
* \note This function may allocate memory or other resources.
|
||
* Once you have called this function on an attribute structure,
|
||
* you must call psa_reset_key_attributes() to free these resources.
|
||
*
|
||
* \param[in] key Identifier of the key to query.
|
||
* \param[in,out] attributes On success, the attributes of the key.
|
||
* On failure, equivalent to a
|
||
* freshly-initialized structure.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_get_key_attributes(mbedtls_svc_key_id_t key,
|
||
psa_key_attributes_t *attributes);
|
||
|
||
/** Reset a key attribute structure to a freshly initialized state.
|
||
*
|
||
* You must initialize the attribute structure as described in the
|
||
* documentation of the type #psa_key_attributes_t before calling this
|
||
* function. Once the structure has been initialized, you may call this
|
||
* function at any time.
|
||
*
|
||
* This function frees any auxiliary resources that the structure
|
||
* may contain.
|
||
*
|
||
* \param[in,out] attributes The attribute structure to reset.
|
||
*/
|
||
void psa_reset_key_attributes(psa_key_attributes_t *attributes);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup key_management Key management
|
||
* @{
|
||
*/
|
||
|
||
/** Remove non-essential copies of key material from memory.
|
||
*
|
||
* If the key identifier designates a volatile key, this functions does not do
|
||
* anything and returns successfully.
|
||
*
|
||
* If the key identifier designates a persistent key, then this function will
|
||
* free all resources associated with the key in volatile memory. The key
|
||
* data in persistent storage is not affected and the key can still be used.
|
||
*
|
||
* \param key Identifier of the key to purge.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* The key material will have been removed from memory if it is not
|
||
* currently required.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not a valid key identifier.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_purge_key(mbedtls_svc_key_id_t key);
|
||
|
||
/** Make a copy of a key.
|
||
*
|
||
* Copy key material from one location to another.
|
||
*
|
||
* This function is primarily useful to copy a key from one location
|
||
* to another, since it populates a key using the material from
|
||
* another key which may have a different lifetime.
|
||
*
|
||
* This function may be used to share a key with a different party,
|
||
* subject to implementation-defined restrictions on key sharing.
|
||
*
|
||
* The policy on the source key must have the usage flag
|
||
* #PSA_KEY_USAGE_COPY set.
|
||
* This flag is sufficient to permit the copy if the key has the lifetime
|
||
* #PSA_KEY_LIFETIME_VOLATILE or #PSA_KEY_LIFETIME_PERSISTENT.
|
||
* Some secure elements do not provide a way to copy a key without
|
||
* making it extractable from the secure element. If a key is located
|
||
* in such a secure element, then the key must have both usage flags
|
||
* #PSA_KEY_USAGE_COPY and #PSA_KEY_USAGE_EXPORT in order to make
|
||
* a copy of the key outside the secure element.
|
||
*
|
||
* The resulting key may only be used in a way that conforms to
|
||
* both the policy of the original key and the policy specified in
|
||
* the \p attributes parameter:
|
||
* - The usage flags on the resulting key are the bitwise-and of the
|
||
* usage flags on the source policy and the usage flags in \p attributes.
|
||
* - If both allow the same algorithm or wildcard-based
|
||
* algorithm policy, the resulting key has the same algorithm policy.
|
||
* - If either of the policies allows an algorithm and the other policy
|
||
* allows a wildcard-based algorithm policy that includes this algorithm,
|
||
* the resulting key allows the same algorithm.
|
||
* - If the policies do not allow any algorithm in common, this function
|
||
* fails with the status #PSA_ERROR_INVALID_ARGUMENT.
|
||
*
|
||
* The effect of this function on implementation-defined attributes is
|
||
* implementation-defined.
|
||
*
|
||
* \param source_key The key to copy. It must allow the usage
|
||
* #PSA_KEY_USAGE_COPY. If a private or secret key is
|
||
* being copied outside of a secure element it must
|
||
* also allow #PSA_KEY_USAGE_EXPORT.
|
||
* \param[in] attributes The attributes for the new key.
|
||
* They are used as follows:
|
||
* - The key type and size may be 0. If either is
|
||
* nonzero, it must match the corresponding
|
||
* attribute of the source key.
|
||
* - The key location (the lifetime and, for
|
||
* persistent keys, the key identifier) is
|
||
* used directly.
|
||
* - The policy constraints (usage flags and
|
||
* algorithm policy) are combined from
|
||
* the source key and \p attributes so that
|
||
* both sets of restrictions apply, as
|
||
* described in the documentation of this function.
|
||
* \param[out] target_key On success, an identifier for the newly created
|
||
* key. For persistent keys, this is the key
|
||
* identifier defined in \p attributes.
|
||
* \c 0 on failure.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \p source_key is invalid.
|
||
* \retval #PSA_ERROR_ALREADY_EXISTS
|
||
* This is an attempt to create a persistent key, and there is
|
||
* already a persistent key with the given identifier.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The lifetime or identifier in \p attributes are invalid.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The policy constraints on the source and specified in
|
||
* \p attributes are incompatible.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p attributes specifies a key type or key size
|
||
* which does not match the attributes of the source key.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The source key does not have the #PSA_KEY_USAGE_COPY usage flag.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The source key is not exportable and its lifetime does not
|
||
* allow copying it to the target's lifetime.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_INSUFFICIENT_STORAGE
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_copy_key(mbedtls_svc_key_id_t source_key,
|
||
const psa_key_attributes_t *attributes,
|
||
mbedtls_svc_key_id_t *target_key);
|
||
|
||
|
||
/**
|
||
* \brief Destroy a key.
|
||
*
|
||
* This function destroys a key from both volatile
|
||
* memory and, if applicable, non-volatile storage. Implementations shall
|
||
* make a best effort to ensure that that the key material cannot be recovered.
|
||
*
|
||
* This function also erases any metadata such as policies and frees
|
||
* resources associated with the key.
|
||
*
|
||
* If a key is currently in use in a multipart operation, then destroying the
|
||
* key will cause the multipart operation to fail.
|
||
*
|
||
* \param key Identifier of the key to erase. If this is \c 0, do nothing and
|
||
* return #PSA_SUCCESS.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \p key was a valid identifier and the key material that it
|
||
* referred to has been erased. Alternatively, \p key is \c 0.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The key cannot be erased because it is
|
||
* read-only, either due to a policy or due to physical restrictions.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \p key is not a valid identifier nor \c 0.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* There was an failure in communication with the cryptoprocessor.
|
||
* The key material may still be present in the cryptoprocessor.
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* This error is typically a result of either storage corruption on a
|
||
* cleartext storage backend, or an attempt to read data that was
|
||
* written by an incompatible version of the library.
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* The storage is corrupted. Implementations shall make a best effort
|
||
* to erase key material even in this stage, however applications
|
||
* should be aware that it may be impossible to guarantee that the
|
||
* key material is not recoverable in such cases.
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* An unexpected condition which is not a storage corruption or
|
||
* a communication failure occurred. The cryptoprocessor may have
|
||
* been compromised.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_destroy_key(mbedtls_svc_key_id_t key);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup import_export Key import and export
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* \brief Import a key in binary format.
|
||
*
|
||
* This function supports any output from psa_export_key(). Refer to the
|
||
* documentation of psa_export_public_key() for the format of public keys
|
||
* and to the documentation of psa_export_key() for the format for
|
||
* other key types.
|
||
*
|
||
* The key data determines the key size. The attributes may optionally
|
||
* specify a key size; in this case it must match the size determined
|
||
* from the key data. A key size of 0 in \p attributes indicates that
|
||
* the key size is solely determined by the key data.
|
||
*
|
||
* Implementations must reject an attempt to import a key of size 0.
|
||
*
|
||
* This specification supports a single format for each key type.
|
||
* Implementations may support other formats as long as the standard
|
||
* format is supported. Implementations that support other formats
|
||
* should ensure that the formats are clearly unambiguous so as to
|
||
* minimize the risk that an invalid input is accidentally interpreted
|
||
* according to a different format.
|
||
*
|
||
* \param[in] attributes The attributes for the new key.
|
||
* The key size is always determined from the
|
||
* \p data buffer.
|
||
* If the key size in \p attributes is nonzero,
|
||
* it must be equal to the size from \p data.
|
||
* \param[out] key On success, an identifier to the newly created key.
|
||
* For persistent keys, this is the key identifier
|
||
* defined in \p attributes.
|
||
* \c 0 on failure.
|
||
* \param[in] data Buffer containing the key data. The content of this
|
||
* buffer is interpreted according to the type declared
|
||
* in \p attributes.
|
||
* All implementations must support at least the format
|
||
* described in the documentation
|
||
* of psa_export_key() or psa_export_public_key() for
|
||
* the chosen type. Implementations may allow other
|
||
* formats, but should be conservative: implementations
|
||
* should err on the side of rejecting content if it
|
||
* may be erroneous (e.g. wrong type or truncated data).
|
||
* \param data_length Size of the \p data buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* If the key is persistent, the key material and the key's metadata
|
||
* have been saved to persistent storage.
|
||
* \retval #PSA_ERROR_ALREADY_EXISTS
|
||
* This is an attempt to create a persistent key, and there is
|
||
* already a persistent key with the given identifier.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* The key type or key size is not supported, either by the
|
||
* implementation in general or in this particular persistent location.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The key attributes, as a whole, are invalid.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The key data is not correctly formatted.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The size in \p attributes is nonzero and does not match the size
|
||
* of the key data.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_INSUFFICIENT_STORAGE
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_import_key(const psa_key_attributes_t *attributes,
|
||
const uint8_t *data,
|
||
size_t data_length,
|
||
mbedtls_svc_key_id_t *key);
|
||
|
||
|
||
|
||
/**
|
||
* \brief Export a key in binary format.
|
||
*
|
||
* The output of this function can be passed to psa_import_key() to
|
||
* create an equivalent object.
|
||
*
|
||
* If the implementation of psa_import_key() supports other formats
|
||
* beyond the format specified here, the output from psa_export_key()
|
||
* must use the representation specified here, not the original
|
||
* representation.
|
||
*
|
||
* For standard key types, the output format is as follows:
|
||
*
|
||
* - For symmetric keys (including MAC keys), the format is the
|
||
* raw bytes of the key.
|
||
* - For DES, the key data consists of 8 bytes. The parity bits must be
|
||
* correct.
|
||
* - For Triple-DES, the format is the concatenation of the
|
||
* two or three DES keys.
|
||
* - For RSA key pairs (#PSA_KEY_TYPE_RSA_KEY_PAIR), the format
|
||
* is the non-encrypted DER encoding of the representation defined by
|
||
* PKCS\#1 (RFC 8017) as `RSAPrivateKey`, version 0.
|
||
* ```
|
||
* RSAPrivateKey ::= SEQUENCE {
|
||
* version INTEGER, -- must be 0
|
||
* modulus INTEGER, -- n
|
||
* publicExponent INTEGER, -- e
|
||
* privateExponent INTEGER, -- d
|
||
* prime1 INTEGER, -- p
|
||
* prime2 INTEGER, -- q
|
||
* exponent1 INTEGER, -- d mod (p-1)
|
||
* exponent2 INTEGER, -- d mod (q-1)
|
||
* coefficient INTEGER, -- (inverse of q) mod p
|
||
* }
|
||
* ```
|
||
* - For elliptic curve key pairs (key types for which
|
||
* #PSA_KEY_TYPE_IS_ECC_KEY_PAIR is true), the format is
|
||
* a representation of the private value as a `ceiling(m/8)`-byte string
|
||
* where `m` is the bit size associated with the curve, i.e. the bit size
|
||
* of the order of the curve's coordinate field. This byte string is
|
||
* in little-endian order for Montgomery curves (curve types
|
||
* `PSA_ECC_FAMILY_CURVEXXX`), and in big-endian order for Weierstrass
|
||
* curves (curve types `PSA_ECC_FAMILY_SECTXXX`, `PSA_ECC_FAMILY_SECPXXX`
|
||
* and `PSA_ECC_FAMILY_BRAINPOOL_PXXX`).
|
||
* For Weierstrass curves, this is the content of the `privateKey` field of
|
||
* the `ECPrivateKey` format defined by RFC 5915. For Montgomery curves,
|
||
* the format is defined by RFC 7748, and output is masked according to §5.
|
||
* For twisted Edwards curves, the private key is as defined by RFC 8032
|
||
* (a 32-byte string for Edwards25519, a 57-byte string for Edwards448).
|
||
* - For Diffie-Hellman key exchange key pairs (key types for which
|
||
* #PSA_KEY_TYPE_IS_DH_KEY_PAIR is true), the
|
||
* format is the representation of the private key `x` as a big-endian byte
|
||
* string. The length of the byte string is the private key size in bytes
|
||
* (leading zeroes are not stripped).
|
||
* - For public keys (key types for which #PSA_KEY_TYPE_IS_PUBLIC_KEY is
|
||
* true), the format is the same as for psa_export_public_key().
|
||
*
|
||
* The policy on the key must have the usage flag #PSA_KEY_USAGE_EXPORT set.
|
||
*
|
||
* \param key Identifier of the key to export. It must allow the
|
||
* usage #PSA_KEY_USAGE_EXPORT, unless it is a public
|
||
* key.
|
||
* \param[out] data Buffer where the key data is to be written.
|
||
* \param data_size Size of the \p data buffer in bytes.
|
||
* \param[out] data_length On success, the number of bytes
|
||
* that make up the key data.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The key does not have the #PSA_KEY_USAGE_EXPORT flag.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p data buffer is too small. You can determine a
|
||
* sufficient buffer size by calling
|
||
* #PSA_EXPORT_KEY_OUTPUT_SIZE(\c type, \c bits)
|
||
* where \c type is the key type
|
||
* and \c bits is the key size in bits.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_export_key(mbedtls_svc_key_id_t key,
|
||
uint8_t *data,
|
||
size_t data_size,
|
||
size_t *data_length);
|
||
|
||
/**
|
||
* \brief Export a public key or the public part of a key pair in binary format.
|
||
*
|
||
* The output of this function can be passed to psa_import_key() to
|
||
* create an object that is equivalent to the public key.
|
||
*
|
||
* This specification supports a single format for each key type.
|
||
* Implementations may support other formats as long as the standard
|
||
* format is supported. Implementations that support other formats
|
||
* should ensure that the formats are clearly unambiguous so as to
|
||
* minimize the risk that an invalid input is accidentally interpreted
|
||
* according to a different format.
|
||
*
|
||
* For standard key types, the output format is as follows:
|
||
* - For RSA public keys (#PSA_KEY_TYPE_RSA_PUBLIC_KEY), the DER encoding of
|
||
* the representation defined by RFC 3279 §2.3.1 as `RSAPublicKey`.
|
||
* ```
|
||
* RSAPublicKey ::= SEQUENCE {
|
||
* modulus INTEGER, -- n
|
||
* publicExponent INTEGER } -- e
|
||
* ```
|
||
* - For elliptic curve keys on a twisted Edwards curve (key types for which
|
||
* #PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY is true and #PSA_KEY_TYPE_ECC_GET_FAMILY
|
||
* returns #PSA_ECC_FAMILY_TWISTED_EDWARDS), the public key is as defined
|
||
* by RFC 8032
|
||
* (a 32-byte string for Edwards25519, a 57-byte string for Edwards448).
|
||
* - For other elliptic curve public keys (key types for which
|
||
* #PSA_KEY_TYPE_IS_ECC_PUBLIC_KEY is true), the format is the uncompressed
|
||
* representation defined by SEC1 §2.3.3 as the content of an ECPoint.
|
||
* Let `m` be the bit size associated with the curve, i.e. the bit size of
|
||
* `q` for a curve over `F_q`. The representation consists of:
|
||
* - The byte 0x04;
|
||
* - `x_P` as a `ceiling(m/8)`-byte string, big-endian;
|
||
* - `y_P` as a `ceiling(m/8)`-byte string, big-endian.
|
||
* - For Diffie-Hellman key exchange public keys (key types for which
|
||
* #PSA_KEY_TYPE_IS_DH_PUBLIC_KEY is true),
|
||
* the format is the representation of the public key `y = g^x mod p` as a
|
||
* big-endian byte string. The length of the byte string is the length of the
|
||
* base prime `p` in bytes.
|
||
*
|
||
* Exporting a public key object or the public part of a key pair is
|
||
* always permitted, regardless of the key's usage flags.
|
||
*
|
||
* \param key Identifier of the key to export.
|
||
* \param[out] data Buffer where the key data is to be written.
|
||
* \param data_size Size of the \p data buffer in bytes.
|
||
* \param[out] data_length On success, the number of bytes
|
||
* that make up the key data.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The key is neither a public key nor a key pair.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p data buffer is too small. You can determine a
|
||
* sufficient buffer size by calling
|
||
* #PSA_EXPORT_KEY_OUTPUT_SIZE(#PSA_KEY_TYPE_PUBLIC_KEY_OF_KEY_PAIR(\c type), \c bits)
|
||
* where \c type is the key type
|
||
* and \c bits is the key size in bits.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_export_public_key(mbedtls_svc_key_id_t key,
|
||
uint8_t *data,
|
||
size_t data_size,
|
||
size_t *data_length);
|
||
|
||
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup hash Message digests
|
||
* @{
|
||
*/
|
||
|
||
/** Calculate the hash (digest) of a message.
|
||
*
|
||
* \note To verify the hash of a message against an
|
||
* expected value, use psa_hash_compare() instead.
|
||
*
|
||
* \param alg The hash algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_HASH(\p alg) is true).
|
||
* \param[in] input Buffer containing the message to hash.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] hash Buffer where the hash is to be written.
|
||
* \param hash_size Size of the \p hash buffer in bytes.
|
||
* \param[out] hash_length On success, the number of bytes
|
||
* that make up the hash value. This is always
|
||
* #PSA_HASH_LENGTH(\p alg).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a hash algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \p hash_size is too small
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_compute(psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
uint8_t *hash,
|
||
size_t hash_size,
|
||
size_t *hash_length);
|
||
|
||
/** Calculate the hash (digest) of a message and compare it with a
|
||
* reference value.
|
||
*
|
||
* \param alg The hash algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_HASH(\p alg) is true).
|
||
* \param[in] input Buffer containing the message to hash.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] hash Buffer containing the expected hash value.
|
||
* \param hash_length Size of the \p hash buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* The expected hash is identical to the actual hash of the input.
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The hash of the message was calculated successfully, but it
|
||
* differs from the expected hash.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a hash algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p input_length or \p hash_length do not match the hash size for \p alg
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_compare(psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
const uint8_t *hash,
|
||
size_t hash_length);
|
||
|
||
/** The type of the state data structure for multipart hash operations.
|
||
*
|
||
* Before calling any function on a hash operation object, the application must
|
||
* initialize it by any of the following means:
|
||
* - Set the structure to all-bits-zero, for example:
|
||
* \code
|
||
* psa_hash_operation_t operation;
|
||
* memset(&operation, 0, sizeof(operation));
|
||
* \endcode
|
||
* - Initialize the structure to logical zero values, for example:
|
||
* \code
|
||
* psa_hash_operation_t operation = {0};
|
||
* \endcode
|
||
* - Initialize the structure to the initializer #PSA_HASH_OPERATION_INIT,
|
||
* for example:
|
||
* \code
|
||
* psa_hash_operation_t operation = PSA_HASH_OPERATION_INIT;
|
||
* \endcode
|
||
* - Assign the result of the function psa_hash_operation_init()
|
||
* to the structure, for example:
|
||
* \code
|
||
* psa_hash_operation_t operation;
|
||
* operation = psa_hash_operation_init();
|
||
* \endcode
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice. */
|
||
typedef struct psa_hash_operation_s psa_hash_operation_t;
|
||
|
||
/** \def PSA_HASH_OPERATION_INIT
|
||
*
|
||
* This macro returns a suitable initializer for a hash operation object
|
||
* of type #psa_hash_operation_t.
|
||
*/
|
||
|
||
/** Return an initial value for a hash operation object.
|
||
*/
|
||
static psa_hash_operation_t psa_hash_operation_init(void);
|
||
|
||
/** Set up a multipart hash operation.
|
||
*
|
||
* The sequence of operations to calculate a hash (message digest)
|
||
* is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_hash_operation_t, e.g. #PSA_HASH_OPERATION_INIT.
|
||
* -# Call psa_hash_setup() to specify the algorithm.
|
||
* -# Call psa_hash_update() zero, one or more times, passing a fragment
|
||
* of the message each time. The hash that is calculated is the hash
|
||
* of the concatenation of these messages in order.
|
||
* -# To calculate the hash, call psa_hash_finish().
|
||
* To compare the hash with an expected value, call psa_hash_verify().
|
||
*
|
||
* If an error occurs at any step after a call to psa_hash_setup(), the
|
||
* operation will need to be reset by a call to psa_hash_abort(). The
|
||
* application may call psa_hash_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_hash_setup(), the application must
|
||
* eventually terminate the operation. The following events terminate an
|
||
* operation:
|
||
* - A successful call to psa_hash_finish() or psa_hash_verify().
|
||
* - A call to psa_hash_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_hash_operation_t and not yet in use.
|
||
* \param alg The hash algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_HASH(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not a supported hash algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p alg is not a hash algorithm.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_setup(psa_hash_operation_t *operation,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Add a message fragment to a multipart hash operation.
|
||
*
|
||
* The application must call psa_hash_setup() before calling this function.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_hash_abort().
|
||
*
|
||
* \param[in,out] operation Active hash operation.
|
||
* \param[in] input Buffer containing the message fragment to hash.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it muct be active).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_update(psa_hash_operation_t *operation,
|
||
const uint8_t *input,
|
||
size_t input_length);
|
||
|
||
/** Finish the calculation of the hash of a message.
|
||
*
|
||
* The application must call psa_hash_setup() before calling this function.
|
||
* This function calculates the hash of the message formed by concatenating
|
||
* the inputs passed to preceding calls to psa_hash_update().
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_hash_abort().
|
||
*
|
||
* \warning Applications should not call this function if they expect
|
||
* a specific value for the hash. Call psa_hash_verify() instead.
|
||
* Beware that comparing integrity or authenticity data such as
|
||
* hash values with a function such as \c memcmp is risky
|
||
* because the time taken by the comparison may leak information
|
||
* about the hashed data which could allow an attacker to guess
|
||
* a valid hash and thereby bypass security controls.
|
||
*
|
||
* \param[in,out] operation Active hash operation.
|
||
* \param[out] hash Buffer where the hash is to be written.
|
||
* \param hash_size Size of the \p hash buffer in bytes.
|
||
* \param[out] hash_length On success, the number of bytes
|
||
* that make up the hash value. This is always
|
||
* #PSA_HASH_LENGTH(\c alg) where \c alg is the
|
||
* hash algorithm that is calculated.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p hash buffer is too small. You can determine a
|
||
* sufficient buffer size by calling #PSA_HASH_LENGTH(\c alg)
|
||
* where \c alg is the hash algorithm that is calculated.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_finish(psa_hash_operation_t *operation,
|
||
uint8_t *hash,
|
||
size_t hash_size,
|
||
size_t *hash_length);
|
||
|
||
/** Finish the calculation of the hash of a message and compare it with
|
||
* an expected value.
|
||
*
|
||
* The application must call psa_hash_setup() before calling this function.
|
||
* This function calculates the hash of the message formed by concatenating
|
||
* the inputs passed to preceding calls to psa_hash_update(). It then
|
||
* compares the calculated hash with the expected hash passed as a
|
||
* parameter to this function.
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_hash_abort().
|
||
*
|
||
* \note Implementations shall make the best effort to ensure that the
|
||
* comparison between the actual hash and the expected hash is performed
|
||
* in constant time.
|
||
*
|
||
* \param[in,out] operation Active hash operation.
|
||
* \param[in] hash Buffer containing the expected hash value.
|
||
* \param hash_length Size of the \p hash buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* The expected hash is identical to the actual hash of the message.
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The hash of the message was calculated successfully, but it
|
||
* differs from the expected hash.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_verify(psa_hash_operation_t *operation,
|
||
const uint8_t *hash,
|
||
size_t hash_length);
|
||
|
||
/** Abort a hash operation.
|
||
*
|
||
* Aborting an operation frees all associated resources except for the
|
||
* \p operation structure itself. Once aborted, the operation object
|
||
* can be reused for another operation by calling
|
||
* psa_hash_setup() again.
|
||
*
|
||
* You may call this function any time after the operation object has
|
||
* been initialized by one of the methods described in #psa_hash_operation_t.
|
||
*
|
||
* In particular, calling psa_hash_abort() after the operation has been
|
||
* terminated by a call to psa_hash_abort(), psa_hash_finish() or
|
||
* psa_hash_verify() is safe and has no effect.
|
||
*
|
||
* \param[in,out] operation Initialized hash operation.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_abort(psa_hash_operation_t *operation);
|
||
|
||
/** Clone a hash operation.
|
||
*
|
||
* This function copies the state of an ongoing hash operation to
|
||
* a new operation object. In other words, this function is equivalent
|
||
* to calling psa_hash_setup() on \p target_operation with the same
|
||
* algorithm that \p source_operation was set up for, then
|
||
* psa_hash_update() on \p target_operation with the same input that
|
||
* that was passed to \p source_operation. After this function returns, the
|
||
* two objects are independent, i.e. subsequent calls involving one of
|
||
* the objects do not affect the other object.
|
||
*
|
||
* \param[in] source_operation The active hash operation to clone.
|
||
* \param[in,out] target_operation The operation object to set up.
|
||
* It must be initialized but not active.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The \p source_operation state is not valid (it must be active).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The \p target_operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_hash_clone(const psa_hash_operation_t *source_operation,
|
||
psa_hash_operation_t *target_operation);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup MAC Message authentication codes
|
||
* @{
|
||
*/
|
||
|
||
/** Calculate the MAC (message authentication code) of a message.
|
||
*
|
||
* \note To verify the MAC of a message against an
|
||
* expected value, use psa_mac_verify() instead.
|
||
* Beware that comparing integrity or authenticity data such as
|
||
* MAC values with a function such as \c memcmp is risky
|
||
* because the time taken by the comparison may leak information
|
||
* about the MAC value which could allow an attacker to guess
|
||
* a valid MAC and thereby bypass security controls.
|
||
*
|
||
* \param key Identifier of the key to use for the operation. It
|
||
* must allow the usage PSA_KEY_USAGE_SIGN_MESSAGE.
|
||
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_MAC(\p alg) is true).
|
||
* \param[in] input Buffer containing the input message.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] mac Buffer where the MAC value is to be written.
|
||
* \param mac_size Size of the \p mac buffer in bytes.
|
||
* \param[out] mac_length On success, the number of bytes
|
||
* that make up the MAC value.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a MAC algorithm.
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \p mac_size is too small
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* The key could not be retrieved from storage.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_compute(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
uint8_t *mac,
|
||
size_t mac_size,
|
||
size_t *mac_length);
|
||
|
||
/** Calculate the MAC of a message and compare it with a reference value.
|
||
*
|
||
* \param key Identifier of the key to use for the operation. It
|
||
* must allow the usage PSA_KEY_USAGE_VERIFY_MESSAGE.
|
||
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_MAC(\p alg) is true).
|
||
* \param[in] input Buffer containing the input message.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] mac Buffer containing the expected MAC value.
|
||
* \param mac_length Size of the \p mac buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* The expected MAC is identical to the actual MAC of the input.
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The MAC of the message was calculated successfully, but it
|
||
* differs from the expected value.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a MAC algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* The key could not be retrieved from storage.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_verify(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
const uint8_t *mac,
|
||
size_t mac_length);
|
||
|
||
/** The type of the state data structure for multipart MAC operations.
|
||
*
|
||
* Before calling any function on a MAC operation object, the application must
|
||
* initialize it by any of the following means:
|
||
* - Set the structure to all-bits-zero, for example:
|
||
* \code
|
||
* psa_mac_operation_t operation;
|
||
* memset(&operation, 0, sizeof(operation));
|
||
* \endcode
|
||
* - Initialize the structure to logical zero values, for example:
|
||
* \code
|
||
* psa_mac_operation_t operation = {0};
|
||
* \endcode
|
||
* - Initialize the structure to the initializer #PSA_MAC_OPERATION_INIT,
|
||
* for example:
|
||
* \code
|
||
* psa_mac_operation_t operation = PSA_MAC_OPERATION_INIT;
|
||
* \endcode
|
||
* - Assign the result of the function psa_mac_operation_init()
|
||
* to the structure, for example:
|
||
* \code
|
||
* psa_mac_operation_t operation;
|
||
* operation = psa_mac_operation_init();
|
||
* \endcode
|
||
*
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice. */
|
||
typedef struct psa_mac_operation_s psa_mac_operation_t;
|
||
|
||
/** \def PSA_MAC_OPERATION_INIT
|
||
*
|
||
* This macro returns a suitable initializer for a MAC operation object of type
|
||
* #psa_mac_operation_t.
|
||
*/
|
||
|
||
/** Return an initial value for a MAC operation object.
|
||
*/
|
||
static psa_mac_operation_t psa_mac_operation_init(void);
|
||
|
||
/** Set up a multipart MAC calculation operation.
|
||
*
|
||
* This function sets up the calculation of the MAC
|
||
* (message authentication code) of a byte string.
|
||
* To verify the MAC of a message against an
|
||
* expected value, use psa_mac_verify_setup() instead.
|
||
*
|
||
* The sequence of operations to calculate a MAC is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_mac_operation_t, e.g. #PSA_MAC_OPERATION_INIT.
|
||
* -# Call psa_mac_sign_setup() to specify the algorithm and key.
|
||
* -# Call psa_mac_update() zero, one or more times, passing a fragment
|
||
* of the message each time. The MAC that is calculated is the MAC
|
||
* of the concatenation of these messages in order.
|
||
* -# At the end of the message, call psa_mac_sign_finish() to finish
|
||
* calculating the MAC value and retrieve it.
|
||
*
|
||
* If an error occurs at any step after a call to psa_mac_sign_setup(), the
|
||
* operation will need to be reset by a call to psa_mac_abort(). The
|
||
* application may call psa_mac_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_mac_sign_setup(), the application must
|
||
* eventually terminate the operation through one of the following methods:
|
||
* - A successful call to psa_mac_sign_finish().
|
||
* - A call to psa_mac_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_mac_operation_t and not yet in use.
|
||
* \param key Identifier of the key to use for the operation. It
|
||
* must remain valid until the operation terminates.
|
||
* It must allow the usage PSA_KEY_USAGE_SIGN_MESSAGE.
|
||
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_MAC(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a MAC algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* The key could not be retrieved from storage.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_sign_setup(psa_mac_operation_t *operation,
|
||
mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Set up a multipart MAC verification operation.
|
||
*
|
||
* This function sets up the verification of the MAC
|
||
* (message authentication code) of a byte string against an expected value.
|
||
*
|
||
* The sequence of operations to verify a MAC is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_mac_operation_t, e.g. #PSA_MAC_OPERATION_INIT.
|
||
* -# Call psa_mac_verify_setup() to specify the algorithm and key.
|
||
* -# Call psa_mac_update() zero, one or more times, passing a fragment
|
||
* of the message each time. The MAC that is calculated is the MAC
|
||
* of the concatenation of these messages in order.
|
||
* -# At the end of the message, call psa_mac_verify_finish() to finish
|
||
* calculating the actual MAC of the message and verify it against
|
||
* the expected value.
|
||
*
|
||
* If an error occurs at any step after a call to psa_mac_verify_setup(), the
|
||
* operation will need to be reset by a call to psa_mac_abort(). The
|
||
* application may call psa_mac_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_mac_verify_setup(), the application must
|
||
* eventually terminate the operation through one of the following methods:
|
||
* - A successful call to psa_mac_verify_finish().
|
||
* - A call to psa_mac_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_mac_operation_t and not yet in use.
|
||
* \param key Identifier of the key to use for the operation. It
|
||
* must remain valid until the operation terminates.
|
||
* It must allow the usage
|
||
* PSA_KEY_USAGE_VERIFY_MESSAGE.
|
||
* \param alg The MAC algorithm to compute (\c PSA_ALG_XXX value
|
||
* such that #PSA_ALG_IS_MAC(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c key is not compatible with \c alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \c alg is not supported or is not a MAC algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* The key could not be retrieved from storage
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_verify_setup(psa_mac_operation_t *operation,
|
||
mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Add a message fragment to a multipart MAC operation.
|
||
*
|
||
* The application must call psa_mac_sign_setup() or psa_mac_verify_setup()
|
||
* before calling this function.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_mac_abort().
|
||
*
|
||
* \param[in,out] operation Active MAC operation.
|
||
* \param[in] input Buffer containing the message fragment to add to
|
||
* the MAC calculation.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_update(psa_mac_operation_t *operation,
|
||
const uint8_t *input,
|
||
size_t input_length);
|
||
|
||
/** Finish the calculation of the MAC of a message.
|
||
*
|
||
* The application must call psa_mac_sign_setup() before calling this function.
|
||
* This function calculates the MAC of the message formed by concatenating
|
||
* the inputs passed to preceding calls to psa_mac_update().
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_mac_abort().
|
||
*
|
||
* \warning Applications should not call this function if they expect
|
||
* a specific value for the MAC. Call psa_mac_verify_finish() instead.
|
||
* Beware that comparing integrity or authenticity data such as
|
||
* MAC values with a function such as \c memcmp is risky
|
||
* because the time taken by the comparison may leak information
|
||
* about the MAC value which could allow an attacker to guess
|
||
* a valid MAC and thereby bypass security controls.
|
||
*
|
||
* \param[in,out] operation Active MAC operation.
|
||
* \param[out] mac Buffer where the MAC value is to be written.
|
||
* \param mac_size Size of the \p mac buffer in bytes.
|
||
* \param[out] mac_length On success, the number of bytes
|
||
* that make up the MAC value. This is always
|
||
* #PSA_MAC_LENGTH(\c key_type, \c key_bits, \c alg)
|
||
* where \c key_type and \c key_bits are the type and
|
||
* bit-size respectively of the key and \c alg is the
|
||
* MAC algorithm that is calculated.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be an active mac sign
|
||
* operation).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p mac buffer is too small. You can determine a
|
||
* sufficient buffer size by calling PSA_MAC_LENGTH().
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_sign_finish(psa_mac_operation_t *operation,
|
||
uint8_t *mac,
|
||
size_t mac_size,
|
||
size_t *mac_length);
|
||
|
||
/** Finish the calculation of the MAC of a message and compare it with
|
||
* an expected value.
|
||
*
|
||
* The application must call psa_mac_verify_setup() before calling this function.
|
||
* This function calculates the MAC of the message formed by concatenating
|
||
* the inputs passed to preceding calls to psa_mac_update(). It then
|
||
* compares the calculated MAC with the expected MAC passed as a
|
||
* parameter to this function.
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_mac_abort().
|
||
*
|
||
* \note Implementations shall make the best effort to ensure that the
|
||
* comparison between the actual MAC and the expected MAC is performed
|
||
* in constant time.
|
||
*
|
||
* \param[in,out] operation Active MAC operation.
|
||
* \param[in] mac Buffer containing the expected MAC value.
|
||
* \param mac_length Size of the \p mac buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* The expected MAC is identical to the actual MAC of the message.
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The MAC of the message was calculated successfully, but it
|
||
* differs from the expected MAC.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be an active mac verify
|
||
* operation).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_verify_finish(psa_mac_operation_t *operation,
|
||
const uint8_t *mac,
|
||
size_t mac_length);
|
||
|
||
/** Abort a MAC operation.
|
||
*
|
||
* Aborting an operation frees all associated resources except for the
|
||
* \p operation structure itself. Once aborted, the operation object
|
||
* can be reused for another operation by calling
|
||
* psa_mac_sign_setup() or psa_mac_verify_setup() again.
|
||
*
|
||
* You may call this function any time after the operation object has
|
||
* been initialized by one of the methods described in #psa_mac_operation_t.
|
||
*
|
||
* In particular, calling psa_mac_abort() after the operation has been
|
||
* terminated by a call to psa_mac_abort(), psa_mac_sign_finish() or
|
||
* psa_mac_verify_finish() is safe and has no effect.
|
||
*
|
||
* \param[in,out] operation Initialized MAC operation.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_mac_abort(psa_mac_operation_t *operation);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup cipher Symmetric ciphers
|
||
* @{
|
||
*/
|
||
|
||
/** Encrypt a message using a symmetric cipher.
|
||
*
|
||
* This function encrypts a message with a random IV (initialization
|
||
* vector). Use the multipart operation interface with a
|
||
* #psa_cipher_operation_t object to provide other forms of IV.
|
||
*
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must allow the usage #PSA_KEY_USAGE_ENCRYPT.
|
||
* \param alg The cipher algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_CIPHER(\p alg) is true).
|
||
* \param[in] input Buffer containing the message to encrypt.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] output Buffer where the output is to be written.
|
||
* The output contains the IV followed by
|
||
* the ciphertext proper.
|
||
* \param output_size Size of the \p output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a cipher algorithm.
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_encrypt(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/** Decrypt a message using a symmetric cipher.
|
||
*
|
||
* This function decrypts a message encrypted with a symmetric cipher.
|
||
*
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must remain valid until the operation
|
||
* terminates. It must allow the usage
|
||
* #PSA_KEY_USAGE_DECRYPT.
|
||
* \param alg The cipher algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_CIPHER(\p alg) is true).
|
||
* \param[in] input Buffer containing the message to decrypt.
|
||
* This consists of the IV followed by the
|
||
* ciphertext proper.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] output Buffer where the plaintext is to be written.
|
||
* \param output_size Size of the \p output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a cipher algorithm.
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_decrypt(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/** The type of the state data structure for multipart cipher operations.
|
||
*
|
||
* Before calling any function on a cipher operation object, the application
|
||
* must initialize it by any of the following means:
|
||
* - Set the structure to all-bits-zero, for example:
|
||
* \code
|
||
* psa_cipher_operation_t operation;
|
||
* memset(&operation, 0, sizeof(operation));
|
||
* \endcode
|
||
* - Initialize the structure to logical zero values, for example:
|
||
* \code
|
||
* psa_cipher_operation_t operation = {0};
|
||
* \endcode
|
||
* - Initialize the structure to the initializer #PSA_CIPHER_OPERATION_INIT,
|
||
* for example:
|
||
* \code
|
||
* psa_cipher_operation_t operation = PSA_CIPHER_OPERATION_INIT;
|
||
* \endcode
|
||
* - Assign the result of the function psa_cipher_operation_init()
|
||
* to the structure, for example:
|
||
* \code
|
||
* psa_cipher_operation_t operation;
|
||
* operation = psa_cipher_operation_init();
|
||
* \endcode
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice. */
|
||
typedef struct psa_cipher_operation_s psa_cipher_operation_t;
|
||
|
||
/** \def PSA_CIPHER_OPERATION_INIT
|
||
*
|
||
* This macro returns a suitable initializer for a cipher operation object of
|
||
* type #psa_cipher_operation_t.
|
||
*/
|
||
|
||
/** Return an initial value for a cipher operation object.
|
||
*/
|
||
static psa_cipher_operation_t psa_cipher_operation_init(void);
|
||
|
||
/** Set the key for a multipart symmetric encryption operation.
|
||
*
|
||
* The sequence of operations to encrypt a message with a symmetric cipher
|
||
* is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_cipher_operation_t, e.g.
|
||
* #PSA_CIPHER_OPERATION_INIT.
|
||
* -# Call psa_cipher_encrypt_setup() to specify the algorithm and key.
|
||
* -# Call either psa_cipher_generate_iv() or psa_cipher_set_iv() to
|
||
* generate or set the IV (initialization vector). You should use
|
||
* psa_cipher_generate_iv() unless the protocol you are implementing
|
||
* requires a specific IV value.
|
||
* -# Call psa_cipher_update() zero, one or more times, passing a fragment
|
||
* of the message each time.
|
||
* -# Call psa_cipher_finish().
|
||
*
|
||
* If an error occurs at any step after a call to psa_cipher_encrypt_setup(),
|
||
* the operation will need to be reset by a call to psa_cipher_abort(). The
|
||
* application may call psa_cipher_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_cipher_encrypt_setup(), the application must
|
||
* eventually terminate the operation. The following events terminate an
|
||
* operation:
|
||
* - A successful call to psa_cipher_finish().
|
||
* - A call to psa_cipher_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_cipher_operation_t and not yet in use.
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must remain valid until the operation
|
||
* terminates. It must allow the usage
|
||
* #PSA_KEY_USAGE_ENCRYPT.
|
||
* \param alg The cipher algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_CIPHER(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a cipher algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_encrypt_setup(psa_cipher_operation_t *operation,
|
||
mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Set the key for a multipart symmetric decryption operation.
|
||
*
|
||
* The sequence of operations to decrypt a message with a symmetric cipher
|
||
* is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_cipher_operation_t, e.g.
|
||
* #PSA_CIPHER_OPERATION_INIT.
|
||
* -# Call psa_cipher_decrypt_setup() to specify the algorithm and key.
|
||
* -# Call psa_cipher_set_iv() with the IV (initialization vector) for the
|
||
* decryption. If the IV is prepended to the ciphertext, you can call
|
||
* psa_cipher_update() on a buffer containing the IV followed by the
|
||
* beginning of the message.
|
||
* -# Call psa_cipher_update() zero, one or more times, passing a fragment
|
||
* of the message each time.
|
||
* -# Call psa_cipher_finish().
|
||
*
|
||
* If an error occurs at any step after a call to psa_cipher_decrypt_setup(),
|
||
* the operation will need to be reset by a call to psa_cipher_abort(). The
|
||
* application may call psa_cipher_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_cipher_decrypt_setup(), the application must
|
||
* eventually terminate the operation. The following events terminate an
|
||
* operation:
|
||
* - A successful call to psa_cipher_finish().
|
||
* - A call to psa_cipher_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_cipher_operation_t and not yet in use.
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must remain valid until the operation
|
||
* terminates. It must allow the usage
|
||
* #PSA_KEY_USAGE_DECRYPT.
|
||
* \param alg The cipher algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_CIPHER(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not a cipher algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_decrypt_setup(psa_cipher_operation_t *operation,
|
||
mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Generate an IV for a symmetric encryption operation.
|
||
*
|
||
* This function generates a random IV (initialization vector), nonce
|
||
* or initial counter value for the encryption operation as appropriate
|
||
* for the chosen algorithm, key type and key size.
|
||
*
|
||
* The application must call psa_cipher_encrypt_setup() before
|
||
* calling this function.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_cipher_abort().
|
||
*
|
||
* \param[in,out] operation Active cipher operation.
|
||
* \param[out] iv Buffer where the generated IV is to be written.
|
||
* \param iv_size Size of the \p iv buffer in bytes.
|
||
* \param[out] iv_length On success, the number of bytes of the
|
||
* generated IV.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, with no IV set).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p iv buffer is too small.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_generate_iv(psa_cipher_operation_t *operation,
|
||
uint8_t *iv,
|
||
size_t iv_size,
|
||
size_t *iv_length);
|
||
|
||
/** Set the IV for a symmetric encryption or decryption operation.
|
||
*
|
||
* This function sets the IV (initialization vector), nonce
|
||
* or initial counter value for the encryption or decryption operation.
|
||
*
|
||
* The application must call psa_cipher_encrypt_setup() before
|
||
* calling this function.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_cipher_abort().
|
||
*
|
||
* \note When encrypting, applications should use psa_cipher_generate_iv()
|
||
* instead of this function, unless implementing a protocol that requires
|
||
* a non-random IV.
|
||
*
|
||
* \param[in,out] operation Active cipher operation.
|
||
* \param[in] iv Buffer containing the IV to use.
|
||
* \param iv_length Size of the IV in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be an active cipher
|
||
* encrypt operation, with no IV set).
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The size of \p iv is not acceptable for the chosen algorithm,
|
||
* or the chosen algorithm does not use an IV.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_set_iv(psa_cipher_operation_t *operation,
|
||
const uint8_t *iv,
|
||
size_t iv_length);
|
||
|
||
/** Encrypt or decrypt a message fragment in an active cipher operation.
|
||
*
|
||
* Before calling this function, you must:
|
||
* 1. Call either psa_cipher_encrypt_setup() or psa_cipher_decrypt_setup().
|
||
* The choice of setup function determines whether this function
|
||
* encrypts or decrypts its input.
|
||
* 2. If the algorithm requires an IV, call psa_cipher_generate_iv()
|
||
* (recommended when encrypting) or psa_cipher_set_iv().
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_cipher_abort().
|
||
*
|
||
* \param[in,out] operation Active cipher operation.
|
||
* \param[in] input Buffer containing the message fragment to
|
||
* encrypt or decrypt.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] output Buffer where the output is to be written.
|
||
* \param output_size Size of the \p output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the returned output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, with an IV set
|
||
* if required for the algorithm).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p output buffer is too small.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_update(psa_cipher_operation_t *operation,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/** Finish encrypting or decrypting a message in a cipher operation.
|
||
*
|
||
* The application must call psa_cipher_encrypt_setup() or
|
||
* psa_cipher_decrypt_setup() before calling this function. The choice
|
||
* of setup function determines whether this function encrypts or
|
||
* decrypts its input.
|
||
*
|
||
* This function finishes the encryption or decryption of the message
|
||
* formed by concatenating the inputs passed to preceding calls to
|
||
* psa_cipher_update().
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_cipher_abort().
|
||
*
|
||
* \param[in,out] operation Active cipher operation.
|
||
* \param[out] output Buffer where the output is to be written.
|
||
* \param output_size Size of the \p output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the returned output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total input size passed to this operation is not valid for
|
||
* this particular algorithm. For example, the algorithm is a based
|
||
* on block cipher and requires a whole number of blocks, but the
|
||
* total input size is not a multiple of the block size.
|
||
* \retval #PSA_ERROR_INVALID_PADDING
|
||
* This is a decryption operation for an algorithm that includes
|
||
* padding, and the ciphertext does not contain valid padding.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, with an IV set
|
||
* if required for the algorithm).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p output buffer is too small.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_finish(psa_cipher_operation_t *operation,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/** Abort a cipher operation.
|
||
*
|
||
* Aborting an operation frees all associated resources except for the
|
||
* \p operation structure itself. Once aborted, the operation object
|
||
* can be reused for another operation by calling
|
||
* psa_cipher_encrypt_setup() or psa_cipher_decrypt_setup() again.
|
||
*
|
||
* You may call this function any time after the operation object has
|
||
* been initialized as described in #psa_cipher_operation_t.
|
||
*
|
||
* In particular, calling psa_cipher_abort() after the operation has been
|
||
* terminated by a call to psa_cipher_abort() or psa_cipher_finish()
|
||
* is safe and has no effect.
|
||
*
|
||
* \param[in,out] operation Initialized cipher operation.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_cipher_abort(psa_cipher_operation_t *operation);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup aead Authenticated encryption with associated data (AEAD)
|
||
* @{
|
||
*/
|
||
|
||
/** Process an authenticated encryption operation.
|
||
*
|
||
* \param key Identifier of the key to use for the
|
||
* operation. It must allow the usage
|
||
* #PSA_KEY_USAGE_ENCRYPT.
|
||
* \param alg The AEAD algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_AEAD(\p alg) is true).
|
||
* \param[in] nonce Nonce or IV to use.
|
||
* \param nonce_length Size of the \p nonce buffer in bytes.
|
||
* \param[in] additional_data Additional data that will be authenticated
|
||
* but not encrypted.
|
||
* \param additional_data_length Size of \p additional_data in bytes.
|
||
* \param[in] plaintext Data that will be authenticated and
|
||
* encrypted.
|
||
* \param plaintext_length Size of \p plaintext in bytes.
|
||
* \param[out] ciphertext Output buffer for the authenticated and
|
||
* encrypted data. The additional data is not
|
||
* part of this output. For algorithms where the
|
||
* encrypted data and the authentication tag
|
||
* are defined as separate outputs, the
|
||
* authentication tag is appended to the
|
||
* encrypted data.
|
||
* \param ciphertext_size Size of the \p ciphertext buffer in bytes.
|
||
* This must be appropriate for the selected
|
||
* algorithm and key:
|
||
* - A sufficient output size is
|
||
* #PSA_AEAD_ENCRYPT_OUTPUT_SIZE(\c key_type,
|
||
* \p alg, \p plaintext_length) where
|
||
* \c key_type is the type of \p key.
|
||
* - #PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(\p
|
||
* plaintext_length) evaluates to the maximum
|
||
* ciphertext size of any supported AEAD
|
||
* encryption.
|
||
* \param[out] ciphertext_length On success, the size of the output
|
||
* in the \p ciphertext buffer.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not an AEAD algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \p ciphertext_size is too small.
|
||
* #PSA_AEAD_ENCRYPT_OUTPUT_SIZE(\c key_type, \p alg,
|
||
* \p plaintext_length) or
|
||
* #PSA_AEAD_ENCRYPT_OUTPUT_MAX_SIZE(\p plaintext_length) can be used to
|
||
* determine the required buffer size.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_encrypt(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *nonce,
|
||
size_t nonce_length,
|
||
const uint8_t *additional_data,
|
||
size_t additional_data_length,
|
||
const uint8_t *plaintext,
|
||
size_t plaintext_length,
|
||
uint8_t *ciphertext,
|
||
size_t ciphertext_size,
|
||
size_t *ciphertext_length);
|
||
|
||
/** Process an authenticated decryption operation.
|
||
*
|
||
* \param key Identifier of the key to use for the
|
||
* operation. It must allow the usage
|
||
* #PSA_KEY_USAGE_DECRYPT.
|
||
* \param alg The AEAD algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_AEAD(\p alg) is true).
|
||
* \param[in] nonce Nonce or IV to use.
|
||
* \param nonce_length Size of the \p nonce buffer in bytes.
|
||
* \param[in] additional_data Additional data that has been authenticated
|
||
* but not encrypted.
|
||
* \param additional_data_length Size of \p additional_data in bytes.
|
||
* \param[in] ciphertext Data that has been authenticated and
|
||
* encrypted. For algorithms where the
|
||
* encrypted data and the authentication tag
|
||
* are defined as separate inputs, the buffer
|
||
* must contain the encrypted data followed
|
||
* by the authentication tag.
|
||
* \param ciphertext_length Size of \p ciphertext in bytes.
|
||
* \param[out] plaintext Output buffer for the decrypted data.
|
||
* \param plaintext_size Size of the \p plaintext buffer in bytes.
|
||
* This must be appropriate for the selected
|
||
* algorithm and key:
|
||
* - A sufficient output size is
|
||
* #PSA_AEAD_DECRYPT_OUTPUT_SIZE(\c key_type,
|
||
* \p alg, \p ciphertext_length) where
|
||
* \c key_type is the type of \p key.
|
||
* - #PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE(\p
|
||
* ciphertext_length) evaluates to the maximum
|
||
* plaintext size of any supported AEAD
|
||
* decryption.
|
||
* \param[out] plaintext_length On success, the size of the output
|
||
* in the \p plaintext buffer.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The ciphertext is not authentic.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not an AEAD algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \p plaintext_size is too small.
|
||
* #PSA_AEAD_DECRYPT_OUTPUT_SIZE(\c key_type, \p alg,
|
||
* \p ciphertext_length) or
|
||
* #PSA_AEAD_DECRYPT_OUTPUT_MAX_SIZE(\p ciphertext_length) can be used
|
||
* to determine the required buffer size.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_decrypt(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *nonce,
|
||
size_t nonce_length,
|
||
const uint8_t *additional_data,
|
||
size_t additional_data_length,
|
||
const uint8_t *ciphertext,
|
||
size_t ciphertext_length,
|
||
uint8_t *plaintext,
|
||
size_t plaintext_size,
|
||
size_t *plaintext_length);
|
||
|
||
/** The type of the state data structure for multipart AEAD operations.
|
||
*
|
||
* Before calling any function on an AEAD operation object, the application
|
||
* must initialize it by any of the following means:
|
||
* - Set the structure to all-bits-zero, for example:
|
||
* \code
|
||
* psa_aead_operation_t operation;
|
||
* memset(&operation, 0, sizeof(operation));
|
||
* \endcode
|
||
* - Initialize the structure to logical zero values, for example:
|
||
* \code
|
||
* psa_aead_operation_t operation = {0};
|
||
* \endcode
|
||
* - Initialize the structure to the initializer #PSA_AEAD_OPERATION_INIT,
|
||
* for example:
|
||
* \code
|
||
* psa_aead_operation_t operation = PSA_AEAD_OPERATION_INIT;
|
||
* \endcode
|
||
* - Assign the result of the function psa_aead_operation_init()
|
||
* to the structure, for example:
|
||
* \code
|
||
* psa_aead_operation_t operation;
|
||
* operation = psa_aead_operation_init();
|
||
* \endcode
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice. */
|
||
typedef struct psa_aead_operation_s psa_aead_operation_t;
|
||
|
||
/** \def PSA_AEAD_OPERATION_INIT
|
||
*
|
||
* This macro returns a suitable initializer for an AEAD operation object of
|
||
* type #psa_aead_operation_t.
|
||
*/
|
||
|
||
/** Return an initial value for an AEAD operation object.
|
||
*/
|
||
static psa_aead_operation_t psa_aead_operation_init(void);
|
||
|
||
/** Set the key for a multipart authenticated encryption operation.
|
||
*
|
||
* The sequence of operations to encrypt a message with authentication
|
||
* is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_aead_operation_t, e.g.
|
||
* #PSA_AEAD_OPERATION_INIT.
|
||
* -# Call psa_aead_encrypt_setup() to specify the algorithm and key.
|
||
* -# If needed, call psa_aead_set_lengths() to specify the length of the
|
||
* inputs to the subsequent calls to psa_aead_update_ad() and
|
||
* psa_aead_update(). See the documentation of psa_aead_set_lengths()
|
||
* for details.
|
||
* -# Call either psa_aead_generate_nonce() or psa_aead_set_nonce() to
|
||
* generate or set the nonce. You should use
|
||
* psa_aead_generate_nonce() unless the protocol you are implementing
|
||
* requires a specific nonce value.
|
||
* -# Call psa_aead_update_ad() zero, one or more times, passing a fragment
|
||
* of the non-encrypted additional authenticated data each time.
|
||
* -# Call psa_aead_update() zero, one or more times, passing a fragment
|
||
* of the message to encrypt each time.
|
||
* -# Call psa_aead_finish().
|
||
*
|
||
* If an error occurs at any step after a call to psa_aead_encrypt_setup(),
|
||
* the operation will need to be reset by a call to psa_aead_abort(). The
|
||
* application may call psa_aead_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_aead_encrypt_setup(), the application must
|
||
* eventually terminate the operation. The following events terminate an
|
||
* operation:
|
||
* - A successful call to psa_aead_finish().
|
||
* - A call to psa_aead_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_aead_operation_t and not yet in use.
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must remain valid until the operation
|
||
* terminates. It must allow the usage
|
||
* #PSA_KEY_USAGE_ENCRYPT.
|
||
* \param alg The AEAD algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_AEAD(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not an AEAD algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_encrypt_setup(psa_aead_operation_t *operation,
|
||
mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Set the key for a multipart authenticated decryption operation.
|
||
*
|
||
* The sequence of operations to decrypt a message with authentication
|
||
* is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_aead_operation_t, e.g.
|
||
* #PSA_AEAD_OPERATION_INIT.
|
||
* -# Call psa_aead_decrypt_setup() to specify the algorithm and key.
|
||
* -# If needed, call psa_aead_set_lengths() to specify the length of the
|
||
* inputs to the subsequent calls to psa_aead_update_ad() and
|
||
* psa_aead_update(). See the documentation of psa_aead_set_lengths()
|
||
* for details.
|
||
* -# Call psa_aead_set_nonce() with the nonce for the decryption.
|
||
* -# Call psa_aead_update_ad() zero, one or more times, passing a fragment
|
||
* of the non-encrypted additional authenticated data each time.
|
||
* -# Call psa_aead_update() zero, one or more times, passing a fragment
|
||
* of the ciphertext to decrypt each time.
|
||
* -# Call psa_aead_verify().
|
||
*
|
||
* If an error occurs at any step after a call to psa_aead_decrypt_setup(),
|
||
* the operation will need to be reset by a call to psa_aead_abort(). The
|
||
* application may call psa_aead_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_aead_decrypt_setup(), the application must
|
||
* eventually terminate the operation. The following events terminate an
|
||
* operation:
|
||
* - A successful call to psa_aead_verify().
|
||
* - A call to psa_aead_abort().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_aead_operation_t and not yet in use.
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must remain valid until the operation
|
||
* terminates. It must allow the usage
|
||
* #PSA_KEY_USAGE_DECRYPT.
|
||
* \param alg The AEAD algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_AEAD(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with \p alg.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not supported or is not an AEAD algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_decrypt_setup(psa_aead_operation_t *operation,
|
||
mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Generate a random nonce for an authenticated encryption operation.
|
||
*
|
||
* This function generates a random nonce for the authenticated encryption
|
||
* operation with an appropriate size for the chosen algorithm, key type
|
||
* and key size.
|
||
*
|
||
* The application must call psa_aead_encrypt_setup() before
|
||
* calling this function.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param[out] nonce Buffer where the generated nonce is to be
|
||
* written.
|
||
* \param nonce_size Size of the \p nonce buffer in bytes.
|
||
* \param[out] nonce_length On success, the number of bytes of the
|
||
* generated nonce.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be an active aead encrypt
|
||
* operation, with no nonce set).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p nonce buffer is too small.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_generate_nonce(psa_aead_operation_t *operation,
|
||
uint8_t *nonce,
|
||
size_t nonce_size,
|
||
size_t *nonce_length);
|
||
|
||
/** Set the nonce for an authenticated encryption or decryption operation.
|
||
*
|
||
* This function sets the nonce for the authenticated
|
||
* encryption or decryption operation.
|
||
*
|
||
* The application must call psa_aead_encrypt_setup() or
|
||
* psa_aead_decrypt_setup() before calling this function.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \note When encrypting, applications should use psa_aead_generate_nonce()
|
||
* instead of this function, unless implementing a protocol that requires
|
||
* a non-random IV.
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param[in] nonce Buffer containing the nonce to use.
|
||
* \param nonce_length Size of the nonce in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, with no nonce
|
||
* set).
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The size of \p nonce is not acceptable for the chosen algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_set_nonce(psa_aead_operation_t *operation,
|
||
const uint8_t *nonce,
|
||
size_t nonce_length);
|
||
|
||
/** Declare the lengths of the message and additional data for AEAD.
|
||
*
|
||
* The application must call this function before calling
|
||
* psa_aead_update_ad() or psa_aead_update() if the algorithm for
|
||
* the operation requires it. If the algorithm does not require it,
|
||
* calling this function is optional, but if this function is called
|
||
* then the implementation must enforce the lengths.
|
||
*
|
||
* You may call this function before or after setting the nonce with
|
||
* psa_aead_set_nonce() or psa_aead_generate_nonce().
|
||
*
|
||
* - For #PSA_ALG_CCM, calling this function is required.
|
||
* - For the other AEAD algorithms defined in this specification, calling
|
||
* this function is not required.
|
||
* - For vendor-defined algorithm, refer to the vendor documentation.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param ad_length Size of the non-encrypted additional
|
||
* authenticated data in bytes.
|
||
* \param plaintext_length Size of the plaintext to encrypt in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, and
|
||
* psa_aead_update_ad() and psa_aead_update() must not have been
|
||
* called yet).
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* At least one of the lengths is not acceptable for the chosen
|
||
* algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_set_lengths(psa_aead_operation_t *operation,
|
||
size_t ad_length,
|
||
size_t plaintext_length);
|
||
|
||
/** Pass additional data to an active AEAD operation.
|
||
*
|
||
* Additional data is authenticated, but not encrypted.
|
||
*
|
||
* You may call this function multiple times to pass successive fragments
|
||
* of the additional data. You may not call this function after passing
|
||
* data to encrypt or decrypt with psa_aead_update().
|
||
*
|
||
* Before calling this function, you must:
|
||
* 1. Call either psa_aead_encrypt_setup() or psa_aead_decrypt_setup().
|
||
* 2. Set the nonce with psa_aead_generate_nonce() or psa_aead_set_nonce().
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \warning When decrypting, until psa_aead_verify() has returned #PSA_SUCCESS,
|
||
* there is no guarantee that the input is valid. Therefore, until
|
||
* you have called psa_aead_verify() and it has returned #PSA_SUCCESS,
|
||
* treat the input as untrusted and prepare to undo any action that
|
||
* depends on the input if psa_aead_verify() returns an error status.
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param[in] input Buffer containing the fragment of
|
||
* additional data.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, have a nonce
|
||
* set, have lengths set if required by the algorithm, and
|
||
* psa_aead_update() must not have been called yet).
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total input length overflows the additional data length that
|
||
* was previously specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_update_ad(psa_aead_operation_t *operation,
|
||
const uint8_t *input,
|
||
size_t input_length);
|
||
|
||
/** Encrypt or decrypt a message fragment in an active AEAD operation.
|
||
*
|
||
* Before calling this function, you must:
|
||
* 1. Call either psa_aead_encrypt_setup() or psa_aead_decrypt_setup().
|
||
* The choice of setup function determines whether this function
|
||
* encrypts or decrypts its input.
|
||
* 2. Set the nonce with psa_aead_generate_nonce() or psa_aead_set_nonce().
|
||
* 3. Call psa_aead_update_ad() to pass all the additional data.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \warning When decrypting, until psa_aead_verify() has returned #PSA_SUCCESS,
|
||
* there is no guarantee that the input is valid. Therefore, until
|
||
* you have called psa_aead_verify() and it has returned #PSA_SUCCESS:
|
||
* - Do not use the output in any way other than storing it in a
|
||
* confidential location. If you take any action that depends
|
||
* on the tentative decrypted data, this action will need to be
|
||
* undone if the input turns out not to be valid. Furthermore,
|
||
* if an adversary can observe that this action took place
|
||
* (for example through timing), they may be able to use this
|
||
* fact as an oracle to decrypt any message encrypted with the
|
||
* same key.
|
||
* - In particular, do not copy the output anywhere but to a
|
||
* memory or storage space that you have exclusive access to.
|
||
*
|
||
* This function does not require the input to be aligned to any
|
||
* particular block boundary. If the implementation can only process
|
||
* a whole block at a time, it must consume all the input provided, but
|
||
* it may delay the end of the corresponding output until a subsequent
|
||
* call to psa_aead_update(), psa_aead_finish() or psa_aead_verify()
|
||
* provides sufficient input. The amount of data that can be delayed
|
||
* in this way is bounded by #PSA_AEAD_UPDATE_OUTPUT_SIZE.
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param[in] input Buffer containing the message fragment to
|
||
* encrypt or decrypt.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[out] output Buffer where the output is to be written.
|
||
* \param output_size Size of the \p output buffer in bytes.
|
||
* This must be appropriate for the selected
|
||
* algorithm and key:
|
||
* - A sufficient output size is
|
||
* #PSA_AEAD_UPDATE_OUTPUT_SIZE(\c key_type,
|
||
* \c alg, \p input_length) where
|
||
* \c key_type is the type of key and \c alg is
|
||
* the algorithm that were used to set up the
|
||
* operation.
|
||
* - #PSA_AEAD_UPDATE_OUTPUT_MAX_SIZE(\p
|
||
* input_length) evaluates to the maximum
|
||
* output size of any supported AEAD
|
||
* algorithm.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the returned output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, have a nonce
|
||
* set, and have lengths set if required by the algorithm).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p output buffer is too small.
|
||
* #PSA_AEAD_UPDATE_OUTPUT_SIZE(\c key_type, \c alg, \p input_length) or
|
||
* #PSA_AEAD_UPDATE_OUTPUT_MAX_SIZE(\p input_length) can be used to
|
||
* determine the required buffer size.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total length of input to psa_aead_update_ad() so far is
|
||
* less than the additional data length that was previously
|
||
* specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total input length overflows the plaintext length that
|
||
* was previously specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_update(psa_aead_operation_t *operation,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/** Finish encrypting a message in an AEAD operation.
|
||
*
|
||
* The operation must have been set up with psa_aead_encrypt_setup().
|
||
*
|
||
* This function finishes the authentication of the additional data
|
||
* formed by concatenating the inputs passed to preceding calls to
|
||
* psa_aead_update_ad() with the plaintext formed by concatenating the
|
||
* inputs passed to preceding calls to psa_aead_update().
|
||
*
|
||
* This function has two output buffers:
|
||
* - \p ciphertext contains trailing ciphertext that was buffered from
|
||
* preceding calls to psa_aead_update().
|
||
* - \p tag contains the authentication tag.
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param[out] ciphertext Buffer where the last part of the ciphertext
|
||
* is to be written.
|
||
* \param ciphertext_size Size of the \p ciphertext buffer in bytes.
|
||
* This must be appropriate for the selected
|
||
* algorithm and key:
|
||
* - A sufficient output size is
|
||
* #PSA_AEAD_FINISH_OUTPUT_SIZE(\c key_type,
|
||
* \c alg) where \c key_type is the type of key
|
||
* and \c alg is the algorithm that were used to
|
||
* set up the operation.
|
||
* - #PSA_AEAD_FINISH_OUTPUT_MAX_SIZE evaluates to
|
||
* the maximum output size of any supported AEAD
|
||
* algorithm.
|
||
* \param[out] ciphertext_length On success, the number of bytes of
|
||
* returned ciphertext.
|
||
* \param[out] tag Buffer where the authentication tag is
|
||
* to be written.
|
||
* \param tag_size Size of the \p tag buffer in bytes.
|
||
* This must be appropriate for the selected
|
||
* algorithm and key:
|
||
* - The exact tag size is #PSA_AEAD_TAG_LENGTH(\c
|
||
* key_type, \c key_bits, \c alg) where
|
||
* \c key_type and \c key_bits are the type and
|
||
* bit-size of the key, and \c alg is the
|
||
* algorithm that were used in the call to
|
||
* psa_aead_encrypt_setup().
|
||
* - #PSA_AEAD_TAG_MAX_SIZE evaluates to the
|
||
* maximum tag size of any supported AEAD
|
||
* algorithm.
|
||
* \param[out] tag_length On success, the number of bytes
|
||
* that make up the returned tag.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be an active encryption
|
||
* operation with a nonce set).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p ciphertext or \p tag buffer is too small.
|
||
* #PSA_AEAD_FINISH_OUTPUT_SIZE(\c key_type, \c alg) or
|
||
* #PSA_AEAD_FINISH_OUTPUT_MAX_SIZE can be used to determine the
|
||
* required \p ciphertext buffer size. #PSA_AEAD_TAG_LENGTH(\c key_type,
|
||
* \c key_bits, \c alg) or #PSA_AEAD_TAG_MAX_SIZE can be used to
|
||
* determine the required \p tag buffer size.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total length of input to psa_aead_update_ad() so far is
|
||
* less than the additional data length that was previously
|
||
* specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total length of input to psa_aead_update() so far is
|
||
* less than the plaintext length that was previously
|
||
* specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_finish(psa_aead_operation_t *operation,
|
||
uint8_t *ciphertext,
|
||
size_t ciphertext_size,
|
||
size_t *ciphertext_length,
|
||
uint8_t *tag,
|
||
size_t tag_size,
|
||
size_t *tag_length);
|
||
|
||
/** Finish authenticating and decrypting a message in an AEAD operation.
|
||
*
|
||
* The operation must have been set up with psa_aead_decrypt_setup().
|
||
*
|
||
* This function finishes the authenticated decryption of the message
|
||
* components:
|
||
*
|
||
* - The additional data consisting of the concatenation of the inputs
|
||
* passed to preceding calls to psa_aead_update_ad().
|
||
* - The ciphertext consisting of the concatenation of the inputs passed to
|
||
* preceding calls to psa_aead_update().
|
||
* - The tag passed to this function call.
|
||
*
|
||
* If the authentication tag is correct, this function outputs any remaining
|
||
* plaintext and reports success. If the authentication tag is not correct,
|
||
* this function returns #PSA_ERROR_INVALID_SIGNATURE.
|
||
*
|
||
* When this function returns successfuly, the operation becomes inactive.
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_aead_abort().
|
||
*
|
||
* \note Implementations shall make the best effort to ensure that the
|
||
* comparison between the actual tag and the expected tag is performed
|
||
* in constant time.
|
||
*
|
||
* \param[in,out] operation Active AEAD operation.
|
||
* \param[out] plaintext Buffer where the last part of the plaintext
|
||
* is to be written. This is the remaining data
|
||
* from previous calls to psa_aead_update()
|
||
* that could not be processed until the end
|
||
* of the input.
|
||
* \param plaintext_size Size of the \p plaintext buffer in bytes.
|
||
* This must be appropriate for the selected algorithm and key:
|
||
* - A sufficient output size is
|
||
* #PSA_AEAD_VERIFY_OUTPUT_SIZE(\c key_type,
|
||
* \c alg) where \c key_type is the type of key
|
||
* and \c alg is the algorithm that were used to
|
||
* set up the operation.
|
||
* - #PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE evaluates to
|
||
* the maximum output size of any supported AEAD
|
||
* algorithm.
|
||
* \param[out] plaintext_length On success, the number of bytes of
|
||
* returned plaintext.
|
||
* \param[in] tag Buffer containing the authentication tag.
|
||
* \param tag_length Size of the \p tag buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The calculations were successful, but the authentication tag is
|
||
* not correct.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be an active decryption
|
||
* operation with a nonce set).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p plaintext buffer is too small.
|
||
* #PSA_AEAD_VERIFY_OUTPUT_SIZE(\c key_type, \c alg) or
|
||
* #PSA_AEAD_VERIFY_OUTPUT_MAX_SIZE can be used to determine the
|
||
* required buffer size.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total length of input to psa_aead_update_ad() so far is
|
||
* less than the additional data length that was previously
|
||
* specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The total length of input to psa_aead_update() so far is
|
||
* less than the plaintext length that was previously
|
||
* specified with psa_aead_set_lengths().
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_verify(psa_aead_operation_t *operation,
|
||
uint8_t *plaintext,
|
||
size_t plaintext_size,
|
||
size_t *plaintext_length,
|
||
const uint8_t *tag,
|
||
size_t tag_length);
|
||
|
||
/** Abort an AEAD operation.
|
||
*
|
||
* Aborting an operation frees all associated resources except for the
|
||
* \p operation structure itself. Once aborted, the operation object
|
||
* can be reused for another operation by calling
|
||
* psa_aead_encrypt_setup() or psa_aead_decrypt_setup() again.
|
||
*
|
||
* You may call this function any time after the operation object has
|
||
* been initialized as described in #psa_aead_operation_t.
|
||
*
|
||
* In particular, calling psa_aead_abort() after the operation has been
|
||
* terminated by a call to psa_aead_abort(), psa_aead_finish() or
|
||
* psa_aead_verify() is safe and has no effect.
|
||
*
|
||
* \param[in,out] operation Initialized AEAD operation.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_aead_abort(psa_aead_operation_t *operation);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup asymmetric Asymmetric cryptography
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* \brief Sign a message with a private key. For hash-and-sign algorithms,
|
||
* this includes the hashing step.
|
||
*
|
||
* \note To perform a multi-part hash-and-sign signature algorithm, first use
|
||
* a multi-part hash operation and then pass the resulting hash to
|
||
* psa_sign_hash(). PSA_ALG_GET_HASH(\p alg) can be used to determine the
|
||
* hash algorithm to use.
|
||
*
|
||
* \param[in] key Identifier of the key to use for the operation.
|
||
* It must be an asymmetric key pair. The key must
|
||
* allow the usage #PSA_KEY_USAGE_SIGN_MESSAGE.
|
||
* \param[in] alg An asymmetric signature algorithm (PSA_ALG_XXX
|
||
* value such that #PSA_ALG_IS_SIGN_MESSAGE(\p alg)
|
||
* is true), that is compatible with the type of
|
||
* \p key.
|
||
* \param[in] input The input message to sign.
|
||
* \param[in] input_length Size of the \p input buffer in bytes.
|
||
* \param[out] signature Buffer where the signature is to be written.
|
||
* \param[in] signature_size Size of the \p signature buffer in bytes. This
|
||
* must be appropriate for the selected
|
||
* algorithm and key:
|
||
* - The required signature size is
|
||
* #PSA_SIGN_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
|
||
* where \c key_type and \c key_bits are the type and
|
||
* bit-size respectively of key.
|
||
* - #PSA_SIGNATURE_MAX_SIZE evaluates to the
|
||
* maximum signature size of any supported
|
||
* signature algorithm.
|
||
* \param[out] signature_length On success, the number of bytes that make up
|
||
* the returned signature value.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The key does not have the #PSA_KEY_USAGE_SIGN_MESSAGE flag,
|
||
* or it does not permit the requested algorithm.
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p signature buffer is too small. You can
|
||
* determine a sufficient buffer size by calling
|
||
* #PSA_SIGN_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
|
||
* where \c key_type and \c key_bits are the type and bit-size
|
||
* respectively of \p key.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_sign_message( mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t * input,
|
||
size_t input_length,
|
||
uint8_t * signature,
|
||
size_t signature_size,
|
||
size_t * signature_length );
|
||
|
||
/** \brief Verify the signature of a message with a public key, using
|
||
* a hash-and-sign verification algorithm.
|
||
*
|
||
* \note To perform a multi-part hash-and-sign signature verification
|
||
* algorithm, first use a multi-part hash operation to hash the message
|
||
* and then pass the resulting hash to psa_verify_hash().
|
||
* PSA_ALG_GET_HASH(\p alg) can be used to determine the hash algorithm
|
||
* to use.
|
||
*
|
||
* \param[in] key Identifier of the key to use for the operation.
|
||
* It must be a public key or an asymmetric key
|
||
* pair. The key must allow the usage
|
||
* #PSA_KEY_USAGE_VERIFY_MESSAGE.
|
||
* \param[in] alg An asymmetric signature algorithm (PSA_ALG_XXX
|
||
* value such that #PSA_ALG_IS_SIGN_MESSAGE(\p alg)
|
||
* is true), that is compatible with the type of
|
||
* \p key.
|
||
* \param[in] input The message whose signature is to be verified.
|
||
* \param[in] input_length Size of the \p input buffer in bytes.
|
||
* \param[out] signature Buffer containing the signature to verify.
|
||
* \param[in] signature_length Size of the \p signature buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The key does not have the #PSA_KEY_USAGE_SIGN_MESSAGE flag,
|
||
* or it does not permit the requested algorithm.
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The calculation was performed successfully, but the passed signature
|
||
* is not a valid signature.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_verify_message( mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t * input,
|
||
size_t input_length,
|
||
const uint8_t * signature,
|
||
size_t signature_length );
|
||
|
||
/**
|
||
* \brief Sign a hash or short message with a private key.
|
||
*
|
||
* Note that to perform a hash-and-sign signature algorithm, you must
|
||
* first calculate the hash by calling psa_hash_setup(), psa_hash_update()
|
||
* and psa_hash_finish(), or alternatively by calling psa_hash_compute().
|
||
* Then pass the resulting hash as the \p hash
|
||
* parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg)
|
||
* to determine the hash algorithm to use.
|
||
*
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must be an asymmetric key pair. The key must
|
||
* allow the usage #PSA_KEY_USAGE_SIGN_HASH.
|
||
* \param alg A signature algorithm that is compatible with
|
||
* the type of \p key.
|
||
* \param[in] hash The hash or message to sign.
|
||
* \param hash_length Size of the \p hash buffer in bytes.
|
||
* \param[out] signature Buffer where the signature is to be written.
|
||
* \param signature_size Size of the \p signature buffer in bytes.
|
||
* \param[out] signature_length On success, the number of bytes
|
||
* that make up the returned signature value.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p signature buffer is too small. You can
|
||
* determine a sufficient buffer size by calling
|
||
* #PSA_SIGN_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
|
||
* where \c key_type and \c key_bits are the type and bit-size
|
||
* respectively of \p key.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_sign_hash(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *hash,
|
||
size_t hash_length,
|
||
uint8_t *signature,
|
||
size_t signature_size,
|
||
size_t *signature_length);
|
||
|
||
/**
|
||
* \brief Verify the signature of a hash or short message using a public key.
|
||
*
|
||
* Note that to perform a hash-and-sign signature algorithm, you must
|
||
* first calculate the hash by calling psa_hash_setup(), psa_hash_update()
|
||
* and psa_hash_finish(), or alternatively by calling psa_hash_compute().
|
||
* Then pass the resulting hash as the \p hash
|
||
* parameter to this function. You can use #PSA_ALG_SIGN_GET_HASH(\p alg)
|
||
* to determine the hash algorithm to use.
|
||
*
|
||
* \param key Identifier of the key to use for the operation. It
|
||
* must be a public key or an asymmetric key pair. The
|
||
* key must allow the usage
|
||
* #PSA_KEY_USAGE_VERIFY_HASH.
|
||
* \param alg A signature algorithm that is compatible with
|
||
* the type of \p key.
|
||
* \param[in] hash The hash or message whose signature is to be
|
||
* verified.
|
||
* \param hash_length Size of the \p hash buffer in bytes.
|
||
* \param[in] signature Buffer containing the signature to verify.
|
||
* \param signature_length Size of the \p signature buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* The signature is valid.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The calculation was perfomed successfully, but the passed
|
||
* signature is not a valid signature.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_verify_hash(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *hash,
|
||
size_t hash_length,
|
||
const uint8_t *signature,
|
||
size_t signature_length);
|
||
|
||
/**
|
||
* \brief Encrypt a short message with a public key.
|
||
*
|
||
* \param key Identifer of the key to use for the operation.
|
||
* It must be a public key or an asymmetric key
|
||
* pair. It must allow the usage
|
||
* #PSA_KEY_USAGE_ENCRYPT.
|
||
* \param alg An asymmetric encryption algorithm that is
|
||
* compatible with the type of \p key.
|
||
* \param[in] input The message to encrypt.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[in] salt A salt or label, if supported by the
|
||
* encryption algorithm.
|
||
* If the algorithm does not support a
|
||
* salt, pass \c NULL.
|
||
* If the algorithm supports an optional
|
||
* salt and you do not want to pass a salt,
|
||
* pass \c NULL.
|
||
*
|
||
* - For #PSA_ALG_RSA_PKCS1V15_CRYPT, no salt is
|
||
* supported.
|
||
* \param salt_length Size of the \p salt buffer in bytes.
|
||
* If \p salt is \c NULL, pass 0.
|
||
* \param[out] output Buffer where the encrypted message is to
|
||
* be written.
|
||
* \param output_size Size of the \p output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the returned output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p output buffer is too small. You can
|
||
* determine a sufficient buffer size by calling
|
||
* #PSA_ASYMMETRIC_ENCRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
|
||
* where \c key_type and \c key_bits are the type and bit-size
|
||
* respectively of \p key.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_asymmetric_encrypt(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
const uint8_t *salt,
|
||
size_t salt_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/**
|
||
* \brief Decrypt a short message with a private key.
|
||
*
|
||
* \param key Identifier of the key to use for the operation.
|
||
* It must be an asymmetric key pair. It must
|
||
* allow the usage #PSA_KEY_USAGE_DECRYPT.
|
||
* \param alg An asymmetric encryption algorithm that is
|
||
* compatible with the type of \p key.
|
||
* \param[in] input The message to decrypt.
|
||
* \param input_length Size of the \p input buffer in bytes.
|
||
* \param[in] salt A salt or label, if supported by the
|
||
* encryption algorithm.
|
||
* If the algorithm does not support a
|
||
* salt, pass \c NULL.
|
||
* If the algorithm supports an optional
|
||
* salt and you do not want to pass a salt,
|
||
* pass \c NULL.
|
||
*
|
||
* - For #PSA_ALG_RSA_PKCS1V15_CRYPT, no salt is
|
||
* supported.
|
||
* \param salt_length Size of the \p salt buffer in bytes.
|
||
* If \p salt is \c NULL, pass 0.
|
||
* \param[out] output Buffer where the decrypted message is to
|
||
* be written.
|
||
* \param output_size Size of the \c output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the returned output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p output buffer is too small. You can
|
||
* determine a sufficient buffer size by calling
|
||
* #PSA_ASYMMETRIC_DECRYPT_OUTPUT_SIZE(\c key_type, \c key_bits, \p alg)
|
||
* where \c key_type and \c key_bits are the type and bit-size
|
||
* respectively of \p key.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_INVALID_PADDING
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_asymmetric_decrypt(mbedtls_svc_key_id_t key,
|
||
psa_algorithm_t alg,
|
||
const uint8_t *input,
|
||
size_t input_length,
|
||
const uint8_t *salt,
|
||
size_t salt_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup key_derivation Key derivation and pseudorandom generation
|
||
* @{
|
||
*/
|
||
|
||
/** The type of the state data structure for key derivation operations.
|
||
*
|
||
* Before calling any function on a key derivation operation object, the
|
||
* application must initialize it by any of the following means:
|
||
* - Set the structure to all-bits-zero, for example:
|
||
* \code
|
||
* psa_key_derivation_operation_t operation;
|
||
* memset(&operation, 0, sizeof(operation));
|
||
* \endcode
|
||
* - Initialize the structure to logical zero values, for example:
|
||
* \code
|
||
* psa_key_derivation_operation_t operation = {0};
|
||
* \endcode
|
||
* - Initialize the structure to the initializer #PSA_KEY_DERIVATION_OPERATION_INIT,
|
||
* for example:
|
||
* \code
|
||
* psa_key_derivation_operation_t operation = PSA_KEY_DERIVATION_OPERATION_INIT;
|
||
* \endcode
|
||
* - Assign the result of the function psa_key_derivation_operation_init()
|
||
* to the structure, for example:
|
||
* \code
|
||
* psa_key_derivation_operation_t operation;
|
||
* operation = psa_key_derivation_operation_init();
|
||
* \endcode
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice.
|
||
*/
|
||
typedef struct psa_key_derivation_s psa_key_derivation_operation_t;
|
||
|
||
/** \def PSA_KEY_DERIVATION_OPERATION_INIT
|
||
*
|
||
* This macro returns a suitable initializer for a key derivation operation
|
||
* object of type #psa_key_derivation_operation_t.
|
||
*/
|
||
|
||
/** Return an initial value for a key derivation operation object.
|
||
*/
|
||
static psa_key_derivation_operation_t psa_key_derivation_operation_init(void);
|
||
|
||
/** Set up a key derivation operation.
|
||
*
|
||
* A key derivation algorithm takes some inputs and uses them to generate
|
||
* a byte stream in a deterministic way.
|
||
* This byte stream can be used to produce keys and other
|
||
* cryptographic material.
|
||
*
|
||
* To derive a key:
|
||
* -# Start with an initialized object of type #psa_key_derivation_operation_t.
|
||
* -# Call psa_key_derivation_setup() to select the algorithm.
|
||
* -# Provide the inputs for the key derivation by calling
|
||
* psa_key_derivation_input_bytes() or psa_key_derivation_input_key()
|
||
* as appropriate. Which inputs are needed, in what order, and whether
|
||
* they may be keys and if so of what type depends on the algorithm.
|
||
* -# Optionally set the operation's maximum capacity with
|
||
* psa_key_derivation_set_capacity(). You may do this before, in the middle
|
||
* of or after providing inputs. For some algorithms, this step is mandatory
|
||
* because the output depends on the maximum capacity.
|
||
* -# To derive a key, call psa_key_derivation_output_key().
|
||
* To derive a byte string for a different purpose, call
|
||
* psa_key_derivation_output_bytes().
|
||
* Successive calls to these functions use successive output bytes
|
||
* calculated by the key derivation algorithm.
|
||
* -# Clean up the key derivation operation object with
|
||
* psa_key_derivation_abort().
|
||
*
|
||
* If this function returns an error, the key derivation operation object is
|
||
* not changed.
|
||
*
|
||
* If an error occurs at any step after a call to psa_key_derivation_setup(),
|
||
* the operation will need to be reset by a call to psa_key_derivation_abort().
|
||
*
|
||
* Implementations must reject an attempt to derive a key of size 0.
|
||
*
|
||
* \param[in,out] operation The key derivation operation object
|
||
* to set up. It must
|
||
* have been initialized but not set up yet.
|
||
* \param alg The key derivation algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_KEY_DERIVATION(\p alg) is true).
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c alg is not a key derivation algorithm.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \c alg is not supported or is not a key derivation algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be inactive).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_setup(
|
||
psa_key_derivation_operation_t *operation,
|
||
psa_algorithm_t alg);
|
||
|
||
/** Retrieve the current capacity of a key derivation operation.
|
||
*
|
||
* The capacity of a key derivation is the maximum number of bytes that it can
|
||
* return. When you get *N* bytes of output from a key derivation operation,
|
||
* this reduces its capacity by *N*.
|
||
*
|
||
* \param[in] operation The operation to query.
|
||
* \param[out] capacity On success, the capacity of the operation.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active).
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_get_capacity(
|
||
const psa_key_derivation_operation_t *operation,
|
||
size_t *capacity);
|
||
|
||
/** Set the maximum capacity of a key derivation operation.
|
||
*
|
||
* The capacity of a key derivation operation is the maximum number of bytes
|
||
* that the key derivation operation can return from this point onwards.
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to modify.
|
||
* \param capacity The new capacity of the operation.
|
||
* It must be less or equal to the operation's
|
||
* current capacity.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p capacity is larger than the operation's current capacity.
|
||
* In this case, the operation object remains valid and its capacity
|
||
* remains unchanged.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active).
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_set_capacity(
|
||
psa_key_derivation_operation_t *operation,
|
||
size_t capacity);
|
||
|
||
/** Use the maximum possible capacity for a key derivation operation.
|
||
*
|
||
* Use this value as the capacity argument when setting up a key derivation
|
||
* to indicate that the operation should have the maximum possible capacity.
|
||
* The value of the maximum possible capacity depends on the key derivation
|
||
* algorithm.
|
||
*/
|
||
#define PSA_KEY_DERIVATION_UNLIMITED_CAPACITY ((size_t)(-1))
|
||
|
||
/** Provide an input for key derivation or key agreement.
|
||
*
|
||
* Which inputs are required and in what order depends on the algorithm.
|
||
* Refer to the documentation of each key derivation or key agreement
|
||
* algorithm for information.
|
||
*
|
||
* This function passes direct inputs, which is usually correct for
|
||
* non-secret inputs. To pass a secret input, which should be in a key
|
||
* object, call psa_key_derivation_input_key() instead of this function.
|
||
* Refer to the documentation of individual step types
|
||
* (`PSA_KEY_DERIVATION_INPUT_xxx` values of type ::psa_key_derivation_step_t)
|
||
* for more information.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to use.
|
||
* It must have been set up with
|
||
* psa_key_derivation_setup() and must not
|
||
* have produced any output yet.
|
||
* \param step Which step the input data is for.
|
||
* \param[in] data Input data to use.
|
||
* \param data_length Size of the \p data buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step is not compatible with the operation's algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step does not allow direct inputs.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid for this input \p step.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_input_bytes(
|
||
psa_key_derivation_operation_t *operation,
|
||
psa_key_derivation_step_t step,
|
||
const uint8_t *data,
|
||
size_t data_length);
|
||
|
||
/** Provide a numeric input for key derivation or key agreement.
|
||
*
|
||
* Which inputs are required and in what order depends on the algorithm.
|
||
* However, when an algorithm requires a particular order, numeric inputs
|
||
* usually come first as they tend to be configuration parameters.
|
||
* Refer to the documentation of each key derivation or key agreement
|
||
* algorithm for information.
|
||
*
|
||
* This function is used for inputs which are fixed-size non-negative
|
||
* integers.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to use.
|
||
* It must have been set up with
|
||
* psa_key_derivation_setup() and must not
|
||
* have produced any output yet.
|
||
* \param step Which step the input data is for.
|
||
* \param[in] value The value of the numeric input.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step is not compatible with the operation's algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step does not allow numeric inputs.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid for this input \p step.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_input_integer(
|
||
psa_key_derivation_operation_t *operation,
|
||
psa_key_derivation_step_t step,
|
||
uint64_t value);
|
||
|
||
/** Provide an input for key derivation in the form of a key.
|
||
*
|
||
* Which inputs are required and in what order depends on the algorithm.
|
||
* Refer to the documentation of each key derivation or key agreement
|
||
* algorithm for information.
|
||
*
|
||
* This function obtains input from a key object, which is usually correct for
|
||
* secret inputs or for non-secret personalization strings kept in the key
|
||
* store. To pass a non-secret parameter which is not in the key store,
|
||
* call psa_key_derivation_input_bytes() instead of this function.
|
||
* Refer to the documentation of individual step types
|
||
* (`PSA_KEY_DERIVATION_INPUT_xxx` values of type ::psa_key_derivation_step_t)
|
||
* for more information.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to use.
|
||
* It must have been set up with
|
||
* psa_key_derivation_setup() and must not
|
||
* have produced any output yet.
|
||
* \param step Which step the input data is for.
|
||
* \param key Identifier of the key. It must have an
|
||
* appropriate type for step and must allow the
|
||
* usage #PSA_KEY_USAGE_DERIVE or
|
||
* #PSA_KEY_USAGE_VERIFY_DERIVATION (see note)
|
||
* and the algorithm used by the operation.
|
||
*
|
||
* \note Once all inputs steps are completed, the operations will allow:
|
||
* - psa_key_derivation_output_bytes() if each input was either a direct input
|
||
* or a key with #PSA_KEY_USAGE_DERIVE set;
|
||
* - psa_key_derivation_output_key() if the input for step
|
||
* #PSA_KEY_DERIVATION_INPUT_SECRET or #PSA_KEY_DERIVATION_INPUT_PASSWORD
|
||
* was from a key slot with #PSA_KEY_USAGE_DERIVE and each other input was
|
||
* either a direct input or a key with #PSA_KEY_USAGE_DERIVE set;
|
||
* - psa_key_derivation_verify_bytes() if each input was either a direct input
|
||
* or a key with #PSA_KEY_USAGE_VERIFY_DERIVATION set;
|
||
* - psa_key_derivation_verify_key() under the same conditions as
|
||
* psa_key_derivation_verify_bytes().
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The key allows neither #PSA_KEY_USAGE_DERIVE nor
|
||
* #PSA_KEY_USAGE_VERIFY_DERIVATION, or it doesn't allow this
|
||
* algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step is not compatible with the operation's algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step does not allow key inputs of the given type
|
||
* or does not allow key inputs at all.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid for this input \p step.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_input_key(
|
||
psa_key_derivation_operation_t *operation,
|
||
psa_key_derivation_step_t step,
|
||
mbedtls_svc_key_id_t key);
|
||
|
||
/** Perform a key agreement and use the shared secret as input to a key
|
||
* derivation.
|
||
*
|
||
* A key agreement algorithm takes two inputs: a private key \p private_key
|
||
* a public key \p peer_key.
|
||
* The result of this function is passed as input to a key derivation.
|
||
* The output of this key derivation can be extracted by reading from the
|
||
* resulting operation to produce keys and other cryptographic material.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to use.
|
||
* It must have been set up with
|
||
* psa_key_derivation_setup() with a
|
||
* key agreement and derivation algorithm
|
||
* \c alg (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_KEY_AGREEMENT(\c alg) is true
|
||
* and #PSA_ALG_IS_RAW_KEY_AGREEMENT(\c alg)
|
||
* is false).
|
||
* The operation must be ready for an
|
||
* input of the type given by \p step.
|
||
* \param step Which step the input data is for.
|
||
* \param private_key Identifier of the private key to use. It must
|
||
* allow the usage #PSA_KEY_USAGE_DERIVE.
|
||
* \param[in] peer_key Public key of the peer. The peer key must be in the
|
||
* same format that psa_import_key() accepts for the
|
||
* public key type corresponding to the type of
|
||
* private_key. That is, this function performs the
|
||
* equivalent of
|
||
* #psa_import_key(...,
|
||
* `peer_key`, `peer_key_length`) where
|
||
* with key attributes indicating the public key
|
||
* type corresponding to the type of `private_key`.
|
||
* For example, for EC keys, this means that peer_key
|
||
* is interpreted as a point on the curve that the
|
||
* private key is on. The standard formats for public
|
||
* keys are documented in the documentation of
|
||
* psa_export_public_key().
|
||
* \param peer_key_length Size of \p peer_key in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid for this key agreement \p step.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c private_key is not compatible with \c alg,
|
||
* or \p peer_key is not valid for \c alg or not compatible with
|
||
* \c private_key.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \c alg is not supported or is not a key derivation algorithm.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \c step does not allow an input resulting from a key agreement.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_key_agreement(
|
||
psa_key_derivation_operation_t *operation,
|
||
psa_key_derivation_step_t step,
|
||
mbedtls_svc_key_id_t private_key,
|
||
const uint8_t *peer_key,
|
||
size_t peer_key_length);
|
||
|
||
/** Read some data from a key derivation operation.
|
||
*
|
||
* This function calculates output bytes from a key derivation algorithm and
|
||
* return those bytes.
|
||
* If you view the key derivation's output as a stream of bytes, this
|
||
* function destructively reads the requested number of bytes from the
|
||
* stream.
|
||
* The operation's capacity decreases by the number of bytes read.
|
||
*
|
||
* If this function returns an error status other than
|
||
* #PSA_ERROR_INSUFFICIENT_DATA, the operation enters an error
|
||
* state and must be aborted by calling psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to read from.
|
||
* \param[out] output Buffer where the output will be written.
|
||
* \param output_length Number of bytes to output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* One of the inputs was a key whose policy didn't allow
|
||
* #PSA_KEY_USAGE_DERIVE.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_DATA
|
||
* The operation's capacity was less than
|
||
* \p output_length bytes. Note that in this case,
|
||
* no output is written to the output buffer.
|
||
* The operation's capacity is set to 0, thus
|
||
* subsequent calls to this function will not
|
||
* succeed, even with a smaller output buffer.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active and completed
|
||
* all required input steps).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_output_bytes(
|
||
psa_key_derivation_operation_t *operation,
|
||
uint8_t *output,
|
||
size_t output_length);
|
||
|
||
/** Derive a key from an ongoing key derivation operation.
|
||
*
|
||
* This function calculates output bytes from a key derivation algorithm
|
||
* and uses those bytes to generate a key deterministically.
|
||
* The key's location, usage policy, type and size are taken from
|
||
* \p attributes.
|
||
*
|
||
* If you view the key derivation's output as a stream of bytes, this
|
||
* function destructively reads as many bytes as required from the
|
||
* stream.
|
||
* The operation's capacity decreases by the number of bytes read.
|
||
*
|
||
* If this function returns an error status other than
|
||
* #PSA_ERROR_INSUFFICIENT_DATA, the operation enters an error
|
||
* state and must be aborted by calling psa_key_derivation_abort().
|
||
*
|
||
* How much output is produced and consumed from the operation, and how
|
||
* the key is derived, depends on the key type and on the key size
|
||
* (denoted \c bits below):
|
||
*
|
||
* - For key types for which the key is an arbitrary sequence of bytes
|
||
* of a given size, this function is functionally equivalent to
|
||
* calling #psa_key_derivation_output_bytes
|
||
* and passing the resulting output to #psa_import_key.
|
||
* However, this function has a security benefit:
|
||
* if the implementation provides an isolation boundary then
|
||
* the key material is not exposed outside the isolation boundary.
|
||
* As a consequence, for these key types, this function always consumes
|
||
* exactly (\c bits / 8) bytes from the operation.
|
||
* The following key types defined in this specification follow this scheme:
|
||
*
|
||
* - #PSA_KEY_TYPE_AES;
|
||
* - #PSA_KEY_TYPE_ARC4;
|
||
* - #PSA_KEY_TYPE_CAMELLIA;
|
||
* - #PSA_KEY_TYPE_DERIVE;
|
||
* - #PSA_KEY_TYPE_HMAC;
|
||
* - #PSA_KEY_TYPE_PASSWORD_HASH.
|
||
*
|
||
* - For ECC keys on a Montgomery elliptic curve
|
||
* (#PSA_KEY_TYPE_ECC_KEY_PAIR(\c curve) where \c curve designates a
|
||
* Montgomery curve), this function always draws a byte string whose
|
||
* length is determined by the curve, and sets the mandatory bits
|
||
* accordingly. That is:
|
||
*
|
||
* - Curve25519 (#PSA_ECC_FAMILY_MONTGOMERY, 255 bits): draw a 32-byte
|
||
* string and process it as specified in RFC 7748 §5.
|
||
* - Curve448 (#PSA_ECC_FAMILY_MONTGOMERY, 448 bits): draw a 56-byte
|
||
* string and process it as specified in RFC 7748 §5.
|
||
*
|
||
* - For key types for which the key is represented by a single sequence of
|
||
* \c bits bits with constraints as to which bit sequences are acceptable,
|
||
* this function draws a byte string of length (\c bits / 8) bytes rounded
|
||
* up to the nearest whole number of bytes. If the resulting byte string
|
||
* is acceptable, it becomes the key, otherwise the drawn bytes are discarded.
|
||
* This process is repeated until an acceptable byte string is drawn.
|
||
* The byte string drawn from the operation is interpreted as specified
|
||
* for the output produced by psa_export_key().
|
||
* The following key types defined in this specification follow this scheme:
|
||
*
|
||
* - #PSA_KEY_TYPE_DES.
|
||
* Force-set the parity bits, but discard forbidden weak keys.
|
||
* For 2-key and 3-key triple-DES, the three keys are generated
|
||
* successively (for example, for 3-key triple-DES,
|
||
* if the first 8 bytes specify a weak key and the next 8 bytes do not,
|
||
* discard the first 8 bytes, use the next 8 bytes as the first key,
|
||
* and continue reading output from the operation to derive the other
|
||
* two keys).
|
||
* - Finite-field Diffie-Hellman keys (#PSA_KEY_TYPE_DH_KEY_PAIR(\c group)
|
||
* where \c group designates any Diffie-Hellman group) and
|
||
* ECC keys on a Weierstrass elliptic curve
|
||
* (#PSA_KEY_TYPE_ECC_KEY_PAIR(\c curve) where \c curve designates a
|
||
* Weierstrass curve).
|
||
* For these key types, interpret the byte string as integer
|
||
* in big-endian order. Discard it if it is not in the range
|
||
* [0, *N* - 2] where *N* is the boundary of the private key domain
|
||
* (the prime *p* for Diffie-Hellman, the subprime *q* for DSA,
|
||
* or the order of the curve's base point for ECC).
|
||
* Add 1 to the resulting integer and use this as the private key *x*.
|
||
* This method allows compliance to NIST standards, specifically
|
||
* the methods titled "key-pair generation by testing candidates"
|
||
* in NIST SP 800-56A §5.6.1.1.4 for Diffie-Hellman,
|
||
* in FIPS 186-4 §B.1.2 for DSA, and
|
||
* in NIST SP 800-56A §5.6.1.2.2 or
|
||
* FIPS 186-4 §B.4.2 for elliptic curve keys.
|
||
*
|
||
* - For other key types, including #PSA_KEY_TYPE_RSA_KEY_PAIR,
|
||
* the way in which the operation output is consumed is
|
||
* implementation-defined.
|
||
*
|
||
* In all cases, the data that is read is discarded from the operation.
|
||
* The operation's capacity is decreased by the number of bytes read.
|
||
*
|
||
* For algorithms that take an input step #PSA_KEY_DERIVATION_INPUT_SECRET,
|
||
* the input to that step must be provided with psa_key_derivation_input_key().
|
||
* Future versions of this specification may include additional restrictions
|
||
* on the derived key based on the attributes and strength of the secret key.
|
||
*
|
||
* \param[in] attributes The attributes for the new key.
|
||
* If the key type to be created is
|
||
* #PSA_KEY_TYPE_PASSWORD_HASH then the algorithm in
|
||
* the policy must be the same as in the current
|
||
* operation.
|
||
* \param[in,out] operation The key derivation operation object to read from.
|
||
* \param[out] key On success, an identifier for the newly created
|
||
* key. For persistent keys, this is the key
|
||
* identifier defined in \p attributes.
|
||
* \c 0 on failure.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* If the key is persistent, the key material and the key's metadata
|
||
* have been saved to persistent storage.
|
||
* \retval #PSA_ERROR_ALREADY_EXISTS
|
||
* This is an attempt to create a persistent key, and there is
|
||
* already a persistent key with the given identifier.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_DATA
|
||
* There was not enough data to create the desired key.
|
||
* Note that in this case, no output is written to the output buffer.
|
||
* The operation's capacity is set to 0, thus subsequent calls to
|
||
* this function will not succeed, even with a smaller output buffer.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* The key type or key size is not supported, either by the
|
||
* implementation in general or in this particular location.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The provided key attributes are not valid for the operation.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The #PSA_KEY_DERIVATION_INPUT_SECRET or
|
||
* #PSA_KEY_DERIVATION_INPUT_PASSWORD input was not provided through a
|
||
* key; or one of the inputs was a key whose policy didn't allow
|
||
* #PSA_KEY_USAGE_DERIVE.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active and completed
|
||
* all required input steps).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_INSUFFICIENT_STORAGE
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_output_key(
|
||
const psa_key_attributes_t *attributes,
|
||
psa_key_derivation_operation_t *operation,
|
||
mbedtls_svc_key_id_t *key);
|
||
|
||
/** Compare output data from a key derivation operation to an expected value.
|
||
*
|
||
* This function calculates output bytes from a key derivation algorithm and
|
||
* compares those bytes to an expected value in constant time.
|
||
* If you view the key derivation's output as a stream of bytes, this
|
||
* function destructively reads the requested number of bytes from the
|
||
* stream before comparing them.
|
||
* The operation's capacity decreases by the number of bytes read.
|
||
*
|
||
* This is functionally equivalent to the following code:
|
||
* \code
|
||
* psa_key_derivation_output_bytes(operation, tmp, output_length);
|
||
* if (memcmp(output, tmp, output_length) != 0)
|
||
* return PSA_ERROR_INVALID_SIGNATURE;
|
||
* \endcode
|
||
* except (1) it works even if the key's policy does not allow outputting the
|
||
* bytes, and (2) the comparison will be done in constant time.
|
||
*
|
||
* If this function returns an error status other than
|
||
* #PSA_ERROR_INSUFFICIENT_DATA or #PSA_ERROR_INVALID_SIGNATURE,
|
||
* the operation enters an error state and must be aborted by calling
|
||
* psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to read from.
|
||
* \param[in] expected_output Buffer where the output will be written.
|
||
* \param output_length Length ot the expected output; this is also the
|
||
* number of bytes that will be read.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The output was read successfully, but if differs from the expected
|
||
* output.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* One of the inputs was a key whose policy didn't allow
|
||
* #PSA_KEY_USAGE_VERIFY_DERIVATION.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_DATA
|
||
* The operation's capacity was less than
|
||
* \p output_length bytes. Note that in this case,
|
||
* the operation's capacity is set to 0, thus
|
||
* subsequent calls to this function will not
|
||
* succeed, even with a smaller output buffer.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active and completed
|
||
* all required input steps).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_verify_bytes(
|
||
psa_key_derivation_operation_t *operation,
|
||
const uint8_t *expected_output,
|
||
size_t output_length);
|
||
|
||
/** Compare output data from a key derivation operation to an expected value
|
||
* stored in a key object.
|
||
*
|
||
* This function calculates output bytes from a key derivation algorithm and
|
||
* compares those bytes to an expected value, provided as key of type
|
||
* #PSA_KEY_TYPE_PASSWORD_HASH.
|
||
* If you view the key derivation's output as a stream of bytes, this
|
||
* function destructively reads the number of bytes corresponding the the
|
||
* length of the expected value from the stream before comparing them.
|
||
* The operation's capacity decreases by the number of bytes read.
|
||
*
|
||
* This is functionally equivalent to exporting the key and calling
|
||
* psa_key_derivation_verify_bytes() on the result, except that it
|
||
* works even if the key cannot be exported.
|
||
*
|
||
* If this function returns an error status other than
|
||
* #PSA_ERROR_INSUFFICIENT_DATA or #PSA_ERROR_INVALID_SIGNATURE,
|
||
* the operation enters an error state and must be aborted by calling
|
||
* psa_key_derivation_abort().
|
||
*
|
||
* \param[in,out] operation The key derivation operation object to read from.
|
||
* \param[in] expected A key of type #PSA_KEY_TYPE_PASSWORD_HASH
|
||
* containing the expected output. Its policy must
|
||
* include the #PSA_KEY_USAGE_VERIFY_DERIVATION flag
|
||
* and the permitted algorithm must match the
|
||
* operation. The value of this key was likely
|
||
* computed by a previous call to
|
||
* psa_key_derivation_output_key().
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_INVALID_SIGNATURE
|
||
* The output was read successfully, but if differs from the expected
|
||
* output.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* The key passed as the expected value does not exist.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* The key passed as the expected value has an invalid type.
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* The key passed as the expected value does not allow this usage or
|
||
* this algorithm; or one of the inputs was a key whose policy didn't
|
||
* allow #PSA_KEY_USAGE_VERIFY_DERIVATION.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_DATA
|
||
* The operation's capacity was less than
|
||
* the length of the expected value. In this case,
|
||
* the operation's capacity is set to 0, thus
|
||
* subsequent calls to this function will not
|
||
* succeed, even with a smaller output buffer.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active and completed
|
||
* all required input steps).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_verify_key(
|
||
psa_key_derivation_operation_t *operation,
|
||
psa_key_id_t expected);
|
||
|
||
/** Abort a key derivation operation.
|
||
*
|
||
* Aborting an operation frees all associated resources except for the \c
|
||
* operation structure itself. Once aborted, the operation object can be reused
|
||
* for another operation by calling psa_key_derivation_setup() again.
|
||
*
|
||
* This function may be called at any time after the operation
|
||
* object has been initialized as described in #psa_key_derivation_operation_t.
|
||
*
|
||
* In particular, it is valid to call psa_key_derivation_abort() twice, or to
|
||
* call psa_key_derivation_abort() on an operation that has not been set up.
|
||
*
|
||
* \param[in,out] operation The operation to abort.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_key_derivation_abort(
|
||
psa_key_derivation_operation_t *operation);
|
||
|
||
/** Perform a key agreement and return the raw shared secret.
|
||
*
|
||
* \warning The raw result of a key agreement algorithm such as finite-field
|
||
* Diffie-Hellman or elliptic curve Diffie-Hellman has biases and should
|
||
* not be used directly as key material. It should instead be passed as
|
||
* input to a key derivation algorithm. To chain a key agreement with
|
||
* a key derivation, use psa_key_derivation_key_agreement() and other
|
||
* functions from the key derivation interface.
|
||
*
|
||
* \param alg The key agreement algorithm to compute
|
||
* (\c PSA_ALG_XXX value such that
|
||
* #PSA_ALG_IS_RAW_KEY_AGREEMENT(\p alg)
|
||
* is true).
|
||
* \param private_key Identifier of the private key to use. It must
|
||
* allow the usage #PSA_KEY_USAGE_DERIVE.
|
||
* \param[in] peer_key Public key of the peer. It must be
|
||
* in the same format that psa_import_key()
|
||
* accepts. The standard formats for public
|
||
* keys are documented in the documentation
|
||
* of psa_export_public_key().
|
||
* \param peer_key_length Size of \p peer_key in bytes.
|
||
* \param[out] output Buffer where the decrypted message is to
|
||
* be written.
|
||
* \param output_size Size of the \c output buffer in bytes.
|
||
* \param[out] output_length On success, the number of bytes
|
||
* that make up the returned output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p alg is not a key agreement algorithm
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p private_key is not compatible with \p alg,
|
||
* or \p peer_key is not valid for \p alg or not compatible with
|
||
* \p private_key.
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* \p output_size is too small
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \p alg is not a supported key agreement algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_raw_key_agreement(psa_algorithm_t alg,
|
||
mbedtls_svc_key_id_t private_key,
|
||
const uint8_t *peer_key,
|
||
size_t peer_key_length,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/**@}*/
|
||
|
||
/** \defgroup random Random generation
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* \brief Generate random bytes.
|
||
*
|
||
* \warning This function **can** fail! Callers MUST check the return status
|
||
* and MUST NOT use the content of the output buffer if the return
|
||
* status is not #PSA_SUCCESS.
|
||
*
|
||
* \note To generate a key, use psa_generate_key() instead.
|
||
*
|
||
* \param[out] output Output buffer for the generated data.
|
||
* \param output_size Number of bytes to generate and output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_generate_random(uint8_t *output,
|
||
size_t output_size);
|
||
|
||
/**
|
||
* \brief Generate a key or key pair.
|
||
*
|
||
* The key is generated randomly.
|
||
* Its location, usage policy, type and size are taken from \p attributes.
|
||
*
|
||
* Implementations must reject an attempt to generate a key of size 0.
|
||
*
|
||
* The following type-specific considerations apply:
|
||
* - For RSA keys (#PSA_KEY_TYPE_RSA_KEY_PAIR),
|
||
* the public exponent is 65537.
|
||
* The modulus is a product of two probabilistic primes
|
||
* between 2^{n-1} and 2^n where n is the bit size specified in the
|
||
* attributes.
|
||
*
|
||
* \param[in] attributes The attributes for the new key.
|
||
* \param[out] key On success, an identifier for the newly created
|
||
* key. For persistent keys, this is the key
|
||
* identifier defined in \p attributes.
|
||
* \c 0 on failure.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* If the key is persistent, the key material and the key's metadata
|
||
* have been saved to persistent storage.
|
||
* \retval #PSA_ERROR_ALREADY_EXISTS
|
||
* This is an attempt to create a persistent key, and there is
|
||
* already a persistent key with the given identifier.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_INSUFFICIENT_ENTROPY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INSUFFICIENT_STORAGE
|
||
* \retval #PSA_ERROR_DATA_INVALID
|
||
* \retval #PSA_ERROR_DATA_CORRUPT
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_generate_key(const psa_key_attributes_t *attributes,
|
||
mbedtls_svc_key_id_t *key);
|
||
|
||
/**@}*/
|
||
|
||
|
||
/** \defgroup pake Password-authenticated key exchange (PAKE)
|
||
* @{
|
||
*/
|
||
|
||
/** The type of the data strucure for PAKE cipher suites.
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice.
|
||
*/
|
||
typedef struct psa_pake_cipher_suite_s psa_pake_cipher_suite_t;
|
||
|
||
/** Retrieve the PAKE algorithm from a PAKE cipher suite.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] cipher_suite The cipher suite structure to query.
|
||
*
|
||
* \return The PAKE algorithm stored in the cipher suite structure.
|
||
*/
|
||
static psa_algorithm_t psa_pake_cs_get_algorithm(
|
||
const psa_pake_cipher_suite_t* cipher_suite
|
||
);
|
||
|
||
/** Declare the PAKE algorithm for the cipher suite.
|
||
*
|
||
* This function overwrites any PAKE algorithm
|
||
* previously set in \p cipher_suite.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] cipher_suite The cipher suite structure to write to.
|
||
* \param algorithm The PAKE algorithm to write.
|
||
* (`PSA_ALG_XXX` values of type ::psa_algorithm_t
|
||
* such that #PSA_ALG_IS_PAKE(\c alg) is true.)
|
||
* If this is 0, the PAKE algorithm in
|
||
* \p cipher_suite becomes unspecified.
|
||
*/
|
||
static void psa_pake_cs_set_algorithm(
|
||
psa_pake_cipher_suite_t* cipher_suite,
|
||
psa_algorithm_t algorithm
|
||
);
|
||
|
||
/** Retrieve the primitive from a PAKE cipher suite.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external linkage).
|
||
* This function may be provided as a function-like macro, but in this case it
|
||
* must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] cipher_suite The cipher suite structure to query.
|
||
*
|
||
* \return The primitive stored in the cipher suite structure.
|
||
*/
|
||
static psa_pake_primitive_t psa_pake_cs_get_primitive(
|
||
const psa_pake_cipher_suite_t* cipher_suite
|
||
);
|
||
|
||
/** Declare the primitive for a PAKE cipher suite.
|
||
*
|
||
* This function overwrites any primitive previously set in \p cipher_suite.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* \param[out] cipher_suite The cipher suite structure to write to.
|
||
* \param primitive The primitive to write. If this is 0, the
|
||
* primitive type in \p cipher_suite becomes
|
||
* unspecified.
|
||
*/
|
||
static void psa_pake_cs_set_primitive(
|
||
psa_pake_cipher_suite_t* cipher_suite,
|
||
psa_pake_primitive_t primitive
|
||
);
|
||
|
||
/** Retrieve the hash algorithm from a PAKE cipher suite.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate its argument exactly once.
|
||
*
|
||
* \param[in] cipher_suite The cipher suite structure to query.
|
||
*
|
||
* \return The hash algorithm stored in the cipher suite structure. The return
|
||
* value is 0 if the PAKE is not parametrised by a hash algorithm or if
|
||
* the hash algorithm is not set.
|
||
*/
|
||
static psa_algorithm_t psa_pake_cs_get_hash(
|
||
const psa_pake_cipher_suite_t* cipher_suite
|
||
);
|
||
|
||
/** Declare the hash algorithm for a PAKE cipher suite.
|
||
*
|
||
* This function overwrites any hash algorithm
|
||
* previously set in \p cipher_suite.
|
||
*
|
||
* This function may be declared as `static` (i.e. without external
|
||
* linkage). This function may be provided as a function-like macro,
|
||
* but in this case it must evaluate each of its arguments exactly once.
|
||
*
|
||
* Refer to the documentation of individual PAKE algorithm types (`PSA_ALG_XXX`
|
||
* values of type ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true)
|
||
* for more information.
|
||
*
|
||
* \param[out] cipher_suite The cipher suite structure to write to.
|
||
* \param hash The hash involved in the cipher suite.
|
||
* (`PSA_ALG_XXX` values of type ::psa_algorithm_t
|
||
* such that #PSA_ALG_IS_HASH(\c alg) is true.)
|
||
* If this is 0, the hash algorithm in
|
||
* \p cipher_suite becomes unspecified.
|
||
*/
|
||
static void psa_pake_cs_set_hash(
|
||
psa_pake_cipher_suite_t* cipher_suite,
|
||
psa_algorithm_t hash
|
||
);
|
||
|
||
/** The type of the state data structure for PAKE operations.
|
||
*
|
||
* Before calling any function on a PAKE operation object, the application
|
||
* must initialize it by any of the following means:
|
||
* - Set the structure to all-bits-zero, for example:
|
||
* \code
|
||
* psa_pake_operation_t operation;
|
||
* memset(&operation, 0, sizeof(operation));
|
||
* \endcode
|
||
* - Initialize the structure to logical zero values, for example:
|
||
* \code
|
||
* psa_pake_operation_t operation = {0};
|
||
* \endcode
|
||
* - Initialize the structure to the initializer #PSA_PAKE_OPERATION_INIT,
|
||
* for example:
|
||
* \code
|
||
* psa_pake_operation_t operation = PSA_PAKE_OPERATION_INIT;
|
||
* \endcode
|
||
* - Assign the result of the function psa_pake_operation_init()
|
||
* to the structure, for example:
|
||
* \code
|
||
* psa_pake_operation_t operation;
|
||
* operation = psa_pake_operation_init();
|
||
* \endcode
|
||
*
|
||
* This is an implementation-defined \c struct. Applications should not
|
||
* make any assumptions about the content of this structure.
|
||
* Implementation details can change in future versions without notice. */
|
||
typedef struct psa_pake_operation_s psa_pake_operation_t;
|
||
|
||
/** Return an initial value for an PAKE operation object.
|
||
*/
|
||
static psa_pake_operation_t psa_pake_operation_init(void);
|
||
|
||
/** Set the session information for a password-authenticated key exchange.
|
||
*
|
||
* The sequence of operations to set up a password-authenticated key exchange
|
||
* is as follows:
|
||
* -# Allocate an operation object which will be passed to all the functions
|
||
* listed here.
|
||
* -# Initialize the operation object with one of the methods described in the
|
||
* documentation for #psa_pake_operation_t, e.g.
|
||
* #PSA_PAKE_OPERATION_INIT.
|
||
* -# Call psa_pake_setup() to specify the cipher suite.
|
||
* -# Call \c psa_pake_set_xxx() functions on the operation to complete the
|
||
* setup. The exact sequence of \c psa_pake_set_xxx() functions that needs
|
||
* to be called depends on the algorithm in use.
|
||
*
|
||
* Refer to the documentation of individual PAKE algorithm types (`PSA_ALG_XXX`
|
||
* values of type ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true)
|
||
* for more information.
|
||
*
|
||
* A typical sequence of calls to perform a password-authenticated key
|
||
* exchange:
|
||
* -# Call psa_pake_output(operation, #PSA_PAKE_STEP_KEY_SHARE, ...) to get the
|
||
* key share that needs to be sent to the peer.
|
||
* -# Call psa_pake_input(operation, #PSA_PAKE_STEP_KEY_SHARE, ...) to provide
|
||
* the key share that was received from the peer.
|
||
* -# Depending on the algorithm additional calls to psa_pake_output() and
|
||
* psa_pake_input() might be necessary.
|
||
* -# Call psa_pake_get_implicit_key() for accessing the shared secret.
|
||
*
|
||
* Refer to the documentation of individual PAKE algorithm types (`PSA_ALG_XXX`
|
||
* values of type ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true)
|
||
* for more information.
|
||
*
|
||
* If an error occurs at any step after a call to psa_pake_setup(),
|
||
* the operation will need to be reset by a call to psa_pake_abort(). The
|
||
* application may call psa_pake_abort() at any time after the operation
|
||
* has been initialized.
|
||
*
|
||
* After a successful call to psa_pake_setup(), the application must
|
||
* eventually terminate the operation. The following events terminate an
|
||
* operation:
|
||
* - A call to psa_pake_abort().
|
||
* - A successful call to psa_pake_get_implicit_key().
|
||
*
|
||
* \param[in,out] operation The operation object to set up. It must have
|
||
* been initialized as per the documentation for
|
||
* #psa_pake_operation_t and not yet in use (no
|
||
* other function has been called on it since the
|
||
* last initialization).
|
||
* \param cipher_suite The cipher suite to use. (A cipher suite fully
|
||
* characterizes a PAKE algorithm and determines
|
||
* the algorithm as well.)
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* The \p cipher_suite is not supported or is not valid.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_setup(psa_pake_operation_t *operation,
|
||
psa_pake_cipher_suite_t cipher_suite);
|
||
|
||
/** Set the password for a password-authenticated key exchange from key ID.
|
||
*
|
||
* Call this function when the password, or a value derived from the password,
|
||
* is already present in the key store. To calculate the password-derived value
|
||
* from a password input, use the key derivation interface and
|
||
* psa_pake_set_password_stretch() instead.
|
||
*
|
||
* \param[in,out] operation The operation object to set the password for. It
|
||
* must have been set up by psa_pake_setup() and
|
||
* not yet in use (neither psa_pake_output() nor
|
||
* psa_pake_input() has been called yet). It must
|
||
* be on operation for which the password hasn't
|
||
* been set yet (neither
|
||
* psa_pake_set_password_mhf() nor
|
||
* psa_pake_set_password_key() has been called
|
||
* yet).
|
||
* \param password Identifier of the key holding the password or a
|
||
* value derived from the password (eg. by a
|
||
* memory-hard function). It must remain valid
|
||
* until the operation terminates. It must be of
|
||
* type #PSA_KEY_TYPE_PASSWORD or
|
||
* #PSA_KEY_TYPE_PASSWORD_HASH. It has to allow
|
||
* the usage #PSA_KEY_USAGE_DERIVE.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must have been set up.)
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p key is not compatible with the algorithm in \p cipher_suite.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_set_password_key(psa_pake_operation_t *operation,
|
||
mbedtls_svc_key_id_t password);
|
||
|
||
/** Set the password for a password-authenticated key exchange via a memory hard
|
||
* function.
|
||
*
|
||
* Some protocols require using values derived from passwords via memory hard
|
||
* functions to mitigate dictionary attacks. Memory hard functions can be
|
||
* accessed through the key derivation interface and the result can be supplied
|
||
* to the PAKE operation in the form of a key derivation object.
|
||
*
|
||
* This function draws bytes from a key derivation algorithm and sets those
|
||
* bytes as a password for the password-authenticated key exchange. If you
|
||
* view the key derivation's output as a stream of bytes, this function
|
||
* destructively reads the requested number of bytes from the stream.
|
||
* The key derivation operation's capacity decreases by the number of bytes read.
|
||
*
|
||
* If this function returns anything other than #PSA_SUCCESS, both \p operation
|
||
* and \p key_derivation operations enter an error state and must be aborted by
|
||
* calling psa_pake_abort() and psa_key_derivation_abort() respectively.
|
||
*
|
||
* \param[in,out] operation The operation object to set the password for.
|
||
* It must have been set up by psa_pake_setup()
|
||
* and not yet in use (neither psa_pake_output()
|
||
* nor psa_pake_input() has been called yet). It
|
||
* must be on operation for which the password
|
||
* hasn't been set yet (neither
|
||
* psa_pake_set_password_mhf() nor
|
||
* psa_pake_set_password_key() has been called
|
||
* yet).
|
||
* \param[in,out] key_derivation An ongoing key derivation operation set up
|
||
* from the password and in a state suitable for
|
||
* calling psa_key_derivation_output_bytes().
|
||
* \param input_length Number of bytes to input from the
|
||
* \p key_derivation operation.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The state of \p operation or \p key_derivation is not valid.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_DATA
|
||
* The \p key_derivation operation's capacity was less than
|
||
* \p input_length bytes.
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INVALID_HANDLE
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_NOT_PERMITTED
|
||
* One of the inputs to \p key_derivation was a key whose policy didn't
|
||
* allow #PSA_KEY_USAGE_DERIVE.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_set_password_mhf(psa_pake_operation_t *operation,
|
||
psa_key_derivation_operation_t *key_derivation,
|
||
size_t input_length);
|
||
|
||
/** Set the user ID for a password-authenticated key exchange.
|
||
*
|
||
* Some PAKE algorithms associate only a single user identifier with the
|
||
* session. Such algorithms must call this function (psa_pake_set_user()) to
|
||
* set the identifier for the PAKE context.
|
||
*
|
||
* Refer to the documentation of individual PAKE algorithm types (`PSA_ALG_XXX`
|
||
* values of type ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true)
|
||
* for more information.
|
||
*
|
||
* \param[in,out] operation The operation object to set the user ID for. It
|
||
* must have been set up by psa_pake_setup() and
|
||
* not yet in use (neither psa_pake_output() nor
|
||
* psa_pake_input() has been called yet). It must
|
||
* be on operation for which the user ID hasn't
|
||
* been set (psa_pake_set_user() hasn't been
|
||
* called yet).
|
||
* \param[in] user_id The user ID to authenticate with.
|
||
* \param user_id_len Size of the \p user_id buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p user_id is NULL.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_set_user(psa_pake_operation_t *operation,
|
||
const uint8_t *user_id,
|
||
size_t user_id_len);
|
||
|
||
/** Set the peer ID for a password-authenticated key exchange.
|
||
*
|
||
* Some PAKE algorithms associate only a single user identifier with the
|
||
* session. Such algorithms must call psa_pake_set_user() to set the
|
||
* identifier for the PAKE context.
|
||
*
|
||
* Refer to the documentation of individual PAKE algorithm types (`PSA_ALG_XXX`
|
||
* values of type ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true)
|
||
* for more information.
|
||
*
|
||
* \param[in,out] operation The operation object to set the peer ID for. It
|
||
* must have been set up by psa_pake_setup() and
|
||
* not yet in use (neither psa_pake_output() nor
|
||
* psa_pake_input() has been called yet). It must
|
||
* be on operation for which the peer ID hasn't
|
||
* been set (psa_pake_set_peer() hasn't been
|
||
* called yet).
|
||
* \param[in] peer_id The peer's ID to authenticate.
|
||
* \param peer_id_len Size of the \p peer_id buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* The algorithm doesn't associate a second identity with the session.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* \p user_id is NULL.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_set_peer(psa_pake_operation_t *operation,
|
||
const uint8_t *peer_id,
|
||
size_t peer_id_len);
|
||
|
||
/** Set the side for a password-authenticated key exchange.
|
||
*
|
||
* Not all PAKE algorithms need to differentiate the communicating entities.
|
||
* It is optional to call this function for PAKEs that don't require a side
|
||
* parameter. For such PAKEs the side parameter is ignored.
|
||
*
|
||
* Refer to the documentation of individual PAKE algorithm types (`PSA_ALG_XXX`
|
||
* values of type ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true)
|
||
* for more information.
|
||
*
|
||
* \param[in,out] operation The operation object to set the side for. It
|
||
* must have been set up by psa_pake_setup() and
|
||
* not yet in use (neither psa_pake_output() nor
|
||
* psa_pake_input() has been called yet). It must
|
||
* be on operation for which the side hasn't been
|
||
* set (psa_pake_set_side() hasn't been called
|
||
* yet).
|
||
* \param side A value of type ::psa_pake_side_t signaling the
|
||
* side of the algorithm that is being set up. For
|
||
* more information see the documentation of \c
|
||
* PSA_PAKE_SIDE_XXX constants.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid.
|
||
* \retval #PSA_ERROR_NOT_SUPPORTED
|
||
* The \p side for this algorithm is not supported or is not valid.
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_set_side(psa_pake_operation_t *operation,
|
||
psa_pake_side_t side);
|
||
|
||
/** Get output for a step of a password-authenticated key exchange.
|
||
*
|
||
* Depending on the algorithm being executed, you might need to call this
|
||
* function several times or you might not need to call this at all.
|
||
*
|
||
* The exact sequence of calls to perform a password-authenticated key
|
||
* exchange depends on the algorithm in use. Refer to the documentation of
|
||
* individual PAKE algorithm types (`PSA_ALG_XXX` values of type
|
||
* ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true) for more
|
||
* information.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_pake_abort().
|
||
*
|
||
* \param[in,out] operation Active PAKE operation.
|
||
* \param step The step of the algorithm for which the output is
|
||
* requested.
|
||
* \param[out] output Buffer where the output is to be written.
|
||
* \param output_size Size of the \p output buffer in bytes. This must
|
||
* be at least #PSA_PAKE_OUTPUT_SIZE(\p alg, \c
|
||
* cipher_suite, \p type).
|
||
*
|
||
* \param[out] output_length On success, the number of bytes of the returned
|
||
* output.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, but beyond that
|
||
* validity is specific to the algorithm).
|
||
* \retval #PSA_ERROR_BUFFER_TOO_SMALL
|
||
* The size of the \p output buffer is too small.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_output(psa_pake_operation_t *operation,
|
||
psa_pake_step_t step,
|
||
uint8_t *output,
|
||
size_t output_size,
|
||
size_t *output_length);
|
||
|
||
/** Provide input for a step of a password-authenticated key exchange.
|
||
*
|
||
* Depending on the algorithm being executed, you might need to call this
|
||
* function several times or you might not need to call this at all.
|
||
*
|
||
* The exact sequence of calls to perform a password-authenticated key
|
||
* exchange depends on the algorithm in use. Refer to the documentation of
|
||
* individual PAKE algorithm types (`PSA_ALG_XXX` values of type
|
||
* ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true) for more
|
||
* information.
|
||
*
|
||
* If this function returns an error status, the operation enters an error
|
||
* state and must be aborted by calling psa_pake_abort().
|
||
*
|
||
* \param[in,out] operation Active PAKE operation.
|
||
* \param step The step for which the input is provided.
|
||
* \param[out] input Buffer containing the input.
|
||
* \param[out] input_length Size of the \p input buffer in bytes.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, but beyond that
|
||
* validity is specific to the algorithm).
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_input(psa_pake_operation_t *operation,
|
||
psa_pake_step_t step,
|
||
uint8_t *input,
|
||
size_t input_length);
|
||
|
||
/** Get implicitly confirmed shared secret from a PAKE.
|
||
*
|
||
* This function can be called after the key exchange phase of the operation
|
||
* has completed. It imports the shared secret output of the PAKE into the
|
||
* provided derivation operation. The input step
|
||
* #PSA_KEY_DERIVATION_INPUT_SECRET is used when placing the shared key
|
||
* material in the key derivation operation.
|
||
*
|
||
* The exact sequence of calls to perform a password-authenticated key
|
||
* exchange depends on the algorithm in use. Refer to the documentation of
|
||
* individual PAKE algorithm types (`PSA_ALG_XXX` values of type
|
||
* ::psa_algorithm_t such that #PSA_ALG_IS_PAKE(\c alg) is true) for more
|
||
* information.
|
||
*
|
||
* When this function returns successfully, \p operation becomes inactive.
|
||
* If this function returns an error status, both \p operation
|
||
* and \p key_derivation operations enter an error state and must be aborted by
|
||
* calling psa_pake_abort() and psa_key_derivation_abort() respectively.
|
||
*
|
||
* \param[in,out] operation Active PAKE operation.
|
||
* \param[out] output A key derivation operation that is ready
|
||
* for an input step of type
|
||
* #PSA_KEY_DERIVATION_INPUT_SECRET.
|
||
*
|
||
* \retval #PSA_SUCCESS
|
||
* Success.
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The operation state is not valid (it must be active, but beyond that
|
||
* validity is specific to the algorithm).
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The state of \p output is not valid for
|
||
* the #PSA_KEY_DERIVATION_INPUT_SECRET step. This can happen if the
|
||
* step is out of order or the application has done this step already
|
||
* and it may not be repeated.
|
||
* \retval #PSA_ERROR_INVALID_ARGUMENT
|
||
* #PSA_KEY_DERIVATION_INPUT_SECRET is not compatible with the output’s
|
||
* algorithm.
|
||
* \retval #PSA_ERROR_INSUFFICIENT_MEMORY
|
||
* \retval #PSA_ERROR_COMMUNICATION_FAILURE
|
||
* \retval #PSA_ERROR_HARDWARE_FAILURE
|
||
* \retval #PSA_ERROR_CORRUPTION_DETECTED
|
||
* \retval #PSA_ERROR_STORAGE_FAILURE
|
||
* \retval #PSA_ERROR_BAD_STATE
|
||
* The library has not been previously initialized by psa_crypto_init().
|
||
* It is implementation-dependent whether a failure to initialize
|
||
* results in this error code.
|
||
*/
|
||
psa_status_t psa_pake_get_implicit_key(psa_pake_operation_t *operation,
|
||
psa_key_derivation_operation_t *output);
|
||
/**@}*/
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
/* The file "crypto_sizes.h" contains definitions for size calculation
|
||
* macros whose definitions are implementation-specific. */
|
||
#include "crypto_sizes.h"
|
||
|
||
/* The file "crypto_struct.h" contains definitions for
|
||
* implementation-specific structs that are declared above. */
|
||
#include "crypto_struct.h"
|
||
|
||
/* The file "crypto_extra.h" contains vendor-specific definitions. This
|
||
* can include vendor-defined algorithms, extra functions, etc. */
|
||
#include "crypto_extra.h"
|
||
|
||
#endif /* PSA_CRYPTO_H */
|