Line data    Source code

       1              : /**
       2              :  *  Copyright Notice:
       3              :  *  Copyright 2024 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 <stdarg.h>
       8              : #include <stddef.h>
       9              : #include <setjmp.h>
      10              : #include <stdint.h>
      11              : #include <stdlib.h>
      12              : #include <stdio.h>
      13              : #include <assert.h>
      14              : #include <string.h>
      15              : 
      16              : #include <base.h>
      17              : #include "library/memlib.h"
      18              : #include "spdm_device_secret_lib_internal.h"
      19              : #include "internal/libspdm_common_lib.h"
      20              : 
      21              : #if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY
      22          144 : bool libspdm_read_responder_private_key(uint32_t base_asym_algo,
      23              :                                         void **data, size_t *size)
      24              : {
      25              :     bool res;
      26              :     char *file;
      27              : 
      28          144 :     switch (base_asym_algo) {
      29            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
      30              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
      31            0 :         file = "rsa2048/end_responder.key";
      32            0 :         break;
      33            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
      34              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
      35            0 :         file = "rsa3072/end_responder.key";
      36            0 :         break;
      37            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
      38              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
      39            0 :         file = "rsa4096/end_responder.key";
      40            0 :         break;
      41          144 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
      42          144 :         file = "ecp256/end_responder.key";
      43          144 :         break;
      44            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
      45            0 :         file = "ecp384/end_responder.key";
      46            0 :         break;
      47            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
      48            0 :         file = "ecp521/end_responder.key";
      49            0 :         break;
      50            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
      51            0 :         file = "sm2/end_responder.key";
      52            0 :         break;
      53            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
      54            0 :         file = "ed25519/end_responder.key";
      55            0 :         break;
      56            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
      57            0 :         file = "ed448/end_responder.key";
      58            0 :         break;
      59            0 :     default:
      60            0 :         LIBSPDM_ASSERT(false);
      61            0 :         return false;
      62              :     }
      63          144 :     res = libspdm_read_input_file(file, data, size);
      64          144 :     return res;
      65              : }
      66              : #endif
      67              : 
      68              : #if LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP
      69           35 : bool libspdm_read_requester_private_key(uint16_t req_base_asym_alg,
      70              :                                         void **data, size_t *size)
      71              : {
      72              :     bool res;
      73              :     char *file;
      74              : 
      75           35 :     switch (req_base_asym_alg) {
      76           35 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
      77              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
      78           35 :         file = "rsa2048/end_requester.key";
      79           35 :         break;
      80            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
      81              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
      82            0 :         file = "rsa3072/end_requester.key";
      83            0 :         break;
      84            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
      85              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
      86            0 :         file = "rsa4096/end_requester.key";
      87            0 :         break;
      88            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
      89            0 :         file = "ecp256/end_requester.key";
      90            0 :         break;
      91            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
      92            0 :         file = "ecp384/end_requester.key";
      93            0 :         break;
      94            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
      95            0 :         file = "ecp521/end_requester.key";
      96            0 :         break;
      97            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
      98            0 :         file = "sm2/end_requester.key";
      99            0 :         break;
     100            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
     101            0 :         file = "ed25519/end_requester.key";
     102            0 :         break;
     103            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
     104            0 :         file = "ed448/end_requester.key";
     105            0 :         break;
     106            0 :     default:
     107            0 :         LIBSPDM_ASSERT(false);
     108            0 :         return false;
     109              :     }
     110           35 :     res = libspdm_read_input_file(file, data, size);
     111           35 :     return res;
     112              : }
     113              : #endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP */