chore(sodium): update to sodiumoxide 0.2.2

Author: Roman Proskuryakov

Cargo.toml

@@ -33,7 +33,7 @@ bytes = "0.4"
 byteorder = "1"
 futures = "0.1"
 log = "0.4"
-sodiumoxide = { git = "https://github.com/sodiumoxide/sodiumoxide.git", rev = "baf88e5" }
+sodiumoxide = "0.2.2"
 nom = "3.2"
 cookie-factory = "0.2"
 get_if_addrs = "0.5"

examples/dht_server.rs

@@ -54,6 +54,10 @@ fn bind_socket(addr: SocketAddr) -> UdpSocket {
 fn main() {
     env_logger::init();
 
+    if crypto_init().is_err() {
+        panic!("Crypto initialization failed.");
+    }
+
     let (server_pk, server_sk) = gen_keypair();
 
     // Create a channel for server to communicate with network

src/toxcore/binary_io.rs

@@ -101,6 +101,10 @@ macro_rules! encode_decode_test (
     ($test:ident, $value:expr) => (
         #[test]
         fn $test() {
+            use crate::toxcore::crypto_core::*;
+
+            crypto_init().unwrap();
+
             let value = $value;
             let mut buf = [0; 1024 * 1024];
             let (_, size) = value.to_bytes((&mut buf, 0)).unwrap();

src/toxcore/crypto_core.rs

@@ -11,14 +11,24 @@ use crate::toxcore::binary_io::*;
 
 // TODO: check if `#[inline]` is actually useful
 
+/** Run before using crypto.
 
-/// Initialize sodiumoxide
-#[deprecated(
-    since = "0.0.10",
-    note = "libsodium is automatically initialized by sodiumoxide now."
-)]
+Runs [`sodiumoxide::init()`](../../../sodiumoxide/fn.init.html).
+
+Returns `Ok` on success, `Err` otherwise.
+
+E.g.
+
+```
+use ::tox::toxcore::crypto_core::crypto_init;
+
+crypto_init().unwrap();
+// second call should yield same result
+crypto_init().unwrap();
+```
+*/
 pub fn crypto_init() -> Result<(), ()> {
-    Ok(())
+    ::sodiumoxide::init()
 }
 
 
@@ -241,6 +251,7 @@ pub mod tests {
     // test comparing random public keys
     // testing since it would appear that sodiumoxide doesn't do testing for it
     fn public_key_cmp_test_random() {
+        crypto_init().unwrap();
         let (alice_publickey, _alice_secretkey) = gen_keypair();
         let (bob_publickey, _bob_secretkey) = gen_keypair();
 
@@ -254,6 +265,7 @@ pub mod tests {
 
     #[test]
     fn random_u32_test() {
+        crypto_init().unwrap();
         let a = random_u32();
         let b = random_u32();
         assert_ne!(a, 0);
@@ -265,6 +277,7 @@ pub mod tests {
 
     #[test]
     fn random_u64_test() {
+        crypto_init().unwrap();
         let a = random_u64();
         let b = random_u64();
         assert_ne!(a, 0);
@@ -275,6 +288,7 @@ pub mod tests {
 
     #[test]
     fn random_usize_test() {
+        crypto_init().unwrap();
         let a = random_usize();
         let b = random_usize();
         assert_ne!(a, 0);
@@ -285,12 +299,14 @@ pub mod tests {
 
     #[test]
     fn random_limit_usize_test() {
+        crypto_init().unwrap();
         let n = random_limit_usize(7);
         assert!(n < 7);
     }
 
     #[test]
     fn public_key_valid_test() {
+        crypto_init().unwrap();
         let (pk, _) = gen_keypair();
         assert!(public_key_valid(&pk));
 
@@ -305,6 +321,7 @@ pub mod tests {
     // test uses "bare" functions provided by `sodiumoxide`, with an exception
     // of the tested function
     fn encrypt_precompute_test() {
+        crypto_init().unwrap();
         let (alice_pk, alice_sk) = gen_keypair();
         let (bob_pk, bob_sk) = gen_keypair();
 
@@ -326,6 +343,7 @@ pub mod tests {
     // test uses "bare" functions provided by `sodiumoxide`, with an "exception"
     // of the tested function
     fn encrypt_data_symmetric_test() {
+        crypto_init().unwrap();
         let (alice_pk, alice_sk) = gen_keypair();
         let (bob_pk, bob_sk) = gen_keypair();
 
@@ -356,6 +374,7 @@ pub mod tests {
     // test uses "bare" functions provided by `sodiumoxide`, with an exception
     // of the tested function
     fn decrypt_data_symmetric_test() {
+        crypto_init().unwrap();
         let (alice_pk, alice_sk) = gen_keypair();
         let (bob_pk, bob_sk) = gen_keypair();
 
@@ -376,6 +395,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_test_zero_plus_one() {
+        crypto_init().unwrap();
         let cmp_nonce = Nonce([0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 1]);
@@ -387,6 +407,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_test_0xf_plus_one() {
+        crypto_init().unwrap();
         let cmp_nonce = Nonce([0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0x10]);
@@ -400,6 +421,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_test_0xff_plus_one() {
+        crypto_init().unwrap();
         let cmp_nonce = Nonce([0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 1, 0]);
@@ -413,6 +435,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_test_0xff_max() {
+        crypto_init().unwrap();
         let cmp_nonce = Nonce([0; NONCEBYTES]);
         let mut nonce = Nonce([0xff; NONCEBYTES]);
         increment_nonce(&mut nonce);
@@ -421,6 +444,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_test_random() {
+        crypto_init().unwrap();
         let mut nonce = gen_nonce();
         let cmp_nonce = nonce;
         increment_nonce(&mut nonce);
@@ -431,6 +455,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_number_test_zero_plus_0xff00() {
+        crypto_init().unwrap();
         let cmp_nonce = Nonce([0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0xff, 0]);
@@ -442,6 +467,7 @@ pub mod tests {
 
     #[test]
     fn increment_nonce_number_test_0xff0000_plus_0x011000() {
+        crypto_init().unwrap();
         let cmp_nonce = Nonce([0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, 1, 0, 0x10, 0]);

src/toxcore/dht/codec.rs

@@ -175,6 +175,7 @@ mod tests {
 
     #[test]
     fn encode_decode() {
+        crypto_init().unwrap();
         let test_packets = vec![
             Packet::PingRequest(PingRequest {
                 pk: gen_keypair().0,
@@ -318,6 +319,7 @@ mod tests {
 
     #[test]
     fn decode_encrypted_packet_incomplete() {
+        crypto_init().unwrap();
         let stats = Stats::new();
         let mut codec = DhtCodec::new(stats);
         let mut buf = BytesMut::new();
@@ -336,6 +338,7 @@ mod tests {
 
     #[test]
     fn decode_encrypted_packet_error() {
+        crypto_init().unwrap();
         let stats = Stats::new();
         let mut codec = DhtCodec::new(stats);
         let mut buf = BytesMut::new();
@@ -350,6 +353,7 @@ mod tests {
 
     #[test]
     fn decode_encrypted_packet_zero_length() {
+        crypto_init().unwrap();
         let stats = Stats::new();
         let mut codec = DhtCodec::new(stats);
         let mut buf = BytesMut::new();
@@ -362,6 +366,7 @@ mod tests {
 
     #[test]
     fn encode_packet_too_big() {
+        crypto_init().unwrap();
         let stats = Stats::new();
         let mut codec = DhtCodec::new(stats);
         let mut buf = BytesMut::new();
@@ -378,6 +383,7 @@ mod tests {
 
     #[test]
     fn codec_is_clonable() {
+        crypto_init().unwrap();
         let stats = Stats::new();
         let codec = DhtCodec::new(stats);
         let _codec_c = codec.clone();

src/toxcore/dht/daemon_state.rs

@@ -121,6 +121,7 @@ mod tests {
 
     #[test]
     fn daemon_state_serialize_deserialize() {
+        crypto_init().unwrap();
         let (pk, sk) = gen_keypair();
         let (tx, rx) = mpsc::channel(1);
         let alice = Server::new(tx, pk, sk);

src/toxcore/dht/dht_friend.rs

@@ -106,6 +106,7 @@ mod tests {
 
     #[test]
     fn addr_is_unknown() {
+        crypto_init().unwrap();
         let pk = gen_keypair().0;
         let mut friend = DhtFriend::new(pk);
 
@@ -117,6 +118,7 @@ mod tests {
 
     #[test]
     fn addr_is_known() {
+        crypto_init().unwrap();
         let pk = gen_keypair().0;
         let mut friend = DhtFriend::new(pk);
 
@@ -130,6 +132,7 @@ mod tests {
 
     #[test]
     fn get_returned_addrs() {
+        crypto_init().unwrap();
         let pk = gen_keypair().0;
         let mut friend = DhtFriend::new(pk);
 
@@ -162,6 +165,7 @@ mod tests {
 
     #[test]
     fn get_returned_addrs_timed_out() {
+        crypto_init().unwrap();
         let pk = gen_keypair().0;
         let mut friend = DhtFriend::new(pk);
 
@@ -194,6 +198,7 @@ mod tests {
 
     #[test]
     fn can_and_try_add_to_close() {
+        crypto_init().unwrap();
         let pk = PublicKey([0; PUBLICKEYBYTES]);
         let mut friend = DhtFriend::new(pk);
 

src/toxcore/dht/dht_node.rs

@@ -236,6 +236,7 @@ mod tests {
 
     #[test]
     fn dht_node_clonable() {
+        crypto_init().unwrap();
         let pn = PackedNode {
             pk: gen_keypair().0,
             saddr: "127.0.0.1:33445".parse().unwrap(),

src/toxcore/dht/kbucket.rs

@@ -562,6 +562,7 @@ mod tests {
 
     #[test]
     fn kbucket_get_node() {
+        crypto_init().unwrap();
         let (pk, _) = gen_keypair();
         let mut kbucket = Kbucket::<DhtNode>::new(KBUCKET_DEFAULT_SIZE);
 
@@ -580,6 +581,7 @@ mod tests {
 
     #[test]
     fn kbucket_get_node_mut() {
+        crypto_init().unwrap();
         let (pk, _) = gen_keypair();
         let mut kbucket = Kbucket::<DhtNode>::new(KBUCKET_DEFAULT_SIZE);
 

src/toxcore/dht/ktree.rs

@@ -220,6 +220,7 @@ mod tests {
 
     #[test]
     fn ktree_new() {
+        crypto_init().unwrap();
         let pk = gen_keypair().0;
         let ktree = Ktree::new(&pk);
         assert_eq!(pk, ktree.pk);
@@ -332,6 +333,7 @@ mod tests {
 
     #[test]
     fn ktree_contains() {
+        crypto_init().unwrap();
         let (pk, _) = gen_keypair();
         let mut ktree = Ktree::new(&pk);
 
@@ -351,6 +353,7 @@ mod tests {
 
     #[test]
     fn ktree_can_add() {
+        crypto_init().unwrap();
         let (pk, _) = gen_keypair();
         let mut ktree = Ktree::new(&pk);
 
@@ -416,6 +419,7 @@ mod tests {
 
     #[test]
     fn ktree_is_all_discarded() {
+        crypto_init().unwrap();
         let (pk, _) = gen_keypair();
         let mut ktree = Ktree::new(&pk);