Skip to content

armgit / moli

Public Imported from GitHub
0

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

12.5 KB
Raw Blame
use cookie::SameSite;
use url::Url;

use crate::cookie::{CanonicalCookieInput, Cookie};
use crate::utils::{is_secure, is_trustworthy_non_cryptographic};
use crate::CookieError;

use super::policy::*;
use super::write_policy::*;
use super::*;

impl CookieStore {
    /// Parses a new `Cookie` from `cookie_str` and inserts it into the store.
    pub fn parse(&mut self, cookie_str: &str, request_url: &Url) -> InsertResult {
        Cookie::parse(cookie_str, request_url)
            .and_then(|cookie| self.insert(cookie.into_owned(), request_url))
    }

    /// Parses a `Set-Cookie` header value and inserts it into the store.
    pub fn insert_response_cookie_str(
        &mut self,
        cookie_str: &str,
        request_url: &Url,
    ) -> InsertResult {
        self.set_response_cookie_str_with_context(cookie_str, &inferred_insert_context(request_url))
            .into_insert_result()
    }

    /// Parse a `Set-Cookie` header value and apply it using an explicit
    /// browser/API insertion context.
    pub fn set_response_cookie_str_with_context(
        &mut self,
        cookie_str: &str,
        context: &InsertContext<'_>,
    ) -> CookieSetResult {
        self.set_response_cookie_str_with_access_result(cookie_str, context)
            .into_set_result()
    }

