wreq-rb 0.3.0

data/vendor/wreq/src/util.rs

@@ -0,0 +1,122 @@
+use std::{fmt, fmt::Write};
+
+use bytes::Bytes;
+
+use crate::header::{Entry, HeaderMap, HeaderValue, OccupiedEntry};
+
+pub(crate) fn basic_auth<U, P>(username: U, password: Option<P>) -> HeaderValue
+where
+    U: fmt::Display,
+    P: fmt::Display,
+{
+    let encoded = {
+        let mut buf = b"Basic ".to_vec();
+        let mut buf_str = String::with_capacity(32);
+        let _ = write!(buf_str, "{username}:");
+        if let Some(password) = password {
+            let _ = write!(buf_str, "{password}");
+        }
+
+        let encoded = boring2::base64::encode_block(buf_str.as_bytes());
+        buf.extend(encoded.into_bytes());
+        buf
+    };
+
+    let mut header = HeaderValue::from_maybe_shared(Bytes::from(encoded))
+        .expect("base64 is always valid HeaderValue");
+    header.set_sensitive(true);
+    header
+}
+
+pub(crate) fn fast_random() -> u64 {
+    use std::{
+        cell::Cell,
+        collections::hash_map::RandomState,
+        hash::{BuildHasher, Hasher},
+    };
+
+    thread_local! {
+        static KEY: RandomState = RandomState::new();
+        static COUNTER: Cell<u64> = const { Cell::new(0) };
+    }
+
+    KEY.with(|key| {
+        COUNTER.with(|ctr| {
+            let n = ctr.get().wrapping_add(1);
+            ctr.set(n);
+
+            let mut h = key.build_hasher();
+            h.write_u64(n);
+            h.finish()
+        })
+    })
+}
+
+pub(crate) fn replace_headers(dst: &mut HeaderMap, src: HeaderMap) {
+    // IntoIter of HeaderMap yields (Option<HeaderName>, HeaderValue).
+    // The first time a name is yielded, it will be Some(name), and if
+    // there are more values with the same name, the next yield will be
+    // None.
+
+    let mut prev_entry: Option<OccupiedEntry<_>> = None;
+    for (key, value) in src {
+        match key {
+            Some(key) => match dst.entry(key) {
+                Entry::Occupied(mut e) => {
+                    e.insert(value);
+                    prev_entry = Some(e);
+                }
+                Entry::Vacant(e) => {
+                    let e = e.insert_entry(value);
+                    prev_entry = Some(e);
+                }
+            },
+            None => match prev_entry {
+                Some(ref mut entry) => {
+                    entry.append(value);
+                }
+                None => unreachable!("HeaderMap::into_iter yielded None first"),
+            },
+        }
+    }
+}
+
+pub(crate) struct Escape<'a>(&'a [u8]);
+
+impl<'a> Escape<'a> {
+    pub(crate) fn new(bytes: &'a [u8]) -> Self {
+        Escape(bytes)
+    }
+}
+
+impl fmt::Debug for Escape<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "b\"{self}\"")?;
+        Ok(())
+    }
+}
+
+impl fmt::Display for Escape<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for &c in self.0 {
+            // https://doc.rust-lang.org/reference.html#byte-escapes
+            if c == b'\n' {
+                write!(f, "\\n")?;
+            } else if c == b'\r' {
+                write!(f, "\\r")?;
+            } else if c == b'\t' {
+                write!(f, "\\t")?;
+            } else if c == b'\\' || c == b'"' {
+                write!(f, "\\{}", c as char)?;
+            } else if c == b'\0' {
+                write!(f, "\\0")?;
+            // ASCII printable
+            } else if (0x20..0x7f).contains(&c) {
+                write!(f, "{}", c as char)?;
+            } else {
+                write!(f, "\\x{c:02x}")?;
+            }
+        }
+        Ok(())
+    }
+}

data/vendor/wreq/tests/badssl.rs

