Skip to main content

pcs/
tcb_evaluation_data_numbers.rs

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/// Implementation of the TcbEvaluationDataNumbers model
18/// <https://api.portal.trustedservices.intel.com/content/documentation.html#pcs-tcb-eval-data-numbers-model-v1>
19#[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    /// Given a particular TCB level, select the best available TCB eval number.
56    /// That is the one that gives the most favorable TCB status, and the higher
57    /// one if there's a tie.
58    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        // NB: QE Identity TCB status can only be UpToDate, OutOfDate, or Revoked
87        fn tcb_total_order(platform_status: Option<TcbStatus>, qe_status: Option<TcbStatus>) -> i8 {
88            use std::ops::Neg;
89            use self::TcbStatus::*;
90            // Since we don't have any information here to judge the enclave
91            // has the needed SW hardening, we assume that it does and we
92            // upgrade SWHardeningNeeded to the next level
93            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    /// Returns the raw TCB evaluation data numbers as signed by Intel
198    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    /// Returns the TCB evaluation data numbers present. Warning: These values should not
222    /// be trusted as there is no guarantee the RawTcbEvaluationDataNumbers is valid. If this
223    /// result must be trustworthy, you need to call `verify`
224    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        // Check cert chain
241        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        // Check signature on data
245        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    /// A TCB policy that allows for TCB info to be used until `grace_period` after
289    /// a TCB recovery event
290    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        // We need the highest TCB Eval Data Number that needs to be enforced
302        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        // platform and QE are nonsensical: just choose highest
422        assert_eq!(select(&TcbComponents::<SGXSpecificTcbComponentData>::from_raw([0; 16], 0), 0).unwrap(), 19);
423        // platform is nonsensical: choose eval nums based on QE up-to-date
424        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        // QE is nonsensical: choose eval nums based on platform up-to-date
427        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        // platform and QE are fully up to date: choose highest
432        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        // QE is up to date: choose up-to-date eval nums based on platform
434        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        // platform is up to date: choose up-to-date eval nums based on QE
438        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        // neither platform and QE are up to date: choose highest eval nums where they were both up to date
440        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}