Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2021-2022 DMTF. All rights reserved.
       4              :  *  License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md
       5              :  **/
       6              : 
       7              : #include "internal/libspdm_crypt_lib.h"
       8              : 
       9          189 : bool libspdm_hkdf_extract(uint32_t base_hash_algo, const uint8_t *ikm, size_t ikm_size,
      10              :                           const uint8_t *salt, size_t salt_size,
      11              :                           uint8_t *prk_out, size_t prk_out_size)
      12              : {
      13          189 :     switch (base_hash_algo) {
      14          189 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
      15              : #if LIBSPDM_SHA256_SUPPORT
      16          189 :         return libspdm_hkdf_sha256_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      17              : #else
      18              :         LIBSPDM_ASSERT(false);
      19              :         return false;
      20              : #endif
      21            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
      22              : #if LIBSPDM_SHA384_SUPPORT
      23            0 :         return libspdm_hkdf_sha384_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      24              : #else
      25              :         LIBSPDM_ASSERT(false);
      26              :         return false;
      27              : #endif
      28            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
      29              : #if LIBSPDM_SHA512_SUPPORT
      30            0 :         return libspdm_hkdf_sha512_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      31              : #else
      32              :         LIBSPDM_ASSERT(false);
      33              :         return false;
      34              : #endif
      35            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
      36              : #if LIBSPDM_SHA3_256_SUPPORT
      37            0 :         return libspdm_hkdf_sha3_256_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      38              : #else
      39              :         LIBSPDM_ASSERT(false);
      40              :         return false;
      41              : #endif
      42            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
      43              : #if LIBSPDM_SHA3_384_SUPPORT
      44            0 :         return libspdm_hkdf_sha3_384_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      45              : #else
      46              :         LIBSPDM_ASSERT(false);
      47              :         return false;
      48              : #endif
      49            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
      50              : #if LIBSPDM_SHA3_512_SUPPORT
      51            0 :         return libspdm_hkdf_sha3_512_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      52              : #else
      53              :         LIBSPDM_ASSERT(false);
      54              :         return false;
      55              : #endif
      56            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
      57              : #if LIBSPDM_SM3_256_SUPPORT
      58              :         return libspdm_hkdf_sm3_256_extract(ikm, ikm_size, salt, salt_size, prk_out, prk_out_size);
      59              : #else
      60            0 :         LIBSPDM_ASSERT(false);
      61            0 :         return false;
      62              : #endif
      63            0 :     default:
      64            0 :         LIBSPDM_ASSERT(false);
      65            0 :         return false;
      66              :     }
      67              : }
      68              : 
      69         1234 : bool libspdm_hkdf_expand(uint32_t base_hash_algo, const uint8_t *prk,
      70              :                          size_t prk_size, const uint8_t *info,
      71              :                          size_t info_size, uint8_t *out, size_t out_size)
      72              : {
      73         1234 :     switch (base_hash_algo) {
      74         1234 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_256:
      75              : #if LIBSPDM_SHA256_SUPPORT
      76         1234 :         return libspdm_hkdf_sha256_expand(prk, prk_size, info, info_size, out, out_size);
      77              : #else
      78              :         LIBSPDM_ASSERT(false);
      79              :         return false;
      80              : #endif
      81            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_384:
      82              : #if LIBSPDM_SHA384_SUPPORT
      83            0 :         return libspdm_hkdf_sha384_expand(prk, prk_size, info, info_size, out, out_size);
      84              : #else
      85              :         LIBSPDM_ASSERT(false);
      86              :         return false;
      87              : #endif
      88            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA_512:
      89              : #if LIBSPDM_SHA512_SUPPORT
      90            0 :         return libspdm_hkdf_sha512_expand(prk, prk_size, info, info_size, out, out_size);
      91              : #else
      92              :         LIBSPDM_ASSERT(false);
      93              :         return false;
      94              : #endif
      95            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_256:
      96              : #if LIBSPDM_SHA3_256_SUPPORT
      97            0 :         return libspdm_hkdf_sha3_256_expand(prk, prk_size, info, info_size, out, out_size);
      98              : #else
      99              :         LIBSPDM_ASSERT(false);
     100              :         return false;
     101              : #endif
     102            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_384:
     103              : #if LIBSPDM_SHA3_384_SUPPORT
     104            0 :         return libspdm_hkdf_sha3_384_expand(prk, prk_size, info, info_size, out, out_size);
     105              : #else
     106              :         LIBSPDM_ASSERT(false);
     107              :         return false;
     108              : #endif
     109            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SHA3_512:
     110              : #if LIBSPDM_SHA3_512_SUPPORT
     111            0 :         return libspdm_hkdf_sha3_512_expand(prk, prk_size, info, info_size, out, out_size);
     112              : #else
     113              :         LIBSPDM_ASSERT(false);
     114              :         return false;
     115              : #endif
     116            0 :     case SPDM_ALGORITHMS_BASE_HASH_ALGO_TPM_ALG_SM3_256:
     117              : #if LIBSPDM_SM3_256_SUPPORT
     118              :         return libspdm_hkdf_sm3_256_expand(prk, prk_size, info, info_size, out, out_size);
     119              : #else
     120            0 :         LIBSPDM_ASSERT(false);
     121            0 :         return false;
     122              : #endif
     123            0 :     default:
     124            0 :         LIBSPDM_ASSERT(false);
     125            0 :         return false;
     126              :     }
     127              : }