include/mbedtls/psa_util.h

/**
 * \file psa_util.h
 *
 * \brief Utility functions for the use of the PSA Crypto library.
 *
 * \warning This function is not part of the public API and may
 *          change at any time.
 */
/*
 *  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 MBEDTLS_PSA_UTIL_H
#define MBEDTLS_PSA_UTIL_H
#include "mbedtls/private_access.h"

#include "mbedtls/build_info.h"

#if defined(MBEDTLS_USE_PSA_CRYPTO)

#    include "psa/crypto.h"

#    include "mbedtls/ecp.h"
#    include "mbedtls/md.h"
#    include "mbedtls/pk.h"
#    include "mbedtls/oid.h"
#    include "mbedtls/error.h"

#    include <string.h>

/* Translations for symmetric crypto. */

static inline psa_key_type_t
mbedtls_psa_translate_cipher_type(mbedtls_cipher_type_t cipher)
{
    switch (cipher) {
        case MBEDTLS_CIPHER_AES_128_CCM:
        case MBEDTLS_CIPHER_AES_192_CCM:
        case MBEDTLS_CIPHER_AES_256_CCM:
        case MBEDTLS_CIPHER_AES_128_GCM:
        case MBEDTLS_CIPHER_AES_192_GCM:
        case MBEDTLS_CIPHER_AES_256_GCM:
        case MBEDTLS_CIPHER_AES_128_CBC:
        case MBEDTLS_CIPHER_AES_192_CBC:
        case MBEDTLS_CIPHER_AES_256_CBC:
            return PSA_KEY_TYPE_AES;

            /* ARIA not yet supported in PSA. */
            /* case MBEDTLS_CIPHER_ARIA_128_CCM:
               case MBEDTLS_CIPHER_ARIA_192_CCM:
               case MBEDTLS_CIPHER_ARIA_256_CCM:
               case MBEDTLS_CIPHER_ARIA_128_GCM:
               case MBEDTLS_CIPHER_ARIA_192_GCM:
               case MBEDTLS_CIPHER_ARIA_256_GCM:
               case MBEDTLS_CIPHER_ARIA_128_CBC:
               case MBEDTLS_CIPHER_ARIA_192_CBC:
               case MBEDTLS_CIPHER_ARIA_256_CBC:
                   return PSA_KEY_TYPE_ARIA ; */

        default:
            return 0;
    }
}

static inline psa_algorithm_t
mbedtls_psa_translate_cipher_mode(mbedtls_cipher_mode_t mode, size_t taglen)
{
    switch (mode) {
        case MBEDTLS_MODE_ECB:
            return PSA_ALG_ECB_NO_PADDING;
        case MBEDTLS_MODE_GCM:
            return PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, taglen);
        case MBEDTLS_MODE_CCM:
            return PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CCM, taglen);
        case MBEDTLS_MODE_CBC:
            if (taglen == 0)
                return PSA_ALG_CBC_NO_PADDING;
            else
                return 0;
        default:
            return 0;
    }
}

static inline psa_key_usage_t
mbedtls_psa_translate_cipher_operation(mbedtls_operation_t op)
{
    switch (op) {
        case MBEDTLS_ENCRYPT:
            return PSA_KEY_USAGE_ENCRYPT;
        case MBEDTLS_DECRYPT:
            return PSA_KEY_USAGE_DECRYPT;
        default:
            return 0;
    }
}

/* Translations for hashing. */

static inline psa_algorithm_t mbedtls_psa_translate_md(mbedtls_md_type_t md_alg)
{
    switch (md_alg) {
#    if defined(MBEDTLS_MD5_C)
        case MBEDTLS_MD_MD5:
            return PSA_ALG_MD5;
#    endif
#    if defined(MBEDTLS_SHA1_C)
        case MBEDTLS_MD_SHA1:
            return PSA_ALG_SHA_1;
#    endif
#    if defined(MBEDTLS_SHA224_C)
        case MBEDTLS_MD_SHA224:
            return PSA_ALG_SHA_224;
#    endif
#    if defined(MBEDTLS_SHA256_C)
        case MBEDTLS_MD_SHA256:
            return PSA_ALG_SHA_256;
#    endif
#    if defined(MBEDTLS_SHA384_C)
        case MBEDTLS_MD_SHA384:
            return PSA_ALG_SHA_384;
#    endif
#    if defined(MBEDTLS_SHA512_C)
        case MBEDTLS_MD_SHA512:
            return PSA_ALG_SHA_512;
#    endif
#    if defined(MBEDTLS_RIPEMD160_C)
        case MBEDTLS_MD_RIPEMD160:
            return PSA_ALG_RIPEMD160;
#    endif
        case MBEDTLS_MD_NONE:
            return 0;
        default:
            return 0;
    }
}

