Re-implement connection ID generation for UDP tracker

Cargo.toml

@@ -18,6 +18,13 @@ opt-level = 3
 lto = "fat"
 strip = true
 
+[dev-dependencies]
+criterion = "0.3"
+
+[[bench]]
+name = "generate_connection_id"
+harness = false
+
 [dependencies]
 tokio = { version = "1.7", features = ["rt-multi-thread", "net", "sync", "macros", "signal"] }
 
@@ -28,6 +35,10 @@ serde_with = "2.0.0"
 hex = "0.4.3"
 percent-encoding = "2.1.0"
 binascii = "0.1"
+blake3 = "1.3.1"
+cipher = "0.4.3"
+blowfish = "0.9.1"
+byteorder = "1.4.3"
 
 openssl = { version = "0.10.41", features = ["vendored"] }
 
@@ -52,3 +63,4 @@ async-trait = "0.1.52"
 
 aquatic_udp_protocol = "0.2.0"
 uuid = { version = "1.1.2", features = ["v4"] }
+arraytools = "0.1.5"

benches/generate_connection_id.rs

@@ -0,0 +1,38 @@
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+use aquatic_udp_protocol::ConnectionId;
+use criterion::{Criterion, criterion_group, criterion_main};
+use torrust_tracker::{udp::connection_id::get_connection_id, protocol::clock::current_timestamp};
+
+fn get_connection_id_old(current_time: u64, port: u16) -> ConnectionId {
+    let time_i64 = (current_time / 3600) as i64;
+
+    ConnectionId((time_i64 | port as i64) << 36)
+}
+
+pub fn benchmark_generate_id_with_time_and_port(bench: &mut Criterion) {
+    let remote_address = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 117);
+    let current_time = current_timestamp();
+
+    bench.bench_function("generate_id_with_time_and_port", |b| {
+        b.iter(|| {
+            // Inner closure, the actual test
+            let _ = get_connection_id_old(current_time, remote_address.port());
+        })
+    });
+}
+
+pub fn benchmark_generate_id_with_hashed_time_and_ip_and_port_and_salt(bench: &mut Criterion) {
+    let remote_address = SocketAddr::from(SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 117));
+    let current_time = current_timestamp();
+    let server_secret = [0;32];
+
+    bench.bench_function("generate_id_with_hashed_time_and_ip_and_port_and_salt", |b| {
+        b.iter(|| {
+            // Inner closure, the actual test
+            let _ = get_connection_id(&server_secret, &remote_address, current_time);
+        })
+    });
+}
+
+criterion_group!(benches, benchmark_generate_id_with_time_and_port, benchmark_generate_id_with_hashed_time_and_ip_and_port_and_salt);
+criterion_main!(benches);

src/api/server.rs

@@ -1,3 +1,47 @@
+//! # API Server
+//!
+//! HTTP server for the tracker HTTP API.
+//!
+//! Endpoint example: 
+//!
+//! GET /api/torrent/:info_hash
+//!
+//! Get torrent details.
+//!
+//! ```s
+//! curl -s http://127.0.0.1:1212/api/torrent/4beb7001cb833968582c67f55cc59dcc6c8d3fe5?token=MyAccessToken | jq
+//! ```
+//!
+//! ```json
+//! {
+//!   "info_hash": "4beb7001cb833968582c67f55cc59dcc6c8d3fe5",
+//!   "seeders": 1,
+//!   "completed": 0,
+//!   "leechers": 0,
+//!   "peers": [
+//!     {
+//!       "peer_id": {
+//!         "id": "2d7142343431302d7358376d33786d2877674179",
+//!         "client": "qBittorrent"
+//!       },
+//!       "peer_addr": "192.168.1.88:17548",
+//!       "updated": 385,
+//!       "uploaded": 0,
+//!       "downloaded": 0,
+//!       "left": 0,
+//!       "event": "None"
+//!     }
+//!   ]
+//! }
+//! ```
+//!
+//! | Parameter | Description |
+//! |-----------|-------------|
+//! | info_hash | The info_hash of the torrent. |
+//!
+//! The `info_hash.peers.updated` are the number of milliseconds since the last update.
+//!
+
 use std::cmp::min;
 use std::collections::{HashMap, HashSet};
 use std::net::SocketAddr;

