improve key- & error-handling; cleanups

Author: daringer

src/error.rs

@@ -40,6 +40,9 @@ pub enum Error {
     WrongKeyKind,
     WrongMessageLength,
     WrongSignatureLength,
+
+    // sw encryption errors
+    FilesystemEncryptionError
 }
 
 // pub struct FutureResult<'a, 'c> {

src/service.rs

@@ -119,7 +119,7 @@ impl<P: Platform> ServiceResources<P> {
             client_id.path.clone(),
             self.rng().map_err(|_| Error::EntropyMalfunction)?,
             full_store,
-            raw_store,
+            raw_store.clone(),
         );
         let keystore = &mut keystore;
 
@@ -128,7 +128,7 @@ impl<P: Platform> ServiceResources<P> {
             client_id.path.clone(),
             self.rng().map_err(|_| Error::EntropyMalfunction)?,
             full_store,
-            raw_store,
+            raw_store.clone(),
         );
         let certstore = &mut certstore;
 
@@ -137,13 +137,13 @@ impl<P: Platform> ServiceResources<P> {
             client_id.path.clone(),
             self.rng().map_err(|_| Error::EntropyMalfunction)?,
             full_store,
-            raw_store,
+            raw_store.clone(),
         );
         let counterstore = &mut counterstore;
 
         // prepare filestore, bound to client_id, for storage calls
         let mut filestore: ClientFilestore<P::S> =
-            ClientFilestore::new(client_id.path.clone(), full_store, raw_store);
+            ClientFilestore::new(client_id.path.clone(), full_store, raw_store.clone());
         let filestore = &mut filestore;
 
         debug_now!("TRUSSED {:?}", request);
@@ -594,11 +594,9 @@ impl<P: Platform> ServiceResources<P> {
             }
 
             Request::ChangePin(request) => {
-                let res = raw_store.change_pin(request.new_pin.clone());
-                match res {
-                    Err(e) => { return Err(e); },
-                    Ok(_) => { client_id.pin = Some(request.new_pin.clone()); },
-                }
+                raw_store.change_pin(request.new_pin.clone())?;
+                client_id.pin = Some(request.new_pin.clone());
+
                 Ok(Reply::ChangePin(reply::ChangePin {}))
             }
 

src/store/rawstore.rs

@@ -29,13 +29,14 @@ use sha2::digest::Digest;
 use chacha20::ChaCha8Rng;
 use rand_core::RngCore;
 
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub struct RawStore<S>
 where
     S: Store,
 {
     mode: RawStoreMode,
-    symmetric_key: Option<[u8; 32]>,
+    pin: Option<ShortData>,
+    key_filename: PathBuf,
     store: S,
 }
 
