Implement Keystore spec for BLS12-381 secret keys

validator_client/Cargo.toml

@@ -20,6 +20,7 @@ types = { path = "../eth2/types" }
 serde = "1.0.102"
 serde_derive = "1.0.102"
 serde_json = "1.0.41"
+serde_repr = "0.1"
 slog = { version = "2.5.2", features = ["max_level_trace", "release_max_level_trace"] }
 slog-async = "2.3.0"
 slog-term = "2.4.2"
@@ -41,3 +42,7 @@ bls = { path = "../eth2/utils/bls" }
 remote_beacon_node = { path = "../eth2/utils/remote_beacon_node" }
 tempdir = "0.3"
 rayon = "1.2.0"
+rand = "0.7.2"
+rust-crypto = "0.2.36"
+uuid = { version = "0.8", features = ["serde", "v4"] }
+time = "0.1.42"

validator_client/src/keystore/checksum.rs

@@ -0,0 +1,27 @@
+use crypto::digest::Digest;
+use crypto::sha2::Sha256;
+use serde::{Deserialize, Serialize};
+
+/// Checksum module for `Keystore`.
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct ChecksumModule {
+    pub function: String,
+    pub params: serde_json::Value, // Empty json object
+    pub message: String,
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct Checksum(String);
+
+impl Checksum {
+    /// Generate checksum using checksum function.
+    pub fn gen_checksum(message: &[u8]) -> String {
+        let mut hasher = Sha256::new();
+        hasher.input(message);
+        hasher.result_str()
+    }
+
+    pub fn function() -> String {
+        "sha256".to_string()
+    }
+}

validator_client/src/keystore/cipher.rs

@@ -0,0 +1,97 @@
+use crypto::aes::{ctr, KeySize};
+use rand::prelude::*;
+use serde::{de, Deserialize, Serialize, Serializer};
+use std::default::Default;
+
+const IV_SIZE: usize = 16;
+
+/// Convert slice to fixed length array.
+fn from_slice(bytes: &[u8]) -> [u8; IV_SIZE] {
+    let mut array = [0; IV_SIZE];
+    let bytes = &bytes[..array.len()]; // panics if not enough data
+    array.copy_from_slice(bytes);
+    array
+}
+
+/// Cipher module representation.
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct CipherModule {
+    pub function: String,
+    pub params: Cipher,
+    pub message: String,
+}
+
+/// Parameters for AES128 with ctr mode.
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct Aes128Ctr {
+    #[serde(serialize_with = "serialize_iv")]
+    #[serde(deserialize_with = "deserialize_iv")]
+    pub iv: [u8; 16],
+}
+
+impl Aes128Ctr {
+    pub fn encrypt(&self, key: &[u8], pt: &[u8]) -> Vec<u8> {
+        // TODO: sanity checks
+        let mut ct = vec![0; pt.len()];
+        ctr(KeySize::KeySize128, key, &self.iv).process(pt, &mut ct);
+        ct
+    }
+
+    pub fn decrypt(&self, key: &[u8], ct: &[u8]) -> Vec<u8> {
+        // TODO: sanity checks
+        let mut pt = vec![0; ct.len()];
+        ctr(KeySize::KeySize128, key, &self.iv).process(ct, &mut pt);
+        pt
+    }
+}
+
+/// Serialize `iv` to its hex representation.
+fn serialize_iv<S>(x: &[u8], s: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    s.serialize_str(&hex::encode(x))
+}
+
+/// Deserialize `iv` from its hex representation to bytes.
+fn deserialize_iv<'de, D>(deserializer: D) -> Result<[u8; 16], D::Error>
+where
+    D: de::Deserializer<'de>,
+{
+    struct StringVisitor;
+    impl<'de> de::Visitor<'de> for StringVisitor {
+        type Value = [u8; IV_SIZE];
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("String should be hex format and 16 bytes in length")
+        }
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            let bytes = hex::decode(v).map_err(E::custom)?;
+            Ok(from_slice(&bytes))
+        }
+    }
+    deserializer.deserialize_any(StringVisitor)
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Cipher {
+    Aes128Ctr(Aes128Ctr),
+}
+
+impl Default for Cipher {
+    fn default() -> Self {
+        let iv = rand::thread_rng().gen::<[u8; IV_SIZE]>();
+        Cipher::Aes128Ctr(Aes128Ctr { iv })
+    }
+}
+
+impl Cipher {
+    pub fn function(&self) -> String {
+        match &self {
+            Cipher::Aes128Ctr(_) => "aes-128-ctr".to_string(),
+        }
+    }
+}