Update to ENR v0.8.1 (#174)

* Update to ENR v0.8.1

* fmt

* Update edwards curve crypto

Author: AgeManning

Cargo.toml

@@ -12,7 +12,7 @@ categories = ["network-programming", "asynchronous"]
 exclude = [".gitignore", ".github/*"]
 
 [dependencies]
-enr = { version = "0.7.0", features = ["k256", "ed25519"] }
+enr = { version = "0.8.1", features = ["k256", "ed25519"] }
 tokio = { version = "1.15.0", features = ["net", "sync", "macros", "rt"] }
 tokio-stream = "0.1.8"
 tokio-util = { version = "0.6.9", features = ["time"] }

examples/find_nodes.rs

@@ -73,7 +73,7 @@ async fn main() {
         let raw_key =
             hex::decode("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
                 .unwrap();
-        let secret_key = k256::ecdsa::SigningKey::from_bytes(&raw_key).unwrap();
+        let secret_key = k256::ecdsa::SigningKey::from_slice(&raw_key).unwrap();
         CombinedKey::from(secret_key)
     } else {
         // use a new key if specified

src/discv5.rs

@@ -422,7 +422,11 @@ impl<P: ProtocolIdentity> Discv5<P> {
     }
 
     /// Allows application layer to insert an arbitrary field into the local ENR.
-    pub fn enr_insert(&self, key: &str, value: &[u8]) -> Result<Option<Vec<u8>>, EnrError> {
+    pub fn enr_insert<T: rlp::Encodable>(
+        &self,
+        key: &str,
+        value: &T,
+    ) -> Result<Option<Vec<u8>>, EnrError> {
         self.local_enr
             .write()
             .insert(key, value, &self.enr_key.read())

src/discv5/test.rs

@@ -11,7 +11,7 @@ fn init() {
         .try_init();
 }
 
-fn update_enr(discv5: &mut Discv5, key: &str, value: &[u8]) -> bool {
+fn update_enr<T: rlp::Encodable>(discv5: &mut Discv5, key: &str, value: &T) -> bool {
     discv5.enr_insert(key, value).is_ok()
 }
 
@@ -72,7 +72,7 @@ fn generate_deterministic_keypair(n: usize, seed: u64) -> Vec<CombinedKey> {
             loop {
                 // until a value is given within the curve order
                 rng.fill_bytes(&mut b);
-                if let Ok(k) = k256::ecdsa::SigningKey::from_bytes(&b) {
+                if let Ok(k) = k256::ecdsa::SigningKey::from_slice(&b) {
                     break k;
                 }
             }

src/handler/crypto/ecdh.rs

@@ -7,10 +7,10 @@ use super::k256::{
 
 pub fn ecdh(public_key: &VerifyingKey, secret_key: &SigningKey) -> Vec<u8> {
     k256::PublicKey::from_affine(
-        (k256::PublicKey::from_sec1_bytes(public_key.to_bytes().as_ref())
+        (k256::PublicKey::from_sec1_bytes(public_key.to_sec1_bytes().as_ref())
             .unwrap()
             .to_projective()
-            * k256::SecretKey::from_be_bytes(&secret_key.to_bytes())
+            * k256::SecretKey::from_slice(&secret_key.to_bytes())
                 .unwrap()
                 .to_nonzero_scalar()
                 .as_ref())

src/handler/crypto/mod.rs

@@ -19,8 +19,7 @@ use enr::{
     k256::{
         self,
         ecdsa::{
-            digest::Update,
-            signature::{DigestSigner, DigestVerifier, Signature as _},
+            signature::{DigestSigner, DigestVerifier},
             Signature,
         },
         sha2::{Digest, Sha256},
@@ -53,10 +52,10 @@ pub(crate) fn generate_session_keys(
     let (secret, ephem_pk) = {
         match contact.public_key() {
             CombinedPublicKey::Secp256k1(remote_pk) => {
-                let ephem_sk = k256::ecdsa::SigningKey::random(rand::thread_rng());
+                let ephem_sk = k256::ecdsa::SigningKey::random(&mut rand::thread_rng());
                 let secret = ecdh(&remote_pk, &ephem_sk);
                 let ephem_pk = ephem_sk.verifying_key();
-                (secret, ephem_pk.to_bytes().to_vec())
+                (secret, ephem_pk.to_sec1_bytes().to_vec())
             }
             CombinedPublicKey::Ed25519(_) => {
                 return Err(Discv5Error::KeyTypeNotSupported("Ed25519"))
@@ -133,11 +132,11 @@ pub(crate) fn sign_nonce(
 
     match signing_key {
         CombinedKey::Secp256k1(key) => {
-            let message = Sha256::new().chain(signing_message);
+            let message = Sha256::new().chain_update(signing_message);
             let signature: Signature = key
                 .try_sign_digest(message)
                 .map_err(|e| Discv5Error::Error(format!("Failed to sign message: {e}")))?;
-            Ok(signature.as_bytes().to_vec())
+            Ok(signature.to_vec())
         }
         CombinedKey::Ed25519(_) => Err(Discv5Error::KeyTypeNotSupported("Ed25519")),
     }
@@ -157,7 +156,7 @@ pub(crate) fn verify_authentication_nonce(
         CombinedPublicKey::Secp256k1(key) => {
             if let Ok(sig) = k256::ecdsa::Signature::try_from(sig) {
                 return key
-                    .verify_digest(Sha256::new().chain(signing_nonce), &sig)
+                    .verify_digest(Sha256::new().chain_update(signing_nonce), &sig)
                     .is_ok();
             }
             false
@@ -262,7 +261,7 @@ mod tests {
                 .unwrap();
 
         let remote_pk = k256::ecdsa::VerifyingKey::from_sec1_bytes(&remote_pubkey).unwrap();
-        let local_sk = k256::ecdsa::SigningKey::from_bytes(&local_secret_key).unwrap();
+        let local_sk = k256::ecdsa::SigningKey::from_slice(&local_secret_key).unwrap();
 
         let secret = ecdh(&remote_pk, &local_sk);
         assert_eq!(secret, expected_secret);
@@ -278,7 +277,7 @@ mod tests {
                 .unwrap();
 
         let remote_pk = k256::ecdsa::VerifyingKey::from_sec1_bytes(&dest_pubkey).unwrap();
-        let local_sk = k256::ecdsa::SigningKey::from_bytes(&ephem_key).unwrap();
+        let local_sk = k256::ecdsa::SigningKey::from_slice(&ephem_key).unwrap();
 
         let secret = ecdh(&remote_pk, &local_sk);
 
@@ -312,7 +311,7 @@ mod tests {
         let expected_sig = hex::decode("94852a1e2318c4e5e9d422c98eaf19d1d90d876b29cd06ca7cb7546d0fff7b484fe86c09a064fe72bdbef73ba8e9c34df0cd2b53e9d65528c2c7f336d5dfc6e6").unwrap();
 
         let challenge_data = ChallengeData::try_from(hex::decode("000000000000000000000000000000006469736376350001010102030405060708090a0b0c00180102030405060708090a0b0c0d0e0f100000000000000000").unwrap().as_slice()).unwrap();
-        let key = k256::ecdsa::SigningKey::from_bytes(&local_secret_key).unwrap();
+        let key = k256::ecdsa::SigningKey::from_slice(&local_secret_key).unwrap();
         let sig = sign_nonce(&key.into(), &challenge_data, &ephemeral_pubkey, &dst_id).unwrap();
 
         assert_eq!(sig, expected_sig);

src/node_info.rs

@@ -117,9 +117,11 @@ impl NodeContact {
                         .expect("Libp2p key conversion, always valid")
                         .into()
                 }
-                PublicKey::Ed25519(pk) => enr::ed25519_dalek::PublicKey::from_bytes(&pk.encode())
-                    .expect("Libp2p key conversion, always valid")
-                    .into(),
+                PublicKey::Ed25519(pk) => {
+                    enr::ed25519_dalek::VerifyingKey::from_bytes(&pk.encode())
+                        .expect("Libp2p key conversion, always valid")
+                        .into()
+                }
                 _ => return Err("The key type is not supported"),
             };