aria2-core 0.3.13

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
use std::io::BufReader;
use std::sync::Arc;

use crate::error::{Aria2Error, FatalError, Result};

use super::ClientTlsConfig;

impl ClientTlsConfig {
    pub(crate) fn websocket_connector(&self) -> Result<tokio_tungstenite::Connector> {
        let provider = Arc::new(rustls::crypto::ring::default_provider());
        let versions = match self.min_tls_version.as_deref() {
            None | Some("TLSv1.1") | Some("TLSv1.2") => {
                [&rustls::version::TLS13, &rustls::version::TLS12][..].to_vec()
            }
            Some("TLSv1.3") => vec![&rustls::version::TLS13],
            Some(version) => {
                return Err(config_error(format!(
                    "Unsupported minimum TLS version '{version}'"
                )));
            }
        };
        let builder = rustls::ClientConfig::builder_with_provider(provider.clone())
            .with_protocol_versions(&versions)
            .map_err(|error| config_error(format!("Invalid TLS version configuration: {error}")))?;

        let mut roots = rustls::RootCertStore::empty();
        roots.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
        if let Some(path) = self.ca_certificate.as_deref() {
            let bytes = std::fs::read(path).map_err(|error| {
                config_error(format!("Failed to read CA certificate '{path}': {error}"))
            })?;
            let mut reader = BufReader::new(bytes.as_slice());
            let certificates = rustls_pemfile::certs(&mut reader)
                .collect::<std::result::Result<Vec<_>, _>>()
                .map_err(|error| {
                    config_error(format!("Invalid CA certificate '{path}': {error}"))
                })?;
            if certificates.is_empty() {
                return Err(config_error(format!(
                    "Invalid CA certificate '{path}': no certificates found"
                )));
            }
            for certificate in certificates {
                roots.add(certificate).map_err(|error| {
                    config_error(format!("Invalid CA certificate '{path}': {error}"))
                })?;
            }
        }

        let builder = if self.check_certificate {
            builder.with_root_certificates(roots)
        } else {
            builder
                .dangerous()
                .with_custom_certificate_verifier(Arc::new(SkipServerCertificateVerification {
                    provider,
                }))
        };

        let config = match (self.certificate.as_deref(), self.private_key.as_deref()) {
            (Some(certificate), Some(private_key)) => {
                let certificate_pem = std::fs::read(certificate).map_err(|error| {
                    config_error(format!(
                        "Failed to read client certificate '{certificate}': {error}"
                    ))
                })?;
                let private_key_pem = std::fs::read(private_key).map_err(|error| {
                    config_error(format!(
                        "Failed to read client private key '{private_key}': {error}"
                    ))
                })?;
                let mut certificate_reader = BufReader::new(certificate_pem.as_slice());
                let certificates = rustls_pemfile::certs(&mut certificate_reader)
                    .collect::<std::result::Result<Vec<_>, _>>()
                    .map_err(|error| {
                        config_error(format!(
                            "Invalid client certificate '{certificate}': {error}"
                        ))
                    })?;
                let mut key_reader = BufReader::new(private_key_pem.as_slice());
                let private_key = rustls_pemfile::private_key(&mut key_reader)
                    .map_err(|error| {
                        config_error(format!(
                            "Invalid client private key '{private_key}': {error}"
                        ))
                    })?
                    .ok_or_else(|| {
                        config_error(format!(
                            "Invalid client private key '{private_key}': no key found"
                        ))
                    })?;
                builder.with_client_auth_cert(certificates, private_key)
            }
            (Some(certificate), None) => {
                let identity = super::pkcs12::load_empty_password_identity_pem(certificate)?;
                let mut reader = BufReader::new(identity.as_slice());
                let certificates = rustls_pemfile::certs(&mut reader)
                    .collect::<std::result::Result<Vec<_>, _>>()
                    .map_err(|error| {
                        config_error(format!("Invalid client identity '{certificate}': {error}"))
                    })?;
                let mut reader = BufReader::new(identity.as_slice());
                let private_key = rustls_pemfile::private_key(&mut reader)
                    .map_err(|error| {
                        config_error(format!("Invalid client identity '{certificate}': {error}"))
                    })?
                    .ok_or_else(|| {
                        config_error(format!(
                            "Invalid client identity '{certificate}': no private key found"
                        ))
                    })?;
                builder.with_client_auth_cert(certificates, private_key)
            }
            (None, Some(_)) => {
                return Err(config_error("private-key requires certificate".to_owned()));
            }
            (None, None) => Ok(builder.with_no_client_auth()),
        }
        .map_err(|error| config_error(format!("Invalid TLS client identity: {error}")))?;

        Ok(tokio_tungstenite::Connector::Rustls(Arc::new(config)))
    }
}

#[derive(Debug)]
struct SkipServerCertificateVerification {
    provider: Arc<rustls::crypto::CryptoProvider>,
}

