1use chrono::{DateTime, Duration, Utc};
2use crate::{
3 Error, Fmspc, PlatformTypeForTcbInfo, QeIdentity, QeIdentitySigned, TcbData, TcbInfo, TcbStatus,
4 Unverified, VerificationType, Verified, io::{self, WriteOptions}, pckcrt::TcbComponents,
5};
6use serde::{Deserialize, Serialize};
7use serde_json::value::RawValue;
8use std::marker::PhantomData;
9use std::path::PathBuf;
10use std::slice::Iter;
11
12#[cfg(feature = "verify")]
13use {
14 std::ops::Deref, crate::RootCaCrl
15};
16
17#[derive(Clone, Debug, Deserialize)]
20#[serde(rename_all = "camelCase")]
21pub struct TcbEvaluationDataNumbers<T: PlatformTypeForTcbInfo, V: VerificationType = Verified> {
22 #[allow(unused)]
23 #[serde(deserialize_with = "crate::deserialize_platform_id")]
24 id: T,
25 #[allow(unused)]
26 version: u16,
27 #[allow(unused)]
28 #[serde(with = "crate::iso8601")]
29 issue_date: DateTime<Utc>,
30 #[allow(unused)]
31 #[serde(with = "crate::iso8601")]
32 next_update: DateTime<Utc>,
33 #[allow(unused)]
34 tcb_eval_numbers: Vec<TcbEvalNumber>,
35 _type: V,
36}
37
38impl<T: PlatformTypeForTcbInfo, V: VerificationType> TcbEvaluationDataNumbers<T, V> {
39 pub fn numbers(&self) -> Iter<'_, TcbEvalNumber> {
40 self.tcb_eval_numbers.iter()
41 }
42}
43
44impl<T: PlatformTypeForTcbInfo> TcbEvaluationDataNumbers<T> {
45 pub fn issue_date(&self) -> &DateTime<Utc> {
46 &self.issue_date
47 }
48
49 pub fn next_update(&self) -> &DateTime<Utc> {
50 &self.next_update
51 }
52}
53
54impl<T: PlatformTypeForTcbInfo> TcbEvaluationDataNumbers<T, Unverified> {
55 pub fn select_best(input_dir: &str, fmspc: &Fmspc, tcb_components: &TcbComponents<T::PlatformSpecificTcbComponentData>, qesvn: u16) -> Result<TcbEvalNumber, Error> {
59 let evalnums = RawTcbEvaluationDataNumbers::<T>::read_from_file(input_dir)?.evaluation_data_numbers()?;
60 let mut tcb_levels: std::collections::HashMap<_, _> = evalnums.numbers().map(|num| (num.number as u64, (num, None, None))).collect();
61
62 for tcbinfo in TcbInfo::<T>::read_all(input_dir, fmspc) {
63 let tcb_data: TcbData<T, Unverified> = TcbData::parse(tcbinfo?.raw_tcb_info())?;
64 if let Some(level) = tcb_data.tcb_levels()
65 .iter()
66 .find(|level| level.tcb <= *tcb_components)
67 {
68 if let Some(entry) = tcb_levels.get_mut(&tcb_data.tcb_evaluation_data_number()) {
69 entry.1 = Some(level.tcb_status);
70 }
71 }
72 };
73
74 for qeid in QeIdentitySigned::read_all(input_dir) {
75 let qeid: QeIdentity::<Unverified> = serde_json::from_str(&qeid?.raw_qe_identity()).map_err(|e| Error::ParseError(e))?;
76 if let Some(level) = qeid.tcb_levels()
77 .iter()
78 .find(|level| level.tcb.isvsvn <= qesvn)
79 {
80 if let Some(entry) = tcb_levels.get_mut(&qeid.tcb_evaluation_data_number()) {
81 entry.2 = Some(level.tcb_status);
82 }
83 }
84 };
85
86 fn tcb_total_order(platform_status: Option<TcbStatus>, qe_status: Option<TcbStatus>) -> i8 {
88 use std::ops::Neg;
89 use self::TcbStatus::*;
90 match (platform_status.map(TcbStatus::drop_sw_hardening_needed), qe_status) {
94 (Some(UpToDate), Some(UpToDate)) => 0i8,
95 (Some(UpToDate), Some(OutOfDate)) => 1,
96 (Some(UpToDate), Some(Revoked)) => 1,
97 (Some(ConfigurationNeeded), Some(UpToDate)) => 2,
98 (Some(ConfigurationNeeded), Some(OutOfDate)) => 3,
99 (Some(ConfigurationNeeded), Some(Revoked)) => 3,
100 (Some(OutOfDate), Some(UpToDate)) => 4,
101 (Some(OutOfDateConfigurationNeeded), Some(UpToDate)) => 4,
102 (Some(Revoked), Some(UpToDate)) => 4,
103 (Some(OutOfDate), Some(OutOfDate)) => 5,
104 (Some(OutOfDate), Some(Revoked)) => 5,
105 (Some(Revoked), Some(OutOfDate)) => 5,
106 (Some(Revoked), Some(Revoked)) => 5,
107 (Some(OutOfDateConfigurationNeeded), Some(OutOfDate)) => 5,
108 (Some(OutOfDateConfigurationNeeded), Some(Revoked)) => 5,
109 (Some(UpToDate), None) => 6,
110 (Some(ConfigurationNeeded), None) => 7,
111 (Some(OutOfDate), None) => 8,
112 (Some(OutOfDateConfigurationNeeded), None) => 8,
113 (Some(Revoked), None) => 8,
114 (None, Some(UpToDate)) => 9,
115 (None, Some(OutOfDate)) => 10,
116 (None, Some(Revoked)) => 10,
117 _ => 11,
118 }.neg()
119 }
120
121 tcb_levels.into_iter()
122 .max_by(|&(a_num, (_, a_platform_status, a_qe_status)), &(b_num, (_, b_platform_status, b_qe_status))| {
123 tcb_total_order(a_platform_status, a_qe_status)
124 .cmp(&tcb_total_order(b_platform_status, b_qe_status))
125 .then_with(|| a_num.cmp(&b_num) )
126 })
127 .map(|(_, (num, _, _))| num.clone())
128 .ok_or(Error::InvalidTcbEvaluationDataNumbers("Empty TCB evaluation data numbers".into()))
129 }
130}
131
132#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
133#[serde(rename_all = "camelCase")]
134pub struct TcbEvalNumber {
135 #[serde(rename = "tcbEvaluationDataNumber")]
136 number: u16,
137 #[serde(with = "crate::iso8601")]
138 tcb_recovery_event_date: DateTime<Utc>,
139 #[serde(with = "crate::iso8601")]
140 tcb_date: DateTime<Utc>,
141}
142
143impl TcbEvalNumber {
144 pub fn number(&self) -> u16 {
145 self.number
146 }
147
148 pub fn tcb_recovery_event_date(&self) -> &DateTime<Utc> {
149 &self.tcb_recovery_event_date
150 }
151
152 pub fn tcb_date(&self) -> &DateTime<Utc> {
153 &self.tcb_date
154 }
155}
156
157#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
158pub struct RawTcbEvaluationDataNumbers<T> {
159 raw_tcb_evaluation_data_numbers: String,
160 signature: Vec<u8>,
161 ca_chain: Vec<String>,
162 #[serde(skip)]
163 platform_: PhantomData<T>,
164}
165
166impl<T: PlatformTypeForTcbInfo> RawTcbEvaluationDataNumbers<T> {
167 const DEFAULT_FILENAME: &'static str = "tcb_evaluation_data_numbers";
168 const FILENAME_EXTENSION: &'static str = ".numbers";
169
170 pub fn new(raw_tcb_evaluation_data_numbers: String, signature: Vec<u8>, ca_chain: Vec<String>) -> Self {
171 RawTcbEvaluationDataNumbers {
172 raw_tcb_evaluation_data_numbers,
173 signature,
174 ca_chain,
175 platform_: PhantomData,
176 }
177 }
178
179 pub fn filename() -> String {
180 format!("{}{}{}", Self::DEFAULT_FILENAME, T::extra_extension(), Self::FILENAME_EXTENSION)
181 }
182
183 pub fn parse(body: &String, ca_chain: Vec<String>) -> Result<Self, Error> {
184 #[derive(Deserialize)]
185 #[serde(rename_all = "camelCase")]
186 struct IntelTcbEvaluationDataNumbers<'a> {
187 #[serde(borrow, rename = "tcbEvaluationDataNumbers")]
188 raw_tcb_evaluation_data_numbers: &'a RawValue,
189 #[serde(deserialize_with = "crate::intel_signature_deserializer")]
190 signature: Vec<u8>,
191 }
192 let IntelTcbEvaluationDataNumbers { raw_tcb_evaluation_data_numbers, signature } = serde_json::from_str(&body)?;
193
194 Ok(RawTcbEvaluationDataNumbers::new(raw_tcb_evaluation_data_numbers.to_string(), signature, ca_chain))
195 }
196
197 pub fn raw_tcb_evaluation_data_numbers(&self) -> &str {
199 &self.raw_tcb_evaluation_data_numbers
200 }
201
202 pub fn signature(&self) -> &Vec<u8> {
203 &self.signature
204 }
205
206 pub fn certificate_chain(&self) -> &Vec<String> {
207 &self.ca_chain
208 }
209
210 pub fn write_to_file(&self, output_dir: &str, option: WriteOptions) -> Result<Option<PathBuf>, Error> {
211 let filename = Self::filename();
212 io::write_to_file(&self, output_dir, &filename, option)
213 }
214
215 pub fn read_from_file(input_dir: &str) -> Result<Self, Error> {
216 let filename = Self::filename();
217 let numbers: Self = io::read_from_file(input_dir, &filename)?;
218 Ok(numbers)
219 }
220
221 pub fn evaluation_data_numbers(&self) -> Result<TcbEvaluationDataNumbers<T, Unverified>, Error> {
225 serde_json::from_str(&self.raw_tcb_evaluation_data_numbers).map_err(|e| Error::ParseError(e))
226 }
227
228 #[cfg(feature = "verify")]
229 pub fn verify<B: Deref<Target = [u8]>>(&self, trusted_root_certs: &[B]) -> Result<TcbEvaluationDataNumbers<T>, Error> {
230 self.verify_ex(trusted_root_certs, &[], &Utc::now())
231 }
232
233 #[cfg(feature = "verify")]
234 pub fn verify_with_rootcacrl<B: Deref<Target = [u8]>>(&self, trusted_root_certs: &[B], root_ca_crls: &[RootCaCrl]) -> Result<TcbEvaluationDataNumbers<T>, Error> {
235 self.verify_ex(trusted_root_certs, root_ca_crls, &Utc::now())
236 }
237
238 #[cfg(feature = "verify")]
239 fn verify_ex<B: Deref<Target = [u8]>>(&self, trusted_root_certs: &[B], root_ca_crls: &[RootCaCrl], now: &DateTime<Utc>) -> Result<TcbEvaluationDataNumbers<T>, Error> {
240 let (chain, root) = crate::build_and_verify_cert_chain(&self.ca_chain, trusted_root_certs, root_ca_crls)?;
242 let mut leaf = chain.first().unwrap_or(&root).clone();
243
244 let mut hash = [0u8; 32];
246 mbedtls::hash::Md::hash(mbedtls::hash::Type::Sha256, self.raw_tcb_evaluation_data_numbers.as_bytes(), &mut hash).unwrap();
247 leaf.public_key_mut()
248 .verify(mbedtls::hash::Type::Sha256, &hash, self.signature())
249 .map_err(|e| Error::UntrustworthyTcbEvaluationDataNumber(e))?;
250
251 let TcbEvaluationDataNumbers::<T, Unverified> {
252 id,
253 version,
254 issue_date,
255 next_update,
256 tcb_eval_numbers,
257 ..
258 } = serde_json::from_str(&self.raw_tcb_evaluation_data_numbers).map_err(|e| Error::ParseError(e))?;
259
260 if version != 1 {
261 return Err(Error::InvalidTcbEvaluationDataNumbers(format!("TCB Evaluation Data Numbers version 1 expected, got {version}")));
262 }
263
264 if *now < issue_date {
265 return Err(Error::InvalidTcbEvaluationDataNumbers(format!("TCB Evaluation Data Numbers only valid from {issue_date}")));
266 }
267 if next_update < *now {
268 return Err(Error::InvalidTcbEvaluationDataNumbers(format!("TCB Evaluation Data Numbers only valid upto {next_update}")));
269 }
270
271 Ok(TcbEvaluationDataNumbers::<T, Verified> {
272 id,
273 version,
274 issue_date,
275 next_update,
276 tcb_eval_numbers,
277 _type: Verified,
278 })
279 }
280}
281
282#[derive(Debug, Clone, PartialEq, Eq)]
283pub struct TcbPolicy {
284 grace_period: Duration,
285}
286
287impl TcbPolicy {
288 pub const fn new(grace_period: Duration) -> Self {
291 Self {
292 grace_period
293 }
294 }
295
296 fn needs_to_be_enforced(&self, tcb_eval: &TcbEvalNumber, now: &DateTime<Utc>) -> bool {
297 *tcb_eval.tcb_recovery_event_date() + self.grace_period <= *now
298 }
299
300 fn minimum_tcb_evaluation_data_number_ex<T: PlatformTypeForTcbInfo, V: VerificationType>(&self, tcb_eval: &TcbEvaluationDataNumbers<T, V>, now: &DateTime<Utc>) -> Option<TcbEvalNumber> {
301 tcb_eval.numbers()
303 .filter(|number| self.needs_to_be_enforced(number, now))
304 .max_by_key(|number| number.number)
305 .cloned()
306 }
307
308 pub fn minimum_tcb_evaluation_data_number<T: PlatformTypeForTcbInfo, V: VerificationType>(&self, tcb_eval: &TcbEvaluationDataNumbers<T, V>) -> Option<TcbEvalNumber> {
309 self.minimum_tcb_evaluation_data_number_ex(tcb_eval, &Utc::now())
310 }
311}
312
313#[cfg(test)]
314mod tests {
315 #[cfg(not(target_env = "sgx"))]
316 use {
317 super::TcbEvaluationDataNumbers,
318 crate::{Error, Unverified, platform}
319 };
320 #[cfg(all(not(target_env = "sgx"), feature = "verify"))]
321 use super::{RawTcbEvaluationDataNumbers, TcbPolicy, TcbEvalNumber, RootCaCrl};
322 #[cfg(all(not(target_env = "sgx"), feature = "verify"))]
323 use chrono::{Duration, TimeZone, Utc};
324
325 #[cfg(all(not(target_env = "sgx"), feature = "verify"))]
326 #[test]
327 fn parse_sgx_tcb_evaluation_data_numbers() {
328 let numbers = RawTcbEvaluationDataNumbers::<platform::SGX>::read_from_file("./tests/data").unwrap();
329 let root_certificate = include_bytes!("../tests/data/root_SGX_CA_der.cert");
330 let root_certificates = [&root_certificate[..]];
331
332 let root_ca_crl_der = include_bytes!("../tests/data/IntelSGXRootCA.der");
333 let root_ca_crls = [RootCaCrl::new(root_ca_crl_der).unwrap().verify(&root_certificates).unwrap()];
334
335 numbers.verify_ex(&root_certificates, &root_ca_crls, &Utc.with_ymd_and_hms(2025, 6, 4, 12, 0, 0).unwrap()).unwrap();
336 }
337
338 #[cfg(all(not(target_env = "sgx"), feature = "verify"))]
339 #[test]
340 fn parse_tcb_evaluation_data_numbers_incorrect_signature() {
341 let numbers = RawTcbEvaluationDataNumbers::<platform::SGX>::read_from_file("./tests/data").unwrap();
342 let root_certificate = include_bytes!("../tests/data/root_SGX_CA_der.cert").to_owned();
343 let root_certificates = [&root_certificate[..]];
344
345 let root_ca_crl_der = include_bytes!("../tests/data/IntelSGXRootCA.der");
346 let root_ca_crls = [RootCaCrl::new(root_ca_crl_der).unwrap().verify(&root_certificates).unwrap()];
347
348 numbers.verify_ex(&root_certificates, &root_ca_crls, &Utc.with_ymd_and_hms(2025, 6, 4, 12, 0, 0).unwrap()).unwrap();
349
350 let mut corrupted = numbers.clone();
351 corrupted.signature[10] = 0x66;
352 if let Err(Error::UntrustworthyTcbEvaluationDataNumber(_s)) = corrupted.verify(&root_certificates) {
353 ();
354 } else {
355 assert!(false);
356 }
357 }
358
359 #[cfg(all(not(target_env = "sgx"), feature = "verify"))]
360 #[test]
361 fn tcb_eval_number() {
362 let april_8_2025 = Utc.with_ymd_and_hms(2025, 4, 8, 14, 55, 0).unwrap();
363 let april_9_2025 = Utc.with_ymd_and_hms(2025, 4, 9, 14, 55, 0).unwrap();
364 let april_15_2025 = Utc.with_ymd_and_hms(2025, 4, 15, 14, 55, 0).unwrap();
365 let april_16_2025 = Utc.with_ymd_and_hms(2025, 4, 16, 14, 55, 0).unwrap();
366 let april_17_2025 = Utc.with_ymd_and_hms(2025, 4, 17, 14, 55, 0).unwrap();
367 let number = TcbEvalNumber {
368 number: 42,
369 tcb_recovery_event_date: april_9_2025,
370 tcb_date: april_9_2025,
371 };
372
373 let policy = TcbPolicy::new(Duration::days(8));
374 assert!(!policy.needs_to_be_enforced(&number, &april_8_2025));
375 assert!(!policy.needs_to_be_enforced(&number, &april_9_2025));
376 assert!(!policy.needs_to_be_enforced(&number, &april_15_2025));
377 assert!(!policy.needs_to_be_enforced(&number, &april_16_2025));
378 assert!(policy.needs_to_be_enforced(&number, &april_17_2025));
379 }
380
381 #[cfg(all(not(target_env = "sgx"), feature = "verify"))]
382 #[test]
383 fn minimum_tcb_evaluation_data_number() {
384 let numbers = RawTcbEvaluationDataNumbers::<platform::SGX>::read_from_file("./tests/data").unwrap();
385 let numbers: TcbEvaluationDataNumbers<platform::SGX, Unverified> = serde_json::from_str(numbers.raw_tcb_evaluation_data_numbers()).unwrap();
386
387 let april_8_2025 = Utc.with_ymd_and_hms(2025, 4, 8, 0, 0, 0).unwrap();
388 let march_12_2024 = Utc.with_ymd_and_hms(2024, 3, 12, 0, 0, 0).unwrap();
389 let march_13_2024 = Utc.with_ymd_and_hms(2024, 3, 13, 0, 0, 0).unwrap();
390 let november_12_2024 = Utc.with_ymd_and_hms(2024, 11, 12, 0, 0, 0).unwrap();
391 let november_13_2024 = Utc.with_ymd_and_hms(2024, 11, 13, 0, 0, 0).unwrap();
392 let november_20_2024 = Utc.with_ymd_and_hms(2024, 11, 20, 0, 0, 0).unwrap();
393 let number_17 = TcbEvalNumber {
394 number: 17,
395 tcb_recovery_event_date: march_12_2024,
396 tcb_date: march_13_2024,
397 };
398 let number_18 = TcbEvalNumber {
399 number: 18,
400 tcb_recovery_event_date: november_12_2024,
401 tcb_date: november_13_2024,
402 };
403 let policy = TcbPolicy::new(Duration::days(10));
404 assert_eq!(policy.minimum_tcb_evaluation_data_number_ex(&numbers, &april_8_2025),
405 Some(number_18));
406 assert_eq!(policy.minimum_tcb_evaluation_data_number_ex(&numbers, &november_13_2024),
407 Some(number_17.clone()));
408 assert_eq!(policy.minimum_tcb_evaluation_data_number_ex(&numbers, &november_20_2024),
409 Some(number_17));
410 }
411
412 #[cfg(not(target_env = "sgx"))]
413 #[test]
414 fn select_best() {
415 use crate::pckcrt::{TcbComponents, SGXSpecificTcbComponentData};
416 fn select(tcb_components: &TcbComponents<SGXSpecificTcbComponentData>, qesvn: u16) -> Result<u16, Error> {
417 use std::convert::TryInto;
418 TcbEvaluationDataNumbers::<platform::SGX, Unverified>::select_best("./tests/data/eval-num-select-best", &"00606a000000".try_into().unwrap(), tcb_components, qesvn)
419 .map(|num| num.number)
420 }
421 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([0; 16], 0), 0).unwrap(), 19);
423 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([0; 16], 0), 8).unwrap(), 19);
425 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([0; 16], 0), 6).unwrap(), 8);
426 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([16, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 0).unwrap(), 19);
428 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([15, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 0).unwrap(), 18);
429 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([14, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 0).unwrap(), 17);
430 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([7, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 0).unwrap(), 14);
431 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([16, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 8).unwrap(), 19);
433 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([15, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 8).unwrap(), 18);
435 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([14, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 8).unwrap(), 17);
436 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([7, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 8).unwrap(), 8);
437 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([16, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 6).unwrap(), 8);
439 assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([4, 16, 3, 3, 255, 255, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 13), 5).unwrap(), 8);
441 }
442}