torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
use std::sync::Arc;

use rustls::pki_types::ServerName;
use tokio::io::AsyncWriteExt;
use tokio_rustls::TlsConnector;

use crate::error::{Error, Result};
use crate::tracker::http::{http_body, parse_tracker_response, AnnounceResponse};
use crate::tracker::policy::{ensure_http_ok, resolve_tracker_socket};

pub async fn scrape_https(
    host: &str,
    port: u16,
    request_target: &str,
    block_private: bool,
) -> Result<std::collections::HashMap<[u8; 20], crate::tracker::ScrapeStats>> {
    crate::security::reject_http_token("tracker host", host)
        .map_err(|err| Error::Tracker(err.to_string()))?;
    crate::security::reject_http_token("tracker request", request_target)
        .map_err(|err| Error::Tracker(err.to_string()))?;
    let addr = resolve_tracker_socket(host, port, block_private)?;
    let stream = crate::net::connect_pinned(addr).await?;
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(rustls_root_store())
        .with_no_client_auth();
    let connector = TlsConnector::from(Arc::new(config));
    let domain = ServerName::try_from(host.to_string())
        .map_err(|_| Error::Tracker(format!("invalid tracker host: {host}")))?;
    let mut tls = connector
        .connect(domain, stream)
        .await
        .map_err(|err| Error::Tracker(format!("tracker tls handshake failed: {err}")))?;

    let request = format!(
        "GET {request_target} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\n\r\n"
    );
    tls.write_all(request.as_bytes()).await?;
    let response =
        crate::net::read_capped(&mut tls, crate::security::MAX_TRACKER_HTTP_RESPONSE).await
            .map_err(|err| Error::Tracker(err.to_string()))?;
    ensure_http_ok(&response)?;
    let body = http_body(&response)?;
    crate::tracker::scrape::parse_scrape_response(body)
}

pub async fn announce_https(
    host: &str,
    port: u16,
    _path: &str,
    request_target: &str,
    block_private: bool,
) -> Result<AnnounceResponse> {
    crate::security::reject_http_token("tracker host", host)
        .map_err(|err| Error::Tracker(err.to_string()))?;
    crate::security::reject_http_token("tracker request", request_target)
        .map_err(|err| Error::Tracker(err.to_string()))?;
    let addr = resolve_tracker_socket(host, port, block_private)?;
    let stream = crate::net::connect_pinned(addr).await?;
    let config = rustls::ClientConfig::builder()
        .with_root_certificates(rustls_root_store())
        .with_no_client_auth();
    let connector = TlsConnector::from(Arc::new(config));
    let domain = ServerName::try_from(host.to_string())
        .map_err(|_| Error::Tracker(format!("invalid tracker host: {host}")))?;
    let mut tls = connector
        .connect(domain, stream)
        .await
        .map_err(|err| Error::Tracker(format!("tracker tls handshake failed: {err}")))?;

    let request = format!(
        "GET {request_target} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\n\r\n"
    );
    tls.write_all(request.as_bytes()).await?;
    let response =
        crate::net::read_capped(&mut tls, crate::security::MAX_TRACKER_HTTP_RESPONSE).await
            .map_err(|err| Error::Tracker(err.to_string()))?;
    ensure_http_ok(&response)?;
    let body = http_body(&response)?;
    parse_tracker_response(body)
}

fn rustls_root_store() -> rustls::RootCertStore {
    let mut store = rustls::RootCertStore::empty();
    store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
    store
}