feat(tee-verifier-interface): Borsh DTOs for the verifier contract boundary

[pbeza]

Closes #3265

Overview

Adds tee-verifier-interface: the Borsh DTOs spoken at the tee-verifier contract boundary.

They are field-for-field mirrors of the dcap-qvl input and output types, owned here so the Borsh wire layout is independent of upstream.

This crate is the only DTO crate a consumer (mpc-contract, future Proximity / Defuse contracts) needs in order to talk to the verifier — without re-linking the dcap-qvl / ring / webpki / x509-cert closure into its own WASM.

Prerequisite for the verifier contract in #3266 (PR #3237); part of the stack tracked by #3264.

[pbeza]

@claude review

[pbeza]

Would be good to mention why we use borsh only (where we were previously using also serde). (...)

Good point! Added a note about that here: bb226c3.

(...) Also as many of these structs will then be removed from the contract-interface crate, might be good to point that out in some issue or comment.

Created an issue: #3494 and referenced it in the comment here: 314a535.

A more general question, if we plan to keep this in sync with the dcap types, would it make sense to add some tests to enforce that?

Great catch! #3237 (the PR stacked on top of this one) does exactly that: it adds the From<dcap_qvl::…> conversions plus tests asserting borsh::to_vec(interface) == borsh::to_vec(dcap) per type, so an upstream field reorder/rename fails CI. Has to live there rather than here, since this crate stays dcap-qvl-free and only the verifier crate links both. See:

mpc/crates/tee-verifier/src/conversions.rs

