diff --git a/CMakeLists.txt b/CMakeLists.txt index c074b9a0808..bbe06df174f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,6 +36,7 @@ set(GCOV ${GCOV} CACHE STRING "Choose the target of Gcov: ON OFF, and default i set(STACK_USAGE ${STACK_USAGE} CACHE STRING "Choose the target of STACK_USAGE: ON OFF, and default is OFF" FORCE) set(BUILD_LINUX_SHARED_LIB ${BUILD_LINUX_SHARED_LIB} CACHE STRING "Choose if libspdm shared library should be built for linux: ON OFF, and default is OFF" FORCE) set(X509_IGNORE_CRITICAL ${X509_IGNORE_CRITICAL} CACHE STRING "Choose if libspdm-provided cryptography libraries (OpenSSL and MbedTLS) ignore unsupported critical extensions in certificates : ON OFF, and default is OFF" FORCE) +set(DEVICE ${DEVICE} CACHE STRING "Choose the test device: sample tpm, and default is sample" FORCE) if(NOT GCOV) set(GCOV "OFF") @@ -53,6 +54,11 @@ if(NOT X509_IGNORE_CRITICAL) set(X509_IGNORE_CRITICAL "OFF") endif() +if (NOT DEVICE) + set(DEVICE "sample") +endif() + + set(LIBSPDM_DIR ${PROJECT_SOURCE_DIR}) # @@ -62,6 +68,7 @@ set(COMPILED_LIBCRYPTO_PATH ${COMPILED_LIBCRYPTO_PATH} CACHE STRING "Optionally set(COMPILED_LIBSSL_PATH ${COMPILED_LIBSSL_PATH} CACHE STRING "Optionally provide a path to libssl" FORCE) message("CMAKE_GENERATOR = ${CMAKE_GENERATOR}") +message("DEVICE = ${DEVICE}") if(ARCH STREQUAL "x64") message("ARCH = x64") @@ -981,7 +988,7 @@ if(ENABLE_CODEQL STREQUAL "ON") add_subdirectory(os_stub/platform_lib) add_subdirectory(os_stub/platform_lib_null) add_subdirectory(os_stub/malloclib) - add_subdirectory(os_stub/spdm_device_secret_lib_sample) + add_subdirectory(os_stub/spdm_device_secret_lib_${DEVICE}) add_subdirectory(os_stub/spdm_device_secret_lib_null) add_subdirectory(os_stub/spdm_cert_verify_callback_sample) add_subdirectory(os_stub/cryptlib_null) @@ -1020,7 +1027,7 @@ else() add_subdirectory(os_stub/platform_lib) add_subdirectory(os_stub/platform_lib_null) add_subdirectory(os_stub/malloclib) - add_subdirectory(os_stub/spdm_device_secret_lib_sample) + add_subdirectory(os_stub/spdm_device_secret_lib_${DEVICE}) add_subdirectory(os_stub/spdm_device_secret_lib_null) add_subdirectory(os_stub/spdm_cert_verify_callback_sample) diff --git a/include/hal/library/cryptlib/cryptlib_tpm.h b/include/hal/library/cryptlib/cryptlib_tpm.h new file mode 100644 index 00000000000..6f348178982 --- /dev/null +++ b/include/hal/library/cryptlib/cryptlib_tpm.h @@ -0,0 +1,24 @@ +/** + * Copyright Notice: + * Copyright 2021-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#ifndef __CRYPTLIB_TPM_H__ +#define __CRYPTLIB_TPM_H__ + +#include + +bool libspdm_tpm_device_init(); + +bool libspdm_tpm_get_private_key(void *handle, void **context); + +bool libspdm_tpm_get_public_key(void *handle, void **context); + +bool libspdm_tpm_get_certificate(void *handle, void **context); + +bool libspdm_tpm_dump_certificate(void *context, void **buffer, size_t *size); + +bool libspdm_tpm_read_pcr(uint32_t hash_algo, uint32_t index, void *buffer, size_t *size); + +#endif diff --git a/os_stub/cryptlib_openssl/CMakeLists.txt b/os_stub/cryptlib_openssl/CMakeLists.txt index 2af00189db1..3d92b10a19c 100644 --- a/os_stub/cryptlib_openssl/CMakeLists.txt +++ b/os_stub/cryptlib_openssl/CMakeLists.txt @@ -52,3 +52,10 @@ target_sources(cryptlib_openssl target_compile_options(cryptlib_openssl PRIVATE ${OPENSSL_FLAGS}) target_link_libraries(cryptlib_openssl PUBLIC openssllib memlib) + +if (${DEVICE} STREQUAL "tpm") + target_sources(cryptlib_openssl PRIVATE + tpm/tpm.c + ) + target_link_libraries(cryptlib_openssl PUBLIC tss2-esys tss2-tctildr) +endif() diff --git a/os_stub/cryptlib_openssl/pk/ec.c b/os_stub/cryptlib_openssl/pk/ec.c index 223f45332bf..f479bba4816 100644 --- a/os_stub/cryptlib_openssl/pk/ec.c +++ b/os_stub/cryptlib_openssl/pk/ec.c @@ -681,6 +681,13 @@ bool libspdm_ecdsa_sign(void *ec_context, size_t hash_nid, return false; } + char buffer[4096]; + BIO *bio = BIO_new(BIO_s_mem()); + EVP_PKEY_print_public(bio, evp_pkey, 4, NULL); + int len = BIO_read(bio, (void*) buffer, sizeof(buffer)); + buffer[len] = '\0'; + printf("SIGN PUBLIC KEY: %s\n", buffer); + half_size = evp_pkey_get_half_size(evp_pkey); if (*sig_size < (size_t)(half_size * 2)) { *sig_size = half_size * 2; @@ -828,6 +835,13 @@ bool libspdm_ecdsa_verify(void *ec_context, size_t hash_nid, return false; } + char buffer[4096]; + BIO *bio = BIO_new(BIO_s_mem()); + EVP_PKEY_print_public(bio, evp_pkey, 4, NULL); + int len = BIO_read(bio, (void*) buffer, sizeof(buffer)); + buffer[len] = '\0'; + printf("VERIFY PUBLIC KEY: %s\n", buffer); + half_size = evp_pkey_get_half_size(evp_pkey); if (sig_size != (size_t)(half_size * 2)) { return false; diff --git a/os_stub/cryptlib_openssl/pk/x509.c b/os_stub/cryptlib_openssl/pk/x509.c index 1c79377a832..2f8b07e4e92 100644 --- a/os_stub/cryptlib_openssl/pk/x509.c +++ b/os_stub/cryptlib_openssl/pk/x509.c @@ -35,6 +35,26 @@ static const uint8_t m_libspdm_oid_ext_key_usage[] = OID_EXT_KEY_USAGE; static const uint8_t m_libspdm_oid_basic_constraints[] = OID_BASIC_CONSTRAINTS; +static void dump_hex(const char* id, const unsigned char *buf, long buflen) +{ + char buffer[4096]; + const unsigned char *p = buf; + X509 *cert = d2i_X509(NULL, &p, buflen); + if (!cert) { + printf("Not an X.509 cert inside this ASN.1 object.\n"); + return; + } + + /* Print certificate */ + BIO *bio = BIO_new(BIO_s_mem()); + X509_print(bio, cert); + int s = BIO_read(bio, (void*) buffer, sizeof(buffer)); + buffer[s] = '\0'; + printf("%s CERT: %s\n", id, buffer); + X509_free(cert); +} + +// /** * Construct a X509 object from DER-encoded certificate data. * @@ -2037,6 +2057,8 @@ bool libspdm_x509_verify_cert_chain(const uint8_t *root_cert, size_t root_cert_l /* Verify current_cert with preceding cert;*/ + dump_hex("CURRENT", current_cert, current_cert_len); + dump_hex("PRECEDING", preceding_cert, preceding_cert_len); verify_flag = libspdm_x509_verify_cert(current_cert, current_cert_len, preceding_cert, preceding_cert_len); @@ -2458,6 +2480,7 @@ bool libspdm_gen_x509_csr_with_pqc( X509_NAME *x509_name; EVP_PKEY *private_key; EVP_PKEY *public_key; + bool owned_keys = false; EVP_MD *md; uint8_t *csr_p; STACK_OF(X509_EXTENSION) *exts; @@ -2536,11 +2559,13 @@ bool libspdm_gen_x509_csr_with_pqc( EVP_PKEY_free(private_key); EVP_PKEY_free(public_key); - private_key = EVP_PKEY_dup(ec_pkey); - public_key = EVP_PKEY_dup(ec_pkey); + // Can't DUP hardware backed keys + private_key = ec_pkey; + public_key = ec_pkey; if (private_key == NULL || public_key == NULL) { goto free_all; } + owned_keys = true; break; } case LIBSPDM_CRYPTO_NID_SM2_DSA_P256: { @@ -2763,8 +2788,10 @@ bool libspdm_gen_x509_csr_with_pqc( EVP_MD_free((EVP_MD *)md); } X509_REQ_free(x509_req); - EVP_PKEY_free(private_key); - EVP_PKEY_free(public_key); + if (!owned_keys) { + EVP_PKEY_free(private_key); + EVP_PKEY_free(public_key); + } return (ret != 0); } diff --git a/os_stub/cryptlib_openssl/tpm/tpm.c b/os_stub/cryptlib_openssl/tpm/tpm.c new file mode 100644 index 00000000000..9d86606a85c --- /dev/null +++ b/os_stub/cryptlib_openssl/tpm/tpm.c @@ -0,0 +1,218 @@ +/** + * Copyright Notice: + * Copyright 2021-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include "library/cryptlib/cryptlib_tpm.h" +#include "internal/libspdm_crypt_lib.h" + +#include "key_context.h" + +bool g_tpm_device_initialized = false; + +static libspdm_key_context *create_key_context(EVP_PKEY *pkey) +{ + libspdm_key_context *context = (libspdm_key_context *)malloc(sizeof(libspdm_key_context)); + context->evp_pkey = pkey; + return context; +} + +bool libspdm_tpm_device_init() +{ + OSSL_PROVIDER *tpm_provider = NULL; + + if (g_tpm_device_initialized) + return true; + + tpm_provider = OSSL_PROVIDER_load(NULL, "tpm2"); + if (tpm_provider == NULL) + { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "failed to load tpm2\n")); + return false; + } + + OSSL_PROVIDER_load(NULL, "default"); + OSSL_PROVIDER_load(NULL, "legacy"); + + g_tpm_device_initialized = true; + return true; +} + +static bool get_keyinfo(const char *handle, void **context, int keyinfo_type) +{ + OSSL_STORE_CTX *store_ctx = NULL; + OSSL_STORE_INFO *info = NULL; + + /* handle must look like: "tpm2tss:0x81010002" */ + store_ctx = OSSL_STORE_open_ex(handle, NULL, "provider=tpm2", NULL, NULL, NULL, NULL, NULL); + if (!store_ctx) + { + return false; + } + + while ((info = OSSL_STORE_load(store_ctx)) != NULL) + { + if (OSSL_STORE_INFO_get_type(info) == keyinfo_type) + { + switch (keyinfo_type) + { + case OSSL_STORE_INFO_PKEY: + *context = OSSL_STORE_INFO_get1_PKEY(info); + break; + case OSSL_STORE_INFO_PUBKEY: + *context = OSSL_STORE_INFO_get1_PUBKEY(info); + break; + case OSSL_STORE_INFO_CERT: + *context = OSSL_STORE_INFO_get1_CERT(info); + break; + } + break; + } + OSSL_STORE_INFO_free(info); + } + + OSSL_STORE_close(store_ctx); + + if (*context == NULL) + { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "no keyinfo %d foun on handle %s\n", keyinfo_type, handle)); + return false; + } + + return true; +} + +bool libspdm_tpm_get_private_key(void *handle, void **context) +{ + EVP_PKEY *pkey = NULL; + if (!get_keyinfo((const char *)handle, (void **)&pkey, OSSL_STORE_INFO_PKEY)) + { + return false; + } + *context = create_key_context(pkey); + return true; +} + +bool libspdm_tpm_get_public_key(void *handle, void **context) +{ + EVP_PKEY *pkey = NULL; + if (!get_keyinfo((const char *)handle, (void **)&pkey, OSSL_STORE_INFO_PUBKEY)) + { + return false; + } + *context = create_key_context(pkey); + return true; +} + +bool libspdm_tpm_get_certificate(void *handle, void **context) +{ + return get_keyinfo((const char *)handle, context, OSSL_STORE_INFO_CERT); +} + +bool libspdm_tpm_dump_certificate(void *context, void **buffer, size_t *size) +{ + int len = 0; + len = i2d_X509((X509 *)context, NULL); + if (len < 0) + return false; + + void *cert = OPENSSL_malloc(len); + if (cert == NULL) + { + return false; + } + *buffer = cert; + len = i2d_X509((X509 *)context, (unsigned char **)&cert); + if (len < 0) + { + free(*buffer); + *buffer = NULL; + return false; + } + *size = len; + return true; +} + +bool libspdm_tpm_read_pcr(uint32_t hash_algo, uint32_t index, void *buffer, size_t *size) +{ + TSS2_RC result; + TSS2_TCTI_CONTEXT *tcti_context = NULL; + ESYS_CONTEXT *context = NULL; + + TPML_PCR_SELECTION sel = { + .count = 1, + .pcrSelections = { + { + .sizeofSelect = 3, + .pcrSelect = {0x00, 0x00, 0x00, 0x00}, + }, + }}; + + *size = 0; + switch (hash_algo) + { + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_256: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_256: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SM3_256: + sel.pcrSelections[0].hash = TPM2_ALG_SHA256; + *size = 32; + break; + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_384: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_384: + sel.pcrSelections[0].hash = TPM2_ALG_SHA384; + *size = 48; + break; + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA_512: + case SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_TPM_ALG_SHA3_512: + sel.pcrSelections[0].hash = TPM2_ALG_SHA512; + *size = 64; + break; + default: + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "unsupported measurement hash algo %d\n", hash_algo)); + return false; + } + sel.pcrSelections[0].pcrSelect[(index - 1) / 8] |= 1 << ((index - 1) % 8); + + UINT32 uc; + TPML_PCR_SELECTION *out = NULL; + TPML_DIGEST *values = NULL; + + const char *tssconf = getenv("TPM2TOOLS_TCTI"); + if ((result = Tss2_TctiLdr_Initialize(tssconf, &tcti_context)) != TSS2_RC_SUCCESS) + { + goto finish; + } + + // TODO: abi version check + if ((result = Esys_Initialize(&context, tcti_context, NULL)) != TSS2_RC_SUCCESS) + { + goto cleanup_tcti; + } + + if ((result = Esys_PCR_Read(context, ESYS_TR_NONE, ESYS_TR_NONE, ESYS_TR_NONE, &sel, &uc, &out, &values)) != TSS2_RC_SUCCESS) + { + goto cleanup_esys; + } + + memcpy(buffer, values->digests[0].buffer, *size); + +cleanup_esys: + Esys_Finalize(&context); + +cleanup_tcti: + Tss2_TctiLdr_Finalize(&tcti_context); + +finish: + return result == TSS2_RC_SUCCESS; +} \ No newline at end of file diff --git a/os_stub/openssllib/ossl_store.c b/os_stub/openssllib/ossl_store.c deleted file mode 100644 index 3667d7cee8b..00000000000 --- a/os_stub/openssllib/ossl_store.c +++ /dev/null @@ -1,156 +0,0 @@ -/** - * Copyright Notice: - * Copyright 2021-2022 DMTF. All rights reserved. - * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md - **/ - -#include /* The OSSL_STORE_INFO type numbers */ - -/* - * This function is cleanup ossl store. - * - * Dummy Implement - */ -void -ossl_store_cleanup_int ( - void - ) -{ -} - -static void * -file_open ( - void *provctx, - const char *uri - ) -{ - return NULL; -} - -const OSSL_DISPATCH ossl_file_store_functions[] = { - { OSSL_FUNC_STORE_OPEN, (void (*)(void)) file_open }, - { 0, NULL }, -}; - -OSSL_STORE_CTX * -OSSL_STORE_open ( - const char *uri, - const UI_METHOD *ui_method, - void *ui_data, - OSSL_STORE_post_process_info_fn post_process, - void *post_process_data - ) -{ - return NULL; -} - -OSSL_STORE_CTX * -OSSL_STORE_open_ex ( - const char *uri, - OSSL_LIB_CTX *libctx, - const char *propq, - const UI_METHOD *ui_method, - void *ui_data, - const OSSL_PARAM params[], - OSSL_STORE_post_process_info_fn post_process, - void *post_process_data - ) -{ - return NULL; -} - -int -OSSL_STORE_INFO_get_type ( - const OSSL_STORE_INFO *info - ) -{ - return 0; -} - -int -OSSL_STORE_find ( - OSSL_STORE_CTX *ctx, - const OSSL_STORE_SEARCH *search - ) -{ - return 0; -} - -OSSL_STORE_INFO * -OSSL_STORE_load ( - OSSL_STORE_CTX *ctx - ) -{ - return NULL; -} - -const char * -OSSL_STORE_INFO_get0_NAME ( - const OSSL_STORE_INFO *info - ) -{ - return NULL; -} - -X509 * -OSSL_STORE_INFO_get0_CERT ( - const OSSL_STORE_INFO *info - ) -{ - return NULL; -} - -X509_CRL * -OSSL_STORE_INFO_get0_CRL ( - const OSSL_STORE_INFO *info - ) -{ - return NULL; -} - -int -OSSL_STORE_eof ( - OSSL_STORE_CTX *ctx - ) -{ - return 0; -} - -int -OSSL_STORE_error ( - OSSL_STORE_CTX *ctx - ) -{ - return 0; -} - -int -OSSL_STORE_close ( - OSSL_STORE_CTX *ctx - ) -{ - return 0; -} - -void -OSSL_STORE_INFO_free ( - OSSL_STORE_INFO *info - ) -{ -} - -OSSL_STORE_SEARCH * -OSSL_STORE_SEARCH_by_name ( - X509_NAME *name - ) -{ - return NULL; -} - -void -OSSL_STORE_SEARCH_free ( - OSSL_STORE_SEARCH *search - ) -{ -} - diff --git a/os_stub/spdm_device_secret_lib_tpm/CMakeLists.txt b/os_stub/spdm_device_secret_lib_tpm/CMakeLists.txt new file mode 100644 index 00000000000..9c82103bcb0 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/CMakeLists.txt @@ -0,0 +1,37 @@ +cmake_minimum_required(VERSION 3.5) + +add_library(spdm_device_secret_lib_tpm STATIC "") + +target_include_directories(spdm_device_secret_lib_tpm + PRIVATE + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_tpm + ${LIBSPDM_DIR}/include + ${LIBSPDM_DIR}/include/hal + ${LIBSPDM_DIR}/os_stub +) + +target_sources(spdm_device_secret_lib_tpm + PRIVATE + chal.c + meas.c + csr.c + ../spdm_device_secret_lib_sample/endpointinfo.c + ../spdm_device_secret_lib_sample/event.c + ../spdm_device_secret_lib_sample/key_pair.c + ../spdm_device_secret_lib_sample/psk.c + read_priv_key_pem.c + read_priv_key_pem_pqc.c + read_priv_key_raw_data.c + read_priv_key_raw_data_pqc.c + read_pub_cert.c + read_pub_cert_pqc.c + read_pub_key_der.c + read_pub_key_der_pqc.c + read_special_cert.c + set_cert.c + sign.c +) + +if ((ARCH STREQUAL "arm") OR (ARCH STREQUAL "aarch64")) + target_compile_options(spdm_device_secret_lib_tpm PRIVATE -DLIBSPDM_CPU_ARM) +endif() \ No newline at end of file diff --git a/os_stub/spdm_device_secret_lib_tpm/chal.c b/os_stub/spdm_device_secret_lib_tpm/chal.c new file mode 100644 index 00000000000..0becc6c1791 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/chal.c @@ -0,0 +1,91 @@ +/** + * Copyright Notice: + * Copyright 2024-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +#if LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP +size_t libspdm_secret_lib_challenge_opaque_data_size; +bool g_check_challenge_request_context = false; +uint64_t g_challenge_request_context; + +bool libspdm_challenge_opaque_data( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t slot_id, + size_t request_context_size, + const void *request_context, + void *opaque_data, + size_t *opaque_data_size) +{ + size_t index; + + LIBSPDM_ASSERT(libspdm_secret_lib_challenge_opaque_data_size <= *opaque_data_size); + + if (g_check_challenge_request_context) { + if ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_13) { + LIBSPDM_ASSERT(request_context_size == SPDM_REQ_CONTEXT_SIZE); + LIBSPDM_ASSERT(libspdm_read_uint64(request_context) == g_challenge_request_context); + } else { + LIBSPDM_ASSERT(request_context_size == 0); + LIBSPDM_ASSERT(request_context == NULL); + } + } + + *opaque_data_size = libspdm_secret_lib_challenge_opaque_data_size; + + for (index = 0; index < *opaque_data_size; index++) + { + ((uint8_t *)opaque_data)[index] = (uint8_t)index; + } + + return true; +} + +bool libspdm_encap_challenge_opaque_data( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t slot_id, + size_t request_context_size, + const void *request_context, + void *opaque_data, + size_t *opaque_data_size) +{ + size_t index; + + LIBSPDM_ASSERT(libspdm_secret_lib_challenge_opaque_data_size <= *opaque_data_size); + + if (g_check_challenge_request_context) { + if ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_13) { + LIBSPDM_ASSERT(request_context_size == SPDM_REQ_CONTEXT_SIZE); + LIBSPDM_ASSERT(libspdm_read_uint64(request_context) == g_challenge_request_context); + } else { + LIBSPDM_ASSERT(request_context_size == 0); + LIBSPDM_ASSERT(request_context == NULL); + } + } + + *opaque_data_size = libspdm_secret_lib_challenge_opaque_data_size; + + for (index = 0; index < *opaque_data_size; index++) + { + ((uint8_t *)opaque_data)[index] = (uint8_t)index; + } + + return true; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_CHAL_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/csr.c b/os_stub/spdm_device_secret_lib_tpm/csr.c new file mode 100644 index 00000000000..9af5cbf75aa --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/csr.c @@ -0,0 +1,373 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" +#include "library/cryptlib/cryptlib_tpm.h" + +#if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP +bool libspdm_read_cached_last_csr_request(uint8_t **last_csr_request, + size_t *last_csr_request_len, + uint8_t req_csr_tracking_tag, + uint8_t *available_rsp_csr_tracking_tag) +{ + bool res; + uint8_t index; + size_t file_size; + uint8_t *file_data; + + file_data = NULL; + *available_rsp_csr_tracking_tag = 0; + char file[] = "cached_last_csr_x_request"; + /*change the file name, for example: cached_last_csr_1_request*/ + file[16] = (char)(req_csr_tracking_tag + '0'); + res = libspdm_read_input_file(file, (void **)last_csr_request, last_csr_request_len); + + for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) { + file[16] = (char)(index + '0'); + libspdm_read_input_file(file, (void **)(&file_data), &file_size); + if (file_size == 0) { + *available_rsp_csr_tracking_tag |= (1 << index); + } else { + if (file_data != NULL) { + free(file_data); + } + } + } + + return res; +} + +bool libspdm_cache_last_csr_request(const uint8_t *last_csr_request, + size_t last_csr_request_len, + uint8_t req_csr_tracking_tag) +{ + bool res; + + char file[] = "cached_last_csr_x_request"; + /*change the file name, for example: cached_last_csr_1_request*/ + file[16] = (char)(req_csr_tracking_tag + '0'); + res = libspdm_write_output_file(file, last_csr_request, last_csr_request_len); + + return res; +} + +/*clean the cached last SPDM csr request*/ +bool libspdm_discard_all_cached_last_request() +{ + uint8_t index; + + char file[] = "cached_last_csr_x_request"; + + for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) { + file[16] = (char)(index + '0'); + if (!libspdm_write_output_file(file, NULL, 0)) { + return false; + } + } + + return true; +} + +/* + * return true represent that: the device complete the csr by reset successfully + * return false represent that: the device complete the csr need reset + **/ +bool libspdm_read_cached_csr(uint8_t **csr_pointer, size_t *csr_len) +{ + bool res; + char *file; + + file = "test_csr/cached.csr"; + + res = libspdm_read_input_file(file, (void **)csr_pointer, csr_len); + return res; +} + +bool libspdm_gen_csr_without_reset(uint32_t base_hash_algo, uint32_t base_asym_algo, + uint32_t pqc_asym_algo, + uint8_t *requester_info, size_t requester_info_length, + uint8_t *opaque_data, uint16_t opaque_data_length, + size_t *csr_len, uint8_t *csr_pointer, + bool is_device_cert_model) +{ + bool result; + size_t hash_nid; + size_t asym_nid; + void *context; + size_t csr_buffer_size; + + csr_buffer_size = *csr_len; + + void *cert_handle, *cert; + void *x509_ca_cert; + size_t cert_size; + + if (!libspdm_tpm_get_private_key("handle:0x81000003", &context)) { + return false; + } + + if (!libspdm_tpm_get_certificate("handle:0x1500023", &cert_handle)) { + return false; + } + + if (!libspdm_tpm_dump_certificate(cert_handle, &cert, &cert_size)) { + return false; + } + + if (!libspdm_x509_construct_certificate(cert, cert_size, (uint8_t**)&x509_ca_cert)) { + return false; + } + + hash_nid = libspdm_get_hash_nid(base_hash_algo); + asym_nid = libspdm_get_aysm_nid(base_asym_algo); + + char * subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; + + result = libspdm_gen_x509_csr(hash_nid, asym_nid, + requester_info, requester_info_length, !is_device_cert_model, + context, subject_name, csr_len, csr_pointer, x509_ca_cert); + + if (csr_buffer_size < *csr_len) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO,"csr buffer is too small to store generated csr! \n")); + result = false; + } + + return result; +} + +bool libspdm_gen_csr( + void *spdm_context, + uint32_t base_hash_algo, uint32_t base_asym_algo, bool *need_reset, + const void *request, size_t request_size, + uint8_t *requester_info, size_t requester_info_length, + uint8_t *opaque_data, uint16_t opaque_data_length, + size_t *csr_len, uint8_t *csr_pointer, + bool is_device_cert_model, + bool *is_busy, bool *unexpected_request) +{ + bool result; + uint8_t *cached_last_csr_request; + size_t cached_last_request_len; + uint8_t *cached_csr; + size_t csr_buffer_size; + uint8_t rsp_csr_tracking_tag; + + csr_buffer_size = *csr_len; + + /*device gen csr need reset*/ + if (*need_reset) { + result = libspdm_read_cached_last_csr_request(&cached_last_csr_request, + &cached_last_request_len, + 1, &rsp_csr_tracking_tag); + + /*get the cached last csr request and csr*/ + if ((result) && + (cached_last_request_len == request_size) && + (libspdm_consttime_is_mem_equal(cached_last_csr_request, request, + request_size)) && + (libspdm_read_cached_csr(&cached_csr, csr_len)) && + (*csr_len != 0)) { + + /*get and save cached csr*/ + if (csr_buffer_size < *csr_len) { + free(cached_csr); + free(cached_last_csr_request); + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "csr buffer is too small to store cached csr! \n")); + return false; + } else { + libspdm_copy_mem(csr_pointer, csr_buffer_size, cached_csr, *csr_len); + } + + /*device don't need reset this time*/ + *need_reset = false; + + free(cached_csr); + free(cached_last_csr_request); + return true; + } else { + if (cached_last_csr_request != NULL) { + free(cached_last_csr_request); + } + + /*device need reset this time: cache the last_csr_request */ + result = libspdm_cache_last_csr_request(request, request_size, 1); + if (!result) { + return result; + } + + /*device need reset this time*/ + *need_reset = true; + return true; + } + } else { + result = libspdm_gen_csr_without_reset(base_hash_algo, base_asym_algo, 0, + requester_info, requester_info_length, + opaque_data, opaque_data_length, + csr_len, csr_pointer, is_device_cert_model); + return result; + } + +} + +#if LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX +bool libspdm_gen_csr_ex( + void *spdm_context, + uint32_t base_hash_algo, uint32_t base_asym_algo, uint32_t pqc_asym_algo, + bool *need_reset, + const void *request, size_t request_size, + uint8_t *requester_info, size_t requester_info_length, + uint8_t *opaque_data, uint16_t opaque_data_length, + size_t *csr_len, uint8_t *csr_pointer, + uint8_t req_cert_model, + uint8_t *req_csr_tracking_tag, + uint8_t req_key_pair_id, + bool overwrite, + bool *is_busy, bool *unexpected_request) +{ + bool result; + uint8_t *cached_last_csr_request; + size_t cached_last_request_len; + uint8_t *cached_csr; + size_t csr_buffer_size; + uint8_t rsp_csr_tracking_tag; + uint8_t available_csr_tracking_tag; + uint8_t *request_change; + uint8_t index; + bool flag; + bool is_device_cert_model; + + available_csr_tracking_tag = 0; + csr_buffer_size = *csr_len; + + /*device gen csr need reset*/ + if (*need_reset) { + result = libspdm_read_cached_last_csr_request(&cached_last_csr_request, + &cached_last_request_len, + *req_csr_tracking_tag, + &rsp_csr_tracking_tag); + + for (index = 1; index <= SPDM_MAX_CSR_TRACKING_TAG; index++) { + if (((rsp_csr_tracking_tag >> index) & 0x01) == 0x01) { + available_csr_tracking_tag = index; + break; + } + } + + if (*req_csr_tracking_tag == 0) { + if (available_csr_tracking_tag == 0) { + /*no available tracking tag*/ + *is_busy = true; + return false; + } else { + flag = false; + } + } else { + /*matched csr_tracking_tag*/ + if (((rsp_csr_tracking_tag >> *req_csr_tracking_tag) & 0x01) == 0) { + flag = true; + } else { + /*unexpected*/ + return false; + } + } + + /*get the cached last csr request and csr*/ + if ((result) && + (cached_last_request_len == request_size) && + (libspdm_consttime_is_mem_equal(cached_last_csr_request, request, + request_size)) && + (libspdm_read_cached_csr(&cached_csr, csr_len)) && + (*csr_len != 0) && + (flag)) { + + /*get and save cached csr*/ + if (csr_buffer_size < *csr_len) { + free(cached_csr); + free(cached_last_csr_request); + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "csr buffer is too small to store cached csr! \n")); + return false; + } else { + libspdm_copy_mem(csr_pointer, csr_buffer_size, cached_csr, *csr_len); + } + + /*device don't need reset this time*/ + *need_reset = false; + + free(cached_csr); + free(cached_last_csr_request); + return true; + } else { + if (cached_last_csr_request != NULL) { + free(cached_last_csr_request); + } + + if ((*req_csr_tracking_tag == 0) && (available_csr_tracking_tag != 0)) { + request_change = malloc(request_size); + libspdm_copy_mem(request_change, request_size, request,request_size); + + if (overwrite) { + available_csr_tracking_tag = 1; + /*discard all previously generated CSRTrackingTags. */ + result = libspdm_discard_all_cached_last_request(); + if (!result) { + free(request_change); + return result; + } + } + + request_change[3] |= + (available_csr_tracking_tag << + SPDM_GET_CSR_REQUEST_ATTRIBUTES_CSR_TRACKING_TAG_OFFSET); + + /*device need reset this time: cache the last_csr_request */ + result = libspdm_cache_last_csr_request(request_change, + request_size, available_csr_tracking_tag); + if (!result) { + free(request_change); + return result; + } + + /*device need reset this time*/ + *need_reset = true; + *req_csr_tracking_tag = available_csr_tracking_tag; + free(request_change); + return true; + } else { + /*the device is busy*/ + *is_busy = true; + return false; + } + } + } else { + if (req_cert_model == SPDM_CERTIFICATE_INFO_CERT_MODEL_DEVICE_CERT) { + is_device_cert_model = true; + } else { + is_device_cert_model = false; + } + result = libspdm_gen_csr_without_reset(base_hash_algo, base_asym_algo, pqc_asym_algo, + requester_info, requester_info_length, + opaque_data, opaque_data_length, + csr_len, csr_pointer, is_device_cert_model); + return result; + } +} +#endif /*LIBSPDM_ENABLE_CAPABILITY_CSR_CAP_EX*/ + +#endif /* LIBSPDM_ENABLE_CAPABILITY_CSR_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/event.c b/os_stub/spdm_device_secret_lib_tpm/event.c new file mode 100644 index 00000000000..a8a37489e84 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/event.c @@ -0,0 +1,132 @@ +/** + * Copyright Notice: + * Copyright 2024-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +uint32_t g_supported_event_groups_list_len = 8; +uint8_t g_event_group_count = 1; +bool g_event_all_subscribe = false; +bool g_event_all_unsubscribe = false; +uint32_t g_event_count = 1; +bool g_generate_event_list_error = false; +bool g_event_get_types_error = false; +bool g_event_subscribe_error = false; + +#if LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP +bool libspdm_event_get_types( + void *spdm_context, + spdm_version_number_t spdm_version, + uint32_t session_id, + void *supported_event_groups_list, + uint32_t *supported_event_groups_list_len, + uint8_t *event_group_count) +{ + if (g_event_get_types_error) { + return false; + } + + *supported_event_groups_list_len = g_supported_event_groups_list_len; + + for (uint32_t index = 0; index < *supported_event_groups_list_len; index++) + { + ((char *)supported_event_groups_list)[index] = (char)index; + } + + *event_group_count = g_event_group_count; + + return true; +} + +bool libspdm_event_subscribe( + void *spdm_context, + spdm_version_number_t spdm_version, + uint32_t session_id, + uint8_t subscribe_type, + uint8_t subscribe_event_group_count, + uint32_t subscribe_list_len, + const void *subscribe_list) +{ + if (g_event_subscribe_error) { + return false; + } + + switch (subscribe_type) { + case LIBSPDM_EVENT_SUBSCRIBE_ALL: + if ((subscribe_list_len != 0) || (subscribe_list != NULL)) { + return false; + } + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "Subscribing to all events for session ID 0x%x.\n", session_id)); + g_event_all_subscribe = true; + g_event_all_unsubscribe = false; + return true; + case LIBSPDM_EVENT_SUBSCRIBE_NONE: + if ((subscribe_list_len != 0) || (subscribe_list != NULL)) { + return false; + } + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "Unsubscribing from all events for session ID 0x%x.\n", session_id)); + g_event_all_subscribe = false; + g_event_all_unsubscribe = true; + return true; + case LIBSPDM_EVENT_SUBSCRIBE_LIST: + if ((subscribe_list_len == 0) || (subscribe_list == NULL)) { + return false; + } + break; + default: + return false; + } + + g_event_all_subscribe = false; + g_event_all_unsubscribe = false; + + LIBSPDM_DEBUG((LIBSPDM_DEBUG_INFO, + "subscribe_event_group_count == %d, subscribe_list_len = %d\n", + subscribe_event_group_count, subscribe_list_len)); + + for (uint32_t index = 0; index < subscribe_list_len; index++) { + printf("%02x ", ((const char *)subscribe_list)[index]); + } + printf("\n"); + + return true; +} + +bool libspdm_generate_event_list( + void *spdm_context, + spdm_version_number_t spdm_version, + uint32_t session_id, + uint32_t *event_count, + size_t *events_list_size, + void *events_list) +{ + if (g_generate_event_list_error) { + return false; + } + + *event_count = g_event_count; + + for (uint32_t index = 0; index < *events_list_size; index++) + { + ((char *)events_list)[index] = (char)index; + } + + return true; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_EVENT_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/meas.c b/os_stub/spdm_device_secret_lib_tpm/meas.c new file mode 100644 index 00000000000..abbebad8a90 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/meas.c @@ -0,0 +1,801 @@ +/** + * Copyright Notice: + * Copyright 2024-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "hal/library/cryptlib/cryptlib_tpm.h" +#include "internal/libspdm_common_lib.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) + +#define LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE 0x1000 +uint8_t m_libspdm_mel[LIBSPDM_MAX_MEASUREMENT_EXTENSION_LOG_SIZE]; + +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) */ + +#if (LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP) +void libspdm_generate_mel(uint32_t measurement_hash_algo) +{ + spdm_measurement_extension_log_dmtf_t *measurement_extension_log; + spdm_mel_entry_dmtf_t *mel_entry1; + spdm_mel_entry_dmtf_t *mel_entry2; + spdm_mel_entry_dmtf_t *mel_entry3; + + uint8_t rom_informational[] = "ROM"; + uint8_t bootfv_informational[] = "Boot FW"; + uint32_t version = 0x0100030A; + + /*generate MEL*/ + measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + + measurement_extension_log->number_of_entries = 3; + measurement_extension_log->mel_entries_len = + measurement_extension_log->number_of_entries * sizeof(spdm_mel_entry_dmtf_t) + + sizeof(rom_informational) - 1 + sizeof(bootfv_informational) - 1 + sizeof(version); + measurement_extension_log->reserved = 0; + + /*MEL Entry 1: informational ROM */ + mel_entry1 = (spdm_mel_entry_dmtf_t *)((uint8_t *)measurement_extension_log + + sizeof(spdm_measurement_extension_log_dmtf_t)); + mel_entry1->mel_index = 1; + mel_entry1->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM; + libspdm_write_uint24(mel_entry1->reserved, 0); + mel_entry1->measurement_block_dmtf_header.dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_INFORMATIONAL | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + mel_entry1->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = + sizeof(rom_informational) - 1; + libspdm_copy_mem((void *)(mel_entry1 + 1), sizeof(rom_informational) - 1, + rom_informational, sizeof(rom_informational) - 1); + + /*MEL Entry 2: informational Boot FW */ + mel_entry2 = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry1 + 1) + + sizeof(rom_informational) - 1); + mel_entry2->mel_index = 2; + mel_entry2->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM; + libspdm_write_uint24(mel_entry2->reserved, 0); + mel_entry2->measurement_block_dmtf_header.dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_INFORMATIONAL | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + mel_entry2->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = + sizeof(bootfv_informational) - 1; + libspdm_copy_mem((void *)(mel_entry2 + 1), sizeof(bootfv_informational) - 1, + bootfv_informational, sizeof(bootfv_informational) - 1); + + /*MEL Entry 3: version 0x0100030A */ + mel_entry3 = (spdm_mel_entry_dmtf_t *)((uint8_t *)(mel_entry2 + 1) + + sizeof(bootfv_informational) - 1); + mel_entry3->mel_index = 3; + mel_entry3->meas_index = LIBSPDM_MEASUREMENT_INDEX_HEM; + libspdm_write_uint24(mel_entry3->reserved, 0); + mel_entry3->measurement_block_dmtf_header.dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_VERSION | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + mel_entry3->measurement_block_dmtf_header.dmtf_spec_measurement_value_size = sizeof(version); + libspdm_copy_mem((void *)(mel_entry3 + 1), sizeof(version), &version, sizeof(version)); +} +#endif /*(LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP) || (LIBSPDM_ENABLE_CAPABILITY_MEL_CAP)*/ + +#if LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP +/** + * Fill image hash measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_image_hash_block ( + bool use_bit_stream, + uint32_t measurement_hash_algo, + uint8_t measurements_index, + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + size_t hash_size; + void *buffer = NULL; + size_t buffer_size = 0; + + hash_size = libspdm_get_measurement_hash_size(measurement_hash_algo); + + if (use_bit_stream) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "use_bit_stream for image_hash_block for TMP device is not supported")); + return 0; + } + + measurement_block->measurement_block_common_header + .index = measurements_index; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + (measurements_index - 1); + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)hash_size; + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)hash_size); + + buffer = (uint8_t*)(measurement_block + 1); + buffer_size = 0; + if (!libspdm_tpm_read_pcr(measurement_hash_algo, measurements_index, buffer, &buffer_size)) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "failed to read pcr from TPM")); + return 0; + } + + if (buffer_size != hash_size) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "hash_size (%d) != buffer_size (%d)\n", hash_size, buffer_size)); + return 0; + } + + return sizeof(spdm_measurement_block_dmtf_t) + hash_size; +} + +/** + * Fill svn measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_svn_block ( + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + spdm_measurements_secure_version_number_t svn; + + measurement_block->measurement_block_common_header + .index = LIBSPDM_MEASUREMENT_INDEX_SVN; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + svn = 0x7; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_SECURE_VERSION_NUMBER | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)sizeof(svn); + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)sizeof(svn)); + + libspdm_copy_mem((void *)(measurement_block + 1), sizeof(svn), (void *)&svn, sizeof(svn)); + + return sizeof(spdm_measurement_block_dmtf_t) + sizeof(svn); +} + +/** + * Fill HEM measurement block. + * + * @param measurement_block A pointer to store measurement block. + * @param measurement_hash_algo Indicates the measurement hash algorithm. + * It must align with measurement_hash_alg + * (SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_*) + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_hem_block ( + spdm_measurement_block_dmtf_t *measurement_block, uint32_t measurement_hash_algo + ) +{ + size_t hash_size; + spdm_measurement_extension_log_dmtf_t *measurement_extension_log; + spdm_mel_entry_dmtf_t *mel_entry; + uint32_t index; + uint8_t *verify_hem; + + if (measurement_hash_algo == SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_RAW_BIT_STREAM_ONLY) { + return 0; + } + + libspdm_generate_mel(measurement_hash_algo); + + hash_size = libspdm_get_measurement_hash_size(measurement_hash_algo); + if (measurement_block == NULL) { + return sizeof(spdm_measurement_block_dmtf_t) + hash_size; + } + + /*MEL*/ + measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + + /*generate measurement block*/ + measurement_block->measurement_block_common_header + .index = LIBSPDM_MEASUREMENT_INDEX_HEM; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_HASH_EXTEND_MEASUREMENT; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)hash_size; + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)hash_size); + + verify_hem = malloc(measurement_extension_log->mel_entries_len + hash_size); + if (verify_hem == NULL) { + return 0; + } + + libspdm_zero_mem(verify_hem, measurement_extension_log->mel_entries_len + hash_size); + mel_entry = (spdm_mel_entry_dmtf_t *)((uint8_t *)measurement_extension_log + + sizeof(spdm_measurement_extension_log_dmtf_t)); + for (index = 0; index < measurement_extension_log->number_of_entries; index++) { + libspdm_copy_mem( + verify_hem + hash_size, + measurement_extension_log->mel_entries_len, + mel_entry, + sizeof(spdm_mel_entry_dmtf_t) + + mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size); + + if (!libspdm_measurement_hash_all( + measurement_hash_algo, + verify_hem, + hash_size + sizeof(spdm_mel_entry_dmtf_t) + + mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size, + verify_hem + )) { + free(verify_hem); + return 0; + } + mel_entry = (spdm_mel_entry_dmtf_t *) + ((uint8_t *)mel_entry + sizeof(spdm_mel_entry_dmtf_t)+ + mel_entry->measurement_block_dmtf_header.dmtf_spec_measurement_value_size); + } + + libspdm_copy_mem((void *)(measurement_block + 1), hash_size, verify_hem, hash_size); + free(verify_hem); + return sizeof(spdm_measurement_block_dmtf_t) + hash_size; +} + +/** + * Fill manifest measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_manifest_block ( + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + uint8_t data[LIBSPDM_MEASUREMENT_MANIFEST_SIZE]; + + measurement_block->measurement_block_common_header + .index = SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_MEASUREMENT_MANIFEST; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + libspdm_set_mem(data, sizeof(data), + (uint8_t)SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_MEASUREMENT_MANIFEST); + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_MEASUREMENT_MANIFEST | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)sizeof(data); + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)sizeof(data)); + + libspdm_copy_mem((void *)(measurement_block + 1), sizeof(data), data, sizeof(data)); + + return sizeof(spdm_measurement_block_dmtf_t) + sizeof(data); +} + +/** + * Fill device mode measurement block. + * + * @return measurement block size. + **/ +size_t libspdm_fill_measurement_device_mode_block ( + spdm_measurement_block_dmtf_t *measurement_block + ) +{ + spdm_measurements_device_mode_t device_mode; + + measurement_block->measurement_block_common_header + .index = SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_DEVICE_MODE; + measurement_block->measurement_block_common_header + .measurement_specification = + SPDM_MEASUREMENT_SPECIFICATION_DMTF; + + device_mode.operational_mode_capabilities = + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_MANUFACTURING_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_VALIDATION_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_NORMAL_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_RECOVERY_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_RMA_MODE | + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_DECOMMISSIONED_MODE; + device_mode.operational_mode_state = + SPDM_MEASUREMENT_DEVICE_OPERATION_MODE_NORMAL_MODE; + device_mode.device_mode_capabilities = + SPDM_MEASUREMENT_DEVICE_MODE_NON_INVASIVE_DEBUG_MODE_IS_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_IS_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_NON_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE_AFTER_MFG; + device_mode.device_mode_state = + SPDM_MEASUREMENT_DEVICE_MODE_NON_INVASIVE_DEBUG_MODE_IS_ACTIVE | + SPDM_MEASUREMENT_DEVICE_MODE_INVASIVE_DEBUG_MODE_HAS_BEEN_ACTIVE_AFTER_MFG; + + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type = + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_DEVICE_MODE | + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_RAW_BIT_STREAM; + measurement_block->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size = + (uint16_t)sizeof(device_mode); + + measurement_block->measurement_block_common_header + .measurement_size = + (uint16_t)(sizeof(spdm_measurement_block_dmtf_header_t) + + (uint16_t)sizeof(device_mode)); + + libspdm_copy_mem((void *)(measurement_block + 1), sizeof(device_mode), + (void *)&device_mode, sizeof(device_mode)); + + return sizeof(spdm_measurement_block_dmtf_t) + sizeof(device_mode); +} + +bool g_check_measurement_request_context = false; +uint64_t g_measurement_request_context; + +libspdm_return_t libspdm_measurement_collection( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t measurement_specification, + uint32_t measurement_hash_algo, + uint8_t measurements_index, + uint8_t request_attribute, + size_t request_context_size, + const void *request_context, + uint8_t *content_changed, + uint8_t *measurements_count, + void *measurements, + size_t *measurements_size) +{ + spdm_measurement_block_dmtf_t *measurement_block; + size_t hash_size; + uint8_t index; + size_t total_size_needed; + bool use_bit_stream; + size_t measurement_block_size; + + if ((measurement_specification != SPDM_MEASUREMENT_SPECIFICATION_DMTF) || + (measurement_hash_algo == 0)) { + return LIBSPDM_STATUS_UNSUPPORTED_CAP; + } + + if (g_check_measurement_request_context) { + if ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_13) { + LIBSPDM_ASSERT(request_context_size == SPDM_REQ_CONTEXT_SIZE); + LIBSPDM_ASSERT(libspdm_read_uint64(request_context) == g_measurement_request_context); + } else { + LIBSPDM_ASSERT(request_context_size == 0); + LIBSPDM_ASSERT(request_context == NULL); + } + } + + hash_size = libspdm_get_measurement_hash_size(measurement_hash_algo); + LIBSPDM_ASSERT(hash_size != 0); + + use_bit_stream = false; + if ((measurement_hash_algo == SPDM_ALGORITHMS_MEASUREMENT_HASH_ALGO_RAW_BIT_STREAM_ONLY) || + ((request_attribute & SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_RAW_BIT_STREAM_REQUESTED) != + 0)) { + use_bit_stream = true; + } + + if (measurements_index == + SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_TOTAL_NUMBER_OF_MEASUREMENTS) { + *measurements_count = LIBSPDM_MEASUREMENT_BLOCK_NUMBER; + goto successful_return; + } else if (measurements_index == + SPDM_GET_MEASUREMENTS_REQUEST_MEASUREMENT_OPERATION_ALL_MEASUREMENTS) { + + /* Calculate total_size_needed based on hash algo selected. + * If we have an hash algo, then the first HASH_NUMBER elements will be + * hash values, otherwise HASH_NUMBER raw bitstream values.*/ + if (!use_bit_stream) { + total_size_needed = + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER * + (sizeof(spdm_measurement_block_dmtf_t) + hash_size); + } else { + total_size_needed = + LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER * + (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_RAW_DATA_SIZE); + } + /* Next one - SVN is always raw bitstream data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + + sizeof(spdm_measurements_secure_version_number_t)); + /* Next one - HEM is always digest data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + hash_size); + /* Next one - manifest is always raw bitstream data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + LIBSPDM_MEASUREMENT_MANIFEST_SIZE); + /* Next one - device_mode is always raw bitstream data.*/ + total_size_needed += + (sizeof(spdm_measurement_block_dmtf_t) + sizeof(spdm_measurements_device_mode_t)); + + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_size = total_size_needed; + *measurements_count = LIBSPDM_MEASUREMENT_BLOCK_NUMBER; + measurement_block = measurements; + + /* The first HASH_NUMBER blocks may be hash values or raw bitstream*/ + for (index = 1; index <= LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER; index++) { + measurement_block_size = libspdm_fill_measurement_image_hash_block (use_bit_stream, + measurement_hash_algo, + index, + measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - SVN is always raw bitstream data.*/ + { + measurement_block_size = libspdm_fill_measurement_svn_block (measurement_block); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - HEM is always digest data.*/ + { + measurement_block_size = libspdm_fill_measurement_hem_block (measurement_block, + measurement_hash_algo); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - manifest is always raw bitstream data.*/ + { + measurement_block_size = libspdm_fill_measurement_manifest_block (measurement_block); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + /* Next one - device_mode is always raw bitstream data.*/ + { + measurement_block_size = libspdm_fill_measurement_device_mode_block (measurement_block); + measurement_block = (void *)((uint8_t *)measurement_block + measurement_block_size); + } + + goto successful_return; + } else { + /* One Index */ + if (measurements_index <= LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER) { + if (!use_bit_stream) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + hash_size; + } else { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + LIBSPDM_MEASUREMENT_RAW_DATA_SIZE; + } + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_image_hash_block (use_bit_stream, + measurement_hash_algo, + measurements_index, + measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == LIBSPDM_MEASUREMENT_INDEX_SVN) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + sizeof(spdm_measurements_secure_version_number_t); + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_svn_block (measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == LIBSPDM_MEASUREMENT_INDEX_HEM) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + hash_size; + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_hem_block (measurement_block, + measurement_hash_algo); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_MEASUREMENT_MANIFEST) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + LIBSPDM_MEASUREMENT_MANIFEST_SIZE; + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_manifest_block (measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else if (measurements_index == SPDM_MEASUREMENT_BLOCK_MEASUREMENT_INDEX_DEVICE_MODE) { + total_size_needed = + sizeof(spdm_measurement_block_dmtf_t) + + sizeof(spdm_measurements_device_mode_t); + LIBSPDM_ASSERT(total_size_needed <= *measurements_size); + if (total_size_needed > *measurements_size) { + return LIBSPDM_STATUS_BUFFER_TOO_SMALL; + } + + *measurements_count = 1; + *measurements_size = total_size_needed; + + measurement_block = measurements; + measurement_block_size = libspdm_fill_measurement_device_mode_block (measurement_block); + if (measurement_block_size == 0) { + return LIBSPDM_STATUS_MEAS_INTERNAL_ERROR; + } + } else { + *measurements_count = 0; + return LIBSPDM_STATUS_MEAS_INVALID_INDEX; + } + } + +successful_return: + if ((content_changed != NULL) && + ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_12)) { + /* return content change*/ + if ((request_attribute & SPDM_GET_MEASUREMENTS_REQUEST_ATTRIBUTES_GENERATE_SIGNATURE) != + 0) { + *content_changed = SPDM_MEASUREMENTS_RESPONSE_CONTENT_NO_CHANGE_DETECTED; + } else { + *content_changed = SPDM_MEASUREMENTS_RESPONSE_CONTENT_CHANGE_NO_DETECTION; + } + } + + return LIBSPDM_STATUS_SUCCESS; +} + +size_t libspdm_secret_lib_meas_opaque_data_size; + +bool libspdm_measurement_opaque_data( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t measurement_specification, + uint32_t measurement_hash_algo, + uint8_t measurement_index, + uint8_t request_attribute, + size_t request_context_size, + const void *request_context, + void *opaque_data, + size_t *opaque_data_size) +{ + size_t index; + + LIBSPDM_ASSERT(libspdm_secret_lib_meas_opaque_data_size <= *opaque_data_size); + + if (g_check_measurement_request_context) { + if ((spdm_version >> SPDM_VERSION_NUMBER_SHIFT_BIT) >= SPDM_MESSAGE_VERSION_13) { + LIBSPDM_ASSERT(request_context_size == SPDM_REQ_CONTEXT_SIZE); + LIBSPDM_ASSERT(libspdm_read_uint64(request_context) == g_measurement_request_context); + } else { + LIBSPDM_ASSERT(request_context_size == 0); + LIBSPDM_ASSERT(request_context == NULL); + } + } + + *opaque_data_size = libspdm_secret_lib_meas_opaque_data_size; + + for (index = 0; index < *opaque_data_size; index++) + { + ((uint8_t *)opaque_data)[index] = (uint8_t)index; + } + + return true; +} + +bool libspdm_generate_measurement_summary_hash( + void *spdm_context, + spdm_version_number_t spdm_version, uint32_t base_hash_algo, + uint8_t measurement_specification, uint32_t measurement_hash_algo, + uint8_t measurement_summary_hash_type, + uint8_t *measurement_summary_hash, + uint32_t measurement_summary_hash_size) +{ + uint8_t measurement_data[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE]; + size_t index; + spdm_measurement_block_dmtf_t *cached_measurement_block; + size_t measurement_data_size; + size_t measurement_block_size; + uint8_t device_measurement[LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE]; + uint8_t device_measurement_count; + size_t device_measurement_size; + libspdm_return_t status; + bool result; + + switch (measurement_summary_hash_type) { + case SPDM_REQUEST_NO_MEASUREMENT_SUMMARY_HASH: + return false; + + case SPDM_REQUEST_TCB_COMPONENT_MEASUREMENT_HASH: + case SPDM_REQUEST_ALL_MEASUREMENTS_HASH: + if (measurement_summary_hash_size != libspdm_get_hash_size(base_hash_algo)) { + return false; + } + + /* get all measurement data*/ + device_measurement_size = sizeof(device_measurement); + status = libspdm_measurement_collection( + spdm_context, + spdm_version, measurement_specification, + measurement_hash_algo, + 0xFF, /* Get all measurements*/ + 0, + 0, + NULL, + NULL, + &device_measurement_count, device_measurement, + &device_measurement_size); + if (LIBSPDM_STATUS_IS_ERROR(status)) { + return false; + } + + /* double confirm that MeasurementData internal size is correct*/ + measurement_data_size = 0; + cached_measurement_block = (void *)device_measurement; + for (index = 0; index < device_measurement_count; index++) { + measurement_block_size = + sizeof(spdm_measurement_block_common_header_t) + + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + LIBSPDM_ASSERT(cached_measurement_block + ->measurement_block_common_header + .measurement_size == + sizeof(spdm_measurement_block_dmtf_header_t) + + cached_measurement_block + ->measurement_block_dmtf_header + .dmtf_spec_measurement_value_size); + measurement_data_size += + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + cached_measurement_block = + (void *)((size_t)cached_measurement_block + + measurement_block_size); + } + + LIBSPDM_ASSERT(measurement_data_size <= + LIBSPDM_MAX_MEASUREMENT_RECORD_SIZE); + + /* get required data and hash them*/ + cached_measurement_block = (void *)device_measurement; + measurement_data_size = 0; + for (index = 0; index < device_measurement_count; index++) { + measurement_block_size = + sizeof(spdm_measurement_block_common_header_t) + + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + /* filter unneeded data*/ + if ((measurement_summary_hash_type == + SPDM_REQUEST_ALL_MEASUREMENTS_HASH) || + ((cached_measurement_block + ->measurement_block_dmtf_header + .dmtf_spec_measurement_value_type & + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_MASK) == + SPDM_MEASUREMENT_BLOCK_MEASUREMENT_TYPE_IMMUTABLE_ROM)) { + libspdm_copy_mem(&measurement_data[measurement_data_size], + sizeof(measurement_data) + - (&measurement_data[measurement_data_size] - measurement_data), + cached_measurement_block, + sizeof(cached_measurement_block-> + measurement_block_common_header) + + cached_measurement_block->measurement_block_common_header + .measurement_size); + measurement_data_size += + sizeof(cached_measurement_block->measurement_block_common_header) + + cached_measurement_block + ->measurement_block_common_header + .measurement_size; + } + cached_measurement_block = + (void *)((size_t)cached_measurement_block + + measurement_block_size); + } + + result = libspdm_hash_all(base_hash_algo, measurement_data, + measurement_data_size, measurement_summary_hash); + if (!result) { + return false; + } + break; + default: + return false; + break; + } + return true; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_MEAS_CAP */ + +#if LIBSPDM_ENABLE_CAPABILITY_MEL_CAP +/*Collect the measurement extension log.*/ +bool libspdm_measurement_extension_log_collection( + void *spdm_context, + uint8_t mel_specification, + uint8_t measurement_specification, + uint32_t measurement_hash_algo, + void **spdm_mel, + size_t *spdm_mel_size) +{ + spdm_measurement_extension_log_dmtf_t *measurement_extension_log; + + if ((measurement_specification != + SPDM_MEASUREMENT_SPECIFICATION_DMTF) || + (mel_specification != SPDM_MEL_SPECIFICATION_DMTF) || + (measurement_hash_algo == 0)) { + return false; + } + + libspdm_generate_mel(measurement_hash_algo); + + measurement_extension_log = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + *spdm_mel = (spdm_measurement_extension_log_dmtf_t *)m_libspdm_mel; + *spdm_mel_size = (size_t)(measurement_extension_log->mel_entries_len) + + sizeof(spdm_measurement_extension_log_dmtf_t); + return true; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_MEL_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/raw_data_key.h b/os_stub/spdm_device_secret_lib_tpm/raw_data_key.h new file mode 100644 index 00000000000..376347185e4 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/raw_data_key.h @@ -0,0 +1,442 @@ +/** + * Copyright Notice: + * Copyright 2021-2022 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +/*automatic generated by raw_data_key_gen.py*/ + +#ifndef RAW_DATA_KEY_H +#define RAW_DATA_KEY_H + +#include "spdm_device_secret_lib_internal.h" + +#if LIBSPDM_ECDSA_SUPPORT +#define LIBSPDM_EC256_RESPONDER_PRIVATE_KEY { \ + 0xad, 0x7c, 0x3a, 0x3a, 0xea, 0x46, 0xe0, 0xc1, 0x4d, 0x69, 0xb8, 0xd5, 0x6f, 0x86, 0x23, \ + 0xcc, 0x37, 0xb5, 0x61, 0xb6, 0x8c, 0xa4, 0x48, 0x62, 0x32, 0xa3, 0x90, 0x0e, 0x77, 0x80, \ + 0x3d, 0x8a,} +#define LIBSPDM_EC256_RESPONDER_PUBLIC_KEY { \ + 0x0d, 0xf4, 0x6e, 0x4d, 0x65, 0xfa, 0x52, 0xfe, 0xce, 0xb0, 0xbd, 0xa0, 0x59, 0x40, 0x49, \ + 0xa0, 0x7b, 0x8d, 0x67, 0xfc, 0x61, 0x91, 0xae, 0x7e, 0x7a, 0xa5, 0x60, 0x93, 0x78, 0x97, \ + 0xe2, 0xab, 0x42, 0x90, 0x28, 0xca, 0x3e, 0x72, 0x51, 0x1e, 0x6d, 0xd7, 0x1b, 0xeb, 0x1a, \ + 0x13, 0x11, 0xa5, 0x1d, 0x36, 0x4f, 0x27, 0xdf, 0x80, 0x66, 0x96, 0x41, 0x73, 0xea, 0x51, \ + 0xdd, 0x54, 0xf9, 0x95,} + +#define LIBSPDM_EC384_RESPONDER_PRIVATE_KEY { \ + 0xbd, 0x85, 0x02, 0x54, 0x11, 0x46, 0xec, 0x9e, 0x53, 0xca, 0x2a, 0x0c, 0x74, 0x0a, 0xdc, \ + 0xd8, 0x5d, 0xa0, 0x55, 0xbb, 0x81, 0x48, 0xf8, 0x2d, 0xfe, 0x9a, 0x32, 0x82, 0x6c, 0xe4, \ + 0x68, 0xb9, 0x3c, 0x76, 0xd6, 0xc3, 0x4a, 0x65, 0x4c, 0x98, 0x60, 0x91, 0x9b, 0xbd, 0x91, \ + 0x96, 0x97, 0x06,} +#define LIBSPDM_EC384_RESPONDER_PUBLIC_KEY { \ + 0x0d, 0x1c, 0xb9, 0x20, 0x1c, 0xdc, 0xed, 0xc8, 0x64, 0xe9, 0x70, 0xa3, 0x62, 0x12, 0xda, \ + 0xd4, 0xfe, 0x59, 0x94, 0xce, 0xbd, 0xae, 0xd7, 0xd2, 0x94, 0xe4, 0xe3, 0x11, 0x88, 0x78, \ + 0xb9, 0x88, 0xc0, 0xed, 0x5b, 0xe1, 0x41, 0x4a, 0xdf, 0x28, 0xdb, 0x49, 0x0f, 0x38, 0x81, \ + 0x52, 0x68, 0xb5, 0x4c, 0x6a, 0x11, 0x0b, 0x58, 0xb1, 0x9c, 0xc1, 0x4d, 0x47, 0x41, 0x14, \ + 0x1f, 0x6d, 0xd6, 0x57, 0xac, 0xa3, 0x9f, 0xd1, 0xb9, 0x64, 0xde, 0x07, 0x11, 0xe8, 0x31, \ + 0x78, 0xde, 0x75, 0x3a, 0xb7, 0x2c, 0x15, 0x56, 0xea, 0xf5, 0x20, 0x63, 0x93, 0x0f, 0x33, \ + 0xa9, 0x71, 0xa3, 0x7e, 0x78, 0x19,} + +#define LIBSPDM_EC521_RESPONDER_PRIVATE_KEY { \ + 0x01, 0x2a, 0x61, 0x6e, 0x4a, 0x21, 0xf5, 0x2a, 0x65, 0x6e, 0x2a, 0x82, 0x38, 0x77, 0xd1, \ + 0x5e, 0x09, 0x49, 0x84, 0x32, 0x3c, 0x3a, 0x55, 0xb1, 0xcd, 0x25, 0x47, 0xa3, 0x8a, 0xdb, \ + 0x3a, 0x8a, 0x56, 0x7b, 0x69, 0x1d, 0xca, 0x15, 0xbe, 0x26, 0xc7, 0xad, 0x42, 0xab, 0xf5, \ + 0x61, 0x1c, 0x05, 0xd9, 0x51, 0xa0, 0x14, 0x4f, 0xaf, 0xae, 0x25, 0xd6, 0x96, 0x7c, 0xb5, \ + 0x53, 0x27, 0xb0, 0xf8, 0x23, 0x13,} +#define LIBSPDM_EC521_RESPONDER_PUBLIC_KEY { \ + 0x00, 0xab, 0xc8, 0xcc, 0x17, 0x86, 0x1c, 0x4a, 0x9e, 0xe4, 0xd9, 0x7a, 0x53, 0x62, 0xeb, \ + 0xbf, 0xb8, 0x35, 0xfc, 0x15, 0x04, 0xa1, 0x5a, 0xa2, 0x36, 0x5c, 0x1c, 0xda, 0xcb, 0x1d, \ + 0x92, 0x78, 0x17, 0x37, 0xa5, 0x16, 0xf5, 0x8e, 0x58, 0x69, 0x25, 0x27, 0x89, 0xd5, 0xb6, \ + 0x12, 0x09, 0xc8, 0x43, 0x09, 0x44, 0x82, 0xb3, 0x40, 0x1a, 0x19, 0xa9, 0xc0, 0x35, 0xdf, \ + 0x06, 0xc8, 0x68, 0xd6, 0x95, 0x0d, 0x01, 0xcb, 0xd3, 0x70, 0xfa, 0x8b, 0x5d, 0xe8, 0xcb, \ + 0xb5, 0x0d, 0xab, 0xee, 0x2b, 0xd6, 0x93, 0x7d, 0xdf, 0x05, 0xa5, 0x47, 0xbf, 0xde, 0x6f, \ + 0x3b, 0x92, 0x23, 0xaf, 0xed, 0x7a, 0x9d, 0x3a, 0x72, 0x2c, 0x2d, 0xdb, 0xba, 0x84, 0x66, \ + 0x34, 0x99, 0xaa, 0x61, 0xf5, 0xfc, 0x16, 0x92, 0x65, 0x2a, 0xe5, 0x11, 0x42, 0xb8, 0x6b, \ + 0x28, 0xf9, 0x9e, 0x89, 0xd0, 0x4a, 0xa6, 0x3c, 0x1c, 0x45, 0xb4, 0x7a,} + +#define LIBSPDM_EC256_REQUESTER_PRIVATE_KEY { \ + 0x31, 0x51, 0x10, 0x95, 0xaf, 0xc3, 0xef, 0xf7, 0x74, 0xe0, 0xfa, 0x1a, 0x24, 0xf6, 0xda, \ + 0x48, 0xf8, 0x6d, 0x86, 0x3e, 0xcb, 0x06, 0xef, 0xd3, 0xda, 0x32, 0x81, 0xa3, 0xed, 0xf5, \ + 0x2e, 0x42,} +#define LIBSPDM_EC256_REQUESTER_PUBLIC_KEY { \ + 0xea, 0x85, 0xba, 0x33, 0x6f, 0x68, 0xd7, 0x6c, 0x8c, 0xd3, 0xcf, 0xf1, 0x3b, 0x0f, 0x3c, \ + 0x55, 0x26, 0x70, 0x28, 0xc2, 0x8f, 0x1b, 0x90, 0x42, 0x7e, 0x2d, 0x31, 0x61, 0x28, 0x71, \ + 0x40, 0x37, 0x12, 0x64, 0x43, 0x3c, 0xe8, 0xd5, 0xcd, 0xdf, 0xa3, 0x16, 0xec, 0x27, 0x33, \ + 0x19, 0xdb, 0xf8, 0xd6, 0xb9, 0x96, 0x80, 0xfa, 0x10, 0xe4, 0x59, 0x8a, 0x6d, 0xa6, 0x32, \ + 0xf4, 0xe8, 0xca, 0x17,} + +#define LIBSPDM_EC384_REQUESTER_PRIVATE_KEY { \ + 0x8b, 0x52, 0x08, 0xf9, 0x3b, 0x09, 0x9f, 0x96, 0x6f, 0x33, 0xf3, 0x52, 0x99, 0xdb, 0x2a, \ + 0x32, 0xf1, 0x42, 0x12, 0xc9, 0xf4, 0x72, 0x48, 0x77, 0xc3, 0x7f, 0x5c, 0x33, 0xed, 0x71, \ + 0x66, 0xde, 0x49, 0xd3, 0xa1, 0xbf, 0xfb, 0xc8, 0x25, 0xd3, 0xde, 0x3d, 0x14, 0x4c, 0x18, \ + 0xbe, 0xf1, 0x22,} +#define LIBSPDM_EC384_REQUESTER_PUBLIC_KEY { \ + 0x3d, 0xad, 0x90, 0xd6, 0xba, 0x44, 0xb0, 0x79, 0xe6, 0xdf, 0xc9, 0x28, 0x3b, 0x6e, 0xb0, \ + 0xb6, 0xc0, 0x85, 0x81, 0xfc, 0x0a, 0xb3, 0xa6, 0x1a, 0x5a, 0x01, 0x49, 0x2e, 0x71, 0x19, \ + 0xba, 0xfc, 0x57, 0x23, 0x0b, 0xd1, 0x5f, 0xa2, 0xd5, 0x55, 0x5d, 0xa1, 0x73, 0xd0, 0xf7, \ + 0xbc, 0x4c, 0x59, 0xba, 0xf2, 0xaa, 0x86, 0xe6, 0xb0, 0x0f, 0xba, 0x31, 0x1a, 0x0b, 0x38, \ + 0x97, 0x15, 0xe6, 0x29, 0x9b, 0x7b, 0x27, 0x1f, 0x88, 0xe9, 0x76, 0xa9, 0xa5, 0x45, 0x7f, \ + 0xfb, 0x47, 0x1c, 0xc0, 0xe1, 0xde, 0x21, 0xa4, 0x9c, 0x58, 0x42, 0xf9, 0xcf, 0xae, 0xdf, \ + 0x6c, 0x0d, 0x9d, 0xef, 0xcc, 0x87,} + +#define LIBSPDM_EC521_REQUESTER_PRIVATE_KEY { \ + 0x00, 0x78, 0xd9, 0xfe, 0xfd, 0x98, 0x7a, 0x47, 0x5a, 0x00, 0x84, 0x69, 0xd6, 0x5b, 0x85, \ + 0x67, 0x0d, 0xdc, 0x0b, 0x6a, 0x2a, 0x2d, 0x35, 0x01, 0x39, 0xff, 0x33, 0xd4, 0x83, 0x9d, \ + 0x1d, 0x69, 0x29, 0xc1, 0x73, 0x84, 0xa1, 0xb7, 0x1e, 0x35, 0x15, 0x10, 0x69, 0xbb, 0xf8, \ + 0xc5, 0xdd, 0xd9, 0x2f, 0xaf, 0xff, 0x6a, 0x04, 0x94, 0x6e, 0x69, 0xe9, 0x0c, 0x4c, 0x2c, \ + 0x37, 0x52, 0x4a, 0xb6, 0x73, 0xf1,} +#define LIBSPDM_EC521_REQUESTER_PUBLIC_KEY { \ + 0x00, 0xf3, 0x27, 0x0a, 0x26, 0x57, 0x09, 0x3c, 0xa0, 0xe2, 0xfe, 0xd1, 0x1d, 0x85, 0x63, \ + 0xd7, 0x3d, 0x45, 0xfa, 0xb6, 0x47, 0xf0, 0xf0, 0x0f, 0x83, 0xdf, 0x03, 0x65, 0xd0, 0x82, \ + 0x30, 0x89, 0x69, 0xbe, 0x41, 0xcd, 0xbb, 0xa2, 0xf0, 0x78, 0xfd, 0x2f, 0xb7, 0x82, 0xab, \ + 0x5c, 0x0f, 0xa2, 0x14, 0x34, 0x09, 0x79, 0x26, 0xfc, 0x96, 0x6d, 0x4a, 0xf6, 0x1d, 0xb1, \ + 0x40, 0x40, 0xe1, 0x40, 0xc5, 0xdd, 0x00, 0x95, 0xa5, 0xc8, 0x65, 0x21, 0x55, 0xe8, 0xb9, \ + 0xba, 0xa7, 0xa3, 0xf4, 0x1d, 0xee, 0x20, 0xcf, 0x2c, 0x81, 0xc1, 0xf0, 0xd0, 0x89, 0x2d, \ + 0xcb, 0x38, 0x70, 0xc0, 0x22, 0x96, 0x60, 0x50, 0x24, 0x83, 0x75, 0x0f, 0x1a, 0x28, 0x55, \ + 0x67, 0x4d, 0xa8, 0xc6, 0x55, 0xdf, 0xe4, 0x67, 0xda, 0xcf, 0xba, 0xfc, 0xca, 0x9c, 0xaa, \ + 0xd2, 0xd9, 0x06, 0xe2, 0x27, 0x6e, 0x79, 0xcd, 0x7a, 0xc5, 0x32, 0x7d,} +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) +#define LIBSPDM_RSA2048_RES_N { \ + 0x00, 0xbb, 0xd3, 0xd9, 0x10, 0x38, 0x39, 0x0a, 0x1f, 0xb3, 0x09, 0x06, 0xdf, 0x70, 0x0e, \ + 0x8f, 0x5a, 0x53, 0x69, 0x93, 0x60, 0xb9, 0x65, 0xa9, 0xe1, 0xc1, 0x8c, 0x58, 0xd7, 0x28, \ + 0xf9, 0xe7, 0x51, 0x75, 0xda, 0x63, 0x99, 0x3a, 0x70, 0x36, 0xb9, 0x80, 0x88, 0x81, 0xe5, \ + 0xa8, 0xcc, 0x4a, 0x0c, 0x3c, 0x8e, 0xba, 0xed, 0x81, 0x59, 0x7c, 0x68, 0x9c, 0x5a, 0x60, \ + 0x90, 0x3a, 0xe4, 0x0a, 0x8e, 0xbb, 0x32, 0x92, 0xd3, 0xbc, 0x19, 0x3e, 0x64, 0xee, 0x19, \ + 0x11, 0x97, 0x6f, 0x55, 0x3a, 0xf0, 0x54, 0x2a, 0x37, 0xb3, 0xb8, 0x15, 0xb0, 0xc7, 0xcf, \ + 0x20, 0x0f, 0x44, 0xc9, 0x74, 0xe1, 0xad, 0x89, 0x56, 0xc3, 0xbe, 0xc6, 0xf6, 0x4f, 0x6e, \ + 0x7d, 0x09, 0xd7, 0xa1, 0xb3, 0xbd, 0xfd, 0xb7, 0x02, 0x47, 0x4a, 0x25, 0x73, 0xaf, 0x2a, \ + 0x39, 0xa4, 0xce, 0x96, 0x09, 0x6c, 0xce, 0xb5, 0x49, 0x31, 0xe5, 0x9f, 0x91, 0x78, 0xa3, \ + 0x6a, 0xe3, 0xd7, 0xc3, 0x12, 0xb6, 0x27, 0xe5, 0x55, 0xda, 0xc7, 0x3e, 0x5f, 0xd0, 0xe6, \ + 0x1c, 0x73, 0x5e, 0xb1, 0x3c, 0x64, 0x54, 0x36, 0xfb, 0x53, 0xde, 0xdb, 0x5b, 0x2d, 0xaa, \ + 0x05, 0x14, 0x60, 0x10, 0x6a, 0xdc, 0xe4, 0x85, 0x6c, 0x2c, 0x4b, 0x95, 0x05, 0xec, 0xd0, \ + 0xe1, 0x4e, 0xaf, 0x6c, 0x40, 0xe6, 0x78, 0xe7, 0xc2, 0x88, 0x55, 0x30, 0xbb, 0x68, 0x4d, \ + 0x8c, 0xa2, 0xd6, 0x0d, 0xbc, 0xa6, 0xbf, 0xfa, 0xdc, 0xc0, 0x6a, 0xbe, 0x4a, 0x2b, 0xb7, \ + 0xfe, 0xff, 0xe6, 0xb6, 0x88, 0xff, 0x38, 0x3e, 0x13, 0x8f, 0x89, 0xc3, 0x1c, 0x25, 0x7b, \ + 0xc5, 0x01, 0x5e, 0xc8, 0xf3, 0xbc, 0xe5, 0xa5, 0x57, 0x68, 0xb1, 0x8b, 0x29, 0x51, 0x42, \ + 0x90, 0xe6, 0x41, 0xdf, 0x1c, 0x34, 0xcf, 0x38, 0xf8, 0x4f, 0xc3, 0xba, 0x89, 0x42, 0x3c, \ + 0x6e, 0x31,} +#define LIBSPDM_RSA2048_RES_E {0x01, 0x00, 0x01,} +#define LIBSPDM_RSA2048_RES_D { \ + 0x50, 0x23, 0x71, 0x47, 0xa4, 0x55, 0x61, 0xe6, 0x68, 0x82, 0xff, 0x75, 0xb1, 0xdf, 0xe4, \ + 0x76, 0x0b, 0x84, 0xce, 0x26, 0xc4, 0xb3, 0x85, 0xaa, 0x16, 0xe4, 0x84, 0xbb, 0x38, 0x76, \ + 0x77, 0xa5, 0x9f, 0xfd, 0x0f, 0xe5, 0xbe, 0xb3, 0x46, 0x06, 0x1b, 0xbb, 0x22, 0x81, 0x14, \ + 0x66, 0x25, 0x69, 0xd7, 0x24, 0xa6, 0xc8, 0xd3, 0x19, 0x95, 0x25, 0x25, 0x20, 0xc2, 0x76, \ + 0x87, 0x49, 0xe8, 0xdf, 0x41, 0x2b, 0xb0, 0xcd, 0xba, 0x41, 0xa3, 0x07, 0x79, 0x37, 0x24, \ + 0xf4, 0x51, 0xc2, 0x31, 0xa5, 0x7c, 0xa3, 0x8e, 0xa4, 0x95, 0x74, 0x5b, 0xba, 0xc4, 0xba, \ + 0xcf, 0x08, 0xf0, 0x53, 0x78, 0x3e, 0x8c, 0x8c, 0x82, 0x74, 0x11, 0x7b, 0xe2, 0x24, 0x28, \ + 0x21, 0x5c, 0xe9, 0x57, 0x41, 0x46, 0xd1, 0x20, 0x9d, 0xbe, 0x1b, 0x00, 0xa2, 0xca, 0x07, \ + 0x52, 0x33, 0xfa, 0x7c, 0x06, 0xfa, 0xa3, 0x09, 0xdd, 0x71, 0x72, 0xe2, 0x2e, 0x80, 0x9a, \ + 0xc2, 0xd7, 0x38, 0x4f, 0x68, 0xdb, 0xa7, 0xb1, 0xc8, 0x80, 0x8e, 0xc4, 0xde, 0x33, 0xa1, \ + 0x8d, 0xd4, 0xf8, 0xa0, 0xa7, 0x16, 0xb4, 0x1e, 0x90, 0x60, 0x03, 0x5b, 0x25, 0xc8, 0x56, \ + 0x9f, 0x32, 0xe5, 0x38, 0xf5, 0xec, 0x86, 0x72, 0xf2, 0xe2, 0xcf, 0xa1, 0x5a, 0x64, 0xe9, \ + 0xa3, 0xf7, 0xb0, 0x2d, 0x9a, 0x6c, 0x86, 0x12, 0x07, 0xa9, 0x34, 0x24, 0x1f, 0x48, 0x2b, \ + 0xa3, 0xa1, 0xba, 0xcb, 0xfc, 0xb9, 0x2d, 0xbe, 0x83, 0x7b, 0xb4, 0x16, 0x01, 0x90, 0x98, \ + 0xa2, 0x2e, 0xac, 0x8a, 0x84, 0x8d, 0x5a, 0x04, 0x0e, 0x1b, 0x6e, 0xe3, 0xbb, 0x61, 0x04, \ + 0x08, 0xe5, 0xcb, 0xb0, 0x22, 0x54, 0x45, 0x10, 0x98, 0xdf, 0xbb, 0x8c, 0xf5, 0x40, 0x8c, \ + 0xd4, 0x92, 0xd9, 0x8a, 0x67, 0x7f, 0x1c, 0x5f, 0xa3, 0x30, 0x99, 0x9f, 0x02, 0x97, 0x14, \ + 0x29,} + +#define LIBSPDM_RSA3072_RES_N { \ + 0x00, 0xa7, 0xb1, 0x22, 0x4c, 0x16, 0x7e, 0x79, 0xe8, 0xd5, 0xd7, 0xdd, 0x23, 0x46, 0x4e, \ + 0x0a, 0xd6, 0x3c, 0xbd, 0xab, 0x6c, 0xe6, 0xcb, 0xaf, 0x62, 0xbe, 0x4c, 0xe5, 0x5f, 0xfd, \ + 0x3e, 0x56, 0xdb, 0xf8, 0xa8, 0x93, 0x38, 0x0e, 0xf3, 0x59, 0x9e, 0x57, 0xe7, 0x91, 0x8e, \ + 0x5a, 0x8b, 0xee, 0xb1, 0xbf, 0xbe, 0x3c, 0x71, 0xfd, 0x3c, 0x43, 0x8e, 0x98, 0xae, 0xa5, \ + 0x48, 0xd1, 0x04, 0xb3, 0xc0, 0xdb, 0xaa, 0xe8, 0x23, 0x1d, 0xb4, 0xe5, 0x1e, 0x4f, 0xa2, \ + 0x57, 0x33, 0xf6, 0xb4, 0x71, 0x17, 0xd1, 0xfb, 0x5c, 0x3b, 0x98, 0x64, 0x88, 0xfb, 0xb0, \ + 0xa0, 0x48, 0xb9, 0xee, 0xbf, 0x18, 0x96, 0x4f, 0xf0, 0x86, 0x35, 0xcd, 0x09, 0xab, 0x4e, \ + 0xe7, 0x9f, 0xc2, 0xac, 0xac, 0xed, 0xf0, 0xce, 0x5f, 0x9c, 0x03, 0xf7, 0xa2, 0xdf, 0x0c, \ + 0xf7, 0xb4, 0x27, 0x02, 0xc3, 0xb1, 0x5a, 0xcb, 0x06, 0xb9, 0xfe, 0xbb, 0xdb, 0xba, 0x12, \ + 0xc0, 0x08, 0xef, 0x61, 0x0a, 0x74, 0x98, 0xa5, 0xcf, 0xa5, 0xeb, 0x80, 0xc8, 0x34, 0x66, \ + 0xd8, 0x75, 0xbf, 0x74, 0xb5, 0x0c, 0x49, 0xa1, 0xd8, 0xba, 0xc5, 0xbd, 0x4a, 0x76, 0x14, \ + 0x33, 0x5a, 0x58, 0x80, 0x16, 0xcd, 0x1b, 0xd7, 0xa9, 0xc8, 0xf0, 0x39, 0x00, 0x0f, 0x80, \ + 0xa9, 0x1c, 0xb1, 0xb9, 0x65, 0xbd, 0xa2, 0xab, 0x54, 0x88, 0x96, 0x76, 0x85, 0xa0, 0xa0, \ + 0x74, 0xf7, 0x9a, 0xfc, 0x6d, 0xd8, 0xf5, 0x4b, 0xbc, 0x73, 0xb6, 0xa3, 0x3f, 0xc0, 0x0f, \ + 0x7c, 0x51, 0x72, 0x72, 0xa7, 0x8e, 0xa5, 0xd7, 0x3d, 0x9a, 0x63, 0x31, 0xaa, 0xbf, 0xda, \ + 0x04, 0x70, 0x7c, 0x4c, 0x08, 0xc2, 0xb4, 0xcb, 0x45, 0x2b, 0xf5, 0xb8, 0x8b, 0xa7, 0xf4, \ + 0x50, 0x17, 0x9d, 0x18, 0xd3, 0x5f, 0x81, 0xb3, 0x05, 0x11, 0xa1, 0x31, 0xc4, 0x4e, 0x25, \ + 0xfb, 0x5d, 0x41, 0x0a, 0x58, 0xbb, 0x2f, 0xf5, 0xc0, 0xa2, 0x35, 0x56, 0x2a, 0x9d, 0xfe, \ + 0x29, 0xa1, 0xee, 0xeb, 0x1c, 0x5f, 0x11, 0xe2, 0x76, 0xa3, 0x65, 0xfc, 0xec, 0x48, 0x4b, \ + 0x00, 0x78, 0x5a, 0x2c, 0x7a, 0x85, 0x62, 0x52, 0x05, 0xc3, 0xc8, 0xd0, 0x62, 0x1f, 0xae, \ + 0x87, 0x99, 0xef, 0x7f, 0xb7, 0xbb, 0x58, 0xd8, 0x13, 0x55, 0x98, 0xf9, 0xbd, 0x1b, 0x80, \ + 0xb9, 0xb5, 0x28, 0x8f, 0x05, 0xfd, 0xe6, 0xd5, 0x9f, 0x44, 0x53, 0xa6, 0x31, 0x3f, 0x87, \ + 0x65, 0x53, 0x67, 0xdd, 0xd4, 0x84, 0xc8, 0xd2, 0xad, 0xac, 0x37, 0xed, 0x85, 0xea, 0xce, \ + 0xe2, 0x7e, 0xbf, 0x1a, 0x81, 0xc7, 0xd4, 0xed, 0xd8, 0x27, 0x2b, 0x0a, 0x56, 0xa0, 0xd7, \ + 0xf5, 0xd4, 0x26, 0xc2, 0xeb, 0xb0, 0x4b, 0x0f, 0x06, 0x1b, 0x4c, 0x35, 0xec, 0x29, 0x5c, \ + 0x00, 0xff, 0xd4, 0x9d, 0xd9, 0x90, 0xb6, 0xd1, 0xd6, 0xb3,} +#define LIBSPDM_RSA3072_RES_E {0x01, 0x00, 0x01,} +#define LIBSPDM_RSA3072_RES_D { \ + 0x00, 0x8f, 0xbf, 0x4d, 0x2a, 0x32, 0x42, 0x1a, 0xd8, 0xd7, 0xae, 0xe2, 0x76, 0xa1, 0x86, \ + 0xb6, 0xcd, 0x6d, 0x66, 0x1d, 0x74, 0x0d, 0xe7, 0xde, 0xa1, 0x63, 0x85, 0xe1, 0x3e, 0x46, \ + 0x84, 0xd0, 0xca, 0x61, 0xbe, 0x87, 0xec, 0x8f, 0x0c, 0x55, 0xef, 0x61, 0x65, 0x35, 0x25, \ + 0xf5, 0x42, 0x6c, 0xcb, 0xdc, 0x15, 0x04, 0x15, 0xa6, 0xc1, 0xa9, 0x1b, 0xac, 0x90, 0x51, \ + 0x49, 0x39, 0x3b, 0xb1, 0xa7, 0x09, 0xe6, 0xd8, 0x75, 0x79, 0xba, 0x9e, 0x89, 0x3c, 0x34, \ + 0x6a, 0x52, 0x36, 0x11, 0xf9, 0xbc, 0x34, 0x99, 0x27, 0x38, 0x42, 0xeb, 0x33, 0x6d, 0xa5, \ + 0xbb, 0xd0, 0x7b, 0xea, 0x47, 0xcf, 0x98, 0xd2, 0x4f, 0xd9, 0x8c, 0x77, 0x05, 0xe9, 0xde, \ + 0x8a, 0xb9, 0x2d, 0x94, 0xfd, 0xec, 0x3d, 0xf7, 0x7a, 0x87, 0xef, 0xf2, 0xb0, 0xa0, 0x49, \ + 0xaa, 0x70, 0xb8, 0xdc, 0x2a, 0xca, 0x76, 0x8d, 0x01, 0x68, 0x21, 0x10, 0x02, 0x4b, 0xe0, \ + 0x54, 0xd3, 0x93, 0xf7, 0xf8, 0x91, 0x78, 0x64, 0xf2, 0xba, 0x45, 0x45, 0xb0, 0xd9, 0x12, \ + 0xac, 0x4d, 0x4b, 0x60, 0x8c, 0xee, 0x4a, 0x94, 0x3d, 0x87, 0xe5, 0x87, 0xdd, 0x33, 0x99, \ + 0x1f, 0x68, 0x3b, 0xe3, 0x19, 0x28, 0x9b, 0xcc, 0x64, 0x53, 0xc6, 0x70, 0xe6, 0x37, 0x63, \ + 0xd0, 0x13, 0xb3, 0xd9, 0xbc, 0x78, 0x31, 0xe0, 0x72, 0x67, 0x5f, 0xab, 0x9a, 0x7f, 0x99, \ + 0x17, 0x5a, 0x0c, 0x64, 0x5b, 0x9d, 0x35, 0x9a, 0x0c, 0xed, 0xeb, 0x31, 0xcc, 0xb4, 0x66, \ + 0xf2, 0x63, 0x52, 0xd4, 0x55, 0x9a, 0x8d, 0x66, 0x21, 0xfc, 0x84, 0x7c, 0x89, 0x98, 0x4a, \ + 0x0e, 0x58, 0x3b, 0x0d, 0x81, 0x76, 0xa5, 0x4a, 0xe8, 0x0d, 0x62, 0x92, 0x81, 0xd6, 0x63, \ + 0x70, 0xf6, 0xc2, 0x84, 0x11, 0xce, 0x87, 0x8b, 0xed, 0x99, 0x16, 0x9b, 0x35, 0xa1, 0x59, \ + 0x7f, 0x09, 0x46, 0x8d, 0xfa, 0xe2, 0x45, 0xae, 0xc2, 0xf5, 0x7c, 0x84, 0x1a, 0xd8, 0x6a, \ + 0x11, 0xb5, 0xb2, 0xe9, 0x14, 0x83, 0x77, 0xd8, 0xd0, 0x5c, 0xb0, 0x02, 0xfd, 0x90, 0x89, \ + 0xde, 0x2e, 0xe3, 0x05, 0xfe, 0x9f, 0xbd, 0x7c, 0x1b, 0x87, 0xbf, 0x2c, 0x6c, 0x4f, 0x32, \ + 0xd1, 0x43, 0x97, 0x0a, 0x08, 0xc5, 0xd4, 0xc1, 0x2e, 0x24, 0xa3, 0xcd, 0x22, 0x16, 0x51, \ + 0x52, 0xa2, 0x5c, 0x7d, 0x1b, 0xbe, 0x86, 0xcf, 0xbe, 0x96, 0x2f, 0xdc, 0x99, 0xb4, 0x39, \ + 0x7d, 0xff, 0xec, 0xf7, 0x13, 0xf4, 0x08, 0x3a, 0x1d, 0x2c, 0xf3, 0xb9, 0x6d, 0xde, 0x53, \ + 0xfd, 0x84, 0x8d, 0x82, 0xb9, 0x5c, 0x8e, 0x7f, 0x2d, 0x17, 0x34, 0x26, 0x18, 0x99, 0x9b, \ + 0x28, 0xb6, 0x02, 0x06, 0xf6, 0x19, 0x60, 0xec, 0x65, 0x47, 0xb6, 0x3e, 0x02, 0x6d, 0xe6, \ + 0xbb, 0x70, 0x20, 0x89, 0xcc, 0x76, 0x92, 0x36, 0xbe, 0xa1,} + +#define LIBSPDM_RSA4096_RES_N { \ + 0x00, 0xcf, 0x55, 0x79, 0x8e, 0x15, 0xd3, 0xfa, 0x5b, 0xf8, 0xef, 0xb5, 0xc7, 0x47, 0x0b, \ + 0x66, 0x8b, 0x8e, 0xa9, 0xbe, 0xd7, 0x15, 0x3c, 0x2e, 0x22, 0xb0, 0xca, 0xe9, 0xf3, 0x8c, \ + 0xf5, 0x54, 0x4a, 0x0d, 0xd1, 0xb2, 0xd9, 0xa0, 0xbc, 0x51, 0x4e, 0x26, 0xdc, 0xa9, 0x77, \ + 0x2f, 0x0d, 0x7a, 0x48, 0x90, 0x8d, 0xf5, 0x39, 0x9e, 0xfb, 0x70, 0x08, 0xda, 0x46, 0xe3, \ + 0x62, 0xf4, 0x5b, 0x60, 0x90, 0x23, 0x1a, 0xc6, 0xd1, 0x75, 0x72, 0x38, 0x1c, 0x7d, 0x90, \ + 0x83, 0x08, 0x21, 0x3a, 0xe6, 0xcf, 0x53, 0x88, 0x04, 0x3f, 0x54, 0xfd, 0x80, 0x51, 0xb2, \ + 0xa8, 0x7f, 0xde, 0x7b, 0x04, 0x63, 0x72, 0xb1, 0xaa, 0x46, 0x22, 0xb9, 0x26, 0x3a, 0x15, \ + 0x3e, 0x28, 0xd7, 0xe8, 0x62, 0xdd, 0x23, 0x9c, 0x70, 0xd0, 0xaf, 0x43, 0x32, 0x14, 0xde, \ + 0xa9, 0x4f, 0xc2, 0x42, 0xec, 0x75, 0x2b, 0x81, 0xa9, 0x01, 0xd0, 0xfc, 0xcc, 0x94, 0x0c, \ + 0x2b, 0x29, 0x3a, 0xa4, 0xe7, 0xe8, 0xc5, 0xc2, 0xdd, 0x77, 0xe3, 0x29, 0xd7, 0x06, 0xf5, \ + 0xf6, 0x03, 0x56, 0xfe, 0xb5, 0xd8, 0xeb, 0xeb, 0x33, 0xf0, 0x6b, 0xbc, 0x60, 0xa4, 0x73, \ + 0x7e, 0x99, 0x1b, 0x0c, 0x41, 0xf7, 0xca, 0x06, 0xfe, 0xc7, 0x64, 0xf3, 0x32, 0x97, 0x51, \ + 0x5a, 0x54, 0xbe, 0xd4, 0xcd, 0xc2, 0x49, 0xc2, 0x2e, 0x72, 0x11, 0x53, 0x22, 0x8b, 0x5b, \ + 0xe2, 0x4b, 0x54, 0xd1, 0x71, 0x93, 0xd3, 0x37, 0xc4, 0xc8, 0xe2, 0x21, 0xbc, 0x87, 0x4e, \ + 0x59, 0x57, 0xbd, 0xd0, 0x0b, 0xd0, 0xc1, 0x82, 0xda, 0xdc, 0xbf, 0x92, 0x2d, 0xd8, 0x42, \ + 0x29, 0x9d, 0xe7, 0xc2, 0x49, 0xbc, 0xdf, 0x99, 0x64, 0x2f, 0x92, 0x09, 0x5d, 0xb0, 0x84, \ + 0x89, 0x34, 0x14, 0x0c, 0xde, 0x08, 0xc8, 0x37, 0xca, 0x67, 0xce, 0x71, 0xa1, 0xc9, 0xb4, \ + 0x66, 0xd5, 0xb4, 0xa0, 0xb2, 0x84, 0x54, 0xeb, 0xf4, 0x62, 0x15, 0xd5, 0xc1, 0x86, 0xbd, \ + 0x6e, 0x6e, 0x43, 0xcf, 0x63, 0xcd, 0x06, 0xc6, 0x81, 0xc5, 0x74, 0x1f, 0x54, 0xc7, 0xd5, \ + 0x92, 0x70, 0x61, 0xb1, 0x54, 0xa7, 0x44, 0xb4, 0x5f, 0x76, 0xfa, 0x26, 0xdf, 0xdd, 0xa5, \ + 0x04, 0x30, 0x16, 0x74, 0xf6, 0x80, 0x22, 0xaf, 0x30, 0x0b, 0x0a, 0x52, 0x33, 0x46, 0xcb, \ + 0x63, 0xc2, 0x85, 0x78, 0x19, 0x3c, 0x0b, 0xd0, 0x5b, 0x03, 0xfc, 0xaa, 0x59, 0x00, 0xb1, \ + 0x9e, 0x52, 0x68, 0x88, 0x56, 0x35, 0x1d, 0xff, 0x4a, 0x68, 0x81, 0xc2, 0x10, 0x3e, 0x88, \ + 0xf9, 0x50, 0x91, 0xff, 0x85, 0x86, 0xbb, 0x23, 0x1a, 0x5a, 0xae, 0x75, 0xe5, 0xaa, 0x3a, \ + 0xf4, 0x38, 0xdb, 0x24, 0x04, 0xd1, 0x6e, 0x22, 0x11, 0xe9, 0xb8, 0x7f, 0x02, 0x90, 0x09, \ + 0xcd, 0x95, 0x2d, 0x9e, 0x48, 0xef, 0x6c, 0xcf, 0xd5, 0x13, 0x3f, 0x7a, 0xe6, 0x8b, 0x99, \ + 0x2b, 0x88, 0xfb, 0xf4, 0x1c, 0x80, 0x9f, 0xe9, 0x2f, 0x28, 0xfc, 0x68, 0xa2, 0x66, 0x1a, \ + 0x6d, 0xbe, 0x9c, 0x47, 0x28, 0xcf, 0x08, 0x47, 0xe2, 0x10, 0x1c, 0x1c, 0xff, 0x31, 0x7c, \ + 0x49, 0x55, 0x4d, 0xf2, 0x4e, 0x10, 0xa2, 0x6e, 0x9b, 0xd7, 0x02, 0x21, 0x29, 0xba, 0x8c, \ + 0xce, 0xf7, 0xf6, 0x2c, 0x5c, 0x26, 0x54, 0x4b, 0x03, 0x52, 0xd3, 0xaa, 0x2e, 0x80, 0x7d, \ + 0x33, 0x68, 0xea, 0x5f, 0x4e, 0x6a, 0xb6, 0xf4, 0x65, 0x18, 0x84, 0x4c, 0xbe, 0x0a, 0x98, \ + 0x24, 0x4b, 0x37, 0x19, 0xcd, 0xfe, 0x4c, 0x34, 0x6a, 0xa9, 0x00, 0xda, 0x32, 0x77, 0x16, \ + 0xe1, 0xb5, 0x13, 0x7e, 0x8a, 0x67, 0x90, 0x62, 0xc9, 0x14, 0x57, 0x99, 0x88, 0xd8, 0xbe, \ + 0x60, 0x92, 0xb2, 0x6e, 0x46, 0xf5, 0x66, 0xd1, 0xa3, 0x34, 0x30, 0x03, 0x65, 0x76, 0xa5, \ + 0xd4, 0xb5, 0xcf,} +#define LIBSPDM_RSA4096_RES_E {0x01, 0x00, 0x01,} +#define LIBSPDM_RSA4096_RES_D { \ + 0x18, 0x5c, 0xed, 0xe4, 0xb1, 0x51, 0xf0, 0x68, 0x60, 0x4f, 0x22, 0xa8, 0x21, 0x04, 0x08, \ + 0xef, 0xbb, 0x3a, 0xdd, 0x0e, 0xff, 0x12, 0xcc, 0x45, 0x0d, 0x4b, 0x3a, 0xc4, 0x80, 0xba, \ + 0xcf, 0x45, 0xc8, 0x6b, 0xec, 0xbd, 0x3f, 0xf3, 0x01, 0x06, 0xd2, 0xf0, 0x39, 0x05, 0xa5, \ + 0x44, 0xcb, 0x2a, 0xbd, 0xb9, 0xc0, 0xa8, 0x1d, 0xb3, 0x64, 0x0d, 0xd6, 0x40, 0x60, 0x35, \ + 0xdf, 0x8a, 0xe1, 0x44, 0xee, 0xab, 0x15, 0xd3, 0xc5, 0x1e, 0x3f, 0xd3, 0xb1, 0x39, 0x8a, \ + 0xfc, 0x28, 0x93, 0x78, 0x4d, 0xc2, 0x7e, 0x08, 0x29, 0xbc, 0xfd, 0xf0, 0xd7, 0x28, 0xcc, \ + 0x3e, 0x02, 0x51, 0xa8, 0x49, 0x5b, 0x4f, 0xdf, 0x37, 0x50, 0x9b, 0x3b, 0x0f, 0xb6, 0x31, \ + 0x50, 0xb1, 0x56, 0x40, 0x4f, 0xc6, 0x00, 0x7b, 0x0d, 0x3a, 0x9b, 0x05, 0xc6, 0x88, 0x07, \ + 0x93, 0x34, 0xbb, 0x92, 0x77, 0x8e, 0x3e, 0x35, 0x32, 0xde, 0x70, 0xe6, 0x45, 0x3b, 0x4c, \ + 0xd3, 0x12, 0x6e, 0x10, 0x46, 0x3c, 0xfe, 0xd1, 0xf1, 0x65, 0x83, 0x24, 0x1e, 0x50, 0x46, \ + 0xb1, 0x4b, 0xc6, 0xb0, 0x6d, 0xa6, 0x03, 0x44, 0x5e, 0x2a, 0xfa, 0xbe, 0xcc, 0x74, 0x39, \ + 0xdb, 0x19, 0xdf, 0x8d, 0xdc, 0xe5, 0x23, 0x7f, 0x4a, 0xc4, 0xe5, 0x02, 0xfb, 0xde, 0xf6, \ + 0x63, 0x60, 0xed, 0x36, 0xa4, 0x6e, 0xf0, 0x5f, 0x6e, 0xcd, 0xf4, 0x5b, 0xe9, 0xce, 0x49, \ + 0x40, 0x1a, 0xde, 0x65, 0x9f, 0x3e, 0x41, 0x9e, 0x61, 0x10, 0x99, 0x70, 0x42, 0xe2, 0x05, \ + 0x03, 0x97, 0x6d, 0x5c, 0x06, 0x12, 0xc7, 0x22, 0x9a, 0xaf, 0xf4, 0x28, 0x68, 0xf2, 0x15, \ + 0x5b, 0xd5, 0xc0, 0xf1, 0xd3, 0x3c, 0xdf, 0x14, 0x73, 0xb6, 0x90, 0x5d, 0x2f, 0x01, 0xd3, \ + 0xf1, 0x87, 0xad, 0x9f, 0x65, 0x9e, 0xc9, 0x57, 0x82, 0x6d, 0x32, 0xd3, 0x15, 0x15, 0x9a, \ + 0xc3, 0xa9, 0xab, 0x15, 0xa6, 0x7a, 0xf8, 0x16, 0xcd, 0xd1, 0xf9, 0xaa, 0x20, 0x82, 0xb3, \ + 0x75, 0xd7, 0xed, 0x01, 0xe3, 0xd7, 0x29, 0x39, 0x12, 0xe5, 0x76, 0x6f, 0xb6, 0x5d, 0x17, \ + 0x6b, 0x00, 0x14, 0xa5, 0x59, 0xfa, 0xba, 0x47, 0x79, 0xe2, 0x9d, 0x3c, 0x12, 0xa0, 0xf5, \ + 0x14, 0x3f, 0xaf, 0x3c, 0x1a, 0xc2, 0x24, 0xea, 0x3c, 0x50, 0x3a, 0x8e, 0x06, 0x8b, 0x09, \ + 0x7d, 0x3f, 0x36, 0x20, 0xad, 0xf6, 0xee, 0x03, 0xb7, 0x38, 0xa9, 0x63, 0xf6, 0x36, 0xcb, \ + 0x85, 0x95, 0x17, 0x37, 0xed, 0x17, 0x92, 0x2f, 0x23, 0x73, 0x62, 0x79, 0xdb, 0x5d, 0x29, \ + 0x51, 0x4a, 0xdf, 0x85, 0xee, 0xd5, 0x41, 0x92, 0x8d, 0xed, 0x5c, 0xa7, 0x12, 0x39, 0x21, \ + 0x50, 0xe7, 0x79, 0xbf, 0x53, 0x84, 0xcc, 0x9c, 0x02, 0x5c, 0x4c, 0x72, 0x29, 0xc9, 0x1b, \ + 0x49, 0x95, 0xd8, 0xda, 0xea, 0x29, 0x1c, 0x2e, 0xd4, 0x48, 0xe8, 0x16, 0x31, 0x39, 0xa2, \ + 0x24, 0xc4, 0xbf, 0x0d, 0x20, 0x66, 0x29, 0x23, 0xb1, 0xc0, 0x0a, 0x72, 0xa8, 0xc7, 0x88, \ + 0xfa, 0x50, 0x9e, 0x34, 0xad, 0xaa, 0xda, 0x09, 0x6c, 0x04, 0x4c, 0xe8, 0x82, 0x4f, 0xef, \ + 0xdb, 0x72, 0xee, 0x34, 0xe6, 0x78, 0xbb, 0x96, 0x80, 0x43, 0x92, 0x3f, 0x94, 0xbd, 0xb7, \ + 0x20, 0x7c, 0xa2, 0xc5, 0xa6, 0xc5, 0x15, 0x9a, 0x16, 0x6c, 0x0a, 0x2f, 0xe3, 0x8b, 0x87, \ + 0x72, 0xc4, 0xed, 0xb8, 0xbb, 0x28, 0x63, 0x08, 0x07, 0x0b, 0x98, 0x28, 0xd4, 0xeb, 0x75, \ + 0x1d, 0x73, 0xa7, 0xad, 0x1f, 0x9c, 0xba, 0x80, 0x83, 0x34, 0x58, 0xb6, 0x0a, 0xe7, 0xe6, \ + 0x2c, 0x91, 0x3f, 0x09, 0x6d, 0x4d, 0x11, 0x63, 0x5a, 0x5f, 0x49, 0x81, 0xf0, 0x3a, 0xeb, \ + 0x60, 0x79, 0x7d, 0x2b, 0x86, 0x85, 0x45, 0x06, 0x00, 0x59, 0xfa, 0x60, 0xec, 0xcd, 0xcb, \ + 0x87, 0xc1,} + +#define LIBSPDM_RSA2048_REQ_N { \ + 0x00, 0xb2, 0x89, 0x92, 0x2b, 0x0d, 0x3a, 0x76, 0x93, 0xcf, 0x6b, 0xab, 0x28, 0x8e, 0x80, \ + 0xfd, 0xe3, 0xc4, 0xa0, 0xf0, 0xdb, 0xa5, 0xef, 0xab, 0x7c, 0xa9, 0x2a, 0x1a, 0xdc, 0x51, \ + 0x81, 0xc7, 0x1a, 0x02, 0x10, 0xc8, 0xf0, 0x19, 0x07, 0x34, 0x24, 0x3c, 0xfa, 0x65, 0xa3, \ + 0x72, 0xd0, 0x18, 0x21, 0x0f, 0xe5, 0x9f, 0x23, 0xcb, 0x62, 0xa3, 0x51, 0x89, 0xcb, 0x40, \ + 0x54, 0xc6, 0xed, 0xcf, 0x0c, 0x13, 0x21, 0x19, 0x05, 0x2e, 0xfb, 0x17, 0x86, 0x09, 0x8e, \ + 0xdd, 0x35, 0x90, 0x1c, 0x5b, 0x7b, 0x46, 0xfb, 0xe6, 0xb0, 0x35, 0xba, 0x94, 0x22, 0x77, \ + 0x6a, 0x99, 0x37, 0x50, 0xba, 0xa7, 0xeb, 0x67, 0xb2, 0x97, 0x42, 0x7b, 0xe8, 0x04, 0x3c, \ + 0x45, 0xad, 0x16, 0x7e, 0x67, 0x61, 0xe2, 0x7b, 0xd2, 0xda, 0xef, 0xb1, 0xd5, 0x52, 0x00, \ + 0x14, 0xd9, 0x19, 0x31, 0x77, 0xf6, 0xdc, 0x0e, 0xb6, 0x18, 0x07, 0x97, 0x35, 0xed, 0xc0, \ + 0xd2, 0x31, 0xd9, 0xf1, 0x1c, 0xb8, 0xd9, 0xbc, 0x04, 0xda, 0x64, 0x82, 0xaa, 0xdf, 0x63, \ + 0x24, 0xb7, 0x91, 0x7d, 0xa6, 0xde, 0x6d, 0xfa, 0xbf, 0xee, 0x85, 0x5d, 0x21, 0x35, 0x34, \ + 0xb8, 0x10, 0x7b, 0x91, 0x7d, 0xbd, 0x59, 0xe7, 0x1f, 0x08, 0xc6, 0x22, 0xc1, 0x94, 0x7c, \ + 0x81, 0x70, 0xa0, 0x70, 0xd1, 0x9c, 0xab, 0x03, 0xe2, 0x05, 0xbe, 0x31, 0x2f, 0x66, 0x65, \ + 0x94, 0x85, 0xf5, 0x57, 0xff, 0xd6, 0x37, 0x3b, 0x14, 0xdf, 0x6e, 0xda, 0x09, 0x7a, 0x81, \ + 0xc0, 0xed, 0xbc, 0x8c, 0x99, 0x77, 0xef, 0x29, 0x5f, 0xfc, 0x87, 0x43, 0xba, 0x4d, 0x2e, \ + 0x9c, 0xf2, 0x5a, 0x50, 0xe0, 0xc8, 0xb4, 0x18, 0xd6, 0x8c, 0x06, 0xec, 0xd5, 0xec, 0x9b, \ + 0x64, 0xf2, 0x04, 0xd7, 0x94, 0x22, 0xdb, 0x2b, 0x71, 0xd8, 0xd2, 0x0d, 0x9f, 0x46, 0x45, \ + 0xac, 0x27,} +#define LIBSPDM_RSA2048_REQ_E {0x01, 0x00, 0x01,} +#define LIBSPDM_RSA2048_REQ_D { \ + 0x22, 0xb1, 0x66, 0xec, 0xe4, 0xba, 0x2a, 0x96, 0x98, 0x64, 0xc4, 0xb2, 0xb1, 0xd6, 0x50, \ + 0xff, 0xb4, 0x92, 0xcd, 0x9a, 0xf1, 0x08, 0xbc, 0x9b, 0x11, 0xc8, 0x33, 0xc6, 0x02, 0x34, \ + 0xa4, 0xba, 0xe2, 0x11, 0xde, 0xea, 0x01, 0x03, 0x0c, 0x57, 0xca, 0x5d, 0xa1, 0xe8, 0x7c, \ + 0x04, 0x01, 0xdc, 0x52, 0xd9, 0x7c, 0xee, 0x18, 0xb4, 0x87, 0x25, 0xee, 0x0f, 0xc7, 0xe5, \ + 0x71, 0x6e, 0x7e, 0xa0, 0x4b, 0x0b, 0x50, 0x70, 0x58, 0x6b, 0xc4, 0x6b, 0x70, 0x6a, 0x09, \ + 0x84, 0x42, 0x07, 0xb0, 0xa3, 0x28, 0xed, 0x04, 0x2b, 0xd3, 0x94, 0xf8, 0xfa, 0x25, 0x98, \ + 0x5a, 0x43, 0x8c, 0x75, 0x68, 0xf1, 0xee, 0x89, 0x9e, 0xa8, 0xf5, 0xa8, 0xe5, 0x41, 0xcd, \ + 0x0c, 0x50, 0x65, 0xa9, 0xb3, 0x34, 0xae, 0x79, 0x0f, 0xc0, 0x2a, 0x1f, 0x58, 0xba, 0xd9, \ + 0x52, 0x42, 0x7a, 0x01, 0x64, 0xbf, 0xe8, 0x3f, 0x99, 0x1f, 0x7c, 0x38, 0x46, 0x3d, 0x9e, \ + 0x1f, 0xa9, 0x45, 0xb7, 0x54, 0xdd, 0xe5, 0x95, 0xb5, 0xd1, 0x56, 0xf7, 0xea, 0x0d, 0x15, \ + 0x37, 0x09, 0xe2, 0xf9, 0x58, 0x99, 0x22, 0xa2, 0x7e, 0x1b, 0xda, 0x0a, 0xa4, 0xbb, 0xe1, \ + 0xdf, 0x3b, 0x88, 0xd8, 0xd6, 0x44, 0xf6, 0x56, 0x89, 0xff, 0xe5, 0xd4, 0x3a, 0x12, 0x53, \ + 0x3c, 0xff, 0x38, 0xed, 0x03, 0x08, 0x8f, 0x13, 0xb9, 0x0a, 0x5a, 0xb0, 0xde, 0xdf, 0xc1, \ + 0x13, 0xa0, 0x06, 0xa8, 0x5a, 0x3f, 0xd7, 0xec, 0xe0, 0x14, 0x38, 0xf1, 0x66, 0x84, 0xfd, \ + 0xd0, 0xd2, 0x7f, 0x80, 0x63, 0xca, 0x1e, 0xb6, 0x88, 0xa2, 0xe9, 0x3f, 0xcb, 0xdb, 0x4d, \ + 0x10, 0x82, 0xd2, 0xf3, 0x17, 0xb9, 0xf0, 0x30, 0xa4, 0x9f, 0x42, 0xe2, 0xda, 0x59, 0xd0, \ + 0xd8, 0x6d, 0xb1, 0xf5, 0xe4, 0x3f, 0xdd, 0x4a, 0x1f, 0x83, 0x56, 0xa8, 0x0a, 0x6c, 0x15, \ + 0x81,} + +#define LIBSPDM_RSA3072_REQ_N { \ + 0x00, 0xb0, 0x46, 0x67, 0x82, 0x63, 0xb9, 0x22, 0x69, 0x01, 0x9b, 0xe7, 0xf9, 0x52, 0xf7, \ + 0x09, 0x1b, 0x72, 0x15, 0x0c, 0x67, 0x3e, 0xe4, 0x6e, 0x41, 0x09, 0xed, 0x01, 0x42, 0xf1, \ + 0xd8, 0x3c, 0x0d, 0xa0, 0x0c, 0x35, 0xfb, 0x5c, 0x36, 0x00, 0x21, 0x58, 0x4a, 0x1b, 0x4e, \ + 0x85, 0xaf, 0xe7, 0x84, 0xc9, 0x8f, 0xb8, 0xe0, 0xb1, 0xa4, 0x3d, 0x78, 0x54, 0x4d, 0xf3, \ + 0x92, 0x8d, 0xe6, 0xb5, 0x97, 0x98, 0x68, 0xd6, 0x4e, 0xde, 0xf3, 0x2d, 0x89, 0xb6, 0x57, \ + 0x9d, 0xb0, 0x83, 0x95, 0x3c, 0x7a, 0x71, 0x7f, 0xf9, 0x0e, 0x57, 0x77, 0xcc, 0x69, 0xa8, \ + 0x01, 0xab, 0x2e, 0x7b, 0x30, 0x50, 0x3b, 0xd1, 0xee, 0xc8, 0x3d, 0xfe, 0xa6, 0x74, 0xe4, \ + 0xf7, 0x7f, 0xf2, 0xfc, 0xd1, 0xe6, 0x4a, 0xb4, 0x7b, 0x45, 0x0b, 0x59, 0xcb, 0x53, 0x60, \ + 0x48, 0x91, 0x59, 0xd9, 0x1b, 0xcc, 0x61, 0x5c, 0x5b, 0xe2, 0xb2, 0xa5, 0xca, 0xce, 0x93, \ + 0x96, 0xde, 0xc9, 0xdb, 0xf8, 0x3a, 0x94, 0x1c, 0x3e, 0xe4, 0x44, 0x44, 0xad, 0x04, 0xe0, \ + 0x2f, 0x63, 0xf1, 0xa5, 0xb7, 0x01, 0x55, 0x4f, 0xbc, 0xb7, 0x7e, 0x7d, 0x8d, 0x82, 0xcb, \ + 0x74, 0xba, 0xc5, 0xed, 0xef, 0x9e, 0x41, 0x4c, 0xb0, 0x54, 0x6d, 0x15, 0x48, 0x18, 0x07, \ + 0x3c, 0x2d, 0x44, 0xe0, 0xe2, 0x38, 0x90, 0x35, 0x34, 0xee, 0x0e, 0xc7, 0x1e, 0x32, 0x58, \ + 0xbe, 0x89, 0x55, 0x9f, 0x7e, 0x68, 0xe5, 0xe7, 0x7f, 0xd1, 0xd0, 0x61, 0xf4, 0x80, 0x48, \ + 0xe0, 0xd4, 0x97, 0x50, 0x74, 0xca, 0x27, 0xa6, 0xb5, 0xcf, 0x6e, 0xa5, 0x0f, 0xc9, 0x4f, \ + 0x21, 0xc7, 0xe6, 0xc9, 0xfd, 0xfe, 0x1a, 0x33, 0x88, 0xe3, 0xb5, 0xa7, 0xb8, 0x3a, 0x4f, \ + 0xbf, 0xf8, 0xc6, 0x54, 0x4d, 0x63, 0x14, 0x05, 0xdf, 0x45, 0x81, 0x4e, 0x84, 0x9a, 0x0a, \ + 0x8a, 0x45, 0x40, 0x52, 0xcf, 0xee, 0x15, 0xb7, 0x71, 0x66, 0x98, 0x43, 0x11, 0x84, 0x7c, \ + 0x2e, 0x1b, 0x02, 0xda, 0xb2, 0x92, 0xa1, 0x01, 0x85, 0x37, 0xb1, 0xce, 0x70, 0x11, 0xa4, \ + 0xcf, 0x46, 0xeb, 0x08, 0x22, 0xdd, 0xad, 0x05, 0x89, 0xf7, 0x2e, 0x1e, 0xa7, 0xbb, 0x36, \ + 0xcd, 0x7f, 0x13, 0xaa, 0xec, 0xdd, 0x2a, 0x2d, 0x23, 0xb1, 0xd0, 0xc6, 0x74, 0xfb, 0x84, \ + 0x23, 0x36, 0xba, 0x90, 0xa0, 0x30, 0x31, 0x48, 0xd5, 0x52, 0xa9, 0x10, 0xd9, 0x4e, 0x5b, \ + 0xa7, 0xb5, 0x06, 0x1c, 0x4b, 0x1c, 0xb1, 0x5e, 0xeb, 0xf0, 0xe1, 0x12, 0xf2, 0xe1, 0x5b, \ + 0x41, 0x22, 0xf2, 0x93, 0x72, 0x62, 0x85, 0x7c, 0x72, 0x52, 0x37, 0x50, 0x52, 0x7b, 0x95, \ + 0xe3, 0x2c, 0xa4, 0x5e, 0xbb, 0xa2, 0xd5, 0x7c, 0xa5, 0x4c, 0xfe, 0x7a, 0x31, 0x40, 0xda, \ + 0x6f, 0xeb, 0xa5, 0x87, 0x4a, 0x49, 0x96, 0x96, 0x32, 0x8f,} +#define LIBSPDM_RSA3072_REQ_E {0x01, 0x00, 0x01,} +#define LIBSPDM_RSA3072_REQ_D { \ + 0x00, 0xa7, 0x70, 0x78, 0xea, 0x16, 0x27, 0xc9, 0x53, 0xcd, 0x3f, 0x76, 0xbe, 0x11, 0xdc, \ + 0xae, 0x3d, 0xef, 0xc3, 0xa6, 0xa0, 0x7b, 0xd1, 0x28, 0x19, 0x87, 0x80, 0x25, 0x6e, 0x9d, \ + 0xa3, 0x34, 0x88, 0x0c, 0xbb, 0x0c, 0x9b, 0xd3, 0x1f, 0x48, 0x48, 0x64, 0x41, 0x20, 0x67, \ + 0x19, 0xfd, 0xd9, 0x00, 0xfd, 0x25, 0x14, 0x0b, 0xfb, 0x31, 0x73, 0x62, 0x55, 0x52, 0x26, \ + 0x47, 0xd3, 0x9a, 0x8e, 0x6b, 0x8d, 0x4e, 0x28, 0x23, 0x8b, 0x0b, 0x9a, 0xf9, 0xf0, 0xc6, \ + 0x90, 0xf7, 0x16, 0x46, 0x2f, 0xc8, 0x6e, 0xff, 0x8c, 0x67, 0xdf, 0x15, 0xe0, 0x89, 0x8c, \ + 0x18, 0xe9, 0xad, 0xa1, 0x3e, 0x67, 0x38, 0x2b, 0x55, 0x91, 0xc7, 0xb1, 0x98, 0x13, 0xf9, \ + 0x5a, 0x4f, 0xa3, 0x54, 0x1b, 0x5d, 0x91, 0x20, 0x96, 0xe7, 0x22, 0xbd, 0x0c, 0xb2, 0x0a, \ + 0x07, 0x64, 0x69, 0xe0, 0x1c, 0xd3, 0xaa, 0xb7, 0xbc, 0x60, 0x3e, 0x29, 0xd5, 0xd7, 0x1b, \ + 0xc2, 0x77, 0xa5, 0x6e, 0xd8, 0xff, 0x6b, 0xa8, 0xd8, 0xe4, 0xa3, 0x24, 0x48, 0xe5, 0x14, \ + 0xbe, 0x6f, 0x45, 0x1e, 0x90, 0x13, 0x28, 0x22, 0x31, 0xb4, 0x6a, 0xe6, 0x80, 0x00, 0xf9, \ + 0x99, 0xcb, 0xc0, 0x2f, 0x1f, 0x29, 0x48, 0x05, 0xbc, 0x88, 0xb5, 0x85, 0x3d, 0x91, 0xf5, \ + 0x6d, 0x67, 0xe2, 0xc1, 0x6a, 0xa1, 0x27, 0xfa, 0x22, 0x68, 0xee, 0x88, 0x9b, 0xc6, 0x4f, \ + 0x1f, 0xdb, 0x22, 0x70, 0x99, 0x21, 0xa7, 0x41, 0x7f, 0x6b, 0x07, 0x7c, 0xc9, 0xd3, 0x57, \ + 0x00, 0xde, 0xd6, 0xc6, 0xca, 0x61, 0x6b, 0x1a, 0x10, 0xaa, 0x8e, 0x0c, 0xbc, 0xe9, 0x69, \ + 0x16, 0xbc, 0xdc, 0xd4, 0x4b, 0xc2, 0xac, 0xa0, 0x03, 0x6e, 0x6b, 0x57, 0x4f, 0x60, 0x67, \ + 0x76, 0x9e, 0xa6, 0x0d, 0xf6, 0x7c, 0x10, 0xdf, 0x40, 0x21, 0x8c, 0xde, 0x78, 0xc5, 0xad, \ + 0x71, 0x45, 0x65, 0x20, 0x74, 0xc2, 0x9a, 0x27, 0x9c, 0x0e, 0x70, 0x0a, 0x56, 0xb0, 0x91, \ + 0xcd, 0xa9, 0x09, 0x3f, 0xe1, 0x4b, 0x17, 0x3e, 0xc8, 0xc7, 0xe6, 0xe8, 0xb9, 0xe1, 0xaa, \ + 0xe8, 0x4a, 0xaa, 0xb7, 0xdc, 0xd6, 0x3b, 0x40, 0x29, 0x88, 0x13, 0xd3, 0x47, 0x96, 0xa5, \ + 0x2f, 0xbb, 0x21, 0xb1, 0xd0, 0xfd, 0x36, 0xe0, 0x57, 0xb9, 0x9e, 0x41, 0xd4, 0xa7, 0x75, \ + 0x9a, 0x6c, 0xfb, 0xb9, 0x36, 0x32, 0xc9, 0x16, 0x2e, 0xe3, 0x87, 0x68, 0x7b, 0x6c, 0xb5, \ + 0x59, 0x9f, 0xed, 0x1b, 0xe8, 0x30, 0xca, 0xdf, 0xe5, 0x76, 0xf3, 0xfd, 0x33, 0x24, 0xae, \ + 0x7f, 0x04, 0x4d, 0x82, 0x12, 0xc2, 0x10, 0x0a, 0xcb, 0x20, 0xee, 0x4b, 0x1a, 0x58, 0x67, \ + 0x88, 0x69, 0x63, 0x62, 0xf1, 0x96, 0x38, 0xca, 0x22, 0x08, 0xab, 0xee, 0x30, 0x61, 0x80, \ + 0x45, 0xff, 0x10, 0xb1, 0x10, 0x1f, 0xfb, 0xd4, 0x07, 0x01,} + +#define LIBSPDM_RSA4096_REQ_N { \ + 0x00, 0xbc, 0xc0, 0x4a, 0x14, 0x67, 0xa6, 0x8c, 0x30, 0x19, 0x06, 0x78, 0xb3, 0x8b, 0x28, \ + 0xbc, 0x6d, 0x41, 0xd1, 0x2c, 0x64, 0x71, 0x57, 0x51, 0xb7, 0xf4, 0xf5, 0x12, 0xbd, 0xd1, \ + 0xab, 0x45, 0x2f, 0x00, 0xa7, 0x9f, 0x50, 0xf8, 0xa8, 0xf5, 0xde, 0xc2, 0x4c, 0xfa, 0x57, \ + 0x07, 0xce, 0x3a, 0x9b, 0xc8, 0xcd, 0x77, 0x1e, 0x3c, 0xaa, 0x5a, 0x70, 0x8d, 0xb7, 0x32, \ + 0xf1, 0xa9, 0x62, 0xd1, 0x71, 0x6f, 0x6a, 0x30, 0x37, 0x87, 0xd5, 0x47, 0x05, 0x8b, 0x0e, \ + 0x4d, 0x35, 0x00, 0x84, 0x1d, 0xfe, 0xb6, 0xe3, 0x46, 0xdd, 0x88, 0x26, 0x04, 0xb7, 0x37, \ + 0x16, 0x43, 0x09, 0x49, 0xb4, 0x3e, 0x49, 0xe4, 0x60, 0x0d, 0x91, 0x34, 0xa7, 0x23, 0xa9, \ + 0x09, 0x91, 0xc5, 0x48, 0x27, 0xb0, 0x99, 0xdb, 0x04, 0x8d, 0xd3, 0x8b, 0x0a, 0x16, 0x83, \ + 0x81, 0xf3, 0x57, 0x24, 0xc0, 0xce, 0x71, 0xf4, 0x7d, 0x25, 0xee, 0x81, 0x6f, 0x21, 0x79, \ + 0x2a, 0x34, 0x0c, 0x19, 0x7c, 0x7b, 0x52, 0xeb, 0x6a, 0x54, 0x18, 0xad, 0x90, 0xaf, 0x0c, \ + 0x84, 0xde, 0xd4, 0x69, 0x42, 0xca, 0xe4, 0x7b, 0xeb, 0xad, 0xd9, 0x99, 0x62, 0xe4, 0xd7, \ + 0x03, 0x73, 0x96, 0x07, 0x7e, 0xab, 0xca, 0x9e, 0xb9, 0x46, 0x80, 0x1e, 0x43, 0xd4, 0xeb, \ + 0x05, 0x6e, 0x66, 0x49, 0x20, 0x34, 0x43, 0x1e, 0x5c, 0x95, 0xe8, 0x08, 0xce, 0x5c, 0x97, \ + 0x94, 0x0d, 0x86, 0x9a, 0x13, 0x5b, 0x92, 0xb6, 0x91, 0xa0, 0x01, 0xcc, 0x0f, 0x49, 0xa0, \ + 0x55, 0xb1, 0x86, 0x0a, 0xb9, 0xba, 0x37, 0xd8, 0xa8, 0x3d, 0x65, 0xdc, 0x76, 0x64, 0xe1, \ + 0x99, 0x6b, 0xeb, 0xe0, 0x51, 0x05, 0x8b, 0x89, 0x75, 0x20, 0xf5, 0xa9, 0xbf, 0x9c, 0x62, \ + 0x23, 0x70, 0x48, 0x88, 0xe2, 0x58, 0x92, 0xb3, 0xb3, 0xb0, 0x87, 0xe3, 0x0e, 0xd0, 0x93, \ + 0x31, 0xf0, 0x6e, 0xef, 0xb7, 0x2b, 0x7d, 0xe7, 0xa8, 0x80, 0x79, 0x41, 0x4a, 0x93, 0x4c, \ + 0xc9, 0x49, 0xce, 0x09, 0x77, 0xc0, 0xd5, 0xd4, 0x3c, 0xe5, 0x8f, 0xb8, 0x4e, 0x19, 0x18, \ + 0x40, 0x65, 0xaf, 0xcc, 0x63, 0x75, 0x81, 0x42, 0x4b, 0xea, 0xdc, 0x7f, 0x42, 0x97, 0x69, \ + 0x62, 0xb2, 0xb9, 0x0a, 0xa8, 0x6f, 0xde, 0xba, 0x7b, 0x62, 0x49, 0x1e, 0x87, 0xb4, 0xb0, \ + 0xa6, 0xd4, 0x61, 0x82, 0x12, 0x56, 0xd1, 0x4d, 0xad, 0xad, 0xaf, 0xf7, 0x1a, 0x52, 0xa8, \ + 0x38, 0x62, 0x24, 0x7d, 0x50, 0x17, 0x43, 0x76, 0x86, 0xfa, 0x08, 0x32, 0xc6, 0xff, 0x8e, \ + 0x1b, 0xdd, 0xbc, 0xf4, 0x55, 0xbb, 0x68, 0x81, 0xb7, 0xdf, 0x4d, 0x9d, 0xe9, 0xef, 0xbe, \ + 0x6d, 0xb6, 0x27, 0xfe, 0x38, 0x9a, 0xde, 0xea, 0x86, 0xb9, 0xab, 0x9e, 0xc3, 0xe6, 0x53, \ + 0xa2, 0xd1, 0x2a, 0x7a, 0x9e, 0x42, 0x51, 0xb3, 0x3c, 0xe3, 0xb1, 0x56, 0x75, 0xfc, 0xe0, \ + 0x17, 0xd2, 0xdf, 0x82, 0x48, 0x70, 0xfa, 0xe6, 0xdb, 0x05, 0xc2, 0xde, 0x2b, 0xd7, 0x68, \ + 0xdc, 0xc0, 0x8d, 0x30, 0xa3, 0x6a, 0x6f, 0x7e, 0x8a, 0xc9, 0x4d, 0x1d, 0xab, 0x39, 0x0c, \ + 0xbe, 0x02, 0xe2, 0x35, 0x3a, 0xb8, 0xda, 0x0a, 0xb9, 0x33, 0x19, 0x8b, 0x7e, 0xb4, 0x4d, \ + 0xd0, 0x0d, 0xf3, 0x9e, 0xaf, 0x38, 0x93, 0x2a, 0xe0, 0x45, 0x46, 0xef, 0x13, 0xd0, 0x4c, \ + 0xf5, 0xc0, 0xdb, 0xc8, 0x97, 0xc2, 0xaa, 0xd0, 0x7f, 0xf6, 0xac, 0xb7, 0xa7, 0x83, 0xcb, \ + 0x0c, 0x15, 0x9d, 0xfd, 0xc9, 0x3f, 0xa2, 0x1a, 0x51, 0xd9, 0x0d, 0x96, 0xb8, 0xbf, 0xb5, \ + 0x66, 0x13, 0x00, 0x13, 0x87, 0xfd, 0x29, 0x20, 0x4a, 0xea, 0xe3, 0x16, 0xea, 0xa8, 0x6c, \ + 0xb0, 0x81, 0x1c, 0x30, 0x47, 0x8d, 0x7e, 0x2e, 0xc1, 0x3d, 0x61, 0x79, 0x7d, 0x8e, 0xb2, \ + 0x07, 0x2d, 0xa1,} +#define LIBSPDM_RSA4096_REQ_E {0x01, 0x00, 0x01,} +#define LIBSPDM_RSA4096_REQ_D { \ + 0x0f, 0x1e, 0xd0, 0x50, 0x66, 0x25, 0x3f, 0x61, 0xb2, 0xff, 0x83, 0xb7, 0xce, 0x54, 0x0b, \ + 0x14, 0x2d, 0x8b, 0x96, 0x24, 0xcd, 0xb7, 0x93, 0x02, 0x4b, 0x8b, 0x3e, 0x5f, 0x1a, 0x66, \ + 0xbf, 0xfa, 0x0d, 0xf1, 0x5f, 0x9f, 0xda, 0xeb, 0x9e, 0x16, 0xa4, 0x36, 0x0a, 0x6f, 0xe2, \ + 0x5e, 0x30, 0xef, 0xbd, 0xdc, 0x47, 0xc8, 0x92, 0x4f, 0x8b, 0x43, 0x2c, 0xf7, 0x1a, 0x0b, \ + 0xa5, 0xe8, 0x16, 0xa3, 0x21, 0xab, 0xbe, 0x05, 0x14, 0xca, 0x8f, 0x0f, 0xf0, 0x9d, 0xca, \ + 0xad, 0x8e, 0x47, 0x07, 0x28, 0x1a, 0x7a, 0x86, 0x78, 0xc4, 0xa9, 0x57, 0x03, 0x5e, 0x54, \ + 0x58, 0x36, 0x6c, 0x43, 0x16, 0x22, 0x51, 0x3b, 0x28, 0x9b, 0x13, 0x3e, 0xb8, 0x6a, 0x98, \ + 0x2b, 0xa7, 0x44, 0x2a, 0x79, 0xc9, 0x39, 0x74, 0x59, 0xf0, 0x32, 0x59, 0x32, 0x88, 0x82, \ + 0x66, 0x7d, 0xfa, 0xa1, 0xbf, 0x67, 0xfd, 0x8f, 0xf0, 0xf3, 0xf4, 0x46, 0x74, 0xc6, 0x02, \ + 0x0d, 0x7d, 0x52, 0xa5, 0x58, 0x33, 0xc2, 0x4c, 0x18, 0x44, 0x89, 0xd2, 0xe7, 0x52, 0xf7, \ + 0x69, 0xea, 0x56, 0x2c, 0x55, 0x98, 0x8c, 0x1c, 0xcb, 0x26, 0x7d, 0x55, 0x20, 0xc3, 0xe0, \ + 0xb0, 0xe7, 0xb9, 0xdd, 0xf9, 0xe1, 0x17, 0x69, 0xfc, 0x2d, 0xd3, 0x3e, 0xd7, 0xd5, 0xa3, \ + 0xef, 0xbe, 0x1d, 0xe9, 0x88, 0x86, 0x3f, 0xee, 0x66, 0xcb, 0xd9, 0xb8, 0xbe, 0x4e, 0x1e, \ + 0x3c, 0x1f, 0x26, 0x44, 0x9a, 0xb7, 0x5c, 0x0c, 0xba, 0x66, 0xaa, 0x74, 0x27, 0x0f, 0xc3, \ + 0x0d, 0x9f, 0x91, 0x48, 0x63, 0x94, 0x89, 0xb4, 0xa0, 0x86, 0x82, 0x6c, 0xb1, 0x94, 0x28, \ + 0xf8, 0x2e, 0x43, 0x1f, 0xfa, 0x73, 0xbd, 0x25, 0x36, 0xe8, 0xb7, 0x1a, 0x74, 0x6a, 0xa0, \ + 0x30, 0x24, 0x7f, 0x62, 0xb2, 0x79, 0xbe, 0x0f, 0x8c, 0xfa, 0xb5, 0xc3, 0xc0, 0x0d, 0xaa, \ + 0x98, 0x56, 0xe1, 0xb2, 0xbc, 0x49, 0xa6, 0x7c, 0xd1, 0xa9, 0x0e, 0x0f, 0x72, 0x06, 0x5d, \ + 0x6c, 0x0c, 0x41, 0x4e, 0xa2, 0x8f, 0xbe, 0xf0, 0x66, 0x2e, 0x9c, 0x5b, 0x66, 0x9f, 0xbf, \ + 0x6c, 0x11, 0x39, 0x03, 0x6f, 0xd1, 0x4f, 0xd5, 0xcf, 0xa3, 0xf8, 0x9e, 0xf0, 0xe7, 0xf0, \ + 0xbf, 0xa0, 0xef, 0x2e, 0x84, 0xaf, 0xd6, 0x01, 0x0e, 0x84, 0xb7, 0xb8, 0xed, 0x5f, 0xc1, \ + 0xb6, 0x69, 0x30, 0x1a, 0x61, 0xae, 0x1d, 0xab, 0x64, 0x20, 0x44, 0x01, 0x22, 0xef, 0x02, \ + 0x4b, 0xf7, 0xcb, 0x3f, 0x43, 0xe8, 0x5f, 0xca, 0x44, 0x51, 0xe5, 0xa4, 0x95, 0x22, 0xc6, \ + 0xe3, 0x27, 0xc9, 0x52, 0x66, 0x23, 0x0b, 0xf6, 0xaa, 0xe7, 0x76, 0x5b, 0xef, 0x4e, 0xe7, \ + 0x50, 0xba, 0x0c, 0x90, 0x1e, 0x48, 0x37, 0xf8, 0xe8, 0x2d, 0x3c, 0xc6, 0x08, 0xa9, 0xf7, \ + 0x0d, 0x0b, 0xe7, 0x60, 0xc3, 0x1f, 0xfb, 0xc3, 0x45, 0x1e, 0xf8, 0xbc, 0x8b, 0x15, 0xa7, \ + 0xa9, 0x0a, 0x9e, 0x66, 0xed, 0xef, 0x5a, 0xab, 0x3f, 0xe7, 0x55, 0xba, 0x79, 0x4c, 0x86, \ + 0x59, 0x2d, 0x2b, 0x57, 0xc6, 0x64, 0xd5, 0x0f, 0x4d, 0x77, 0x8a, 0xd3, 0xb5, 0x23, 0x87, \ + 0xa6, 0xf4, 0x4b, 0x33, 0x88, 0x31, 0xcb, 0xf3, 0xd0, 0x91, 0x7d, 0xbb, 0x52, 0x7c, 0x6a, \ + 0x17, 0x6c, 0xcc, 0xe7, 0x20, 0x46, 0x5d, 0xa5, 0xe0, 0xf3, 0xd5, 0xd9, 0x3e, 0x18, 0xaa, \ + 0x4b, 0xa6, 0x8f, 0x45, 0x54, 0x2b, 0xe6, 0xa2, 0xd8, 0xf9, 0x54, 0x8b, 0x35, 0xe8, 0x5e, \ + 0x8e, 0xbe, 0x99, 0x08, 0xb5, 0x2a, 0x10, 0x8d, 0x5b, 0x86, 0x23, 0x18, 0xc4, 0xb7, 0x34, \ + 0x09, 0xeb, 0x32, 0x5a, 0x9c, 0x60, 0xfd, 0x00, 0x64, 0x4a, 0x34, 0xfd, 0xbe, 0xb6, 0xec, \ + 0x56, 0xfb, 0xba, 0x10, 0x8a, 0xe6, 0x53, 0xfb, 0x1c, 0xb8, 0x53, 0xd0, 0x7a, 0xca, 0xe5, \ + 0x12, 0x61,} +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +#endif /*RAW_DATA_KEY_H*/ diff --git a/os_stub/spdm_device_secret_lib_tpm/read_priv_key_pem.c b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_pem.c new file mode 100644 index 00000000000..57aed731efc --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_pem.c @@ -0,0 +1,113 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_private_key(uint32_t base_asym_algo, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (base_asym_algo) { + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + file = "rsa2048/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + file = "rsa3072/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: + file = "rsa4096/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + file = "ecp256/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + file = "ecp384/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: + file = "ecp521/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256: + file = "sm2/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519: + file = "ed25519/end_responder.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448: + file = "ed448/end_responder.key"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_private_key(uint16_t req_base_asym_alg, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (req_base_asym_alg) { + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + file = "rsa2048/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + file = "rsa3072/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: + file = "rsa4096/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + file = "ecp256/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + file = "ecp384/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: + file = "ecp521/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256: + file = "sm2/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519: + file = "ed25519/end_requester.key"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448: + file = "ed448/end_requester.key"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ diff --git a/os_stub/spdm_device_secret_lib_tpm/read_priv_key_pem_pqc.c b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_pem_pqc.c new file mode 100644 index 00000000000..6b7f03b11cf --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_pem_pqc.c @@ -0,0 +1,143 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_pqc_private_key(uint32_t pqc_asym_algo, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_responder.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_responder.key"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_pqc_private_key(uint32_t req_pqc_asym_alg, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (req_pqc_asym_alg) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_requester.key"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_requester.key"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP || (...) */ diff --git a/os_stub/spdm_device_secret_lib_tpm/read_priv_key_raw_data.c b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_raw_data.c new file mode 100644 index 00000000000..b10381df67c --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_raw_data.c @@ -0,0 +1,360 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "raw_data_key.h" +#include "internal/libspdm_common_lib.h" + +/* "g_private_key_mode = 1" means use the PEM mode + * "g_private_key_mode = 0" means use the RAW mode + **/ +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool g_private_key_mode = 1; +#endif + +#if LIBSPDM_ECDSA_SUPPORT +uint8_t m_libspdm_ec256_responder_private_key[] = LIBSPDM_EC256_RESPONDER_PRIVATE_KEY; +uint8_t m_libspdm_ec256_responder_public_key[] = LIBSPDM_EC256_RESPONDER_PUBLIC_KEY; + +uint8_t m_libspdm_ec384_responder_private_key[] = LIBSPDM_EC384_RESPONDER_PRIVATE_KEY; +uint8_t m_libspdm_ec384_responder_public_key[] = LIBSPDM_EC384_RESPONDER_PUBLIC_KEY; + +uint8_t m_libspdm_ec521_responder_private_key[] = LIBSPDM_EC521_RESPONDER_PRIVATE_KEY; +uint8_t m_libspdm_ec521_responder_public_key[] = LIBSPDM_EC521_RESPONDER_PUBLIC_KEY; + +uint8_t m_libspdm_ec256_requester_private_key[] = LIBSPDM_EC256_REQUESTER_PRIVATE_KEY; +uint8_t m_libspdm_ec256_requester_public_key[] = LIBSPDM_EC256_REQUESTER_PUBLIC_KEY; + +uint8_t m_libspdm_ec384_requester_private_key[] = LIBSPDM_EC384_REQUESTER_PRIVATE_KEY; +uint8_t m_libspdm_ec384_requester_public_key[] = LIBSPDM_EC384_REQUESTER_PUBLIC_KEY; + +uint8_t m_libspdm_ec521_requester_private_key[] = LIBSPDM_EC521_REQUESTER_PRIVATE_KEY; +uint8_t m_libspdm_ec521_requester_public_key[] = LIBSPDM_EC521_REQUESTER_PUBLIC_KEY; +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) +uint8_t m_libspdm_rsa2048_res_n[] = LIBSPDM_RSA2048_RES_N; +uint8_t m_libspdm_rsa2048_res_e[] = LIBSPDM_RSA2048_RES_E; +uint8_t m_libspdm_rsa2048_res_d[] = LIBSPDM_RSA2048_RES_D; +uint8_t m_libspdm_rsa3072_res_n[] = LIBSPDM_RSA3072_RES_N; +uint8_t m_libspdm_rsa3072_res_e[] = LIBSPDM_RSA3072_RES_E; +uint8_t m_libspdm_rsa3072_res_d[] = LIBSPDM_RSA3072_RES_D; +uint8_t m_libspdm_rsa4096_res_n[] = LIBSPDM_RSA4096_RES_N; +uint8_t m_libspdm_rsa4096_res_e[] = LIBSPDM_RSA4096_RES_E; +uint8_t m_libspdm_rsa4096_res_d[] = LIBSPDM_RSA4096_RES_D; +uint8_t m_libspdm_rsa2048_req_n[] = LIBSPDM_RSA2048_REQ_N; +uint8_t m_libspdm_rsa2048_req_e[] = LIBSPDM_RSA2048_REQ_E; +uint8_t m_libspdm_rsa2048_req_d[] = LIBSPDM_RSA2048_REQ_D; +uint8_t m_libspdm_rsa3072_req_n[] = LIBSPDM_RSA3072_REQ_N; +uint8_t m_libspdm_rsa3072_req_e[] = LIBSPDM_RSA3072_REQ_E; +uint8_t m_libspdm_rsa3072_req_d[] = LIBSPDM_RSA3072_REQ_D; +uint8_t m_libspdm_rsa4096_req_n[] = LIBSPDM_RSA4096_REQ_N; +uint8_t m_libspdm_rsa4096_req_e[] = LIBSPDM_RSA4096_REQ_E; +uint8_t m_libspdm_rsa4096_req_d[] = LIBSPDM_RSA4096_REQ_D; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +bool libspdm_get_responder_private_key_from_raw_data(uint32_t base_asym_algo, void **context) +{ +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) || (LIBSPDM_ECDSA_SUPPORT) + bool result; + +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) + void *rsa_context; + uint8_t *rsa_n; + uint8_t *rsa_e; + uint8_t *rsa_d; + size_t rsa_n_size; + size_t rsa_e_size; + size_t rsa_d_size; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +#if LIBSPDM_ECDSA_SUPPORT + void *ec_context; + size_t ec_nid; + uint8_t *ec_public; + uint8_t *ec_private; + size_t ec_public_size; + size_t ec_private_size; +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + + switch (base_asym_algo) { +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + rsa_n = m_libspdm_rsa2048_res_n; + rsa_e = m_libspdm_rsa2048_res_e; + rsa_d = m_libspdm_rsa2048_res_d; + rsa_n_size = sizeof(m_libspdm_rsa2048_res_n); + rsa_e_size = sizeof(m_libspdm_rsa2048_res_e); + rsa_d_size = sizeof(m_libspdm_rsa2048_res_d); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + rsa_n = m_libspdm_rsa3072_res_n; + rsa_e = m_libspdm_rsa3072_res_e; + rsa_d = m_libspdm_rsa3072_res_d; + rsa_n_size = sizeof(m_libspdm_rsa3072_res_n); + rsa_e_size = sizeof(m_libspdm_rsa3072_res_e); + rsa_d_size = sizeof(m_libspdm_rsa3072_res_d); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: + rsa_n = m_libspdm_rsa4096_res_n; + rsa_e = m_libspdm_rsa4096_res_e; + rsa_d = m_libspdm_rsa4096_res_d; + rsa_n_size = sizeof(m_libspdm_rsa4096_res_n); + rsa_e_size = sizeof(m_libspdm_rsa4096_res_e); + rsa_d_size = sizeof(m_libspdm_rsa4096_res_d); + break; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +#if LIBSPDM_ECDSA_SUPPORT + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + ec_nid = LIBSPDM_CRYPTO_NID_ECDSA_NIST_P256; + ec_public = m_libspdm_ec256_responder_public_key; + ec_private = m_libspdm_ec256_responder_private_key; + ec_public_size = sizeof(m_libspdm_ec256_responder_public_key); + ec_private_size = sizeof(m_libspdm_ec256_responder_private_key); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + ec_nid = LIBSPDM_CRYPTO_NID_ECDSA_NIST_P384; + ec_public = m_libspdm_ec384_responder_public_key; + ec_private = m_libspdm_ec384_responder_private_key; + ec_public_size = sizeof(m_libspdm_ec384_responder_public_key); + ec_private_size = sizeof(m_libspdm_ec384_responder_private_key); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: + ec_nid = LIBSPDM_CRYPTO_NID_ECDSA_NIST_P521; + ec_public = m_libspdm_ec521_responder_public_key; + ec_private = m_libspdm_ec521_responder_private_key; + ec_public_size = sizeof(m_libspdm_ec521_responder_public_key); + ec_private_size = sizeof(m_libspdm_ec521_responder_private_key); + break; +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + default: + LIBSPDM_ASSERT(false); + return false; + } + + switch (base_asym_algo) { + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) + rsa_context = libspdm_rsa_new(); + if (rsa_context == NULL) { + return false; + } + result = libspdm_rsa_set_key(rsa_context, LIBSPDM_RSA_KEY_N, rsa_n, rsa_n_size); + if (!result) { + libspdm_rsa_free(rsa_context); + return false; + } + result = libspdm_rsa_set_key(rsa_context, LIBSPDM_RSA_KEY_E, rsa_e, rsa_e_size); + if (!result) { + libspdm_rsa_free(rsa_context); + return false; + } + result = libspdm_rsa_set_key(rsa_context, LIBSPDM_RSA_KEY_D, rsa_d, rsa_d_size); + if (!result) { + libspdm_rsa_free(rsa_context); + return false; + } + *context = rsa_context; + return true; +#else + LIBSPDM_ASSERT(false); + return false; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: +#if LIBSPDM_ECDSA_SUPPORT + ec_context = libspdm_ec_new_by_nid(ec_nid); + if (ec_context == NULL) { + return false; + } + result = libspdm_ec_set_pub_key(ec_context, ec_public, ec_public_size); + if (!result) { + libspdm_ec_free(ec_context); + return false; + } + result = libspdm_ec_set_priv_key(ec_context, ec_private, ec_private_size); + if (!result) { + libspdm_ec_free(ec_context); + return false; + } + *context = ec_context; + return true; +#else + LIBSPDM_ASSERT(false); + return false; +#endif /*#LIBSPDM_ECDSA_SUPPORT*/ + } + +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) || (LIBSPDM_ECDSA_SUPPORT) */ + return false; +} + +bool libspdm_get_requester_private_key_from_raw_data(uint32_t base_asym_algo, void **context) +{ +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) || (LIBSPDM_ECDSA_SUPPORT) + bool result; + +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) + void *rsa_context; + uint8_t *rsa_n; + uint8_t *rsa_e; + uint8_t *rsa_d; + size_t rsa_n_size; + size_t rsa_e_size; + size_t rsa_d_size; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +#if LIBSPDM_ECDSA_SUPPORT + void *ec_context; + size_t ec_nid; + uint8_t *ec_public; + uint8_t *ec_private; + size_t ec_public_size; + size_t ec_private_size; +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + + switch (base_asym_algo) { +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + rsa_n = m_libspdm_rsa2048_req_n; + rsa_e = m_libspdm_rsa2048_req_e; + rsa_d = m_libspdm_rsa2048_req_d; + rsa_n_size = sizeof(m_libspdm_rsa2048_req_n); + rsa_e_size = sizeof(m_libspdm_rsa2048_req_e); + rsa_d_size = sizeof(m_libspdm_rsa2048_req_d); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + rsa_n = m_libspdm_rsa3072_req_n; + rsa_e = m_libspdm_rsa3072_req_e; + rsa_d = m_libspdm_rsa3072_req_d; + rsa_n_size = sizeof(m_libspdm_rsa3072_req_n); + rsa_e_size = sizeof(m_libspdm_rsa3072_req_e); + rsa_d_size = sizeof(m_libspdm_rsa3072_req_d); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: + rsa_n = m_libspdm_rsa4096_req_n; + rsa_e = m_libspdm_rsa4096_req_e; + rsa_d = m_libspdm_rsa4096_req_d; + rsa_n_size = sizeof(m_libspdm_rsa4096_req_n); + rsa_e_size = sizeof(m_libspdm_rsa4096_req_e); + rsa_d_size = sizeof(m_libspdm_rsa4096_req_d); + break; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + +#if LIBSPDM_ECDSA_SUPPORT + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + ec_nid = LIBSPDM_CRYPTO_NID_ECDSA_NIST_P256; + ec_public = m_libspdm_ec256_requester_public_key; + ec_private = m_libspdm_ec256_requester_private_key; + ec_public_size = sizeof(m_libspdm_ec256_requester_public_key); + ec_private_size = sizeof(m_libspdm_ec256_requester_private_key); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + ec_nid = LIBSPDM_CRYPTO_NID_ECDSA_NIST_P384; + ec_public = m_libspdm_ec384_requester_public_key; + ec_private = m_libspdm_ec384_requester_private_key; + ec_public_size = sizeof(m_libspdm_ec384_requester_public_key); + ec_private_size = sizeof(m_libspdm_ec384_requester_private_key); + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: + ec_nid = LIBSPDM_CRYPTO_NID_ECDSA_NIST_P521; + ec_public = m_libspdm_ec521_requester_public_key; + ec_private = m_libspdm_ec521_requester_private_key; + ec_public_size = sizeof(m_libspdm_ec521_requester_public_key); + ec_private_size = sizeof(m_libspdm_ec521_requester_private_key); + break; +#endif /*LIBSPDM_ECDSA_SUPPORT*/ + default: + LIBSPDM_ASSERT(false); + return false; + } + + switch (base_asym_algo) { + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: +#if (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) + rsa_context = libspdm_rsa_new(); + if (rsa_context == NULL) { + return false; + } + result = libspdm_rsa_set_key(rsa_context, LIBSPDM_RSA_KEY_N, rsa_n, rsa_n_size); + if (!result) { + libspdm_rsa_free(rsa_context); + return false; + } + result = libspdm_rsa_set_key(rsa_context, LIBSPDM_RSA_KEY_E, rsa_e, rsa_e_size); + if (!result) { + libspdm_rsa_free(rsa_context); + return false; + } + result = libspdm_rsa_set_key(rsa_context, LIBSPDM_RSA_KEY_D, rsa_d, rsa_d_size); + if (!result) { + libspdm_rsa_free(rsa_context); + return false; + } + *context = rsa_context; + return true; +#else + LIBSPDM_ASSERT(false); + return false; +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) */ + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: +#if LIBSPDM_ECDSA_SUPPORT + ec_context = libspdm_ec_new_by_nid(ec_nid); + if (ec_context == NULL) { + return false; + } + result = libspdm_ec_set_pub_key(ec_context, ec_public, ec_public_size); + if (!result) { + libspdm_ec_free(ec_context); + return false; + } + result = libspdm_ec_set_priv_key(ec_context, ec_private, ec_private_size); + if (!result) { + libspdm_ec_free(ec_context); + return false; + } + *context = ec_context; + return true; +#else + LIBSPDM_ASSERT(false); + return false; +#endif /*#LIBSPDM_ECDSA_SUPPORT*/ + } + +#endif /* (LIBSPDM_RSA_SSA_SUPPORT) || (LIBSPDM_RSA_PSS_SUPPORT) || (LIBSPDM_ECDSA_SUPPORT) */ + return false; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_priv_key_raw_data_pqc.c b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_raw_data_pqc.c new file mode 100644 index 00000000000..e50039fff3e --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_priv_key_raw_data_pqc.c @@ -0,0 +1,264 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "raw_data_key.h" +#include "internal/libspdm_common_lib.h" + +bool libspdm_get_responder_pqc_private_key_from_raw_data(uint32_t pqc_asym_algo, void **context) +{ +#if (LIBSPDM_ML_DSA_SUPPORT) || (LIBSPDM_SLH_DSA_SUPPORT) + bool res; + void *data; + size_t size; + char *file; + size_t nid; + void *dsa_context; + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_responder.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_responder.key.priv.raw"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + + res = libspdm_read_input_file(file, &data, &size); + + nid = libspdm_get_pqc_aysm_nid(pqc_asym_algo); + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: +#if LIBSPDM_ML_DSA_SUPPORT + dsa_context = libspdm_mldsa_new(nid); + if (dsa_context == NULL) { + return false; + } + res = libspdm_mldsa_set_privkey(dsa_context, data, size); + if (!res) { + libspdm_mldsa_free(dsa_context); + return false; + } + *context = dsa_context; + return true; +#else + return false; +#endif + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: +#if LIBSPDM_SLH_DSA_SUPPORT + dsa_context = libspdm_slhdsa_new(nid); + if (dsa_context == NULL) { + return false; + } + res = libspdm_slhdsa_set_privkey(dsa_context, data, size); + if (!res) { + libspdm_slhdsa_free(dsa_context); + return false; + } + *context = dsa_context; + return true; +#else + return false; +#endif + break; + default: + LIBSPDM_ASSERT(false); + return false; + } +#else + return false; +#endif /* (LIBSPDM_ML_DSA_SUPPORT) || (LIBSPDM_SLH_DSA_SUPPORT) */ +} + +bool libspdm_get_requester_pqc_private_key_from_raw_data(uint32_t req_pqc_asym_algo, void **context) +{ +#if (LIBSPDM_ML_DSA_SUPPORT) || (LIBSPDM_SLH_DSA_SUPPORT) + bool res; + void *data; + size_t size; + char *file; + size_t nid; + void *dsa_context; + + switch (req_pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_requester.key.priv.raw"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_requester.key.priv.raw"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + + res = libspdm_read_input_file(file, &data, &size); + + nid = libspdm_get_pqc_aysm_nid(req_pqc_asym_algo); + + switch (req_pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: +#if LIBSPDM_ML_DSA_SUPPORT + dsa_context = libspdm_mldsa_new(nid); + if (dsa_context == NULL) { + return false; + } + res = libspdm_mldsa_set_privkey(dsa_context, data, size); + if (!res) { + libspdm_mldsa_free(dsa_context); + return false; + } + *context = dsa_context; + return true; +#else + return false; +#endif + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: +#if LIBSPDM_SLH_DSA_SUPPORT + dsa_context = libspdm_slhdsa_new(nid); + if (dsa_context == NULL) { + return false; + } + res = libspdm_slhdsa_set_privkey(dsa_context, data, size); + if (!res) { + libspdm_slhdsa_free(dsa_context); + return false; + } + *context = dsa_context; + return true; +#else + return false; +#endif + break; + default: + LIBSPDM_ASSERT(false); + return false; + } +#else + return false; +#endif /* (LIBSPDM_ML_DSA_SUPPORT) || (LIBSPDM_SLH_DSA_SUPPORT) */ +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_pub_cert.c b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert.c new file mode 100644 index 00000000000..40329bd265d --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert.c @@ -0,0 +1,253 @@ +/** + * Copyright Notice: + * Copyright 2021-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" +#include "hal/library/cryptlib/cryptlib_tpm.h" + +static bool get_certificate(const char *handle, uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + bool result; + void *cert_handler; + void *cert; + size_t cert_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + size_t digest_size; + + if (base_asym_algo != SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256) { + LIBSPDM_DEBUG((LIBSPDM_DEBUG_ERROR, "unsupported asym algo %d\n", base_asym_algo)); + return false; + } + + if (!libspdm_tpm_device_init()) + return false; + + result = libspdm_tpm_get_certificate((void *)handle, &cert_handler); + if (!result) + return false; + + result = libspdm_tpm_dump_certificate(cert_handler, &cert, &cert_size); + if (!result) + return false; + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + cert_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL){ + result = false; + goto cleanup_cert; + } + cert_chain->length = (uint32_t)cert_chain_size; + + result = libspdm_hash_all(base_hash_algo, cert, cert_size, + (uint8_t *)(cert_chain + 1)); + if (!result){ + result = false; + free(cert_chain); + goto cleanup_cert; + } + + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + cert, cert_size); + + *data = cert_chain; + *size = cert_chain_size; + + if (hash != NULL) + *hash = (cert_chain + 1); + + if (hash_size != NULL) + *hash_size = digest_size; + +cleanup_cert: + free(cert); + + return result; +} + +static bool get_certificate_chain(const char *filename, uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size, + bool is_requester_cert, bool is_device_cert_model) +{ + bool result; + void *cert; + size_t cert_size; + const uint8_t *root_cert; + size_t root_cert_len; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + size_t digest_size; + + if (base_asym_algo != SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256){ + fprintf(stderr, "ERROR: unsupported asym algo %d\n", base_asym_algo); + return false; + } + + libspdm_read_input_file(filename, &cert, &cert_size); + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + cert_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL){ + result = false; + goto cleanup_cert; + } + cert_chain->length = (uint32_t)cert_chain_size; + result = libspdm_verify_cert_chain_data(cert, cert_size, + base_asym_algo, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!result) + goto cleanup_cert_chain; + + result = libspdm_x509_get_cert_from_cert_chain(cert, cert_size, 0, &root_cert, + &root_cert_len); + if (!result) + goto cleanup_cert_chain; + + result = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!result) + goto cleanup_cert_chain; + + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + cert, cert_size); + + *data = cert_chain; + *size = cert_chain_size; + + if (hash != NULL) + *hash = (cert_chain + 1); + + if (hash_size != NULL) + *hash_size = digest_size; + + if (result) + goto cleanup_cert; + +cleanup_cert_chain: + free(cert_chain); + +cleanup_cert: + free(cert); + + return result; +} + +bool libspdm_read_requester_root_public_certificate(uint32_t base_hash_algo, + uint16_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + return get_certificate("handle:0x1500021", base_hash_algo, base_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_requester_public_certificate_chain( + uint32_t base_hash_algo, uint16_t req_base_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + return get_certificate_chain("requester_certchain.der", base_hash_algo, req_base_asym_alg, data, size, hash, + hash_size, false, true); +} + +bool libspdm_read_responder_certificate(uint32_t base_asym_algo, + void **data, size_t *size) +{ + bool result; + void *cert_handler; + void *cert; + size_t cert_size; + + if (base_asym_algo != SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256){ + fprintf(stderr, "ERROR: unsupported asym algo %d\n", base_asym_algo); + return false; + } + + if (!libspdm_tpm_device_init()) + return false; + + result = libspdm_tpm_get_certificate((void *)"0x1500023", &cert_handler); + if (!result) + return false; + + result = libspdm_tpm_dump_certificate(cert_handler, &cert, &cert_size); + if (!result) + return false; + + return true; +} + +bool libspdm_read_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + return get_certificate("handle:0x1500021", base_hash_algo, base_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + return get_certificate_chain("responder_certchain.der", base_hash_algo, base_asym_algo, data, size, hash, hash_size, + false, true); +} + +bool libspdm_read_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + return get_certificate("handle:0x1500021", base_hash_algo, base_asym_algo, data, size, hash, hash_size); +} + +bool libspdm_read_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t base_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size) +{ + return get_certificate_chain("responder_certchain.der", base_hash_algo, base_asym_algo, data, size, hash, hash_size, + false, true); +} + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + libspdm_debug_print(LIBSPDM_DEBUG_ERROR, + "libspdm_read_responder_public_certificate_chain_alias_cert_till_dev_cert_ca not yet implemented\n"); + return false; +} + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + libspdm_debug_print(LIBSPDM_DEBUG_ERROR, + "libspdm_read_responder_public_certificate_chain_alias_cert not yet implemented\n"); + return false; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_pub_cert_pqc.c b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert_pqc.c new file mode 100644 index 00000000000..a26ebceb440 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_pub_cert_pqc.c @@ -0,0 +1,1287 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" + +bool libspdm_read_pqc_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t pqc_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + size_t digest_size; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (pqc_asym_algo == 0) { + return false; + } + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/ca.cert.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_hash_all(base_hash_algo, file_data, file_size, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +bool libspdm_read_pqc_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t pqc_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + size_t digest_size; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (pqc_asym_algo == 0) { + return false; + } + + if (slot_id == 0) { + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/ca.cert.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + } else { + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/ca1.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/ca1.cert.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_hash_all(base_hash_algo, file_data, file_size, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +bool libspdm_read_pqc_requester_root_public_certificate(uint32_t base_hash_algo, + uint32_t req_pqc_asym_alg, + void **data, size_t *size, + void **hash, + size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + size_t digest_size; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (req_pqc_asym_alg == 0) { + return false; + } + + switch (req_pqc_asym_alg) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/ca.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/ca.cert.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + res = libspdm_hash_all(base_hash_algo, file_data, file_size, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +bool libspdm_read_pqc_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + const uint8_t *root_cert; + size_t root_cert_len; + size_t digest_size; + bool is_requester_cert; + bool is_device_cert_model; + + is_requester_cert = false; + + /*default is true*/ + is_device_cert_model = true; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (pqc_asym_algo == 0) { + return false; + } + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/bundle_responder.certchain.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_verify_cert_chain_data_with_pqc(file_data, file_size, + 0, pqc_asym_algo, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + + /* Get Root Certificate and calculate hash value*/ + + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, 0, &root_cert, + &root_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + res = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + const uint8_t *root_cert; + size_t root_cert_len; + const uint8_t *leaf_cert; + size_t leaf_cert_len; + size_t digest_size; + bool is_requester_cert; + bool is_device_cert_model; + + is_requester_cert = false; + + /*default is false*/ + is_device_cert_model = false; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (pqc_asym_algo == 0) { + return false; + } + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/bundle_responder.certchain_alias_cert_partial_set.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + /* Get leaf Certificate*/ + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, -1, &leaf_cert, + &leaf_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + res = libspdm_x509_set_cert_certificate_check_with_pqc(leaf_cert, leaf_cert_len, + 0, pqc_asym_algo, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + /* Get Root Certificate*/ + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, 0, &root_cert, + &root_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + /*verify cert_chain*/ + res = libspdm_x509_verify_cert_chain(root_cert, root_cert_len, file_data, file_size); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + /*calculate hash value*/ + res = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + const uint8_t *root_cert; + size_t root_cert_len; + const uint8_t *leaf_cert; + size_t leaf_cert_len; + size_t digest_size; + bool is_requester_cert; + bool is_device_cert_model; + + is_requester_cert = false; + + /*default is false*/ + is_device_cert_model = false; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (pqc_asym_algo == 0) { + return false; + } + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/bundle_responder.certchain_alias.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/bundle_responder.certchain_alias.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + /* Get leaf Certificate*/ + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, -1, &leaf_cert, + &leaf_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + res = libspdm_x509_certificate_check_with_pqc(leaf_cert, leaf_cert_len, + 0, pqc_asym_algo, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + /* Get Root Certificate*/ + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, 0, &root_cert, + &root_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + /*verify cert_chain*/ + res = libspdm_x509_verify_cert_chain(root_cert, root_cert_len, file_data, file_size); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + /*calculate hash value*/ + res = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +bool libspdm_read_pqc_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t pqc_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + const uint8_t *root_cert; + size_t root_cert_len; + size_t digest_size; + bool is_requester_cert; + bool is_device_cert_model; + + is_requester_cert = false; + + /*default is true*/ + is_device_cert_model = true; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (pqc_asym_algo == 0) { + return false; + } + + if (slot_id == 0) { + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/bundle_responder.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/bundle_responder.certchain.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + } else { + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/bundle_responder.certchain1.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/bundle_responder.certchain1.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_verify_cert_chain_data_with_pqc(file_data, file_size, + 0, pqc_asym_algo, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + + /* Get Root Certificate and calculate hash value*/ + + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, 0, &root_cert, + &root_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + res = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + + +bool libspdm_read_pqc_requester_public_certificate_chain( + uint32_t base_hash_algo, uint32_t req_pqc_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + const uint8_t *root_cert; + size_t root_cert_len; + size_t digest_size; + bool is_requester_cert; + bool is_device_cert_model; + + is_requester_cert = false; + + /*default is true*/ + is_device_cert_model = true; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + if (req_pqc_asym_alg == 0) { + return false; + } + + switch (req_pqc_asym_alg) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/bundle_requester.certchain.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/bundle_requester.certchain.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_verify_cert_chain_data_with_pqc(file_data, file_size, + 0, req_pqc_asym_alg, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + + /* Get Root Certificate and calculate hash value*/ + + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, 0, &root_cert, + &root_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + res = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +bool libspdm_read_responder_pqc_certificate(uint32_t pqc_asym_algo, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_responder.cert.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_responder.cert.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_pub_key_der.c b/os_stub/spdm_device_secret_lib_tpm/read_pub_key_der.c new file mode 100644 index 00000000000..bfb01088068 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_pub_key_der.c @@ -0,0 +1,109 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +bool libspdm_read_responder_public_key(uint32_t base_asym_algo, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (base_asym_algo) { + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + file = "rsa2048/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + file = "rsa3072/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: + file = "rsa4096/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + file = "ecp256/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + file = "ecp384/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: + file = "ecp521/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256: + file = "sm2/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519: + file = "ed25519/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448: + file = "ed448/end_responder.key.pub.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} + +bool libspdm_read_requester_public_key(uint16_t req_base_asym_alg, + void **data, size_t *size) +{ + bool res; + char *file; + + switch (req_base_asym_alg) { + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_2048: + file = "rsa2048/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_3072: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_3072: + file = "rsa3072/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_4096: + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSAPSS_4096: + file = "rsa4096/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P256: + file = "ecp256/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P384: + file = "ecp384/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_ECDSA_ECC_NIST_P521: + file = "ecp521/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_SM2_ECC_SM2_P256: + file = "sm2/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED25519: + file = "ed25519/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_BASE_ASYM_ALGO_EDDSA_ED448: + file = "ed448/end_requester.key.pub.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_pub_key_der_pqc.c b/os_stub/spdm_device_secret_lib_tpm/read_pub_key_der_pqc.c new file mode 100644 index 00000000000..eeece428643 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_pub_key_der_pqc.c @@ -0,0 +1,139 @@ +/** + * Copyright Notice: + * Copyright 2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +bool libspdm_read_responder_pqc_public_key( + uint32_t pqc_asym_algo, void **data, size_t *size) +{ + bool res; + char *file; + + switch (pqc_asym_algo) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_responder.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_responder.key.pub.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} + +bool libspdm_read_requester_pqc_public_key( + uint32_t req_pqc_asym_alg, void **data, size_t *size) +{ + bool res; + char *file; + + switch (req_pqc_asym_alg) { + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_44: + file = "mldsa44/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_65: + file = "mldsa65/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_ML_DSA_87: + file = "mldsa87/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128S: + file = "slh-dsa-sha2-128s/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128S: + file = "slh-dsa-shake-128s/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_128F: + file = "slh-dsa-sha2-128f/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_128F: + file = "slh-dsa-shake-128f/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192S: + file = "slh-dsa-sha2-192s/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192S: + file = "slh-dsa-shake-192s/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_192F: + file = "slh-dsa-sha2-192f/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_192F: + file = "slh-dsa-shake-192f/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256S: + file = "slh-dsa-sha2-256s/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256S: + file = "slh-dsa-shake-256s/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHA2_256F: + file = "slh-dsa-sha2-256f/end_requester.key.pub.der"; + break; + case SPDM_ALGORITHMS_PQC_ASYM_ALGO_SLH_DSA_SHAKE_256F: + file = "slh-dsa-shake-256f/end_requester.key.pub.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, data, size); + return res; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/read_special_cert.c b/os_stub/spdm_device_secret_lib_tpm/read_special_cert.c new file mode 100644 index 00000000000..72fd1b065a4 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/read_special_cert.c @@ -0,0 +1,202 @@ +/** + * Copyright Notice: + * Copyright 2024-2025 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +bool libspdm_read_responder_root_public_certificate_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t chain_id, + void **data, size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + size_t digest_size; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + switch (chain_id) { + case LIBSPDM_TEST_CERT_SMALL: + file = "long_chains/Shorter1024B_ca.cert.der"; + break; + case LIBSPDM_TEST_CERT_MAXINT16: /* data_size slightly smaller than 0x7FFF*/ + file = "long_chains/ShorterMAXINT16_ca.cert.der"; + break; + case LIBSPDM_TEST_CERT_MAXUINT16: /* data_size slightly smaller than 0xFFFF*/ + file = "long_chains/ShorterMAXUINT16_ca.cert.der"; + break; + case LIBSPDM_LIBSPDM_TEST_CERT_MAXUINT16_LARGER: /* data_size larger than 0xFFFF*/ + file = "long_chains/LongerMAXUINT16_ca.cert.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_hash_all(base_hash_algo, file_data, file_size, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} + +bool libspdm_read_responder_public_certificate_chain_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t chain_id, + void **data, size_t *size, void **hash, size_t *hash_size) +{ + bool res; + void *file_data; + size_t file_size; + spdm_cert_chain_t *cert_chain; + size_t cert_chain_size; + char *file; + const uint8_t *root_cert; + size_t root_cert_len; + size_t digest_size; + bool is_requester_cert; + bool is_device_cert_model; + + is_requester_cert = false; + + /*default is true*/ + is_device_cert_model = true; + + *data = NULL; + *size = 0; + if (hash != NULL) { + *hash = NULL; + } + if (hash_size != NULL) { + *hash_size = 0; + } + + switch (chain_id) { + case LIBSPDM_TEST_CERT_SMALL: /* data_size smaller than 1024 Bytes*/ + file = "long_chains/Shorter1024B_bundle_responder.certchain.der"; + break; + case LIBSPDM_TEST_CERT_MAXINT16: /* data_size slightly smaller than 0x7FFF*/ + file = "long_chains/ShorterMAXINT16_bundle_responder.certchain.der"; + break; + case LIBSPDM_TEST_CERT_MAXUINT16: /* data_size slightly smaller than 0xFFFF*/ + file = "long_chains/ShorterMAXUINT16_bundle_responder.certchain.der"; + break; + case LIBSPDM_LIBSPDM_TEST_CERT_MAXUINT16_LARGER: /* data_size larger than 0xFFFF*/ + file = "long_chains/LongerMAXUINT16_bundle_responder.certchain.der"; + break; + default: + LIBSPDM_ASSERT(false); + return false; + } + res = libspdm_read_input_file(file, &file_data, &file_size); + if (!res) { + return res; + } + + digest_size = libspdm_get_hash_size(base_hash_algo); + + cert_chain_size = sizeof(spdm_cert_chain_t) + digest_size + file_size; + cert_chain = (void *)malloc(cert_chain_size); + if (cert_chain == NULL) { + free(file_data); + return false; + } + cert_chain->length = (uint32_t)cert_chain_size; + + res = libspdm_verify_cert_chain_data(file_data, file_size, + base_asym_algo, base_hash_algo, + is_requester_cert, is_device_cert_model); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + + /* Get Root Certificate and calculate hash value*/ + + res = libspdm_x509_get_cert_from_cert_chain(file_data, file_size, 0, &root_cert, + &root_cert_len); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + + res = libspdm_hash_all(base_hash_algo, root_cert, root_cert_len, + (uint8_t *)(cert_chain + 1)); + if (!res) { + free(file_data); + free(cert_chain); + return res; + } + libspdm_copy_mem((uint8_t *)cert_chain + sizeof(spdm_cert_chain_t) + digest_size, + cert_chain_size - (sizeof(spdm_cert_chain_t) + digest_size), + file_data, file_size); + + *data = cert_chain; + *size = cert_chain_size; + if (hash != NULL) { + *hash = (cert_chain + 1); + } + if (hash_size != NULL) { + *hash_size = digest_size; + } + + free(file_data); + return true; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/set_cert.c b/os_stub/spdm_device_secret_lib_tpm/set_cert.c new file mode 100644 index 00000000000..e02edce9d5d --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/set_cert.c @@ -0,0 +1,106 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#if defined(_WIN32) || (defined(__clang__) && (defined (LIBSPDM_CPU_AARCH64) || \ + defined(LIBSPDM_CPU_ARM))) +#else + #include + #include + #include +#endif +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "internal/libspdm_common_lib.h" + +bool g_in_trusted_environment = false; +bool g_set_cert_is_busy = false; + +#if LIBSPDM_ENABLE_CAPABILITY_SET_CERT_CAP +bool libspdm_is_in_trusted_environment(void *spdm_context) +{ + return g_in_trusted_environment; +} + +bool libspdm_write_certificate_to_nvm( + void *spdm_context, + uint8_t slot_id, const void * cert_chain, + size_t cert_chain_size, + uint32_t base_hash_algo, uint32_t base_asym_algo, uint32_t pqc_asym_algo, + bool *need_reset, bool *is_busy) +{ + if (g_set_cert_is_busy) { + *is_busy = true; + + return false; + } else { + #if defined(_WIN32) || (defined(__clang__) && (defined (LIBSPDM_CPU_AARCH64) || \ + defined(LIBSPDM_CPU_ARM))) + FILE *fp_out; + #else + int64_t fp_out; + #endif + + char file_name[] = "slot_id_0_cert_chain.der"; + /*change the file name, for example: slot_id_1_cert_chain.der*/ + file_name[8] = (char)(slot_id+'0'); + + /*check the input parameter*/ + if ((cert_chain == NULL) ^ (cert_chain_size == 0) ) { + return false; + } + + #if defined(_WIN32) || (defined(__clang__) && (defined (LIBSPDM_CPU_AARCH64) || \ + defined(LIBSPDM_CPU_ARM))) + if ((fp_out = fopen(file_name, "w+b")) == NULL) { + printf("Unable to open file %s\n", file_name); + return false; + } + + if (cert_chain != NULL) { + if ((fwrite(cert_chain, 1, cert_chain_size, fp_out)) != cert_chain_size) { + printf("Write output file error %s\n", file_name); + fclose(fp_out); + return false; + } + } + + fclose(fp_out); + #else + if (cert_chain != NULL) { + if ((fp_out = open(file_name, O_WRONLY | O_CREAT, S_IRWXU)) == -1) { + printf("Unable to open file %s\n", file_name); + return false; + } + + if ((write(fp_out, cert_chain, cert_chain_size)) != cert_chain_size) { + printf("Write output file error %s\n", file_name); + close(fp_out); + return false; + } + } else { + if ((fp_out = open(file_name, O_WRONLY | O_TRUNC)) == -1) { + printf("Unable to open file %s\n", file_name); + return false; + } + } + + close(fp_out); + #endif + + return true; + } +} +#endif /* LIBSPDM_ENABLE_CAPABILITY_SET_CERT_CAP */ diff --git a/os_stub/spdm_device_secret_lib_tpm/sign.c b/os_stub/spdm_device_secret_lib_tpm/sign.c new file mode 100644 index 00000000000..9303de7fd90 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/sign.c @@ -0,0 +1,89 @@ +/** + * Copyright Notice: + * Copyright 2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "library/memlib.h" +#include "spdm_device_secret_lib_internal.h" +#include "hal/library/cryptlib/cryptlib_tpm.h" +#include "internal/libspdm_common_lib.h" + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_requester_data_sign( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t key_pair_id, uint8_t op_code, + uint16_t req_base_asym_alg, uint32_t req_pqc_asym_alg, + uint32_t base_hash_algo, bool is_data_hash, + const uint8_t *message, size_t message_size, + uint8_t *signature, size_t *sig_size) +{ + void *context = NULL; + bool result = false; + + libspdm_debug_print(SPDM_ERROR, "Loading TPM device"); + libspdm_tpm_device_init(); + result = libspdm_tpm_get_private_key("handle:0x81000002", &context); + if (!result){ + libspdm_debug_print(SPDM_ERROR, "Failed to load requester handle"); + return false; + } + + if (is_data_hash){ + result = libspdm_req_asym_sign_hash( + spdm_version, op_code, req_base_asym_alg, base_hash_algo, context, + message, message_size, signature, sig_size); + } else { + result = libspdm_req_asym_sign(spdm_version, op_code, req_base_asym_alg, + base_hash_algo, context, message, + message_size, signature, sig_size); + } + libspdm_asym_free(req_base_asym_alg, context); + + return result; +} +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +bool libspdm_responder_data_sign( + void *spdm_context, + spdm_version_number_t spdm_version, + uint8_t key_pair_id, uint8_t op_code, + uint32_t base_asym_algo, uint32_t pqc_asym_algo, + uint32_t base_hash_algo, bool is_data_hash, + const uint8_t *message, size_t message_size, + uint8_t *signature, size_t *sig_size) +{ + void *context = NULL; + bool result = false; + + libspdm_tpm_device_init(); + result = libspdm_tpm_get_private_key("handle:0x81000003", &context); + if (!result){ + libspdm_debug_print(SPDM_ERROR, "Failed to load responder handle"); + return false; + } + + if (is_data_hash){ + result = libspdm_asym_sign_hash(spdm_version, op_code, base_asym_algo, + base_hash_algo, context, message, + message_size, signature, sig_size); + } else { + result = + libspdm_asym_sign(spdm_version, op_code, base_asym_algo, base_hash_algo, + context, message, message_size, signature, sig_size); + } + libspdm_asym_free(base_asym_algo, context); + + return result; +} diff --git a/os_stub/spdm_device_secret_lib_tpm/spdm_device_secret_lib_internal.h b/os_stub/spdm_device_secret_lib_tpm/spdm_device_secret_lib_internal.h new file mode 100644 index 00000000000..fef326c5909 --- /dev/null +++ b/os_stub/spdm_device_secret_lib_tpm/spdm_device_secret_lib_internal.h @@ -0,0 +1,231 @@ +/** + * Copyright Notice: + * Copyright 2021-2024 DMTF. All rights reserved. + * License: BSD 3-Clause License. For full text see link: https://github.com/DMTF/libspdm/blob/main/LICENSE.md + **/ + +#ifndef __SPDM_DEVICE_SECRET_LIB_INTERNAL_H__ +#define __SPDM_DEVICE_SECRET_LIB_INTERNAL_H__ + +#include "library/spdm_crypt_lib.h" +#include "spdm_crypt_ext_lib/spdm_crypt_ext_lib.h" +#include "spdm_crypt_ext_lib/cryptlib_ext.h" +#include "hal/library/responder/asymsignlib.h" +#include "hal/library/responder/csrlib.h" +#include "hal/library/responder/measlib.h" +#include "hal/library/responder/key_pair_info.h" +#include "hal/library/responder/psklib.h" +#include "hal/library/responder/setcertlib.h" +#include "hal/library/requester/reqasymsignlib.h" +#include "hal/library/requester/psklib.h" +#include "hal/library/debuglib.h" +#include "hal/library/cryptlib.h" +#include "industry_standard/cxl_tsp.h" + +/* for meas test */ +#define LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER 4 +#define LIBSPDM_MEASUREMENT_BLOCK_NUMBER (LIBSPDM_MEASUREMENT_BLOCK_HASH_NUMBER /*Index - 1~4*/ + \ + 1 /*SVN - 0x10*/ + \ + 1 /*HEM - 0x11*/ + \ + 1 /*Manifest - 0xFD*/ + 1 /*DEVICE_MODE - 0xFE*/) +#define LIBSPDM_MEASUREMENT_RAW_DATA_SIZE 72 +#define LIBSPDM_MEASUREMENT_MANIFEST_SIZE 128 +#define LIBSPDM_MEASUREMENT_INDEX_SVN 0x10 +#define LIBSPDM_MEASUREMENT_INDEX_HEM 0x11 + +/* for psk test */ +#define LIBSPDM_TEST_PSK_DATA_STRING "TestPskData" +#define LIBSPDM_TEST_PSK_HINT_STRING "TestPskHint" + +/* for cert test */ +#define LIBSPDM_TEST_CERT_MAXINT16 1 +#define LIBSPDM_TEST_CERT_MAXUINT16 2 +#define LIBSPDM_LIBSPDM_TEST_CERT_MAXUINT16_LARGER 3 +#define LIBSPDM_TEST_CERT_SMALL 4 + +/* "LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY = 1" means use the RAW private key only + * "LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY = 0" means controlled by g_private_key_mode + **/ +#define LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY 0 +/* "g_private_key_mode = 1" means use the PEM mode + * "g_private_key_mode = 0" means use the RAW mode + **/ +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +extern bool g_private_key_mode; +#endif + +/* Option to change signing algorithm to little endian. Default is big endian. */ +#define LIBSPDM_SECRET_LIB_SIGN_LITTLE_ENDIAN (0) + +/* read pub cert */ + +bool libspdm_read_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t base_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t base_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_requester_public_certificate_chain( + uint32_t base_hash_algo, uint16_t req_base_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t base_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_requester_root_public_certificate(uint32_t base_hash_algo, + uint16_t req_base_asym_alg, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_responder_certificate(uint32_t base_asym_algo, + void **data, size_t *size); + +/* read pub cert pqc */ + +bool libspdm_read_pqc_responder_public_certificate_chain( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is partial, from root CA to device certificate CA.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert_till_dev_cert_ca( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +/*This alias cert chain is entire, from root CA to leaf certificate.*/ +bool libspdm_read_pqc_responder_public_certificate_chain_alias_cert( + uint32_t base_hash_algo, uint32_t pqc_asym_algo, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_pqc_responder_public_certificate_chain_per_slot( + uint8_t slot_id, uint32_t base_hash_algo, uint32_t pqc_asym_algo, + void **data, size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_pqc_requester_public_certificate_chain( + uint32_t base_hash_algo, uint32_t req_pqc_asym_alg, void **data, + size_t *size, void **hash, size_t *hash_size); + +bool libspdm_read_pqc_responder_root_public_certificate(uint32_t base_hash_algo, + uint32_t pqc_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_pqc_responder_root_public_certificate_slot(uint8_t slot_id, + uint32_t base_hash_algo, + uint32_t pqc_asym_algo, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_pqc_requester_root_public_certificate(uint32_t base_hash_algo, + uint32_t req_pqc_asym_alg, + void **data, size_t *size, + void **hash, + size_t *hash_size); + +bool libspdm_read_responder_pqc_certificate(uint32_t base_asym_algo, + void **data, size_t *size); + +/* read special cert */ + +bool libspdm_read_responder_public_certificate_chain_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t CertId, + void **data, size_t *size, void **hash, + size_t *hash_size); + +bool libspdm_read_responder_root_public_certificate_by_size( + uint32_t base_hash_algo, uint32_t base_asym_algo, uint16_t CertId, + void **data, size_t *size, void **hash, + size_t *hash_size); + +/* read pub key der */ + +bool libspdm_read_responder_public_key( + uint32_t base_asym_algo, void **data, size_t *size); + +bool libspdm_read_requester_public_key( + uint16_t req_base_asym_alg, void **data, size_t *size); + +/* read pub key der pqc */ + +bool libspdm_read_responder_pqc_public_key( + uint32_t pqc_asym_algo, void **data, size_t *size); + +bool libspdm_read_requester_pqc_public_key( + uint32_t req_pqc_asym_alg, void **data, size_t *size); + +/* read priv key pem */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_private_key(uint32_t base_asym_algo, + void **data, size_t *size); +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_private_key(uint16_t req_base_asym_alg, + void **data, size_t *size); +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +/* read priv key pem pqc */ + +#if !LIBSPDM_PRIVATE_KEY_MODE_RAW_KEY_ONLY +bool libspdm_read_responder_pqc_private_key(uint32_t pqc_asym_algo, + void **data, size_t *size); +#endif + +#if (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (LIBSPDM_ENABLE_CAPABILITY_ENDPOINT_INFO_CAP) +bool libspdm_read_requester_pqc_private_key(uint32_t req_pqc_asym_alg, + void **data, size_t *size); +#endif /* (LIBSPDM_ENABLE_CAPABILITY_MUT_AUTH_CAP) || (...) */ + +/* read priv key raw data */ + +bool libspdm_get_responder_private_key_from_raw_data(uint32_t base_asym_algo, void **context); + +bool libspdm_get_requester_private_key_from_raw_data(uint32_t base_asym_algo, void **context); + +/* read priv key raw data pqc */ + +bool libspdm_get_responder_pqc_private_key_from_raw_data(uint32_t pqc_asym_algo, void **context); + +bool libspdm_get_requester_pqc_private_key_from_raw_data(uint32_t req_pqc_asym_algo, void **context); + +/* key pairs */ +#if LIBSPDM_ENABLE_CAPABILITY_GET_KEY_PAIR_INFO_CAP +uint8_t libspdm_read_total_key_pairs(void *spdm_context); +#endif + +/* External*/ + +bool libspdm_read_input_file(const char *file_name, void **file_data, + size_t *file_size); + +bool libspdm_write_output_file(const char *file_name, const void *file_data, + size_t file_size); + +void libspdm_dump_hex_str(const uint8_t *buffer, size_t buffer_size); + +#endif diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt index 2bbb9392184..1d0097fdee4 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_key_exchange ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_key_exchange ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt index 208d8598fad..56c6859863c 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_key_update/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_key_update ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_key_update ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt index c6c9e861e4e..8db092159c0 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_negotiate_algorithms ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_negotiate_algorithms ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_requester_negotiate_algorithms @@ -61,6 +61,6 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt index 63c2ca97073..a3b26db46cc 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_psk_exchange ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_psk_exchange ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt index a95fe21ed7e..956426fa814 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_psk_finish ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_psk_finish ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt index fcc6db22af5..df5bf29e8d2 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_set_certificate ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_set_certificate ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt b/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt index df1be3b0385..64f53d3b458 100644 --- a/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt +++ b/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds/CMakeLists.txt @@ -7,7 +7,7 @@ target_include_directories(test_spdm_requester_vendor_cmds ${LIBSPDM_DIR}/unit_test/fuzzing/test_requester/test_spdm_requester_vendor_cmds ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ ) else() @@ -62,7 +62,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt index 93693498a18..a19a9df670f 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_certificate/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_certificate ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt index 069e1655bb3..14de85b8ccd 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_get/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_chunk_get ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt index f805433b00d..f877390be5f 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_chunk_send_ack/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_chunk_send_ack ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt index 8ed364b4fdb..eb110295291 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_csr/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_csr ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt index cd7eb3b48d2..a6ee1eb6f23 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_challenge/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_challenge ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt index 41ef018ac9d..05cd1274a4f 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_certificate/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_get_certificate ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt index 9587706859a..87eaf20f56e 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_get_digests/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_get_digests ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt index b17e8e6b1e0..01174e1ecc0 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_key_update/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_key_update ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt index bce20f7ba85..8ba13e2ac12 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_encap_response/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_encap_response ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt index b2c8280fb8d..2d742e70c40 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_end_session/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_end_session ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt index b2ff7982195..557e1032b8e 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_finish_rsp/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_finish_rsp ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt index 9ae072c84f1..c8f20b81c43 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_heartbeat_ack/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_heartbeat_ack ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt index 6989e8690da..041287bdf2d 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_if_ready/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_if_ready ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt index af732eef19d..4d803914534 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_key_exchange/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_key_exchange ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt index 27ce4cf4ebc..72ebee2bee2 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_key_pair_info/CMakeLists.txt @@ -8,7 +8,7 @@ target_include_directories(test_spdm_responder_key_pair_info ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub ) @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_responder_key_pair_info @@ -61,6 +61,6 @@ else() spdm_secured_message_lib spdm_transport_test_lib platform_lib_null - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt index a909b370e8d..9d9cea39a10 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_key_update/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_key_update ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt index 88e9b84db3e..8c0fced9769 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_measurement_extension_log/CMakeLists.txt @@ -42,7 +42,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_responder_measurement_extension_log @@ -60,6 +60,6 @@ else() spdm_secured_message_lib spdm_transport_test_lib platform_lib_null - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt index fce3c7ed151..4f90f5fdafc 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_measurements/CMakeLists.txt @@ -8,7 +8,7 @@ target_include_directories(test_spdm_responder_measurements ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub ) @@ -42,7 +42,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -61,7 +61,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt index 3c6d667c673..c7ad0964c8b 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_exchange_rsp/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_psk_exchange_rsp ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -64,7 +64,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt index b3b18428112..6b5e653c6e0 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_psk_finish_rsp/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_psk_finish_rsp ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt index d45a4181820..809039da881 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_set_certificate/CMakeLists.txt @@ -9,7 +9,7 @@ target_include_directories(test_spdm_responder_set_certificate ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub @@ -44,7 +44,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -63,7 +63,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt index a6b05d614c1..0b4f2a0666b 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_set_key_pair_info_ack/CMakeLists.txt @@ -8,7 +8,7 @@ target_include_directories(test_spdm_responder_set_key_pair_info_ack ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include ${LIBSPDM_DIR}/unit_test/fuzzing/spdm_unit_fuzzing_common - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/include ${LIBSPDM_DIR}/os_stub ) @@ -43,7 +43,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ ) else() target_link_libraries(test_spdm_responder_set_key_pair_info_ack @@ -61,6 +61,6 @@ else() spdm_secured_message_lib spdm_transport_test_lib platform_lib_null - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt index a11a85a8122..18877096870 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_supported_event_types/CMakeLists.txt @@ -41,7 +41,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -60,7 +60,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt b/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt index 394203f1444..60e2ccbcac9 100644 --- a/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt +++ b/unit_test/fuzzing/test_responder/test_spdm_responder_vendor_cmds/CMakeLists.txt @@ -41,7 +41,7 @@ if((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC")) $ $ $ - $ + $ $ $ ) @@ -60,7 +60,7 @@ else() spdm_crypt_ext_lib spdm_secured_message_lib spdm_transport_test_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} cmockalib platform_lib_null ) diff --git a/unit_test/test_spdm_common/CMakeLists.txt b/unit_test/test_spdm_common/CMakeLists.txt index 718a5e9936e..9a2deac504c 100644 --- a/unit_test/test_spdm_common/CMakeLists.txt +++ b/unit_test/test_spdm_common/CMakeLists.txt @@ -8,7 +8,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) ${LIBSPDM_DIR}/unit_test/test_spdm_requester ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -39,7 +39,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) spdm_crypt_lib spdm_crypt_ext_lib spdm_secured_message_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_transport_test_lib cmockalib platform_lib_null diff --git a/unit_test/test_spdm_crypt/CMakeLists.txt b/unit_test/test_spdm_crypt/CMakeLists.txt index a459105abd8..038d4aef1db 100644 --- a/unit_test/test_spdm_crypt/CMakeLists.txt +++ b/unit_test/test_spdm_crypt/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(test_spdm_crypt PRIVATE ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -53,7 +53,7 @@ else() rnglib malloclib cmockalib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_crypt_ext_lib ) endif() diff --git a/unit_test/test_spdm_fips/CMakeLists.txt b/unit_test/test_spdm_fips/CMakeLists.txt index 8b9e5fe06d6..9f99e5386a7 100644 --- a/unit_test/test_spdm_fips/CMakeLists.txt +++ b/unit_test/test_spdm_fips/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(test_spdm_fips PRIVATE ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -53,6 +53,6 @@ else() rnglib malloclib cmockalib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} ) endif() \ No newline at end of file diff --git a/unit_test/test_spdm_sample/CMakeLists.txt b/unit_test/test_spdm_sample/CMakeLists.txt index d353ad56dc1..2984916f42b 100644 --- a/unit_test/test_spdm_sample/CMakeLists.txt +++ b/unit_test/test_spdm_sample/CMakeLists.txt @@ -6,7 +6,7 @@ target_include_directories(test_spdm_sample PRIVATE ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/os_stub/spdm_cert_verify_callback_sample ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery @@ -54,7 +54,7 @@ else() rnglib malloclib cmockalib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_cert_verify_callback_sample spdm_crypt_ext_lib spdm_common_lib diff --git a/unit_test/test_spdm_secured_message/CMakeLists.txt b/unit_test/test_spdm_secured_message/CMakeLists.txt index 629784b68af..fc65a60fbd3 100644 --- a/unit_test/test_spdm_secured_message/CMakeLists.txt +++ b/unit_test/test_spdm_secured_message/CMakeLists.txt @@ -8,7 +8,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) ${LIBSPDM_DIR}/unit_test/test_spdm_requester ${LIBSPDM_DIR}/include ${LIBSPDM_DIR}/unit_test/include - ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_sample + ${LIBSPDM_DIR}/os_stub/spdm_device_secret_lib_${DEVICE} ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include ${LIBSPDM_DIR}/unit_test/cmockalib/cmocka/include/cmockery ${LIBSPDM_DIR}/unit_test/spdm_unit_test_common @@ -38,7 +38,7 @@ if(NOT ((TOOLCHAIN STREQUAL "KLEE") OR (TOOLCHAIN STREQUAL "CBMC"))) spdm_crypt_lib spdm_crypt_ext_lib spdm_secured_message_lib - spdm_device_secret_lib_sample + spdm_device_secret_lib_${DEVICE} spdm_transport_test_lib cmockalib platform_lib_null