mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
fix(fetch): challenge and cache browser Basic authentication
This commit is contained in:
Generated
+1
-1
@@ -2987,7 +2987,7 @@ dependencies = [
|
||||
"moli-web-bot-auth",
|
||||
"moli-web-mime",
|
||||
"parking_lot",
|
||||
"percent-encoding 2.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||
"percent-encoding",
|
||||
"rcgen",
|
||||
"regex",
|
||||
"serde",
|
||||
|
||||
@@ -34,7 +34,7 @@ moli-url-policy = { path = "../moli-url-policy" }
|
||||
moli-web-bot-auth = { path = "../moli-web-bot-auth" }
|
||||
moli-web-mime = { path = "../moli-web-mime" }
|
||||
parking_lot = "0.12"
|
||||
percent-encoding = "2"
|
||||
percent-encoding = "2.3"
|
||||
regex = "1"
|
||||
serde = { version = "1.0.228", features = ["derive"] }
|
||||
sfv = "0.15.0"
|
||||
|
||||
@@ -669,7 +669,14 @@ pub(crate) fn configure_easy(
|
||||
.configure(easy, request.allows_credentials_for_url(request_url))?;
|
||||
easy.useragent(request.browser_identity(config).user_agent())
|
||||
.context("failed to set curl user-agent")?;
|
||||
easy.url(request_url.as_str())
|
||||
// Browser URL credentials are selected only after an eligible 401. Do
|
||||
// not let libcurl independently turn userinfo into a preemptive header.
|
||||
let mut transport_url = request_url.clone();
|
||||
if request.request_origin().is_some() {
|
||||
let _ = transport_url.set_username("");
|
||||
let _ = transport_url.set_password(None);
|
||||
}
|
||||
easy.url(transport_url.as_str())
|
||||
.with_context(|| anyhow!("failed to set curl request url to {}", request_url))?;
|
||||
|
||||
match request.method.as_str() {
|
||||
@@ -766,7 +773,7 @@ pub(crate) fn configure_easy(
|
||||
.context("failed to suppress curl default content-type")?;
|
||||
}
|
||||
|
||||
if let Some(auth) = request.auth_for_url(request_url)
|
||||
if let Some(auth) = request.transport_auth_for_url(request_url)
|
||||
&& request.auth_requires_buffered_transport()
|
||||
{
|
||||
let mut methods = Auth::new();
|
||||
|
||||
@@ -21,6 +21,7 @@ pub struct FetchClientHandle {
|
||||
cookie_store: SharedBrowserCookieStore,
|
||||
runtime: FetchRuntimeHandle,
|
||||
dictionaries: crate::compression_dictionary::SharedDictionaryStore,
|
||||
http_authentication: crate::http_authentication::SharedHttpAuthenticationCache,
|
||||
}
|
||||
|
||||
/// Unique structured-concurrency owner for one fetch client.
|
||||
@@ -41,6 +42,12 @@ impl FetchClientHandle {
|
||||
pub fn prepare_request(&self, request: &mut Request) {
|
||||
request.prepare_accept_header(&self.config);
|
||||
let url = request.url.clone();
|
||||
crate::http_authentication::HttpAuthenticationCache::prepare(
|
||||
&self.http_authentication,
|
||||
&self.config,
|
||||
request,
|
||||
&url,
|
||||
);
|
||||
if let std::borrow::Cow::Owned(prepared) =
|
||||
crate::compression_dictionary::DictionaryStore::prepare(
|
||||
&self.dictionaries,
|
||||
@@ -315,17 +322,20 @@ impl FetchClient {
|
||||
let client_hint_preferences =
|
||||
Arc::new(parking_lot::Mutex::new(ClientHintPreferences::default()));
|
||||
let dictionaries = Arc::default();
|
||||
let http_authentication = Arc::default();
|
||||
let runtime_owner = FetchRuntimeOwner::new_with_network_state(
|
||||
config,
|
||||
Arc::clone(&cookie_store),
|
||||
Arc::clone(&client_hint_preferences),
|
||||
Arc::clone(&dictionaries),
|
||||
Arc::clone(&http_authentication),
|
||||
);
|
||||
let handle = FetchClientHandle {
|
||||
config: config.clone(),
|
||||
runtime: runtime_owner.handle(),
|
||||
cookie_store,
|
||||
dictionaries,
|
||||
http_authentication,
|
||||
};
|
||||
Self {
|
||||
handle,
|
||||
|
||||
@@ -0,0 +1,676 @@
|
||||
//! Browser Basic authentication belongs to the network context, not libcurl's
|
||||
//! URL userinfo handling. URL credentials require a challenge; accepted
|
||||
//! identities can subsequently be sent within their protection space.
|
||||
|
||||
use std::{collections::VecDeque, fmt, sync::Arc};
|
||||
|
||||
use moli_header_field::{HeaderFieldTokenMode, HeaderFieldTokenizer, split_outside_quoted_strings};
|
||||
use moli_storage_key::{MoliStorageKey, deserialize_serialized_storage_key, site_for_url};
|
||||
use moli_url::WebOrigin;
|
||||
use parking_lot::Mutex;
|
||||
use url::Url;
|
||||
|
||||
use crate::{FetchConfig, Request, RequestAuth, RequestAuthScheme, RequestAuthTarget, RequestMode};
|
||||
|
||||
const MAX_ENTRIES: usize = 256;
|
||||
const MAX_PATHS: usize = 10;
|
||||
|
||||
pub(crate) type SharedHttpAuthenticationCache = Arc<Mutex<HttpAuthenticationCache>>;
|
||||
|
||||
#[derive(Default)]
|
||||
pub(crate) struct HttpAuthenticationCache {
|
||||
entries: VecDeque<Entry>,
|
||||
}
|
||||
|
||||
#[derive(Clone, PartialEq, Eq)]
|
||||
struct ProtectionSpace {
|
||||
origin: url::Origin,
|
||||
partition: String,
|
||||
}
|
||||
|
||||
impl ProtectionSpace {
|
||||
fn new(request: &Request, url: &Url) -> Option<Self> {
|
||||
let origin = request.request_origin()?;
|
||||
let partition = if let Some(key) = request.network_partition_key() {
|
||||
if origin.is_opaque()
|
||||
&& deserialize_serialized_storage_key(key)?
|
||||
.opaque_nonce()
|
||||
.is_none()
|
||||
{
|
||||
return None;
|
||||
}
|
||||
key.to_owned()
|
||||
} else {
|
||||
if origin.is_opaque() {
|
||||
return None;
|
||||
}
|
||||
let frame = Url::parse(origin.ascii_serialization()).ok()?;
|
||||
let context = &request.cookie_context.browser_context;
|
||||
let top_frame = context
|
||||
.top_frame_origin_url
|
||||
.as_ref()
|
||||
.or(context.site_for_cookies_url.as_ref())
|
||||
.unwrap_or(&frame);
|
||||
MoliStorageKey::from_url_and_top_level_site(&frame, site_for_url(top_frame), None)
|
||||
.serialized_storage_key()
|
||||
};
|
||||
Some(Self {
|
||||
origin: url.origin(),
|
||||
partition,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
struct Identity {
|
||||
space: ProtectionSpace,
|
||||
realm: String,
|
||||
credentials: Arc<RequestAuth>,
|
||||
}
|
||||
|
||||
struct Entry {
|
||||
identity: Arc<Identity>,
|
||||
paths: VecDeque<String>,
|
||||
}
|
||||
|
||||
impl HttpAuthenticationCache {
|
||||
fn lookup(&mut self, space: &ProtectionSpace, path: &str) -> Option<Arc<Identity>> {
|
||||
let (index, _) = self
|
||||
.entries
|
||||
.iter()
|
||||
.enumerate()
|
||||
.filter_map(|(index, entry)| {
|
||||
if entry.identity.space != *space {
|
||||
return None;
|
||||
}
|
||||
entry
|
||||
.paths
|
||||
.iter()
|
||||
.filter(|prefix| path.starts_with(prefix.as_str()))
|
||||
.map(String::len)
|
||||
.max()
|
||||
.map(|length| (index, length))
|
||||
})
|
||||
.max_by_key(|(_, length)| *length)?;
|
||||
let entry = self.entries.remove(index)?;
|
||||
let identity = Arc::clone(&entry.identity);
|
||||
self.entries.push_front(entry);
|
||||
Some(identity)
|
||||
}
|
||||
|
||||
fn store(&mut self, identity: Arc<Identity>, path: &str) {
|
||||
let mut entry = self
|
||||
.entries
|
||||
.iter()
|
||||
.position(|entry| {
|
||||
entry.identity.space == identity.space && entry.identity.realm == identity.realm
|
||||
})
|
||||
.and_then(|index| self.entries.remove(index))
|
||||
.unwrap_or_else(|| Entry {
|
||||
identity: Arc::clone(&identity),
|
||||
paths: VecDeque::new(),
|
||||
});
|
||||
entry.identity = identity;
|
||||
let directory = &path[..path.rfind('/').map_or(0, |index| index + 1)];
|
||||
if !entry
|
||||
.paths
|
||||
.iter()
|
||||
.any(|prefix| directory.starts_with(prefix.as_str()))
|
||||
{
|
||||
entry.paths.retain(|prefix| !prefix.starts_with(directory));
|
||||
entry.paths.push_front(directory.to_owned());
|
||||
entry.paths.truncate(MAX_PATHS);
|
||||
}
|
||||
self.entries.push_front(entry);
|
||||
self.entries.truncate(MAX_ENTRIES);
|
||||
}
|
||||
|
||||
fn reject(&mut self, identity: &Arc<Identity>) {
|
||||
// An old in-flight rejection must not evict a newer accepted identity.
|
||||
self.entries
|
||||
.retain(|entry| !Arc::ptr_eq(&entry.identity, identity));
|
||||
}
|
||||
|
||||
pub(crate) fn prepare_owned(
|
||||
cache: &SharedHttpAuthenticationCache,
|
||||
config: &FetchConfig,
|
||||
mut request: Request,
|
||||
url: &Url,
|
||||
) -> Request {
|
||||
Self::prepare(cache, config, &mut request, url);
|
||||
request
|
||||
}
|
||||
|
||||
pub(crate) fn prepare(
|
||||
cache: &SharedHttpAuthenticationCache,
|
||||
config: &FetchConfig,
|
||||
request: &mut Request,
|
||||
url: &Url,
|
||||
) {
|
||||
if request.request_origin().is_none()
|
||||
|| request
|
||||
.configured_auth()
|
||||
.is_some_and(|auth| auth.target == RequestAuthTarget::Server)
|
||||
{
|
||||
request.http_authentication = None;
|
||||
return;
|
||||
}
|
||||
if request
|
||||
.http_authentication
|
||||
.as_ref()
|
||||
.is_some_and(|snapshot| snapshot.matches(cache, config, request, url))
|
||||
{
|
||||
return;
|
||||
}
|
||||
let has_authorization = has_authorization(config, request);
|
||||
let space = ProtectionSpace::new(request, url);
|
||||
let action = if has_authorization
|
||||
|| !request.allows_credentials_for_url(url)
|
||||
|| !matches!(url.scheme(), "http" | "https")
|
||||
{
|
||||
Authentication::None
|
||||
} else if !url.username().is_empty() || url.password().is_some() {
|
||||
if matches!(
|
||||
request.request_mode,
|
||||
RequestMode::Cors | RequestMode::SameOrigin
|
||||
) && request.has_cross_origin_url(url)
|
||||
{
|
||||
Authentication::None
|
||||
} else {
|
||||
Authentication::Url(Arc::new(RequestAuth {
|
||||
target: RequestAuthTarget::Server,
|
||||
scheme: RequestAuthScheme::Basic,
|
||||
username: percent_encoding::percent_decode_str(url.username())
|
||||
.decode_utf8_lossy()
|
||||
.into_owned(),
|
||||
password: percent_encoding::percent_decode_str(url.password().unwrap_or(""))
|
||||
.decode_utf8_lossy()
|
||||
.into_owned(),
|
||||
}))
|
||||
}
|
||||
} else {
|
||||
space
|
||||
.as_ref()
|
||||
.and_then(|space| cache.lock().lookup(space, url.path()))
|
||||
.map_or(Authentication::None, Authentication::Cached)
|
||||
};
|
||||
request.http_authentication = Some(Arc::new(PreparedHttpAuthentication {
|
||||
cache: Arc::clone(cache),
|
||||
url: url.clone(),
|
||||
origin: request.request_origin().cloned(),
|
||||
partition: request.network_partition_key().map(str::to_owned),
|
||||
top_frame: request
|
||||
.cookie_context
|
||||
.browser_context
|
||||
.top_frame_origin_url
|
||||
.clone(),
|
||||
site_for_cookies: request
|
||||
.cookie_context
|
||||
.browser_context
|
||||
.site_for_cookies_url
|
||||
.clone(),
|
||||
credentials_mode: request.credentials_mode,
|
||||
mode: request.request_mode,
|
||||
cross_origin: request.has_cross_origin_url(url),
|
||||
has_authorization,
|
||||
space,
|
||||
action,
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
enum Authentication {
|
||||
None,
|
||||
Url(Arc<RequestAuth>),
|
||||
Challenged {
|
||||
realm: String,
|
||||
credentials: Arc<RequestAuth>,
|
||||
},
|
||||
Cached(Arc<Identity>),
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct PreparedHttpAuthentication {
|
||||
cache: SharedHttpAuthenticationCache,
|
||||
url: Url,
|
||||
origin: Option<WebOrigin>,
|
||||
partition: Option<String>,
|
||||
top_frame: Option<Url>,
|
||||
site_for_cookies: Option<Url>,
|
||||
credentials_mode: crate::RequestCredentialsMode,
|
||||
mode: RequestMode,
|
||||
cross_origin: bool,
|
||||
has_authorization: bool,
|
||||
space: Option<ProtectionSpace>,
|
||||
action: Authentication,
|
||||
}
|
||||
|
||||
impl fmt::Debug for PreparedHttpAuthentication {
|
||||
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
formatter.write_str("PreparedHttpAuthentication")
|
||||
}
|
||||
}
|
||||
|
||||
fn has_authorization(config: &FetchConfig, request: &Request) -> bool {
|
||||
request
|
||||
.request_headers
|
||||
.iter()
|
||||
.any(|(name, _)| name.eq_ignore_ascii_case("authorization"))
|
||||
|| config
|
||||
.default_request_headers()
|
||||
.iter()
|
||||
.any(|(name, _)| name.eq_ignore_ascii_case("authorization"))
|
||||
}
|
||||
|
||||
impl PreparedHttpAuthentication {
|
||||
fn matches(
|
||||
&self,
|
||||
cache: &SharedHttpAuthenticationCache,
|
||||
config: &FetchConfig,
|
||||
request: &Request,
|
||||
url: &Url,
|
||||
) -> bool {
|
||||
Arc::ptr_eq(&self.cache, cache)
|
||||
&& self.url == *url
|
||||
&& self.origin.as_ref() == request.request_origin()
|
||||
&& self.partition.as_deref() == request.network_partition_key()
|
||||
&& self.top_frame == request.cookie_context.browser_context.top_frame_origin_url
|
||||
&& self.site_for_cookies == request.cookie_context.browser_context.site_for_cookies_url
|
||||
&& self.credentials_mode == request.credentials_mode
|
||||
&& self.mode == request.request_mode
|
||||
&& self.cross_origin == request.has_cross_origin_url(url)
|
||||
&& self.has_authorization == has_authorization(config, request)
|
||||
}
|
||||
|
||||
pub(crate) fn credentials(&self) -> Option<&RequestAuth> {
|
||||
match &self.action {
|
||||
Authentication::None => None,
|
||||
Authentication::Url(credentials) | Authentication::Challenged { credentials, .. } => {
|
||||
Some(credentials)
|
||||
}
|
||||
Authentication::Cached(identity) => Some(&identity.credentials),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn preemptive_credentials(&self, url: &Url) -> Option<&RequestAuth> {
|
||||
if self.url != *url {
|
||||
return None;
|
||||
}
|
||||
match &self.action {
|
||||
Authentication::Challenged { credentials, .. } => Some(credentials),
|
||||
Authentication::Cached(identity) => Some(&identity.credentials),
|
||||
Authentication::None | Authentication::Url(_) => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) struct HttpAuthenticationRetry {
|
||||
pub(crate) prepared: Arc<PreparedHttpAuthentication>,
|
||||
pub(crate) headers: Vec<(String, Vec<u8>)>,
|
||||
}
|
||||
|
||||
pub(crate) enum AuthenticationHeaderAction {
|
||||
Forward,
|
||||
Defer,
|
||||
Retry,
|
||||
Replay(Vec<Vec<u8>>),
|
||||
}
|
||||
|
||||
pub(crate) struct HttpAuthenticationResponse {
|
||||
prepared: Arc<PreparedHttpAuthentication>,
|
||||
status: u16,
|
||||
lines: Vec<Vec<u8>>,
|
||||
headers: Vec<(String, Vec<u8>)>,
|
||||
retry: Option<HttpAuthenticationRetry>,
|
||||
finalized: bool,
|
||||
}
|
||||
|
||||
impl HttpAuthenticationResponse {
|
||||
pub(crate) fn new(request: &Request) -> Option<Self> {
|
||||
let prepared = request.http_authentication.as_ref()?;
|
||||
prepared.credentials()?;
|
||||
Some(Self {
|
||||
prepared: Arc::clone(prepared),
|
||||
status: 0,
|
||||
lines: Vec::new(),
|
||||
headers: Vec::new(),
|
||||
retry: None,
|
||||
finalized: false,
|
||||
})
|
||||
}
|
||||
|
||||
pub(crate) fn take_retry(&mut self) -> Option<HttpAuthenticationRetry> {
|
||||
self.retry.take()
|
||||
}
|
||||
|
||||
pub(crate) fn header(&mut self, data: &[u8]) -> AuthenticationHeaderAction {
|
||||
use AuthenticationHeaderAction::{Defer, Forward, Replay, Retry};
|
||||
if let Some(line) = crate::response::parse_http_response_status_line(data) {
|
||||
self.status = line.status;
|
||||
self.lines.clear();
|
||||
self.headers.clear();
|
||||
self.finalized = false;
|
||||
}
|
||||
if self.finalized {
|
||||
return Forward;
|
||||
}
|
||||
let defer = self.status == 401 && matches!(self.prepared.action, Authentication::Url(_));
|
||||
if defer {
|
||||
self.lines.push(data.to_vec());
|
||||
if let Some(header) = crate::headers::parse_http_response_header_line(data) {
|
||||
self.headers.push(header);
|
||||
}
|
||||
}
|
||||
if data != b"\r\n" && data != b"\n" {
|
||||
return if defer { Defer } else { Forward };
|
||||
}
|
||||
self.finalized = true;
|
||||
match &self.prepared.action {
|
||||
Authentication::Url(credentials) if defer => {
|
||||
if let Some(realm) = basic_realm(&self.headers) {
|
||||
let mut prepared = (*self.prepared).clone();
|
||||
prepared.action = Authentication::Challenged {
|
||||
realm,
|
||||
credentials: Arc::clone(credentials),
|
||||
};
|
||||
self.retry = Some(HttpAuthenticationRetry {
|
||||
prepared: Arc::new(prepared),
|
||||
headers: std::mem::take(&mut self.headers),
|
||||
});
|
||||
Retry
|
||||
} else {
|
||||
Replay(std::mem::take(&mut self.lines))
|
||||
}
|
||||
}
|
||||
Authentication::Challenged { realm, credentials }
|
||||
if (200..400).contains(&self.status) =>
|
||||
{
|
||||
if let Some(space) = &self.prepared.space {
|
||||
self.prepared.cache.lock().store(
|
||||
Arc::new(Identity {
|
||||
space: space.clone(),
|
||||
realm: realm.clone(),
|
||||
credentials: Arc::clone(credentials),
|
||||
}),
|
||||
self.prepared.url.path(),
|
||||
);
|
||||
}
|
||||
Forward
|
||||
}
|
||||
Authentication::Cached(identity) if self.status == 401 => {
|
||||
self.prepared.cache.lock().reject(identity);
|
||||
Forward
|
||||
}
|
||||
_ => Forward,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A comma can separate challenges or auth-params. Tokenize params using the
|
||||
/// shared HTTP field parser, preserving quoted commas/escapes and rejecting
|
||||
/// malformed Basic challenges. Chromium accepts a missing realm as empty.
|
||||
fn basic_realm(headers: &[(String, Vec<u8>)]) -> Option<String> {
|
||||
for (_, value) in headers
|
||||
.iter()
|
||||
.filter(|(name, _)| name.eq_ignore_ascii_case("www-authenticate"))
|
||||
{
|
||||
let value: String = value.iter().copied().map(char::from).collect();
|
||||
let mut basic = false;
|
||||
let mut valid = true;
|
||||
let mut realm = String::new();
|
||||
for part in split_outside_quoted_strings(&value, ',') {
|
||||
let mut parser = HeaderFieldTokenizer::new(part);
|
||||
let Some(token) = parser.consume_token(HeaderFieldTokenMode::Normal) else {
|
||||
valid = false;
|
||||
continue;
|
||||
};
|
||||
if !parser.consume('=') {
|
||||
if basic && valid {
|
||||
return Some(realm);
|
||||
}
|
||||
basic = token.eq_ignore_ascii_case("Basic");
|
||||
valid = true;
|
||||
realm = String::new();
|
||||
if !basic || parser.is_consumed() {
|
||||
continue;
|
||||
}
|
||||
let Some(name) = parser.consume_token(HeaderFieldTokenMode::Normal) else {
|
||||
valid = false;
|
||||
continue;
|
||||
};
|
||||
if !parser.consume('=') {
|
||||
valid = false;
|
||||
continue;
|
||||
}
|
||||
valid &= auth_parameter(&mut parser, name, &mut realm);
|
||||
} else if basic {
|
||||
valid &= auth_parameter(&mut parser, token, &mut realm);
|
||||
}
|
||||
}
|
||||
if basic && valid {
|
||||
return Some(realm);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn auth_parameter(parser: &mut HeaderFieldTokenizer<'_>, name: &str, realm: &mut String) -> bool {
|
||||
let Some(value) = parser.consume_token_or_quoted_string(HeaderFieldTokenMode::Normal) else {
|
||||
return false;
|
||||
};
|
||||
if !parser.is_consumed()
|
||||
|| name.bytes().any(|byte| byte.is_ascii_control())
|
||||
|| value
|
||||
.chars()
|
||||
.any(|character| character.is_ascii_control() && character != '\t')
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if name.eq_ignore_ascii_case("realm") {
|
||||
*realm = value.into_owned();
|
||||
}
|
||||
true
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn basic_challenges_use_http_quoted_parameter_grammar() {
|
||||
for (field, expected) in [
|
||||
("Basic", Some("")),
|
||||
("bAsIc realm=plain", Some("plain")),
|
||||
(
|
||||
"Digest realm=other, nonce=abc, Basic realm=\"a,b\\\"c\", charset=UTF-8",
|
||||
Some("a,b\"c"),
|
||||
),
|
||||
("Basic realm=old, REALM=new", Some("new")),
|
||||
("Basic realm=\"", None),
|
||||
("Basic realm=", None),
|
||||
("Basic realm=\"ok\"junk", None),
|
||||
("Basic realm=\"bad\u{7f}\"", None),
|
||||
("Bearer token", None),
|
||||
("NotBasic realm=other", None),
|
||||
] {
|
||||
assert_eq!(
|
||||
basic_realm(&[("www-authenticate".into(), field.as_bytes().to_vec())]).as_deref(),
|
||||
expected,
|
||||
"{field:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
fn identity(partition: &str, origin: &str, realm: &str) -> Arc<Identity> {
|
||||
Arc::new(Identity {
|
||||
space: ProtectionSpace {
|
||||
origin: Url::parse(origin).unwrap().origin(),
|
||||
partition: partition.into(),
|
||||
},
|
||||
realm: realm.into(),
|
||||
credentials: Arc::new(RequestAuth {
|
||||
target: RequestAuthTarget::Server,
|
||||
scheme: RequestAuthScheme::Basic,
|
||||
username: "user".into(),
|
||||
password: "secret".into(),
|
||||
}),
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cache_uses_longest_directory_match_without_crossing_origin_or_partition() {
|
||||
let mut cache = HttpAuthenticationCache::default();
|
||||
let broad = identity("a", "https://one.test/", "broad");
|
||||
let narrow = identity("a", "https://one.test/", "narrow");
|
||||
cache.store(Arc::clone(&broad), "/shared/login");
|
||||
cache.store(Arc::clone(&narrow), "/shared/private/login");
|
||||
assert!(Arc::ptr_eq(
|
||||
&cache.lookup(&broad.space, "/shared/private/data").unwrap(),
|
||||
&narrow
|
||||
));
|
||||
assert!(Arc::ptr_eq(
|
||||
&cache.lookup(&broad.space, "/shared/public").unwrap(),
|
||||
&broad
|
||||
));
|
||||
for (partition, origin) in [
|
||||
("b", "https://one.test/"),
|
||||
("a", "http://one.test/"),
|
||||
("a", "https://two.test/"),
|
||||
] {
|
||||
assert!(
|
||||
cache
|
||||
.lookup(
|
||||
&identity(partition, origin, "").space,
|
||||
"/shared/private/data"
|
||||
)
|
||||
.is_none()
|
||||
);
|
||||
}
|
||||
assert!(cache.lookup(&broad.space, "/sharedness/data").is_none());
|
||||
assert!(cache.lookup(&broad.space, "/shared").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn old_rejection_does_not_remove_new_credentials_and_cache_is_bounded() {
|
||||
let mut cache = HttpAuthenticationCache::default();
|
||||
let old = identity("a", "https://one.test/", "realm");
|
||||
let new = identity("a", "https://one.test/", "realm");
|
||||
cache.store(Arc::clone(&old), "/login");
|
||||
cache.store(Arc::clone(&new), "/other/login");
|
||||
cache.reject(&old);
|
||||
assert!(Arc::ptr_eq(
|
||||
&cache.lookup(&new.space, "/data").unwrap(),
|
||||
&new
|
||||
));
|
||||
cache.reject(&new);
|
||||
assert!(cache.lookup(&new.space, "/data").is_none());
|
||||
for index in 0..=MAX_ENTRIES {
|
||||
cache.store(
|
||||
identity(&index.to_string(), "https://one.test/", "realm"),
|
||||
"/login",
|
||||
);
|
||||
}
|
||||
assert_eq!(cache.entries.len(), MAX_ENTRIES);
|
||||
assert!(
|
||||
cache
|
||||
.lookup(&identity("0", "https://one.test/", "realm").space, "/data")
|
||||
.is_none()
|
||||
);
|
||||
let value = identity("last", "https://one.test/", "realm");
|
||||
for index in 0..MAX_PATHS + 3 {
|
||||
cache.store(Arc::clone(&value), &format!("/{index}/login"));
|
||||
}
|
||||
assert_eq!(cache.entries.front().unwrap().paths.len(), MAX_PATHS);
|
||||
assert!(cache.lookup(&value.space, "/0/data").is_none());
|
||||
cache.store(Arc::clone(&value), "/login");
|
||||
assert_eq!(cache.entries.front().unwrap().paths.len(), 1);
|
||||
assert!(cache.lookup(&value.space, "/any/data").is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepared_authentication_keeps_one_selection_but_revalidates_security_inputs_and_owner() {
|
||||
let config = FetchConfig::default();
|
||||
let cache = SharedHttpAuthenticationCache::default();
|
||||
let url = Url::parse("https://one.test/data").unwrap();
|
||||
let request = Request::get_with_url(url.clone()).with_request_origin((&url).into());
|
||||
let selected = HttpAuthenticationCache::prepare_owned(&cache, &config, request, &url);
|
||||
let accepted = identity(
|
||||
ProtectionSpace::new(&selected, &url)
|
||||
.unwrap()
|
||||
.partition
|
||||
.as_str(),
|
||||
"https://one.test/",
|
||||
"realm",
|
||||
);
|
||||
cache.lock().store(accepted, "/login");
|
||||
let frozen =
|
||||
HttpAuthenticationCache::prepare_owned(&cache, &config, selected.clone(), &url);
|
||||
assert!(
|
||||
frozen.auth().is_none(),
|
||||
"cache selection must not change between renderer lookup and dispatch"
|
||||
);
|
||||
let mut fresh = selected.clone();
|
||||
fresh.http_authentication = None;
|
||||
let fresh = HttpAuthenticationCache::prepare_owned(&cache, &config, fresh, &url);
|
||||
assert!(fresh.auth().is_some());
|
||||
let other_owner = SharedHttpAuthenticationCache::default();
|
||||
assert!(
|
||||
HttpAuthenticationCache::prepare_owned(&other_owner, &config, fresh.clone(), &url)
|
||||
.auth()
|
||||
.is_none()
|
||||
);
|
||||
let mut omitted = fresh.clone();
|
||||
omitted.credentials_mode = crate::RequestCredentialsMode::Omit;
|
||||
assert!(
|
||||
HttpAuthenticationCache::prepare_owned(&cache, &config, omitted, &url)
|
||||
.auth()
|
||||
.is_none()
|
||||
);
|
||||
let mut explicit = fresh;
|
||||
explicit
|
||||
.request_headers
|
||||
.push(("Authorization".into(), b"Bearer author".to_vec()));
|
||||
assert!(
|
||||
HttpAuthenticationCache::prepare_owned(&cache, &config, explicit, &url)
|
||||
.auth()
|
||||
.is_none()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn opaque_origins_require_a_storage_nonce_for_session_reuse() {
|
||||
let url = Url::parse("https://one.test/data").unwrap();
|
||||
let request = Request::get_with_url(url.clone()).with_request_origin(WebOrigin::Opaque);
|
||||
assert!(ProtectionSpace::new(&request, &url).is_none());
|
||||
for key in [
|
||||
"null",
|
||||
"partition",
|
||||
"storage-key:v1;origin=null;top-level-site=https://one.test",
|
||||
] {
|
||||
assert!(
|
||||
ProtectionSpace::new(
|
||||
&request.clone().with_network_partition_key(Some(key.into())),
|
||||
&url
|
||||
)
|
||||
.is_none()
|
||||
);
|
||||
}
|
||||
let key = |nonce| {
|
||||
MoliStorageKey::new(
|
||||
"null".into(),
|
||||
"https://one.test".into(),
|
||||
Some(moli_storage_key::OpaqueOriginNonce::new(nonce)),
|
||||
moli_storage_key::StoragePartitionRelation::FirstParty,
|
||||
)
|
||||
.serialized_storage_key()
|
||||
};
|
||||
let first = ProtectionSpace::new(
|
||||
&request.clone().with_network_partition_key(Some(key(1))),
|
||||
&url,
|
||||
)
|
||||
.unwrap();
|
||||
let second =
|
||||
ProtectionSpace::new(&request.with_network_partition_key(Some(key(2))), &url).unwrap();
|
||||
assert!(first != second);
|
||||
}
|
||||
}
|
||||
@@ -20,6 +20,7 @@ mod dns;
|
||||
mod error;
|
||||
mod fetch_url_list;
|
||||
mod headers;
|
||||
mod http_authentication;
|
||||
mod network_fetch_result;
|
||||
mod proxy;
|
||||
mod proxy_connect;
|
||||
|
||||
+47
-23
@@ -104,7 +104,9 @@ pub struct Request {
|
||||
pub credentials_mode: RequestCredentialsMode,
|
||||
pub(crate) redirect_chain: Vec<RedirectInfo>,
|
||||
network_partition_key: Option<String>,
|
||||
auth: Option<ScopedRequestAuth>,
|
||||
auth: Option<Arc<ConfiguredRequestAuth>>,
|
||||
pub(crate) http_authentication:
|
||||
Option<Arc<crate::http_authentication::PreparedHttpAuthentication>>,
|
||||
pub cookie_context: NetworkCookieRequestContext,
|
||||
timeout_policy: RequestTimeoutPolicy,
|
||||
network_observation_recorder: Option<NetworkObservationRecorder>,
|
||||
@@ -139,12 +141,6 @@ impl RequestRedirectPolicy {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct ScopedRequestAuth {
|
||||
credentials: RequestAuth,
|
||||
origin: WebOrigin,
|
||||
}
|
||||
|
||||
/// The lifetime of request headers supplied by an interception command.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum RequestHeaderOverride {
|
||||
@@ -603,6 +599,14 @@ pub struct RequestAuth {
|
||||
pub password: String,
|
||||
}
|
||||
|
||||
// Credentials and their original server are immutable request configuration.
|
||||
// Keep them together and out of the inline Request/async-future footprint.
|
||||
#[derive(Debug)]
|
||||
struct ConfiguredRequestAuth {
|
||||
value: RequestAuth,
|
||||
origin: url::Origin,
|
||||
}
|
||||
|
||||
impl RequestAuth {
|
||||
fn can_use_header_transport(&self) -> bool {
|
||||
matches!(
|
||||
@@ -669,6 +673,7 @@ impl Request {
|
||||
redirect_chain: Vec::new(),
|
||||
network_partition_key: None,
|
||||
auth: None,
|
||||
http_authentication: None,
|
||||
cookie_context: NetworkCookieRequestContext::top_level_navigation("GET"),
|
||||
timeout_policy: RequestTimeoutPolicy::default(),
|
||||
network_observation_recorder: None,
|
||||
@@ -714,6 +719,7 @@ impl Request {
|
||||
redirect_chain: Vec::new(),
|
||||
network_partition_key: None,
|
||||
auth: None,
|
||||
http_authentication: None,
|
||||
cookie_context: NetworkCookieRequestContext::top_level_navigation("GET"),
|
||||
timeout_policy: RequestTimeoutPolicy::default(),
|
||||
network_observation_recorder: None,
|
||||
@@ -792,6 +798,7 @@ impl Request {
|
||||
redirect_chain: Vec::new(),
|
||||
network_partition_key: None,
|
||||
auth: None,
|
||||
http_authentication: None,
|
||||
cookie_context: NetworkCookieRequestContext::subresource(method),
|
||||
timeout_policy: RequestTimeoutPolicy::default(),
|
||||
network_observation_recorder: None,
|
||||
@@ -1666,35 +1673,52 @@ impl Request {
|
||||
}
|
||||
|
||||
pub fn auth(&self) -> Option<&RequestAuth> {
|
||||
self.auth.as_ref().map(|auth| &auth.credentials)
|
||||
self.configured_auth()
|
||||
.or_else(|| self.http_authentication.as_ref()?.credentials())
|
||||
}
|
||||
|
||||
pub(crate) fn auth_for_url(&self, request_url: &Url) -> Option<&RequestAuth> {
|
||||
let auth = self.auth.as_ref()?;
|
||||
(auth.credentials.target != RequestAuthTarget::Server
|
||||
|| auth.origin.same_origin(&WebOrigin::from_url(request_url)))
|
||||
.then_some(&auth.credentials)
|
||||
pub(crate) fn configured_auth(&self) -> Option<&RequestAuth> {
|
||||
self.auth.as_ref().map(|auth| &auth.value)
|
||||
}
|
||||
|
||||
pub(crate) fn transport_auth_for_url(&self, url: &Url) -> Option<&RequestAuth> {
|
||||
let configured = self.auth.as_ref()?;
|
||||
let auth = &configured.value;
|
||||
(auth.target != RequestAuthTarget::Server
|
||||
|| (self.allows_credentials_for_url(url) && configured.origin == url.origin()))
|
||||
.then_some(auth)
|
||||
}
|
||||
|
||||
pub fn auth_requires_buffered_transport(&self) -> bool {
|
||||
self.auth()
|
||||
self.configured_auth()
|
||||
.is_some_and(|auth| !auth.can_use_header_transport())
|
||||
}
|
||||
|
||||
pub fn preemptive_server_basic_auth_for_url(&self, request_url: &Url) -> Option<(&str, &str)> {
|
||||
let auth = self.auth_for_url(request_url)?;
|
||||
(auth.target == RequestAuthTarget::Server && auth.scheme == RequestAuthScheme::Basic)
|
||||
.then_some((auth.username.as_str(), auth.password.as_str()))
|
||||
let auth = self
|
||||
.transport_auth_for_url(request_url)
|
||||
.filter(|auth| {
|
||||
auth.target == RequestAuthTarget::Server && auth.scheme == RequestAuthScheme::Basic
|
||||
})
|
||||
.or_else(|| {
|
||||
self.http_authentication
|
||||
.as_ref()?
|
||||
.preemptive_credentials(request_url)
|
||||
})?;
|
||||
(auth.target == RequestAuthTarget::Server
|
||||
&& auth.scheme == RequestAuthScheme::Basic
|
||||
&& self.allows_credentials_for_url(request_url))
|
||||
.then_some((auth.username.as_str(), auth.password.as_str()))
|
||||
}
|
||||
|
||||
pub fn set_auth(&mut self, auth: Option<RequestAuth>) {
|
||||
// Pin credentials to where they were supplied, rather than the mutable
|
||||
// current URL. A later CDP auth response grants new credentials only to
|
||||
// that challenged origin, without authorizing subsequent redirects.
|
||||
self.auth = auth.map(|credentials| ScopedRequestAuth {
|
||||
credentials,
|
||||
origin: WebOrigin::from_url(&self.url),
|
||||
self.auth = auth.map(|value| {
|
||||
Arc::new(ConfiguredRequestAuth {
|
||||
value,
|
||||
origin: self.url.origin(),
|
||||
})
|
||||
});
|
||||
self.http_authentication = None;
|
||||
}
|
||||
|
||||
pub fn with_auth(mut self, auth: RequestAuth) -> Self {
|
||||
|
||||
+150
-37
@@ -70,12 +70,16 @@ const CURLINFO_HTTP_VERSION: curl_sys::CURLINFO = curl_sys::CURLINFO_LONG + 46;
|
||||
static NEXT_FETCH_RUNTIME_ID: AtomicU64 = AtomicU64::new(0);
|
||||
static INSTALL_FETCH_RUNTIME_PANIC_HOOK: Once = Once::new();
|
||||
|
||||
fn curl_runtime_deadline(request: &Request, config: &FetchConfig) -> Option<Instant> {
|
||||
fn curl_runtime_deadline(
|
||||
request: &Request,
|
||||
config: &FetchConfig,
|
||||
started_at: Instant,
|
||||
) -> Option<Instant> {
|
||||
let timeout = request.effective_request_timeout(config);
|
||||
if timeout.is_zero() {
|
||||
None
|
||||
} else {
|
||||
Instant::now().checked_add(timeout)
|
||||
started_at.checked_add(timeout)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -377,6 +381,7 @@ impl FetchRuntimeOwner {
|
||||
crate::client_hints::ClientHintPreferences::default(),
|
||||
)),
|
||||
Arc::default(),
|
||||
Arc::default(),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -385,6 +390,7 @@ impl FetchRuntimeOwner {
|
||||
cookie_store: SharedBrowserCookieStore,
|
||||
client_hint_preferences: SharedClientHintPreferences,
|
||||
dictionaries: crate::compression_dictionary::SharedDictionaryStore,
|
||||
http_authentication: crate::http_authentication::SharedHttpAuthenticationCache,
|
||||
) -> Self {
|
||||
let runtime_id = NEXT_FETCH_RUNTIME_ID
|
||||
.fetch_add(1, Ordering::Relaxed)
|
||||
@@ -404,6 +410,7 @@ impl FetchRuntimeOwner {
|
||||
cookie_store,
|
||||
client_hint_preferences,
|
||||
dictionaries,
|
||||
http_authentication,
|
||||
request_rx,
|
||||
curl_runtime,
|
||||
curl_http,
|
||||
@@ -715,6 +722,7 @@ struct RuntimeOwner {
|
||||
cookie_store: SharedBrowserCookieStore,
|
||||
client_hint_preferences: SharedClientHintPreferences,
|
||||
dictionaries: crate::compression_dictionary::SharedDictionaryStore,
|
||||
http_authentication: crate::http_authentication::SharedHttpAuthenticationCache,
|
||||
request_rx: Receiver<RuntimeCommand>,
|
||||
curl_runtime: CurlMultiRuntime<FetchTransferHandler, ActiveTransferContext>,
|
||||
curl_http: CurlHttpSender<FetchTransferHandler, ActiveTransferContext>,
|
||||
@@ -738,6 +746,12 @@ impl RuntimeOwner {
|
||||
request,
|
||||
url,
|
||||
);
|
||||
prepared.request = crate::http_authentication::HttpAuthenticationCache::prepare_owned(
|
||||
&self.http_authentication,
|
||||
&self.config,
|
||||
prepared.request,
|
||||
url,
|
||||
);
|
||||
prepared.request = crate::compression_dictionary::DictionaryStore::prepare_owned(
|
||||
&self.dictionaries,
|
||||
&self.config,
|
||||
@@ -1047,7 +1061,11 @@ impl RuntimeOwner {
|
||||
let curl_job = CurlMultiJob {
|
||||
easy,
|
||||
origin: context.job.origin_key.clone(),
|
||||
deadline: curl_runtime_deadline(&context.job.request, &self.config),
|
||||
deadline: curl_runtime_deadline(
|
||||
&context.job.request,
|
||||
&self.config,
|
||||
context.job.hop.started_at,
|
||||
),
|
||||
dns_resolution,
|
||||
priority: request_fetch_priority_rank(&context.job.request),
|
||||
label,
|
||||
@@ -1285,7 +1303,11 @@ impl RuntimeOwner {
|
||||
let curl_job = CurlMultiJob {
|
||||
easy,
|
||||
origin: context.job.origin_key.clone(),
|
||||
deadline: curl_runtime_deadline(&context.job.request, &self.config),
|
||||
deadline: curl_runtime_deadline(
|
||||
&context.job.request,
|
||||
&self.config,
|
||||
context.job.hop.started_at,
|
||||
),
|
||||
dns_resolution,
|
||||
priority: request_fetch_priority_rank(&context.job.request),
|
||||
label,
|
||||
@@ -1537,7 +1559,11 @@ impl RuntimeOwner {
|
||||
let curl_job = CurlMultiJob {
|
||||
easy,
|
||||
origin: context.job.origin_key.clone(),
|
||||
deadline: curl_runtime_deadline(&context.job.request, &self.config),
|
||||
deadline: curl_runtime_deadline(
|
||||
&context.job.request,
|
||||
&self.config,
|
||||
context.job.hop.started_at,
|
||||
),
|
||||
dns_resolution,
|
||||
priority: request_fetch_priority_rank(&context.job.request),
|
||||
label,
|
||||
@@ -1579,7 +1605,54 @@ impl RuntimeOwner {
|
||||
.as_ref()
|
||||
.and_then(moli_curl::CurlConnectionTiming::from_easy),
|
||||
);
|
||||
if let Some(easy) = completion.easy.as_mut() {
|
||||
let authentication_retry = if !self.shutdown_requested.load(Ordering::SeqCst)
|
||||
&& !completion.context.is_cancelled()
|
||||
{
|
||||
completion
|
||||
.easy
|
||||
.as_mut()
|
||||
.and_then(|easy| easy.get_mut().http_authentication.as_mut()?.take_retry())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
if let Some(retry) = authentication_retry {
|
||||
let (request, url, cookie_context) = completion.context.request_context();
|
||||
let cookies = if request.allows_credentials_for_url(url) {
|
||||
store_response_cookies(&self.cookie_store, url, &retry.headers, cookie_context)
|
||||
} else {
|
||||
Ok(Vec::new())
|
||||
};
|
||||
match cookies {
|
||||
Ok(_) => {
|
||||
state.active_transfers = state.active_transfers.saturating_sub(1);
|
||||
// No collector received this private 401. Keep the same
|
||||
// logical request, body, cancellation and uncommitted stream
|
||||
// channels; this is an authentication retry, not a redirect.
|
||||
match completion.context {
|
||||
ActiveTransferContext::Buffered(mut context) => {
|
||||
context.job.request.http_authentication = Some(retry.prepared);
|
||||
self.start_job_or_reply(state, context.job);
|
||||
}
|
||||
ActiveTransferContext::Streaming(mut context) => {
|
||||
context.job.request.http_authentication = Some(retry.prepared);
|
||||
context.job.easy = completion.easy;
|
||||
self.start_streaming_job_or_reply(state, context.job);
|
||||
}
|
||||
ActiveTransferContext::StreamingRaw(mut context) => {
|
||||
context.job.request.http_authentication = Some(retry.prepared);
|
||||
context.job.easy = completion.easy;
|
||||
self.start_raw_streaming_job_or_reply(state, context.job);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
Err(error) => completion.result = Err(error),
|
||||
}
|
||||
}
|
||||
if completion.context.is_cancelled() {
|
||||
completion.result = Err(anyhow::Error::new(crate::FetchCancelled)
|
||||
.context("fetch runtime request cancelled"));
|
||||
} else if let Some(easy) = completion.easy.as_mut() {
|
||||
if let Some(error) = easy.get_mut().content_decoding_error.take() {
|
||||
completion.result = Err(anyhow!(error));
|
||||
} else if completion.result.is_ok()
|
||||
@@ -2940,6 +3013,26 @@ enum ActiveTransferContext {
|
||||
}
|
||||
|
||||
impl ActiveTransferContext {
|
||||
fn request_context(&self) -> (&Request, &Url, &NetworkCookieRequestContext) {
|
||||
match self {
|
||||
Self::Buffered(context) => (
|
||||
&context.job.request,
|
||||
&context.job.current_url,
|
||||
&context.job.current_cookie_context,
|
||||
),
|
||||
Self::Streaming(context) => (
|
||||
&context.job.request,
|
||||
&context.job.current_url,
|
||||
&context.job.current_cookie_context,
|
||||
),
|
||||
Self::StreamingRaw(context) => (
|
||||
&context.job.request,
|
||||
&context.job.current_url,
|
||||
&context.job.current_cookie_context,
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
fn response_progress(&self) -> &ResponseProgress {
|
||||
match self {
|
||||
Self::Buffered(context) => &context.job.response_progress,
|
||||
@@ -3020,6 +3113,7 @@ pub(crate) struct FetchTransferHandler {
|
||||
upload_observer: Option<crate::UploadObserver>,
|
||||
proxy_connect_response_recorder: ProxyConnectResponseRecorder,
|
||||
dictionary_response: Option<crate::compression_dictionary::DictionaryResponse>,
|
||||
http_authentication: Option<crate::http_authentication::HttpAuthenticationResponse>,
|
||||
content_decoding: Option<crate::content_decoding::ContentDecoding>,
|
||||
content_decoding_error: Option<String>,
|
||||
}
|
||||
@@ -3074,6 +3168,7 @@ impl FetchTransferHandler {
|
||||
upload_observer: None,
|
||||
proxy_connect_response_recorder: ProxyConnectResponseRecorder::default(),
|
||||
dictionary_response: None,
|
||||
http_authentication: None,
|
||||
content_decoding: None,
|
||||
content_decoding_error: None,
|
||||
}
|
||||
@@ -3135,6 +3230,8 @@ impl FetchTransferHandler {
|
||||
}
|
||||
|
||||
pub(crate) fn begin_dictionary_response(&mut self, request: &Request, url: &Url) {
|
||||
self.http_authentication =
|
||||
crate::http_authentication::HttpAuthenticationResponse::new(request);
|
||||
self.dictionary_response = request.compression_dictionary_store.as_ref().map(|store| {
|
||||
crate::compression_dictionary::DictionaryResponse::new(
|
||||
Arc::clone(store),
|
||||
@@ -3146,6 +3243,41 @@ impl FetchTransferHandler {
|
||||
self.content_decoding_error = None;
|
||||
}
|
||||
|
||||
fn forward_response_header(&mut self, data: &[u8]) -> bool {
|
||||
if crate::response::parse_http_response_status_line(data)
|
||||
.is_some_and(|line| line.status >= 200)
|
||||
{
|
||||
self.content_decoding_error = None;
|
||||
}
|
||||
if let Some(response) = self.dictionary_response.as_mut() {
|
||||
response.header(data);
|
||||
}
|
||||
if let Some(decoding) = self.content_decoding.as_mut() {
|
||||
if let Err(error) = decoding.header(data) {
|
||||
self.content_decoding_error = Some(error.to_string());
|
||||
} else if decoding.needs_readable_dictionary_response()
|
||||
&& self
|
||||
.dictionary_response
|
||||
.as_ref()
|
||||
.is_none_or(|response| !response.readable())
|
||||
{
|
||||
self.content_decoding_error =
|
||||
Some("dictionary response failed its CORS readability check".to_owned());
|
||||
}
|
||||
}
|
||||
if crate::response::parse_http_response_status_line(data)
|
||||
.is_some_and(|line| line.status >= 200)
|
||||
&& let Some(timing) = self.response_progress()
|
||||
{
|
||||
timing.reset_response_body_sizes();
|
||||
}
|
||||
match &mut self.response {
|
||||
FetchResponseCollector::Buffered(collector) => collector.header(data),
|
||||
FetchResponseCollector::Streaming(collector) => collector.header(data),
|
||||
FetchResponseCollector::StreamingRaw(collector) => collector.header(data),
|
||||
}
|
||||
}
|
||||
|
||||
fn finish_dictionary_response(&mut self) -> Result<()> {
|
||||
if let Some(decoding) = self.content_decoding.as_mut() {
|
||||
decoding.finish()?;
|
||||
@@ -3273,40 +3405,21 @@ impl Handler for FetchTransferHandler {
|
||||
}
|
||||
|
||||
fn header(&mut self, data: &[u8]) -> bool {
|
||||
if crate::response::parse_http_response_status_line(data)
|
||||
.is_some_and(|line| line.status >= 200)
|
||||
{
|
||||
self.content_decoding_error = None;
|
||||
}
|
||||
if let Some(response) = self.dictionary_response.as_mut() {
|
||||
response.header(data);
|
||||
}
|
||||
if let Some(decoding) = self.content_decoding.as_mut() {
|
||||
if let Err(error) = decoding.header(data) {
|
||||
self.content_decoding_error = Some(error.to_string());
|
||||
} else if decoding.needs_readable_dictionary_response()
|
||||
&& self
|
||||
.dictionary_response
|
||||
.as_ref()
|
||||
.is_none_or(|response| !response.readable())
|
||||
{
|
||||
self.content_decoding_error =
|
||||
Some("dictionary response failed its CORS readability check".to_owned());
|
||||
}
|
||||
}
|
||||
if crate::response::parse_http_response_status_line(data)
|
||||
.is_some_and(|line| line.status >= 200)
|
||||
&& let Some(timing) = self.response_progress()
|
||||
{
|
||||
timing.reset_response_body_sizes();
|
||||
}
|
||||
if let Some(recorder) = self.network_observation_recorder.as_ref() {
|
||||
recorder.record_response_header_line(data);
|
||||
}
|
||||
match &mut self.response {
|
||||
FetchResponseCollector::Buffered(collector) => collector.header(data),
|
||||
FetchResponseCollector::Streaming(collector) => collector.header(data),
|
||||
FetchResponseCollector::StreamingRaw(collector) => collector.header(data),
|
||||
use crate::http_authentication::AuthenticationHeaderAction;
|
||||
match self
|
||||
.http_authentication
|
||||
.as_mut()
|
||||
.map(|response| response.header(data))
|
||||
{
|
||||
Some(AuthenticationHeaderAction::Defer) => true,
|
||||
Some(AuthenticationHeaderAction::Retry) => false,
|
||||
Some(AuthenticationHeaderAction::Replay(lines)) => {
|
||||
lines.iter().all(|line| self.forward_response_header(line))
|
||||
}
|
||||
Some(AuthenticationHeaderAction::Forward) | None => self.forward_response_header(data),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,442 @@
|
||||
use super::*;
|
||||
|
||||
fn browser_request(url: &str) -> Result<Request> {
|
||||
let origin: moli_url::WebOrigin = (&Url::parse(url)?).into();
|
||||
Ok(Request::get(url)?.with_request_origin(origin))
|
||||
}
|
||||
|
||||
fn credentials(url: &str) -> String {
|
||||
let mut url = Url::parse(url).unwrap();
|
||||
url.set_username("us%65r").unwrap();
|
||||
url.set_password(Some("p%2Bss%3Aword")).unwrap();
|
||||
url.into()
|
||||
}
|
||||
|
||||
fn header<'a>(request: &'a str, name: &str) -> Option<&'a str> {
|
||||
request
|
||||
.lines()
|
||||
.filter_map(|line| line.split_once(':'))
|
||||
.find(|(field, _)| field.eq_ignore_ascii_case(name))
|
||||
.map(|(_, value)| value.trim())
|
||||
}
|
||||
|
||||
fn challenge() -> ScriptedResponse {
|
||||
ScriptedResponse::status(401, "Unauthorized")
|
||||
.with_header("WWW-Authenticate", "Basic realm=\"session\"")
|
||||
.with_header("Cache-Control", "no-store")
|
||||
}
|
||||
|
||||
async fn body(
|
||||
client: &FetchClientHandle,
|
||||
request: Request,
|
||||
transport: &str,
|
||||
) -> Result<(u16, Vec<u8>)> {
|
||||
let response = match transport {
|
||||
"buffered" => {
|
||||
let response = client.fetch(request.with_single_hop()).await?;
|
||||
return Ok((response.status, response.body_text().as_bytes().to_vec()));
|
||||
}
|
||||
"html" => {
|
||||
let response = client
|
||||
.fetch_html_stream(request)
|
||||
.await?
|
||||
.into_materialized_text_response()
|
||||
.await?;
|
||||
return Ok((response.status, response.body_text().as_bytes().to_vec()));
|
||||
}
|
||||
"raw" => client.fetch_raw(request).await?,
|
||||
_ => unreachable!(),
|
||||
};
|
||||
Ok((response.status, response.body_bytes().to_vec()))
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn url_basic_authentication_challenges_then_reuses_session_on_all_transports() -> Result<()> {
|
||||
use base64::Engine;
|
||||
let expected = format!(
|
||||
"Basic {}",
|
||||
base64::engine::general_purpose::STANDARD.encode("user:p+ss:word")
|
||||
);
|
||||
for transport in ["buffered", "html", "raw"] {
|
||||
// The private challenge body exceeds the final response limit; it is
|
||||
// retired at headers without entering the response collector.
|
||||
let server = ScriptedHttpServer::spawn(vec![
|
||||
challenge()
|
||||
.with_body(&"x".repeat(1024))
|
||||
.with_header("Set-Cookie", "challenge=seen; Path=/"),
|
||||
ScriptedResponse::ok("accepted"),
|
||||
ScriptedResponse::ok("reused"),
|
||||
ScriptedResponse::ok("explicit"),
|
||||
]);
|
||||
let mut config = FetchConfig::default();
|
||||
config.set_connection_limits(None, None, Some(64));
|
||||
let client = FetchClient::new(&config, new_shared_browser_cookie_store());
|
||||
let first = browser_request(&credentials(&server.url()))?;
|
||||
assert_eq!(
|
||||
body(&client, first, transport).await?,
|
||||
(200, b"accepted".to_vec())
|
||||
);
|
||||
assert_eq!(
|
||||
body(&client, browser_request(&server.url())?, transport).await?,
|
||||
(200, b"reused".to_vec())
|
||||
);
|
||||
let mut explicit = browser_request(&credentials(&server.url()))?;
|
||||
explicit.credentials_mode = RequestCredentialsMode::Omit;
|
||||
explicit
|
||||
.request_headers
|
||||
.push(("Authorization".into(), b"Bearer author".to_vec()));
|
||||
assert_eq!(
|
||||
body(&client, explicit, transport).await?,
|
||||
(200, b"explicit".to_vec())
|
||||
);
|
||||
let requests = server.requests();
|
||||
assert_eq!(requests.len(), 4, "{transport}");
|
||||
assert_eq!(header(&requests[0], "Authorization"), None);
|
||||
assert_eq!(
|
||||
header(&requests[1], "Authorization"),
|
||||
Some(expected.as_str())
|
||||
);
|
||||
assert_eq!(header(&requests[1], "Cookie"), Some("challenge=seen"));
|
||||
assert_eq!(
|
||||
header(&requests[2], "Authorization"),
|
||||
Some(expected.as_str())
|
||||
);
|
||||
assert_eq!(header(&requests[3], "Authorization"), Some("Bearer author"));
|
||||
assert_eq!(header(&requests[3], "Cookie"), None);
|
||||
server.shutdown();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn browser_url_credentials_respect_cors_and_credentials_mode() -> Result<()> {
|
||||
for (mode, credentials_mode, cross_origin) in [
|
||||
(RequestMode::Cors, RequestCredentialsMode::Include, true),
|
||||
(RequestMode::Cors, RequestCredentialsMode::Omit, false),
|
||||
(
|
||||
RequestMode::NoCors,
|
||||
RequestCredentialsMode::SameOrigin,
|
||||
true,
|
||||
),
|
||||
] {
|
||||
let server = ScriptedHttpServer::spawn(vec![challenge().with_body("final 401")]);
|
||||
let mut request = browser_request(&credentials(&server.url()))?.with_request_mode(mode);
|
||||
request.credentials_mode = credentials_mode;
|
||||
if cross_origin {
|
||||
request = request.with_request_origin((&Url::parse("https://other.test/")?).into());
|
||||
}
|
||||
let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
|
||||
let response = client.fetch_raw(request).await?;
|
||||
assert_eq!(response.status, 401);
|
||||
assert_eq!(response.body_bytes(), b"final 401");
|
||||
assert_eq!(server.hits(), 1);
|
||||
assert_eq!(header(&server.requests()[0], "Authorization"), None);
|
||||
server.shutdown();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn basic_authentication_cache_is_partitioned_and_owned_by_the_client() -> Result<()> {
|
||||
let server = ScriptedHttpServer::spawn(vec![
|
||||
challenge(),
|
||||
ScriptedResponse::ok("accepted"),
|
||||
ScriptedResponse::ok("cached"),
|
||||
challenge(),
|
||||
challenge(),
|
||||
challenge(),
|
||||
]);
|
||||
let cookies = new_shared_browser_cookie_store();
|
||||
let client = FetchClient::new(&FetchConfig::default(), Arc::clone(&cookies));
|
||||
let request = |url: &str, partition: &str| -> Result<Request> {
|
||||
Ok(browser_request(url)?.with_network_partition_key(Some(partition.into())))
|
||||
};
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(request(&credentials(&server.url()), "partition-a")?)
|
||||
.await?
|
||||
.status,
|
||||
200
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(request(&server.url(), "partition-a")?)
|
||||
.await?
|
||||
.status,
|
||||
200
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(request(&server.url(), "partition-b")?)
|
||||
.await?
|
||||
.status,
|
||||
401
|
||||
);
|
||||
let mut omitted = request(&server.url(), "partition-a")?;
|
||||
omitted.credentials_mode = RequestCredentialsMode::Omit;
|
||||
assert_eq!(client.fetch_raw(omitted).await?.status, 401);
|
||||
let other = FetchClient::new(&FetchConfig::default(), cookies);
|
||||
assert_eq!(
|
||||
other
|
||||
.fetch_raw(request(&server.url(), "partition-a")?)
|
||||
.await?
|
||||
.status,
|
||||
401
|
||||
);
|
||||
let requests = server.requests();
|
||||
assert_eq!(requests.len(), 6);
|
||||
for request in &requests[3..] {
|
||||
assert_eq!(header(request, "Authorization"), None);
|
||||
}
|
||||
server.shutdown();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rejected_basic_credentials_stop_after_one_retry_and_evict_cached_identity() -> Result<()> {
|
||||
let server = ScriptedHttpServer::spawn(vec![
|
||||
challenge(),
|
||||
challenge().with_body("rejected"),
|
||||
challenge(),
|
||||
challenge(),
|
||||
ScriptedResponse::ok("accepted"),
|
||||
challenge().with_body("expired"),
|
||||
challenge(),
|
||||
]);
|
||||
let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(browser_request(&credentials(&server.url()))?)
|
||||
.await?
|
||||
.body_bytes(),
|
||||
b"rejected"
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(browser_request(&server.url())?)
|
||||
.await?
|
||||
.status,
|
||||
401
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(browser_request(&credentials(&server.url()))?)
|
||||
.await?
|
||||
.status,
|
||||
200
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(browser_request(&server.url())?)
|
||||
.await?
|
||||
.body_bytes(),
|
||||
b"expired"
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(browser_request(&server.url())?)
|
||||
.await?
|
||||
.status,
|
||||
401
|
||||
);
|
||||
let requests = server.requests();
|
||||
assert_eq!(requests.len(), 7);
|
||||
for index in [0, 2, 3, 6] {
|
||||
assert_eq!(header(&requests[index], "Authorization"), None);
|
||||
}
|
||||
for index in [1, 4, 5] {
|
||||
assert!(header(&requests[index], "Authorization").is_some());
|
||||
}
|
||||
server.shutdown();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unsupported_or_malformed_authentication_challenges_preserve_final_response() -> Result<()>
|
||||
{
|
||||
for challenge in [
|
||||
"Digest realm=\"other\", nonce=\"n\"",
|
||||
"Basic realm=\"unterminated",
|
||||
"Basic realm=",
|
||||
] {
|
||||
let server = ScriptedHttpServer::spawn(vec![
|
||||
ScriptedResponse::status(401, "Unauthorized")
|
||||
.with_header("WWW-Authenticate", challenge)
|
||||
.with_header("X-Final", "retained")
|
||||
.with_body("final body"),
|
||||
]);
|
||||
let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
|
||||
let response = client
|
||||
.fetch_raw(browser_request(&credentials(&server.url()))?)
|
||||
.await?;
|
||||
assert_eq!(response.status, 401);
|
||||
assert_eq!(response.body_bytes(), b"final body");
|
||||
assert!(
|
||||
response
|
||||
.headers
|
||||
.iter()
|
||||
.any(|(name, value)| name == "x-final" && value == b"retained")
|
||||
);
|
||||
assert_eq!(server.hits(), 1);
|
||||
server.shutdown();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cached_and_configured_basic_credentials_do_not_cross_redirect_origins() -> Result<()> {
|
||||
for configured in [false, true] {
|
||||
let target = ScriptedHttpServer::spawn(vec![challenge().with_body("target challenge")]);
|
||||
let redirect =
|
||||
ScriptedResponse::status(302, "Found").with_header("Location", &target.url());
|
||||
let responses = if configured {
|
||||
vec![redirect]
|
||||
} else {
|
||||
vec![challenge(), ScriptedResponse::ok("accepted"), redirect]
|
||||
};
|
||||
let source = ScriptedHttpServer::spawn(responses);
|
||||
let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
|
||||
if !configured {
|
||||
assert_eq!(
|
||||
client
|
||||
.fetch_raw(browser_request(&credentials(&source.url()))?)
|
||||
.await?
|
||||
.status,
|
||||
200
|
||||
);
|
||||
}
|
||||
let mut request = browser_request(&source.url())?.with_request_mode(RequestMode::NoCors);
|
||||
if configured {
|
||||
request = request.with_auth(RequestAuth {
|
||||
target: RequestAuthTarget::Server,
|
||||
scheme: RequestAuthScheme::Basic,
|
||||
username: "explicit".into(),
|
||||
password: "secret".into(),
|
||||
});
|
||||
}
|
||||
let response = client.fetch_raw(request).await?;
|
||||
assert_eq!(response.status, 401);
|
||||
assert_eq!(response.body_bytes(), b"target challenge");
|
||||
assert!(response.redirected);
|
||||
assert_eq!(response.redirect_chain.len(), 1);
|
||||
assert_eq!(target.hits(), 1);
|
||||
assert_eq!(header(&target.requests()[0], "Authorization"), None);
|
||||
assert!(header(source.requests().last().unwrap(), "Authorization").is_some());
|
||||
source.shutdown();
|
||||
target.shutdown();
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn basic_authentication_retry_retains_original_timeout_budget() -> Result<()> {
|
||||
let server = ScriptedHttpServer::spawn(vec![
|
||||
challenge().with_delay_ms(150),
|
||||
ScriptedResponse::ok("late").with_delay_ms(250),
|
||||
]);
|
||||
let mut config = FetchConfig::default();
|
||||
config.set_request_timeout_ms(300);
|
||||
let client = FetchClient::new(&config, new_shared_browser_cookie_store());
|
||||
let error = client
|
||||
.fetch_raw(browser_request(&credentials(&server.url()))?)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert!(
|
||||
error
|
||||
.downcast_ref::<curl::Error>()
|
||||
.is_some_and(curl::Error::is_operation_timedout),
|
||||
"{error:#}"
|
||||
);
|
||||
assert_eq!(server.hits(), 2);
|
||||
server.shutdown();
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn read_upload(stream: &mut tokio::net::TcpStream) -> Result<String> {
|
||||
let mut request = Vec::new();
|
||||
let mut byte = [0];
|
||||
while !request.ends_with(b"\r\n\r\n") {
|
||||
anyhow::ensure!(
|
||||
request.len() < 65536 && stream.read(&mut byte).await? == 1,
|
||||
"incomplete request"
|
||||
);
|
||||
request.push(byte[0]);
|
||||
}
|
||||
let length = header(std::str::from_utf8(&request)?, "Content-Length")
|
||||
.unwrap_or("0")
|
||||
.parse::<usize>()?;
|
||||
let start = request.len();
|
||||
request.resize(start + length, 0);
|
||||
stream.read_exact(&mut request[start..]).await?;
|
||||
Ok(String::from_utf8(request)?)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn basic_authentication_replays_upload_and_keeps_final_body_streaming_and_cancellable()
|
||||
-> Result<()> {
|
||||
for cancel_final_body in [false, true] {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").await?;
|
||||
let url = format!("http://{}/upload", listener.local_addr()?);
|
||||
let (release_tx, release_rx) = oneshot::channel();
|
||||
let server = tokio::spawn(async move {
|
||||
let (mut stream, _) = listener.accept().await?;
|
||||
let first = read_upload(&mut stream).await?;
|
||||
stream.write_all(b"HTTP/1.1 401 Unauthorized\r\nWWW-Authenticate: Basic\r\nContent-Length: 1000000\r\nConnection: close\r\n\r\n").await?;
|
||||
drop(stream);
|
||||
let (mut stream, _) = listener.accept().await?;
|
||||
let second = read_upload(&mut stream).await?;
|
||||
stream
|
||||
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 6\r\nConnection: close\r\n\r\none")
|
||||
.await?;
|
||||
release_rx.await?;
|
||||
let _ = stream.write_all(b"two").await;
|
||||
Ok::<_, anyhow::Error>((first, second))
|
||||
});
|
||||
let client = FetchClient::new(&FetchConfig::default(), new_shared_browser_cookie_store());
|
||||
let mut request = browser_request(&credentials(&url))?;
|
||||
request.method = "POST".into();
|
||||
request.body = Some(bytes::Bytes::from_static(b"payload"));
|
||||
let cancel = FetchCancelHandle::new();
|
||||
let result = tokio::time::timeout(
|
||||
Duration::from_secs(5),
|
||||
client.fetch_raw_stream_with_cancel_and_network_metadata(request, cancel.clone()),
|
||||
)
|
||||
.await??;
|
||||
let (mut response, journal) = result.into_parts_with_observation_journal();
|
||||
assert_eq!(response.status, 200);
|
||||
assert!(!response.redirected);
|
||||
assert!(response.redirect_chain.is_empty());
|
||||
assert_eq!(
|
||||
journal
|
||||
.exchanges()
|
||||
.iter()
|
||||
.map(|exchange| exchange.response().unwrap().status())
|
||||
.collect::<Vec<_>>(),
|
||||
[401, 200]
|
||||
);
|
||||
assert_eq!(
|
||||
tokio::time::timeout(Duration::from_secs(5), response.next_chunk()).await?,
|
||||
Some(b"one".to_vec())
|
||||
);
|
||||
assert!(!cancel.response_completion_is_committed());
|
||||
if cancel_final_body {
|
||||
assert!(cancel.cancel_if_response_pending());
|
||||
}
|
||||
release_tx.send(()).unwrap();
|
||||
if cancel_final_body {
|
||||
let error = response.finish().await.unwrap_err();
|
||||
assert!(crate::is_fetch_cancelled(&error), "{error:#}");
|
||||
} else {
|
||||
assert_eq!(response.next_chunk().await, Some(b"two".to_vec()));
|
||||
response.finish().await?;
|
||||
}
|
||||
let (first, second) = tokio::time::timeout(Duration::from_secs(5), server).await???;
|
||||
for request in [&first, &second] {
|
||||
assert!(request.starts_with("POST /upload HTTP/1.1\r\n"));
|
||||
assert!(request.ends_with("\r\n\r\npayload"));
|
||||
}
|
||||
assert_eq!(header(&first, "Authorization"), None);
|
||||
assert!(header(&second, "Authorization").is_some());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -11,6 +11,7 @@ mod corp;
|
||||
mod fetch_metadata;
|
||||
mod header_bytes;
|
||||
mod header_eof;
|
||||
mod http_authentication;
|
||||
mod mixed_transport;
|
||||
mod redirect_auth;
|
||||
mod redirect_policy;
|
||||
|
||||
@@ -264,7 +264,10 @@ fn redirect_authorization_proxy_credentials_keep_their_independent_scope() -> Re
|
||||
target,
|
||||
..server_auth(RequestAuthScheme::Basic)
|
||||
});
|
||||
assert_eq!(request.auth_for_url(&foreign).unwrap().target, target);
|
||||
assert_eq!(
|
||||
request.transport_auth_for_url(&foreign).unwrap().target,
|
||||
target
|
||||
);
|
||||
assert!(
|
||||
request
|
||||
.preemptive_server_basic_auth_for_url(&foreign)
|
||||
|
||||
@@ -85,7 +85,13 @@ async fn same_origin_window_fetch_and_xhr_post_send_origin_on_wire() {
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn window_xhr_open_freezes_base_url_and_applies_url_credentials() {
|
||||
let server = StaticHttpServer::spawn(1).await;
|
||||
let server = StaticHttpServer::spawn_with_raw_responder(2, |index, _| {
|
||||
if index == 0 {
|
||||
"HTTP/1.1 401 Unauthorized\r\nWWW-Authenticate: Basic realm=\"xhr\"\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_owned()
|
||||
} else {
|
||||
"HTTP/1.1 200 OK\r\nContent-Length: 0\r\nConnection: close\r\n\r\n".to_owned()
|
||||
}
|
||||
}).await;
|
||||
let base_url = server.base_url();
|
||||
let loader = static_http_loader(std::iter::empty::<String>());
|
||||
let mut vm = new_page_task_executor_test_vm_with_loader(
|
||||
@@ -129,10 +135,12 @@ async fn window_xhr_open_freezes_base_url_and_applies_url_credentials() {
|
||||
.await;
|
||||
|
||||
let requests = server.finish().await;
|
||||
assert_eq!(requests.len(), 1);
|
||||
assert_eq!(requests.len(), 2);
|
||||
assert_eq!(requests[0].target, "/first/resource");
|
||||
assert_eq!(requests[0].header_value("authorization"), None);
|
||||
assert_eq!(requests[1].target, "/first/resource");
|
||||
assert_eq!(
|
||||
requests[0].header_value("authorization"),
|
||||
requests[1].header_value("authorization"),
|
||||
Some("Basic YWxpY2U6c2VjcmV0")
|
||||
);
|
||||
}
|
||||
|
||||
@@ -63,6 +63,16 @@ impl StaticHttpServer {
|
||||
expected_requests: usize,
|
||||
response_headers: &'static str,
|
||||
response_body: impl Fn(usize, &CapturedHttpRequest) -> String + Send + 'static,
|
||||
) -> Self {
|
||||
Self::spawn_with_raw_responder(expected_requests, move |index, request| {
|
||||
let body = response_body(index, request);
|
||||
format!("HTTP/1.1 200 OK\r\n{response_headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len())
|
||||
}).await
|
||||
}
|
||||
|
||||
pub(super) async fn spawn_with_raw_responder(
|
||||
expected_requests: usize,
|
||||
response: impl Fn(usize, &CapturedHttpRequest) -> String + Send + 'static,
|
||||
) -> Self {
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
||||
.await
|
||||
@@ -147,17 +157,11 @@ impl StaticHttpServer {
|
||||
headers,
|
||||
body: request[header_end..header_end + content_length].to_vec(),
|
||||
};
|
||||
let body = response_body(index, &captured);
|
||||
let response = response(index, &captured);
|
||||
requests.push(captured);
|
||||
|
||||
socket
|
||||
.write_all(
|
||||
format!(
|
||||
"HTTP/1.1 200 OK\r\n{response_headers}Content-Length: {}\r\nConnection: close\r\n\r\n{body}",
|
||||
body.len()
|
||||
)
|
||||
.as_bytes(),
|
||||
)
|
||||
.write_all(response.as_bytes())
|
||||
.await
|
||||
.expect("write static HTTP test response");
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user