aria2-protocol 0.3.10

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use super::*;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener;

fn options<'a>(user_agent: &'a str) -> HttpConnectOptions<'a> {
    HttpConnectOptions {
        target_host: "example.com",
        target_port: 443,
        user_agent,
        username: None,
        password: None,
        preemptive_basic_auth: false,
        write_timeout: Duration::from_secs(2),
        read_timeout: Duration::from_secs(2),
    }
}

#[test]
fn proxy_auth_body_framing_requires_unambiguous_http_boundaries() {
    assert_eq!(
        proxy_response_body_framing(&[(
            "Transfer-Encoding".to_string(),
            "gzip, chunked".to_string(),
        )])
        .unwrap(),
        ProxyResponseBodyFraming::Chunked
    );
    assert!(matches!(
        proxy_response_body_framing(&[(
            "Transfer-Encoding".to_string(),
            "chunked, gzip".to_string(),
        )]),
        Err(HttpConnectError::InvalidResponse(_))
    ));
    assert!(matches!(
        proxy_response_body_framing(&[(
            "Transfer-Encoding".to_string(),
            "chunked, chunked".to_string(),
        )]),
        Err(HttpConnectError::InvalidResponse(_))
    ));
    assert!(matches!(
        proxy_response_body_framing(&[
            ("Content-Length".to_string(), "1".to_string()),
            ("content-length".to_string(), "2".to_string()),
        ]),
        Err(HttpConnectError::InvalidResponse(_))
    ));
    assert!(matches!(
        proxy_response_body_framing(&[("Content-Length".to_string(), "not-a-length".to_string(),)]),
        Err(HttpConnectError::InvalidResponse(_))
    ));
    assert!(matches!(
        proxy_response_body_framing(&[]),
        Err(HttpConnectError::InvalidResponse(_))
    ));
    assert_eq!(
        proxy_response_body_framing(&[("Content-Length".to_string(), "1, 1".to_string(),)])
            .unwrap(),
        ProxyResponseBodyFraming::ContentLength(1)
    );
}

#[tokio::test]
async fn skips_informational_responses_and_preserves_tunnel_bytes() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let mut request = [0; 1024];
        let length = stream.read(&mut request).await.unwrap();
        assert!(request[..length].starts_with(b"CONNECT example.com:443 HTTP/1.1\r\n"));
        stream
            .write_all(
                b"HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 Connection Established\r\n\r\nTLS",
            )
            .await
            .unwrap();
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    establish_connect_tunnel(&mut stream, &options("test-agent"))
        .await
        .unwrap();
    let mut tunneled = [0; 3];
    stream.read_exact(&mut tunneled).await.unwrap();
    assert_eq!(&tunneled, b"TLS");
    server.await.unwrap();
}

#[tokio::test]
async fn invalid_user_agent_is_rejected_before_connect_request_is_written() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let mut request = [0; 256];
        let result =
            tokio::time::timeout(Duration::from_millis(100), stream.read(&mut request)).await;
        assert!(result.is_err(), "invalid request must not be written");
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let options = HttpConnectOptions {
        user_agent: "agent\r\nX-Injected: yes",
        ..options("unused")
    };
    assert!(matches!(
        establish_connect_tunnel(&mut stream, &options).await,
        Err(HttpConnectError::InvalidRequestField("User-Agent"))
    ));
    server.await.unwrap();
}

#[tokio::test]
async fn challenge_authentication_is_sent_only_after_407() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let mut request = [0; 2048];
        let length = stream.read(&mut request).await.unwrap();
        assert!(
            !request[..length]
                .windows(b"Proxy-Authorization:".len())
                .any(|window| window == b"Proxy-Authorization:")
        );
        stream
                .write_all(
                    b"HTTP/1.1 407 Proxy Authentication Required\r\nProxy-Authenticate: Basic realm=\"test\"\r\nContent-Length: 1\r\n\r\nx",
                )
                .await
                .unwrap();
        let length = stream.read(&mut request).await.unwrap();
        assert!(
            request[..length]
                .windows(b"Proxy-Authorization: Basic dXNlcjpwYXNz\r\n".len())
                .any(|window| window == b"Proxy-Authorization: Basic dXNlcjpwYXNz\r\n")
        );
        stream
            .write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n")
            .await
            .unwrap();
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let options = HttpConnectOptions {
        username: Some("user"),
        password: Some("pass"),
        ..options("test-agent")
    };
    establish_connect_tunnel(&mut stream, &options)
        .await
        .unwrap();
    server.await.unwrap();
}

#[tokio::test]
async fn unframed_407_stops_before_authenticated_retry() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let mut request = [0; 2048];
        let length = stream.read(&mut request).await.unwrap();
        assert!(request[..length].starts_with(b"CONNECT example.com:443 HTTP/1.1\r\n"));
        stream
            .write_all(
                b"HTTP/1.1 407 Proxy Authentication Required\r\nProxy-Authenticate: Basic realm=\"test\"\r\n\r\n",
            )
            .await
            .unwrap();

        let mut retry = [0; 2048];
        assert!(
            tokio::time::timeout(Duration::from_millis(100), stream.read(&mut retry))
                .await
                .is_err(),
            "an unframed 407 must not trigger an authenticated retry"
        );
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let options = HttpConnectOptions {
        username: Some("user"),
        password: Some("pass"),
        ..options("test-agent")
    };
    let result = establish_connect_tunnel(&mut stream, &options).await;
    assert!(matches!(
        result,
        Err(HttpConnectError::InvalidResponse(message))
            if message.contains("no body framing")
    ));
    server.await.unwrap();
}

