aria2-core 0.3.9

aria2-rust core download engine: multi-protocol segmented downloads, rate limiting, configuration, session persistence, and BitTorrent seeding
Documentation
use super::pkcs12::empty_pkcs12_password;
use super::test_support::{
    TEST_CHAIN_PEM, TEST_PRIVATE_KEY_PEM, TEST_ROOT_PEM, TLS12_ONLY, start_https_fixture,
    start_https_fixture_with_versions, test_client_builder,
};
use super::{ClientTlsConfig, apply};
use bytes::Bytes;

#[test]
fn accepts_an_unconfigured_identity() {
    crate::http::client_pool::ensure_rustls_provider();
    let builder = apply(reqwest::Client::builder(), &ClientTlsConfig::default())
        .expect("missing optional client identity should be valid");
    builder.build().expect("plain client should build");
}

#[test]
fn marks_non_default_tls_settings_as_custom_client_requirements() {
    assert!(!ClientTlsConfig::default().requires_custom_client());
    assert!(
        ClientTlsConfig {
            check_certificate: false,
            ..ClientTlsConfig::default()
        }
        .requires_custom_client()
    );
    assert!(
        ClientTlsConfig {
            ca_certificate: Some("ca.pem".into()),
            ..ClientTlsConfig::default()
        }
        .requires_custom_client()
    );
    assert!(
        ClientTlsConfig {
            min_tls_version: Some("TLSv1.3".into()),
            ..ClientTlsConfig::default()
        }
        .requires_custom_client()
    );
}

#[test]
fn rejects_unknown_minimum_tls_version() {
    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            min_tls_version: Some("TLSv9".into()),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("unknown minimum TLS versions must be rejected");
    assert!(
        error
            .to_string()
            .contains("Unsupported minimum TLS version")
    );
}

#[test]
fn accepts_disabled_certificate_verification() {
    crate::http::client_pool::ensure_rustls_provider();
    let builder = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            check_certificate: false,
            ..ClientTlsConfig::default()
        },
    )
    .expect("disabled certificate verification should be configurable");
    builder
        .build()
        .expect("client with disabled certificate verification should build");
}

#[test]
fn reports_missing_ca_certificate_file() {
    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            ca_certificate: Some("missing-ca.pem".into()),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("missing CA files must be rejected");
    assert!(error.to_string().contains("Failed to read CA certificate"));
}

#[test]
fn reports_invalid_ca_certificate_pem() {
    let directory = tempfile::tempdir().expect("create temporary CA directory");
    let ca = directory.path().join("ca.pem");
    std::fs::write(&ca, b"not a CA certificate").expect("write invalid CA fixture");

    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            ca_certificate: Some(ca.to_string_lossy().into_owned()),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("invalid CA PEM must be rejected");
    assert!(error.to_string().contains("Invalid CA certificate"));
}

#[test]
fn rejects_a_non_pkcs12_certificate_when_private_key_is_omitted() {
    let directory = tempfile::tempdir().expect("create temporary identity directory");
    let certificate = directory.path().join("client.pem");
    std::fs::write(&certificate, b"not a PKCS#12 archive").expect("write invalid PKCS#12 fixture");

    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            certificate: Some(certificate.to_string_lossy().into_owned()),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("non-PKCS#12 certificates without a key must be rejected");
    assert!(
        error
            .to_string()
            .contains("Invalid empty-password PKCS#12 client identity")
    );
}

#[test]
fn accepts_a_modern_empty_password_pkcs12_identity() {
    crate::http::client_pool::ensure_rustls_provider();
    let archive = include_bytes!("../testdata/modern_empty_password_aes256.p12");
    let pfx = p12_q3::PFX::parse(archive).expect("modern PKCS#12 fixture should parse");
    assert!(matches!(
        pfx.mac_data
            .as_ref()
            .map(|mac_data| &mac_data.mac.digest_algorithm),
        Some(p12_q3::AlgorithmIdentifier::Sha2)
    ));
    let password = empty_pkcs12_password(&pfx)
        .expect("modern PKCS#12 fixture should verify with an empty password");
    let bags = pfx
        .bags(&password)
        .expect("modern PKCS#12 fixture bags should decrypt");
    let key_bag = bags
        .iter()
        .find_map(|bag| match &bag.bag {
            p12_q3::SafeBagKind::Pkcs8ShroudedKeyBag(key_bag) => Some(key_bag),
            _ => None,
        })
        .expect("modern PKCS#12 fixture should contain a private key");
    let p12_q3::AlgorithmIdentifier::Pbes2(params) = &key_bag.encryption_algorithm else {
        panic!("modern PKCS#12 fixture should use PBES2");
    };
    assert!(matches!(
        params.key_derivation_function.as_ref(),
        p12_q3::AlgorithmIdentifier::Pbkdf2(params)
            if matches!(
                params.prf.as_ref(),
                p12_q3::AlgorithmIdentifier::HmacWithSha256
            )
    ));
    assert!(matches!(
        params.encryption_scheme.as_ref(),
        p12_q3::AlgorithmIdentifier::AesCbcPad(iv) if iv.len() == 16
    ));

    let directory = tempfile::tempdir().expect("create temporary identity directory");
    let certificate = directory.path().join("modern-client.p12");
    std::fs::write(&certificate, archive).expect("write modern PKCS#12 fixture");

    let builder = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            certificate: Some(certificate.to_string_lossy().into_owned()),
            ..ClientTlsConfig::default()
        },
    )
    .expect("modern empty-password PKCS#12 identity should configure the client");
    builder
        .build()
        .expect("modern PKCS#12 client identity should build");
}

