fix: report data and attestation

Author: think-in-universe

kms/src/near_kms_client.rs

@@ -8,6 +8,7 @@
 //! which verifies attestation and requests keys from the MPC network.
 
 use anyhow::{Context, Result};
+use byte_slice_cast::AsByteSlice;
 use fs_err as fs;
 use hex;
 use near_api::{
@@ -16,6 +17,7 @@ use near_api::{
 };
 use near_crypto::InMemorySigner;
 use serde::{Deserialize, Serialize};
+use sha3::{Digest, Sha3_384};
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -267,3 +269,48 @@ pub fn load_or_generate_near_signer(config: &KmsConfig) -> Result<Option<InMemor
         Ok(Some(signer))
     }
 }
+
+/// Converts a NEAR public key to the report_data format required by the NEAR KMS contract.
+///
+/// The format matches `ReportData::new()` in the contract:
+/// `[version(2 bytes big endian) || SHA3-384(public_key_bytes[1..]) || zero padding]`
+///
+/// # Arguments
+/// * `public_key` - The NEAR account public key (must be ED25519)
+///
+/// # Returns
+/// A 64-byte array containing the report_data in the format expected by the KMS contract
+///
+/// # Errors
+/// Returns an error if the public key is not ED25519 (only ED25519 keys are supported for NEAR implicit accounts)
+pub fn near_public_key_to_report_data(
+    public_key: &near_crypto::PublicKey,
+) -> Result<[u8; 64]> {
+    const REPORT_DATA_SIZE: usize = 64;
+    const BINARY_VERSION_SIZE: usize = 2;
+    const PUBLIC_KEYS_HASH_SIZE: usize = 48;
+    const PUBLIC_KEYS_OFFSET: usize = BINARY_VERSION_SIZE;
+
+    let mut report_data = [0u8; REPORT_DATA_SIZE];
+
+    // Version: 1 (2 bytes, big endian)
+    report_data[0..BINARY_VERSION_SIZE].copy_from_slice(&1u16.to_be_bytes());
+
+    // Get public key bytes (skip first byte which is curve type identifier)
+    let public_key_bytes = match public_key {
+        near_crypto::PublicKey::ED25519(pk) => pk.as_byte_slice(),
+        _ => anyhow::bail!("Only ED25519 keys are supported for NEAR implicit accounts"),
+    };
+
+    // Hash public key bytes (skip first byte) with SHA3-384
+    let mut hasher = Sha3_384::new();
+    hasher.update(&public_key_bytes[1..]); // Skip first byte (curve type)
+    let hash: [u8; PUBLIC_KEYS_HASH_SIZE] = hasher.finalize().into();
+
+    // Copy hash to report_data (offset 2, length 48)
+    report_data[PUBLIC_KEYS_OFFSET..PUBLIC_KEYS_OFFSET + PUBLIC_KEYS_HASH_SIZE]
+        .copy_from_slice(&hash);
+    // Remaining bytes (50..64) are already zero-padded
+
+    Ok(report_data)
+}

kms/src/onboard_service.rs

@@ -26,7 +26,7 @@ use crate::ckd::{
     derive_root_key_from_mpc, g1_to_near_format, generate_ephemeral_keypair, MpcConfig,
 };
 use crate::config::{AuthApi, KmsConfig};
-use crate::near_kms_client::{load_or_generate_near_signer, NearKmsClient};
+use crate::near_kms_client::{load_or_generate_near_signer, near_public_key_to_report_data, NearKmsClient};
 use dcap_qvl::collateral;
 use near_api::NetworkConfig;
 use ra_tls::kdf;
@@ -446,6 +446,10 @@ async fn try_derive_keys_from_mpc(
     tracing::info!("  Domain ID: {}", mpc_domain_id);
     tracing::info!("  Signer Account ID: {}", signer.account_id);
 
+    // Get the NEAR account public key for report_data (clone before moving signer)
+    // The signer's public_key field contains the NEAR account public key
+    let near_account_public_key = signer.public_key.clone();
+
     let kms_client = NearKmsClient::new(
         network_config,
         mpc_contract_id.clone(),
@@ -479,28 +483,20 @@ async fn try_derive_keys_from_mpc(
     // Get TDX attestation (quote, collateral, tcb_info) for KMS contract
     // The KMS contract's request_kms_root_key() requires attestation verification
     let (quote_hex, collateral_json, tcb_info_json) = if quote_enabled {
-        // Generate a quote with the worker public key as report_data
-        let worker_pubkey_bytes = ephemeral_public_key.to_compressed();
-        let mut report_data = vec![0u8; 64];
-        // Put worker public key in report_data (first 48 bytes for BLS12-381 G1)
-        if worker_pubkey_bytes.len() <= 48 {
-            report_data[..worker_pubkey_bytes.len()].copy_from_slice(&worker_pubkey_bytes);
-        } else {
-            // Hash if too long
-            use sha2::{Digest, Sha256};
-            let hash = Sha256::digest(&worker_pubkey_bytes);
-            report_data[..32].copy_from_slice(&hash);
-        }
+        // Generate report_data from NEAR account public key using helper function
+        let report_data = near_public_key_to_report_data(&near_account_public_key)
+            .context("Failed to convert NEAR public key to report_data format")?;
 
-        let attest_response = app_attest(report_data)
+        let attest_response = app_attest(report_data.to_vec())
             .await
             .context("Failed to get TDX quote for MPC request")?;
 
         let attestation = VersionedAttestation::from_scale(&attest_response.attestation)
             .context("Failed to parse attestation")?;
 
-        // Get quote bytes
+        // Get quote bytes - need to call into_inner() first to get Attestation
         let quote_bytes = attestation
+            .into_inner()
             .tdx_quote()
             .and_then(|q| Some(q.quote.clone()))
             .context("Failed to get TDX quote bytes")?;
@@ -512,8 +508,11 @@ async fn try_derive_keys_from_mpc(
             .await
             .context("Failed to get collateral and verify quote")?;
 
-        let collateral_json = serde_json::to_string(&verified_report.collateral)
-            .context("Failed to serialize collateral")?;
+        // Extract collateral from verified_report
+        // The verified_report contains the quote verification result
+        // We need to serialize the entire verified_report or extract the needed fields
+        let collateral_json = serde_json::to_string(&verified_report)
+            .context("Failed to serialize verified report as collateral")?;
 
         // Get TCB info from verified report
         let td_report = verified_report