impl rustls::client::danger::ServerCertVerifier for SkipServerCertificateVerification {
    fn verify_server_cert(
        &self,
        _end_entity: &rustls::pki_types::CertificateDer<'_>,
        _intermediates: &[rustls::pki_types::CertificateDer<'_>],
        _server_name: &rustls::pki_types::ServerName<'_>,
        _ocsp_response: &[u8],
        _now: rustls::pki_types::UnixTime,
    ) -> std::result::Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
        Ok(rustls::client::danger::ServerCertVerified::assertion())
    }

    fn verify_tls12_signature(
        &self,
        message: &[u8],
        certificate: &rustls::pki_types::CertificateDer<'_>,
        signed: &rustls::DigitallySignedStruct,
    ) -> std::result::Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
        rustls::crypto::verify_tls12_signature(
            message,
            certificate,
            signed,
            &self.provider.signature_verification_algorithms,
        )
    }

    fn verify_tls13_signature(
        &self,
        message: &[u8],
        certificate: &rustls::pki_types::CertificateDer<'_>,
        signed: &rustls::DigitallySignedStruct,
    ) -> std::result::Result<rustls::client::danger::HandshakeSignatureValid, rustls::Error> {
        rustls::crypto::verify_tls13_signature(
            message,
            certificate,
            signed,
            &self.provider.signature_verification_algorithms,
        )
    }

    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
        self.provider
            .signature_verification_algorithms
            .supported_schemes()
    }
}

fn config_error(message: String) -> Aria2Error {
    Aria2Error::Fatal(FatalError::Config(message))
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use futures::{SinkExt, StreamExt};
    use serde_json::Value;
    use tokio::net::{TcpListener, TcpStream};
    use tokio_rustls::TlsAcceptor;
    use tokio_tungstenite::tungstenite::Message;

    use super::super::test_support::{
        TEST_CHAIN_PEM, TEST_HOST, TEST_PRIVATE_KEY_PEM, TEST_ROOT_PEM, pem_certificates,
        pem_private_key,
    };
    use super::ClientTlsConfig;

    #[tokio::test]
    async fn websocket_tracker_uses_task_custom_ca() {
        let directory = tempfile::tempdir().expect("create CA fixture directory");
        let ca_path = directory.path().join("tracker-root.pem");
        std::fs::write(&ca_path, TEST_ROOT_PEM).expect("write custom tracker CA");

        let listener = TcpListener::bind("127.0.0.1:0")
            .await
            .expect("bind local WSS tracker");
        let address = listener.local_addr().expect("local tracker address");
        let server_config = rustls::ServerConfig::builder()
            .with_no_client_auth()
            .with_single_cert(
                pem_certificates(TEST_CHAIN_PEM),
                pem_private_key(TEST_PRIVATE_KEY_PEM),
            )
            .expect("configure local WSS certificate");
        let acceptor = TlsAcceptor::from(Arc::new(server_config));
        let server = tokio::spawn(async move {
            let (stream, _) = listener.accept().await.expect("accept tracker client");
            let stream = acceptor
                .accept(stream)
                .await
                .expect("accept TLS connection");
            let mut websocket = tokio_tungstenite::accept_async(stream)
                .await
                .expect("accept WebSocket upgrade");
            let Some(Ok(Message::Text(request))) = websocket.next().await else {
                panic!("tracker should receive an announce message");
            };
            let request: Value = serde_json::from_str(&request).expect("decode announce JSON");
            let info_hash = request["info_hash"]
                .as_str()
                .expect("announce includes info_hash");
            websocket
                .send(Message::Text(
                    serde_json::json!({
                        "action": "announce",
                        "info_hash": info_hash,
                        "peers": [{"ip": "192.0.2.9", "port": 6881}]
                    })
                    .to_string()
                    .into(),
                ))
                .await
                .expect("send tracker response");
        });

        let connector = ClientTlsConfig {
            ca_certificate: Some(ca_path.to_string_lossy().into_owned()),
            ..ClientTlsConfig::default()
        }
        .websocket_connector()
        .expect("build task-configured WebSocket TLS connector");
        let stream = TcpStream::connect(address)
            .await
            .expect("connect to local tracker");
        let response =
            aria2_protocol::bittorrent::tracker::websocket::announce_over_stream_with_connector(
                stream,
                &format!("wss://{TEST_HOST}:{}/announce", address.port()),
                &aria2_protocol::bittorrent::tracker::websocket::WebSocketAnnounceRequest {
                    info_hash: &[0x31; 20],
                    peer_id: &[0x52; 20],
                    downloaded: 0,
                    left: 1,
                    uploaded: 0,
                    numwant: 10,
                    port: 6881,
                    event: Some("started"),
                },
                std::time::Duration::from_secs(5),
                Some(connector),
            )
            .await
            .expect("custom root should validate the local WSS tracker");

        assert_eq!(response.peers, vec!["192.0.2.9:6881".parse().unwrap()]);
        server.await.expect("local WSS tracker task");
    }
}