#[tokio::test]
async fn proxy_auth_body_drain_preserves_bytes_after_content_length() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        stream.write_all(b"xNEXT").await.unwrap();
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let headers = vec![("content-length".to_string(), "1".to_string())];
    consume_response_body(&mut stream, &headers, Duration::from_secs(2))
        .await
        .unwrap();
    let mut remaining = [0; 4];
    stream.read_exact(&mut remaining).await.unwrap();
    assert_eq!(&remaining, b"NEXT");
    server.await.unwrap();
}

#[tokio::test]
async fn proxy_auth_body_drain_uses_configured_read_timeout() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        tokio::time::sleep(Duration::from_millis(100)).await;
        stream.write_all(b"x").await.unwrap();
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let headers = vec![("content-length".to_string(), "1".to_string())];
    let result = consume_response_body(&mut stream, &headers, Duration::from_millis(10)).await;

    assert!(matches!(result, Err(HttpConnectError::Timeout)));
    server.await.unwrap();
}

#[tokio::test]
async fn proxy_auth_chunked_body_drain_preserves_bytes_after_body() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        stream
            .write_all(b"1\r\nx\r\n0\r\nTrailer: done\r\n\r\nNEXT")
            .await
            .unwrap();
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let headers = vec![("transfer-encoding".to_string(), "chunked".to_string())];
    consume_response_body(&mut stream, &headers, Duration::from_secs(2))
        .await
        .unwrap();
    let mut remaining = [0; 4];
    stream.read_exact(&mut remaining).await.unwrap();
    assert_eq!(&remaining, b"NEXT");
    server.await.unwrap();
}

#[tokio::test]
async fn preemptive_basic_auth_is_sent_on_the_first_request_when_enabled() {
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let mut request = [0; 2048];
        let length = stream.read(&mut request).await.unwrap();
        assert!(
            request[..length]
                .windows(b"Proxy-Authorization: Basic dXNlcjpwYXNz\r\n".len())
                .any(|window| window == b"Proxy-Authorization: Basic dXNlcjpwYXNz\r\n")
        );
        stream
            .write_all(b"HTTP/1.1 200 Connection Established\r\n\r\n")
            .await
            .unwrap();
    });

    let mut stream = TcpStream::connect(address).await.unwrap();
    let options = HttpConnectOptions {
        username: Some("user"),
        password: Some("pass"),
        preemptive_basic_auth: true,
        ..options("test-agent")
    };
    establish_connect_tunnel(&mut stream, &options)
        .await
        .unwrap();
    server.await.unwrap();
}

#[test]
fn md5_sess_connect_response_uses_client_nonce_in_session_hash() {
    let challenge = DigestChallenge::parse(
            r#"Digest realm="testrealm@host.com", nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", qop="auth", algorithm=MD5-sess"#,
        )
        .unwrap();
    let response = DigestResponse::compute_with_cnonce(
        "Mufasa",
        "Circle Of Life",
        "CONNECT",
        "target.example.com:443",
        &challenge,
        1,
        "aria2rustcnonce",
    )
    .to_header_value();

    assert!(response.contains("cnonce=\"aria2rustcnonce\""));
    assert!(response.contains("response=\"3ac03d7149007bfa5959a930308906e0\""));
}

#[test]
fn compatibility_policy_prefers_digest_and_uses_retry_count() {
    let headers = vec![
        (
            "proxy-authenticate".to_string(),
            "Basic realm=\"test\"".to_string(),
        ),
        (
            "proxy-authenticate".to_string(),
            "Digest realm=\"test\", nonce=\"n1\", qop=\"auth\"".to_string(),
        ),
    ];
    let auth = challenged_authentication(
        "user",
        "pass",
        &headers,
        "example.com:443",
        2,
        &HttpConnectRetryPolicy {
            max_auth_retries: 2,
            prefer_digest: true,
            fallback_to_basic: true,
            proxy_connection_keep_alive: true,
        },
    )
    .unwrap();

    assert!(auth.starts_with("Digest "));
    assert!(auth.contains("nc=00000002"));
}

#[test]
fn compatibility_policy_falls_back_to_basic_for_unknown_challenge() {
    let headers = vec![("proxy-authenticate".to_string(), "NTLM".to_string())];
    let auth = challenged_authentication(
        "user",
        "pass",
        &headers,
        "example.com:443",
        1,
        &HttpConnectRetryPolicy {
            fallback_to_basic: true,
            ..HttpConnectRetryPolicy::default()
        },
    )
    .unwrap();

    assert_eq!(auth, "Basic dXNlcjpwYXNz");
}