Add seal and open in the key crate

Author: majecty

key/src/encryption.rs

@@ -0,0 +1,49 @@
+// Copyright 2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+mod keypair;
+mod private;
+mod public;
+
+pub use keypair::KeyPair;
+pub use private::Private;
+pub use public::Public;
+use sodiumoxide::crypto::sealedbox;
+
+pub fn encrypt(message: &[u8], public: &Public) -> Vec<u8> {
+    let Public(public) = public;
+    sealedbox::seal(message, public)
+}
+
+pub fn decrypt(encrypted: &[u8], public: &Public, private: &Private) -> Result<Vec<u8>, ()> {
+    let Private(private) = private;
+    let Public(public) = public;
+    sealedbox::open(encrypted, public, private)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::keypair::KeyPair;
+    use crate::{decrypt, encrypt, Generator, KeyPairTrait, Random};
+    #[test]
+    fn open_and_seal() {
+        let secret_data = b"Dr. Crowe was dead";
+        let keypair: KeyPair = Random.generate().unwrap();
+        let encrypted = encrypt(secret_data, keypair.public());
+        let decrypted = decrypt(&encrypted, keypair.public(), keypair.private()).unwrap();
+        assert_eq!(secret_data[..], decrypted[..]);
+    }
+}

key/src/encryption/keypair.rs

@@ -0,0 +1,52 @@
+// Copyright 2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use super::private::Private;
+use super::public::Public;
+use crate::KeyPairTrait;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct KeyPair {
+    private: Private,
+    public: Public,
+}
+
+impl KeyPairTrait for KeyPair {
+    type Private = Private;
+    type Public = Public;
+
+    fn from_private(private: Self::Private) -> Self {
+        KeyPair {
+            public: private.public_key(),
+            private,
+        }
+    }
+
+    fn from_keypair(private: Self::Private, public: Self::Public) -> Self {
+        KeyPair {
+            private,
+            public,
+        }
+    }
+
+    fn private(&self) -> &Self::Private {
+        &self.private
+    }
+
+    fn public(&self) -> &Self::Public {
+        &self.public
+    }
+}

key/src/encryption/private.rs

@@ -0,0 +1,43 @@
+// Copyright 2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use super::public::Public;
+use sodiumoxide::crypto::box_::SecretKey;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Private(pub(crate) SecretKey);
+
+impl Private {
+    pub fn from_slice(slice: &[u8]) -> Option<Self> {
+        SecretKey::from_slice(slice).map(Self)
+    }
+
+    pub fn public_key(&self) -> Public {
+        self.0.public_key().into()
+    }
+}
+
+impl AsRef<[u8]> for Private {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl From<SecretKey> for Private {
+    fn from(k: SecretKey) -> Self {
+        Private(k)
+    }
+}

key/src/encryption/public.rs

@@ -0,0 +1,38 @@
+// Copyright 2020 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use sodiumoxide::crypto::box_::PublicKey;
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct Public(pub(crate) PublicKey);
+
+impl Public {
+    pub fn from_slice(slice: &[u8]) -> Option<Self> {
+        PublicKey::from_slice(slice).map(Self)
+    }
+}
+
+impl AsRef<[u8]> for Public {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+impl From<PublicKey> for Public {
+    fn from(k: PublicKey) -> Self {
+        Public(k)
+    }
+}

key/src/lib.rs

@@ -19,6 +19,7 @@ extern crate codechain_crypto as crypto;
 extern crate serde_derive;
 
 mod ed25519;
+mod encryption;
 mod error;
 mod keypair;
 mod network;
@@ -31,6 +32,7 @@ pub use crate::ed25519::{
     sign, verify, KeyPair as Ed25519KeyPair, Private as Ed25519Private, Public as Ed25519Public, Signature,
     SIGNATURE_LENGTH,
 };
+pub use crate::encryption::{decrypt, encrypt, KeyPair as SealKeyPair, Private as SealPrivate, Public as SealPublic};
 pub use crate::error::Error;
 pub use crate::keypair::KeyPair as KeyPairTrait;
 pub use crate::network::NetworkId;

key/src/random.rs

@@ -14,12 +14,13 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Ed25519KeyPair, Generator, KeyPairTrait, X25519KeyPair, X25519Private, X25519Public};
+use crate::{Ed25519KeyPair, Generator, KeyPairTrait, SealKeyPair, X25519KeyPair, X25519Private, X25519Public};
 use never_type::Never;
 use rand::rngs::OsRng;
 #[cfg(test)]
 use rand::SeedableRng;
 use rand_xorshift::XorShiftRng;
+use sodiumoxide::crypto::box_::gen_keypair as gen_curve25519xsalsa20poly1305;
 use sodiumoxide::crypto::kx::gen_keypair as gen_x25519;
 use sodiumoxide::crypto::sign::gen_keypair as gen_ed25519;
 #[cfg(test)]
@@ -126,3 +127,45 @@ impl Generator<X25519KeyPair> for XorShiftRng {
         Ok(X25519KeyPair::from_keypair(sec, publ))
     }
 }
+
+impl Generator<SealKeyPair> for Random {
+    type Error = ::std::io::Error;
+
+    //FIXME: there is no distinction between the two generate functions
+    #[cfg(not(test))]
+    fn generate(&mut self) -> Result<SealKeyPair, Self::Error> {
+        let mut rng = OsRng::new()?;
+        match rng.generate() {
+            Ok(pair) => Ok(pair),
+            Err(never) => match never {}, // LLVM unreachable
+        }
+    }
+
+    #[cfg(test)]
+    fn generate(&mut self) -> Result<SealKeyPair, Self::Error> {
+        RNG.with(|rng| {
+            match rng.borrow_mut().generate() {
+                Ok(pair) => Ok(pair),
+                Err(never) => match never {}, // LLVM unreachable
+            }
+        })
+    }
+}
+
+impl Generator<SealKeyPair> for OsRng {
+    type Error = Never;
+
+    fn generate(&mut self) -> Result<SealKeyPair, Self::Error> {
+        let (publ, sec) = gen_curve25519xsalsa20poly1305();
+        Ok(SealKeyPair::from_keypair(sec.into(), publ.into()))
+    }
+}
+
+impl Generator<SealKeyPair> for XorShiftRng {
+    type Error = Never;
+
+    fn generate(&mut self) -> Result<SealKeyPair, Self::Error> {
+        let (publ, sec) = gen_curve25519xsalsa20poly1305();
+        Ok(SealKeyPair::from_keypair(sec.into(), publ.into()))
+    }
+}