edhoc 1.4.0 → 2.0.0

package/external/libedhoc/externals/mbedtls/3rdparty/p256-m/p256-m/p256-m.h

@@ -1,135 +0,0 @@
-/*
- * Interface of curve P-256 (ECDH and ECDSA)
- *
- * Copyright The Mbed TLS Contributors
- * Author: Manuel Pégourié-Gonnard.
- * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-#ifndef P256_M_H
-#define P256_M_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-/* Status codes */
-#define P256_SUCCESS            0
-#define P256_RANDOM_FAILED      -1
-#define P256_INVALID_PUBKEY     -2
-#define P256_INVALID_PRIVKEY    -3
-#define P256_INVALID_SIGNATURE  -4
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * RNG function - must be provided externally and be cryptographically secure.
- *
- * in: output - must point to a writable buffer of at least output_size bytes.
- *     output_size - the number of random bytes to write to output.
- * out: output is filled with output_size random bytes.
- *      return 0 on success, non-zero on errors.
- */
-extern int p256_generate_random(uint8_t * output, unsigned output_size);
-
-/*
- * ECDH/ECDSA generate key pair
- *
- * [in] draws from p256_generate_random()
- * [out] priv: on success, holds the private key, as a big-endian integer
- * [out] pub: on success, holds the public key, as two big-endian integers
- *
- * return:  P256_SUCCESS on success
- *          P256_RANDOM_FAILED on failure
- */
-int p256_gen_keypair(uint8_t priv[32], uint8_t pub[64]);
-
-/*
- * ECDH compute shared secret
- *
- * [out] secret: on success, holds the shared secret, as a big-endian integer
- * [in] priv: our private key as a big-endian integer
- * [in] pub: the peer's public key, as two big-endian integers
- *
- * return:  P256_SUCCESS on success
- *          P256_INVALID_PRIVKEY if priv is invalid
- *          P256_INVALID_PUBKEY if pub is invalid
- */
-int p256_ecdh_shared_secret(uint8_t secret[32],
-                            const uint8_t priv[32], const uint8_t pub[64]);
-
-/*
- * ECDSA sign
- *
- * [in] draws from p256_generate_random()
- * [out] sig: on success, holds the signature, as two big-endian integers
- * [in] priv: our private key as a big-endian integer
- * [in] hash: the hash of the message to be signed
- * [in] hlen: the size of hash in bytes
- *
- * return:  P256_SUCCESS on success
- *          P256_RANDOM_FAILED on failure
- *          P256_INVALID_PRIVKEY if priv is invalid
- */
-int p256_ecdsa_sign(uint8_t sig[64], const uint8_t priv[32],
-                    const uint8_t *hash, size_t hlen);
-
-/*
- * ECDSA verify
- *
- * [in] sig: the signature to be verified, as two big-endian integers
- * [in] pub: the associated public key, as two big-endian integers
- * [in] hash: the hash of the message that was signed
- * [in] hlen: the size of hash in bytes
- *
- * return:  P256_SUCCESS on success - the signature was verified as valid
- *          P256_INVALID_PUBKEY if pub is invalid
- *          P256_INVALID_SIGNATURE if the signature was found to be invalid
- */
-int p256_ecdsa_verify(const uint8_t sig[64], const uint8_t pub[64],
-                      const uint8_t *hash, size_t hlen);
-
-/*
- * Public key validation
- *
- * Note: you never need to call this function, as all other functions always
- * validate their input; however it's availabe if you want to validate the key
- * without performing an operation.
- *
- * [in] pub: the public key, as two big-endian integers
- *
- * return:  P256_SUCCESS if the key is valid
- *          P256_INVALID_PUBKEY if pub is invalid
- */
-int p256_validate_pubkey(const uint8_t pub[64]);
-
-/*
- * Private key validation
- *
- * Note: you never need to call this function, as all other functions always
- * validate their input; however it's availabe if you want to validate the key
- * without performing an operation.
- *
- * [in] priv: the private key, as a big-endian integer
- *
- * return:  P256_SUCCESS if the key is valid
- *          P256_INVALID_PRIVKEY if priv is invalid
- */
-int p256_validate_privkey(const uint8_t priv[32]);
-
-/*
- * Compute public key from private key
- *
- * [out] pub: the associated public key, as two big-endian integers
- * [in] priv: the private key, as a big-endian integer
- *
- * return:  P256_SUCCESS on success
- *          P256_INVALID_PRIVKEY if priv is invalid
- */
-int p256_public_from_private(uint8_t pub[64], const uint8_t priv[32]);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* P256_M_H */