/* Translations for ECC. */

static inline int mbedtls_psa_get_ecc_oid_from_id(psa_ecc_family_t curve,
                                                  size_t bits,
                                                  char const **oid,
                                                  size_t *oid_len)
{
    switch (curve) {
        case PSA_ECC_FAMILY_SECP_R1:
            switch (bits) {
#    if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
                case 192:
                    *oid = MBEDTLS_OID_EC_GRP_SECP192R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP192R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
                case 224:
                    *oid = MBEDTLS_OID_EC_GRP_SECP224R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP224R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
                case 256:
                    *oid = MBEDTLS_OID_EC_GRP_SECP256R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP256R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
                case 384:
                    *oid = MBEDTLS_OID_EC_GRP_SECP384R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP384R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
                case 521:
                    *oid = MBEDTLS_OID_EC_GRP_SECP521R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP521R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
            }
            break;
        case PSA_ECC_FAMILY_SECP_K1:
            switch (bits) {
#    if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
                case 192:
                    *oid = MBEDTLS_OID_EC_GRP_SECP192K1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP192K1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
                case 224:
                    *oid = MBEDTLS_OID_EC_GRP_SECP224K1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP224K1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
                case 256:
                    *oid = MBEDTLS_OID_EC_GRP_SECP256K1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_SECP256K1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
            }
            break;
        case PSA_ECC_FAMILY_BRAINPOOL_P_R1:
            switch (bits) {
#    if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
                case 256:
                    *oid = MBEDTLS_OID_EC_GRP_BP256R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_BP256R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
                case 384:
                    *oid = MBEDTLS_OID_EC_GRP_BP384R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_BP384R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
#    if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
                case 512:
                    *oid = MBEDTLS_OID_EC_GRP_BP512R1;
                    *oid_len = MBEDTLS_OID_SIZE(MBEDTLS_OID_EC_GRP_BP512R1);
                    return 0;
#    endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
            }
            break;
    }
    (void)oid;
    (void)oid_len;
    return -1;
}

#    define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH 1

#    if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((192 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((192 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((224 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((224 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((256 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((256 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((384 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((384 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((521 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((521 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((192 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((192 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((224 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((224 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((256 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((256 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((256 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((256 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((384 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((384 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */

#    if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
#        if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < (2 * ((512 + 7) / 8) + 1)
#            undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
#            define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH (2 * ((512 + 7) / 8) + 1)
#        endif
#    endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */

/* Translations for PK layer */

static inline int mbedtls_psa_err_translate_pk(psa_status_t status)
{
    switch (status) {
        case PSA_SUCCESS:
            return 0;
        case PSA_ERROR_NOT_SUPPORTED:
            return MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE;
        case PSA_ERROR_INSUFFICIENT_MEMORY:
            return MBEDTLS_ERR_PK_ALLOC_FAILED;
        case PSA_ERROR_INSUFFICIENT_ENTROPY:
            return MBEDTLS_ERR_ECP_RANDOM_FAILED;
        case PSA_ERROR_BAD_STATE:
            return MBEDTLS_ERR_PK_BAD_INPUT_DATA;
        /* All other failures */
        case PSA_ERROR_COMMUNICATION_FAILURE:
        case PSA_ERROR_HARDWARE_FAILURE:
        case PSA_ERROR_CORRUPTION_DETECTED:
            return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
        default: /* We return the same as for the 'other failures',
                  * but list them separately nonetheless to indicate
                  * which failure conditions we have considered. */
            return MBEDTLS_ERR_PLATFORM_HW_ACCEL_FAILED;
    }
}

/* Translations for ECC */

/* This function transforms an ECC group identifier from
 * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8
 * into a PSA ECC group identifier. */
#    if defined(MBEDTLS_ECP_C)
static inline psa_key_type_t
mbedtls_psa_parse_tls_ecc_group(uint16_t tls_ecc_grp_reg_id, size_t *bits)
{
    const mbedtls_ecp_curve_info *curve_info =
        mbedtls_ecp_curve_info_from_tls_id(tls_ecc_grp_reg_id);
    if (curve_info == NULL)
        return 0;
    return (PSA_KEY_TYPE_ECC_KEY_PAIR(
        mbedtls_ecc_group_to_psa(curve_info->MBEDTLS_PRIVATE(grp_id), bits)));
}
#    endif /* MBEDTLS_ECP_C */

/* This function takes a buffer holding an EC public key
 * exported through psa_export_public_key(), and converts
 * it into an ECPoint structure to be put into a ClientKeyExchange
 * message in an ECDHE exchange.
 *
 * Both the present and the foreseeable future format of EC public keys
 * used by PSA have the ECPoint structure contained in the exported key
 * as a subbuffer, and the function merely selects this subbuffer instead
 * of making a copy.
 */
