1use abi::*;
8use thiserror::Error as ThisError;
9
10use std::io::{self, Error as IoError, ErrorKind as IoErrorKind, Read, Result as IoResult, Write};
11use std::result::Result as StdResult;
12
13#[derive(ThisError, Debug)]
14pub enum Error {
15 #[error("The stream is not canonical.")]
16 StreamNotCanonical,
17 #[error("An invalid measurement tag {:016x} was encountered.", _0)]
18 InvalidMeasTag(u64),
19 #[error("The given offset is not a multiple of the page size.")]
20 InvalidPageOffset,
21 #[error("An unsized stream was encountered but a sized stream was expected.")]
22 StreamUnsized,
23}
24
25pub type Result<T> = StdResult<T, anyhow::Error>;
26
27pub enum Meas {
29 ECreate(MeasECreate),
30 EAdd(MeasEAdd),
31 EExtend {
32 header: MeasEExtend,
33 data: [u8; 256],
34 },
35 BareEExtend(MeasEExtend),
36 Unsized(MeasECreate),
41 Unmeasured {
43 header: MeasEExtend,
44 data: [u8; 256],
45 },
46 BareUnmeasured(MeasEExtend),
47}
48
49pub const MEAS_UNSIZED: u64 = 0x0044455a49534e55;
50pub const MEAS_UNMEASRD: u64 = 0x44525341454d4e55;
51
52impl ::std::fmt::Debug for Meas {
53 fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
54 match (&*self,) {
55 (&Meas::ECreate(ref __self_0),) => {
56 let mut builder = __arg_0.debug_tuple("ECreate");
57 builder.field(&&(*__self_0));
58 builder.finish()
59 }
60 (&Meas::EAdd(ref __self_0),) => {
61 let mut builder = __arg_0.debug_tuple("EAdd");
62 builder.field(&&(*__self_0));
63 builder.finish()
64 }
65 (&Meas::EExtend {
66 header: ref __self_0,
67 data: ref __self_1,
68 },) => {
69 let mut builder = __arg_0.debug_struct("EExtend");
70 builder.field("header", &&(*__self_0));
71 builder.field("data", &"<blob>");
72 builder.finish()
73 }
74 (&Meas::BareEExtend(ref __self_0),) => {
75 let mut builder = __arg_0.debug_tuple("EExtend");
76 builder.field(&&(*__self_0));
77 builder.finish()
78 }
79 (&Meas::Unsized(ref __self_0),) => {
80 let mut builder = __arg_0.debug_tuple("Unsized");
81 builder.field(&&(*__self_0));
82 builder.finish()
83 }
84 (&Meas::Unmeasured {
85 header: ref __self_0,
86 data: ref __self_1,
87 },) => {
88 let mut builder = __arg_0.debug_struct("Unmeasured");
89 builder.field("header", &&(*__self_0));
90 builder.field("data", &"<blob>");
91 builder.finish()
92 }
93 (&Meas::BareUnmeasured(ref __self_0),) => {
94 let mut builder = __arg_0.debug_tuple("Unmeasured");
95 builder.field(&&(*__self_0));
96 builder.finish()
97 }
98 }
99 }
100}
101
102fn read_fill<R: Read>(reader: &mut R, mut buf: &mut [u8]) -> IoResult<bool> {
103 let mut read_any = false;
104 while !buf.is_empty() {
105 match reader.read(buf) {
106 Ok(0) => break,
107 Ok(n) => {
108 read_any = true;
109 let tmp = buf;
110 buf = &mut tmp[n..];
111 }
112 Err(ref e) if e.kind() == IoErrorKind::Interrupted => {}
113 Err(e) => return Err(e),
114 }
115 }
116 if read_any {
117 if !buf.is_empty() {
118 Err(IoError::new(
119 IoErrorKind::UnexpectedEof,
120 "failed to fill whole buffer",
121 ))
122 } else {
123 Ok(true)
124 }
125 } else {
126 Ok(false)
127 }
128}
129
130pub trait SgxsRead {
131 fn read_meas(&mut self) -> Result<Option<Meas>>;
132}
133
134impl<R: Read> SgxsRead for R {
135 fn read_meas(&mut self) -> Result<Option<Meas>> {
136 use byteorder::{LittleEndian, ReadBytesExt};
137
138 let mut header = [0u8; 64];
139 if !(read_fill(self, &mut header)?) {
140 return Ok(None);
141 }
142 let mut headerp = &header[..];
143
144 match headerp.read_u64::<LittleEndian>().unwrap() {
145 MEAS_ECREATE => Ok(Some(Meas::ECreate(
146 unsafe { &*(headerp as *const _ as *const MeasECreate) }.clone(),
147 ))),
148 MEAS_UNSIZED => Ok(Some(Meas::Unsized(
149 unsafe { &*(headerp as *const _ as *const MeasECreate) }.clone(),
150 ))),
151 MEAS_EADD => Ok(Some(Meas::EAdd(
152 unsafe { &*(headerp as *const _ as *const MeasEAdd) }.clone(),
153 ))),
154 m @ MEAS_EEXTEND | m @ MEAS_UNMEASRD => {
155 let header = unsafe { &*(headerp as *const _ as *const MeasEExtend) }.clone();
156
157 let mut data = [0u8; 256];
158 if !(read_fill(self, &mut data)?) {
159 return Err(IoError::new(
160 IoErrorKind::UnexpectedEof,
161 "failed to fill whole buffer",
162 )
163 .into());
164 }
165
166 if m == MEAS_EEXTEND {
167 Ok(Some(Meas::EExtend {
168 header: header,
169 data: data,
170 }))
171 } else {
172 Ok(Some(Meas::Unmeasured {
173 header: header,
174 data: data,
175 }))
176 }
177 }
178 v => Err(Error::InvalidMeasTag(v).into()),
179 }
180 }
181}
182
183impl SgxsRead for &mut dyn SgxsRead {
184 fn read_meas(&mut self) -> Result<Option<Meas>> {
185 (*self).read_meas()
186 }
187}
188
189#[derive(Copy, Clone, PartialEq, Eq, Debug)]
191pub struct PageChunks(pub u16);
192
193impl ::std::fmt::Display for PageChunks {
194 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
195 f.pad(match self.0 {
196 0xffff => "all",
197 0 => "none",
198 _ => "partial",
199 })
200 }
201}
202
203pub struct CanonicalSgxsReader<'a, R: SgxsRead + 'a> {
213 reader: &'a mut R,
214 got_ecreate: bool,
215 last_offset: Option<u64>,
216 chunks_measured: PageChunks,
217 chunks_seen: PageChunks,
218}
219
220impl<'a, R: SgxsRead + 'a> CanonicalSgxsReader<'a, R> {
221 pub fn new(reader: &'a mut R) -> Self {
222 CanonicalSgxsReader {
223 reader: reader,
224 got_ecreate: false,
225 last_offset: None,
226 chunks_measured: PageChunks(0),
227 chunks_seen: PageChunks(0),
228 }
229 }
230
231 fn check_chunk_offset(&mut self, offset: u64, measured: bool) -> bool {
232 if (offset & 0xff) != 0 {
233 return false;
234 }
235 if let Some(last_offset) = self.last_offset {
236 if offset < last_offset {
237 return false;
238 }
239 let chunk = (offset - last_offset) >> 8;
240 if chunk >= 16 {
241 return false;
242 }
243 let chunk_bit = 1 << chunk;
244 if self.chunks_seen.0 & chunk_bit == 1 {
245 return false;
246 }
247 self.chunks_seen.0 |= chunk_bit;
248 if measured {
249 self.chunks_measured.0 |= chunk_bit;
250 }
251 return true;
252 }
253 return false;
254 }
255}
256
257impl<'a, R: SgxsRead + 'a> SgxsRead for CanonicalSgxsReader<'a, R> {
258 fn read_meas(&mut self) -> Result<Option<Meas>> {
259 let meas = self.reader.read_meas()?;
260
261 match meas {
262 Some(Meas::ECreate(_)) | Some(Meas::Unsized(_)) => {
263 if self.got_ecreate {
264 return Err(Error::StreamNotCanonical.into());
265 }
266 self.got_ecreate = true
267 }
268 Some(Meas::EAdd(ref header)) => {
269 if !self.got_ecreate
270 || (header.offset & 0xfff) != 0
271 || self.last_offset.map_or(false, |lo| header.offset <= lo)
272 || (header.secinfo.flags.page_type() == PageType::Tcs as u8
273 && header.secinfo.flags.intersects(SecinfoFlags::R|SecinfoFlags::W|SecinfoFlags::X))
274 {
275 return Err(Error::StreamNotCanonical.into());
276 }
277 self.last_offset = Some(header.offset);
278 self.chunks_measured.0 = 0;
279 self.chunks_seen.0 = 0;
280 }
281 Some(Meas::EExtend { ref header, .. }) => {
282 if !self.got_ecreate || !self.check_chunk_offset(header.offset, true) {
283 return Err(Error::StreamNotCanonical.into());
284 }
285 }
286 Some(Meas::Unmeasured { ref header, .. }) => {
287 if !self.got_ecreate || !self.check_chunk_offset(header.offset, false) {
288 return Err(Error::StreamNotCanonical.into());
289 }
290 }
291 Some(Meas::BareEExtend(_)) | Some(Meas::BareUnmeasured(_)) => unreachable!(),
292 None => {}
293 }
294
295 Ok(meas)
296 }
297}
298
299pub struct PageReader<'a, R: SgxsRead + 'a> {
300 reader: CanonicalSgxsReader<'a, R>,
301 last_eadd: Option<MeasEAdd>,
302}
303
304pub struct CreateInfo {
305 pub ecreate: MeasECreate,
306 pub sized: bool,
307}
308
309impl<'a, R: SgxsRead + 'a> PageReader<'a, R> {
310 pub fn new(reader: &'a mut R) -> Result<(CreateInfo, Self)> {
311 let mut cread = CanonicalSgxsReader::new(reader);
312 let cinfo = match cread.read_meas()? {
313 Some(Meas::ECreate(ecreate)) => CreateInfo {
314 ecreate,
315 sized: true,
316 },
317 Some(Meas::Unsized(ecreate)) => CreateInfo {
318 ecreate,
319 sized: false,
320 },
321 _ => return Err(Error::StreamNotCanonical.into()),
322 };
323 Ok((
324 cinfo,
325 PageReader {
326 reader: cread,
327 last_eadd: None,
328 },
329 ))
330 }
331
332 pub fn read_page(&mut self) -> Result<Option<(MeasEAdd, PageChunks, [u8; 4096])>> {
333 use std::mem::replace;
334
335 let mut page = [0u8; 4096];
336 loop {
337 let chunks_measured = self.reader.chunks_measured;
338 let meas = self.reader.read_meas()?;
339 match meas {
340 meas @ Some(Meas::EAdd(_)) | meas @ None => {
341 let meas = match meas {
342 Some(Meas::EAdd(header)) => Some(header),
343 None => None,
344 _ => unreachable!(),
345 };
346 if let Some(eadd) = replace(&mut self.last_eadd, meas) {
347 return Ok(Some((eadd, chunks_measured, page)));
348 } else if self.last_eadd.is_none() {
349 return Ok(None);
350 }
351 }
352 Some(Meas::EExtend { header, data }) | Some(Meas::Unmeasured { header, data }) => {
353 let offset = (header.offset & 0xfff) as usize;
354 (&mut page[offset..offset + 256]).write(&data).unwrap();
355 }
356 _ => return Err(Error::StreamNotCanonical.into()),
357 }
358 }
359 }
360}
361
362#[derive(Debug, Clone, Copy, PartialEq, Eq)]
363pub enum PageChunk {
364 Skipped,
365 Included,
366 IncludedMeasured,
367}
368
369pub struct MeasuredData<'a, R: Read + 'a> {
370 chunks: [PageChunk; 16],
371 reader: Option<&'a mut R>,
372}
373
374impl<'a, R: Read + 'a> From<Option<&'a mut R>> for MeasuredData<'a, R> {
375 fn from(reader: Option<&'a mut R>) -> Self {
376 use self::PageChunk::*;
377 MeasuredData {
378 chunks: [if reader.is_some() {
379 IncludedMeasured
380 } else {
381 Skipped
382 }; 16],
383 reader,
384 }
385 }
386}
387
388impl<'a, R: Read + 'a> From<(&'a mut R, [PageChunk; 16])> for MeasuredData<'a, R> {
389 fn from((reader, chunks): (&'a mut R, [PageChunk; 16])) -> Self {
390 MeasuredData {
391 chunks,
392 reader: Some(reader),
393 }
394 }
395}
396
397pub trait SgxsWrite {
398 fn write_meas(&mut self, meas: &Meas) -> Result<()>;
399 fn write_page<'a, R: Read + 'a, D: Into<MeasuredData<'a, R>>>(
400 &mut self,
401 data: D,
402 offset: u64,
403 secinfo: SecinfoTruncated,
404 ) -> Result<()>;
405 fn write_pages<R: Read>(
406 &mut self,
407 data: Option<&mut R>,
408 n: usize,
409 offset: u64,
410 secinfo: SecinfoTruncated,
411 ) -> Result<()>;
412}
413
414impl<W: Write> SgxsWrite for W {
415 fn write_meas(&mut self, meas: &Meas) -> Result<()> {
416 use self::Meas::*;
417 use std::ptr;
418
419 let mut buf = [0u8; 64];
420 unsafe {
421 let (tag, headerdst) = buf.split_at_mut(8);
422 let tag = &mut *(&mut tag[0..8] as *mut _ as *mut u64);
423 let headerdst = &mut headerdst[0..56] as *mut _;
424
425 match meas {
426 &ECreate(ref header) => {
427 *tag = MEAS_ECREATE;
428 ptr::write(headerdst as *mut _, header.clone())
429 }
430 &Unsized(ref header) => {
431 *tag = MEAS_UNSIZED;
432 ptr::write(headerdst as *mut _, header.clone())
433 }
434 &EAdd(ref header) => {
435 *tag = MEAS_EADD;
436 ptr::write(headerdst as *mut _, header.clone())
437 }
438 &EExtend { ref header, .. } | &BareEExtend(ref header) => {
439 *tag = MEAS_EEXTEND;
440 ptr::write(headerdst as *mut _, header.clone())
441 }
442 &Unmeasured { ref header, .. } | &BareUnmeasured(ref header) => {
443 *tag = MEAS_UNMEASRD;
444 ptr::write(headerdst as *mut _, header.clone())
445 }
446 };
447 }
448 self.write_all(&buf)?;
449
450 match meas {
451 &EExtend { ref data, .. } | &Unmeasured { ref data, .. } => self.write_all(data)?,
452 _ => {}
453 }
454
455 Ok(())
456 }
457
458 fn write_page<'a, R: Read + 'a, D: Into<MeasuredData<'a, R>>>(
459 &mut self,
460 data: D,
461 offset: u64,
462 secinfo: SecinfoTruncated,
463 ) -> Result<()> {
464 self.write_meas(&Meas::EAdd(MeasEAdd {
465 offset: offset,
466 secinfo: secinfo
467 }))?;
468
469 let MeasuredData { chunks, reader } = data.into();
470 let mut reader = reader.map(|r| r.chain(io::repeat(0)));
471 for (i, chunk) in chunks.iter().enumerate() {
472 let eext = MeasEExtend {
473 offset: offset + (i as u64 * 256),
474 };
475 match *chunk {
476 PageChunk::Skipped => continue,
477 PageChunk::Included => self.write_meas(&Meas::BareUnmeasured(eext))?,
478 PageChunk::IncludedMeasured => self.write_meas(&Meas::BareEExtend(eext))?,
479 }
480 io::copy(&mut reader.as_mut().unwrap().take(256), self)?;
481 }
482
483 Ok(())
484 }
485
486 fn write_pages<R: Read>(
487 &mut self,
488 mut data: Option<&mut R>,
489 n: usize,
490 offset: u64,
491 secinfo: SecinfoTruncated,
492 ) -> Result<()> {
493 for i in 0..(n as u64) {
494 self.write_page(data.as_mut(), offset + 4096 * i, secinfo.clone())?;
495 }
496 Ok(())
497 }
498}
499
500pub struct CanonicalSgxsWriter<'a, W: SgxsWrite + 'a> {
501 writer: &'a mut W,
502 next_offset: u64,
503}
504
505impl<'a, W: SgxsWrite + 'a> CanonicalSgxsWriter<'a, W> {
506 pub fn new(writer: &'a mut W, ecreate: MeasECreate, sized: bool) -> Result<Self> {
507 if sized {
508 writer.write_meas(&Meas::ECreate(ecreate))?;
509 } else {
510 writer.write_meas(&Meas::Unsized(ecreate))?;
511 }
512 Ok(CanonicalSgxsWriter {
513 writer: writer,
514 next_offset: 0,
515 })
516 }
517
518 fn check_offset(&mut self, offset: Option<u64>) -> Result<()> {
519 match offset {
520 Some(offset) if offset & 0xfff != 0 => return Err(Error::InvalidPageOffset.into()),
521 Some(offset) if offset < self.next_offset => {
522 return Err(Error::StreamNotCanonical.into())
523 }
524 Some(offset) => self.next_offset = offset,
525 None => {}
526 }
527 Ok(())
528 }
529
530 pub fn write_page<'b, R: Read + 'b, D: Into<MeasuredData<'b, R>>>(
532 &mut self,
533 data: D,
534 offset: Option<u64>,
535 secinfo: SecinfoTruncated,
536 ) -> Result<()> {
537 self.check_offset(offset)?;
538 self.writer.write_page(data, self.next_offset, secinfo)?;
539 self.skip_page();
540 Ok(())
541 }
542
543 pub fn write_pages<R: Read>(
545 &mut self,
546 data: Option<&mut R>,
547 n: usize,
548 offset: Option<u64>,
549 secinfo: SecinfoTruncated,
550 ) -> Result<()> {
551 self.check_offset(offset)?;
552 self.writer.write_pages(data, n, self.next_offset, secinfo)?;
553 self.skip_pages(n);
554 Ok(())
555 }
556
557 pub fn skip_page(&mut self) {
558 self.skip_pages(1);
559 }
560
561 pub fn skip_pages(&mut self, n: usize) {
562 self.next_offset += (n as u64) * 4096;
563 }
564
565 pub fn offset(&self) -> u64 {
566 self.next_offset
567 }
568}
569
570#[repr(C)]
573#[derive(Clone, Copy, Debug, Default)]
574pub struct SecinfoTruncated {
575 pub flags: SecinfoFlags,
576}
577
578#[repr(C, packed)]
579#[derive(Clone, Copy, Debug, Default)]
580pub struct MeasECreate {
581 pub ssaframesize: u32,
582 pub size: u64,
583}
584
585#[repr(C)]
586#[derive(Clone, Copy, Debug, Default)]
587pub struct MeasEAdd {
588 pub offset: u64,
589 pub secinfo: SecinfoTruncated,
590}
591
592#[repr(C)]
593#[derive(Clone, Copy, Debug, Default)]
594pub struct MeasEExtend {
595 pub offset: u64,
596}
597
598pub fn copy_measured<R: SgxsRead, W: SgxsWrite>(reader: &mut R, writer: &mut W) -> Result<()> {
620 while let Some(meas) = reader.read_meas()? {
621 match meas {
622 Meas::Unsized(_) => return Err(Error::StreamUnsized.into()),
623 Meas::Unmeasured { .. } => (),
624 meas => writer.write_meas(&meas)?,
625 }
626 }
627
628 Ok(())
629}