Migrate from ring to ed25519-dalek, take 2 (#3844)

* Migrate from ring to ed25519-dalek

* Move gen_keypair_file test to a more appropriate location

* Fixup bench-exchange and add helper fn for single deterministic keypair

* Update golden

sdk/src/signature.rs

@@ -2,19 +2,18 @@
 
 use crate::pubkey::Pubkey;
 use bs58;
+use ed25519_dalek;
 use generic_array::typenum::U64;
 use generic_array::GenericArray;
-use ring::signature::Ed25519KeyPair;
-use ring::{rand, signature};
+use rand::rngs::OsRng;
 use serde_json;
 use std::error;
 use std::fmt;
 use std::fs::{self, File};
 use std::io::Write;
 use std::path::Path;
-use untrusted::Input;
 
-pub type Keypair = Ed25519KeyPair;
+pub type Keypair = ed25519_dalek::Keypair;
 
 #[derive(Serialize, Deserialize, Clone, Copy, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct Signature(GenericArray<u8, U64>);
@@ -25,10 +24,9 @@ impl Signature {
     }
 
     pub fn verify(&self, pubkey_bytes: &[u8], message_bytes: &[u8]) -> bool {
-        let pubkey = Input::from(pubkey_bytes);
-        let message = Input::from(message_bytes);
-        let signature = Input::from(self.0.as_slice());
-        signature::verify(&signature::ED25519, pubkey, message, signature).is_ok()
+        let pubkey = ed25519_dalek::PublicKey::from_bytes(pubkey_bytes).unwrap();
+        let signature = ed25519_dalek::Signature::from_bytes(self.0.as_slice()).unwrap();
+        pubkey.verify(message_bytes, &signature).is_ok()
     }
 }
 
@@ -72,45 +70,33 @@ pub trait KeypairUtil {
     fn sign_message(&self, message: &[u8]) -> Signature;
 }
 
-impl KeypairUtil for Ed25519KeyPair {
+impl KeypairUtil for Keypair {
     /// Return a new ED25519 keypair
     fn new() -> Self {
-        let rng = rand::SystemRandom::new();
-        let pkcs8_bytes = Ed25519KeyPair::generate_pkcs8(&rng).expect("generate_pkcs8");
-        Ed25519KeyPair::from_pkcs8(Input::from(&pkcs8_bytes)).expect("from_pcks8")
+        let mut rng = OsRng::new().unwrap();
+        Keypair::generate(&mut rng)
     }
 
     /// Return the public key for the given keypair
     fn pubkey(&self) -> Pubkey {
-        Pubkey::new(self.public_key_bytes())
+        Pubkey::new(&self.public.as_ref())
     }
 
     fn sign_message(&self, message: &[u8]) -> Signature {
-        Signature::new(self.sign(message).as_ref())
+        Signature::new(&self.sign(message).to_bytes())
     }
 }
 
-pub fn read_pkcs8(path: &str) -> Result<Vec<u8>, Box<error::Error>> {
-    let file = File::open(path.to_string())?;
-    let pkcs8: Vec<u8> = serde_json::from_reader(file)?;
-    Ok(pkcs8)
-}
-
 pub fn read_keypair(path: &str) -> Result<Keypair, Box<error::Error>> {
-    let pkcs8 = read_pkcs8(path)?;
-    let keypair = Ed25519KeyPair::from_pkcs8(Input::from(&pkcs8))?;
+    let file = File::open(path.to_string())?;
+    let bytes: Vec<u8> = serde_json::from_reader(file)?;
+    let keypair = Keypair::from_bytes(&bytes).unwrap();
     Ok(keypair)
 }
 
-pub fn gen_pkcs8() -> Result<Vec<u8>, Box<error::Error>> {
-    let rnd = rand::SystemRandom::new();
-    let pkcs8_bytes = Ed25519KeyPair::generate_pkcs8(&rnd)?;
-    Ok(pkcs8_bytes.to_vec())
-}
-
-//pub fn gen_keypair_file(outfile: String) -> Result<String, Box<dyn error::Error>> {
 pub fn gen_keypair_file(outfile: String) -> Result<String, Box<error::Error>> {
-    let serialized = serde_json::to_string(&gen_pkcs8()?)?;
+    let keypair_bytes = Keypair::new().to_bytes();
+    let serialized = serde_json::to_string(&keypair_bytes.to_vec())?;
 
     if outfile != "-" {
         if let Some(outdir) = Path::new(&outfile).parent() {
@@ -121,3 +107,35 @@ pub fn gen_keypair_file(outfile: String) -> Result<String, Box<error::Error>> {
     }
     Ok(serialized)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem;
+
+    fn tmp_file_path(name: &str) -> String {
+        use std::env;
+        let out_dir = env::var("OUT_DIR").unwrap_or_else(|_| "target".to_string());
+        let keypair = Keypair::new();
+
+        format!("{}/tmp/{}-{}", out_dir, name, keypair.pubkey()).to_string()
+    }
+
+    #[test]
+    fn test_gen_keypair_file() {
+        let outfile = tmp_file_path("test_gen_keypair_file.json");
+        let serialized_keypair = gen_keypair_file(outfile.to_string()).unwrap();
+        let keypair_vec: Vec<u8> = serde_json::from_str(&serialized_keypair).unwrap();
+        assert!(Path::new(&outfile).exists());
+        assert_eq!(
+            keypair_vec,
+            read_keypair(&outfile).unwrap().to_bytes().to_vec()
+        );
+        assert_eq!(
+            read_keypair(&outfile).unwrap().pubkey().as_ref().len(),
+            mem::size_of::<Pubkey>()
+        );
+        fs::remove_file(&outfile).unwrap();
+        assert!(!Path::new(&outfile).exists());
+    }
+}