fix(scripts): keep Function import provenance distinct in V8 caches

V8 caches Function-constructor source without the active script identity,
so later functions can inherit another script's import base URL and nonce.
Add an origin discriminator outside the generated FunctionExpression after
the CSP and Trusted Types checks, retaining the original source and
parameter/body offsets. Keep the other V8 compilation caches enabled.

Cover nonce removal, delayed calls from a different script, async and
generator constructors, UTF-16 and toString preservation, parameter
validation, and invalid Trusted Types replacement source.
This commit is contained in:
ldm0
2026-11-05 05:41:35 +08:00
parent afbfe7c634
commit 1bda521175
2 changed files with 284 additions and 3 deletions
@@ -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::Local<'s, v8::String>>,
) -> v8::ModifyCodeGenerationFromStringsResult<'s> {
let original_string = v8::Local::<v8::String>::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>(
@@ -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 [