diff --git a/doc/api/requester_api.md b/doc/api/requester_api.md
index bb01cc2a8d5..792f1bece4a 100644
--- a/doc/api/requester_api.md
+++ b/doc/api/requester_api.md
@@ -31,6 +31,32 @@ returns early with value not equal to `LIBSPDM_STATUS_SUCCESS` then the SPDM con
 before attempting establish a new connection.
 <br/><br/>
 
+---
+### libspdm_get_supported_algorithms
+---
+
+### Description
+Sends GET_VERSION and GET_CAPABILITIES requests to retrieve the Responder's supported algorithms before algorithm negotiation.
+
+### Parameters
+
+**spdm_context**<br/>
+The SPDM context.
+
+**algorithms**<br/>
+A pointer to a libspdm_responder_supported_algorithms_t structure to store the Responder's supported algorithms.
+
+### Details
+Before calling this function the Integrator must ensure that the SPDM context is initialized
+with proper configuration, including the requester's capabilities and supported cryptographic
+algorithms. The Requester must support at least one SPDM version >= 1.3 and have CHUNK_CAP
+capability enabled in its configuration.
+
+When this function returns with value `LIBSPDM_STATUS_SUCCESS`, the algorithms parameter will contain
+the Responder's supported algorithms that can be used for subsequent algorithm negotiation. If this
+function returns with value `LIBSPDM_STATUS_UNSUPPORTED_CAP`, either the Requester does not support
+version 1.3 or above, or CHUNK_CAP is not enabled.
+<br/><br/>
 
 ---
 ### libspdm_get_digest
diff --git a/include/industry_standard/spdm.h b/include/industry_standard/spdm.h
index bdf94e53cc5..516c4cff2f0 100644
--- a/include/industry_standard/spdm.h
+++ b/include/industry_standard/spdm.h
@@ -161,8 +161,41 @@ typedef struct {
     uint32_t max_spdm_msg_size;
 } spdm_get_capabilities_request_t;
 
-/* SPDM GET_CAPABILITIES response*/
+/* SPDM extended algorithm */
+typedef struct {
+    uint8_t registry_id;
+    uint8_t reserved;
+    uint16_t algorithm_id;
+} spdm_extended_algorithm_t;
+
+typedef struct {
+    uint8_t alg_type;
+    uint8_t alg_count;
+    uint16_t alg_supported;
+} spdm_negotiate_algorithms_common_struct_table_t;
 
+/* SPDM supported algorithms block */
+typedef struct {
+    uint8_t param1;  /* Number of Algorithms Structure Tables */
+    uint8_t param2;  /* Reserved */
+    uint16_t length;
+    uint8_t measurement_specification;
+    uint8_t other_params_support;
+    uint32_t base_asym_algo;
+    uint32_t base_hash_algo;
+    uint8_t reserved2[12];
+    uint8_t ext_asym_count;
+    uint8_t ext_hash_count;
+    uint8_t reserved3;
+    uint8_t mel_specification;
+    /* Followed by dynamic arrays for ext_asym, ext_hash, and struct_tableif needed
+     * spdm_extended_algorithm_t ext_asym[ext_asym_count];
+     * spdm_extended_algorithm_t ext_hash[ext_hash_count];
+     * spdm_negotiate_algorithms_common_struct_table_t struct_table[
+     *  SPDM_NEGOTIATE_ALGORITHMS_MAX_NUM_STRUCT_TABLE_ALG];*/
+} spdm_supported_algorithms_block_t;
+
+/* SPDM GET_CAPABILITIES response*/
 typedef struct {
     spdm_message_header_t header;
     /* param1 == RSVD
@@ -174,6 +207,8 @@ typedef struct {
     /* Below field is added in 1.2.*/
     uint32_t data_transfer_size;
     uint32_t max_spdm_msg_size;
+    /* Below field is added in 1.3.*/
+    spdm_supported_algorithms_block_t supported_algorithms;
 } spdm_capabilities_response_t;
 
 #define SPDM_MIN_DATA_TRANSFER_SIZE_VERSION_12  42
