git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Source/mbedtls/include/mbedtls/psa_util.h

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