diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a38ba2..e81524c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,8 @@
   `reference_manifest_data` and `payload_checksum` fields to correctly parse
   their contents.
 
+- file: Add encode req & decode resp for DfOpen and DfClose command
+
 ### Changed
 
 - Stabilised `decode_get_event_receiver_resp()`
diff --git a/include/libpldm/file.h b/include/libpldm/file.h
index 425f017..0c17daf 100644
--- a/include/libpldm/file.h
+++ b/include/libpldm/file.h
@@ -117,6 +117,39 @@
 				 const struct pldm_file_df_open_req *req,
 				 struct pldm_msg *msg, size_t payload_length);
 
+/** @brief Decode DFOpen request data
+ *
+ *  @param[in] msg - Response message
+ *  @param[in] payload_length - Length of response message payload
+ *  @param[out] req - Pointer to the decoded request message
+ *  @return 0 on success
+ *          -EINVAL if argument values are invalid for the invocation
+ *          -EOVERFLOW if the input message buffer is too short for the output
+ *          response struct
+ *          -EBADMSG if the input message buffer is too large for the output
+ *          response struct.
+ */
+int decode_pldm_file_df_open_req(const struct pldm_msg *msg,
+				 size_t payload_length,
+				 struct pldm_file_df_open_req *req);
+
+/** @brief Create a PLDM response message for DFOpen
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in] resp - The pointer to the response message to be encoded
+ *  @param[in,out] msg - Message will be written to this
+ *  @param[in, out] payload_length - Length of the request message payload
+ *  @return 0 on success
+ *          -EINVAL if argument values are invalid for the invocation
+ *          -ENOMSG if the PLDM type in the request header is invalid
+ *          -EOVERFLOW if the input message length is invalid
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.payload'
+ */
+int encode_pldm_file_df_open_resp(uint8_t instance_id,
+				  const struct pldm_file_df_open_resp *resp,
+				  struct pldm_msg *msg, size_t *payload_length);
+
 /** @brief Decode DFOpen response data
  *
  *  @param[in] msg - Response message
@@ -151,6 +184,40 @@
 				  const struct pldm_file_df_close_req *req,
 				  struct pldm_msg *msg, size_t payload_length);
 
+/** @brief Decode DFClose request data
+ *
+ *  @param[in] msg - Response message
+ *  @param[in] payload_length - Length of response message payload
+ *  @param[out] req - pointer to the decoded request message
+ *  @return 0 on success
+ *          -EINVAL if argument values are invalid for the invocation
+ *          -EOVERFLOW if the input message buffer is too short for the output
+ *          response struct
+ *          -EBADMSG if the input message buffer is too large for the output
+ *          response struct.
+ */
+int decode_pldm_file_df_close_req(const struct pldm_msg *msg,
+				  size_t payload_length,
+				  struct pldm_file_df_close_req *req);
+
+/** @brief Create a PLDM response message for DFClose
+ *
+ *  @param[in] instance_id - Message's instance id
+ *  @param[in] resp - The pointer to the response message to be encoded
+ *  @param[in,out] msg - Message will be written to this
+ *  @param[in,out] payload_length - Length of the request message payload
+ *  @return 0 on success
+ *          -EINVAL if argument values are invalid for the invocation
+ *          -ENOMSG if the PLDM type in the request header is invalid
+ *          -EOVERFLOW if the input message length is invalid
+ *  @note  Caller is responsible for memory alloc and dealloc of param
+ *         'msg.payload'
+ */
+int encode_pldm_file_df_close_resp(uint8_t instance_id,
+				   const struct pldm_file_df_close_resp *resp,
+				   struct pldm_msg *msg,
+				   size_t *payload_length);
+
 /** @brief Decode DFClose response data
  *
  *  @param[in] msg - Response message
diff --git a/src/dsp/file.c b/src/dsp/file.c
index fb3d1de..988d284 100644
--- a/src/dsp/file.c
+++ b/src/dsp/file.c
@@ -49,6 +49,67 @@
 }
 
 LIBPLDM_ABI_TESTING
+int decode_pldm_file_df_open_req(const struct pldm_msg *msg,
+				 size_t payload_length,
+				 struct pldm_file_df_open_req *req)
+{
+	PLDM_MSGBUF_DEFINE_P(buf);
+	int rc;
+
+	if (!msg || !req) {
+		return -EINVAL;
+	}
+
+	rc = pldm_msgbuf_init_errno(buf, PLDM_DF_OPEN_REQ_BYTES, msg->payload,
+				    payload_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_extract(buf, req->file_identifier);
+	pldm_msgbuf_extract(buf, req->file_attribute.value);
+
+	return pldm_msgbuf_complete_consumed(buf);
+}
+
+LIBPLDM_ABI_TESTING
+int encode_pldm_file_df_open_resp(uint8_t instance_id,
+				  const struct pldm_file_df_open_resp *resp,
+				  struct pldm_msg *msg, size_t *payload_length)
+{
+	PLDM_MSGBUF_DEFINE_P(buf);
+	int rc;
+
+	if (!msg || !resp) {
+		return -EINVAL;
+	}
+
+	struct pldm_header_info header = { 0 };
+	header.instance = instance_id;
+	header.msg_type = PLDM_RESPONSE;
+	header.pldm_type = PLDM_FILE;
+	header.command = PLDM_FILE_CMD_DF_OPEN;
+
+	rc = pack_pldm_header_errno(&header, &(msg->hdr));
+	if (rc) {
+		return rc;
+	}
+
+	rc = pldm_msgbuf_init_errno(buf, PLDM_DF_OPEN_RESP_BYTES, msg->payload,
+				    *payload_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_insert(buf, resp->completion_code);
+	if (resp->completion_code == PLDM_SUCCESS) {
+		pldm_msgbuf_insert(buf, resp->file_descriptor);
+	}
+
+	return pldm_msgbuf_complete_used(buf, *payload_length, payload_length);
+}
+
+LIBPLDM_ABI_TESTING
 int decode_pldm_file_df_open_resp(const struct pldm_msg *msg,
 				  size_t payload_length,
 				  struct pldm_file_df_open_resp *resp)
@@ -73,6 +134,11 @@
 	}
 
 	pldm_msgbuf_extract(buf, resp->completion_code);
+	if (resp->completion_code != PLDM_SUCCESS) {
+		// Return the CC directly without decoding the rest of the payload
+		return pldm_msgbuf_complete(buf);
+	}
+
 	pldm_msgbuf_extract(buf, resp->file_descriptor);
 
 	return pldm_msgbuf_complete_consumed(buf);
@@ -114,6 +180,64 @@
 }
 
 LIBPLDM_ABI_TESTING
+int decode_pldm_file_df_close_req(const struct pldm_msg *msg,
+				  size_t payload_length,
+				  struct pldm_file_df_close_req *req)
+{
+	PLDM_MSGBUF_DEFINE_P(buf);
+	int rc;
+
+	if (!msg || !req) {
+		return -EINVAL;
+	}
+
+	rc = pldm_msgbuf_init_errno(buf, PLDM_DF_CLOSE_REQ_BYTES, msg->payload,
+				    payload_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_extract(buf, req->file_descriptor);
+	pldm_msgbuf_extract(buf, req->df_close_options.value);
+
+	return pldm_msgbuf_complete_consumed(buf);
+}
+
+LIBPLDM_ABI_TESTING
+int encode_pldm_file_df_close_resp(uint8_t instance_id,
+				   const struct pldm_file_df_close_resp *resp,
+				   struct pldm_msg *msg, size_t *payload_length)
+{
+	PLDM_MSGBUF_DEFINE_P(buf);
+	int rc;
+
+	if (!msg || !resp) {
+		return -EINVAL;
+	}
+
+	struct pldm_header_info header = { 0 };
+	header.instance = instance_id;
+	header.msg_type = PLDM_RESPONSE;
+	header.pldm_type = PLDM_FILE;
+	header.command = PLDM_FILE_CMD_DF_CLOSE;
+
+	rc = pack_pldm_header_errno(&header, &(msg->hdr));
+	if (rc) {
+		return rc;
+	}
+
+	rc = pldm_msgbuf_init_errno(buf, PLDM_DF_CLOSE_RESP_BYTES, msg->payload,
+				    *payload_length);
+	if (rc) {
+		return rc;
+	}
+
+	pldm_msgbuf_insert(buf, resp->completion_code);
+
+	return pldm_msgbuf_complete_used(buf, *payload_length, payload_length);
+}
+
+LIBPLDM_ABI_TESTING
 int decode_pldm_file_df_close_resp(const struct pldm_msg *msg,
 				   size_t payload_length,
 				   struct pldm_file_df_close_resp *resp)
diff --git a/tests/dsp/file.cpp b/tests/dsp/file.cpp
index 93ba847..71dcce3 100644
--- a/tests/dsp/file.cpp
+++ b/tests/dsp/file.cpp
@@ -441,3 +441,284 @@
     EXPECT_EQ(rc, -EOVERFLOW);
 }
 #endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfOpenResp, GoodTest)
+{
+    uint8_t instance_id = 0;
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint16_t file_descriptor = 0x0100;
+    size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
+    std::array<uint8_t, PLDM_DF_OPEN_RESP_BYTES> responseMsg = {0x00, 0x00,
+                                                                0x01};
+
+    const struct pldm_file_df_open_resp resp_data = {completion_code,
+                                                     file_descriptor};
+
+    PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
+    auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data,
+                                            responsePtr, &payload_length);
+
+    ASSERT_EQ(rc, 0);
+    EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(),
+                        sizeof(responseMsg)));
+    EXPECT_EQ(payload_length, PLDM_DF_OPEN_RESP_BYTES);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfOpenResp, BadTestUnAllocatedPtrParams)
+{
+    uint8_t instance_id = 0;
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint16_t file_descriptor = 0x0100;
+    int rc;
+    size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
+    const struct pldm_file_df_open_resp resp_data = {completion_code,
+                                                     file_descriptor};
+
+    PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
+    rc = encode_pldm_file_df_open_resp(instance_id, &resp_data, nullptr,
+                                       &payload_length);
+    EXPECT_EQ(rc, -EINVAL);
+
+    rc = encode_pldm_file_df_open_req(instance_id, nullptr, responsePtr,
+                                      PLDM_DF_OPEN_RESP_BYTES);
+    EXPECT_EQ(rc, -EINVAL);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfOpenResp, BadTestInvalidExpectedOutputMsgLength)
+{
+    uint8_t instance_id = 0;
+    uint8_t completion_code = PLDM_SUCCESS;
+    uint16_t file_descriptor = 0x0100;
+    size_t payload_length;
+
+    const struct pldm_file_df_open_resp resp_data = {completion_code,
+                                                     file_descriptor};
+
+    PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
+    payload_length = 1;
+    auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data,
+                                            responsePtr, &payload_length);
+    EXPECT_EQ(rc, -EOVERFLOW);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfOpenResp, GoodTestCompletionCode)
+{
+    uint8_t instance_id = 0;
+    uint8_t completion_code = PLDM_FILE_CC_INVALID_FILE_DESCRIPTOR;
+    uint16_t file_descriptor = 0x0100;
+    size_t payload_length = PLDM_DF_OPEN_RESP_BYTES;
+
+    const struct pldm_file_df_open_resp resp_data = {completion_code,
+                                                     file_descriptor};
+
+    PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES);
+    auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data,
+                                            responsePtr, &payload_length);
+    EXPECT_EQ(rc, 0);
+    EXPECT_EQ(payload_length, 1); // Completion code only
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfOpenReq, GoodTest)
+{
+    uint16_t file_identifier = 0x0100;
+    bitfield16_t file_attribute;
+    file_attribute.value = 0x0400;
+
+    struct pldm_file_df_open_req req_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES;
+
+    PLDM_MSG_DEFINE_P(requestMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint16(buf, file_identifier);
+    pldm_msgbuf_insert_uint16(buf, file_attribute.value);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_open_req(requestMsg, payload_length, &req_data);
+
+    ASSERT_EQ(rc, 0);
+    EXPECT_EQ(req_data.file_identifier, file_identifier);
+    EXPECT_EQ(req_data.file_attribute.value, file_attribute.value);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfOpenReq, BadTestUnAllocatedPtrParams)
+{
+    uint16_t file_identifier = 0x0100;
+    bitfield16_t file_attribute;
+    file_attribute.value = 0x0400;
+
+    struct pldm_file_df_open_req req_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES;
+
+    PLDM_MSG_DEFINE_P(requestMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint16(buf, file_identifier);
+    pldm_msgbuf_insert_uint16(buf, file_attribute.value);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_open_req(nullptr, payload_length, &req_data);
+    EXPECT_EQ(rc, -EINVAL);
+
+    rc = decode_pldm_file_df_open_req(requestMsg, payload_length, nullptr);
+    EXPECT_EQ(rc, -EINVAL);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfOpenReq, BadTestInvalidExpectedInputMsgLength)
+{
+    uint16_t file_identifier = 0x0100;
+    bitfield16_t file_attribute;
+    file_attribute.value = 0x0400;
+
+    struct pldm_file_df_open_req req_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES;
+
+    PLDM_MSG_DEFINE_P(requestMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint16(buf, file_identifier);
+    pldm_msgbuf_insert_uint16(buf, file_attribute.value);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_open_req(requestMsg, 0, &req_data);
+    EXPECT_EQ(rc, -EOVERFLOW);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfCloseResp, GoodTest)
+{
+    uint8_t instance_id = 0;
+    size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES;
+    std::array<uint8_t, PLDM_DF_CLOSE_RESP_BYTES> responseMsg = {PLDM_SUCCESS};
+
+    const struct pldm_file_df_close_resp resp_data = {PLDM_SUCCESS};
+
+    PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_CLOSE_RESP_BYTES);
+
+    auto rc = encode_pldm_file_df_close_resp(instance_id, &resp_data,
+                                             responsePtr, &payload_length);
+
+    ASSERT_EQ(rc, 0);
+    EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(),
+                        sizeof(responseMsg)));
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(EncodeDfCloseResp, BadTestUnAllocatedPtrParams)
+{
+    uint8_t instance_id = 0;
+    size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES;
+    const struct pldm_file_df_close_resp resp_data = {PLDM_SUCCESS};
+    int rc;
+
+    PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_CLOSE_RESP_BYTES);
+
+    rc = encode_pldm_file_df_close_resp(instance_id, &resp_data, nullptr,
+                                        &payload_length);
+    EXPECT_EQ(rc, -EINVAL);
+
+    rc = encode_pldm_file_df_close_resp(instance_id, nullptr, responsePtr,
+                                        &payload_length);
+    EXPECT_EQ(rc, -EINVAL);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfCloseReq, GoodTest)
+{
+    uint16_t file_descriptor = 0x1000;
+    bitfield16_t df_close_options;
+    df_close_options.value = 0x4000;
+
+    struct pldm_file_df_close_req req_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_CLOSE_REQ_BYTES;
+
+    PLDM_MSG_DEFINE_P(requestMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint16(buf, file_descriptor);
+    pldm_msgbuf_insert_uint16(buf, df_close_options.value);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_close_req(requestMsg, payload_length, &req_data);
+
+    ASSERT_EQ(rc, 0);
+    EXPECT_EQ(req_data.file_descriptor, file_descriptor);
+    EXPECT_EQ(req_data.df_close_options.value, df_close_options.value);
+}
+#endif
+
+#ifdef LIBPLDM_API_TESTING
+TEST(DecodeDfCloseReq, BadTestUnAllocatedPtrParams)
+{
+    uint16_t file_descriptor = 0x1000;
+    bitfield16_t df_close_options;
+    df_close_options.value = 0x4000;
+
+    struct pldm_file_df_close_req req_data = {};
+
+    PLDM_MSGBUF_DEFINE_P(buf);
+    int rc;
+
+    static constexpr const size_t payload_length = PLDM_DF_CLOSE_REQ_BYTES;
+
+    PLDM_MSG_DEFINE_P(requestMsg, payload_length);
+
+    rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length);
+    ASSERT_EQ(rc, 0);
+
+    pldm_msgbuf_insert_uint16(buf, file_descriptor);
+    pldm_msgbuf_insert_uint16(buf, df_close_options.value);
+
+    ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
+
+    rc = decode_pldm_file_df_close_req(nullptr, payload_length, &req_data);
+    EXPECT_EQ(rc, -EINVAL);
+
+    rc = decode_pldm_file_df_close_req(requestMsg, payload_length, nullptr);
+    EXPECT_EQ(rc, -EINVAL);
+}
+#endif