#[test]
fn rejects_an_unpaired_private_key() {
    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            private_key: Some("client.key".into()),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("private key without a certificate must be rejected");
    assert!(error.to_string().contains("requires certificate"));
}

#[test]
fn reports_missing_certificate_file() {
    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            certificate: Some("missing-client.pem".into()),
            private_key: Some("missing-client.key".into()),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("missing certificate files must be rejected");
    assert!(
        error
            .to_string()
            .contains("Failed to read client certificate")
    );
}

#[test]
fn reports_invalid_certificate_and_key_pem() {
    let directory = tempfile::tempdir().expect("create temporary identity directory");
    let certificate = directory.path().join("client.pem");
    let private_key = directory.path().join("client.key");
    std::fs::write(&certificate, b"not a certificate").expect("write invalid certificate fixture");
    std::fs::write(&private_key, b"not a private key").expect("write invalid key fixture");

    let error = apply(
        reqwest::Client::builder(),
        &ClientTlsConfig {
            certificate: certificate.to_string_lossy().into_owned().into(),
            private_key: private_key.to_string_lossy().into_owned().into(),
            ..ClientTlsConfig::default()
        },
    )
    .expect_err("invalid PEM must be rejected");
    assert!(
        error
            .to_string()
            .contains("Invalid client certificate/private key")
    );
}

#[tokio::test]
async fn custom_ca_verifies_a_live_https_server() {
    let fixture = start_https_fixture(false).await;
    let directory = tempfile::tempdir().expect("create temporary CA directory");
    let ca_path = directory.path().join("root.pem");
    std::fs::write(&ca_path, TEST_ROOT_PEM).expect("write test root certificate");

    let config = ClientTlsConfig {
        ca_certificate: Some(ca_path.to_string_lossy().into_owned()),
        ..ClientTlsConfig::default()
    };
    let client = apply(test_client_builder(fixture.address), &config)
        .expect("custom CA should configure the client")
        .build()
        .expect("custom CA client should build");

    let response = client
        .get(fixture.url())
        .send()
        .await
        .expect("custom CA should verify the live server");
    assert_eq!(response.status(), reqwest::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("read HTTPS response"),
        Bytes::from_static(b"tls-ok")
    );
}

#[tokio::test]
async fn disabled_certificate_verification_reaches_a_live_https_server() {
    let fixture = start_https_fixture(false).await;
    let config = ClientTlsConfig {
        check_certificate: false,
        ..ClientTlsConfig::default()
    };
    let client = apply(test_client_builder(fixture.address), &config)
        .expect("disabled verification should configure the client")
        .build()
        .expect("disabled verification client should build");

    let response = client
        .get(fixture.url())
        .send()
        .await
        .expect("disabled verification should reach the live server");
    assert_eq!(response.status(), reqwest::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("read HTTPS response"),
        Bytes::from_static(b"tls-ok")
    );
}

#[tokio::test]
async fn minimum_tls_version_rejects_an_older_live_server_protocol() {
    let fixture = start_https_fixture_with_versions(false, TLS12_ONLY).await;
    let config = ClientTlsConfig {
        min_tls_version: Some("TLSv1.3".into()),
        ..ClientTlsConfig::default()
    };
    let client = apply(test_client_builder(fixture.address), &config)
        .expect("minimum TLS version should configure the client")
        .build()
        .expect("minimum TLS version client should build");

    let error = client
        .get(fixture.url())
        .send()
        .await
        .expect_err("TLS 1.3 minimum must reject a TLS 1.2-only server");
    let _ = error;
}

#[tokio::test]
async fn client_certificate_and_private_key_complete_live_mutual_tls() {
    let fixture = start_https_fixture(true).await;
    let directory = tempfile::tempdir().expect("create temporary identity directory");
    let ca_path = directory.path().join("root.pem");
    let certificate_path = directory.path().join("client-chain.pem");
    let private_key_path = directory.path().join("client.key");
    std::fs::write(&ca_path, TEST_ROOT_PEM).expect("write test root certificate");
    std::fs::write(&certificate_path, TEST_CHAIN_PEM).expect("write test client certificate chain");
    std::fs::write(&private_key_path, TEST_PRIVATE_KEY_PEM).expect("write test client private key");

    let config = ClientTlsConfig {
        ca_certificate: Some(ca_path.to_string_lossy().into_owned()),
        certificate: Some(certificate_path.to_string_lossy().into_owned()),
        private_key: Some(private_key_path.to_string_lossy().into_owned()),
        ..ClientTlsConfig::default()
    };
    let client = apply(test_client_builder(fixture.address), &config)
        .expect("client identity should configure the client")
        .build()
        .expect("mutual TLS client should build");

    let response = client
        .get(fixture.url())
        .send()
        .await
        .expect("client identity should complete mutual TLS");
    assert_eq!(response.status(), reqwest::StatusCode::OK);
    assert_eq!(
        response.bytes().await.expect("read HTTPS response"),
        Bytes::from_static(b"tls-ok")
    );
}