@@ -0,0 +1,228 @@
+use std::time::Duration;
+
+use wreq::{
+    Client,
+    tls::{AlpsProtocol, CertStore, TlsInfo, TlsOptions, TlsVersion},
+};
+
+macro_rules! join {
+    ($sep:expr, $first:expr $(, $rest:expr)*) => {
+        concat!($first $(, $sep, $rest)*)
+    };
+}
+
+#[tokio::test]
+async fn test_badssl_modern() {
+    let text = Client::builder()
+        .no_proxy()
+        .connect_timeout(Duration::from_secs(360))
+        .build()
+        .unwrap()
+        .get("https://mozilla-modern.badssl.com/")
+        .send()
+        .await
+        .unwrap()
+        .text()
+        .await
+        .unwrap();
+
+    assert!(!text.is_empty());
+}
+
+#[tokio::test]
+async fn test_badssl_self_signed() {
+    let text = Client::builder()
+        .cert_verification(false)
+        .connect_timeout(Duration::from_secs(360))
+        .no_proxy()
+        .build()
+        .unwrap()
+        .get("https://self-signed.badssl.com/")
+        .send()
+        .await
+        .unwrap()
+        .text()
+        .await
+        .unwrap();
+
+    assert!(!text.is_empty());
+}
+const CURVES_LIST: &str = join!(
+    ":",
+    "X25519",
+    "P-256",
+    "P-384",
+    "P-521",
+    "ffdhe2048",
+    "ffdhe3072"
+);
+
+#[tokio::test]
+async fn test_3des_support() -> wreq::Result<()> {
+    let tls_options = TlsOptions::builder()
+        .cipher_list(join!(
+            ":",
+            "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
+            "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA"
+        ))
+        .curves_list(CURVES_LIST)
+        .build();
+
+    // Create a client with the TLS options
+    let client = Client::builder()
+        .emulation(tls_options)
+        .cert_verification(false)
+        .connect_timeout(Duration::from_secs(360))
+        .build()?;
+
+    // Check if the client can connect to the 3des.badssl.com
+    let content = client
+        .get("https://3des.badssl.com/")
+        .send()
+        .await?
+        .text()
+        .await?;
+
+    println!("3des.badssl.com is supported:\n{content}");
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_firefox_7x_100_cipher() -> wreq::Result<()> {
+    let tls_options = TlsOptions::builder()
+        .cipher_list(join!(
+            ":",
+            "TLS_DHE_RSA_WITH_AES_128_CBC_SHA",
+            "TLS_DHE_RSA_WITH_AES_256_CBC_SHA",
+            "TLS_DHE_RSA_WITH_AES_128_CBC_SHA256",
+            "TLS_DHE_RSA_WITH_AES_256_CBC_SHA256"
+        ))
+        .curves_list(CURVES_LIST)
+        .build();
+
+    // Create a client with the TLS options
+    let client = Client::builder()
+        .emulation(tls_options)
+        .cert_verification(false)
+        .connect_timeout(Duration::from_secs(360))
+        .build()?;
+
+    // Check if the client can connect to the dh2048.badssl.com
+    let content = client
+        .get("https://dh2048.badssl.com/")
+        .send()
+        .await?
+        .text()
+        .await?;
+
+    println!("dh2048.badssl.com is supported:\n{content}");
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_alps_new_endpoint() -> wreq::Result<()> {
+    let tls_options = TlsOptions::builder()
+        .min_tls_version(TlsVersion::TLS_1_2)
+        .max_tls_version(TlsVersion::TLS_1_3)
+        .alps_protocols([AlpsProtocol::HTTP2])
+        .alps_use_new_codepoint(true)
+        .build();
+
+    let client = Client::builder()
+        .emulation(tls_options)
+        .connect_timeout(Duration::from_secs(360))
+        .build()?;
+
+    let resp = client.get("https://www.google.com").send().await?;
+    assert!(resp.status().is_success());
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_aes_hw_override() -> wreq::Result<()> {
+    const CIPHER_LIST: &str = join!(
+        ":",
+        "TLS_AES_128_GCM_SHA256",
+        "TLS_CHACHA20_POLY1305_SHA256",
+        "TLS_AES_256_GCM_SHA384",
+        "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
+        "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
+        "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
+        "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
+        "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
+        "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
+        "TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA",
+        "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
+        "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA",
+        "TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA",
+        "TLS_RSA_WITH_AES_128_GCM_SHA256",
+        "TLS_RSA_WITH_AES_256_GCM_SHA384",
+        "TLS_RSA_WITH_AES_128_CBC_SHA",
+        "TLS_RSA_WITH_AES_256_CBC_SHA"
+    );
+
+    let tls_options = TlsOptions::builder()
+        .cipher_list(CIPHER_LIST)
+        .min_tls_version(TlsVersion::TLS_1_2)
+        .max_tls_version(TlsVersion::TLS_1_3)
+        .enable_ech_grease(true)
+        .aes_hw_override(false)
+        .preserve_tls13_cipher_list(true)
+        .build();
+
+    // Create a client with the TLS options
+    let client = Client::builder()
+        .emulation(tls_options)
+        .connect_timeout(Duration::from_secs(360))
+        .build()?;
+
+    let resp = client.get("https://tls.browserleaks.com").send().await?;
+    assert!(resp.status().is_success());
+    let text = resp.text().await?;
+    assert!(text.contains("ChaCha20Poly1305"));
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_tls_self_signed_cert() {
+    let client = Client::builder()
+        .cert_verification(false)
+        .connect_timeout(Duration::from_secs(360))
+        .tls_info(true)
+        .build()
+        .unwrap();
+
+    let resp = client
+        .get("https://self-signed.badssl.com/")
+        .send()
+        .await
+        .unwrap();
+
+    let peer_cert_der = resp
+        .extensions()
+        .get::<TlsInfo>()
+        .and_then(|info| info.peer_certificate())
+        .unwrap();
+
+    let self_signed_cert_store = CertStore::builder()
+        .add_der_cert(peer_cert_der)
+        .build()
+        .unwrap();
+
+    let client = Client::builder()
+        .cert_store(self_signed_cert_store)
+        .build()
+        .unwrap();
+
+    let resp = client
+        .get("https://self-signed.badssl.com/")
+        .send()
+        .await
+        .unwrap();
+    assert!(resp.status().is_success());
+
+    let res = client.get("https://www.google.com").send().await;
+    assert!(res.is_err());
+}

data/vendor/wreq/tests/brotli.rs

@@ -0,0 +1,350 @@
+mod support;
+use std::io::Read;
+
+use support::server;
+use tokio::io::AsyncWriteExt;
+use wreq::Client;
+
+#[tokio::test]
+async fn brotli_response() {
+    brotli_case(10_000, 4096).await;
+}
+
+#[tokio::test]
+async fn brotli_single_byte_chunks() {
+    brotli_case(10, 1).await;
+}
+
+#[tokio::test]
+async fn test_brotli_empty_body() {
+    let server = server::http(move |req| async move {
+        assert_eq!(req.method(), "HEAD");
+
+        http::Response::builder()
+            .header("content-encoding", "br")
+            .body(Default::default())
+            .unwrap()
+    });
+
+    let res = wreq::head(format!("http://{}/brotli", server.addr()))
+        .send()
+        .await
+        .unwrap();
+
+    let body = res.text().await.unwrap();
+
+    assert_eq!(body, "");
+}
+
+#[tokio::test]
+async fn test_accept_header_is_not_changed_if_set() {
+    let server = server::http(move |req| async move {
+        assert_eq!(req.headers()["accept"], "application/json");
+        assert!(
+            req.headers()["accept-encoding"]
+                .to_str()
+                .unwrap()
+                .contains("br")
+        );
+        http::Response::default()
+    });
+
+    let res = wreq::get(format!("http://{}/accept", server.addr()))
+        .header(
+            wreq::header::ACCEPT,
+            wreq::header::HeaderValue::from_static("application/json"),
+        )
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+#[tokio::test]
+async fn test_accept_encoding_header_is_not_changed_if_set() {
+    let server = server::http(move |req| async move {
+        assert_eq!(req.headers()["accept"], "*/*");
+        assert_eq!(req.headers()["accept-encoding"], "identity");
+        http::Response::default()
+    });
+
+    let res = wreq::get(format!("http://{}/accept-encoding", server.addr()))
+        .header(wreq::header::ACCEPT, "*/*")
+        .header(
+            wreq::header::ACCEPT_ENCODING,
+            wreq::header::HeaderValue::from_static("identity"),
+        )
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(res.status(), wreq::StatusCode::OK);
+}
+
+async fn brotli_case(response_size: usize, chunk_size: usize) {
+    use futures_util::stream::StreamExt;
+
+    let content: String = (0..response_size).fold(String::new(), |mut acc, i| {
+        acc.push_str(&format!("test {i}"));
+        acc
+    });
+
+    let mut encoder = brotli::CompressorReader::new(content.as_bytes(), 4096, 5, 20);
+    let mut brotlied_content = Vec::new();
+    encoder.read_to_end(&mut brotlied_content).unwrap();
+
+    let mut response = format!(
+        "\
+         HTTP/1.1 200 OK\r\n\
+         Server: test-accept\r\n\
+         Content-Encoding: br\r\n\
+         Content-Length: {}\r\n\
+         \r\n",
+        &brotlied_content.len()
+    )
+    .into_bytes();
+    response.extend(&brotlied_content);
+
+    let server = server::http(move |req| {
+        assert!(
+            req.headers()["accept-encoding"]
+                .to_str()
+                .unwrap()
+                .contains("br")
+        );
+
+        let brotlied = brotlied_content.clone();
+        async move {
+            let len = brotlied.len();
+            let stream =
+                futures_util::stream::unfold((brotlied, 0), move |(brotlied, pos)| async move {
+                    let chunk = brotlied.chunks(chunk_size).nth(pos)?.to_vec();
+
+                    Some((chunk, (brotlied, pos + 1)))
+                });
+
+            let body = wreq::Body::wrap_stream(stream.map(Ok::<_, std::convert::Infallible>));
+
+            http::Response::builder()
+                .header("content-encoding", "br")
+                .header("content-length", len)
+                .body(body)
+                .unwrap()
+        }
+    });
+
+    let res = wreq::get(format!("http://{}/brotli", server.addr()))
+        .send()
+        .await
+        .expect("response");
+
+    let body = res.text().await.expect("text");
+    assert_eq!(body, content);
+}
+
+const COMPRESSED_RESPONSE_HEADERS: &[u8] = b"HTTP/1.1 200 OK\x0d\x0a\
+            Content-Type: text/plain\x0d\x0a\
+            Connection: keep-alive\x0d\x0a\
+            Content-Encoding: br\x0d\x0a";
+
+const RESPONSE_CONTENT: &str = "some message here";
+
+fn brotli_compress(input: &[u8]) -> Vec<u8> {
+    let mut encoder = brotli::CompressorReader::new(input, 4096, 5, 20);
+    let mut brotlied_content = Vec::new();
+    encoder.read_to_end(&mut brotlied_content).unwrap();
+    brotlied_content
+}
+
+#[tokio::test]
+async fn test_non_chunked_non_fragmented_response() {
+    let server = server::low_level_with_response(|_raw_request, client_socket| {
+        Box::new(async move {
+            let brotlied_content = brotli_compress(RESPONSE_CONTENT.as_bytes());
+            let content_length_header =
+                format!("Content-Length: {}\r\n\r\n", brotlied_content.len()).into_bytes();
+            let response = [
+                COMPRESSED_RESPONSE_HEADERS,
+                &content_length_header,
+                &brotlied_content,
+            ]
+            .concat();
+
+            client_socket
+                .write_all(response.as_slice())
+                .await
+                .expect("response write_all failed");
+            client_socket.flush().await.expect("response flush failed");
+        })
+    });
+
+    let res = wreq::get(format!("http://{}/", server.addr()))
+        .send()
+        .await
+        .expect("response");
+
+    assert_eq!(res.text().await.expect("text"), RESPONSE_CONTENT);
+}
+
+#[tokio::test]
+async fn test_chunked_fragmented_response_1() {
+    const DELAY_BETWEEN_RESPONSE_PARTS: tokio::time::Duration =
+        tokio::time::Duration::from_millis(1000);
+    const DELAY_MARGIN: tokio::time::Duration = tokio::time::Duration::from_millis(50);
+
+    let server = server::low_level_with_response(|_raw_request, client_socket| {
+        Box::new(async move {
+            let brotlied_content = brotli_compress(RESPONSE_CONTENT.as_bytes());
+            let response_first_part = [
+                COMPRESSED_RESPONSE_HEADERS,
+                format!(
+                    "Transfer-Encoding: chunked\r\n\r\n{:x}\r\n",
+                    brotlied_content.len()
+                )
+                .as_bytes(),
+                &brotlied_content,
+            ]
+            .concat();
+            let response_second_part = b"\r\n0\r\n\r\n";
+
+            client_socket
+                .write_all(response_first_part.as_slice())
+                .await
+                .expect("response_first_part write_all failed");
+            client_socket
+                .flush()
+                .await
+                .expect("response_first_part flush failed");
+
+            tokio::time::sleep(DELAY_BETWEEN_RESPONSE_PARTS).await;
+
+            client_socket
+                .write_all(response_second_part)
+                .await
+                .expect("response_second_part write_all failed");
+            client_socket
+                .flush()
+                .await
+                .expect("response_second_part flush failed");
+        })
+    });
+
+    let start = tokio::time::Instant::now();
+    let res = wreq::get(format!("http://{}/", server.addr()))
+        .send()
+        .await
+        .expect("response");
+
+    assert_eq!(res.text().await.expect("text"), RESPONSE_CONTENT);
+    assert!(start.elapsed() >= DELAY_BETWEEN_RESPONSE_PARTS - DELAY_MARGIN);
+}
+
+#[tokio::test]
+async fn test_chunked_fragmented_response_2() {
+    const DELAY_BETWEEN_RESPONSE_PARTS: tokio::time::Duration =
+        tokio::time::Duration::from_millis(1000);
+    const DELAY_MARGIN: tokio::time::Duration = tokio::time::Duration::from_millis(50);
+
+    let server = server::low_level_with_response(|_raw_request, client_socket| {
+        Box::new(async move {
+            let brotlied_content = brotli_compress(RESPONSE_CONTENT.as_bytes());
+            let response_first_part = [
+                COMPRESSED_RESPONSE_HEADERS,
+                format!(
+                    "Transfer-Encoding: chunked\r\n\r\n{:x}\r\n",
+                    brotlied_content.len()
+                )
+                .as_bytes(),
+                &brotlied_content,
+                b"\r\n",
+            ]
+            .concat();
+            let response_second_part = b"0\r\n\r\n";
+
+            client_socket
+                .write_all(response_first_part.as_slice())
+                .await
+                .expect("response_first_part write_all failed");
+            client_socket
+                .flush()
+                .await
+                .expect("response_first_part flush failed");
+
+            tokio::time::sleep(DELAY_BETWEEN_RESPONSE_PARTS).await;
+
+            client_socket
+                .write_all(response_second_part)
+                .await
+                .expect("response_second_part write_all failed");
+            client_socket
+                .flush()
+                .await
+                .expect("response_second_part flush failed");
+        })
+    });
+
+    let start = tokio::time::Instant::now();
+    let res = wreq::get(format!("http://{}/", server.addr()))
+        .send()
+        .await
+        .expect("response");
+
+    assert_eq!(res.text().await.expect("text"), RESPONSE_CONTENT);
+    assert!(start.elapsed() >= DELAY_BETWEEN_RESPONSE_PARTS - DELAY_MARGIN);
+}
+
+#[tokio::test]
+async fn test_chunked_fragmented_response_with_extra_bytes() {
+    const DELAY_BETWEEN_RESPONSE_PARTS: tokio::time::Duration =
+        tokio::time::Duration::from_millis(1000);
+    const DELAY_MARGIN: tokio::time::Duration = tokio::time::Duration::from_millis(50);
+
+    let server = server::low_level_with_response(|_raw_request, client_socket| {
+        Box::new(async move {
+            let brotlied_content = brotli_compress(RESPONSE_CONTENT.as_bytes());
+            let response_first_part = [
+                COMPRESSED_RESPONSE_HEADERS,
+                format!(
+                    "Transfer-Encoding: chunked\r\n\r\n{:x}\r\n",
+                    brotlied_content.len()
+                )
+                .as_bytes(),
+                &brotlied_content,
+            ]
+            .concat();
+            let response_second_part = b"\r\n2ab\r\n0\r\n\r\n";
+
+            client_socket
+                .write_all(response_first_part.as_slice())
+                .await
+                .expect("response_first_part write_all failed");
+            client_socket
+                .flush()
+                .await
+                .expect("response_first_part flush failed");
+
+            tokio::time::sleep(DELAY_BETWEEN_RESPONSE_PARTS).await;
+
+            client_socket
+                .write_all(response_second_part)
+                .await
+                .expect("response_second_part write_all failed");
+            client_socket
+                .flush()
+                .await
+                .expect("response_second_part flush failed");
+        })
+    });
+
+    let start = tokio::time::Instant::now();
+    let res = Client::new()
+        .get(format!("http://{}/", server.addr()))
+        .send()
+        .await
+        .expect("response");
+
+    let err = res.text().await.expect_err("there must be an error");
+    assert!(err.is_decode());
+    assert!(start.elapsed() >= DELAY_BETWEEN_RESPONSE_PARTS - DELAY_MARGIN);
+}