@@ -46,21 +47,17 @@ impl<S: Store> RawStore<S> {
         pin: Option<ShortData>,
         rng: Option<ChaCha8Rng>,
     ) -> Self {
-        let mut symmetric_key = [0u8; 32];
-
+        let key_filename = PathBuf::from("encryption-key");
         if mode == RawStoreMode::Encrypted {
-            let key_filename = PathBuf::from("encryption-key");
             let res: Result<Bytes<128>, Error> =
                 store::read(store, Location::Internal, &key_filename);
-            debug_now!("pin: {:?}", pin);
-            let pin_key = Self::get_pin_key(pin.unwrap()).into_vec();
+            let pin_key = Self::get_pin_key(pin.clone().unwrap()).into_vec();
             match res {
                 // 'key_filename' not found, generate new key and save (encrypted) to 'key_filename'
                 Err(e) => {
                     let mut new_key = [0u8; 32];
                     rng.unwrap().fill_bytes(&mut new_key);
 
-                    symmetric_key.copy_from_slice(&new_key);
                     let content =
                         Self::encrypt_content(mode, &key_filename, pin_key.as_slice(), &new_key);
                     store::write(
@@ -70,21 +67,17 @@ impl<S: Store> RawStore<S> {
                         content.into_vec().as_slice(),
                     );
                 }
-                // 'key_filename' found, extract symmetric key and use it
+                // 'key_filename' found
                 Ok(data) => {
-                    symmetric_key.copy_from_slice(&Self::decrypt_content(
-                        mode,
-                        &key_filename,
-                        pin_key.as_slice(),
-                        data,
-                    ));
+                    // do nothing, read key on-demand
                 }
             }
         }
 
         Self {
             mode,
-            symmetric_key: Some(symmetric_key),
+            pin: pin.clone(),
+            key_filename,
             store,
         }
     }
@@ -93,10 +86,8 @@ impl<S: Store> RawStore<S> {
         match mode {
             RawStoreMode::Unencrypted => Message::from_slice(contents).unwrap(),
             RawStoreMode::Encrypted => {
-                let zero_iv = Self::get_iv(path);
-                debug_now!("iv: {:?}", zero_iv);
-                debug_now!("key: {:?}", key);
-                let cipher = Aes256Cbc::new_from_slices(key, &zero_iv).unwrap();
+                let iv = Self::get_iv(path);
+                let cipher = Aes256Cbc::new_from_slices(key, &iv).unwrap();
                 let mut buffer = Message::from_slice(contents).unwrap();
                 let l = contents.len();
                 buffer.resize_default(l + (32 - l % 32));
@@ -113,42 +104,18 @@ impl<S: Store> RawStore<S> {
         contents: Bytes<N>,
     ) -> Bytes<N> {
         match mode {
-            RawStoreMode::Unencrypted => {
-                //debug_now!("READ DATA LEN - N:{:?} len:{:?} data: {:?}", N, contents.len(), &contents[..10]);
-                contents
-            }
+            RawStoreMode::Unencrypted => contents,
             RawStoreMode::Encrypted => {
-                let zero_iv = Self::get_iv(path);
-                let cipher = Aes256Cbc::new_from_slices(key, &zero_iv).unwrap();
+                let iv = Self::get_iv(path);
+                let cipher = Aes256Cbc::new_from_slices(key, &iv).unwrap();
                 let mut buffer = contents.clone();
                 let plaintext = cipher.decrypt(&mut buffer).unwrap();
                 let out = Bytes::<N>::from_slice(plaintext).unwrap();
-                //debug_now!("READ DATA LEN - N:{:?} len:{:?} data: {:?}", N, out.len(), &out[..10]);
                 out
             }
         }
     }
 
-    pub fn change_pin(&self, new_pin: ShortData) -> Result<(), Error> {
-        let key_filename = PathBuf::from("encryption-key");
-        let pin_key = Self::get_pin_key(new_pin).into_vec();
-
-        // write key with new pin
-        let content = Self::encrypt_content(
-            RawStoreMode::Encrypted,
-            &key_filename,
-            pin_key.as_slice(),
-            &self.symmetric_key.unwrap(),
-        );
-        store::write(
-            self.store,
-            Location::Internal,
-            &key_filename,
-            content.into_vec().as_slice(),
-        );
-        Ok(())
-    }
-
     pub fn get_pin_key(pin: ShortData) -> Bytes<32> {
         let mut hash = sha2::Sha256::new();
         hash.update(pin);
@@ -169,12 +136,55 @@ impl<S: Store> RawStore<S> {
         Bytes::<16>::from_slice(&hashed.into_vec().as_slice()[..16]).unwrap()
     }
 
-    pub fn create_directories<'s, X: LfsStorage>(
-        &self,
-        fs: &Filesystem<'s, X>,
-        path: &Path,
-    ) -> Result<(), Error> {
-        store::create_directories(fs, path)
+    fn read_symmetric_key(&self) -> Result<[u8; 32], Error> {
+        if self.mode == RawStoreMode::Unencrypted {
+            return Ok([0u8; 32]);
+        }
+
+        let pin_key = Self::get_pin_key(self.pin.clone().unwrap()).into_vec();
+        let res: Result<Bytes<128>, Error> =
+            store::read(self.store, Location::Internal, &self.key_filename);
+        let data = res.unwrap();
+
+        let mut symmetric_key = [0u8; 32];
+
+        /*symmetric_key.copy_from_slice(&Self::decrypt_content(
+            self.mode,
+            &self.key_filename,
+            pin_key.as_slice(),
+            data,
+        ));*/
+        // instead explicitly decrypt "by-hand" to catch (and propagate) a wrong pin
+        let iv = Self::get_iv(&self.key_filename);
+        let cipher = Aes256Cbc::new_from_slices(pin_key.as_slice(), &iv).unwrap();
+        let mut buffer = data.clone();
+        match cipher.decrypt(&mut buffer) {
+            Err(e) => return Err(Error::FilesystemEncryptionError),
+            Ok(plaintext) => symmetric_key.copy_from_slice(plaintext)
+        };
+
+        //let out = Bytes::<N>::from_slice(plaintext).unwrap();
+
+        Ok(symmetric_key)
+    }
+
+    pub fn change_pin(&self, new_pin: ShortData) -> Result<(), Error> {
+        let pin_key = Self::get_pin_key(new_pin).into_vec();
+        // write key with new pin
+        let key = self.read_symmetric_key()?;
+        let content = Self::encrypt_content(
+            RawStoreMode::Encrypted,
+            &self.key_filename,
+            pin_key.as_slice(),
+            &key,
+        );
+        store::write(
+            self.store,
+            Location::Internal,
+            &self.key_filename,
+            content.into_vec().as_slice(),
+        );
+        Ok(())
     }
 
     pub fn read<const N: usize>(
@@ -183,9 +193,10 @@ impl<S: Store> RawStore<S> {
         location: Location,
         path: &Path,
     ) -> Result<Bytes<N>, Error> {
-        debug_now!("READ: {:?} {:?}", N, path);
+        //debug_now!("READ: {:?} {:?}", N, path);
+        let key = self.read_symmetric_key()?;
         store::read(store, location, path)
-            .map(|val| Self::decrypt_content(self.mode, path, &self.symmetric_key.unwrap(), val))
+            .map(|val| Self::decrypt_content(self.mode, path, &key, val))
     }
 
     pub fn write(
@@ -195,13 +206,9 @@ impl<S: Store> RawStore<S> {
         path: &Path,
         contents: &[u8],
     ) -> Result<(), Error> {
-        debug_now!("WRITE: {:?} data: {:?}", path, &contents[..10]);
-        let data = Self::encrypt_content(
-            self.mode,
-            path,
-            &self.symmetric_key.unwrap(),
-            &contents.clone(),
-        );
+        // debug_now!("WRITE: {:?} data: {:?}", path, &contents[..10]);
+        let key = self.read_symmetric_key()?;
+        let data = Self::encrypt_content(self.mode, path, &key, &contents.clone());
         store::write(store, location, path, data.into_vec().as_slice())
     }
 
@@ -212,15 +219,20 @@ impl<S: Store> RawStore<S> {
         path: &Path,
         contents: &[u8],
     ) -> Result<(), Error> {
-        debug_now!("STORE: {:?} data: {:?}", path, &contents[..10]);
-        let data = Self::encrypt_content(
-            self.mode,
-            path,
-            &self.symmetric_key.unwrap(),
-            &contents.clone(),
-        );
+        //debug_now!("STORE: {:?} data: {:?}", path, &contents[..10]);
+        let key = self.read_symmetric_key()?;
+        let data = Self::encrypt_content(self.mode, path, &key, &contents.clone());
         store::store(store, location, path, data.into_vec().as_slice())
     }
+
+    pub fn create_directories<'s, X: LfsStorage>(
+        &self,
+        fs: &Filesystem<'s, X>,
+        path: &Path,
+    ) -> Result<(), Error> {
+        store::create_directories(fs, path)
+    }
+
     pub fn delete(&self, store: impl Store, location: Location, path: &Path) -> bool {
         store::delete(store, location, path)
     }