package/external/libedhoc/externals/mbedtls/3rdparty/p256-m/p256-m_driver_entrypoints.c

@@ -1,312 +0,0 @@
-/*
- *  Driver entry points for p256-m
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-#include "mbedtls/platform.h"
-#include "p256-m_driver_entrypoints.h"
-#include "p256-m/p256-m.h"
-#include "psa/crypto.h"
-#include <stddef.h>
-#include <string.h>
-#include "psa_crypto_driver_wrappers_no_static.h"
-
-#if defined(MBEDTLS_PSA_P256M_DRIVER_ENABLED)
-
-/* INFORMATION ON PSA KEY EXPORT FORMATS:
- *
- * PSA exports SECP256R1 keys in two formats:
- * 1. Keypair format: 32 byte string which is just the private key (public key
- *                    can be calculated from the private key)
- * 2. Public Key format: A leading byte 0x04 (indicating uncompressed format),
- *                       followed by the 64 byte public key. This results in a
- *                       total of 65 bytes.
- *
- * p256-m's internal format for private keys matches PSA. Its format for public
- * keys is only 64 bytes: the same as PSA but without the leading byte (0x04).
- * Hence, when passing public keys from PSA to p256-m, the leading byte is
- * removed.
- *
- * Shared secret and signature have the same format between PSA and p256-m.
- */
-#define PSA_PUBKEY_SIZE         65
-#define PSA_PUBKEY_HEADER_BYTE  0x04
-#define P256_PUBKEY_SIZE        64
-#define PRIVKEY_SIZE            32
-#define SHARED_SECRET_SIZE      32
-#define SIGNATURE_SIZE          64
-
-#define CURVE_BITS              256
-
-/* Convert between p256-m and PSA error codes */
-static psa_status_t p256_to_psa_error(int ret)
-{
-    switch (ret) {
-        case P256_SUCCESS:
-            return PSA_SUCCESS;
-        case P256_INVALID_PUBKEY:
-        case P256_INVALID_PRIVKEY:
-            return PSA_ERROR_INVALID_ARGUMENT;
-        case P256_INVALID_SIGNATURE:
-            return PSA_ERROR_INVALID_SIGNATURE;
-        case P256_RANDOM_FAILED:
-        default:
-            return PSA_ERROR_GENERIC_ERROR;
-    }
-}
-
-psa_status_t p256_transparent_import_key(const psa_key_attributes_t *attributes,
-                             const uint8_t *data,
-                             size_t data_length,
-                             uint8_t *key_buffer,
-                             size_t key_buffer_size,
-                             size_t *key_buffer_length,
-                             size_t *bits)
-{
-    /* Check the key size */
-    if (*bits != 0 && *bits != CURVE_BITS) {
-        return PSA_ERROR_NOT_SUPPORTED;
-    }
-
-    /* Validate the key (and its type and size) */
-    psa_key_type_t type = psa_get_key_type(attributes);
-    if (type == PSA_KEY_TYPE_ECC_PUBLIC_KEY(PSA_ECC_FAMILY_SECP_R1)) {
-        if (data_length != PSA_PUBKEY_SIZE) {
-            return *bits == 0 ? PSA_ERROR_NOT_SUPPORTED : PSA_ERROR_INVALID_ARGUMENT;
-        }
-        /* See INFORMATION ON PSA KEY EXPORT FORMATS near top of file */
-        if (p256_validate_pubkey(data + 1) != P256_SUCCESS) {
-            return PSA_ERROR_INVALID_ARGUMENT;
-        }
-    } else if (type == PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1)) {
-        if (data_length != PRIVKEY_SIZE) {
-            return *bits == 0 ? PSA_ERROR_NOT_SUPPORTED : PSA_ERROR_INVALID_ARGUMENT;
-        }
-        if (p256_validate_privkey(data) != P256_SUCCESS) {
-            return PSA_ERROR_INVALID_ARGUMENT;
-        }
-    } else {
-        return PSA_ERROR_NOT_SUPPORTED;
-    }
-    *bits = CURVE_BITS;
-
-    /* We only support the export format for input, so just copy. */
-    if (key_buffer_size < data_length) {
-        return PSA_ERROR_BUFFER_TOO_SMALL;
-    }
-    memcpy(key_buffer, data, data_length);
-    *key_buffer_length = data_length;
-
-    return PSA_SUCCESS;
-}
-
-psa_status_t p256_transparent_export_public_key(const psa_key_attributes_t *attributes,
-                                    const uint8_t *key_buffer,
-                                    size_t key_buffer_size,
-                                    uint8_t *data,
-                                    size_t data_size,
-                                    size_t *data_length)
-{
-    /* Is this the right curve? */
-    size_t bits = psa_get_key_bits(attributes);
-    psa_key_type_t type = psa_get_key_type(attributes);
-    if (bits != CURVE_BITS || type != PSA_KEY_TYPE_ECC_KEY_PAIR(PSA_ECC_FAMILY_SECP_R1)) {
-        return PSA_ERROR_NOT_SUPPORTED;
-    }
-
-    /* Validate sizes, as p256-m expects fixed-size buffers */
-    if (key_buffer_size != PRIVKEY_SIZE) {
-        return PSA_ERROR_INVALID_ARGUMENT;
-    }
-    if (data_size < PSA_PUBKEY_SIZE) {
-        return PSA_ERROR_BUFFER_TOO_SMALL;
-    }
-
-    /* See INFORMATION ON PSA KEY EXPORT FORMATS near top of file */
-    data[0] = PSA_PUBKEY_HEADER_BYTE;
-    int ret = p256_public_from_private(data + 1, key_buffer);
-    if (ret == P256_SUCCESS) {
-        *data_length = PSA_PUBKEY_SIZE;
-    }
-
-    return p256_to_psa_error(ret);
-}
-
-psa_status_t p256_transparent_generate_key(
-    const psa_key_attributes_t *attributes,
-    uint8_t *key_buffer,
-    size_t key_buffer_size,
-    size_t *key_buffer_length)
-{
-    /* We don't use this argument, but the specification mandates the signature
-     * of driver entry-points. (void) used to avoid compiler warning. */
-    (void) attributes;
-
-    /* Validate sizes, as p256-m expects fixed-size buffers */
-    if (key_buffer_size != PRIVKEY_SIZE) {
-        return PSA_ERROR_BUFFER_TOO_SMALL;
-    }
-
-    /*
-     *  p256-m's keypair generation function outputs both public and private
-     *  keys. Allocate a buffer to which the public key will be written. The
-     *  private key will be written to key_buffer, which is passed to this
-     *  function as an argument. */
-    uint8_t public_key_buffer[P256_PUBKEY_SIZE];
-
-    int ret = p256_gen_keypair(key_buffer, public_key_buffer);
-    if (ret == P256_SUCCESS) {
-        *key_buffer_length = PRIVKEY_SIZE;
-    }
-
-    return p256_to_psa_error(ret);
-}
-
-psa_status_t p256_transparent_key_agreement(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    psa_algorithm_t alg,
-    const uint8_t *peer_key,
-    size_t peer_key_length,
-    uint8_t *shared_secret,
-    size_t shared_secret_size,
-    size_t *shared_secret_length)
-{
-    /* We don't use these arguments, but the specification mandates the
-     * sginature of driver entry-points. (void) used to avoid compiler
-     * warning. */
-    (void) attributes;
-    (void) alg;
-
-    /* Validate sizes, as p256-m expects fixed-size buffers */
-    if (key_buffer_size != PRIVKEY_SIZE || peer_key_length != PSA_PUBKEY_SIZE) {
-        return PSA_ERROR_INVALID_ARGUMENT;
-    }
-    if (shared_secret_size < SHARED_SECRET_SIZE) {
-        return PSA_ERROR_BUFFER_TOO_SMALL;
-    }
-
-    /* See INFORMATION ON PSA KEY EXPORT FORMATS near top of file */
-    const uint8_t *peer_key_p256m = peer_key + 1;
-    int ret = p256_ecdh_shared_secret(shared_secret, key_buffer, peer_key_p256m);
-    if (ret == P256_SUCCESS) {
-        *shared_secret_length = SHARED_SECRET_SIZE;
-    }
-
-    return p256_to_psa_error(ret);
-}
-
-psa_status_t p256_transparent_sign_hash(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    psa_algorithm_t alg,
-    const uint8_t *hash,
-    size_t hash_length,
-    uint8_t *signature,
-    size_t signature_size,
-    size_t *signature_length)
-{
-    /* We don't use these arguments, but the specification mandates the
-     * sginature of driver entry-points. (void) used to avoid compiler
-     * warning. */
-    (void) attributes;
-    (void) alg;
-
-    /* Validate sizes, as p256-m expects fixed-size buffers */
-    if (key_buffer_size != PRIVKEY_SIZE) {
-        return PSA_ERROR_INVALID_ARGUMENT;
-    }
-    if (signature_size < SIGNATURE_SIZE) {
-        return PSA_ERROR_BUFFER_TOO_SMALL;
-    }
-
-    int ret = p256_ecdsa_sign(signature, key_buffer, hash, hash_length);
-    if (ret == P256_SUCCESS) {
-        *signature_length = SIGNATURE_SIZE;
-    }
-
-    return p256_to_psa_error(ret);
-}
-
-/*  This function expects the key buffer to contain a PSA public key,
- *  as exported by psa_export_public_key() */
-static psa_status_t p256_verify_hash_with_public_key(
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    const uint8_t *hash,
-    size_t hash_length,
-    const uint8_t *signature,
-    size_t signature_length)
-{
-    /* Validate sizes, as p256-m expects fixed-size buffers */
-    if (key_buffer_size != PSA_PUBKEY_SIZE || *key_buffer != PSA_PUBKEY_HEADER_BYTE) {
-        return PSA_ERROR_INVALID_ARGUMENT;
-    }
-    if (signature_length != SIGNATURE_SIZE) {
-        return PSA_ERROR_INVALID_SIGNATURE;
-    }
-
-    /* See INFORMATION ON PSA KEY EXPORT FORMATS near top of file */
-    const uint8_t *public_key_p256m = key_buffer + 1;
-    int ret = p256_ecdsa_verify(signature, public_key_p256m, hash, hash_length);
-
-    return p256_to_psa_error(ret);
-}
-
-psa_status_t p256_transparent_verify_hash(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    psa_algorithm_t alg,
-    const uint8_t *hash,
-    size_t hash_length,
-    const uint8_t *signature,
-    size_t signature_length)
-{
-    /* We don't use this argument, but the specification mandates the signature
-     * of driver entry-points. (void) used to avoid compiler warning. */
-    (void) alg;
-
-    psa_status_t status;
-    uint8_t public_key_buffer[PSA_PUBKEY_SIZE];
-    size_t public_key_buffer_size = PSA_PUBKEY_SIZE;
-
-    size_t public_key_length = PSA_PUBKEY_SIZE;
-    /* As p256-m doesn't require dynamic allocation, we want to avoid it in
-     * the entrypoint functions as well. psa_driver_wrapper_export_public_key()
-     * requires size_t*, so we use a pointer to a stack variable. */
-    size_t *public_key_length_ptr = &public_key_length;
-
-    /* The contents of key_buffer may either be the 32 byte private key
-     * (keypair format), or 0x04 followed by the 64 byte public key (public
-     * key format). To ensure the key is in the latter format, the public key
-     * is exported. */
-    status = psa_driver_wrapper_export_public_key(
-        attributes,
-        key_buffer,
-        key_buffer_size,
-        public_key_buffer,
-        public_key_buffer_size,
-        public_key_length_ptr);
-    if (status != PSA_SUCCESS) {
-        goto exit;
-    }
-
-    status = p256_verify_hash_with_public_key(
-        public_key_buffer,
-        public_key_buffer_size,
-        hash,
-        hash_length,
-        signature,
-        signature_length);
-
-exit:
-    return status;
-}
-
-#endif /* MBEDTLS_PSA_P256M_DRIVER_ENABLED */

