third_party/mbedtls/repo/include/mbedtls/psa_util.h

   1 /**
   2  * \file psa_util.h
   3  *
   4  * \brief Utility functions for the use of the PSA Crypto library.
   5  *
   6  * \warning This function is not part of the public API and may
   7  *          change at any time.
   8  */
   9 /*
  10  *  Copyright (C) 2006-2018, ARM Limited, All Rights Reserved
  11  *  SPDX-License-Identifier: Apache-2.0
  12  *
  13  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
  14  *  not use this file except in compliance with the License.
  15  *  You may obtain a copy of the License at
  16  *
  17  *  http://www.apache.org/licenses/LICENSE-2.0
  18  *
  19  *  Unless required by applicable law or agreed to in writing, software
  20  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  21  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22  *  See the License for the specific language governing permissions and
  23  *  limitations under the License.
  24  *
  25  *  This file is part of mbed TLS (https://tls.mbed.org)
  26  */
  27
  28 #ifndef MBEDTLS_PSA_UTIL_H
  29 #define MBEDTLS_PSA_UTIL_H
  30
  31 #if !defined(MBEDTLS_CONFIG_FILE)
  32 #include "config.h"
  33 #else
  34 #include MBEDTLS_CONFIG_FILE
  35 #endif
  36
  37 #if defined(MBEDTLS_USE_PSA_CRYPTO)
  38
  39 #include "psa/crypto.h"
  40
  41 #include "ecp.h"
  42 #include "md.h"
  43 #include "pk.h"
  44 #include "oid.h"
  45
  46 #include <string.h>
  47
  48 /* Translations for symmetric crypto. */
  49
  50 static inline psa_key_type_t mbedtls_psa_translate_cipher_type(
  51     mbedtls_cipher_type_t cipher )
  52 {
  53     switch( cipher )
  54     {
  55         case MBEDTLS_CIPHER_AES_128_CCM:
  56         case MBEDTLS_CIPHER_AES_192_CCM:
  57         case MBEDTLS_CIPHER_AES_256_CCM:
  58         case MBEDTLS_CIPHER_AES_128_GCM:
  59         case MBEDTLS_CIPHER_AES_192_GCM:
  60         case MBEDTLS_CIPHER_AES_256_GCM:
  61         case MBEDTLS_CIPHER_AES_128_CBC:
  62         case MBEDTLS_CIPHER_AES_192_CBC:
  63         case MBEDTLS_CIPHER_AES_256_CBC:
  64             return( PSA_KEY_TYPE_AES );
  65
  66         /* ARIA not yet supported in PSA. */
  67         /* case MBEDTLS_CIPHER_ARIA_128_CCM:
  68            case MBEDTLS_CIPHER_ARIA_192_CCM:
  69            case MBEDTLS_CIPHER_ARIA_256_CCM:
  70            case MBEDTLS_CIPHER_ARIA_128_GCM:
  71            case MBEDTLS_CIPHER_ARIA_192_GCM:
  72            case MBEDTLS_CIPHER_ARIA_256_GCM:
  73            case MBEDTLS_CIPHER_ARIA_128_CBC:
  74            case MBEDTLS_CIPHER_ARIA_192_CBC:
  75            case MBEDTLS_CIPHER_ARIA_256_CBC:
  76                return( PSA_KEY_TYPE_ARIA ); */
  77
  78         default:
  79             return( 0 );
  80     }
  81 }
  82
  83 static inline psa_algorithm_t mbedtls_psa_translate_cipher_mode(
  84     mbedtls_cipher_mode_t mode, size_t taglen )
  85 {
  86     switch( mode )
  87     {
  88         case MBEDTLS_MODE_GCM:
  89             return( PSA_ALG_AEAD_WITH_TAG_LENGTH( PSA_ALG_GCM, taglen ) );
  90         case MBEDTLS_MODE_CCM:
  91             return( PSA_ALG_AEAD_WITH_TAG_LENGTH( PSA_ALG_CCM, taglen ) );
  92         case MBEDTLS_MODE_CBC:
  93             if( taglen == 0 )
  94                 return( PSA_ALG_CBC_NO_PADDING );
  95             /* Intentional fallthrough for taglen != 0 */
  96             /* fallthrough */
  97         default:
  98             return( 0 );
  99     }
 100 }
 101
 102 static inline psa_key_usage_t mbedtls_psa_translate_cipher_operation(
 103     mbedtls_operation_t op )
 104 {
 105     switch( op )
 106     {
 107         case MBEDTLS_ENCRYPT:
 108             return( PSA_KEY_USAGE_ENCRYPT );
 109         case MBEDTLS_DECRYPT:
 110             return( PSA_KEY_USAGE_DECRYPT );
 111         default:
 112             return( 0 );
 113     }
 114 }
 115
 116 /* Translations for hashing. */
 117
 118 static inline psa_algorithm_t mbedtls_psa_translate_md( mbedtls_md_type_t md_alg )
 119 {
 120     switch( md_alg )
 121     {
 122 #if defined(MBEDTLS_MD2_C)
 123     case MBEDTLS_MD_MD2:
 124         return( PSA_ALG_MD2 );
 125 #endif
 126 #if defined(MBEDTLS_MD4_C)
 127     case MBEDTLS_MD_MD4:
 128         return( PSA_ALG_MD4 );
 129 #endif
 130 #if defined(MBEDTLS_MD5_C)
 131     case MBEDTLS_MD_MD5:
 132         return( PSA_ALG_MD5 );
 133 #endif
 134 #if defined(MBEDTLS_SHA1_C)
 135     case MBEDTLS_MD_SHA1:
 136         return( PSA_ALG_SHA_1 );
 137 #endif
 138 #if defined(MBEDTLS_SHA256_C)
 139     case MBEDTLS_MD_SHA224:
 140         return( PSA_ALG_SHA_224 );
 141     case MBEDTLS_MD_SHA256:
 142         return( PSA_ALG_SHA_256 );
 143 #endif
 144 #if defined(MBEDTLS_SHA512_C)
 145     case MBEDTLS_MD_SHA384:
 146         return( PSA_ALG_SHA_384 );
 147     case MBEDTLS_MD_SHA512:
 148         return( PSA_ALG_SHA_512 );
 149 #endif
 150 #if defined(MBEDTLS_RIPEMD160_C)
 151     case MBEDTLS_MD_RIPEMD160:
 152         return( PSA_ALG_RIPEMD160 );
 153 #endif
 154     case MBEDTLS_MD_NONE:  /* Intentional fallthrough */
 155     default:
 156         return( 0 );
 157     }
 158 }
 159
 160 /* Translations for ECC. */
 161
 162 static inline int mbedtls_psa_get_ecc_oid_from_id(
 163     psa_ecc_curve_t curve, char const **oid, size_t *oid_len )
 164 {
 165     switch( curve )
 166     {
 167 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
 168         case PSA_ECC_CURVE_SECP192R1:
 169             *oid = MBEDTLS_OID_EC_GRP_SECP192R1;
 170             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP192R1 );
 171             return( 0 );
 172 #endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
 173 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
 174         case PSA_ECC_CURVE_SECP224R1:
 175             *oid = MBEDTLS_OID_EC_GRP_SECP224R1;
 176             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP224R1 );
 177             return( 0 );
 178 #endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
 179 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
 180         case PSA_ECC_CURVE_SECP256R1:
 181             *oid = MBEDTLS_OID_EC_GRP_SECP256R1;
 182             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP256R1 );
 183             return( 0 );
 184 #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
 185 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
 186         case PSA_ECC_CURVE_SECP384R1:
 187             *oid = MBEDTLS_OID_EC_GRP_SECP384R1;
 188             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP384R1 );
 189             return( 0 );
 190 #endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
 191 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
 192         case PSA_ECC_CURVE_SECP521R1:
 193             *oid = MBEDTLS_OID_EC_GRP_SECP521R1;
 194             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP521R1 );
 195             return( 0 );
 196 #endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
 197 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
 198         case PSA_ECC_CURVE_SECP192K1:
 199             *oid = MBEDTLS_OID_EC_GRP_SECP192K1;
 200             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP192K1 );
 201             return( 0 );
 202 #endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
 203 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
 204         case PSA_ECC_CURVE_SECP224K1:
 205             *oid = MBEDTLS_OID_EC_GRP_SECP224K1;
 206             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP224K1 );
 207             return( 0 );
 208 #endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
 209 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
 210         case PSA_ECC_CURVE_SECP256K1:
 211             *oid = MBEDTLS_OID_EC_GRP_SECP256K1;
 212             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_SECP256K1 );
 213             return( 0 );
 214 #endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
 215 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
 216         case PSA_ECC_CURVE_BRAINPOOL_P256R1:
 217             *oid = MBEDTLS_OID_EC_GRP_BP256R1;
 218             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_BP256R1 );
 219             return( 0 );
 220 #endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
 221 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
 222         case PSA_ECC_CURVE_BRAINPOOL_P384R1:
 223             *oid = MBEDTLS_OID_EC_GRP_BP384R1;
 224             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_BP384R1 );
 225             return( 0 );
 226 #endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
 227 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
 228         case PSA_ECC_CURVE_BRAINPOOL_P512R1:
 229             *oid = MBEDTLS_OID_EC_GRP_BP512R1;
 230             *oid_len = MBEDTLS_OID_SIZE( MBEDTLS_OID_EC_GRP_BP512R1 );
 231             return( 0 );
 232 #endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
 233     }
 234
 235      return( -1 );
 236 }
 237
 238 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH 1
 239
 240 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
 241 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 192 + 7 ) / 8 ) + 1 )
 242 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 243 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 192 + 7 ) / 8 ) + 1 )
 244 #endif
 245 #endif /* MBEDTLS_ECP_DP_SECP192R1_ENABLED */
 246
 247 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
 248 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 224 + 7 ) / 8 ) + 1 )
 249 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 250 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 224 + 7 ) / 8 ) + 1 )
 251 #endif
 252 #endif /* MBEDTLS_ECP_DP_SECP224R1_ENABLED */
 253
 254 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
 255 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 256 + 7 ) / 8 ) + 1 )
 256 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 257 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 256 + 7 ) / 8 ) + 1 )
 258 #endif
 259 #endif /* MBEDTLS_ECP_DP_SECP256R1_ENABLED */
 260
 261 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
 262 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 384 + 7 ) / 8 ) + 1 )
 263 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 264 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 384 + 7 ) / 8 ) + 1 )
 265 #endif
 266 #endif /* MBEDTLS_ECP_DP_SECP384R1_ENABLED */
 267
 268 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
 269 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 521 + 7 ) / 8 ) + 1 )
 270 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 271 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 521 + 7 ) / 8 ) + 1 )
 272 #endif
 273 #endif /* MBEDTLS_ECP_DP_SECP521R1_ENABLED */
 274
 275 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
 276 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 192 + 7 ) / 8 ) + 1 )
 277 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 278 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 192 + 7 ) / 8 ) + 1 )
 279 #endif
 280 #endif /* MBEDTLS_ECP_DP_SECP192K1_ENABLED */
 281
 282 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
 283 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 224 + 7 ) / 8 ) + 1 )
 284 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 285 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 224 + 7 ) / 8 ) + 1 )
 286 #endif
 287 #endif /* MBEDTLS_ECP_DP_SECP224K1_ENABLED */
 288
 289 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
 290 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 256 + 7 ) / 8 ) + 1 )
 291 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 292 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 256 + 7 ) / 8 ) + 1 )
 293 #endif
 294 #endif /* MBEDTLS_ECP_DP_SECP256K1_ENABLED */
 295
 296 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
 297 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 256 + 7 ) / 8 ) + 1 )
 298 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 299 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 256 + 7 ) / 8 ) + 1 )
 300 #endif
 301 #endif /* MBEDTLS_ECP_DP_BP256R1_ENABLED */
 302
 303 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
 304 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 384 + 7 ) / 8 ) + 1 )
 305 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 306 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 384 + 7 ) / 8 ) + 1 )
 307 #endif
 308 #endif /* MBEDTLS_ECP_DP_BP384R1_ENABLED */
 309
 310 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
 311 #if MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH < ( 2 * ( ( 512 + 7 ) / 8 ) + 1 )
 312 #undef MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH
 313 #define MBEDTLS_PSA_MAX_EC_PUBKEY_LENGTH ( 2 * ( ( 512 + 7 ) / 8 ) + 1 )
 314 #endif
 315 #endif /* MBEDTLS_ECP_DP_BP512R1_ENABLED */
 316
 317
 318 static inline psa_ecc_curve_t mbedtls_psa_translate_ecc_group( mbedtls_ecp_group_id grpid )
 319 {
 320     switch( grpid )
 321     {
 322 #if defined(MBEDTLS_ECP_DP_SECP192R1_ENABLED)
 323         case MBEDTLS_ECP_DP_SECP192R1:
 324             return( PSA_ECC_CURVE_SECP192R1 );
 325 #endif
 326 #if defined(MBEDTLS_ECP_DP_SECP224R1_ENABLED)
 327         case MBEDTLS_ECP_DP_SECP224R1:
 328             return( PSA_ECC_CURVE_SECP224R1 );
 329 #endif
 330 #if defined(MBEDTLS_ECP_DP_SECP256R1_ENABLED)
 331         case MBEDTLS_ECP_DP_SECP256R1:
 332             return( PSA_ECC_CURVE_SECP256R1 );
 333 #endif
 334 #if defined(MBEDTLS_ECP_DP_SECP384R1_ENABLED)
 335         case MBEDTLS_ECP_DP_SECP384R1:
 336             return( PSA_ECC_CURVE_SECP384R1 );
 337 #endif
 338 #if defined(MBEDTLS_ECP_DP_SECP521R1_ENABLED)
 339         case MBEDTLS_ECP_DP_SECP521R1:
 340             return( PSA_ECC_CURVE_SECP521R1 );
 341 #endif
 342 #if defined(MBEDTLS_ECP_DP_BP256R1_ENABLED)
 343         case MBEDTLS_ECP_DP_BP256R1:
 344             return( PSA_ECC_CURVE_BRAINPOOL_P256R1 );
 345 #endif
 346 #if defined(MBEDTLS_ECP_DP_BP384R1_ENABLED)
 347         case MBEDTLS_ECP_DP_BP384R1:
 348             return( PSA_ECC_CURVE_BRAINPOOL_P384R1 );
 349 #endif
 350 #if defined(MBEDTLS_ECP_DP_BP512R1_ENABLED)
 351         case MBEDTLS_ECP_DP_BP512R1:
 352             return( PSA_ECC_CURVE_BRAINPOOL_P512R1 );
 353 #endif
 354 #if defined(MBEDTLS_ECP_DP_CURVE25519_ENABLED)
 355         case MBEDTLS_ECP_DP_CURVE25519:
 356             return( PSA_ECC_CURVE_CURVE25519 );
 357 #endif
 358 #if defined(MBEDTLS_ECP_DP_SECP192K1_ENABLED)
 359         case MBEDTLS_ECP_DP_SECP192K1:
 360             return( PSA_ECC_CURVE_SECP192K1 );
 361 #endif
 362 #if defined(MBEDTLS_ECP_DP_SECP224K1_ENABLED)
 363         case MBEDTLS_ECP_DP_SECP224K1:
 364             return( PSA_ECC_CURVE_SECP224K1 );
 365 #endif
 366 #if defined(MBEDTLS_ECP_DP_SECP256K1_ENABLED)
 367         case MBEDTLS_ECP_DP_SECP256K1:
 368             return( PSA_ECC_CURVE_SECP256K1 );
 369 #endif
 370 #if defined(MBEDTLS_ECP_DP_CURVE448_ENABLED)
 371         case MBEDTLS_ECP_DP_CURVE448:
 372             return( PSA_ECC_CURVE_CURVE448 );
 373 #endif
 374         default:
 375             return( 0 );
 376     }
 377 }
 378
 379
 380 #define MBEDTLS_PSA_ECC_KEY_BITS_OF_CURVE( curve )                \
 381     ( curve == PSA_ECC_CURVE_SECP192R1        ? 192 :             \
 382       curve == PSA_ECC_CURVE_SECP224R1        ? 224 :             \
 383       curve == PSA_ECC_CURVE_SECP256R1        ? 256 :             \
 384       curve == PSA_ECC_CURVE_SECP384R1        ? 384 :             \
 385       curve == PSA_ECC_CURVE_SECP521R1        ? 521 :             \
 386       curve == PSA_ECC_CURVE_SECP192K1        ? 192 :             \
 387       curve == PSA_ECC_CURVE_SECP224K1        ? 224 :             \
 388       curve == PSA_ECC_CURVE_SECP256K1        ? 256 :             \
 389       curve == PSA_ECC_CURVE_BRAINPOOL_P256R1 ? 256 :             \
 390       curve == PSA_ECC_CURVE_BRAINPOOL_P384R1 ? 384 :             \
 391       curve == PSA_ECC_CURVE_BRAINPOOL_P512R1 ? 512 :             \
 392       0 )
 393
 394 #define MBEDTLS_PSA_ECC_KEY_BYTES_OF_CURVE( curve )                \
 395     ( ( MBEDTLS_PSA_ECC_KEY_BITS_OF_CURVE( curve ) + 7 ) / 8 )
 396
 397 /* Translations for PK layer */
 398
 399 static inline int mbedtls_psa_err_translate_pk( psa_status_t status )
 400 {
 401     switch( status )
 402     {
 403         case PSA_SUCCESS:
 404             return( 0 );
 405         case PSA_ERROR_NOT_SUPPORTED:
 406             return( MBEDTLS_ERR_PK_FEATURE_UNAVAILABLE );
 407         case PSA_ERROR_INSUFFICIENT_MEMORY:
 408             return( MBEDTLS_ERR_PK_ALLOC_FAILED );
 409         case PSA_ERROR_INSUFFICIENT_ENTROPY:
 410             return( MBEDTLS_ERR_ECP_RANDOM_FAILED );
 411         case PSA_ERROR_BAD_STATE:
 412             return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
 413         /* All other failures */
 414         case PSA_ERROR_COMMUNICATION_FAILURE:
 415         case PSA_ERROR_HARDWARE_FAILURE:
 416         case PSA_ERROR_TAMPERING_DETECTED:
 417             return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED );
 418         default: /* We return the same as for the 'other failures',
 419                   * but list them separately nonetheless to indicate
 420                   * which failure conditions we have considered. */
 421             return( MBEDTLS_ERR_PK_HW_ACCEL_FAILED );
 422     }
 423 }
 424
 425 /* Translations for ECC */
 426
 427 /* This function transforms an ECC group identifier from
 428  * https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8
 429  * into a PSA ECC group identifier. */
 430 static inline psa_ecc_curve_t mbedtls_psa_parse_tls_ecc_group(
 431     uint16_t tls_ecc_grp_reg_id )
 432 {
 433     /* The PSA identifiers are currently aligned with those from
 434      * the TLS Supported Groups registry, so no conversion is necessary. */
 435     return( (psa_ecc_curve_t) tls_ecc_grp_reg_id );
 436 }
 437
 438 /* This function takes a buffer holding an EC public key
 439  * exported through psa_export_public_key(), and converts
 440  * it into an ECPoint structure to be put into a ClientKeyExchange
 441  * message in an ECDHE exchange.
 442  *
 443  * Both the present and the foreseeable future format of EC public keys
 444  * used by PSA have the ECPoint structure contained in the exported key
 445  * as a subbuffer, and the function merely selects this subbuffer instead
 446  * of making a copy.
 447  */
 448 static inline int mbedtls_psa_tls_psa_ec_to_ecpoint( unsigned char *src,
 449                                                      size_t srclen,
 450                                                      unsigned char **dst,
 451                                                      size_t *dstlen )
 452 {
 453     *dst = src;
 454     *dstlen = srclen;
 455     return( 0 );
 456 }
 457
 458 /* This function takes a buffer holding an ECPoint structure
 459  * (as contained in a TLS ServerKeyExchange message for ECDHE
 460  * exchanges) and converts it into a format that the PSA key
 461  * agreement API understands.
 462  */
 463 static inline int mbedtls_psa_tls_ecpoint_to_psa_ec( psa_ecc_curve_t curve,
 464                                                      unsigned char const *src,
 465                                                      size_t srclen,
 466                                                      unsigned char *dst,
 467                                                      size_t dstlen,
 468                                                      size_t *olen )
 469 {
 470     ((void) curve);
 471
 472     if( srclen > dstlen )
 473         return( MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL );
 474
 475     memcpy( dst, src, srclen );
 476     *olen = srclen;
 477     return( 0 );
 478 }
 479
 480 #endif /* MBEDTLS_USE_PSA_CRYPTO */
 481
 482 #endif /* MBEDTLS_PSA_UTIL_H */