@@ -357,12 +392,6 @@ typedef struct {
 #define SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_AEAD_12_MASK 0x000f
 #define SPDM_NEGOTIATE_ALGORITHMS_ALG_SUPPORTED_REQ_BASE_ASYM_ALG_12_MASK 0x0fff
 
-typedef struct {
-    uint8_t alg_type;
-    uint8_t alg_count;
-    uint16_t alg_supported;
-} spdm_negotiate_algorithms_common_struct_table_t;
-
 
 /* SPDM NEGOTIATE_ALGORITHMS request base_asym_algo/REQ_BASE_ASYM_ALG */
 #define SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048 0x00000001
@@ -481,13 +510,6 @@ typedef struct {
     /*opaque_element_table_t  opaque_list[];*/
 } spdm_general_opaque_data_table_header_t;
 
-/* SPDM extended algorithm */
-typedef struct {
-    uint8_t registry_id;
-    uint8_t reserved;
-    uint16_t algorithm_id;
-} spdm_extended_algorithm_t;
-
 /* SPDM registry_id */
 #define SPDM_REGISTRY_ID_DMTF 0x0
 #define SPDM_REGISTRY_ID_TCG 0x1
diff --git a/include/internal/libspdm_common_lib.h b/include/internal/libspdm_common_lib.h
index 834867604c4..8ca00bd7c0a 100644
--- a/include/internal/libspdm_common_lib.h
+++ b/include/internal/libspdm_common_lib.h
@@ -67,6 +67,30 @@ typedef struct {
     uint16_t key_schedule;
 } libspdm_device_algorithm_t;
 
+#define LIBSPDM_MAX_EXT_ALG_COUNT 5
+
+#pragma pack(1)
+typedef struct {
+    spdm_negotiate_algorithms_common_struct_table_t alg_struct;
+    spdm_extended_algorithm_t alg_external[LIBSPDM_MAX_EXT_ALG_COUNT];
+} libspdm_supported_algorithms_alg_struct_t;
+#pragma pack()
+
+typedef struct {
+    uint8_t measurement_specification;
+    uint8_t other_params_support;
+    uint32_t base_asym_algo;
+    uint32_t base_hash_algo;
+    uint8_t mel_specification;
+    uint8_t ext_asym_count;
+    spdm_extended_algorithm_t ext_asym[LIBSPDM_MAX_EXT_ALG_COUNT];
+    uint8_t ext_hash_count;
+    spdm_extended_algorithm_t ext_hash[LIBSPDM_MAX_EXT_ALG_COUNT];
+    uint8_t struct_table_count;
+    libspdm_supported_algorithms_alg_struct_t
+        struct_table[SPDM_NEGOTIATE_ALGORITHMS_MAX_NUM_STRUCT_TABLE_ALG];
+} libspdm_responder_supported_algorithms_t;
+
 typedef struct {
 #if LIBSPDM_RECORD_TRANSCRIPT_DATA_SUPPORT
     uint8_t buffer[LIBSPDM_MAX_CERT_CHAIN_SIZE];
diff --git a/include/internal/libspdm_requester_lib.h b/include/internal/libspdm_requester_lib.h
index 050cda95ab8..fe331953246 100644
--- a/include/internal/libspdm_requester_lib.h
+++ b/include/internal/libspdm_requester_lib.h
@@ -1,6 +1,6 @@
 /**
  *  Copyright Notice:
- *  Copyright 2021-2024 DMTF. All rights reserved.
+ *  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
  **/
 
@@ -133,6 +133,7 @@ libspdm_return_t libspdm_get_version(libspdm_context_t *spdm_context,
  * This function sends GET_CAPABILITIES and receives CAPABILITIES.
  *
  * @param  spdm_context                  A pointer to the SPDM context.
+ * @param  get_supported_algorithms     If true, indicates that the requester wants the responder to include its supported algorithms in the CAPABILITIES response.
  * @param  RequesterCTExponent          RequesterCTExponent to the GET_CAPABILITIES request.
  * @param  RequesterFlags               RequesterFlags to the GET_CAPABILITIES request.
  * @param  ResponderCTExponent          ResponderCTExponent from the CAPABILITIES response.
@@ -141,7 +142,9 @@ libspdm_return_t libspdm_get_version(libspdm_context_t *spdm_context,
  * @retval RETURN_SUCCESS               The GET_CAPABILITIES is sent and the CAPABILITIES is received.
  * @retval RETURN_DEVICE_ERROR          A device error occurs when communicates with the device.
  **/
-libspdm_return_t libspdm_get_capabilities(libspdm_context_t *spdm_context);
+libspdm_return_t libspdm_get_capabilities(libspdm_context_t *spdm_context,
+                                          bool get_supported_algorithms,
+                                          libspdm_responder_supported_algorithms_t *supported_algs);
 
 /**
  * This function sends NEGOTIATE_ALGORITHMS and receives ALGORITHMS.
diff --git a/include/library/spdm_requester_lib.h b/include/library/spdm_requester_lib.h
index a91a9c72e30..acc37b2171d 100644
--- a/include/library/spdm_requester_lib.h
+++ b/include/library/spdm_requester_lib.h
@@ -1,6 +1,6 @@
 /**
  *  Copyright Notice:
- *  Copyright 2021-2024 DMTF. All rights reserved.
+ *  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
  **/
 
@@ -12,6 +12,7 @@ extern "C" {
 #endif
 
 #include "library/spdm_common_lib.h"
+#include "internal/libspdm_common_lib.h"
 
 /**
  * This function sends GET_VERSION, GET_CAPABILITIES, NEGOTIATE_ALGORITHMS
@@ -491,6 +492,19 @@ libspdm_return_t libspdm_start_session(void *spdm_context, bool use_psk,
                                        uint8_t *heartbeat_period,
                                        void *measurement_hash);
 
+/**
+ * Sends the `GET_VERSION` and `GET_CAPABILITIES` requests, where GET_CAPABILITIES.Param1[0] is set
+ * If the Responder supports this extended capability, the Responder will include the Supported
+ * Algorithms Block in its CAPABILITIES response.
+ *
+ * @param spdm_context The SPDM context.
+ * @param responder_supported_algorithms The responder supported algorithms.
+ * @retval RETURN_SUCCESS               The connection is initialized successfully.
+ * @retval RETURN_DEVICE_ERROR          A device error occurs when communicates with the device.
+ **/
+libspdm_return_t libspdm_get_supported_algorithms(
+    void *spdm_context, libspdm_responder_supported_algorithms_t *responder_supported_algorithms);
+
 /**
  * This function sends KEY_EXCHANGE/FINISH or PSK_EXCHANGE/PSK_FINISH to start an SPDM Session.
  *
diff --git a/library/spdm_requester_lib/libspdm_req_communication.c b/library/spdm_requester_lib/libspdm_req_communication.c
index e57a39dfb23..13fc6d18897 100644
--- a/library/spdm_requester_lib/libspdm_req_communication.c
+++ b/library/spdm_requester_lib/libspdm_req_communication.c
@@ -1,6 +1,6 @@
 /**
  *  Copyright Notice:
- *  Copyright 2021-2024 DMTF. All rights reserved.
+ *  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
  **/
 
@@ -19,7 +19,7 @@ libspdm_return_t libspdm_init_connection(void *spdm_context, bool get_version_on
     }
 
     if (!get_version_only) {
-        status = libspdm_get_capabilities(context);
+        status = libspdm_get_capabilities(context, false, NULL);
         if (LIBSPDM_STATUS_IS_ERROR(status)) {
             return status;
         }
@@ -31,6 +31,52 @@ libspdm_return_t libspdm_init_connection(void *spdm_context, bool get_version_on
     return LIBSPDM_STATUS_SUCCESS;
 }
 
+libspdm_return_t libspdm_get_supported_algorithms(void *spdm_context,
+                                                  libspdm_responder_supported_algorithms_t *algorithms)
+{
+    libspdm_return_t status;
+    libspdm_context_t *context;
+    bool has_version_1_3_or_above;
+    size_t index;
+
+    context = spdm_context;
+    has_version_1_3_or_above = false;
+
+    /* Verify algorithms is not NULL */
+    LIBSPDM_ASSERT(algorithms != NULL);
+
+    /* Pre-check: Verify requester supports at least one version >= 1.3 */
+    for (index = 0; index < context->local_context.version.spdm_version_count; index++) {
+        if (context->local_context.version.spdm_version[index] >= SPDM_MESSAGE_VERSION_13) {
+            has_version_1_3_or_above = true;
+            break;
+        }
+    }
+    LIBSPDM_ASSERT(has_version_1_3_or_above);
+    if (!has_version_1_3_or_above) {
+        return LIBSPDM_STATUS_UNSUPPORTED_CAP;
+    }
+
+    LIBSPDM_ASSERT((context->local_context.capability.flags &
+                    SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP) != 0);
+
+    status = libspdm_get_version(context, NULL, NULL);
+    if (LIBSPDM_STATUS_IS_ERROR(status)) {
+        return status;
+    }
+
+    if (context->connection_info.version < SPDM_MESSAGE_VERSION_13) {
+        return LIBSPDM_STATUS_UNSUPPORTED_CAP;
+    }
+
+    status = libspdm_get_capabilities(context, true, algorithms);
+    if (LIBSPDM_STATUS_IS_ERROR(status)) {
+        return status;
+    }
+
+    return LIBSPDM_STATUS_SUCCESS;
+}
+
 #if (LIBSPDM_ENABLE_CAPABILITY_KEY_EX_CAP) || (LIBSPDM_ENABLE_CAPABILITY_PSK_CAP)
 libspdm_return_t libspdm_start_session(void *spdm_context, bool use_psk,
                                        const void *psk_hint,
diff --git a/library/spdm_requester_lib/libspdm_req_get_capabilities.c b/library/spdm_requester_lib/libspdm_req_get_capabilities.c
index a414c1c228e..c78d6d588aa 100644
--- a/library/spdm_requester_lib/libspdm_req_get_capabilities.c
+++ b/library/spdm_requester_lib/libspdm_req_get_capabilities.c
@@ -211,7 +211,9 @@ static bool validate_responder_capability(uint32_t capabilities_flag, uint8_t ve
  * @retval LIBSPDM_STATUS_BUFFER_FULL
  *         The buffer used to store transcripts is exhausted.
  **/
-static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_context)
+static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_context,
+                                                     bool get_supported_algorithms,
+                                                     libspdm_responder_supported_algorithms_t *supported_algs)
 {
     libspdm_return_t status;
     spdm_get_capabilities_request_t *spdm_request;
@@ -241,6 +243,11 @@ static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_con
                         spdm_context->local_context.capability.transport_tail_size;
 
     LIBSPDM_ASSERT (spdm_request_size >= sizeof(spdm_request->header));
+
+    LIBSPDM_ASSERT(!((spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13) &&
+                     get_supported_algorithms &&
+                     ((spdm_request->flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP) == 0)));
+
     libspdm_zero_mem(spdm_request, spdm_request_size);
     spdm_request->header.spdm_version = libspdm_get_connection_version (spdm_context);
     if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
@@ -258,6 +265,10 @@ static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_con
     }
     spdm_request->header.request_response_code = SPDM_GET_CAPABILITIES;
     spdm_request->header.param1 = 0;
+    if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13 &&
+        get_supported_algorithms) {
+        spdm_request->header.param1 |= 0x01;
+    }
     spdm_request->header.param2 = 0;
     if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_11) {
         spdm_request->ct_exponent = spdm_context->local_context.capability.ct_exponent;
@@ -315,22 +326,51 @@ static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_con
         status = LIBSPDM_STATUS_INVALID_MSG_FIELD;
         goto receive_done;
     }
-    if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
+    if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_13) {
         if (spdm_response_size < sizeof(spdm_capabilities_response_t)) {
             status = LIBSPDM_STATUS_INVALID_MSG_SIZE;
             goto receive_done;
         }
+    } else if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
+        if (spdm_response_size < (sizeof(spdm_capabilities_response_t) -
+                                  sizeof(spdm_supported_algorithms_block_t))) {
+            status = LIBSPDM_STATUS_INVALID_MSG_SIZE;
+            goto receive_done;
+        }
     } else {
-        if (spdm_response_size < sizeof(spdm_capabilities_response_t) -
-            sizeof(spdm_response->data_transfer_size) - sizeof(spdm_response->max_spdm_msg_size)) {
+        if (spdm_response_size < (sizeof(spdm_capabilities_response_t) -
+                                  sizeof(spdm_supported_algorithms_block_t) -
+                                  sizeof(spdm_response->data_transfer_size) -
+                                  sizeof(spdm_response->max_spdm_msg_size))) {
             status = LIBSPDM_STATUS_INVALID_MSG_SIZE;
             goto receive_done;
         }
     }
-    if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
+
+    if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_13 &&
+        (spdm_request->header.param1 & 0x01)) {
+
         spdm_response_size = sizeof(spdm_capabilities_response_t);
+
+        if (spdm_response->supported_algorithms.ext_asym_count > 0) {
+            spdm_response_size += spdm_response->supported_algorithms.ext_asym_count *
+                                  sizeof(spdm_extended_algorithm_t);
+        }
+        if (spdm_response->supported_algorithms.ext_hash_count > 0) {
+            spdm_response_size += spdm_response->supported_algorithms.ext_hash_count *
+                                  sizeof(spdm_extended_algorithm_t);
+        }
+        if (spdm_response->supported_algorithms.param1 > 0) {
+            spdm_response_size += spdm_response->supported_algorithms.param1 *
+                                  sizeof(spdm_negotiate_algorithms_common_struct_table_t);
+        }
+
+    } else if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
+        spdm_response_size = sizeof(spdm_capabilities_response_t)-
+                             sizeof(spdm_supported_algorithms_block_t);
     } else {
         spdm_response_size = sizeof(spdm_capabilities_response_t) -
+                             sizeof(spdm_supported_algorithms_block_t) -
                              sizeof(spdm_response->data_transfer_size) -
                              sizeof(spdm_response->max_spdm_msg_size);
     }
@@ -383,6 +423,56 @@ static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_con
         spdm_context->connection_info.capability.max_spdm_msg_size = 0;
     }
 
