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

This reverts commit e9b82bacda.

sdk/src/signature.rs

@@ -2,18 +2,19 @@
 
 use crate::pubkey::Pubkey;
 use bs58;
-use ed25519_dalek;
 use generic_array::typenum::U64;
 use generic_array::GenericArray;
-use rand::rngs::OsRng;
+use ring::signature::Ed25519KeyPair;
+use ring::{rand, signature};
 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 = ed25519_dalek::Keypair;
+pub type Keypair = Ed25519KeyPair;
 
 #[derive(Serialize, Deserialize, Clone, Copy, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct Signature(GenericArray<u8, U64>);
@@ -24,9 +25,10 @@ impl Signature {
     }
 
     pub fn verify(&self, pubkey_bytes: &[u8], message_bytes: &[u8]) -> bool {
-        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()
+        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()
     }
 }
 
@@ -70,33 +72,45 @@ pub trait KeypairUtil {
     fn sign_message(&self, message: &[u8]) -> Signature;
 }
 
-impl KeypairUtil for Keypair {
+impl KeypairUtil for Ed25519KeyPair {
     /// Return a new ED25519 keypair
     fn new() -> Self {
-        let mut rng = OsRng::new().unwrap();
-        Keypair::generate(&mut rng)
+        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")
     }
 
     /// Return the public key for the given keypair
     fn pubkey(&self) -> Pubkey {
-        Pubkey::new(&self.public.as_ref())
+        Pubkey::new(self.public_key_bytes())
     }
 
     fn sign_message(&self, message: &[u8]) -> Signature {
-        Signature::new(&self.sign(message).to_bytes())
+        Signature::new(self.sign(message).as_ref())
     }
 }
 
-pub fn read_keypair(path: &str) -> Result<Keypair, Box<error::Error>> {
+pub fn read_pkcs8(path: &str) -> Result<Vec<u8>, Box<error::Error>> {
     let file = File::open(path.to_string())?;
-    let bytes: Vec<u8> = serde_json::from_reader(file)?;
-    let keypair = Keypair::from_bytes(&bytes).unwrap();
+    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))?;
     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 keypair_bytes = Keypair::new().to_bytes();
-    let serialized = serde_json::to_string(&keypair_bytes.to_vec())?;
+    let serialized = serde_json::to_string(&gen_pkcs8()?)?;
 
     if outfile != "-" {
         if let Some(outdir) = Path::new(&outfile).parent() {
@@ -107,35 +121,3 @@ 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());
-    }
-}