Merge pull request #446 from tox-rs/rand

refactor(rand): use rand crate instead of sodiumoxide

Author: kurnevsky

tox_core/Cargo.toml

@@ -31,6 +31,7 @@ failure = "0.1"
 lru = "0.6"
 bitflags = "1.0"
 itertools = "0.10"
+rand = "0.8"
 
 [dependencies.tokio]
 version = "1.0"

tox_core/src/dht/dht_friend.rs

@@ -4,6 +4,7 @@ Module for friend.
 
 use std::time::Instant;
 use std::net::SocketAddr;
+use rand::Rng;
 
 use crate::time::*;
 use crate::dht::kbucket::*;
@@ -40,14 +41,14 @@ pub struct DhtFriend {
 
 impl DhtFriend {
     /// Create new `DhtFriend`.
-    pub fn new(pk: PublicKey) -> Self {
+    pub fn new<R: Rng>(rng: &mut R, pk: PublicKey) -> Self {
         DhtFriend {
             pk,
             close_nodes: Kbucket::new(FRIEND_CLOSE_NODES_COUNT),
             last_nodes_req_time: clock_now(),
             random_requests_count: 0,
             nodes_to_bootstrap: Kbucket::new(FRIEND_BOOTSTRAP_NODES_COUNT),
-            hole_punch: HolePunching::new(),
+            hole_punch: HolePunching::new(rng),
         }
     }
 
@@ -98,12 +99,13 @@ mod tests {
     use super::*;
 
     use std::time::Duration;
+    use rand::thread_rng;
 
     #[test]
     fn addr_is_unknown() {
         crypto_init().unwrap();
         let pk = gen_keypair().0;
-        let mut friend = DhtFriend::new(pk);
+        let mut friend = DhtFriend::new(&mut thread_rng(), pk);
 
         assert!(friend.try_add_to_close(PackedNode::new("192.168.1.1:12345".parse().unwrap(), &gen_keypair().0)));
         assert!(friend.try_add_to_close(PackedNode::new("192.168.1.2:12345".parse().unwrap(), &gen_keypair().0)));
@@ -115,7 +117,7 @@ mod tests {
     fn addr_is_known() {
         crypto_init().unwrap();
         let pk = gen_keypair().0;
-        let mut friend = DhtFriend::new(pk);
+        let mut friend = DhtFriend::new(&mut thread_rng(), pk);
 
         assert!(friend.try_add_to_close(PackedNode::new("192.168.1.1:12345".parse().unwrap(), &gen_keypair().0)));
         assert!(friend.try_add_to_close(PackedNode::new("192.168.1.2:12345".parse().unwrap(), &gen_keypair().0)));
@@ -129,7 +131,7 @@ mod tests {
     fn get_returned_addrs() {
         crypto_init().unwrap();
         let pk = gen_keypair().0;
-        let mut friend = DhtFriend::new(pk);
+        let mut friend = DhtFriend::new(&mut thread_rng(), pk);
 
         let nodes = [
             PackedNode::new("192.168.1.1:12345".parse().unwrap(), &gen_keypair().0),
@@ -162,7 +164,7 @@ mod tests {
     async fn get_returned_addrs_timed_out() {
         crypto_init().unwrap();
         let pk = gen_keypair().0;
-        let mut friend = DhtFriend::new(pk);
+        let mut friend = DhtFriend::new(&mut thread_rng(), pk);
 
         let nodes = [
             PackedNode::new("192.168.1.1:12345".parse().unwrap(), &gen_keypair().0),
@@ -191,7 +193,7 @@ mod tests {
     fn can_and_try_add_to_close() {
         crypto_init().unwrap();
         let pk = PublicKey([0; PUBLICKEYBYTES]);
-        let mut friend = DhtFriend::new(pk);
+        let mut friend = DhtFriend::new(&mut thread_rng(), pk);
 
         for i in 0 .. 8 {
             let addr = SocketAddr::new("1.2.3.4".parse().unwrap(), 12345 + u16::from(i));

tox_core/src/dht/dht_node.rs

@@ -195,7 +195,7 @@ impl From<PackedNode> for DhtNode {
     }
 }
 
-impl HasPK for DhtNode {
+impl HasPk for DhtNode {
     fn pk(&self) -> PublicKey {
         self.pk
     }

tox_core/src/dht/kbucket.rs

@@ -66,24 +66,24 @@ impl Distance for PublicKey {
 }
 
 /// Anything that has `PublicKey`.
-pub trait HasPK {
+pub trait HasPk {
     /// `PublicKey`.
     fn pk(&self) -> PublicKey;
 }
 
-impl HasPK for PackedNode {
+impl HasPk for PackedNode {
     fn pk(&self) -> PublicKey {
         self.pk
     }
 }
 
 /// Node that can be stored in a `Kbucket`.
-pub trait KbucketNode : Sized + HasPK {
+pub trait KbucketNode : Sized + HasPk {
     /// The type of nodes that can be added to a `Kbucket`.
-    type NewNode: HasPK;
+    type NewNode: HasPk;
     /// The type of nodes that can be checked if they can be added to a
     /// `Kbucket`.
-    type CheckNode: HasPK;
+    type CheckNode: HasPk;
 
     /// Check if the node can be updated with a new one.
     fn is_outdated(&self, other: &Self::CheckNode) -> bool;
@@ -143,9 +143,9 @@ pub struct Kbucket<Node> {
     pub nodes: Vec<Node>,
 }
 
-impl<Node> Into<Vec<Node>> for Kbucket<Node> {
-    fn into(self) -> Vec<Node> {
-        self.nodes
+impl<Node> From<Kbucket<Node>> for Vec<Node> {
+    fn from(kbucket: Kbucket<Node>) -> Self {
+        kbucket.nodes
     }
 }
 
@@ -154,8 +154,8 @@ pub const KBUCKET_DEFAULT_SIZE: u8 = 8;
 
 impl<NewNode, CheckNode, Node> Kbucket<Node>
 where
-    NewNode: HasPK,
-    CheckNode: HasPK,
+    NewNode: HasPk,
+    CheckNode: HasPk,
     Node: KbucketNode<NewNode = NewNode, CheckNode = CheckNode> + From<NewNode>
 {
     /** Create a new `Kbucket` to store nodes close to the `PublicKey`.

tox_core/src/dht/request_queue.rs

@@ -3,6 +3,7 @@
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use std::time::{Duration, Instant};
+use rand::Rng;
 
 use crate::utils::gen_ping_id;
 use crate::time::*;
@@ -28,9 +29,9 @@ impl<T> RequestQueue<T> {
     }
 
     /// Generate unique non zero request ID.
-    fn generate_ping_id(&self) -> u64 {
+    fn generate_ping_id<R: Rng>(&self, rng: &mut R) -> u64 {
         loop {
-            let ping_id = gen_ping_id();
+            let ping_id = gen_ping_id(rng);
             if !self.ping_map.contains_key(&ping_id) {
                 return ping_id;
             }
@@ -39,8 +40,8 @@ impl<T> RequestQueue<T> {
 
     /// Generate and store unique non zero request ID. Later this request ID can
     /// be verified with `check_ping_id` function.
-    pub fn new_ping_id(&mut self, data: T) -> u64 {
-        let ping_id = self.generate_ping_id();
+    pub fn new_ping_id<R: Rng>(&mut self, rng: &mut R, data: T) -> u64 {
+        let ping_id = self.generate_ping_id(rng);
         self.ping_map.insert(ping_id, (clock_now(), data));
         ping_id
     }
@@ -87,26 +88,22 @@ impl<T> RequestQueue<T> {
 mod tests {
     use super::*;
 
-    use tox_crypto::*;
+    use rand::thread_rng;
 
     #[test]
     fn insert_new_ping_id() {
-        crypto_init().unwrap();
-
         let mut queue = RequestQueue::new(Duration::from_secs(42));
 
-        let ping_id = queue.new_ping_id(7);
+        let ping_id = queue.new_ping_id(&mut thread_rng(), 7);
 
         assert_eq!(queue.ping_map[&ping_id].1, 7);
     }
 
     #[test]
     fn check_ping_id() {
-        crypto_init().unwrap();
-
         let mut queue = RequestQueue::new(Duration::from_secs(42));
 
-        let ping_id = queue.new_ping_id(7);
+        let ping_id = queue.new_ping_id(&mut thread_rng(), 7);
         assert_eq!(queue.check_ping_id(ping_id, |&data| data == 6), None);
         assert_eq!(queue.check_ping_id(ping_id, |&data| data == 7), Some(7));
         assert_eq!(queue.check_ping_id(ping_id, |&data| data == 7), None);
@@ -121,21 +118,17 @@ mod tests {
 
     #[test]
     fn check_ping_id_nonexistent() {
-        crypto_init().unwrap();
-
         let mut queue = RequestQueue::new(Duration::from_secs(42));
 
-        let ping_id = queue.new_ping_id(());
+        let ping_id = queue.new_ping_id(&mut thread_rng(), ());
         assert_eq!(queue.check_ping_id(ping_id.overflowing_add(1).0, |_| true), None);
         assert_eq!(queue.check_ping_id(ping_id.overflowing_sub(1).0, |_| true), None);
     }
 
     #[tokio::test]
     async fn check_ping_id_timed_out() {
-        crypto_init().unwrap();
-
         let mut queue = RequestQueue::new(Duration::from_secs(42));
-        let ping_id = queue.new_ping_id(());
+        let ping_id = queue.new_ping_id(&mut thread_rng(), ());
 
         tokio::time::pause();
 
@@ -148,18 +141,16 @@ mod tests {
 
     #[tokio::test]
     async fn clear_timed_out() {
-        crypto_init().unwrap();
-
         let mut queue = RequestQueue::new(Duration::from_secs(42));
-        let ping_id_1 = queue.new_ping_id(());
+        let ping_id_1 = queue.new_ping_id(&mut thread_rng(), ());
 
         tokio::time::pause();
 
         let now = clock_now();
         let time = queue.ping_map[&ping_id_1].0;
 
         tokio::time::advance((time + Duration::from_secs(21)) - now).await;
-        let ping_id_2 = queue.new_ping_id(());
+        let ping_id_2 = queue.new_ping_id(&mut thread_rng(), ());
 
         tokio::time::advance(Duration::from_secs(43 - 21)).await;
         queue.clear_timed_out();
@@ -171,13 +162,12 @@ mod tests {
 
     #[test]
     fn get_values() {
-        crypto_init().unwrap();
-
         let mut queue = RequestQueue::new(Duration::from_secs(42));
+        let mut rng = &mut thread_rng();
 
-        let _ping_id_1 = queue.new_ping_id(1);
-        let _ping_id_2 = queue.new_ping_id(2);
-        let _ping_id_3 = queue.new_ping_id(3);
+        let _ping_id_1 = queue.new_ping_id(&mut rng, 1);
+        let _ping_id_2 = queue.new_ping_id(&mut rng, 2);
+        let _ping_id_3 = queue.new_ping_id(&mut rng, 3);
 
         let values = queue.get_values().map(|(_, &data)| data).collect::<Vec<_>>();
 

tox_core/src/dht/server/hole_punching.rs

@@ -7,6 +7,7 @@ https://zetok.github.io/tox-spec/#hole-punching
 use std::net::{IpAddr, SocketAddr};
 use std::time::{Duration, Instant};
 use std::collections::HashMap;
+use rand::Rng;
 
 use crate::dht::dht_friend::*;
 use crate::dht::server::*;
@@ -55,15 +56,9 @@ pub struct HolePunching {
     pub ping_id: u64,
 }
 
-impl Default for HolePunching {
-    fn default() -> Self {
-        HolePunching::new()
-    }
-}
-
 impl HolePunching {
     /// Create new `HolePunching` object.
-    pub fn new() -> Self {
+    pub fn new<R: Rng>(rng: &mut R) -> Self {
         HolePunching {
             is_punching_done: true,
             num_punch_tries: 0,
@@ -72,7 +67,7 @@ impl HolePunching {
             last_punching_time: None,
             first_punching_index: 0,
             last_punching_index: 0,
-            ping_id: gen_ping_id(),
+            ping_id: gen_ping_id(rng),
         }
     }
 
@@ -216,21 +211,11 @@ impl HolePunching {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use rand::thread_rng;
 
     #[test]
     fn hole_punch_new() {
-        let hole_punch = HolePunching::new();
-        assert!(hole_punch.is_punching_done);
-        assert_eq!(hole_punch.num_punch_tries, 0);
-        assert!(hole_punch.last_send_ping_time.is_none());
-        assert!(hole_punch.last_punching_time.is_none());
-        assert_eq!(hole_punch.first_punching_index, 0);
-        assert_eq!(hole_punch.last_punching_index, 0);
-    }
-
-    #[test]
-    fn hole_punch_default() {
-        let hole_punch = HolePunching::default();
+        let hole_punch = HolePunching::new(&mut thread_rng());
         assert!(hole_punch.is_punching_done);
         assert_eq!(hole_punch.num_punch_tries, 0);
         assert!(hole_punch.last_send_ping_time.is_none());
@@ -243,7 +228,7 @@ mod tests {
     fn hole_punch_get_common_ip_with_null_addrs() {
         let addrs = vec![];
 
-        let mut hole_punch = HolePunching::new();
+        let mut hole_punch = HolePunching::new(&mut thread_rng());
         hole_punch.is_punching_done = false;
 
         assert!(hole_punch.next_punch_addrs(&addrs).is_empty());
@@ -257,7 +242,7 @@ mod tests {
             "127.0.0.2:33333".parse().unwrap(),
         ];
 
-        let mut hole_punch = HolePunching::new();
+        let mut hole_punch = HolePunching::new(&mut thread_rng());
         hole_punch.is_punching_done = false;
 
         assert!(hole_punch.next_punch_addrs(&addrs).is_empty());
@@ -277,7 +262,7 @@ mod tests {
             "127.0.0.2:55559".parse().unwrap(),
         ];
 
-        let mut hole_punch = HolePunching::new();
+        let mut hole_punch = HolePunching::new(&mut thread_rng());
         hole_punch.is_punching_done = false;
 
         assert!(!hole_punch.next_punch_addrs(&addrs).is_empty());
@@ -297,7 +282,7 @@ mod tests {
             "127.0.0.2:55559".parse().unwrap(),
         ];
 
-        let mut hole_punch = HolePunching::new();
+        let mut hole_punch = HolePunching::new(&mut thread_rng());
         hole_punch.is_punching_done = false;
         hole_punch.num_punch_tries = MAX_NORMAL_PUNCHING_TRIES + 1;