Add spdm attestation flow for rebinding

Author: IntelCaisui

src/migtd/src/migration/rebinding.rs

@@ -13,6 +13,8 @@ use ring::rand::{SecureRandom, SystemRandom};
 use tdx_tdcall::tdx::{tdcall_servtd_rebind_approve, tdcall_vm_write};
 
 use crate::mig_policy::get_init_policy;
+#[cfg(feature = "spdm_attestation")]
+use crate::spdm;
 use crypto::hash::digest_sha384;
 
 use crate::{
@@ -76,6 +78,7 @@ impl RebindingToken {
     }
 }
 
+#[derive(Clone)]
 pub struct RebindingInfo {
     pub mig_request_id: u64,
     pub rebinding_src: u8,
@@ -326,6 +329,16 @@ pub async fn start_rebinding(
             remote_policy,
         )
         .await?;
+
+        #[cfg(feature = "spdm_attestation")]
+        rebinding_old_spdm(
+            transport,
+            info,
+            data,
+            #[cfg(feature = "policy_v2")]
+            remote_policy,
+        )
+        .await?;
     } else {
         let remote_policy = Box::pin(with_timeout(
             PRE_SESSION_TIMEOUT,
@@ -356,6 +369,16 @@ pub async fn start_rebinding(
             remote_policy,
         )
         .await?;
+
+        #[cfg(feature = "spdm_attestation")]
+        rebinding_new_spdm(
+            transport,
+            info,
+            data,
+            #[cfg(feature = "policy_v2")]
+            remote_policy,
+        )
+        .await?;
     }
 
     #[cfg(feature = "vmcall-raw")]
@@ -370,6 +393,87 @@ pub async fn start_rebinding(
     Ok(())
 }
 
+#[cfg(feature = "spdm_attestation")]
+pub async fn rebinding_old_spdm(
+    transport: TransportType,
+    info: &RebindingInfo,
+    _data: &mut Vec<u8>,
+    #[cfg(feature = "policy_v2")] remote_policy: Vec<u8>,
+) -> Result<(), MigrationResult> {
+    const SPDM_TIMEOUT: Duration = Duration::from_secs(60); // 60 seconds
+    let mut spdm_requester = spdm::spdm_requester(transport).map_err(|_e| {
+        log::error!(
+            "rebinding: Failed in spdm_requester transport. Migration ID: {}\n",
+            info.mig_request_id
+        );
+        MigrationResult::SecureSessionError
+    })?;
+    with_timeout(
+        SPDM_TIMEOUT,
+        spdm::spdm_requester_rebind_old(
+            &mut spdm_requester,
+            info,
+            #[cfg(feature = "policy_v2")]
+            remote_policy,
+        ),
+    )
+    .await
+    .map_err(|e| {
+        log::error!(
+            "rebinding: spdm_requester_rebind_old timeout error: {:?}\n",
+            e
+        );
+        e
+    })?
+    .map_err(|e| {
+        log::error!("rebinding: spdm_requester_rebind_old error: {:?}\n", e);
+        e
+    })?;
+    log::info!("Rebind completed\n");
+    Ok(())
+}
+
+#[cfg(feature = "spdm_attestation")]
+pub async fn rebinding_new_spdm(
+    transport: TransportType,
+    info: &RebindingInfo,
+    _data: &mut Vec<u8>,
+    #[cfg(feature = "policy_v2")] remote_policy: Vec<u8>,
+) -> Result<(), MigrationResult> {
+    const SPDM_TIMEOUT: Duration = Duration::from_secs(60); // 60 seconds
+    let mut spdm_responder = spdm::spdm_responder(transport).map_err(|_e| {
+        log::error!(
+            "rebinding: Failed in spdm_responder transport. Migration ID: {}\n",
+            info.mig_request_id
+        );
+        MigrationResult::SecureSessionError
+    })?;
+
+    with_timeout(
+        SPDM_TIMEOUT,
+        spdm::spdm_responder_rebind_new(
+            &mut spdm_responder,
+            &info,
+            #[cfg(feature = "policy_v2")]
+            remote_policy,
+        ),
+    )
+    .await
+    .map_err(|e| {
+        log::error!(
+            "rebinding: spdm_responder_rebind_new timeout error: {:?}\n",
+            e
+        );
+        e
+    })?
+    .map_err(|e| {
+        log::error!("rebinding: spdm_responder_rebind_new error: {:?}\n", e);
+        e
+    })?;
+    log::info!("Rebind completed\n");
+    Ok(())
+}
+
 pub async fn rebinding_old(
     transport: TransportType,
     info: &RebindingInfo,
@@ -506,7 +610,7 @@ fn get_servtd_ext_from_cert(certs: &Option<Vec<&[u8]>>) -> Result<ServtdExt, Mig
     }
 }
 
-fn create_token_list(info: &RebindingInfo) -> Result<Vec<RebindingToken>, MigrationResult> {
+pub fn create_token_list(info: &RebindingInfo) -> Result<Vec<RebindingToken>, MigrationResult> {
     let mut tokens = Vec::new();
 
     for (handle, uuid) in info

src/migtd/src/migration/servtd_ext.rs

@@ -24,6 +24,7 @@ pub const TDCS_FIELD_SERVTD_ATTR: u64 = 0x1910000300000202;
 pub const TDCS_FIELD_SERVTD_ACCEPT_SERVTD_EXT_HASH: u64 = 0x1910000300000214;
 
 #[repr(C)]
+#[derive(Clone, Copy)]
 pub struct ServtdExt {
     pub init_servtd_info_hash: [u8; 48],
     pub init_attr: [u8; 8],

src/migtd/src/ratls/server_client.rs

@@ -247,7 +247,7 @@ fn gen_quote(public_key: &[u8]) -> Result<Vec<u8>> {
     })
 }
 
-fn gen_tdreport(public_key: &[u8]) -> Result<TdxReport> {
+pub fn gen_tdreport(public_key: &[u8]) -> Result<TdxReport> {
     let hash = digest_sha384(public_key).map_err(|e| {
         log::error!("Failed to compute SHA384 digest: {:?}\n", e);
         e

src/migtd/src/spdm/mod.rs

@@ -4,6 +4,7 @@
 
 #![cfg(feature = "spdm_attestation")]
 
+mod spdm_rebind;
 mod spdm_req;
 mod spdm_rsp;
 mod spdm_vdm;
@@ -25,6 +26,8 @@ use zeroize::ZeroizeOnDrop;
 use async_io::AsyncRead;
 use async_io::AsyncWrite;
 use crypto::hash::digest_sha384;
+pub use spdm_rebind::spdm_requester_rebind_old;
+pub use spdm_rebind::spdm_responder_rebind_new;
 pub use spdm_req::spdm_requester;
 pub use spdm_req::spdm_requester_transfer_msk;
 pub use spdm_rsp::spdm_responder;

src/migtd/src/spdm/spdm_rebind.rs

@@ -0,0 +1,89 @@
+// Copyright (c) 2026 Intel Corporation
+//
+// SPDX-License-Identifier: BSD-2-Clause-Patent
+use crate::{
+    migration::{rebinding::RebindingInfo, MigtdMigrationInformation},
+    spdm::{
+        spdm_req::{
+            send_and_receive_pub_key, send_and_receive_sdm_rebind_attest_info,
+            send_and_receive_sdm_rebind_info,
+        },
+        spdm_rsp::{rsp_handle_message, ResponderContextEx, ResponderContextExInfo},
+        PrivateKeyDer, SpdmAppContextData,
+    },
+};
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use codec::{Codec, Writer};
+use spdmlib::{
+    error::{SpdmStatus, SPDM_STATUS_BUFFER_FULL},
+    protocol::SpdmMeasurementSummaryHashType,
+    requester::RequesterContext,
+};
+use zeroize::Zeroize;
+
+pub async fn spdm_requester_rebind_old(
+    spdm_requester: &mut RequesterContext,
+    rebind_info: &RebindingInfo,
+    #[cfg(feature = "policy_v2")] remote_policy: Vec<u8>,
+) -> Result<(), SpdmStatus> {
+    Box::pin(spdm_requester.send_receive_spdm_version()).await?;
+    Box::pin(spdm_requester.send_receive_spdm_capability()).await?;
+    Box::pin(spdm_requester.send_receive_spdm_algorithm()).await?;
+
+    Box::pin(send_and_receive_pub_key(spdm_requester)).await?;
+    let session_id = Box::pin(spdm_requester.send_receive_spdm_key_exchange(
+        0xff,
+        SpdmMeasurementSummaryHashType::SpdmMeasurementSummaryHashTypeNone,
+    ))
+    .await?;
+
+    Box::pin(send_and_receive_sdm_rebind_attest_info(
+        spdm_requester,
+        rebind_info,
+        session_id,
+        #[cfg(feature = "policy_v2")]
+        remote_policy,
+    ))
+    .await?;
+
+    Box::pin(spdm_requester.send_receive_spdm_finish(Some(0xff), session_id)).await?;
+
+    Box::pin(send_and_receive_sdm_rebind_info(
+        spdm_requester,
+        rebind_info,
+        Some(session_id),
+    ))
+    .await?;
+
+    Box::pin(spdm_requester.send_receive_spdm_end_session(session_id)).await?;
+    Ok(())
+}
+
+pub async fn spdm_responder_rebind_new(
+    spdm_responder_ex: &mut ResponderContextEx,
+    rebind_info: &RebindingInfo,
+    #[cfg(feature = "policy_v2")] remote_policy: Vec<u8>,
+) -> Result<(), SpdmStatus> {
+    #[cfg(not(feature = "policy_v2"))]
+    let remote_policy = Vec::new();
+
+    spdm_responder_ex.remote_policy = remote_policy;
+    spdm_responder_ex.info = ResponderContextExInfo::RebindInformation(rebind_info.clone());
+
+    let spdm_responder = &mut spdm_responder_ex.responder_context;
+    let mut writer = Writer::init(&mut spdm_responder.common.app_context_data_buffer);
+
+    let responder_app_context = SpdmAppContextData {
+        migration_info: MigtdMigrationInformation::default(),
+        private_key: PrivateKeyDer::default(),
+    };
+    responder_app_context
+        .encode(&mut writer)
+        .map_err(|_| SPDM_STATUS_BUFFER_FULL)?;
+
+    Box::pin(rsp_handle_message(spdm_responder)).await?;
+    spdm_responder.common.app_context_data_buffer.zeroize();
+
+    Ok(())
+}