+    /* Copy algorithms if requested and received */
+    if (get_supported_algorithms && supported_algs != NULL &&
+        spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_13 &&
+        (spdm_request->header.param1 & 0x01)) {
+
+        spdm_supported_algorithms_block_t *src = &spdm_response->supported_algorithms;
+        libspdm_responder_supported_algorithms_t *dst = supported_algs;
+        uint8_t *src_bytes = (uint8_t *)src;
+        size_t offset;
+        size_t alg_size;
+
+        dst->struct_table_count = src->param1;
+        dst->measurement_specification = src->measurement_specification;
+        dst->other_params_support = src->other_params_support;
+        dst->base_asym_algo = src->base_asym_algo;
+        dst->base_hash_algo = src->base_hash_algo;
+        dst->ext_asym_count = src->ext_asym_count;
+        dst->ext_hash_count = src->ext_hash_count;
+        dst->mel_specification = src->mel_specification;
+
+        offset = sizeof(spdm_supported_algorithms_block_t);
+
+        if (src->ext_asym_count > 0) {
+            size_t copy_size = src->ext_asym_count * sizeof(spdm_extended_algorithm_t);
+            libspdm_copy_mem(dst->ext_asym,
+                             sizeof(dst->ext_asym),
+                             src_bytes + offset,
+                             copy_size);
+            offset += copy_size;
+        }
+
+        if (src->ext_hash_count > 0) {
+            size_t copy_size = src->ext_hash_count * sizeof(spdm_extended_algorithm_t);
+            libspdm_copy_mem(dst->ext_hash,
+                             sizeof(dst->ext_hash),
+                             src_bytes + offset,
+                             copy_size);
+            offset += copy_size;
+        }
+
+        alg_size = sizeof(spdm_negotiate_algorithms_common_struct_table_t);
+        for (size_t i = 0; i < src->param1; i++) {
+            libspdm_copy_mem(&(dst->struct_table[i].alg_struct),
+                             alg_size,
+                             (uint8_t *)src + offset + (i * alg_size),
+                             alg_size);
+        }
+    }
+
+
     /* -=[Update State Phase]=- */
     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_CAPABILITIES;
     status = LIBSPDM_STATUS_SUCCESS;
@@ -397,17 +487,23 @@ static libspdm_return_t libspdm_try_get_capabilities(libspdm_context_t *spdm_con
     return status;
 }
 
