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           15 : bool libspdm_read_responder_public_key(uint32_t base_asym_algo,
      22              :                                        void **data, size_t *size)
      23              : {
      24              :     bool res;
      25              :     char *file;
      26              : 
      27           15 :     switch (base_asym_algo) {
      28            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
      29              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
      30            0 :         file = "rsa2048/end_responder.key.pub.der";
      31            0 :         break;
      32            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
      33              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
      34            0 :         file = "rsa3072/end_responder.key.pub.der";
      35            0 :         break;
      36            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
      37              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
      38            0 :         file = "rsa4096/end_responder.key.pub.der";
      39            0 :         break;
      40           15 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
      41           15 :         file = "ecp256/end_responder.key.pub.der";
      42           15 :         break;
      43            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
      44            0 :         file = "ecp384/end_responder.key.pub.der";
      45            0 :         break;
      46            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
      47            0 :         file = "ecp521/end_responder.key.pub.der";
      48            0 :         break;
      49            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
      50            0 :         file = "sm2/end_responder.key.pub.der";
      51            0 :         break;
      52            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
      53            0 :         file = "ed25519/end_responder.key.pub.der";
      54            0 :         break;
      55            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
      56            0 :         file = "ed448/end_responder.key.pub.der";
      57            0 :         break;
      58            0 :     default:
      59            0 :         LIBSPDM_ASSERT(false);
      60            0 :         return false;
      61              :     }
      62           15 :     res = libspdm_read_input_file(file, data, size);
      63           15 :     return res;
      64              : }
      65              : 
      66            6 : bool libspdm_read_requester_public_key(uint16_t req_base_asym_alg,
      67              :                                        void **data, size_t *size)
      68              : {
      69              :     bool res;
      70              :     char *file;
      71              : 
      72            6 :     switch (req_base_asym_alg) {
      73            6 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048:
      74              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048:
      75            6 :         file = "rsa2048/end_requester.key.pub.der";
      76            6 :         break;
      77            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072:
      78              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072:
      79            0 :         file = "rsa3072/end_requester.key.pub.der";
      80            0 :         break;
      81            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096:
      82              :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096:
      83            0 :         file = "rsa4096/end_requester.key.pub.der";
      84            0 :         break;
      85            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256:
      86            0 :         file = "ecp256/end_requester.key.pub.der";
      87            0 :         break;
      88            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384:
      89            0 :         file = "ecp384/end_requester.key.pub.der";
      90            0 :         break;
      91            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521:
      92            0 :         file = "ecp521/end_requester.key.pub.der";
      93            0 :         break;
      94            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256:
      95            0 :         file = "sm2/end_requester.key.pub.der";
      96            0 :         break;
      97            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519:
      98            0 :         file = "ed25519/end_requester.key.pub.der";
      99            0 :         break;
     100            0 :     case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448:
     101            0 :         file = "ed448/end_requester.key.pub.der";
     102            0 :         break;
     103            0 :     default:
     104            0 :         LIBSPDM_ASSERT(false);
     105            0 :         return false;
     106              :     }
     107            6 :     res = libspdm_read_input_file(file, data, size);
     108            6 :     return res;
     109              : }