Lines 148 to 339 in cf72a5a

	/// Pins the Borsh wire layout of each `tee-verifier-interface` mirror type
	/// against its `dcap_qvl` counterpart.
	///
	/// The conversions above already make the compiler reject an upstream rename,
	/// removal, type change, or added variant; the drift they miss is a same-name
	/// *reordering* of fields or variants, which silently changes the Borsh layout.
	/// Each test builds both sides by the same field/variant names and asserts
	/// equal Borsh bytes, so a reorder diverges — even for fieldless enum variants.
	/// This relies on every field having a distinct fill value (`[1; _]`, `[2; _]`,
	/// ...): a swap of two same-typed fields is only observable when they differ.
	#[cfg(test)]
	#[expect(non_snake_case)]
	mod tests {
	use super::*;
	use rstest::rstest;
	/// Asserts the two values encode to identical Borsh bytes.
	fn assert_same_borsh_bytes<I: borsh::BorshSerialize, D: borsh::BorshSerialize>(
	interface: &I,
	dcap: &D,
	) {
	let interface_bytes = borsh::to_vec(interface).expect("interface should serialize");
	let dcap_bytes = borsh::to_vec(dcap).expect("dcap should serialize");
	assert_eq!(interface_bytes, dcap_bytes);
	}
	fn sample_collateral() -> Collateral {
	Collateral {
	pck_crl_issuer_chain: "issuer-chain".into(),
	root_ca_crl: vec![1, 2, 3],
	pck_crl: vec![4, 5, 6],
	tcb_info_issuer_chain: "tcb-issuer".into(),
	tcb_info: "tcb-info-json".into(),
	tcb_info_signature: vec![7, 8],
	qe_identity_issuer_chain: "qe-issuer".into(),
	qe_identity: "qe-identity-json".into(),
	qe_identity_signature: vec![9, 10],
	pck_certificate_chain: Some("pck-chain".into()),
	}
	}
	fn dcap_td10() -> dq_quote::TDReport10 {
	dq_quote::TDReport10 {
	tee_tcb_svn: [1; 16],
	mr_seam: [2; 48],
	mr_signer_seam: [3; 48],
	seam_attributes: [4; 8],
	td_attributes: [5; 8],
	xfam: [6; 8],
	mr_td: [7; 48],
	mr_config_id: [8; 48],
	mr_owner: [9; 48],
	mr_owner_config: [10; 48],
	rt_mr0: [11; 48],
	rt_mr1: [12; 48],
	rt_mr2: [13; 48],
	rt_mr3: [14; 48],
	report_data: [15; 64],
	}
	}
	fn dcap_td15() -> dq_quote::TDReport15 {
	dq_quote::TDReport15 {
	base: dcap_td10(),
	tee_tcb_svn2: [16; 16],
	mr_service_td: [17; 48],
	}
	}
	fn dcap_sgx() -> dq_quote::EnclaveReport {
	dq_quote::EnclaveReport {
	cpu_svn: [1; 16],
	misc_select: 42,
	reserved1: [2; 28],
	attributes: [3; 16],
	mr_enclave: [4; 32],
	reserved2: [5; 32],
	mr_signer: [6; 32],
	reserved3: [7; 96],
	isv_prod_id: 8,
	isv_svn: 9,
	reserved4: [10; 60],
	report_data: [11; 64],
	}
	}
	fn dcap_verified_report(report: dq_quote::Report) -> dq_verify::VerifiedReport {
	dq_verify::VerifiedReport {
	status: "UpToDate".into(),
	advisory_ids: vec!["INTEL-SA-00001".into()],
	report,
	ppid: vec![0xAB; 16],
	qe_status: dq_tcb::TcbStatusWithAdvisory {
	status: dq_tcb::TcbStatus::UpToDate,
	advisory_ids: vec![],
	},
	platform_status: dq_tcb::TcbStatusWithAdvisory {
	status: dq_tcb::TcbStatus::ConfigurationNeeded,
	advisory_ids: vec!["INTEL-SA-00002".into()],
	},
	}
	}
	/// Name-equal `dcap_qvl` counterpart of an interface [`TcbStatus`]. The
	/// exhaustive `match` makes the compiler flag an upstream variant
	/// rename/removal; the byte comparison in the test catches a reorder.
	fn dcap_tcb_status(status: &TcbStatus) -> dq_tcb::TcbStatus {
	match status {
	TcbStatus::UpToDate => dq_tcb::TcbStatus::UpToDate,
	TcbStatus::OutOfDateConfigurationNeeded => {
	dq_tcb::TcbStatus::OutOfDateConfigurationNeeded
	}
	TcbStatus::OutOfDate => dq_tcb::TcbStatus::OutOfDate,
	TcbStatus::ConfigurationAndSWHardeningNeeded => {
	dq_tcb::TcbStatus::ConfigurationAndSWHardeningNeeded
	}
	TcbStatus::ConfigurationNeeded => dq_tcb::TcbStatus::ConfigurationNeeded,
	TcbStatus::SWHardeningNeeded => dq_tcb::TcbStatus::SWHardeningNeeded,
	TcbStatus::Revoked => dq_tcb::TcbStatus::Revoked,
	}
	}
	#[test]
	fn collateral__should_match_dcap_borsh_layout() {
	let interface = sample_collateral();
	let dcap = interface.clone().into_dcap_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	#[test]
	fn td_report_10__should_match_dcap_borsh_layout() {
	let dcap = dcap_td10();
	let interface: TDReport10 = dcap.into_interface_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	#[test]
	fn td_report_15__should_match_dcap_borsh_layout() {
	let dcap = dcap_td15();
	let interface: TDReport15 = dcap.into_interface_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	#[test]
	fn enclave_report__should_match_dcap_borsh_layout() {
	let dcap = dcap_sgx();
	let interface: EnclaveReport = dcap.into_interface_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	#[rstest]
	#[case::sgx(dq_quote::Report::SgxEnclave(dcap_sgx()))]
	#[case::td10(dq_quote::Report::TD10(dcap_td10()))]
	#[case::td15(dq_quote::Report::TD15(dcap_td15()))]
	fn report__should_match_dcap_borsh_layout(#[case] dcap: dq_quote::Report) {
	let interface: Report = dcap.clone().into_interface_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	#[rstest]
	#[case(TcbStatus::UpToDate)]
	#[case(TcbStatus::OutOfDateConfigurationNeeded)]
	#[case(TcbStatus::OutOfDate)]
	#[case(TcbStatus::ConfigurationAndSWHardeningNeeded)]
	#[case(TcbStatus::ConfigurationNeeded)]
	#[case(TcbStatus::SWHardeningNeeded)]
	#[case(TcbStatus::Revoked)]
	fn tcb_status__should_match_dcap_borsh_layout(#[case] status: TcbStatus) {
	let dcap = dcap_tcb_status(&status);
	assert_same_borsh_bytes(&status, &dcap);
	}
	#[test]
	fn tcb_status_with_advisory__should_match_dcap_borsh_layout() {
	let dcap = dq_tcb::TcbStatusWithAdvisory {
	status: dq_tcb::TcbStatus::ConfigurationNeeded,
	advisory_ids: vec!["INTEL-SA-00003".into()],
	};
	let interface: TcbStatusWithAdvisory = dcap.clone().into_interface_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	#[rstest]
	#[case::sgx(dq_quote::Report::SgxEnclave(dcap_sgx()))]
	#[case::td10(dq_quote::Report::TD10(dcap_td10()))]
	#[case::td15(dq_quote::Report::TD15(dcap_td15()))]
	fn verified_report__should_match_dcap_borsh_layout(#[case] report: dq_quote::Report) {
	let dcap = dcap_verified_report(report);
	let interface: VerifiedReport = dcap.clone().into_interface_type();
	assert_same_borsh_bytes(&interface, &dcap);
	}
	}

[pbeza]

@barakeinav1 @netrome I need one more approval. Please re-review when you get a chance. Thanks! 🙏🏼

[barakeinav1]

Re-reviewed fa44ba9b. The VerificationResult { Verified, Rejected } change resolves the regression cleanly — a rejected quote now resumes immediately with its reason, and only a genuinely unreachable verifier falls through to the timeout, which is the correct behavior. Doc is fully in sync now. Thanks for the quick turnaround. 👍