-libspdm_return_t libspdm_get_capabilities(libspdm_context_t *spdm_context)
+libspdm_return_t libspdm_get_capabilities(libspdm_context_t *spdm_context,
+                                          bool get_supported_algorithms,
+                                          libspdm_responder_supported_algorithms_t *supported_algs)
 {
     size_t retry;
     uint64_t retry_delay_time;
     libspdm_return_t status;
 
+    /* Verify supported_algs is not NULL if get_supported_algorithms is true */
+    LIBSPDM_ASSERT(!get_supported_algorithms || (supported_algs != NULL));
+
     spdm_context->crypto_request = false;
     retry = spdm_context->retry_times;
     retry_delay_time = spdm_context->retry_delay_time;
     do {
-        status = libspdm_try_get_capabilities(spdm_context);
+        status =
+            libspdm_try_get_capabilities(spdm_context, get_supported_algorithms, supported_algs);
         if (status != LIBSPDM_STATUS_BUSY_PEER) {
             return status;
         }
diff --git a/library/spdm_responder_lib/libspdm_rsp_capabilities.c b/library/spdm_responder_lib/libspdm_rsp_capabilities.c
index d607dd727e8..740113ff296 100644
--- a/library/spdm_responder_lib/libspdm_rsp_capabilities.c
+++ b/library/spdm_responder_lib/libspdm_rsp_capabilities.c
@@ -247,6 +247,17 @@ libspdm_return_t libspdm_get_response_capabilities(libspdm_context_t *spdm_conte
         }
     }
 
+    /* Check that if Param1[0] is set, Requester must have CHUNK_CAP */
+    if (spdm_request->header.spdm_version >= SPDM_MESSAGE_VERSION_13 &&
+        (spdm_request->header.param1 & 0x01) &&
+        ((spdm_request->flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP) == 0)) {
+        return libspdm_generate_error_response(spdm_context,
+                                               SPDM_ERROR_CODE_INVALID_REQUEST,
+                                               0,
+                                               response_size,
+                                               response);
+    }
+
     libspdm_reset_message_buffer_via_request_code(spdm_context, NULL,
                                                   spdm_request->header.request_response_code);
 
@@ -270,11 +281,90 @@ libspdm_return_t libspdm_get_response_capabilities(libspdm_context_t *spdm_conte
         spdm_response->max_spdm_msg_size =
             spdm_context->local_context.capability.max_spdm_msg_size;
     }
+    if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_13 &&
+        (spdm_request->header.param1 & 0x01) &&
+        (spdm_request->flags & SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP) &&
+        (spdm_response->flags & SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP)) {
 
-    if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
+        uint8_t index = 0;
         *response_size = sizeof(spdm_capabilities_response_t);
+
+        spdm_response->supported_algorithms.param2 = 0;
+        spdm_response->supported_algorithms.length = sizeof(spdm_supported_algorithms_block_t);
+        spdm_response->supported_algorithms.measurement_specification =
+            spdm_context->local_context.algorithm.measurement_spec;
+        spdm_response->supported_algorithms.other_params_support =
+            spdm_context->local_context.algorithm.other_params_support;
+        spdm_response->supported_algorithms.base_asym_algo=
+            spdm_context->local_context.algorithm.base_asym_algo;
+        spdm_response->supported_algorithms.base_hash_algo=
+            spdm_context->local_context.algorithm.base_hash_algo;
+        spdm_response->supported_algorithms.ext_asym_count = 0;
+        spdm_response->supported_algorithms.ext_hash_count = 0;
+        spdm_response->supported_algorithms.mel_specification =
+            spdm_context->local_context.algorithm.mel_spec;
+
+        spdm_negotiate_algorithms_common_struct_table_t *struct_table =
+            (spdm_negotiate_algorithms_common_struct_table_t*)(
+                (uint8_t*)&spdm_response->supported_algorithms +
+                sizeof(spdm_supported_algorithms_block_t)
+                );
+
+        if (spdm_context->local_context.algorithm.dhe_named_group != 0) {
+            struct_table[index].alg_type =
+                SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE;
+            struct_table[index].alg_count = 0x20;
+            struct_table[index].alg_supported =
+                spdm_context->local_context.algorithm.dhe_named_group;
+            index++;
+        }
+
+        if (spdm_context->local_context.algorithm.aead_cipher_suite != 0) {
+            struct_table[index].alg_type =
+                SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD;
+            struct_table[index].alg_count = 0x20;
+            struct_table[index].alg_supported =
+                spdm_context->local_context.algorithm.aead_cipher_suite;
+            index++;
+        }
+
+        if (spdm_context->local_context.algorithm.req_base_asym_alg != 0) {
+            struct_table[index].alg_type =
+                SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG;
+            struct_table[index].alg_count = 0x20;
+            struct_table[index].alg_supported =
+                spdm_context->local_context.algorithm.req_base_asym_alg;
+            index++;
+        }
+
+        if (spdm_context->local_context.algorithm.key_schedule != 0) {
+            struct_table[index].alg_type =
+                SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE;
+            struct_table[index].alg_count = 0x20;
+            struct_table[index].alg_supported =
+                spdm_context->local_context.algorithm.key_schedule;
+            index++;
+        }
+
+        if (index == 0) {
+            struct_table = NULL;
+        }
+
+        spdm_response->supported_algorithms.param1 = index;
+        spdm_response->supported_algorithms.length +=
+            spdm_response->supported_algorithms.param1*
+            sizeof(spdm_negotiate_algorithms_common_struct_table_t);
+
+        *response_size = sizeof(spdm_capabilities_response_t) +
+                         (spdm_response->supported_algorithms.param1*
+                          sizeof(spdm_negotiate_algorithms_common_struct_table_t));
+
+    } else if (spdm_response->header.spdm_version >= SPDM_MESSAGE_VERSION_12) {
+        *response_size = sizeof(spdm_capabilities_response_t) -
+                         sizeof(spdm_supported_algorithms_block_t);
     } else {
         *response_size = sizeof(spdm_capabilities_response_t) -
+                         sizeof(spdm_supported_algorithms_block_t)-
                          sizeof(spdm_response->data_transfer_size) -
                          sizeof(spdm_response->max_spdm_msg_size);
     }
diff --git a/unit_test/fuzzing/test_requester/test_spdm_requester_get_capabilities/get_capabilities.c b/unit_test/fuzzing/test_requester/test_spdm_requester_get_capabilities/get_capabilities.c
index 5bab433d419..34422c7b8b8 100644
--- a/unit_test/fuzzing/test_requester/test_spdm_requester_get_capabilities/get_capabilities.c
+++ b/unit_test/fuzzing/test_requester/test_spdm_requester_get_capabilities/get_capabilities.c
@@ -73,7 +73,7 @@ void libspdm_test_requester_get_capabilities(void **State)
         spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
         libspdm_reset_message_a(spdm_context);
 
-        libspdm_get_capabilities(spdm_context);
+        libspdm_get_capabilities(spdm_context, false, NULL);
     }
 }
 
