Skip to main content

sgxs/
sgxs.rs

1/* Copyright (c) Fortanix, Inc.
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7use 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
27// Doesn't work because large array: #[derive(Clone,Debug,Default)]
28pub enum Meas {
29    ECreate(MeasECreate),
30    EAdd(MeasEAdd),
31    EExtend {
32        header: MeasEExtend,
33        data: [u8; 256],
34    },
35    BareEExtend(MeasEExtend),
36    /// The start of an SGXS file with an unknown enclave size which can be
37    /// filled in later. The `size` member is an offset of where to write the
38    /// enclave size as a 64-bit unsigned little endian integer, in addition to
39    /// the `size` member itself of course.
40    Unsized(MeasECreate),
41    /// A 256-byte chunk of memory that should be loaded but not measured.
42    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// TODO: update to [PageChunk; 16]
190#[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
203/// The `CanonicalSgxsReader` struct adds canonicalness checking to any `SgxsRead` reader.
204///
205/// An SGXS stream is canonical if
206/// - the first measurement blob is an ECREATE blob, and no other blobs are an ECREATE blob
207/// - the offset of every EADD blob does not have the lower 12 bits set
208/// - the offset of every EADD blob is higher than that of any previous EADD blob
209/// - the offset of every EEXTEND blob does not have the lower 12 bits set
210/// - the upper 52 bits of offsets of all EEXTEND blobs are equal to those of the preceding EADD blob
211/// - the lower 12 bits of offsets of all consecutive EEXTEND blobs are unique
212pub 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    /// If offset is None, just append at the current offset.
531    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    /// If offset is None, just append at the current offset.
544    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/// Note: only the first 48 bytes of the `Secinfo` structure are included in a
571/// `Meas` blob.
572#[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
598/// Copy only the measured bits of an SGXS stream.
599///
600/// # Example
601/// Compute ENCLAVEHASH from an SGXS:
602///
603/// ```
604/// extern crate crypto_hash;
605/// extern crate sgxs;
606/// use crypto_hash::{Hasher, Algorithm};
607/// use sgxs::sgxs::{SgxsRead, Result, copy_measured};
608///
609/// fn enclavehash<R: SgxsRead>(stream: &mut R) -> Result<[u8; 32]> {
610///     let mut hasher = Hasher::new(Algorithm::SHA256);
611///     copy_measured(stream, &mut hasher)?;
612///     let mut hash = [0u8; 32];
613///     hash.copy_from_slice(&hasher.finish());
614///     Ok(hash)
615/// }
616///
617/// # fn main() { /* compile test */ }
618/// ```
619pub 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}