Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(cookies): handle Unicode expiration dates without panicking

ldm09616d01ab1fa
diff --git a/moli-cookie-jar/src/jar.rs b/moli-cookie-jar/src/jar.rs
index 7c48bd952..5f5c70aad 100644
--- a/moli-cookie-jar/src/jar.rs
+++ b/moli-cookie-jar/src/jar.rs
@@ -168,11 +168,10 @@ impl BrowserCookieStore {
}
let normalized = match cookie.split_once(';') {
- Some((first, rest)) if !first.contains('=') => format!("{first}=;{rest}"),
- None if !cookie.contains('=') => format!("{cookie}="),
- _ => cookie.to_owned(),
+ Some((first, rest)) if !first.contains('=') => Cow::Owned(format!("{first}=;{rest}")),
+ None if !cookie.contains('=') => Cow::Owned(format!("{cookie}=")),
+ _ => Cow::Borrowed(cookie),
};
- let normalized = normalize_expires_utc_timezone(&normalized);
let effective_document_url = effective_document_cookie_url(document_url);
let report =
stored_set_report_from_core(self.full_core.set_response_cookie_str_with_access_result(
@@ -227,12 +226,9 @@ impl BrowserCookieStore {
.filter(|(name, _)| name.eq_ignore_ascii_case("set-cookie"))
{
let value = moli_header_field::decode_header_value(value);
- let normalized = normalize_expires_utc_timezone(&value);
reports.push(stored_set_report_from_core(
- self.full_core.set_response_cookie_str_with_access_result(
- normalized.as_ref(),
- &insert_context,
- ),
+ self.full_core
+ .set_response_cookie_str_with_access_result(value.as_ref(), &insert_context),
));
}
if reports.iter().any(StoredCookieSetReport::is_accepted) {
@@ -488,79 +484,6 @@ impl BrowserCookieStore {
}
}
-fn normalize_expires_utc_timezone(raw: &str) -> Cow<'_, str> {
- let mut changed = false;
- let segments = raw
- .split(';')
- .map(|segment| {
- let trimmed = segment.trim_start();
- let Some(eq_index) = trimmed.find('=') else {
- return segment.to_owned();
- };
- let (name, value_with_equals) = trimmed.split_at(eq_index);
- if !name.eq_ignore_ascii_case("expires") {
- return segment.to_owned();
- }
- let value = &value_with_equals[1..];
- let value_trimmed = value.trim_end();
- if value_trimmed.len() < 3
- || !value_trimmed[value_trimmed.len() - 3..].eq_ignore_ascii_case("UTC")
- {
- if !looks_like_http_date_without_timezone(value_trimmed) {
- return segment.to_owned();
- }
- let leading = &segment[..segment.len() - trimmed.len()];
- let trailing = &value[value_trimmed.len()..];
- changed = true;
- return format!("{leading}{name}={value_trimmed} GMT{trailing}");
- }
- let leading = &segment[..segment.len() - trimmed.len()];
- let trailing = &value[value_trimmed.len()..];
- changed = true;
- format!(
- "{leading}{name}={}GMT{trailing}",
- &value_trimmed[..value_trimmed.len() - 3]
- )
- })
- .collect::<Vec<_>>();
- if changed {
- Cow::Owned(segments.join(";"))
- } else {
- Cow::Borrowed(raw)
- }
-}
-
-fn looks_like_http_date_without_timezone(value: &str) -> bool {
- let parts = value.split_ascii_whitespace().collect::<Vec<_>>();
- if parts.len() != 5 {
- return false;
- }
- let [weekday, day, month, year, time] = parts.as_slice() else {
- return false;
- };
- weekday.ends_with(',')
- && weekday[..weekday.len() - 1]
- .chars()
- .all(|ch| ch.is_ascii_alphabetic())
- && day.len() <= 2
- && day.chars().all(|ch| ch.is_ascii_digit())
- && month.len() == 3
- && month.chars().all(|ch| ch.is_ascii_alphabetic())
- && year.len() == 4
- && year.chars().all(|ch| ch.is_ascii_digit())
- && looks_like_http_time(time)
-}
-
-fn looks_like_http_time(value: &str) -> bool {
- let parts = value.split(':').collect::<Vec<_>>();
- if parts.len() != 3 {
- return false;
- }
- parts
- .iter()
- .all(|part| part.len() == 2 && part.chars().all(|ch| ch.is_ascii_digit()))
-}
-
fn canonical_cookie_input_from_stored_cookie(
cookie: &StoredCookie,
request_url_hint: Option<&Url>,
diff --git a/moli-cookie-jar/src/tests.rs b/moli-cookie-jar/src/tests.rs
index 38d5df9c0..7e2ae9bdd 100644
--- a/moli-cookie-jar/src/tests.rs
+++ b/moli-cookie-jar/src/tests.rs
@@ -901,6 +901,131 @@ fn document_cookie_utc_expires_does_not_leave_empty_host_only_shadow() {
assert!(!cookies[0].host_only);
}
+#[test]
+fn document_cookie_multibyte_expires_is_ignored() {
+ let url = parse("https://example.com/cookies");
+
+ for expires in [
+ "é",
+ "éé",
+ "時)",
+ "😀",
+ "2026年10月11日 12時00分00秒 (日本標準時)",
+ "時) \t",
+ ] {
+ let mut store = BrowserCookieStore::default();
+ let cookie = format!("sid=client; Expires={expires}; Path=/");
+
+ let report = store.set_document_cookie_with_report(&url, &cookie);
+
+ assert!(report.is_accepted(), "{expires:?}: {report:?}");
+ assert_eq!(store.document_cookie(&url), "sid=client", "{expires:?}");
+ let cookies = store.cookies();
+ assert_eq!(cookies.len(), 1, "{expires:?}");
+ assert!(cookies[0].expires.is_none(), "{expires:?}");
+ }
+}
+
+#[test]
+fn response_cookie_multibyte_expires_is_ignored() {
+ let url = parse("https://example.com/cookies");
+
+ for expires in [
+ "é",
+ "éé",
+ "時)",
+ "😀",
+ "2026年10月11日 12時00分00秒 (日本標準時)",
+ "時) \t",
+ ] {
+ let mut store = BrowserCookieStore::default();
+ let headers = vec![(
+ "set-cookie".to_owned(),
+ format!("sid=server; Expires={expires}; Path=/").into_bytes(),
+ )];
+
+ let reports = store.store_response_headers_with_reports(&url, &headers);
+
+ assert_eq!(reports.len(), 1, "{expires:?}");
+ assert!(reports[0].is_accepted(), "{expires:?}: {reports:?}");
+ assert_eq!(
+ store.cookie_header(&url).as_deref(),
+ Some("sid=server"),
+ "{expires:?}"
+ );
+ let cookies = store.cookies();
+ assert_eq!(cookies.len(), 1, "{expires:?}");
+ assert!(cookies[0].expires.is_none(), "{expires:?}");
+ }
+}
+
+#[test]
+fn cookie_dates_use_browser_parsing_for_document_and_response_writes() {
+ let url = parse("https://example.com/cookies");
+ let expected = time::Date::from_calendar_date(2037, time::Month::June, 9)
+ .unwrap()
+ .with_hms(19, 21, 5)
+ .unwrap()
+ .assume_utc();
+
+ for expires in [
+ "Tue, 09 Jun 2037 19:21:05 GMT",
+ "Tue, 09 Jun 2037 19:21:05 UTC",
+ "Tue, 09 Jun 2037 19:21:05",
+ "Tue Jun 09 2037 19:21:05 GMT+0900 (日本標準時)",
+ "Tue, 09 Jun 2037 19:21:05 (😀)",
+ ] {
+ for via_response_headers in [false, true] {
+ let mut store = BrowserCookieStore::default();
+ let cookie = format!("sid=value; Expires={expires}; Path=/");
+ if via_response_headers {
+ let reports = store.store_response_headers_with_reports(
+ &url,
+ &[("set-cookie".to_owned(), cookie.into_bytes())],
+ );
+ assert!(reports[0].is_accepted(), "{expires:?}: {reports:?}");
+ } else {
+ let report = store.set_document_cookie_with_report(&url, &cookie);
+ assert!(report.is_accepted(), "{expires:?}: {report:?}");
+ }
+ assert_eq!(store.document_cookie(&url), "sid=value", "{expires:?}");
+ let cookies = store.cookies();
+ assert_eq!(cookies.len(), 1, "{expires:?}");
+ assert_eq!(
+ cookies[0].expires,
+ Some(expected),
+ "{expires:?}, response={via_response_headers}"
+ );
+ }
+ }
+}
+
+#[test]
+fn cookie_named_expires_keeps_its_value() {
+ let url = parse("https://example.com/cookies");
+
+ for value in ["UTC", "Tue, 09 Jun 2037 19:21:05"] {
+ for via_response_headers in [false, true] {
+ let mut store = BrowserCookieStore::default();
+ let cookie = format!("expires={value}; Path=/");
+ if via_response_headers {
+ let reports = store.store_response_headers_with_reports(
+ &url,
+ &[("set-cookie".to_owned(), cookie.into_bytes())],
+ );
+ assert!(reports[0].is_accepted(), "{reports:?}");
+ } else {
+ let report = store.set_document_cookie_with_report(&url, &cookie);
+ assert!(report.is_accepted(), "{report:?}");
+ }
+ assert_eq!(store.document_cookie(&url), format!("expires={value}"));
+ let cookies = store.cookies();
+ assert_eq!(cookies.len(), 1);
+ assert!(cookies[0].expires.is_none());
+ }
+ }
+}
+
#[test]
fn document_cookie_expires_without_timezone_is_treated_as_gmt() {
let mut store = BrowserCookieStore::default();
diff --git a/moli-cookie-store/src/cookie.rs b/moli-cookie-store/src/cookie.rs
index ec6c679f0..15ffbf931 100644
--- a/moli-cookie-store/src/cookie.rs
+++ b/moli-cookie-store/src/cookie.rs
@@ -336,7 +336,7 @@ impl<'a> Cookie<'a> {
where
S: Into<Cow<'a, str>>,
{
- Cookie::try_from_raw_cookie(&RawCookie::parse(cookie_str)?, request_url)
+ Cookie::try_from_raw_cookie(&crate::cookie_date::parse_cookie(cookie_str)?, request_url)
}
/// Create a canonical cookie from structured fields.
diff --git a/moli-cookie-store/src/cookie_date.rs b/moli-cookie-store/src/cookie_date.rs
new file mode 100644
index 000000000..a15e53259
--- /dev/null
+++ b/moli-cookie-store/src/cookie_date.rs
@@ -0,0 +1,251 @@
+use std::borrow::Cow;
+
+use cookie::{Cookie as RawCookie, ParseError};
+use time::{Date, Month, OffsetDateTime, Time};
+
+pub(crate) fn parse_cookie<'a>(
+ input: impl Into<Cow<'a, str>>,
+) -> Result<RawCookie<'a>, ParseError> {
+ let input = input.into();
+ let expires = input
+ .split(';')
+ .skip(1)
+ .filter_map(|attribute| {
+ let (name, value) = attribute.split_once('=').unwrap_or((attribute, ""));
+ name.trim()
+ .eq_ignore_ascii_case("expires")
+ .then_some(value.trim())
+ })
+ .last()
+ .and_then(|value| parse_cookie_date(value.as_bytes()));
+ let mut cookie = RawCookie::parse(input)?;
+ // The dependency recognizes fixed HTTP-date formats. Browser cookie dates
+ // use token parsing instead, with the last Expires attribute taking effect.
+ cookie.unset_expires();
+ if let Some(expires) = expires {
+ cookie.set_expires(expires);
+ }
+ Ok(cookie)
+}
+
+// Follows Chromium's ParseCookieExpirationTime: ASCII token delimiters,
+// numeric prefixes, and the first occurrence of each date field. Timezone
+// tokens are ignored; cookie expiration times are always interpreted as UTC.
+fn parse_cookie_date(input: &[u8]) -> Option<OffsetDateTime> {
+ const MONTHS: [&[u8; 3]; 12] = [
+ b"jan", b"feb", b"mar", b"apr", b"may", b"jun", b"jul", b"aug", b"sep", b"oct", b"nov",
+ b"dec",
+ ];
+ let (mut day, mut month, mut year, mut time) = (None, None, None, None);
+ for token in input
+ .split(|byte| matches!(byte, b'\t' | b' '..=b'/' | b';'..=b'@' | b'['..=b'`' | b'{'..=b'~'))
+ .filter(|token| !token.is_empty())
+ {
+ if !token[0].is_ascii_digit() {
+ if month.is_none() {
+ month = MONTHS
+ .iter()
+ .position(|name| {
+ token
+ .get(..3)
+ .is_some_and(|prefix| prefix.eq_ignore_ascii_case(*name))
+ })
+ .and_then(|index| Month::try_from(index as u8 + 1).ok());
+ }
+ } else if token.contains(&b':') {
+ if time.is_none() {
+ time = parse_time(token);
+ }
+ } else if day.is_none() && token.len() <= 2 {
+ day = parse_number(token);
+ } else if year.is_none() && token.len() <= 5 {
+ year = parse_number(token);
+ }
+ }
+ let year = match year? {
+ year @ 0..=69 => year + 2000,
+ year @ 70..=99 => year + 1900,
+ year => year,
+ };
+ let day = u8::try_from(day?).ok()?;
+ let month = month?;
+ let [hour, minute, second] = time?;
+ let time = Time::from_hms(hour, minute, second).ok()?;
+ if !(1..=31).contains(&day) {
+ return None;
+ }
+ if year > 9999 {
+ return Some(
+ Date::from_calendar_date(9999, Month::December, 31)
+ .ok()?
+ .with_time(Time::MAX)
+ .assume_utc(),
+ );
+ }
+ Some(
+ Date::from_calendar_date(year as i32, month, day)
+ .ok()?
+ .with_time(time)
+ .assume_utc(),
+ )
+}
+
+fn parse_number(input: &[u8]) -> Option<u32> {
+ if !input.first()?.is_ascii_digit() {
+ return None;
+ }
+ input
+ .iter()
+ .take_while(|byte| byte.is_ascii_digit())
+ .try_fold(0_u32, |number, byte| {
+ number.checked_mul(10)?.checked_add(u32::from(byte - b'0'))
+ })
+}
+
+fn parse_time(mut input: &[u8]) -> Option<[u8; 3]> {
+ let mut time = [0; 3];
+ for (index, field) in time.iter_mut().enumerate() {
+ let digits = input
+ .iter()
+ .take(2)
+ .take_while(|byte| byte.is_ascii_digit())
+ .count();
+ *field = u8::try_from(parse_number(&input[..digits])?).ok()?;
+ input = &input[digits..];
+ if index < 2 {
+ input = input.strip_prefix(b":")?;
+ }
+ }
+ Some(time)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn expected_date() -> OffsetDateTime {
+ Date::from_calendar_date(2037, Month::June, 9)
+ .unwrap()
+ .with_hms(19, 21, 5)
+ .unwrap()
+ .assume_utc()
+ }
+
+ #[test]
+ fn browser_date_formats_share_the_same_utc_expiration() {
+ for input in [
+ "Tue, 09 Jun 2037 19:21:05 GMT",
+ "Tuesday, 09-Jun-37 19:21:05 GMT",
+ "Tue Jun 9 19:21:05 2037",
+ "Tue, 9-Jun-2037 19:21:05 GMT",
+ "Tue, 09 Jun 2037 19:21:05 UTC",
+ "Tue, 09 Jun 2037 19:21:05 utc",
+ "Tue, 09 Jun 2037 19:21:05",
+ "Tue Jun 09 2037 19:21:05 GMT+0900 (日本標準時)",
+ "Tue, 09 Jun 2037 19:21:05 GMT (😀)",
+ "2037 June 9 19:21:05",
+ "19:21:05 2037 Jun 9",
+ "9 Jun 2037 ::00 19:21:05",
+ "9 Jun 2037 19:21:05 01:02:03",
+ "9 Jun 2037 19:21:05:00",
+ "9 Jun 2037 256:00:00 19:21:05",
+ "9 Jun 2037 19:21:05日本",
+ "9x Jun 2037 19:21:05",
+ "9 Jun 2037x 19:21:05",
+ ] {
+ assert_eq!(
+ parse_cookie_date(input.as_bytes()),
+ Some(expected_date()),
+ "{input:?}"
+ );
+ }
+ assert_eq!(
+ parse_cookie_date(b"9 Jun 2037 19:21:05 (\xff\xfe)"),
+ Some(expected_date())
+ );
+ }
+
+ #[test]
+ fn malformed_or_incomplete_dates_are_ignored() {
+ for input in [
+ "",
+ "é",
+ "éé",
+ "時)",
+ "😀",
+ "2026年10月11日 12時00分00秒 (日本標準時)",
+ "9 Jun 2037",
+ "9 2037 19:21:05",
+ "Jun 2037 19:21:05",
+ "9 Jun 19:21:05",
+ "0 Jun 2037 19:21:05",
+ "32 Jun 2037 19:21:05",
+ "29 Feb 2037 19:21:05",
+ "31 Apr 2037 19:21:05",
+ "009 Jun 2037 19:21:05",
+ "9 Jun 123456 19:21:05",
+ "9 Jun 2037 24:00:00",
+ "9 Jun 2037 19:60:05",
+ "9 Jun 2037 19:21:60",
+ "9 Jun 2037 19::05",
+ "9 Jun 2037 19:21",
+ "9 Jun 2037 019:21:05",
+ "9 Jun 2037 19:021:05",
+ "9 Jun 2037 99:00:00 19:21:05",
+ ] {
+ assert_eq!(parse_cookie_date(input.as_bytes()), None, "{input:?}");
+ }
+ }
+
+ #[test]
+ fn abbreviated_years_and_single_digit_time_fields_are_supported() {
+ for (input, year) in [
+ ("1 Jan 00 1:2:3", 2000),
+ ("1 Jan 69 1:2:3", 2069),
+ ("1 Jan 70 1:2:3", 1970),
+ ("1 Jan 99 1:2:3", 1999),
+ ] {
+ let expected = Date::from_calendar_date(year, Month::January, 1)
+ .unwrap()
+ .with_hms(1, 2, 3)
+ .unwrap()
+ .assume_utc();
+ assert_eq!(
+ parse_cookie_date(input.as_bytes()),
+ Some(expected),
+ "{input:?}"
+ );
+ }
+ }
+
+ #[test]
+ fn out_of_range_years_remain_persistent_dates() {
+ assert_eq!(parse_cookie_date(b"1 Jan 1600 0:0:0").unwrap().year(), 1600);
+ assert_eq!(
+ parse_cookie_date(b"1 Jan 10000 0:0:0").unwrap(),
+ Date::from_calendar_date(9999, Month::December, 31)
+ .unwrap()
+ .with_time(Time::MAX)
+ .assume_utc()
+ );
+ }
+
+ #[test]
+ fn last_expires_attribute_is_authoritative_even_when_invalid() {
+ for (suffix, expected) in [
+ ("", Some(expected_date())),
+ ("; Expires=invalid", None),
+ ("; Expires", None),
+ ("; Expires=", None),
+ (
+ "; eXpIrEs=9 Jun 2037 19:21:05 (日本標準時)",
+ Some(expected_date()),
+ ),
+ ] {
+ let input = format!("sid=value; Expires=Tue, 09 Jun 2037 19:21:05 GMT{suffix}");
+ let cookie = parse_cookie(input).unwrap();
+ assert_eq!(cookie.expires_datetime(), expected, "{suffix:?}");
+ assert_eq!(cookie.name_value(), ("sid", "value"));
+ }
+ }
+}
diff --git a/moli-cookie-store/src/cookie_store/write.rs b/moli-cookie-store/src/cookie_store/write.rs
index 0f709063c..ecf87ed06 100644
--- a/moli-cookie-store/src/cookie_store/write.rs
+++ b/moli-cookie-store/src/cookie_store/write.rs
@@ -1,4 +1,4 @@
-use cookie::{Cookie as RawCookie, SameSite};
+use cookie::SameSite;
use url::Url;
use crate::cookie::{CanonicalCookieInput, Cookie};
@@ -45,7 +45,7 @@ impl CookieStore {
context: &InsertContext<'_>,
) -> CookieSetAccessResult {
let sanitized = sanitize_cookie_line_for_browser_parse(cookie_str);
- match RawCookie::parse(sanitized.line.as_ref())
+ match crate::cookie_date::parse_cookie(sanitized.line.as_ref())
.map_err(CookieError::from)
.and_then(|cookie| {
Cookie::try_from_raw_cookie(&cookie, context.url).map(Cookie::into_owned)
diff --git a/moli-cookie-store/src/lib.rs b/moli-cookie-store/src/lib.rs
index 62df5c5a3..0ca68f43f 100644
--- a/moli-cookie-store/src/lib.rs
+++ b/moli-cookie-store/src/lib.rs
@@ -13,6 +13,7 @@
pub use ::cookie::{Cookie as RawCookie, ParseError as RawCookieParseError, SameSite};
mod cookie;
+mod cookie_date;
pub use crate::cookie::Error as CookieError;
pub use crate::cookie::{
CanonicalCookieInput, Cookie, CookiePartitionKey, CookiePriority, CookieResult,