SPDM Chunk capability - add early large message size check

Add early large message size check at receiver side for detecting
  danger of chunk_seq_num wrapping around.
If problem is detected early, return error early for performance.

Author: IntelCaisui

spdmlib/src/requester/context.rs

@@ -481,6 +481,19 @@ impl RequesterContext {
                                         error!("!!! receive_large_response: large message size too small !!!\n");
                                         return Err(SPDM_STATUS_INVALID_MSG_FIELD);
                                     }
+
+                                    // Early check whether large message size is too large to be received in chunks.
+                                    let data_transfer_size = config::SPDM_DATA_TRANSFER_SIZE;
+                                    let max_large_response_size = (data_transfer_size
+                                        - SPDM_VERSION_1_2_OFFSET_OF_SPDM_CHUNK_IN_CHUNK_RESPONSE)
+                                        * (u16::MAX as usize - 1)
+                                        + data_transfer_size
+                                        - SPDM_VERSION_1_2_OFFSET_OF_RESPONSE_OF_LARGE_REQUEST_IN_CHUNK_SEND_ACK;
+                                    if large_message_size as usize > max_large_response_size {
+                                        error!("!!! receive_large_response: request too large to receive in chunks !!!\n");
+                                        return Err(SPDM_STATUS_INVALID_MSG_FIELD);
+                                    }
+
                                     self.common.chunk_context.chunk_message_size =
                                         large_message_size as usize;
                                 } else {

spdmlib/src/responder/context.rs

@@ -882,15 +882,25 @@ impl ResponderContext {
                 let max_chunk_size = (config::SPDM_DATA_TRANSFER_SIZE
                     - SPDM_VERSION_1_2_OFFSET_OF_SPDM_CHUNK_IN_FIRST_CHUNK_SEND)
                     as u32;
+
+                // Early check whether large message size is too large to be received in chunks.
+                let data_transfer_size = config::SPDM_DATA_TRANSFER_SIZE;
+                let max_large_request_size = (data_transfer_size
+                    - SPDM_VERSION_1_2_OFFSET_OF_SPDM_CHUNK_IN_CHUNK_SEND)
+                    * (u16::MAX as usize - 1)
+                    + data_transfer_size
+                    - SPDM_VERSION_1_2_OFFSET_OF_SPDM_CHUNK_IN_FIRST_CHUNK_SEND;
+
                 if chunk_send_request.chunk_seq_num != 0
                     || !(config::SPDM_MIN_DATA_TRANSFER_SIZE..=config::MAX_SPDM_MSG_SIZE)
                         .contains(&large_message_size)
+                    || large_message_size > max_large_request_size
                     || chunk_send_request
                         .chunk_sender_attributes
                         .contains(SpdmChunkSenderAttributes::LAST_CHUNK)
                     || chunk_send_request.chunk_size > max_chunk_size
                 {
-                    error!("!!! invalid chunk send request, first chunk send is expected !!!\n");
+                    error!("!!! invalid chunk send request, first chunk send is expected or request contains illegal data !!!\n");
                     self.write_spdm_error(SpdmErrorCode::SpdmErrorInvalidRequest, 0, writer);
                     return (
                         Err(SPDM_STATUS_INVALID_STATE_PEER),