src/protocol/clock.rs

@@ -0,0 +1,22 @@
+use std::time::SystemTime;
+
+pub type UnixTime = u64;
+
+/// A Clock which uses the UNIX time.
+pub trait UnixClock {
+    fn now(&self) -> UnixTime;
+}
+
+/// A Clock which uses the operating system to determine the time.
+pub struct SystemUnixClock;
+
+impl UnixClock for SystemUnixClock {
+    fn now(&self) -> UnixTime {
+        SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs()
+    }
+}
+
+/// It returns the current timestamp using the system clock.
+pub fn current_timestamp() -> UnixTime {
+    SystemUnixClock.now()
+}

src/protocol/mod.rs

@@ -1,2 +1,2 @@
 pub mod common;
-pub mod utils;
+pub mod clock;

src/tracker/key.rs

@@ -4,9 +4,8 @@ use rand::{Rng, thread_rng};
 use rand::distributions::Alphanumeric;
 use serde::Serialize;
 
-use crate::protocol::utils::current_time;
-
 use crate::AUTH_KEY_LENGTH;
+use crate::protocol::clock::current_timestamp;
 
 pub fn generate_auth_key(seconds_valid: u64) -> AuthKey {
     let key: String = thread_rng()
@@ -19,12 +18,12 @@ pub fn generate_auth_key(seconds_valid: u64) -> AuthKey {
 
     AuthKey {
         key,
-        valid_until: Some(current_time() + seconds_valid),
+        valid_until: Some(current_timestamp() + seconds_valid),
     }
 }
 
 pub fn verify_auth_key(auth_key: &AuthKey) -> Result<(), Error> {
-    let current_time = current_time();
+    let current_time = current_timestamp();
     if auth_key.valid_until.is_none() { return Err(Error::KeyInvalid); }
     if auth_key.valid_until.unwrap() < current_time { return Err(Error::KeyExpired); }
 

src/tracker/mod.rs

@@ -1,6 +1,7 @@
 pub mod tracker;
 pub mod statistics;
 pub mod peer;
+pub mod serializer;
 pub mod torrent;
 pub mod key;
 pub mod mode;

src/tracker/peer.rs

@@ -5,9 +5,9 @@ use serde;
 use serde::{Serialize};
 
 use crate::protocol::common::{NumberOfBytesDef, AnnounceEventDef};
-use crate::protocol::utils::ser_instant;
 use crate::http::AnnounceRequest;
 use crate::PeerId;
+use crate::tracker::serializer::ser_instant;
 
 #[derive(PartialEq, Eq, Debug, Clone, Serialize)]
 pub struct TorrentPeer {

src/tracker/serializer.rs

@@ -0,0 +1,47 @@
+/// Serializer for `std::time::Instant` type.
+/// Before serializing, it converts the instant to time elapse since that instant in milliseconds.
+///
+/// You can use it like this:
+///
+/// ```text
+/// #[serde(serialize_with = "ser_instant")]
+/// pub updated: std::time::Instant,
+/// ```
+///
+pub fn ser_instant<S: serde::Serializer>(inst: &std::time::Instant, ser: S) -> Result<S::Ok, S::Error> {
+    ser.serialize_u64(inst.elapsed().as_millis() as u64)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{time::Instant};
+    use serde::Serialize;
+
+    #[warn(unused_imports)]
+    use super::ser_instant;
+
+    #[derive(PartialEq, Eq, Debug, Clone, Serialize)]
+    struct S {
+        #[serde(serialize_with = "ser_instant")]
+        pub time: Instant,
+    }
+
+    #[test]
+    fn instant_types_can_be_serialized_as_elapsed_time_since_that_instant_in_milliseconds() {
+
+        use std::{thread, time};
+
+        let t1 = Instant::now();
+
+        let s = S { time: t1 };
+
+        // Sleep 10 milliseconds
+        let ten_millis = time::Duration::from_millis(10);
+        thread::sleep(ten_millis);
+
+        let json_serialized_value = serde_json::to_string(&s).unwrap();
+
+        // Json contains time duration since t1 instant in milliseconds
+        assert_eq!(json_serialized_value, r#"{"time":10}"#);
+    }
+}

src/udp/connection/client_id.rs

@@ -0,0 +1,104 @@
+//! ClientId is a unique ID for the UDP tracker client.
+//! Currently implemented with a hash of the socket, i.e the IP and port.
+use std::hash::Hash;
+use std::hash::Hasher;
+use std::net::SocketAddr;
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct ClientId {
+    value: [u8; 4],
+}
+
+pub trait Make<T: Default + Hasher> {
+    fn new(socket: &SocketAddr) -> Self;
+
+    fn hash(socket: &SocketAddr) -> [u8;8] {
+        let mut hasher = T::default();
+        socket.hash(&mut hasher);
+
+        hasher.finish().to_le_bytes()
+    }
+}
+
+impl<T: Default + Hasher> Make<T> for ClientId {
+    fn new(socket: &SocketAddr) -> Self {
+        let hash = <ClientId as Make<T>>::hash(socket);
+
+        let mut truncated_hash: [u8; 4] = [0u8; 4];
+        truncated_hash.copy_from_slice(&hash[..4]);
+
+        ClientId {
+            value: truncated_hash,
+        }
+    }
+}
+
+impl ClientId {
+    /// It generates the ID with a previously generated value
+    pub fn from_bytes(bytes: &[u8]) -> Self {
+        let mut client_id = ClientId {
+            value: [0u8; 4]
+        };
+        client_id.value.copy_from_slice(bytes);
+        client_id
+    }
+
+    pub fn to_bytes(&self) -> [u8; 4] {
+        let bytes: [u8; 4] = self.value;
+        bytes
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{net::{IpAddr, Ipv4Addr, SocketAddr}, collections::hash_map::DefaultHasher};
+
+    use super::{ClientId, Make};
+
+    #[test]
+    fn it_should_be_a_hash_of_the_socket() {
+        let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let id: ClientId = Make::<DefaultHasher>::new(&socket);
+
+        assert_eq!(id.value, [213, 195, 130, 185]);
+    }
+
+    #[test]
+    fn id_should_be_converted_to_a_byte_array() {
+        let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let id: ClientId = Make::<DefaultHasher>::new(&socket);
+
+        assert_eq!(id.to_bytes(), [213, 195, 130, 185]);
+    }
+
+    #[test]
+    fn id_should_be_instantiate_from_a_previously_generated_value() {
+        let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let id: ClientId = Make::<DefaultHasher>::new(&socket);
+        let bytes = id.to_bytes();
+
+        assert_eq!(ClientId::from_bytes(&bytes), id);
+    }
+
+    #[test]
+    fn it_should_be_unique_with_different_socket_ips() {
+        let socket_1 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let socket_2 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 2)), 8080);
+
+        assert_ne!(
+            <ClientId as Make::<DefaultHasher>>::new(&socket_1),
+            <ClientId as Make::<DefaultHasher>>::new(&socket_2)
+        );
+    }
+
+    #[test]
+    fn it_should_be_unique_with_different_socket_ports() {
+        let socket_1 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+        let socket_2 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8081);
+
+        assert_ne!(
+            <ClientId as Make::<DefaultHasher>>::new(&socket_1),
+            <ClientId as Make::<DefaultHasher>>::new(&socket_2)
+        );
+    }
+}