fix: correctly decoding peer_id from http announce request

Author: mickvandijke

src/common.rs

@@ -126,15 +126,23 @@ impl<'v> serde::de::Visitor<'v> for InfoHashVisitor {
 }
 
 #[derive(PartialEq, Eq, Hash, Clone, Debug, PartialOrd, Ord)]
-pub struct PeerId(pub String);
+pub struct PeerId(pub [u8; 20]);
+
+impl PeerId {
+    pub fn to_string(&self) -> String {
+        let mut buffer = [0u8; 20];
+        let bytes_out = binascii::bin2hex(&self.0, &mut buffer).ok().unwrap();
+        String::from(std::str::from_utf8(bytes_out).unwrap())
+    }
+}
 
 impl PeerId {
     pub fn get_client_name(&self) -> Option<&'static str> {
-        if self.0.as_bytes()[0] == b'M' {
+        if self.0[0] == b'M' {
             return Some("BitTorrent");
         }
-        if self.0.as_bytes()[0] == b'-' {
-            let name = match &self.0.as_bytes()[1..3] {
+        if self.0[0] == b'-' {
+            let name = match &self.0[1..3] {
                 b"AG" => "Ares",
                 b"A~" => "Ares",
                 b"AR" => "Arctic",
@@ -211,9 +219,9 @@ impl Serialize for PeerId {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: serde::Serializer, {
-        let buff_size = self.0.as_bytes().len() * 2;
+        let buff_size = self.0.len() * 2;
         let mut tmp: Vec<u8> = vec![0; buff_size];
-        binascii::bin2hex(&self.0.as_bytes(), &mut tmp).unwrap();
+        binascii::bin2hex(&self.0, &mut tmp).unwrap();
         let id = std::str::from_utf8(&tmp).ok();
 
         #[derive(Serialize)]

src/torrust_http_tracker/errors.rs

@@ -9,6 +9,9 @@ pub enum ServerError {
     #[error("info_hash is either missing or invalid")]
     InvalidInfoHash,
 
+    #[error("peer_id is either missing or invalid")]
+    InvalidPeerId,
+
     #[error("could not find remote address")]
     AddressNotFound,
 

src/torrust_http_tracker/filters.rs

@@ -3,7 +3,7 @@ use std::net::{IpAddr, SocketAddr};
 use std::str::FromStr;
 use std::sync::Arc;
 use warp::{Filter, reject, Rejection};
-use crate::{InfoHash, MAX_SCRAPE_TORRENTS, TorrentTracker};
+use crate::{InfoHash, MAX_SCRAPE_TORRENTS, PeerId, TorrentTracker};
 use crate::key_manager::AuthKey;
 use crate::torrust_http_tracker::{AnnounceRequest, AnnounceRequestQuery, ScrapeRequest, ServerError, WebResult};
 
@@ -44,6 +44,49 @@ async fn info_hashes(raw_query: String) -> WebResult<Vec<InfoHash>> {
     }
 }
 
+/// Check for PeerId
+pub fn with_peer_id() -> impl Filter<Extract = (PeerId,), Error = Rejection> + Clone {
+    warp::filters::query::raw()
+        .and_then(peer_id)
+}
+
+/// Parse PeerId from raw query string
+async fn peer_id(raw_query: String) -> WebResult<PeerId> {
+    // put all query params in a vec
+    let split_raw_query: Vec<&str> = raw_query.split("&").collect();
+
+    let mut peer_id: Option<PeerId> = None;
+
+    for v in split_raw_query {
+        // look for the peer_id param
+        if v.contains("peer_id") {
+            // get raw percent_encoded peer_id
+            let raw_peer_id = v.split("=").collect::<Vec<&str>>()[1];
+
+            // decode peer_id
+            let peer_id_bytes = percent_encoding::percent_decode_str(raw_peer_id).collect::<Vec<u8>>();
+
+            // peer_id must be 20 bytes
+            if peer_id_bytes.len() > 20 {
+                return Err(reject::custom(ServerError::InvalidPeerId));
+            }
+
+            // clone peer_id_bytes into fixed length array
+            let mut byte_arr: [u8; 20] = Default::default();
+            byte_arr.clone_from_slice(peer_id_bytes.as_slice());
+
+            peer_id = Some(PeerId(byte_arr));
+            break;
+        }
+    }
+
+    if peer_id.is_none() {
+        Err(reject::custom(ServerError::InvalidPeerId))
+    } else {
+        Ok(peer_id.unwrap())
+    }
+}
+
 /// Pass Arc<TorrentTracker> along
 pub fn with_auth_key() -> impl Filter<Extract = (Option<AuthKey>,), Error = Infallible> + Clone {
     warp::path::param::<String>()
@@ -59,13 +102,14 @@ pub fn with_auth_key() -> impl Filter<Extract = (Option<AuthKey>,), Error = Infa
 pub fn with_announce_request() -> impl Filter<Extract = (AnnounceRequest,), Error = Rejection> + Clone {
     warp::filters::query::query::<AnnounceRequestQuery>()
         .and(with_info_hash())
+        .and(with_peer_id())
         .and(warp::addr::remote())
         .and(warp::header::optional::<String>("X-Forwarded-For"))
         .and_then(announce_request)
 }
 
 /// Parse AnnounceRequest from raw AnnounceRequestQuery, InfoHash and Option<SocketAddr>
-async fn announce_request(announce_request_query: AnnounceRequestQuery, info_hashes: Vec<InfoHash>, remote_addr: Option<SocketAddr>, forwarded_for: Option<String>) -> WebResult<AnnounceRequest> {
+async fn announce_request(announce_request_query: AnnounceRequestQuery, info_hashes: Vec<InfoHash>, peer_id: PeerId, remote_addr: Option<SocketAddr>, forwarded_for: Option<String>) -> WebResult<AnnounceRequest> {
     if remote_addr.is_none() { return Err(reject::custom(ServerError::AddressNotFound)) }
 
     // get first forwarded ip
@@ -76,14 +120,14 @@ async fn announce_request(announce_request_query: AnnounceRequestQuery, info_has
                 .and_then(|ip_str| IpAddr::from_str(ip_str).ok())
         }
     };
-    
+
     Ok(AnnounceRequest {
         info_hash: info_hashes[0],
         peer_addr: remote_addr.unwrap(),
         forwarded_ip,
         downloaded: announce_request_query.downloaded,
         uploaded: announce_request_query.uploaded,
-        peer_id: announce_request_query.peer_id,
+        peer_id,
         port: announce_request_query.port,
         left: announce_request_query.left,
         event: announce_request_query.event,

src/torrust_http_tracker/handlers.rs

@@ -96,7 +96,7 @@ pub async fn handle_error(r: Rejection) -> std::result::Result<impl Reply, Infal
 /// Send announce response
 fn send_announce_response(announce_request: &AnnounceRequest, torrent_stats: TorrentStats, peers: Vec<TorrentPeer>, interval: u32) -> WebResult<impl Reply> {
     let http_peers: Vec<Peer> = peers.iter().map(|peer| Peer {
-        peer_id: peer.peer_id.0.clone(),
+        peer_id: peer.peer_id.to_string(),
         ip: peer.peer_addr.ip(),
         port: peer.peer_addr.port()
     }).collect();

src/torrust_http_tracker/request.rs

@@ -1,14 +1,13 @@
 use std::net::{IpAddr, SocketAddr};
 use serde::{Deserialize};
-use crate::InfoHash;
+use crate::{InfoHash, PeerId};
 use crate::torrust_http_tracker::Bytes;
 
 #[derive(Deserialize)]
 pub struct AnnounceRequestQuery {
     pub downloaded: Bytes,
     pub uploaded: Bytes,
     pub key: String,
-    pub peer_id: String,
     pub port: u16,
     pub left: Bytes,
     pub event: Option<String>,
@@ -21,7 +20,7 @@ pub struct AnnounceRequest {
     pub forwarded_ip: Option<IpAddr>,
     pub downloaded: Bytes,
     pub uploaded: Bytes,
-    pub peer_id: String,
+    pub peer_id: PeerId,
     pub port: u16,
     pub left: Bytes,
     pub event: Option<String>,

src/tracker.rs

@@ -57,10 +57,8 @@ impl TorrentPeer {
     pub fn from_udp_announce_request(announce_request: &aquatic_udp_protocol::AnnounceRequest, remote_ip: IpAddr, host_opt_ip: Option<IpAddr>) -> Self {
         let peer_addr = TorrentPeer::peer_addr_from_ip_and_port_and_opt_host_ip(remote_ip, host_opt_ip, announce_request.port.0);
 
-        let peer_id = String::from_utf8_lossy(&announce_request.peer_id.0).parse().unwrap_or("unknown".to_string());
-
         TorrentPeer {
-            peer_id: PeerId(peer_id),
+            peer_id: PeerId(announce_request.peer_id.0),
             peer_addr,
             updated: std::time::Instant::now(),
             uploaded: announce_request.bytes_uploaded,
@@ -73,9 +71,6 @@ impl TorrentPeer {
     pub fn from_http_announce_request(announce_request: &AnnounceRequest, remote_ip: IpAddr, host_opt_ip: Option<IpAddr>) -> Self {
         let peer_addr = TorrentPeer::peer_addr_from_ip_and_port_and_opt_host_ip(remote_ip, host_opt_ip, announce_request.port);
 
-        let max_string_size = announce_request.peer_id.len().clamp(0, 40);
-        let peer_id = announce_request.peer_id[..max_string_size].to_string();
-
         let event: AnnounceEvent = if let Some(event) = &announce_request.event {
             match event.as_ref() {
                 "started" => AnnounceEvent::Started,
@@ -88,7 +83,7 @@ impl TorrentPeer {
         };
 
         TorrentPeer {
-            peer_id: PeerId(peer_id),
+            peer_id: announce_request.peer_id.clone(),
             peer_addr,
             updated: std::time::Instant::now(),
             uploaded: NumberOfBytes(announce_request.uploaded as i64),