static inline int mbedtls_psa_tls_psa_ec_to_ecpoint(unsigned char *src,
                                                    size_t srclen,
                                                    unsigned char **dst,
                                                    size_t *dstlen)
{
    *dst = src;
    *dstlen = srclen;
    return 0;
}

/* This function takes a buffer holding an ECPoint structure
 * (as contained in a TLS ServerKeyExchange message for ECDHE
 * exchanges) and converts it into a format that the PSA key
 * agreement API understands.
 */
static inline int mbedtls_psa_tls_ecpoint_to_psa_ec(unsigned char const *src,
                                                    size_t srclen,
                                                    unsigned char *dst,
                                                    size_t dstlen,
                                                    size_t *olen)
{
    if (srclen > dstlen)
        return MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL;

    memcpy(dst, src, srclen);
    *olen = srclen;
    return 0;
}

#endif /* MBEDTLS_USE_PSA_CRYPTO */

/* Expose whatever RNG the PSA subsystem uses to applications using the
 * mbedtls_xxx API. The declarations and definitions here need to be
 * consistent with the implementation in library/psa_crypto_random_impl.h.
 * See that file for implementation documentation. */
#if defined(MBEDTLS_PSA_CRYPTO_C)

/* The type of a `f_rng` random generator function that many library functions
 * take.
 *
 * This type name is not part of the Mbed TLS stable API. It may be renamed
 * or moved without warning.
 */
typedef int
mbedtls_f_rng_t(void *p_rng, unsigned char *output, size_t output_size);

#    if defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG)

/** The random generator function for the PSA subsystem.
 *
 * This function is suitable as the `f_rng` random generator function
 * parameter of many `mbedtls_xxx` functions. Use #MBEDTLS_PSA_RANDOM_STATE
 * to obtain the \p p_rng parameter.
 *
 * The implementation of this function depends on the configuration of the
 * library.
 *
 * \note Depending on the configuration, this may be a function or
 *       a pointer to a function.
 *
 * \note This function may only be used if the PSA crypto subsystem is active.
 *       This means that you must call psa_crypto_init() before any call to
 *       this function, and you must not call this function after calling
 *       mbedtls_psa_crypto_free().
 *
 * \param p_rng         The random generator context. This must be
 *                      #MBEDTLS_PSA_RANDOM_STATE. No other state is
 *                      supported.
 * \param output        The buffer to fill. It must have room for
 *                      \c output_size bytes.
 * \param output_size   The number of bytes to write to \p output.
 *                      This function may fail if \p output_size is too
 *                      large. It is guaranteed to accept any output size
 *                      requested by Mbed TLS library functions. The
 *                      maximum request size depends on the library
 *                      configuration.
 *
 * \return              \c 0 on success.
 * \return              An `MBEDTLS_ERR_ENTROPY_xxx`,
 *                      `MBEDTLS_ERR_PLATFORM_xxx,
 *                      `MBEDTLS_ERR_CTR_DRBG_xxx` or
 *                      `MBEDTLS_ERR_HMAC_DRBG_xxx` on error.
 */
int mbedtls_psa_get_random(void *p_rng,
                           unsigned char *output,
                           size_t output_size);

/** The random generator state for the PSA subsystem.
 *
 * This macro expands to an expression which is suitable as the `p_rng`
 * random generator state parameter of many `mbedtls_xxx` functions.
 * It must be used in combination with the random generator function
 * mbedtls_psa_get_random().
 *
 * The implementation of this macro depends on the configuration of the
 * library. Do not make any assumption on its nature.
 */
#        define MBEDTLS_PSA_RANDOM_STATE NULL

#    else /* !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) */

#        if defined(MBEDTLS_CTR_DRBG_C)
#            include "mbedtls/ctr_drbg.h"
typedef mbedtls_ctr_drbg_context mbedtls_psa_drbg_context_t;
static mbedtls_f_rng_t *const mbedtls_psa_get_random = mbedtls_ctr_drbg_random;
#        elif defined(MBEDTLS_HMAC_DRBG_C)
#            include "mbedtls/hmac_drbg.h"
typedef mbedtls_hmac_drbg_context mbedtls_psa_drbg_context_t;
static mbedtls_f_rng_t *const mbedtls_psa_get_random = mbedtls_hmac_drbg_random;
#        endif
extern mbedtls_psa_drbg_context_t *const mbedtls_psa_random_state;

#        define MBEDTLS_PSA_RANDOM_STATE mbedtls_psa_random_state

#    endif /* !defined(MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG) */

#endif /* MBEDTLS_PSA_CRYPTO_C */

#endif /* MBEDTLS_PSA_UTIL_H */