    /// Parse a `Set-Cookie` header value and apply it using an explicit
    /// browser/API insertion context, returning a rich browser-style result.
    pub fn set_response_cookie_str_with_access_result(
        &mut self,
        cookie_str: &str,
        context: &InsertContext<'_>,
    ) -> CookieSetAccessResult {
        let sanitized = sanitize_cookie_line_for_browser_parse(cookie_str);
        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)
            }) {
            Ok(cookie) => self.set_with_access_result_chain(
                cookie,
                context,
                CookieSetAccessResult {
                    status: CookieSetResult::Accepted(StoreAction::Inserted),
                    rejection_reasons: Vec::new(),
                    warning_reasons: sanitized.warning_reasons,
                    effective_same_site: None,
                },
            ),
            Err(error) => {
                let reason = CookieSetRejectionReason::from(error);
                CookieSetAccessResult {
                    status: CookieSetResult::Rejected(reason),
                    rejection_reasons: vec![reason],
                    warning_reasons: sanitized.warning_reasons,
                    effective_same_site: None,
                }
            }
        }
    }

    /// Parse a `Set-Cookie` header value and insert it into the store using an
    /// explicit browser/API context.
    pub fn insert_response_cookie_str_with_context(
        &mut self,
        cookie_str: &str,
        context: &InsertContext<'_>,
    ) -> InsertResult {
        self.set_response_cookie_str_with_access_result(cookie_str, context)
            .into_insert_result()
    }

    /// Construct and store a canonical cookie from structured fields using an
    /// explicit browser/API context.
    pub fn set_canonical_cookie_with_context(
        &mut self,
        input: CanonicalCookieInput,
        context: &InsertContext<'_>,
    ) -> CookieSetResult {
        self.set_canonical_cookie_with_access_result(input, context)
            .into_set_result()
    }

    /// Construct and store a canonical cookie from structured fields using an
    /// explicit browser/API context, returning a rich browser-style result.
    pub fn set_canonical_cookie_with_access_result(
        &mut self,
        input: CanonicalCookieInput,
        context: &InsertContext<'_>,
    ) -> CookieSetAccessResult {
        match Cookie::try_from_canonical_input(input, context.url) {
            Ok(cookie) => self.set_with_access_result(cookie, context),
            Err(error) => rejected_set_access_result(error.into()),
        }
    }

    /// Construct and store a canonical cookie from structured fields while
    /// continuing an existing rich set result.
    pub fn set_canonical_cookie_with_access_result_chain(
        &mut self,
        input: CanonicalCookieInput,
        context: &InsertContext<'_>,
        prior_result: CookieSetAccessResult,
    ) -> CookieSetAccessResult {
        match Cookie::try_from_canonical_input(input, context.url) {
            Ok(cookie) => self.set_with_access_result_chain(cookie, context, prior_result),
            Err(error) => merge_rejected_set_access_result(prior_result, error.into()),
        }
    }

    /// Inserts `cookie`, received from `request_url`, into the store.
    pub fn insert(&mut self, cookie: Cookie<'static>, request_url: &Url) -> InsertResult {
        self.set_with_context(cookie, &inferred_insert_context(request_url))
            .into_insert_result()
    }

    /// Insert a canonical cookie using an explicit browser/API context.
    pub fn set_with_context(
        &mut self,
        cookie: Cookie<'static>,
        context: &InsertContext<'_>,
    ) -> CookieSetResult {
        self.set_with_access_result(cookie, context)
            .into_set_result()
    }

    /// Insert a canonical cookie using an explicit browser/API context and
    /// return a rich browser-style result.
    pub fn set_with_access_result(
        &mut self,
        cookie: Cookie<'static>,
        context: &InsertContext<'_>,
    ) -> CookieSetAccessResult {
        self.set_with_access_result_chain(cookie, context, provisional_set_access_result())
    }

    /// Insert a canonical cookie using an explicit browser/API context while
    /// continuing an existing rich set result.
    pub fn set_with_access_result_chain(
        &mut self,
        mut cookie: Cookie<'static>,
        context: &InsertContext<'_>,
        mut prior_result: CookieSetAccessResult,
    ) -> CookieSetAccessResult {
        if matches!(prior_result.status, CookieSetResult::Rejected(_)) {
            return prior_result;
        }

        if cookie.partitioned().unwrap_or(false) && cookie.partition_key().is_none() {
            cookie.set_partition_key(context.browser_context.cookie_partition_key.clone());
        } else if !cookie.partitioned().unwrap_or(false) {
            cookie.set_partition_key(None);
        }

        if prior_result.effective_same_site.is_none() {
            prior_result.effective_same_site = Some(effective_same_site(&cookie));
        }
        if cookie.secure().unwrap_or(false) && is_trustworthy_non_cryptographic(context.url) {
            prior_result.add_warning(CookieSetWarningReason::SecureAccessGrantedNonCryptographic);
        }

        for reason in collect_preinsert_rejection_reasons(self, &cookie, context) {
            prior_result.add_rejection(reason);
        }
        if matches!(prior_result.status, CookieSetResult::Rejected(_)) {
            return prior_result;
        }

        match self.insert_with_context_impl(cookie, context) {
            Ok(action) => {
                prior_result.status = CookieSetResult::Accepted(action);
                prior_result
            }
            Err(error) => {
                prior_result.add_rejection(error.into());
                prior_result
            }
        }
    }

    /// Insert a canonical cookie using an explicit browser/API context.
    pub fn insert_with_context(
        &mut self,
        cookie: Cookie<'static>,
        context: &InsertContext<'_>,
    ) -> InsertResult {
        self.set_with_access_result(cookie, context)
            .into_insert_result()
    }

    fn insert_with_context_impl(
        &mut self,
        cookie: Cookie<'static>,
        context: &InsertContext<'_>,
    ) -> InsertResult {
        let request_url = context.url;
        let cookie = canonicalize_cookie_for_store_checks(self, cookie, request_url)?;

        if cookie.http_only().unwrap_or(false) && context.source == CookieAccessSource::Document {
            return Err(CookieError::NonHttpScheme);
        }
        if context.enforce_browser_policy
            && cookie.secure().unwrap_or(false)
            && !is_secure(request_url)
        {
            return Err(CookieError::SecureOnly);
        }
        if context.enforce_browser_policy
            && cookie.same_site() == Some(SameSite::None)
            && !cookie.secure().unwrap_or(false)
        {
            return Err(CookieError::SameSiteNoneRequiresSecure);
        }
        if context.enforce_browser_policy
            && cookie_name_value_too_large(cookie.name(), cookie.value())
        {
            return Err(CookieError::NameValueTooLarge);
        }
        if cookie.partitioned().unwrap_or(false) {
            if context.enforce_browser_policy && !cookie.secure().unwrap_or(false) {
                return Err(CookieError::PartitionedRequiresSecure);
            }
            if cookie.partition_key().is_none() {
                return Err(CookieError::PartitionedMissingPartitionKey);
            }
        }
        if context.enforce_browser_policy && !prefixes_are_valid(&cookie) {
            return Err(CookieError::PrefixViolation);
        }
        if !cookie.domain.matches(request_url) {
            return Err(CookieError::DomainMismatch);
        }
        if context.enforce_browser_policy
            && context.source != CookieAccessSource::Cdp
            && !cookie.secure().unwrap_or(false)
            && !is_secure(request_url)
            && self.has_secure_overlay_conflict(&cookie)
        {
            return Err(CookieError::SecureOverlay);
        }

        {
            let cookie_domain = cookie
                .domain
                .as_cow()
                .ok_or(CookieError::UnspecifiedDomain)?;
            if let Some(old_cookie) = self.get_mut_with_partition_key(
                &cookie_domain,
                &cookie.path,
                cookie.name(),
                cookie.partition_key(),
            ) {
                if old_cookie.http_only().unwrap_or(false)
                    && context.source == CookieAccessSource::Document
                {
                    return Err(CookieError::NonHttpScheme);
                } else if cookie.is_expired() {
                    old_cookie.expire();
                    return Ok(StoreAction::ExpiredExisting);
                }
            }
        }

        if !cookie.is_expired() {
            let mut cookie = cookie;
            let cookie_domain = String::from(&cookie.domain);
            let cookie_path = String::from(&cookie.path);
            let cookie_name = cookie.name().to_owned();
            let cookie_key = CookieKey::for_cookie(&cookie);
            let existing_creation_index = self
                .get_with_partition_key(
                    &cookie_domain,
                    &cookie_path,
                    &cookie_name,
                    cookie.partition_key(),
                )
                .map(|existing| existing.creation_index());
            let replacing_existing = existing_creation_index.is_some();
            if !self.make_room_for_cookie(
                &cookie_domain,
                cookie.partition_key(),
                cookie.secure().unwrap_or(false),
                replacing_existing,
            ) {
                return Err(CookieError::StorageFull);
            }
            let creation_index = if let Some(creation_index) = existing_creation_index {
                creation_index
            } else {
                // Expired tombstones should not count as an in-place replacement. Remove any
                // stale entry for this key before inserting so quota checks and store actions
                // treat the new cookie as a fresh live entry.
                let _ = self.remove_with_partition_key(
                    &cookie_domain,
                    &cookie_path,
                    &cookie_name,
                    cookie.partition_key(),
                );
                self.bump_creation_index()
            };
            cookie.set_creation_index(creation_index);
            cookie.touch_with_access_index(self.bump_access_index());
            Ok(
                if self
                    .cookies
                    .entry(cookie_domain)
                    .or_default()
                    .entry(cookie_path)
                    .or_default()
                    .insert(cookie_key, cookie)
                    .is_none()
                {
                    StoreAction::Inserted
                } else {
                    StoreAction::UpdatedExisting
                },
            )
        } else {
            Err(CookieError::Expired)
        }
    }
}