refactor: [torrust#1275] move authentication in udp tracker to core

Author: josecelano

src/packages/udp_tracker_core/connection_cookie.rs

@@ -86,7 +86,7 @@ use zerocopy::AsBytes;
 use crate::shared::crypto::keys::CipherArrayBlowfish;
 
 /// Error returned when there was an error with the connection cookie.
-#[derive(Error, Debug)]
+#[derive(Error, Debug, Clone)]
 pub enum ConnectionCookieError {
     #[error("cookie value is not normal: {not_normal_value}")]
     ValueNotNormal { not_normal_value: f64 },
@@ -123,6 +123,8 @@ pub fn make(fingerprint: u64, issue_at: f64) -> Result<Cookie, ConnectionCookieE
     Ok(zerocopy::FromBytes::read_from(cookie.as_slice()).expect("it should be the same size"))
 }
 
+use std::hash::{DefaultHasher, Hash, Hasher};
+use std::net::SocketAddr;
 use std::ops::Range;
 
 /// Checks if the supplied `connection_cookie` is valid.
@@ -166,6 +168,13 @@ pub fn check(cookie: &Cookie, fingerprint: u64, valid_range: Range<f64>) -> Resu
     Ok(issue_time)
 }
 
+#[must_use]
+pub(crate) fn gen_remote_fingerprint(remote_addr: &SocketAddr) -> u64 {
+    let mut state = DefaultHasher::new();
+    remote_addr.hash(&mut state);
+    state.finish()
+}
+
 mod cookie_builder {
     use cipher::{BlockDecrypt, BlockEncrypt};
     use tracing::instrument;

src/packages/udp_tracker_core/services/announce.rs

@@ -8,19 +8,57 @@
 //! It also sends an [`udp_tracker_core::statistics::event::Event`]
 //! because events are specific for the HTTP tracker.
 use std::net::{IpAddr, SocketAddr};
+use std::ops::Range;
 use std::sync::Arc;
 
 use aquatic_udp_protocol::AnnounceRequest;
 use bittorrent_primitives::info_hash::InfoHash;
 use bittorrent_tracker_core::announce_handler::{AnnounceHandler, PeersWanted};
-use bittorrent_tracker_core::error::AnnounceError;
+use bittorrent_tracker_core::error::{AnnounceError, WhitelistError};
 use bittorrent_tracker_core::whitelist;
 use bittorrent_udp_protocol::peer_builder;
 use torrust_tracker_primitives::core::AnnounceData;
 use torrust_tracker_primitives::peer;
 
+use crate::packages::udp_tracker_core::connection_cookie::{check, gen_remote_fingerprint, ConnectionCookieError};
 use crate::packages::udp_tracker_core::{self};
 
+/// Errors related to announce requests.
+#[derive(thiserror::Error, Debug, Clone)]
+pub enum UdpAnnounceError {
+    /// Error returned when there was an error with the connection cookie.
+    #[error("Connection cookie error: {source}")]
+    ConnectionCookieError { source: ConnectionCookieError },
+
+    /// Error returned when there was an error with the tracker core announce handler.
+    #[error("Tracker core announce error: {source}")]
+    TrackerCoreAnnounceError { source: AnnounceError },
+
+    /// Error returned when there was an error with the tracker core whitelist.
+    #[error("Tracker core whitelist error: {source}")]
+    TrackerCoreWhitelistError { source: WhitelistError },
+}
+
+impl From<ConnectionCookieError> for UdpAnnounceError {
+    fn from(connection_cookie_error: ConnectionCookieError) -> Self {
+        Self::ConnectionCookieError {
+            source: connection_cookie_error,
+        }
+    }
+}
+
+impl From<AnnounceError> for UdpAnnounceError {
+    fn from(announce_error: AnnounceError) -> Self {
+        Self::TrackerCoreAnnounceError { source: announce_error }
+    }
+}
+
+impl From<WhitelistError> for UdpAnnounceError {
+    fn from(whitelist_error: WhitelistError) -> Self {
+        Self::TrackerCoreWhitelistError { source: whitelist_error }
+    }
+}
+
 /// It handles the `Announce` request.
 ///
 /// # Errors
@@ -36,7 +74,17 @@ pub async fn handle_announce(
     announce_handler: &Arc<AnnounceHandler>,
     whitelist_authorization: &Arc<whitelist::authorization::WhitelistAuthorization>,
     opt_udp_stats_event_sender: &Arc<Option<Box<dyn udp_tracker_core::statistics::event::sender::Sender>>>,
-) -> Result<AnnounceData, AnnounceError> {
+    cookie_valid_range: Range<f64>,
+) -> Result<AnnounceData, UdpAnnounceError> {
+    // todo: return a UDP response like the HTTP tracker instead of raw AnnounceData.
+
+    // Authentication
+    check(
+        &request.connection_id,
+        gen_remote_fingerprint(&remote_addr),
+        cookie_valid_range,
+    )?;
+
     let info_hash = request.info_hash.into();
     let remote_client_ip = remote_addr.ip();
 

src/packages/udp_tracker_core/services/scrape.rs

@@ -8,15 +8,53 @@
 //! It also sends an [`udp_tracker_core::statistics::event::Event`]
 //! because events are specific for the UDP tracker.
 use std::net::SocketAddr;
+use std::ops::Range;
 use std::sync::Arc;
 
 use aquatic_udp_protocol::ScrapeRequest;
 use bittorrent_primitives::info_hash::InfoHash;
-use bittorrent_tracker_core::error::ScrapeError;
+use bittorrent_tracker_core::error::{ScrapeError, WhitelistError};
 use bittorrent_tracker_core::scrape_handler::ScrapeHandler;
 use torrust_tracker_primitives::core::ScrapeData;
 
 use crate::packages::udp_tracker_core;
+use crate::packages::udp_tracker_core::connection_cookie::{check, gen_remote_fingerprint, ConnectionCookieError};
+
+/// Errors related to scrape requests.
+#[derive(thiserror::Error, Debug, Clone)]
+pub enum UdpScrapeError {
+    /// Error returned when there was an error with the connection cookie.
+    #[error("Connection cookie error: {source}")]
+    ConnectionCookieError { source: ConnectionCookieError },
+
+    /// Error returned when there was an error with the tracker core scrape handler.
+    #[error("Tracker core scrape error: {source}")]
+    TrackerCoreScrapeError { source: ScrapeError },
+
+    /// Error returned when there was an error with the tracker core whitelist.
+    #[error("Tracker core whitelist error: {source}")]
+    TrackerCoreWhitelistError { source: WhitelistError },
+}
+
+impl From<ConnectionCookieError> for UdpScrapeError {
+    fn from(connection_cookie_error: ConnectionCookieError) -> Self {
+        Self::ConnectionCookieError {
+            source: connection_cookie_error,
+        }
+    }
+}
+
+impl From<ScrapeError> for UdpScrapeError {
+    fn from(scrape_error: ScrapeError) -> Self {
+        Self::TrackerCoreScrapeError { source: scrape_error }
+    }
+}
+
+impl From<WhitelistError> for UdpScrapeError {
+    fn from(whitelist_error: WhitelistError) -> Self {
+        Self::TrackerCoreWhitelistError { source: whitelist_error }
+    }
+}
 
 /// It handles the `Scrape` request.
 ///
@@ -28,7 +66,16 @@ pub async fn handle_scrape(
     request: &ScrapeRequest,
     scrape_handler: &Arc<ScrapeHandler>,
     opt_udp_stats_event_sender: &Arc<Option<Box<dyn udp_tracker_core::statistics::event::sender::Sender>>>,
-) -> Result<ScrapeData, ScrapeError> {
+    cookie_valid_range: Range<f64>,
+) -> Result<ScrapeData, UdpScrapeError> {
+    // todo: return a UDP response like the HTTP tracker instead of raw ScrapeData.
+
+    check(
+        &request.connection_id,
+        gen_remote_fingerprint(&remote_addr),
+        cookie_valid_range,
+    )?;
+
     // Convert from aquatic infohashes
     let info_hashes: Vec<InfoHash> = request.info_hashes.iter().map(|&x| x.into()).collect();
 

src/servers/udp/error.rs

@@ -6,7 +6,8 @@ use derive_more::derive::Display;
 use thiserror::Error;
 use torrust_tracker_located_error::LocatedError;
 
-use crate::packages::udp_tracker_core::connection_cookie::ConnectionCookieError;
+use crate::packages::udp_tracker_core::services::announce::UdpAnnounceError;
+use crate::packages::udp_tracker_core::services::scrape::UdpScrapeError;
 
 #[derive(Display, Debug)]
 #[display(":?")]
@@ -15,18 +16,17 @@ pub struct ConnectionCookie(pub ConnectionId);
 /// Error returned by the UDP server.
 #[derive(Error, Debug)]
 pub enum Error {
-    /// Error returned when there was an error with the connection cookie.
-    #[error("Connection cookie error: {source}")]
-    ConnectionCookieError { source: ConnectionCookieError },
-
+    /// Error returned when the request is invalid.
     #[error("error when phrasing request: {request_parse_error:?}")]
     RequestParseError { request_parse_error: RequestParseError },
 
-    /// Error returned when the domain tracker returns an error.
-    #[error("tracker server error: {source}")]
-    TrackerError {
-        source: LocatedError<'static, dyn std::error::Error + Send + Sync>,
-    },
+    /// Error returned when the domain tracker returns an announce error.
+    #[error("tracker announce error: {source}")]
+    UdpAnnounceError { source: UdpAnnounceError },
+
+    /// Error returned when the domain tracker returns an scrape error.
+    #[error("tracker scrape error: {source}")]
+    UdpScrapeError { source: UdpScrapeError },
 
     /// Error returned from a third-party library (`aquatic_udp_protocol`).
     #[error("internal server error: {message}, {location}")]
@@ -52,10 +52,18 @@ impl From<RequestParseError> for Error {
     }
 }
 
-impl From<ConnectionCookieError> for Error {
-    fn from(connection_cookie_error: ConnectionCookieError) -> Self {
-        Self::ConnectionCookieError {
-            source: connection_cookie_error,
+impl From<UdpAnnounceError> for Error {
+    fn from(udp_announce_error: UdpAnnounceError) -> Self {
+        Self::UdpAnnounceError {
+            source: udp_announce_error,
+        }
+    }
+}
+
+impl From<UdpScrapeError> for Error {
+    fn from(udp_scrape_error: UdpScrapeError) -> Self {
+        Self::UdpScrapeError {
+            source: udp_scrape_error,
         }
     }
 }

src/servers/udp/handlers/announce.rs

@@ -14,10 +14,8 @@ use torrust_tracker_configuration::Core;
 use tracing::{instrument, Level};
 use zerocopy::network_endian::I32;
 
-use crate::packages::udp_tracker_core::connection_cookie::check;
 use crate::packages::udp_tracker_core::{self};
 use crate::servers::udp::error::Error;
-use crate::servers::udp::handlers::gen_remote_fingerprint;
 
 /// It handles the `Announce` request. Refer to [`Announce`](crate::servers::udp#announce)
 /// request for more information.
@@ -43,27 +41,16 @@ pub async fn handle_announce(
 
     tracing::trace!("handle announce");
 
-    // todo: move authentication to `udp_tracker_core::services::announce::handle_announce`
-
-    check(
-        &request.connection_id,
-        gen_remote_fingerprint(&remote_addr),
-        cookie_valid_range,
-    )
-    .map_err(|e| (e.into(), request.transaction_id))?;
-
     let response = udp_tracker_core::services::announce::handle_announce(
         remote_addr,
         request,
         announce_handler,
         whitelist_authorization,
         opt_udp_stats_event_sender,
+        cookie_valid_range,
     )
     .await
-    .map_err(|e| Error::TrackerError {
-        source: (Arc::new(e) as Arc<dyn std::error::Error + Send + Sync>).into(),
-    })
-    .map_err(|e| (e, request.transaction_id))?;
+    .map_err(|e| (e.into(), request.transaction_id))?;
 
     // todo: extract `build_response` function.
 
@@ -213,15 +200,15 @@ mod tests {
             use mockall::predicate::eq;
             use torrust_tracker_configuration::Core;
 
-            use crate::packages::udp_tracker_core::connection_cookie::make;
+            use crate::packages::udp_tracker_core::connection_cookie::{gen_remote_fingerprint, make};
             use crate::packages::{self, udp_tracker_core};
             use crate::servers::udp::handlers::announce::tests::announce_request::AnnounceRequestBuilder;
+            use crate::servers::udp::handlers::handle_announce;
             use crate::servers::udp::handlers::tests::{
                 initialize_core_tracker_services_for_default_tracker_configuration,
                 initialize_core_tracker_services_for_public_tracker, sample_cookie_valid_range, sample_ipv4_socket_address,
                 sample_issue_time, MockUdpStatsEventSender, TorrentPeerBuilder,
             };
-            use crate::servers::udp::handlers::{gen_remote_fingerprint, handle_announce};
 
             #[tokio::test]
             async fn an_announced_peer_should_be_added_to_the_tracker() {
@@ -447,13 +434,13 @@ mod tests {
 
                 use aquatic_udp_protocol::{InfoHash as AquaticInfoHash, PeerId as AquaticPeerId};
 
-                use crate::packages::udp_tracker_core::connection_cookie::make;
+                use crate::packages::udp_tracker_core::connection_cookie::{gen_remote_fingerprint, make};
                 use crate::servers::udp::handlers::announce::tests::announce_request::AnnounceRequestBuilder;
+                use crate::servers::udp::handlers::handle_announce;
                 use crate::servers::udp::handlers::tests::{
                     initialize_core_tracker_services_for_public_tracker, sample_cookie_valid_range, sample_issue_time,
                     TorrentPeerBuilder,
                 };
-                use crate::servers::udp::handlers::{gen_remote_fingerprint, handle_announce};
 
                 #[tokio::test]
                 async fn the_peer_ip_should_be_changed_to_the_external_ip_in_the_tracker_configuration_if_defined() {
@@ -520,15 +507,15 @@ mod tests {
             use mockall::predicate::eq;
             use torrust_tracker_configuration::Core;
 
-            use crate::packages::udp_tracker_core::connection_cookie::make;
+            use crate::packages::udp_tracker_core::connection_cookie::{gen_remote_fingerprint, make};
             use crate::packages::{self, udp_tracker_core};
             use crate::servers::udp::handlers::announce::tests::announce_request::AnnounceRequestBuilder;
+            use crate::servers::udp::handlers::handle_announce;
             use crate::servers::udp::handlers::tests::{
                 initialize_core_tracker_services_for_default_tracker_configuration,
                 initialize_core_tracker_services_for_public_tracker, sample_cookie_valid_range, sample_ipv6_remote_addr,
                 sample_issue_time, MockUdpStatsEventSender, TorrentPeerBuilder,
             };
-            use crate::servers::udp::handlers::{gen_remote_fingerprint, handle_announce};
 
             #[tokio::test]
             async fn an_announced_peer_should_be_added_to_the_tracker() {
@@ -776,12 +763,12 @@ mod tests {
                 use mockall::predicate::eq;
 
                 use crate::packages::udp_tracker_core;
-                use crate::packages::udp_tracker_core::connection_cookie::make;
+                use crate::packages::udp_tracker_core::connection_cookie::{gen_remote_fingerprint, make};
                 use crate::servers::udp::handlers::announce::tests::announce_request::AnnounceRequestBuilder;
+                use crate::servers::udp::handlers::handle_announce;
                 use crate::servers::udp::handlers::tests::{
                     sample_cookie_valid_range, sample_issue_time, MockUdpStatsEventSender, TrackerConfigurationBuilder,
                 };
-                use crate::servers::udp::handlers::{gen_remote_fingerprint, handle_announce};
 
                 #[tokio::test]
                 async fn the_peer_ip_should_be_changed_to_the_external_ip_in_the_tracker_configuration() {

src/servers/udp/handlers/connect.rs

@@ -6,8 +6,7 @@ use aquatic_udp_protocol::{ConnectRequest, ConnectResponse, Response};
 use tracing::{instrument, Level};
 
 use crate::packages::udp_tracker_core;
-use crate::packages::udp_tracker_core::connection_cookie::make;
-use crate::servers::udp::handlers::gen_remote_fingerprint;
+use crate::packages::udp_tracker_core::connection_cookie::{gen_remote_fingerprint, make};
 
 /// It handles the `Connect` request. Refer to [`Connect`](crate::servers::udp#connect)
 /// request for more information.

src/servers/udp/handlers/error.rs

@@ -9,9 +9,8 @@ use uuid::Uuid;
 use zerocopy::network_endian::I32;
 
 use crate::packages::udp_tracker_core;
-use crate::packages::udp_tracker_core::connection_cookie::check;
+use crate::packages::udp_tracker_core::connection_cookie::{check, gen_remote_fingerprint};
 use crate::servers::udp::error::Error;
-use crate::servers::udp::handlers::gen_remote_fingerprint;
 use crate::servers::udp::UDP_TRACKER_LOG_TARGET;
 
 #[allow(clippy::too_many_arguments)]