Merge pull request #1642 from scrtlabs/dcap-05

Dcap 05

Author: valdok

cosmwasm/enclaves/shared/utils/src/storage.rs

@@ -2,9 +2,11 @@ use crate::results::UnwrapOrSgxErrorUnexpected;
 
 use core::mem;
 use core::ptr::null;
+use log::*;
 use log::{error, info};
 use std::io::{Read, Write};
 use std::path::Path;
+use std::ptr;
 use std::sgxfs::SgxFile;
 use std::slice;
 
@@ -71,6 +73,41 @@ pub struct FileMdPlain {
 
 const FILE_MD_ENCRYPTED_DATA_SIZE: usize = 3072;
 const FILE_MD_ENCRYPTED_FILENAME_SIZE: usize = 260;
+const FILE_MD_ENCRYPTED_DATA_NODES: usize = 96;
+
+#[repr(packed)]
+pub struct FileDataKeyAndMac {
+    pub key: [u8; 16],
+    pub gmac: [u8; 16],
+}
+
+impl FileDataKeyAndMac {
+    unsafe fn decrypt_once(
+        &self,
+        p_src: *const uint8_t,
+        src_len: uint32_t,
+        p_dst: *mut uint8_t,
+        p_iv: &[u8; 12],
+    ) -> Result<(), sgx_status_t> {
+        let res = sgx_rijndael128GCM_decrypt(
+            &self.key,
+            p_src,
+            src_len,
+            p_dst,
+            p_iv.as_ptr(),
+            12,
+            null(),
+            0,
+            &self.gmac,
+        );
+
+        if sgx_status_t::SGX_SUCCESS != res {
+            return Err(res);
+        }
+
+        Ok(())
+    }
+}
 
 #[repr(packed)]
 pub struct FileMdEncrypted {
@@ -81,8 +118,7 @@ pub struct FileMdEncrypted {
     pub mc_uuid: [u8; 16],
     pub mc_value: u32,
 
-    pub mht_key: [u8; 16],
-    pub mht_gmac: [u8; 16],
+    pub root_mht: FileDataKeyAndMac,
 
     pub data: [u8; FILE_MD_ENCRYPTED_DATA_SIZE],
 }
@@ -94,29 +130,43 @@ pub struct FileMd {
     pub padding: [u8; 610],
 }
 
+#[repr(packed)]
+pub struct FileMhtNode {
+    pub data: [FileDataKeyAndMac; FILE_MD_ENCRYPTED_DATA_NODES],
+    pub lower_nodes: [FileDataKeyAndMac; 32],
+}
+
 pub fn unseal_file_from_2_17(
     s_path: &str,
     should_check_fname: bool,
 ) -> Result<Vec<u8>, sgx_status_t> {
     let mut file = match File::open(s_path) {
         Ok(f) => f,
-        Err(_) => {
-            return Err(/*e*/ sgx_status_t::SGX_ERROR_UNEXPECTED);
+        Err(e) => {
+            warn!("Failed to open file: {}", e);
+            return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
         }
     };
 
     let mut bytes = Vec::new();
-    if file.read_to_end(&mut bytes).is_err() {
-        return Err(/*e*/ sgx_status_t::SGX_ERROR_UNEXPECTED);
+    if let Err(e) = file.read_to_end(&mut bytes) {
+        warn!("Failed to read file: {}", e);
+        return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
     }
 
     if bytes.len() < mem::size_of::<FileMd>() {
+        warn!("file too small");
         return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
     }
 
     unsafe {
         let p_md = bytes.as_mut_ptr() as *const FileMd;
 
+        if (*p_md).plain.update_flag > 0 {
+            warn!("file left in recovery mode, unsupported");
+            return Err(sgx_status_t::SGX_ERROR_UNEXPECTED); // we don't support recovery
+        }
+
         let mut key_request = sgx_key_request_t {
             key_name: sgx_types::SGX_KEYSELECT_SEAL,
             key_policy: sgx_types::SGX_KEYPOLICY_MRSIGNER,
@@ -131,49 +181,39 @@ pub fn unseal_file_from_2_17(
         key_request.cpu_svn.svn = (*p_md).plain.cpu_svn;
         key_request.key_id.id = (*p_md).plain.key_id;
 
-        let mut cur_key: sgx_key_128bit_t = sgx_key_128bit_t::default();
+        let mut cur_key_mac = FileDataKeyAndMac {
+            key: sgx_key_128bit_t::default(),
+            gmac: (*p_md).plain.meta_data_gmac,
+        };
 
-        let mut st = sgx_get_key(&key_request, &mut cur_key);
-        if sgx_status_t::SGX_SUCCESS != st {
-            return Err(st);
+        match sgx_get_key(&key_request, &mut cur_key_mac.key) {
+            sgx_status_t::SGX_SUCCESS => {}
+            err_code => {
+                warn!("gen key failed");
+                return Err(err_code);
+            }
         }
 
         let /* mut */ md_decr: FileMdEncrypted = FileMdEncrypted {
             clean_filename: [0; FILE_MD_ENCRYPTED_FILENAME_SIZE],
             size: 0,
             mc_uuid: [0; 16],
             mc_value: 0,
-            mht_key: [0; 16],
-            mht_gmac: [0; 16],
-
-            data: [0; 3072],
+            root_mht: FileDataKeyAndMac{
+                key: [0; 16],
+                gmac: [0; 16],
+            },
+            data: [0; FILE_MD_ENCRYPTED_DATA_SIZE],
         };
 
         let p_iv: [u8; 12] = [0; 12];
 
-        st = sgx_rijndael128GCM_decrypt(
-            &cur_key,
+        cur_key_mac.decrypt_once(
             std::ptr::addr_of!((*p_md).encr) as *const u8,
             mem::size_of::<FileMdEncrypted>() as u32,
             std::ptr::addr_of!(md_decr) as *mut uint8_t,
-            p_iv.as_ptr() as *const u8,
-            12,
-            null(),
-            0,
-            &(*p_md).plain.meta_data_gmac,
-        );
-
-        if sgx_status_t::SGX_SUCCESS != st {
-            return Err(st);
-        }
-
-        let ret_size = std::ptr::read_unaligned(std::ptr::addr_of!(md_decr.size)) as usize;
-        if ret_size > FILE_MD_ENCRYPTED_DATA_SIZE {
-            return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
-        }
-
-        bytes.resize(ret_size, 0);
-        bytes.copy_from_slice(slice::from_raw_parts(md_decr.data.as_ptr(), ret_size));
+            &p_iv,
+        )?;
 
         if should_check_fname {
             let raw_path = s_path.as_bytes();
@@ -204,6 +244,64 @@ pub fn unseal_file_from_2_17(
                 return Err(sgx_status_t::SGX_ERROR_FILE_NAME_MISMATCH);
             }
         }
+
+        let ret_size = std::ptr::read_unaligned(std::ptr::addr_of!(md_decr.size)) as usize;
+
+        if ret_size <= FILE_MD_ENCRYPTED_DATA_SIZE {
+            bytes.resize(ret_size, 0);
+            bytes.copy_from_slice(slice::from_raw_parts(md_decr.data.as_ptr(), ret_size));
+        } else {
+            let node_size = mem::size_of::<FileMd>(); // 4K
+
+            let num_nodes = (ret_size - FILE_MD_ENCRYPTED_DATA_SIZE + node_size - 1) / node_size;
+            if num_nodes > FILE_MD_ENCRYPTED_DATA_NODES {
+                warn!("too many nodes, indirect files not supported");
+                return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
+            }
+
+            let size_required = mem::size_of::<FileMd>() + node_size * (num_nodes + 1);
+            if bytes.len() < size_required {
+                warn!("file too short");
+                return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
+            }
+
+            let mut bytes_src = bytes;
+            bytes = Vec::new();
+            bytes.resize(FILE_MD_ENCRYPTED_DATA_SIZE + node_size * num_nodes, 7); // allocate with padding
+
+            let mut offs_dst = FILE_MD_ENCRYPTED_DATA_SIZE;
+
+            ptr::copy_nonoverlapping(md_decr.data.as_ptr(), bytes.as_mut_ptr(), offs_dst);
+
+            // Decode mht node
+            let p_mht_node =
+                bytes_src.as_mut_ptr().add(mem::size_of::<FileMd>()) as *mut FileMhtNode;
+
+            md_decr.root_mht.decrypt_once(
+                p_mht_node as *const u8,
+                mem::size_of::<FileMhtNode>() as u32,
+                p_mht_node as *mut uint8_t,
+                &p_iv,
+            )?;
+
+            let mut offs_src = mem::size_of::<FileMd>() + node_size;
+
+            for i_node in 0..num_nodes {
+                let keys = &(*p_mht_node).data[i_node];
+
+                keys.decrypt_once(
+                    bytes_src.as_ptr().add(offs_src),
+                    node_size as u32,
+                    bytes.as_mut_ptr().add(offs_dst),
+                    &p_iv,
+                )?;
+
+                offs_src += node_size;
+                offs_dst += node_size;
+            }
+
+            bytes.resize(ret_size, 0); // truncate the padding
+        }
     };
 
     Ok(bytes)
@@ -214,26 +312,30 @@ pub fn migrate_file_from_2_17_safe(
     should_check_fname: bool,
 ) -> Result<(), sgx_status_t> {
     if Path::new(s_path).exists() {
-        let data = match unseal_file_from_2_17(s_path, should_check_fname) {
-            Ok(x) => x,
-            Err(e) => {
-                error!("Couldn't unseal file {}, {}", s_path, e);
-                return Err(e);
+        if SgxFile::open(s_path).is_ok() {
+            info!("File {} is already converted", s_path);
+        } else {
+            let data = match unseal_file_from_2_17(s_path, should_check_fname) {
+                Ok(x) => x,
+                Err(e) => {
+                    error!("Couldn't unseal file {}, {}", s_path, e);
+                    return Err(e);
+                }
+            };
+
+            let s_path_bkp = s_path.to_string() + ".bkp";
+            if let Err(e) = fs::copy(s_path, &s_path_bkp) {
+                error!("Couldn't backup {} into {}, {}", s_path, s_path_bkp, e);
+                return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
             }
-        };
 
-        let s_path_bkp = s_path.to_string() + ".bkp";
-        if let Err(e) = fs::copy(s_path, &s_path_bkp) {
-            error!("Couldn't backup {} into {}, {}", s_path, s_path_bkp, e);
-            return Err(sgx_status_t::SGX_ERROR_UNEXPECTED);
-        }
+            if let Err(e) = seal(data.as_slice(), s_path) {
+                error!("Couldn't RE-seal file {}, {}", s_path, e);
+                return Err(e);
+            }
 
-        if let Err(e) = seal(data.as_slice(), s_path) {
-            error!("Couldn't RE-seal file {}, {}", s_path, e);
-            return Err(e);
+            info!("File {} successfully RE-sealed", s_path);
         }
-
-        info!("File {} successfully RE-sealed", s_path);
     } else {
         info!("File {} doesn't exist, skipping", s_path);
     }