diff --git a/moli-renderer-v8/src/script_vm/security_policy.rs b/moli-renderer-v8/src/script_vm/security_policy.rs index 90674c98ec5..cb21a9cebba 100644 --- a/moli-renderer-v8/src/script_vm/security_policy.rs +++ b/moli-renderer-v8/src/script_vm/security_policy.rs @@ -1,4 +1,5 @@ use std::pin::pin; +use std::sync::atomic::{AtomicU64, Ordering}; use anyhow::Result; @@ -148,6 +149,7 @@ pub(crate) fn string_code_generation_check_callback<'s>( source: v8::Local<'s, v8::Value>, is_code_like: bool, ) -> v8::ModifyCodeGenerationFromStringsResult<'s> { + let original_source = source; let worker_trusted_types_requirements = crate::worker::worker_trusted_types_for_script_requirements(scope); let (trusted_types_requirements, allow_trusted_types_eval, host_ptr) = @@ -159,7 +161,7 @@ pub(crate) fn string_code_generation_check_callback<'s>( ) } else { let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { - return code_generation_result(true, None); + return allowed_code_generation_result(scope, source, None); }; ( unsafe { &*host_ptr }.trusted_types_for_script_requirements(scope), @@ -282,11 +284,107 @@ pub(crate) fn string_code_generation_check_callback<'s>( } None => None, }; - return code_generation_result(true, replacement); + return allowed_code_generation_result(scope, original_source, replacement); } StringCodeGenerationPolicyAction::Block => false, }; - code_generation_result(codegen_allowed, None) + if codegen_allowed { + allowed_code_generation_result(scope, original_source, None) + } else { + code_generation_result(false, None) + } +} + +fn allowed_code_generation_result<'s>( + scope: &mut v8::PinScope<'s, '_>, + original_source: v8::Local<'s, v8::Value>, + modified_source: Option>, +) -> v8::ModifyCodeGenerationFromStringsResult<'s> { + let original_string = v8::Local::::try_from(original_source).ok(); + let Some(source) = modified_source.or(original_string) else { + return code_generation_result(true, modified_source); + }; + let is_dynamic_function = original_string + .is_some_and(|source| is_dynamic_function_source(scope, source)) + || is_dynamic_function_source(scope, source); + if !is_dynamic_function { + return code_generation_result(true, modified_source); + } + + // V8's Function-constructor cache keys include the native-context closure + // but omit the active Script/Module. A cached function can consequently + // keep another script's dynamic-import base URL and fetch options. + let script_id = v8::StackTrace::current_stack_trace(scope, 1) + // V8's GetFrame does not bounds-check an empty trace, including when + // a host call or cross-origin boundary hides all JavaScript frames. + .filter(|trace| trace.get_frame_count() != 0) + .and_then(|trace| trace.get_frame(scope, 0)) + .filter(|frame| frame.is_user_javascript()) + .map(|frame| frame.get_script_id()) + .filter(|id| *id != 0); + let origin = if let Some(script_id) = script_id { + format!("script-{script_id}") + } else { + // A host call or a security boundary can leave no visible JS frame. + // Give such compilations distinct keys rather than sharing provenance. + static NEXT_UNATTRIBUTED_COMPILATION: AtomicU64 = AtomicU64::new(1); + let Ok(id) = NEXT_UNATTRIBUTED_COMPILATION.fetch_update( + Ordering::Relaxed, + Ordering::Relaxed, + |id| id.checked_add(1), + ) else { + return code_generation_result(false, None); + }; + format!("host-{id}") + }; + // Keep the key outside the FunctionExpression: neither Function#toString + // nor parameter/body source positions change. Concat preserves UTF-16, + // including lone surrogates, without a lossy Rust string conversion. + // A line comment cannot close an invalid, unterminated block comment in + // a Trusted Types policy's replacement source. + let Some(suffix) = v8::String::new(scope, &format!("\n// moli-function-origin:{origin}")) + else { + return code_generation_result(false, None); + }; + let Some(source) = v8::String::concat(scope, source, suffix) else { + return code_generation_result(false, None); + }; + code_generation_result(true, Some(source)) +} + +fn is_dynamic_function_source( + scope: &v8::PinScope<'_, '_>, + source: v8::Local<'_, v8::String>, +) -> bool { + if source.length() < 3 { + return false; + } + let mut prefix = [0_u16; 32]; + source.write_v2(scope, 0, &mut prefix, v8::WriteFlags::empty()); + let matches_prefix = [ + "(function anonymous(", + "(function* anonymous(", + "(async function anonymous(", + "(async function* anonymous(", + ] + .into_iter() + .any(|candidate| { + prefix[..candidate.len()] + .iter() + .copied() + .eq(candidate.encode_utf16()) + }); + if !matches_prefix { + return false; + } + let mut suffix = [0_u16; 3]; + source.write_v2( + scope, + (source.length() - suffix.len()) as u32, + &mut suffix, + v8::WriteFlags::empty(), + ); + suffix == [u16::from(b'\n'), u16::from(b'}'), u16::from(b')')] } fn code_generation_result<'s>( diff --git a/moli-renderer-v8/src/script_vm/tests/string_timers.rs b/moli-renderer-v8/src/script_vm/tests/string_timers.rs index 33db3477b2a..953da8b6c9b 100644 --- a/moli-renderer-v8/src/script_vm/tests/string_timers.rs +++ b/moli-renderer-v8/src/script_vm/tests/string_timers.rs @@ -59,6 +59,189 @@ fn assert_import_nonce(vm: &mut ScriptVm, base_url: &Url, nonce: Option<&str>) { ); } +#[test] +fn dynamic_function_imports_preserve_each_initiators_nonce_for_identical_source() { + let mut vm = new_storage_test_vm("https://function-nonce.test/page.html"); + let script_url = Url::parse("https://function-nonce.test/scripts/same.js").unwrap(); + for nonce in [Some("first-nonce"), None, Some("last-nonce")] { + execute_nonce_script( + &mut vm, + r#"(new Function('x', 'return import(x)'))('./dependency.mjs');"#, + &script_url, + nonce, + ); + let request = vm + .document_runtime + .take_next_native_dynamic_module_import() + .expect("the Function should queue a dynamic import") + .into_dynamic_import_request(); + assert_eq!(request.specifier(), "./dependency.mjs"); + assert_eq!(request.base_url(), &script_url); + assert_eq!(request.fetch_metadata().nonce(), nonce); + assert_eq!( + request.fetch_metadata().credentials_mode, + moli_fetch::RequestCredentialsMode::Include + ); + assert_eq!( + request + .fetch_metadata() + .request_metadata + .referrer_policy + .as_deref(), + Some("no-referrer") + ); + assert!(request.fetch_metadata().parser_inserted); + assert!( + request + .fetch_metadata() + .request_metadata + .integrity + .is_none() + ); + } +} + +#[test] +fn dynamic_function_imports_keep_creation_metadata_when_invoked_by_another_script() { + let mut vm = new_storage_test_vm("https://function-origin.test/page.html"); + let initiators = [ + ( + "https://function-origin.test/alpha/source.js", + Some("alpha"), + ), + ("https://function-origin.test/beta/source.js", None), + ( + "https://function-origin.test/gamma/source.js", + Some("gamma"), + ), + ]; + for (url, nonce) in initiators { + execute_nonce_script( + &mut vm, + r#"(globalThis.importers ??= []).push(new Function('x', 'return import(x)'));"#, + &Url::parse(url).unwrap(), + nonce, + ); + } + execute_nonce_script( + &mut vm, + "importers.forEach(importer => importer('./dependency.mjs'));", + &Url::parse("https://function-origin.test/caller/source.js").unwrap(), + Some("caller"), + ); + for (url, nonce) in initiators { + let request = vm + .document_runtime + .take_next_native_dynamic_module_import() + .expect("each created Function should queue its own import") + .into_dynamic_import_request(); + assert_eq!(request.base_url(), &Url::parse(url).unwrap()); + assert_eq!(request.fetch_metadata().nonce(), nonce); + } +} + +#[test] +fn dynamic_function_imports_keep_origins_for_async_and_generator_constructors() { + for expression in [ + "new (async function() {}).constructor('x', 'return import(x)')('./dependency.mjs')", + "new (function*() {}).constructor('x', 'yield import(x)')('./dependency.mjs').next()", + "new (async function*() {}).constructor('x', 'yield import(x)')('./dependency.mjs').next()", + ] { + let mut vm = new_storage_test_vm("https://function-kinds.test/page.html"); + let script_url = Url::parse("https://function-kinds.test/initiator.js").unwrap(); + for nonce in [Some("first"), None, Some("last")] { + execute_nonce_script(&mut vm, expression, &script_url, nonce); + let request = vm + .document_runtime + .take_next_native_dynamic_module_import() + .expect("each constructor kind should queue an import") + .into_dynamic_import_request(); + assert_eq!(request.base_url(), &script_url); + assert_eq!(request.fetch_metadata().nonce(), nonce); + } + } +} + +#[test] +fn dynamic_function_origin_keys_preserve_source_utf16_and_parameter_validation() { + let mut vm = new_storage_test_vm("https://function-source.test/page.html"); + let result = vm.eval(r#"(() => { + const assert = (condition, message) => { if (!condition) throw new Error(message); }; + const cases = [ + [Function, 'function'], + [(function*() {}).constructor, 'function*'], + [(async function() {}).constructor, 'async function'], + [(async function*() {}).constructor, 'async function*'], + ]; + for (const [Constructor, prefix] of cases) { + const f = Constructor('x', 'return x;'); + assert(f.toString() === prefix + ' anonymous(x\n) {\nreturn x;\n}', 'source text'); + assert(f.name === 'anonymous' && f.length === 1, 'name and length'); + assert(Object.getPrototypeOf(f) === Constructor.prototype, 'function prototype'); + } + const surrogate = String.fromCharCode(0xd800); + const body = 'return "' + surrogate + '";'; + const f = Function(body); + assert(f().charCodeAt(0) === 0xd800, 'lone surrogate value'); + assert(f.toString() === 'function anonymous(\n) {\n' + body + '\n}', 'lone surrogate source'); + const earlyError = (params, body) => { + try { Function(params, body); } catch (error) { return error instanceof SyntaxError; } + return false; + }; + Function('', 'function anonymous(\n/**/) {\n}'); + assert(earlyError('\n/**/) {\nfunction anonymous(', '}'), 'cache must retain parameter boundary'); + assert(earlyError('/*', '*/ ) {'), 'parameters and body parse separately'); + assert(earlyError('a = 1', '"use strict";'), 'non-simple strict parameters'); + const sourceURL = Function('throw new Error("source URL");\n//# sourceURL=created-function.js'); + try { sourceURL(); } catch (error) { + assert(error.stack.includes('created-function.js'), 'source URL'); + } + return 'ok'; + })()"#).expect("Function origin keys must preserve ordinary source semantics"); + assert_eq!(result, "ok"); +} + +#[test] +fn dynamic_function_origin_keys_preserve_trusted_types_source_checks() { + let mut vm = new_storage_test_vm("https://function-trusted-source.test/page.html"); + vm.set_response_content_security_policies(&[ + "require-trusted-types-for 'script'; script-src 'unsafe-eval'".to_owned(), + ]); + let result = vm + .eval( + r#"(() => { + let transform = false; + let replacement = '(function anonymous(\n) {\nreturn 7;\n}) /*'; + const seen = []; + trustedTypes.createPolicy('default', {createScript: source => { + seen.push(source); + return transform ? replacement : source; + }}); + let invalidError; + try { Function('return 1; /*'); } catch (error) { invalidError = error.name; } + if (invalidError !== 'SyntaxError') throw new Error('invalid source was repaired'); + const f = Function('return 1;'); + if (f() !== 1 || f.toString() !== 'function anonymous(\n) {\nreturn 1;\n}') { + throw new Error('identity policy changed source'); + } + const offered = seen[seen.length - 1]; + if (offered !== f.toString() && offered !== '(' + f.toString() + ')') { + throw new Error('policy received host-modified source'); + } + transform = true; + for (const source of [replacement, '(function anonymous(\n) {\nreturn 7;\n})']) { + replacement = source; + let transformedError; + try { Function('return 1;'); } catch (error) { transformedError = error.name; } + if (transformedError !== 'EvalError') throw new Error('transformed source was accepted'); + } + return 'ok'; + })()"#, + ) + .expect("cache keys must preserve Trusted Types replacement syntax"); + assert_eq!(result, "ok"); +} + #[test] fn string_timers_preserve_fetch_options_for_timeout_interval_and_nested_source() { for (source, timer_turns) in [