EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
fix(expr): bound runtime parser and native recursion depth (#2124, #2125)
Barzabel6686cc75ca73
diff --git a/crates/expr/src/prelude.js b/crates/expr/src/prelude.jsindex 4da7bc63b..3a43a9d10 100644--- a/crates/expr/src/prelude.js+++ b/crates/expr/src/prelude.js@@ -670,14 +670,17 @@ var __groupHandler = {},};-function __mkGroup(c, l, info) {- var f = function (k) { return f.__get(k); };- delete f.name;- delete f.length;- Object.setPrototypeOf(f, __GroupProto);- f.__c = c; f.__l = l; f.__p = info[0]; f.__info = info;- return new Proxy(f, __groupHandler);-}+// `Proxy` is private to the object model (see "Stack safety" at the end).+var __mkGroup = (function (P) {+ return function (c, l, info) {+ var f = function (k) { return f.__get(k); };+ delete f.name;+ delete f.length;+ Object.setPrototypeOf(f, __GroupProto);+ f.__c = c; f.__l = l; f.__p = info[0]; f.__info = info;+ return new P(f, __groupHandler);+ };+})(Proxy);// Properties ------------------------------------------------------------------------------------@@ -852,9 +855,11 @@ var __propHandler = {},};-function __mkProp(c, l, path) {- return new Proxy(new Prop(c, l, path), __propHandler);-}+var __mkProp = (function (P) {+ return function (c, l, path) {+ return new P(new Prop(c, l, path), __propHandler);+ };+})(Proxy);// Text styles (the Source Text style API) ------------------------------------------------------// A TextStyle is the source document (as JSON from the host), the character index it reads its@@ -1069,3 +1074,92 @@ function velocityAtTime(t) { return thisProperty.velocityAtTime(t); }function speedAtTime(t) { return thisProperty.speedAtTime(t); }function key(n) { return thisProperty.key(n); }function nearestKey(t) { return thisProperty.nearestKey(t); }++// ---------------------------------------------------------------------------------------------+// Stack safety (#2124, #2125). A stack overflow aborts the whole app, so nothing a script does+// may nest native code without bound. The expression text is checked for nesting before it is+// compiled; source handed to `eval` and the function constructors at run time is checked by+// `__nest`. The natives that walk nested values recursively (`join`, which `toString` and string+// conversion use, `toLocaleString`, `JSON.stringify`, `flat`) call `__stack` once per level,+// which throws once the run has used its share of the stack. `Proxy` (chains of proxies nest+// without any script frame) and `Reflect` are not available to expressions.+(function () {+ var nest = __nest, stack = __stack, apply = Reflect.apply, construct = Reflect.construct;+ var define = Object.defineProperty, describe = Object.getOwnPropertyDescriptor, proto = Object.getPrototypeOf;+ // Replace `obj[name]` keeping its attributes.+ function replace(obj, name, f) {+ var d = describe(obj, name);+ define(obj, name, { value: f, writable: d.writable, enumerable: d.enumerable, configurable: true });+ }+ function guard(obj, name) {+ var f = obj[name];+ replace(obj, name, function () { stack(); return apply(f, this, arguments); });+ }++ var evalJs = eval;+ eval = function (x) {+ if (typeof x === 'string') {+ stack();+ nest(x);+ }+ return evalJs(x);+ };+ // `Function` and the generator / async variants (reachable as `(function* () {}).constructor`).+ function dynamic(F) {+ var w = function () {+ var args = [];+ for (var i = 0; i < arguments.length; i++) args.push(String(arguments[i]));+ stack();+ nest(args.slice(0, -1).join(','));+ nest(args.length ? args[args.length - 1] : '');+ return construct(F, args);+ };+ define(w, 'name', { value: F.name, configurable: true });+ w.prototype = F.prototype;+ replace(F.prototype, 'constructor', w);+ return w;+ }+ Function = dynamic(Function);+ dynamic(proto(function* () {}).constructor);+ dynamic(proto(async function () {}).constructor);+ dynamic(proto(async function* () {}).constructor);++ guard(Array.prototype, 'join');+ guard(Array.prototype, 'toLocaleString');+ var flat = Array.prototype.flat;+ replace(Array.prototype, 'flat', function (depth) {+ stack();+ var d = depth === undefined ? 1 : Number(depth);+ return apply(flat, this, [d > 64 ? 64 : d]);+ });++ // A replacer function sees every value before it is serialized: the per-level check. An array+ // replacer (a list of keys) becomes one that copies each object's listed keys, in list order.+ var stringify = JSON.stringify;+ replace(JSON, 'stringify', function (value, replacer, space) {+ var fn = typeof replacer === 'function' ? replacer : null;+ var keys = null;+ if (Array.isArray(replacer)) {+ keys = [];+ for (var i = 0; i < replacer.length; i++) {+ var k = replacer[i];+ if (typeof k === 'number' || k instanceof Number || k instanceof String) k = String(k);+ if (typeof k === 'string' && keys.indexOf(k) < 0) keys.push(k);+ }+ }+ return apply(stringify, JSON, [value, function (key, v) {+ stack();+ if (fn !== null) v = apply(fn, this, [key, v]);+ if (keys !== null && v !== null && typeof v === 'object' && !Array.isArray(v) &&+ !(v instanceof Number || v instanceof String || v instanceof Boolean)) {+ var o = {};+ for (var j = 0; j < keys.length; j++) if (keys[j] in v) o[keys[j]] = v[keys[j]];+ v = o;+ }+ return v;+ }, space]);+ });++ delete globalThis.Proxy;+ delete globalThis.Reflect;+})();diff --git a/crates/expr/src/rewrite.rs b/crates/expr/src/rewrite.rsindex 55e9800aa..f84b96bc4 100644--- a/crates/expr/src/rewrite.rs+++ b/crates/expr/src/rewrite.rs@@ -758,6 +758,12 @@ pub fn check_nesting(src: &str) -> Result<(), String> {Ok(())}+/// An error when plain JavaScript `src` (not rewritten: what `eval` and `Function` get at run+/// time) nests deeper than [`MAX_NESTING`] levels.+pub fn check_plain_nesting(src: &str) -> Result<(), String> {+ if too_nested(&tokenize(src).0) { Err(too_deep()) } else { Ok(()) }+}+fn too_deep() -> String {format!("Error: expression is nested too deeply (more than {MAX_NESTING} levels of brackets, or too long a chain of operators)")}diff --git a/crates/expr/src/runtime.rs b/crates/expr/src/runtime.rsindex 53c2960ba..8afa839e5 100644--- a/crates/expr/src/runtime.rs+++ b/crates/expr/src/runtime.rs@@ -51,6 +51,8 @@ thread_local! {pub static FRAMES: RefCell<Vec<Frame>> = const { RefCell::new(Vec::new()) };/// Script runs since the outermost evaluation on this thread began (nested ones included).pub static RUNS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };+ /// Stack address where the current script run began (0: none; see [`native_stack`]).+ static STACK_BASE: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };}#[cfg(not(target_arch = "wasm32"))]@@ -232,17 +234,49 @@ fn native_random(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<JOk(JsValue::from(noise::unit(noise::mix(&parts))))}+/// Stack a script run may use below [`run`] for natives that recurse once per level of a nested+/// value (`join`, `JSON.stringify`, …; the prelude calls [`native_stack`] per level). Render+/// threads have 2 MiB; the parser's own nesting limit ([`crate::rewrite::MAX_NESTING`]) needs+/// most of the rest.+const NATIVE_STACK: usize = 256 << 10;++/// An address on the current stack.+fn stack_here() -> usize {+ let marker = 0u8;+ std::hint::black_box(&marker) as *const u8 as usize+}++/// `__stack()`: throw once the current run has used [`NATIVE_STACK`] (values nested so deeply+/// would overflow the stack, which aborts the app).+fn native_stack(_: &JsValue, _: &[JsValue], _: &mut Context) -> JsResult<JsValue> {+ let base = STACK_BASE.with(|b| b.get());+ if base != 0 && base.abs_diff(stack_here()) > NATIVE_STACK {+ return Err(JsNativeError::range().with_message("value is nested too deeply").into());+ }+ Ok(JsValue::undefined())+}++/// `__nest(src)`: throw when source handed to `eval` / `Function` at run time nests deeper than+/// the parser's stack allows (the expression text itself is checked before it is compiled).+fn native_nesting(_: &JsValue, args: &[JsValue], ctx: &mut Context) -> JsResult<JsValue> {+ let src = string(args, 0, ctx)?;+ crate::rewrite::check_plain_nesting(&src).map_err(|e| JsNativeError::range().with_message(e.trim_start_matches("Error: ").to_string()))?;+ Ok(JsValue::undefined())+}+impl Runtime {fn new() -> Result<Runtime, String> {let mut ctx = Context::default();let limits = ctx.runtime_limits_mut();limits.set_loop_iteration_limit(LOOP_LIMIT);limits.set_recursion_limit(400);- let natives: [(JsString, usize, fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsValue>); 4] = [+ let natives: [(JsString, usize, fn(&JsValue, &[JsValue], &mut Context) -> JsResult<JsValue>); 6] = [+ (js_string!("__stack"), 0, native_stack),(js_string!("__h"), 6, native_host),(js_string!("__wig"), 8, native_wiggle),(js_string!("__noise"), 3, native_noise),(js_string!("__rnd"), 6, native_random),+ (js_string!("__nest"), 1, native_nesting),];for (name, len, f) in natives {ctx.register_global_callable(name, len, NativeFunction::from_fn_ptr(f)).map_err(|e| e.to_string())?;@@ -361,6 +395,9 @@ pub fn out_of_time() -> bool {}}+/// Levels of nested arrays a script result keeps.+const MAX_DETACH: usize = 4;+/// Copy a JS value out of the heap.fn detach(v: &JsValue, ctx: &mut Context, depth: usize) -> Result<Out, String> {if v.is_undefined() {@@ -380,7 +417,7 @@ fn detach(v: &JsValue, ctx: &mut Context, depth: usize) -> Result<Out, String> {}let err = |e: boa_engine::JsError| format_error(&e.to_string(), usize::MAX);if let Some(o) = v.as_object() {- if o.is_array() && depth < 4 {+ if o.is_array() && depth < MAX_DETACH {let arr = JsArray::from_object(o).map_err(err)?;let n = arr.length(ctx).map_err(err)?.min(1 << 16);let mut out = Vec::with_capacity(n as usize);@@ -408,6 +445,11 @@ fn detach(v: &JsValue, ctx: &mut Context, depth: usize) -> Result<Out, String> {return Ok(Out::Path { points, ins, outs, closed });}}+ // Below the levels detached above, an object's text could be its whole nested content+ // (`String([[[…]]])`), converted by natives that recurse once per level.+ if depth >= MAX_DETACH && v.is_object() {+ return Ok(Out::Object("[object]".into()));+ }Ok(Out::Object(v.to_string(ctx).map(|s| s.to_std_string_escaped()).unwrap_or_default()))}@@ -484,6 +526,8 @@ fn position_line(msg: &str) -> Option<usize> {/// `__begin` with memoized answers, so nothing carries over. A script that really overflows the/// stack fails again on the fresh context and reports the error.pub fn run(text: &str, b: &Begin) -> Run {+ // Runs don't nest (other expressions are evaluated between runs), so one base suffices.+ STACK_BASE.with(|s| s.set(stack_here()));RUNTIME.with(|r| {let mut r = r.borrow_mut();for fresh in [false, true] {diff --git a/crates/expr/src/tests.rs b/crates/expr/src/tests.rsindex 7d2790255..cf13f02f8 100644--- a/crates/expr/src/tests.rs+++ b/crates/expr/src/tests.rs@@ -1,5 +1,6 @@use std::time::Instant;+mod deep_nesting;mod fuzz;use effectcraft_color::Label;diff --git a/crates/expr/src/tests/deep_nesting.rs b/crates/expr/src/tests/deep_nesting.rsnew file mode 100644index 000000000..d544d6f80--- /dev/null+++ b/crates/expr/src/tests/deep_nesting.rs@@ -0,0 +1,104 @@+//! Deep nesting the expression text check can't see (#2124, #2125): source handed to `eval` /+//! `Function` at run time, and deeply nested values that boa's natives (`join`, `JSON.stringify`,+//! proxies…) walk recursively. Each used to overflow the stack, which aborts the whole app+//! (`catch_unwind` can't catch it); now each is an expression error.++use super::*;++/// The render threads' stack size (rayon's default): what the app gets.+const RENDER_STACK: usize = 2 << 20;++/// Evaluate `text` on the title's source text (any result converts) on a render-sized stack.+fn eval_small_stack(text: &str) -> Result<Value, String> {+ let text = text.to_string();+ std::thread::Builder::new()+ .stack_size(RENDER_STACK)+ .spawn(move || {+ let f = fx();+ f.ev(f.title, "text/sourceText", &text, 0.0)+ })+ .unwrap()+ .join()+ .unwrap()+}++fn text_of(r: Result<Value, String>) -> String {+ match r {+ Ok(Value::Text(d)) => d.text,+ other => panic!("not text: {other:?}"),+ }+}++/// A 100 000-deep array: `var a = []; … a = [a]` in a loop (under the loop limit).+const DEEP_ARRAY: &str = "var a = []; for (var i = 0; i < 100000; i++) a = [a];";++#[test]+fn eval_and_function_constructors_check_nesting() {+ let deep = r#""(".repeat(1000) + "1" + ")".repeat(1000)"#;+ for call in [+ format!("eval({deep})"),+ format!("Function({deep})()"),+ format!("new Function('a', {deep})(1)"),+ format!("Function('a = ' + {deep}, 'return a')()"),+ "Function.apply(null, '('.repeat(1000).split('').concat(['1']))".to_string(),+ format!("(function () {{}}).constructor({deep})()"),+ format!("Object.getPrototypeOf(function* () {{}}).constructor({deep})"),+ format!("Object.getPrototypeOf(async function () {{}}).constructor({deep})"),+ format!("Object.getPrototypeOf(async function* () {{}}).constructor({deep})"),+ format!("Reflect.construct(Function, [{deep}])"),+ ] {+ let e = eval_small_stack(&call).expect_err(&call);+ assert!(!e.is_empty(), "{call}");+ }+}++#[test]+fn eval_and_function_still_work() {+ let f = fx();+ assert_eq!(f.num("eval('1 + 2')", 0.0), 3.0);+ assert_eq!(f.num("eval('[1, [2, (3)]]')[1][1]", 0.0), 3.0);+ assert_eq!(f.num("new Function('a', 'b', 'return a * b')(3, 4)", 0.0), 12.0);+ assert_eq!(f.num("Function('return 5')()", 0.0), 5.0);+ assert_eq!(f.num("(function () {}).constructor('return 6')()", 0.0), 6.0);+ assert_eq!(f.num("(function () {}) instanceof Function ? 1 : 0", 0.0), 1.0);+ assert_eq!(f.num("(function () {}).constructor === Function ? 1 : 0", 0.0), 1.0);+ assert_eq!(f.num("Object.getPrototypeOf(function* () { yield 7; }).constructor('yield 7')().next().value", 0.0), 7.0);+}++#[test]+fn deep_array_result_is_an_error_or_text_not_a_crash() {+ // The result itself: detaching it used to `toString` it past depth 4.+ let _ = eval_small_stack(&format!("{DEEP_ARRAY} a"));+ // Explicit conversions inside the script.+ for tail in ["a.join()", "a.toString()", "String(a)", "a + ''", "`${a}`", "a.toLocaleString()", "JSON.stringify(a)", "JSON.stringify({ a: a })"] {+ let text = format!("{DEEP_ARRAY} {tail}");+ assert!(eval_small_stack(&text).is_err(), "{text}");+ }+ // A deep array as a text style value goes through JSON.stringify in the prelude.+ let _ = eval_small_stack(&format!("{DEEP_ARRAY} text.sourceText.style.setFontSize(a)"));+}++#[test]+fn deep_proxy_chain_is_an_error_not_a_crash() {+ let text = "var p = {}; for (var i = 0; i < 100000; i++) p = new Proxy(p, {}); p.x";+ assert!(eval_small_stack(text).is_err(), "{text}");+ // Neither is available to expressions; the object model's own proxies still work.+ let f = fx();+ assert_eq!(f.text("typeof Proxy + ' ' + typeof Reflect", 0.0), "undefined undefined");+ assert_eq!(f.num("thisComp.layer('A').effect('Slider Control')('Slider')", 0.0), 42.0);+}++#[test]+fn nested_values_still_convert() {+ let f = fx();+ assert_eq!(f.text("[[1, 2], [3, [4, 5]]].join(';')", 0.0), "1,2;3,4,5");+ assert_eq!(f.text("String([[1, 2], 3])", 0.0), "1,2,3");+ assert_eq!(f.text("JSON.stringify({ a: [1, { b: [2] }] })", 0.0), r#"{"a":[1,{"b":[2]}]}"#);+ assert_eq!(f.text("JSON.stringify({ a: 1, b: 2 }, ['b'])", 0.0), r#"{"b":2}"#);+ assert_eq!(f.text("JSON.stringify([1, [2]], null, 1)", 0.0), "[\n 1,\n [\n 2\n ]\n]");+ assert_eq!(f.text("JSON.stringify({ a: 1 }, function (k, v) { return k === 'a' ? v + 1 : v; })", 0.0), r#"{"a":2}"#);+ // Nested deeper than the detached levels: still converts to its text.+ assert_eq!(text_of(eval_small_stack("[[[[[[1, 2]]]]]]")), "");+ assert_eq!(f.text("String([[[[[[[[1]]]]]]]])", 0.0), "1");+ assert_eq!(f.num("[1, [2, [3, [4]]]].flat(Infinity).length", 0.0), 4.0);+}