package/external/libedhoc/externals/mbedtls/3rdparty/p256-m/p256-m_driver_entrypoints.h

@@ -1,219 +0,0 @@
-/*
- *   Driver entry points for p256-m
- */
-/*
- *  Copyright The Mbed TLS Contributors
- *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
- */
-
-#ifndef P256M_DRIVER_ENTRYPOINTS_H
-#define P256M_DRIVER_ENTRYPOINTS_H
-
-#if defined(MBEDTLS_PSA_P256M_DRIVER_ENABLED)
-#ifndef PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT
-#define PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT
-#endif /* PSA_CRYPTO_ACCELERATOR_DRIVER_PRESENT */
-#endif /* MBEDTLS_PSA_P256M_DRIVER_ENABLED */
-
-#include "psa/crypto_types.h"
-
-/** Import SECP256R1 key.
- *
- * \param[in]  attributes           The attributes of the key to use for the
- *                                  operation.
- * \param[in]  data                 The raw key material. For private keys
- *                                  this must be a big-endian integer of 32
- *                                  bytes; for public key this must be an
- *                                  uncompressed ECPoint (65 bytes).
- * \param[in]  data_length          The size of the raw key material.
- * \param[out] key_buffer           The buffer to contain the key data in
- *                                  output format upon successful return.
- * \param[in]  key_buffer_size      Size of the \p key_buffer buffer in bytes.
- * \param[out] key_buffer_length    The length of the data written in \p
- *                                  key_buffer in bytes.
- * \param[out] bits                 The bitsize of the key.
- *
- * \retval  #PSA_SUCCESS
- *          Success. Keypair generated and stored in buffer.
- * \retval  #PSA_ERROR_NOT_SUPPORTED
- *          The input is not supported by this driver (not SECP256R1).
- * \retval  #PSA_ERROR_INVALID_ARGUMENT
- *          The input is invalid.
- * \retval  #PSA_ERROR_BUFFER_TOO_SMALL
- *          \p key_buffer_size is too small.
- */
-psa_status_t p256_transparent_import_key(const psa_key_attributes_t *attributes,
-                             const uint8_t *data,
-                             size_t data_length,
-                             uint8_t *key_buffer,
-                             size_t key_buffer_size,
-                             size_t *key_buffer_length,
-                             size_t *bits);
-
-/** Export SECP256R1 public key, from the private key.
- *
- * \param[in]  attributes           The attributes of the key to use for the
- *                                  operation.
- * \param[in]  key_buffer           The private key in the export format.
- * \param[in]  key_buffer_size      The size of the private key in bytes.
- * \param[out] data                 The buffer to contain the public key in
- *                                  the export format upon successful return.
- * \param[in]  data_size            The size of the \p data buffer in bytes.
- * \param[out] data_length          The length written to \p data in bytes.
- *
- * \retval  #PSA_SUCCESS
- *          Success. Keypair generated and stored in buffer.
- * \retval  #PSA_ERROR_NOT_SUPPORTED
- *          The input is not supported by this driver (not SECP256R1).
- * \retval  #PSA_ERROR_INVALID_ARGUMENT
- *          The input is invalid.
- * \retval  #PSA_ERROR_BUFFER_TOO_SMALL
- *          \p key_buffer_size is too small.
- */
-psa_status_t p256_transparent_export_public_key(const psa_key_attributes_t *attributes,
-                                    const uint8_t *key_buffer,
-                                    size_t key_buffer_size,
-                                    uint8_t *data,
-                                    size_t data_size,
-                                    size_t *data_length);
-
-/** Generate SECP256R1 ECC Key Pair.
- *  Interface function which calls the p256-m key generation function and
- *  places it in the key buffer provided by the caller (Mbed TLS) in the
- *  correct format. For a SECP256R1 curve this is the 32 bit private key.
- *
- * \param[in]  attributes           The attributes of the key to use for the
- *                                  operation.
- * \param[out]  key_buffer          The buffer to contain the key data in
- *                                  output format upon successful return.
- * \param[in]   key_buffer_size     Size of the \p key_buffer buffer in bytes.
- * \param[out]  key_buffer_length   The length of the data written in \p
- *                                  key_buffer in bytes.
- *
- * \retval  #PSA_SUCCESS
- *          Success. Keypair generated and stored in buffer.
- * \retval  #PSA_ERROR_BUFFER_TOO_SMALL
- *          \p key_buffer_size is too small.
- * \retval  #PSA_ERROR_GENERIC_ERROR
- *          The internal RNG failed.
- */
-psa_status_t p256_transparent_generate_key(
-    const psa_key_attributes_t *attributes,
-    uint8_t *key_buffer,
-    size_t key_buffer_size,
-    size_t *key_buffer_length);
-
-/** Perform raw key agreement using p256-m's ECDH implementation
- * \param[in]  attributes           The attributes of the key to use for the
- *                                  operation.
- * \param[in]  key_buffer           The buffer containing the private key
- *                                  in the format specified by PSA.
- * \param[in]  key_buffer_size      Size of the \p key_buffer buffer in bytes.
- * \param[in]  alg                  A key agreement algorithm that is
- *                                  compatible with the type of the key.
- * \param[in]  peer_key             The buffer containing the peer's public
- *                                  key in format specified by PSA.
- * \param[in]  peer_key_length      Size of the \p peer_key buffer in
- *                                  bytes.
- * \param[out] shared_secret        The buffer to which the shared secret
- *                                  is to be written.
- * \param[in]  shared_secret_size   Size of the \p shared_secret buffer in
- *                                  bytes.
- * \param[out] shared_secret_length On success, the number of bytes that
- *                                  make up the returned shared secret.
- * \retval  #PSA_SUCCESS
- *          Success. Shared secret successfully calculated.
- * \retval  #PSA_ERROR_INVALID_ARGUMENT
- *          The input is invalid.
- * \retval  #PSA_ERROR_BUFFER_TOO_SMALL
- *          \p shared_secret_size is too small.
- */
-psa_status_t p256_transparent_key_agreement(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    psa_algorithm_t alg,
-    const uint8_t *peer_key,
-    size_t peer_key_length,
-    uint8_t *shared_secret,
-    size_t shared_secret_size,
-    size_t *shared_secret_length);
-
-/** Sign an already-calculated hash with a private key using p256-m's ECDSA
- *  implementation
- * \param[in]  attributes           The attributes of the key to use for the
- *                                  operation.
- * \param[in]  key_buffer           The buffer containing the private key
- *                                  in the format specified by PSA.
- * \param[in]  key_buffer_size      Size of the \p key_buffer buffer in bytes.
- * \param[in]  alg                  A signature algorithm that is compatible
- *                                  with the type of the key.
- * \param[in]  hash                 The hash to sign.
- * \param[in]  hash_length          Size of the \p hash buffer in bytes.
- * \param[out] signature            Buffer where signature is to be written.
- * \param[in]  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
- *          Success. Hash was signed successfully.
- * \retval  #PSA_ERROR_INVALID_ARGUMENT
- *          The input is invalid.
- * \retval  #PSA_ERROR_BUFFER_TOO_SMALL
- *          \p signature_size is too small.
- * \retval  #PSA_ERROR_GENERIC_ERROR
- *          The internal RNG failed.
- */
-psa_status_t p256_transparent_sign_hash(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    psa_algorithm_t alg,
-    const uint8_t *hash,
-    size_t hash_length,
-    uint8_t *signature,
-    size_t signature_size,
-    size_t *signature_length);
-
-/** Verify the signature of a hash using a SECP256R1 public key using p256-m's
- *  ECDSA implementation.
- *
- * \note p256-m expects a 64 byte public key, but the contents of the key
-         buffer may be the 32 byte keypair representation or the 65 byte
-         public key representation. As a result, this function calls
-         psa_driver_wrapper_export_public_key() to ensure the public key
-         can be passed to p256-m.
- *
- * \param[in]  attributes       The attributes of the key to use for the
- *                              operation.
- *
- * \param[in]  key_buffer       The buffer containing the key
- *                              in the format specified by PSA.
- * \param[in]  key_buffer_size  Size of the \p key_buffer buffer in bytes.
- * \param[in]  alg              A signature algorithm that is compatible with
- *                              the type of the key.
- * \param[in]  hash             The hash whose signature is to be
- *                              verified.
- * \param[in]  hash_length      Size of the \p hash buffer in bytes.
- * \param[in]  signature        Buffer containing the signature to verify.
- * \param[in]  signature_length Size of the \p signature buffer in bytes.
- *
- * \retval  #PSA_SUCCESS
- *          The signature is valid.
- * \retval  #PSA_ERROR_INVALID_SIGNATURE
- *          The calculation was performed successfully, but the passed
- *          signature is not a valid signature.
- * \retval  #PSA_ERROR_INVALID_ARGUMENT
- *          The input is invalid.
- */
-psa_status_t p256_transparent_verify_hash(
-    const psa_key_attributes_t *attributes,
-    const uint8_t *key_buffer,
-    size_t key_buffer_size,
-    psa_algorithm_t alg,
-    const uint8_t *hash,
-    size_t hash_length,
-    const uint8_t *signature,
-    size_t signature_length);
-
-#endif /* P256M_DRIVER_ENTRYPOINTS_H */