From 659eaa9ff296ae3e03362593ee756cbe6d1f42ed Mon Sep 17 00:00:00 2001
From: Katharina Fey <kookie@spacekookie.de>
Date: Wed, 9 May 2018 00:26:05 +0200
Subject: Bumping version on core and crypto

---
 lockchain-crypto/src/data.rs   | 13 --------
 lockchain-crypto/src/engine.rs | 72 +++++++++++++++++++++++++++---------------
 lockchain-crypto/src/lib.rs    |  2 --
 3 files changed, 47 insertions(+), 40 deletions(-)
 delete mode 100644 lockchain-crypto/src/data.rs

(limited to 'lockchain-crypto/src')

diff --git a/lockchain-crypto/src/data.rs b/lockchain-crypto/src/data.rs
deleted file mode 100644
index 74698e4..0000000
--- a/lockchain-crypto/src/data.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//! A simple data layout
-
-use lcc::traits::AutoEncoder;
-
-/// Represents some packed data – includes nonce and blob
-#[derive(Serialize, Deserialize)]
-pub struct PackedData {
-    pub nonce: Vec<u8>,
-    pub iv: Vec<u8>,
-    pub data: Vec<u8>,
-}
-
-impl AutoEncoder for PackedData {}
\ No newline at end of file
diff --git a/lockchain-crypto/src/engine.rs b/lockchain-crypto/src/engine.rs
index d9664bb..1af386c 100644
--- a/lockchain-crypto/src/engine.rs
+++ b/lockchain-crypto/src/engine.rs
@@ -1,22 +1,20 @@
 //!
 
-use lcc::{traits::{AutoEncoder, Encryptable, EncryptionHandler},
-          EncryptedBody};
+use lcc::traits::{AutoEncoder, Encryptable, EncryptionHandler};
+use lcc::{EncryptedBody, PackedData};
+
 use miscreant::aead::{Aes256Siv, Algorithm};
 
-use super::data::PackedData;
 use super::databody::DataBody;
 
-use lcc::crypto::{Key, keys::KEY_LENGTH};
-use lcc::crypto::utils::random;
-
-use std::collections::BTreeMap;
+use lcc::crypto::random;
+use lcc::crypto::{Key, KEY_LENGTH};
 
 impl Encryptable for DataBody {}
 
 pub struct AesEngine {
     ctx: Aes256Siv,
-    key: Key,
+    _key: Key,
     iv: Vec<u8>,
 }
 
@@ -26,45 +24,69 @@ impl AesEngine {
         let key = Key::generate();
         Self {
             ctx: Aes256Siv::new(&key.to_slice()),
-            key,
+            _key: key,
             iv: random::bytes(KEY_LENGTH),
         }
     }
-
+    /// Generate an Aes context from password
     pub fn from_pw(pw: &str, salt: &str) -> Self {
         let key = Key::from_password(pw, salt);
         Self {
             ctx: Aes256Siv::new(&key.to_slice()),
-            key,
+            _key: key,
             iv: random::bytes(KEY_LENGTH),
         }
     }
-}
 
-impl EncryptionHandler<DataBody> for AesEngine {
-    fn encrypt(&mut self, item: DataBody) -> EncryptedBody {
-        let ser = item.encode();
+    /// Load a packed data object which contains an Aes context
+    pub fn load(packed: PackedData, pw: &str, salt: &str) -> Option<Self> {
+        let mut temp = Self::from_pw(pw, salt);
+        let k = Key::decode(&String::from_utf8(temp.decrypt_primitive(&packed)?).ok()?);
+
+        Some(Self {
+            ctx: Aes256Siv::new(&k.to_slice()),
+            _key: k,
+            iv: packed.iv
+        })
+    }
+
+    /// Serialise the current context to save it somewhere
+    pub fn save(&mut self) -> PackedData {
+        let k = self._key.to_vec();
+        self.encrypt_primitive(&k)
+    }
+
+    fn encrypt_primitive(&mut self, data: &Vec<u8>) -> PackedData {
         let nonce = random::bytes(64);
         let iv = &self.iv.as_slice();
-        let data = &ser.as_bytes();
+        let encrypted = self.ctx.seal(nonce.as_slice(), iv, data.as_slice());
 
-        let encrypted = self.ctx.seal(nonce.as_slice(), iv, data);
-        let data = PackedData {
+        PackedData {
             iv: self.iv.clone(),
             data: encrypted,
             nonce: nonce,
-        }.encode();
+        }
+    }
+
+    fn decrypt_primitive(&mut self, packed: &PackedData) -> Option<Vec<u8>> {
+        let iv = &self.iv.as_slice();
+        Some(self.ctx
+            .open(packed.nonce.as_slice(), iv, packed.data.as_slice())
+            .ok()?)
+    }
+}
 
+impl EncryptionHandler<DataBody> for AesEngine {
+    fn encrypt(&mut self, item: DataBody) -> EncryptedBody {
+        let ser = item.encode();
+        let data = self.encrypt_primitive(&ser.as_bytes().to_vec()).encode();
         EncryptedBody { data }
     }
 
     fn decrypt(&mut self, item: EncryptedBody) -> Option<DataBody> {
         let packed = PackedData::decode(&item.data);
-        let iv = &self.iv.as_slice();
-        let decrypted = self.ctx
-            .open(packed.nonce.as_slice(), iv, packed.data.as_slice())
-            .ok()?;
-
-        Some(DataBody::decode(&String::from_utf8(decrypted).ok()?))
+        Some(DataBody::decode(&String::from_utf8(
+            self.decrypt_primitive(&packed)?,
+        ).ok()?))
     }
 }
diff --git a/lockchain-crypto/src/lib.rs b/lockchain-crypto/src/lib.rs
index b10b2c5..a33e8bc 100644
--- a/lockchain-crypto/src/lib.rs
+++ b/lockchain-crypto/src/lib.rs
@@ -11,10 +11,8 @@ extern crate miscreant;
 
 extern crate lockchain_core as lcc;
 
-
 mod databody;
 mod engine;
-mod data;
 
 pub use databody::*;
 pub use engine::AesEngine;
-- 
cgit v1.2.3