diff --git a/unit_test/test_spdm_requester/error_test/get_capabilities_err.c b/unit_test/test_spdm_requester/error_test/get_capabilities_err.c
index 22d11d87650..f1d58e58aa3 100644
--- a/unit_test/test_spdm_requester/error_test/get_capabilities_err.c
+++ b/unit_test/test_spdm_requester/error_test/get_capabilities_err.c
@@ -1103,7 +1103,7 @@ static void libspdm_test_requester_get_capabilities_err_case1(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SEND_FAIL);
 }
 
@@ -1126,7 +1126,7 @@ static void libspdm_test_requester_get_capabilities_err_case2(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1145,7 +1145,7 @@ static void libspdm_test_requester_get_capabilities_err_case3(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_STATE_LOCAL);
 }
 
@@ -1165,7 +1165,7 @@ static void libspdm_test_requester_get_capabilities_err_case4(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_ERROR_PEER);
 }
 
@@ -1185,7 +1185,7 @@ static void libspdm_test_requester_get_capabilities_err_case5(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_BUSY_PEER);
 }
 
@@ -1209,7 +1209,7 @@ static void libspdm_test_requester_get_capabilities_err_case6(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1229,7 +1229,7 @@ static void libspdm_test_requester_get_capabilities_err_case7(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_RESYNCH_PEER);
     assert_int_equal(spdm_context->connection_info.connection_state,
                      LIBSPDM_CONNECTION_STATE_NOT_STARTED);
@@ -1250,7 +1250,7 @@ static void libspdm_test_requester_get_capabilities_err_case8(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_NOT_READY_PEER);
 }
 
@@ -1273,7 +1273,7 @@ static void libspdm_test_requester_get_capabilities_err_case9(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1297,7 +1297,7 @@ static void libspdm_test_requester_get_capabilities_err_case10(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1320,7 +1320,7 @@ static void libspdm_test_requester_get_capabilities_err_case11(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1346,7 +1346,7 @@ static void libspdm_test_requester_get_capabilities_err_case12(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1365,7 +1365,7 @@ static void libspdm_test_requester_get_capabilities_err_case13(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
 }
 
@@ -1384,7 +1384,7 @@ static void libspdm_test_requester_get_capabilities_err_case14(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
 }
 
@@ -1403,7 +1403,7 @@ static void libspdm_test_requester_get_capabilities_err_case15(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_SIZE);
 }
 
@@ -1429,7 +1429,7 @@ static void libspdm_test_requester_get_capabilities_err_case16(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1448,7 +1448,7 @@ static void libspdm_test_requester_get_capabilities_err_case17(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
     /*assert_int_equal (spdm_context->connection_info.capability.ct_exponent, 0);
      * assert_int_equal (spdm_context->connection_info.capability.flags, LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11 & (0xFFFFFFFF^(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)));*/
@@ -1471,7 +1471,7 @@ static void libspdm_test_requester_get_capabilities_err_case18(void **state)
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags =
         LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
     /*assert_int_equal (spdm_context->connection_info.capability.ct_exponent, 0);
      * assert_int_equal (spdm_context->connection_info.capability.flags, LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11 & (0xFFFFFFFF^(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MAC_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)));*/
@@ -1493,7 +1493,7 @@ static void libspdm_test_requester_get_capabilities_err_case19(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
     /*assert_int_equal (spdm_context->connection_info.capability.ct_exponent, 0);
      * assert_int_equal (spdm_context->connection_info.capability.flags, LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11 & (0xFFFFFFFF^(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PSK_CAP | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_HANDSHAKE_IN_THE_CLEAR_CAP)));*/
@@ -1515,7 +1515,7 @@ static void libspdm_test_requester_get_capabilities_err_case20(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1535,7 +1535,7 @@ static void libspdm_test_requester_get_capabilities_err_case21(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1555,7 +1555,7 @@ static void libspdm_test_requester_get_capabilities_err_case22(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1575,7 +1575,7 @@ static void libspdm_test_requester_get_capabilities_err_case23(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
     /*assert_int_equal (spdm_context->connection_info.capability.ct_exponent, 0);
      * assert_int_equal (spdm_context->connection_info.capability.flags, LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11 & (0xFFFFFFFF^(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCAP_CAP)));*/
@@ -1597,7 +1597,7 @@ static void libspdm_test_requester_get_capabilities_err_case24(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
     /*assert_int_equal (spdm_context->connection_info.capability.ct_exponent, 0);
      * assert_int_equal (spdm_context->connection_info.capability.flags, LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11 & (0xFFFFFFFF^(SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP)));*/
@@ -1619,7 +1619,7 @@ static void libspdm_test_requester_get_capabilities_err_case25(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1639,7 +1639,7 @@ static void libspdm_test_requester_get_capabilities_err_case26(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
     /*assert_int_equal (spdm_context->connection_info.capability.ct_exponent, 0);
      * assert_int_equal (spdm_context->connection_info.capability.flags, LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11 | SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_PUB_KEY_ID_CAP);*/
@@ -1661,7 +1661,7 @@ static void libspdm_test_requester_get_capabilities_err_case27(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1681,7 +1681,7 @@ static void libspdm_test_requester_get_capabilities_err_case28(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1704,7 +1704,7 @@ static void libspdm_test_requester_get_capabilities_err_case29(void **state) {
         spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
         libspdm_reset_message_a(spdm_context);
 
-        status = libspdm_get_capabilities (spdm_context);
+        status = libspdm_get_capabilities(spdm_context, false, NULL);
         LIBSPDM_ASSERT_INT_EQUAL_CASE (status, LIBSPDM_STATUS_ERROR_PEER, error_code);
 
         error_code++;
@@ -1741,7 +1741,7 @@ static void libspdm_test_requester_get_capabilities_err_case30(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1759,7 +1759,7 @@ static void libspdm_test_requester_get_capabilities_err_case31(void **state)
     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_RECEIVE_FAIL);
 }
 
@@ -1784,7 +1784,7 @@ static void libspdm_test_requester_get_capabilities_err_case32(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1809,7 +1809,7 @@ static void libspdm_test_requester_get_capabilities_err_case33(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
 
@@ -1830,7 +1830,7 @@ static void libspdm_test_requester_get_capabilities_err_case34(void **state)
         spdm_context->transcript.message_a.max_buffer_size;
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_BUFFER_FULL);
 
     spdm_context->transcript.message_a.buffer_size = 0;
@@ -1857,7 +1857,7 @@ static void libspdm_test_requester_get_capabilities_err_case35(void **state)
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
 
     libspdm_force_error (LIBSPDM_ERR_ACQUIRE_SENDER_BUFFER);
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     libspdm_release_error (LIBSPDM_ERR_ACQUIRE_SENDER_BUFFER);
 
     assert_int_equal(status, LIBSPDM_STATUS_ACQUIRE_FAIL);
@@ -1884,7 +1884,7 @@ static void libspdm_test_requester_get_capabilities_err_case36(void **state)
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
 
     libspdm_force_error (LIBSPDM_ERR_ACQUIRE_RECEIVER_BUFFER);
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     libspdm_release_error (LIBSPDM_ERR_ACQUIRE_RECEIVER_BUFFER);
 
     assert_int_equal(status, LIBSPDM_STATUS_ACQUIRE_FAIL);
@@ -1910,7 +1910,7 @@ static void libspdm_test_requester_get_capabilities_err_case37(void **state)
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
 
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
 
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
@@ -1936,7 +1936,7 @@ static void libspdm_test_requester_get_capabilities_err_case38(void **state)
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
 
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
 
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
@@ -1961,7 +1961,7 @@ static void libspdm_test_requester_get_capabilities_err_case39(void **state)
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
 
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
 
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
@@ -1986,7 +1986,7 @@ static void libspdm_test_requester_get_capabilities_err_case40(void **state)
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
 
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
 
     assert_int_equal(status, LIBSPDM_STATUS_INVALID_MSG_FIELD);
 }
diff --git a/unit_test/test_spdm_requester/get_capabilities.c b/unit_test/test_spdm_requester/get_capabilities.c
index 7117466f437..36a43ee4317 100644
--- a/unit_test/test_spdm_requester/get_capabilities.c
+++ b/unit_test/test_spdm_requester/get_capabilities.c
@@ -1,6 +1,6 @@
 /**
  *  Copyright Notice:
- *  Copyright 2021-2022 DMTF. All rights reserved.
+ *  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
  **/
 
@@ -145,10 +145,20 @@ static libspdm_return_t libspdm_requester_get_capabilities_test_send_message(
         return LIBSPDM_STATUS_SUCCESS;
     case 0x23:
         return LIBSPDM_STATUS_SUCCESS;
+    case 0x24:
+        return LIBSPDM_STATUS_SUCCESS;
+    case 0x25:
+        return LIBSPDM_STATUS_SUCCESS;
     default:
         return LIBSPDM_STATUS_SEND_FAIL;
     }
 }
+typedef struct {
+    spdm_message_header_t header;
+    uint8_t reserved;
+    uint8_t version_number_entry_count;
+    spdm_version_number_t version_number_entry[LIBSPDM_MAX_VERSION_COUNT];
+} libspdm_version_response_mine_t;
 
 static libspdm_return_t libspdm_requester_get_capabilities_test_receive_message(
     void *spdm_context, size_t *response_size,
@@ -417,7 +427,8 @@ static libspdm_return_t libspdm_requester_get_capabilities_test_receive_message(
         size_t spdm_response_size;
         size_t transport_header_size;
 
-        spdm_response_size = sizeof(spdm_capabilities_response_t);
+        spdm_response_size = sizeof(spdm_capabilities_response_t) -
+                             sizeof(spdm_supported_algorithms_block_t);
         transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
         spdm_response = (void *)((uint8_t *)*response + transport_header_size);
 
@@ -913,7 +924,8 @@ static libspdm_return_t libspdm_requester_get_capabilities_test_receive_message(
         size_t spdm_response_size;
         size_t transport_header_size;
 
-        spdm_response_size = sizeof(spdm_capabilities_response_t);
+        spdm_response_size = sizeof(spdm_capabilities_response_t) -
+                             sizeof(spdm_supported_algorithms_block_t);
         transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
         spdm_response = (void *)((uint8_t *)*response + transport_header_size);
 
@@ -926,6 +938,7 @@ static libspdm_return_t libspdm_requester_get_capabilities_test_receive_message(
         spdm_response->flags = LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_11;
 
         spdm_response_size = sizeof(spdm_capabilities_response_t) -
+                             sizeof(spdm_supported_algorithms_block_t)-
                              sizeof(spdm_response->data_transfer_size) -
                              sizeof(spdm_response->max_spdm_msg_size);
 
@@ -1008,6 +1021,75 @@ static libspdm_return_t libspdm_requester_get_capabilities_test_receive_message(
         spdm_response->flags = LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_13;
         spdm_response->data_transfer_size = LIBSPDM_DATA_TRANSFER_SIZE;
         spdm_response->max_spdm_msg_size = LIBSPDM_MAX_SPDM_MSG_SIZE;
+        libspdm_transport_test_encode_message(spdm_context, NULL, false,
+                                              false, spdm_response_size,
+                                              spdm_response,
+                                              response_size, response);
+    }
+        return LIBSPDM_STATUS_SUCCESS;
+    case 0x24: {
+        spdm_capabilities_response_t *spdm_response;
+        size_t spdm_response_size;
+        size_t transport_header_size;
+
+        spdm_response_size = sizeof(spdm_capabilities_response_t) + 4*
+                             sizeof(spdm_negotiate_algorithms_common_struct_table_t);
+        transport_header_size = LIBSPDM_TEST_TRANSPORT_HEADER_SIZE;
+        spdm_response = (void *)((uint8_t *)*response + transport_header_size);
+
+        libspdm_zero_mem(spdm_response, spdm_response_size);
+        spdm_response->header.spdm_version = SPDM_MESSAGE_VERSION_13;
+        spdm_response->header.request_response_code = SPDM_CAPABILITIES;
+        spdm_response->header.param1 = 0;
+        spdm_response->header.param2 = 0;
+        spdm_response->ct_exponent = 0;
+        spdm_response->flags = LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_13;
+        spdm_response->data_transfer_size = LIBSPDM_DATA_TRANSFER_SIZE;
+        spdm_response->max_spdm_msg_size = LIBSPDM_MAX_SPDM_MSG_SIZE;
+
+        spdm_response->supported_algorithms.param1 = 4;
+        spdm_response->supported_algorithms.param2 = 0;
+        spdm_response->supported_algorithms.length = sizeof(spdm_supported_algorithms_block_t) +
+                                                     4 *
+                                                     sizeof(
+            spdm_negotiate_algorithms_common_struct_table_t);
+        spdm_response->supported_algorithms.measurement_specification =
+            SPDM_MEASUREMENT_SPECIFICATION_DMTF;
+        spdm_response->supported_algorithms.other_params_support = 0;
+        spdm_response->supported_algorithms.base_asym_algo = m_libspdm_use_asym_algo;
+        spdm_response->supported_algorithms.base_hash_algo = m_libspdm_use_hash_algo;
+        spdm_response->supported_algorithms.ext_asym_count = 0;
+        spdm_response->supported_algorithms.ext_hash_count = 0;
+        spdm_response->supported_algorithms.mel_specification = SPDM_MEL_SPECIFICATION_DMTF;
+
+        spdm_negotiate_algorithms_common_struct_table_t *struct_table =
+            (spdm_negotiate_algorithms_common_struct_table_t *)(&spdm_response->supported_algorithms
+                                                                + 1);
+
+        struct_table[0].alg_type =
+            SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_DHE;
+        struct_table[0].alg_count = 0x20;
+        struct_table[0].alg_supported =
+            SPDM_ALGORITHMS_DHE_NAMED_GROUP_SECP_256_R1;
+
+        struct_table[1].alg_type =
+            SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_AEAD;
+        struct_table[1].alg_count = 0x20;
+        struct_table[1].alg_supported =
+            SPDM_ALGORITHMS_AEAD_CIPHER_SUITE_AES_256_GCM;;
+
+        struct_table[2].alg_type =
+            SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_REQ_BASE_ASYM_ALG;
+        struct_table[2].alg_count = 0x20;
+        struct_table[2].alg_supported =
+            SPDM_ALGORITHMS_BASE_ASYM_ALGO_TPM_ALG_RSASSA_2048;
+
+        struct_table[3].alg_type =
+            SPDM_NEGOTIATE_ALGORITHMS_STRUCT_TABLE_ALG_TYPE_KEY_SCHEDULE;
+        struct_table[3].alg_count = 0x20;
+        struct_table[3].alg_supported =
+            SPDM_ALGORITHMS_KEY_SCHEDULE_HMAC_HASH;
+
         libspdm_transport_test_encode_message(spdm_context, NULL, false,
                                               false, spdm_response_size,
                                               spdm_response,
@@ -1044,7 +1126,7 @@ static void libspdm_test_requester_get_capabilities_case2(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(spdm_context->connection_info.capability.flags,
@@ -1089,7 +1171,7 @@ static void libspdm_test_requester_get_capabilities_case6(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(spdm_context->connection_info.capability.flags,
@@ -1130,7 +1212,7 @@ static void libspdm_test_requester_get_capabilities_case10(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(spdm_context->connection_info.capability.flags,
@@ -1156,7 +1238,7 @@ static void libspdm_test_requester_get_capabilities_case11(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(
@@ -1183,7 +1265,7 @@ static void libspdm_test_requester_get_capabilities_case12(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(spdm_context->connection_info.capability.flags,
@@ -1224,7 +1306,7 @@ static void libspdm_test_requester_get_capabilities_case16(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(spdm_context->connection_info.capability.flags,
@@ -1343,7 +1425,7 @@ static void libspdm_test_requester_get_capabilities_case32(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_11;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
     assert_int_equal(spdm_context->connection_info.capability.flags,
@@ -1374,7 +1456,7 @@ static void libspdm_test_requester_get_capabilities_case33(void **state)
 
     spdm_context->local_context.capability.ct_exponent = 0;
     spdm_context->local_context.capability.flags = LIBSPDM_DEFAULT_CAPABILITY_FLAG_VERSION_12;
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.max_spdm_msg_size,
                      LIBSPDM_MAX_SPDM_MSG_SIZE);
@@ -1406,7 +1488,50 @@ static void libspdm_test_requester_get_capabilities_case35(void **state)
     spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
     spdm_context->local_context.capability.ct_exponent = 0;
 
-    status = libspdm_get_capabilities(spdm_context);
+    status = libspdm_get_capabilities(spdm_context, false, NULL);
+    assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
+    assert_int_equal(spdm_context->connection_info.capability.max_spdm_msg_size,
+                     LIBSPDM_MAX_SPDM_MSG_SIZE);
+    assert_int_equal(spdm_context->connection_info.capability.data_transfer_size,
+                     LIBSPDM_DATA_TRANSFER_SIZE);
+    assert_int_equal(spdm_context->connection_info.capability.ct_exponent, 0);
+    assert_int_equal(spdm_context->connection_info.capability.flags,
+                     LIBSPDM_DEFAULT_CAPABILITY_RESPONSE_FLAG_VERSION_13);
+}
+
+static void libspdm_test_requester_get_capabilities_case36(void **state)
+{
+    libspdm_return_t status;
+    libspdm_test_context_t *spdm_test_context;
+    libspdm_context_t *spdm_context;
+    libspdm_responder_supported_algorithms_t supported_algs;
+
+    spdm_test_context = *state;
+    spdm_context = spdm_test_context->spdm_context;
+    spdm_test_context->case_id = 0x24;
+    spdm_context->connection_info.version = SPDM_MESSAGE_VERSION_13 <<
+                                            SPDM_VERSION_NUMBER_SHIFT_BIT;
+    spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
+    spdm_context->local_context.capability.ct_exponent = 0;
+
+    spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
+    spdm_context->local_context.algorithm.other_params_support = 0;
+    spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
+    spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
+    spdm_context->local_context.algorithm.mel_spec = SPDM_MEL_SPECIFICATION_DMTF;
+
+    spdm_context->connection_info.capability.flags |=
+        SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
+    spdm_context->connection_info.capability.flags |=
+        SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
+    spdm_context->connection_info.capability.flags |=
+        SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
+
+    spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
+    spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
+    spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
+    spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
+    status = libspdm_get_capabilities(spdm_context, true, &supported_algs);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(spdm_context->connection_info.capability.max_spdm_msg_size,
                      LIBSPDM_MAX_SPDM_MSG_SIZE);
@@ -1455,6 +1580,7 @@ int libspdm_requester_get_capabilities_test_main(void)
         cmocka_unit_test(libspdm_test_requester_get_capabilities_case33),
         /* cmocka_unit_test(libspdm_test_requester_get_capabilities_case34), */
         cmocka_unit_test(libspdm_test_requester_get_capabilities_case35),
+        cmocka_unit_test(libspdm_test_requester_get_capabilities_case36),
     };
 
     libspdm_test_context_t test_context = {
diff --git a/unit_test/test_spdm_responder/capabilities.c b/unit_test/test_spdm_responder/capabilities.c
index 3eaa7d48186..614496b1c73 100644
--- a/unit_test/test_spdm_responder/capabilities.c
+++ b/unit_test/test_spdm_responder/capabilities.c
@@ -467,6 +467,22 @@ spdm_get_capabilities_request_t m_libspdm_get_capabilities_request27 = {
 };
 size_t m_libspdm_get_capabilities_request27_size = sizeof(m_libspdm_get_capabilities_request27);
 
+spdm_get_capabilities_request_t m_libspdm_get_capabilities_request28 = {
+    {
+        SPDM_MESSAGE_VERSION_13,
+        SPDM_GET_CAPABILITIES,
+        0x01,
+    },
+    0x00, /*reserved*/
+    0x01, /*ct_exponent*/
+    0x0000, /*reserved, 2 bytes*/
+    SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP |
+    SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY,
+    LIBSPDM_DATA_TRANSFER_SIZE,
+    LIBSPDM_MAX_SPDM_MSG_SIZE,
+};
+size_t m_libspdm_get_capabilities_request28_size = sizeof(m_libspdm_get_capabilities_request28);
+
 void libspdm_test_responder_capabilities_case1(void **state)
 {
     libspdm_return_t status;
@@ -491,6 +507,7 @@ void libspdm_test_responder_capabilities_case1(void **state)
         &m_libspdm_get_capabilities_request1, &response_size, response);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t) -
                      sizeof(spdm_response->data_transfer_size) -
                      sizeof(spdm_response->max_spdm_msg_size));
     spdm_response = (void *)response;
@@ -527,6 +544,7 @@ void libspdm_test_responder_capabilities_case2(void **state)
         &m_libspdm_get_capabilities_request2, &response_size, response);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t) -
                      sizeof(spdm_response->data_transfer_size) -
                      sizeof(spdm_response->max_spdm_msg_size));
     spdm_response = (void *)response;
@@ -691,6 +709,7 @@ void libspdm_test_responder_capabilities_case8(void **state)
         &m_libspdm_get_capabilities_request4, &response_size, response);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t) -
                      sizeof(spdm_response->data_transfer_size) -
                      sizeof(spdm_response->max_spdm_msg_size));
     spdm_response = (void *)response;
@@ -721,6 +740,7 @@ void libspdm_test_responder_capabilities_case9(void **state)
         &m_libspdm_get_capabilities_request5, &response_size, response);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t) -
                      sizeof(spdm_response->data_transfer_size) -
                      sizeof(spdm_response->max_spdm_msg_size));
     spdm_response = (void *)response;
@@ -1017,6 +1037,7 @@ void libspdm_test_responder_capabilities_case22(void **state)
         &m_libspdm_get_capabilities_request18, &response_size, response);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t) -
                      sizeof(spdm_response->data_transfer_size) -
                      sizeof(spdm_response->max_spdm_msg_size));
     spdm_response = (void *)response;
@@ -1053,6 +1074,7 @@ void libspdm_test_responder_capabilities_case23(void **state)
         &m_libspdm_get_capabilities_request4, &response_size, response);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
     assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t) -
                      sizeof(spdm_response->data_transfer_size) -
                      sizeof(spdm_response->max_spdm_msg_size));
     spdm_response = (void *)response;
@@ -1094,7 +1116,8 @@ void libspdm_test_responder_capabilities_case24(void **state)
     assert_int_equal(spdm_context->connection_info.capability.data_transfer_size,
                      m_libspdm_get_capabilities_request19.data_transfer_size);
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
-    assert_int_equal(response_size, sizeof(spdm_capabilities_response_t));
+    assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t));
     spdm_response = (void *)response;
     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_12);
     assert_int_equal(spdm_response->header.request_response_code,
@@ -1185,7 +1208,8 @@ void libspdm_test_responder_capabilities_case27(void **state)
         &m_libspdm_get_capabilities_request27, &response_size, response);
 
     assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
-    assert_int_equal(response_size, sizeof(spdm_capabilities_response_t));
+    assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) -
+                     sizeof(spdm_supported_algorithms_block_t));
     spdm_response = (void *)response;
     assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
     assert_int_equal(spdm_response->header.request_response_code,
@@ -1196,6 +1220,57 @@ void libspdm_test_responder_capabilities_case27(void **state)
                      SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY);
 }
 
+void libspdm_test_responder_capabilities_case28(void **state)
+{
+    libspdm_return_t status;
+    libspdm_test_context_t *spdm_test_context;
+    libspdm_context_t *spdm_context;
+    size_t response_size;
+    uint8_t response[LIBSPDM_MAX_SPDM_MSG_SIZE];
+    spdm_capabilities_response_t *spdm_response;
+
+    spdm_test_context = *state;
+    spdm_context = spdm_test_context->spdm_context;
+    spdm_test_context->case_id = 0x1C;
+    spdm_context->connection_info.connection_state = LIBSPDM_CONNECTION_STATE_AFTER_VERSION;
+
+    spdm_context->local_context.algorithm.measurement_spec = SPDM_MEASUREMENT_SPECIFICATION_DMTF;
+    spdm_context->local_context.algorithm.other_params_support = 0;
+    spdm_context->local_context.algorithm.base_asym_algo = m_libspdm_use_asym_algo;
+    spdm_context->local_context.algorithm.base_hash_algo = m_libspdm_use_hash_algo;
+    spdm_context->local_context.algorithm.mel_spec = SPDM_MEL_SPECIFICATION_DMTF;
+    spdm_context->local_context.capability.flags = SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_CHUNK_CAP;
+
+    spdm_context->connection_info.capability.flags |=
+        SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_KEY_EX_CAP;
+    spdm_context->connection_info.capability.flags |=
+        SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_ENCRYPT_CAP;
+    spdm_context->connection_info.capability.flags |=
+        SPDM_GET_CAPABILITIES_RESPONSE_FLAGS_MUT_AUTH_CAP;
+
+    spdm_context->local_context.algorithm.dhe_named_group = m_libspdm_use_dhe_algo;
+    spdm_context->local_context.algorithm.aead_cipher_suite = m_libspdm_use_aead_algo;
+    spdm_context->local_context.algorithm.req_base_asym_alg = m_libspdm_use_req_asym_algo;
+    spdm_context->local_context.algorithm.key_schedule = m_libspdm_use_key_schedule_algo;
+
+    response_size = sizeof(response);
+    status = libspdm_get_response_capabilities(
+        spdm_context, m_libspdm_get_capabilities_request28_size,
+        &m_libspdm_get_capabilities_request28, &response_size, response);
+    assert_int_equal(status, LIBSPDM_STATUS_SUCCESS);
+    assert_int_equal(response_size, sizeof(spdm_capabilities_response_t) +
+                     4 * sizeof(spdm_negotiate_algorithms_common_struct_table_t));
+    spdm_response = (void *)response;
+    assert_int_equal(spdm_response->header.spdm_version, SPDM_MESSAGE_VERSION_13);
+    assert_int_equal(spdm_response->header.request_response_code,
+                     SPDM_CAPABILITIES);
+    assert_int_equal(spdm_response->data_transfer_size, LIBSPDM_DATA_TRANSFER_SIZE);
+    assert_int_equal(spdm_response->max_spdm_msg_size, LIBSPDM_MAX_SPDM_MSG_SIZE);
+    assert_int_equal(spdm_context->connection_info.capability.flags,
+                     SPDM_GET_CAPABILITIES_REQUEST_FLAGS_CHUNK_CAP |
+                     SPDM_GET_CAPABILITIES_REQUEST_FLAGS_MULTI_KEY_CAP_ONLY);
+}
+
 int libspdm_responder_capabilities_test_main(void)
 {
     const struct CMUnitTest spdm_responder_capabilities_tests[] = {
@@ -1251,6 +1326,8 @@ int libspdm_responder_capabilities_test_main(void)
         cmocka_unit_test(libspdm_test_responder_capabilities_case26),
         /* Success Case , capability supports MULTI_KEY_CAP */
         cmocka_unit_test(libspdm_test_responder_capabilities_case27),
+        /* Success Case , capability supports MULTI_KEY_CAP */
+        cmocka_unit_test(libspdm_test_responder_capabilities_case28),
     };
 
     libspdm_test_context_t test_context = {