Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(canvas): validate transform overloads and preserve color alpha

ldm00f27fa8522ac
diff --git a/moli-canvas/src/lib.rs b/moli-canvas/src/lib.rs
index 4fe9dfe7d..82f584c86 100644
--- a/moli-canvas/src/lib.rs
+++ b/moli-canvas/src/lib.rs
@@ -54,6 +54,32 @@ mod tests {
assert_eq!(canonicalize_fill_style("bad"), None);
}
+ #[test]
+ fn hex_alpha_canonicalization_round_trips_every_byte() {
+ for alpha in 0..=255_u8 {
+ let raw = format!("#12ab34{alpha:02x}");
+ let canonical = canonicalize_fill_style(&raw).expect("valid eight-digit hex");
+ assert_eq!(
+ fill_style_rgba(&canonical),
+ [0x12, 0xab, 0x34, alpha],
+ "{raw}: {canonical}"
+ );
+ }
+ for alpha in 0..16_u8 {
+ let raw = format!("#0f0{alpha:x}");
+ let canonical = canonicalize_fill_style(&raw).expect("valid four-digit hex");
+ assert_eq!(fill_style_rgba(&canonical), [0, 255, 0, alpha * 17]);
+ }
+ }
+
+ #[test]
+ fn malformed_hex_colors_cannot_panic_or_install_a_style() {
+ for raw in ["#", "#12", "#12345", "#gggg", "#💚", "#éé", "#0000000x"] {
+ assert_eq!(canonicalize_fill_style(raw), None, "{raw}");
+ assert_eq!(fill_style_rgba(raw), [0, 0, 0, 255], "{raw}");
+ }
+ }
+
#[test]
fn data_url_zero_and_png_dimensions_are_stable() {
assert_eq!(encode_data_url(&[], 0, 0).as_deref(), Some("data:,"));
diff --git a/moli-canvas/src/rect.rs b/moli-canvas/src/rect.rs
index cac941fdc..e6bff36e2 100644
--- a/moli-canvas/src/rect.rs
+++ b/moli-canvas/src/rect.rs
@@ -15,8 +15,7 @@ pub fn canonicalize_fill_style(raw: &str) -> Option<String> {
if alpha == u8::MAX {
return Some(format!("rgb({red}, {green}, {blue})"));
}
- let alpha = (f64::from(alpha) / 255.0 * 100.0).round() / 100.0;
- return Some(format!("rgba({red}, {green}, {blue}, {alpha:.2})"));
+ return Some(canonical_rgba(red, green, blue, alpha));
}
None
}
@@ -300,34 +299,22 @@ pub fn paint_rect(
}
fn canonical_hex_color(value: &str) -> Option<String> {
- let hex = value.strip_prefix('#')?;
- if !hex.chars().all(|char| char.is_ascii_hexdigit()) {
- return None;
+ let [red, green, blue, alpha] = hex_color_rgba(value)?;
+ if alpha == u8::MAX {
+ Some(format!("#{red:02x}{green:02x}{blue:02x}"))
+ } else {
+ Some(canonical_rgba(red, green, blue, alpha))
}
- match hex.len() {
- 3 => {
- let chars = hex.chars().collect::<Vec<_>>();
- Some(format!(
- "#{0}{0}{1}{1}{2}{2}",
- chars[0].to_ascii_lowercase(),
- chars[1].to_ascii_lowercase(),
- chars[2].to_ascii_lowercase()
- ))
- }
- 6 => Some(format!("#{hex}")),
- 8 => {
- let rgba = u32::from_str_radix(hex, 16).ok()?;
- let red = ((rgba >> 24) & 0xff) as u8;
- let green = ((rgba >> 16) & 0xff) as u8;
- let blue = ((rgba >> 8) & 0xff) as u8;
- let alpha = (rgba & 0xff) as u8;
- if alpha == u8::MAX {
- Some(format!("#{red:02x}{green:02x}{blue:02x}"))
- } else {
- let alpha = (alpha as f64 / 255.0 * 100.0).round() / 100.0;
- Some(format!("rgba({red}, {green}, {blue}, {alpha:.2})"))
- }
- }
- _ => None,
+}
+
+fn canonical_rgba(red: u8, green: u8, blue: u8, alpha: u8) -> String {
+ let fraction = f64::from(alpha) / 255.0;
+ let rounded = (fraction * 100.0).round() / 100.0;
+ if (rounded * 255.0).round() as u8 == alpha {
+ format!("rgba({red}, {green}, {blue}, {rounded:.2})")
+ } else {
+ // Two decimal places cannot represent every 8-bit alpha. Retain enough
+ // precision that serializing a style does not change its pixels.
+ format!("rgba({red}, {green}, {blue}, {fraction:.3})")
}
}
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas.rs b/moli-renderer-v8/src/context_bootstrap/canvas.rs
index 6393c3d18..640f9b392 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas.rs
@@ -193,6 +193,7 @@ mod objects;
mod offscreen;
mod path;
mod state;
+mod transform;
mod webgl;
pub(crate) use backing_store::{
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs
index 5fcd51971..f6e75dfeb 100644
--- a/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs
+++ b/moli-renderer-v8/src/context_bootstrap/canvas/context2d.rs
@@ -272,23 +272,6 @@ struct CanvasContextEllipseArgs {
counterclockwise: bool,
}
-#[derive(webidl::WebIdlArgs)]
-#[webidl(prefix = "CanvasRenderingContext2D.transform")]
-struct CanvasContextTransformArgs {
- #[webidl(required)]
- a: f64,
- #[webidl(required)]
- b: f64,
- #[webidl(required)]
- c: f64,
- #[webidl(required)]
- d: f64,
- #[webidl(required)]
- e: f64,
- #[webidl(required)]
- f: f64,
-}
-
fn require_canvas_context_receiver<'s>(
scope: &mut v8::PinScope<'s, '_>,
receiver: v8::Local<'s, v8::Object>,
@@ -872,6 +855,18 @@ pub(crate) fn canvas_context_arc_callback<'s>(
let Some(parsed) = webidl::parse_args::<CanvasContextArcArgs>(scope, &args) else {
return;
};
+ if ![
+ parsed.x,
+ parsed.y,
+ parsed.radius,
+ parsed.start_angle,
+ parsed.end_angle,
+ ]
+ .into_iter()
+ .all(f64::is_finite)
+ {
+ return;
+ }
if parsed.radius < 0.0 {
webidl::throw_index_size_error(scope);
rv.set_undefined();
@@ -902,6 +897,12 @@ pub(crate) fn canvas_context_arc_to_callback<'s>(
let Some(parsed) = webidl::parse_args::<CanvasContextArcToArgs>(scope, &args) else {
return;
};
+ if ![parsed.x1, parsed.y1, parsed.x2, parsed.y2, parsed.radius]
+ .into_iter()
+ .all(f64::is_finite)
+ {
+ return;
+ }
if parsed.radius < 0.0 {
webidl::throw_index_size_error(scope);
rv.set_undefined();
@@ -925,6 +926,20 @@ pub(crate) fn canvas_context_ellipse_callback<'s>(
let Some(parsed) = webidl::parse_args::<CanvasContextEllipseArgs>(scope, &args) else {
return;
};
+ if ![
+ parsed.x,
+ parsed.y,
+ parsed.radius_x,
+ parsed.radius_y,
+ parsed.rotation,
+ parsed.start_angle,
+ parsed.end_angle,
+ ]
+ .into_iter()
+ .all(f64::is_finite)
+ {
+ return;
+ }
if parsed.radius_x < 0.0 || parsed.radius_y < 0.0 {
webidl::throw_index_size_error(scope);
rv.set_undefined();
@@ -1008,12 +1023,14 @@ pub(crate) fn canvas_context_transform_callback<'s>(
if !require_canvas_context_receiver(scope, args.this(), "transform") {
return;
}
- let Some(parsed) = webidl::parse_args::<CanvasContextTransformArgs>(scope, &args) else {
+ let Some([a, b, c, d, e, f]) =
+ super::transform::transform_arguments(scope, &args, "CanvasRenderingContext2D.transform")
+ else {
return;
};
let path_state = canvas_path_state(scope, args.this());
with_path_state(&path_state, |state| {
- state.concatenate_transform(parsed.a, parsed.b, parsed.c, parsed.d, parsed.e, parsed.f);
+ state.concatenate_transform(a, b, c, d, e, f);
});
}
@@ -1025,12 +1042,12 @@ pub(crate) fn canvas_context_set_transform_callback<'s>(
if !require_canvas_context_receiver(scope, args.this(), "setTransform") {
return;
}
- let Some(parsed) = webidl::parse_args::<CanvasContextTransformArgs>(scope, &args) else {
+ let Some([a, b, c, d, e, f]) = super::transform::set_transform_arguments(scope, &args) else {
return;
};
let path_state = canvas_path_state(scope, args.this());
with_path_state(&path_state, |state| {
- state.set_transform(parsed.a, parsed.b, parsed.c, parsed.d, parsed.e, parsed.f);
+ state.set_transform(a, b, c, d, e, f);
});
}
@@ -1168,7 +1185,7 @@ pub(crate) fn canvas_context_line_width_setter_callback<'s>(
if !require_canvas_context_receiver(scope, args.this(), "lineWidth setter") {
return;
}
- canvas_context_nonnegative_number_assign(
+ canvas_context_positive_number_assign(
scope,
args.this(),
args.get(0),
@@ -1198,7 +1215,7 @@ pub(crate) fn canvas_context_miter_limit_setter_callback<'s>(
if !require_canvas_context_receiver(scope, args.this(), "miterLimit setter") {
return;
}
- canvas_context_nonnegative_number_assign(
+ canvas_context_positive_number_assign(
scope,
args.this(),
args.get(0),
@@ -1365,7 +1382,7 @@ pub(crate) fn canvas_context_stroke_style_setter_callback<'s>(
rv.set_undefined();
}
-fn canvas_context_nonnegative_number_assign<'s>(
+fn canvas_context_positive_number_assign<'s>(
scope: &mut v8::PinScope<'s, '_>,
holder: v8::Local<'s, v8::Object>,
value: v8::Local<'s, v8::Value>,
@@ -1378,7 +1395,7 @@ fn canvas_context_nonnegative_number_assign<'s>(
);
if let Ok(value) = value {
let value = f64::from(value);
- if value.is_finite() && value >= 0.0 {
+ if value.is_finite() && value > 0.0 {
set_context_number_slot(scope, holder, slot, value);
}
}
diff --git a/moli-renderer-v8/src/context_bootstrap/canvas/transform.rs b/moli-renderer-v8/src/context_bootstrap/canvas/transform.rs
new file mode 100644
index 000000000..3c433bad9
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/canvas/transform.rs
@@ -0,0 +1,88 @@
+//! WebIDL conversion and DOMMatrix2DInit alias validation for Canvas transforms.
+
+use crate::{util::throw_type_error, webidl};
+
+#[derive(Default, webidl::WebIdlDictionary)]
+#[webidl(prefix = "DOMMatrix2DInit")]
+struct TransformInit {
+ a: Option<f64>,
+ b: Option<f64>,
+ c: Option<f64>,
+ d: Option<f64>,
+ e: Option<f64>,
+ f: Option<f64>,
+ m11: Option<f64>,
+ m12: Option<f64>,
+ m21: Option<f64>,
+ m22: Option<f64>,
+ m41: Option<f64>,
+ m42: Option<f64>,
+}
+
+pub(super) fn transform_arguments<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: &v8::FunctionCallbackArguments<'s>,
+ prefix: &'static str,
+) -> Option<[f64; 6]> {
+ if args.length() < 6 {
+ throw_type_error(scope, &format!("{prefix} requires six arguments"));
+ return None;
+ }
+ let mut values = [0.0; 6];
+ for (index, value) in values.iter_mut().enumerate() {
+ match webidl::argument::<webidl::UnrestrictedDouble>(
+ scope,
+ args,
+ index as i32,
+ webidl::Context::argument(prefix, index + 1),
+ ) {
+ Ok(parsed) => *value = parsed.0,
+ Err(error) => {
+ webidl::throw_error(scope, &error);
+ return None;
+ }
+ }
+ }
+ Some(values)
+}
+
+pub(super) fn set_transform_arguments<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: &v8::FunctionCallbackArguments<'s>,
+) -> Option<[f64; 6]> {
+ const PREFIX: &str = "CanvasRenderingContext2D.setTransform";
+ if args.length() > 1 {
+ return transform_arguments(scope, args, PREFIX);
+ }
+ let init = match webidl::parse_dictionary::<TransformInit>(
+ scope,
+ args.get(0),
+ webidl::Context::argument(PREFIX, 1),
+ ) {
+ Ok(init) => init.unwrap_or_default(),
+ Err(error) => {
+ webidl::throw_error(scope, &error);
+ return None;
+ }
+ };
+ let pairs = [
+ (init.a, init.m11, 1.0),
+ (init.b, init.m12, 0.0),
+ (init.c, init.m21, 0.0),
+ (init.d, init.m22, 1.0),
+ (init.e, init.m41, 0.0),
+ (init.f, init.m42, 0.0),
+ ];
+ let mut values = [0.0; 6];
+ for (value, (alias, component, default)) in values.iter_mut().zip(pairs) {
+ if let (Some(a), Some(b)) = (alias, component)
+ && a != b
+ && !(a.is_nan() && b.is_nan())
+ {
+ throw_type_error(scope, "DOMMatrix2DInit contains inconsistent aliases");
+ return None;
+ }
+ *value = alias.or(component).unwrap_or(default);
+ }
+ Some(values)
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs
index 7df3980d2..05b8973ff 100644
--- a/moli-renderer-v8/src/context_bootstrap/media_file_template.rs
+++ b/moli-renderer-v8/src/context_bootstrap/media_file_template.rs
@@ -292,7 +292,7 @@ struct CanvasRenderingContext2dTemplateDeclaration {
#[webapi(
method = "setTransform",
- length = 6,
+ length = 0,
callback = canvas_context_set_transform_callback
)]
set_transform: (),
diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_arguments.rs b/moli-renderer-v8/src/script_vm/tests/canvas_arguments.rs
new file mode 100644
index 000000000..d92619085
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/canvas_arguments.rs
@@ -0,0 +1,177 @@
+use super::{canvas_paths::canvas_pixels, *};
+
+fn check(script: &str, expected: &str) {
+ for constructor in [
+ "document.createElement('canvas')",
+ "new OffscreenCanvas(96,96)",
+ ] {
+ let mut vm = new_storage_test_vm("https://canvas-arguments.test/");
+ let result = vm
+ .eval(&format!(
+ r#"(() => {{
+ const canvas={constructor};canvas.width=canvas.height=96;
+ const ctx=canvas.getContext('2d');
+ const caught=f=>{{try{{f();return 'ok';}}catch(e){{return e.name;}}}};
+ {script}
+ }})()"#
+ ))
+ .unwrap();
+ assert_eq!(result, expected, "{constructor}: {script}");
+ }
+}
+
+#[test]
+fn canvas_line_width_and_miter_limit_ignore_nonpositive_or_nonfinite_values() {
+ check(
+ r#"
+ ctx.lineWidth=8;ctx.miterLimit=7;
+ for(const n of [0,-0,-1,NaN,Infinity,-Infinity]) {
+ ctx.lineWidth=n;ctx.miterLimit=n;
+ if(ctx.lineWidth!==8||ctx.miterLimit!==7)throw Error('invalid setter changed state');
+ }
+ ctx.lineWidth={valueOf(){return 0;}};ctx.miterLimit='0';
+ return JSON.stringify([ctx.lineWidth,ctx.miterLimit]);
+ "#,
+ "[8,7]",
+ );
+}
+
+#[test]
+fn canvas_transform_dictionary_and_dommatrix_overloads_record_the_same_geometry() {
+ for init in [
+ "{e:20}",
+ "{m41:20}",
+ "{a:1,m11:1,e:20,m41:20}",
+ "new DOMMatrix([1,0,0,1,20,0])",
+ ] {
+ canvas_pixels(
+ &format!("ctx.setTransform({init});ctx.rect(0,0,10,10);ctx.fill();"),
+ &[(5, 5), (25, 5)],
+ &[0, 255],
+ );
+ }
+}
+
+#[test]
+fn canvas_set_transform_default_dictionary_resets_to_identity() {
+ for init in ["", "undefined", "null", "{}"] {
+ canvas_pixels(
+ &format!(
+ "ctx.translate(20,0);ctx.setTransform({init});ctx.rect(0,0,10,10);ctx.fill();"
+ ),
+ &[(5, 5), (25, 5)],
+ &[255, 0],
+ );
+ }
+ check(
+ "return JSON.stringify([ctx.setTransform.length,ctx.transform.length]);",
+ "[0,6]",
+ );
+}
+
+#[test]
+fn canvas_transform_dictionary_rejects_each_inconsistent_alias_atomically() {
+ check(
+ r#"
+ ctx.translate(20,0);
+ const results=[];
+ for(const [a,b] of [['a','m11'],['b','m12'],['c','m21'],['d','m22'],['e','m41'],['f','m42']]) {
+ results.push(caught(()=>ctx.setTransform({[a]:1,[b]:2})));
+ }
+ ctx.rect(0,0,10,10);ctx.fill();
+ results.push(ctx.getImageData(25,5,1,1).data[3],ctx.getImageData(5,5,1,1).data[3]);
+ return JSON.stringify(results);
+ "#,
+ r#"["TypeError","TypeError","TypeError","TypeError","TypeError","TypeError",255,0]"#,
+ );
+}
+
+#[test]
+fn canvas_transform_dictionary_reads_members_in_webidl_order() {
+ check(
+ r#"
+ const names=['a','b','c','d','e','f','m11','m12','m21','m22','m41','m42'];
+ const order=[],init={};
+ for(const name of names)Object.defineProperty(init,name,{get(){order.push(name);return undefined;}});
+ ctx.setTransform(init);
+ return JSON.stringify(order);
+ "#,
+ r#"["a","b","c","d","e","f","m11","m12","m21","m22","m41","m42"]"#,
+ );
+}
+
+#[test]
+fn canvas_transform_dictionary_getter_exception_preserves_current_transform() {
+ check(
+ r#"
+ ctx.translate(20,0);
+ let message;
+ try{ctx.setTransform({a:2,get e(){throw Error('dictionary failed');}});}catch(e){message=e.message;}
+ ctx.rect(0,0,10,10);ctx.fill();
+ return JSON.stringify([message,ctx.getImageData(25,5,1,1).data[3],ctx.getImageData(5,5,1,1).data[3]]);
+ "#,
+ r#"["dictionary failed",255,0]"#,
+ );
+}
+
+#[test]
+fn canvas_transform_nonfinite_values_are_ignored_after_alias_validation() {
+ check(
+ r#"
+ ctx.translate(20,0);
+ const results=[caught(()=>ctx.setTransform({a:NaN,m11:NaN})),caught(()=>ctx.setTransform({b:0,m12:-0}))];
+ ctx.translate(20,0);
+ ctx.setTransform(Infinity,0,0,1,0,0);ctx.transform(1,0,0,NaN,0,0);
+ ctx.rotate(NaN);ctx.scale(Infinity,1);ctx.translate(0,Infinity);
+ ctx.rect(0,0,10,10);ctx.fill();
+ results.push(ctx.getImageData(25,5,1,1).data[3],ctx.getImageData(5,5,1,1).data[3]);
+ return JSON.stringify(results);
+ "#,
+ r#"["ok","ok",255,0]"#,
+ );
+}
+
+#[test]
+fn canvas_transform_overloads_reject_invalid_arity_and_primitives() {
+ check(
+ r#"
+ return JSON.stringify([
+ caught(()=>ctx.setTransform(1)),caught(()=>ctx.setTransform('matrix(1,0,0,1,0,0)')),
+ caught(()=>ctx.setTransform(1,0)),caught(()=>ctx.setTransform(1,0,0,1,0)),
+ caught(()=>ctx.transform()),caught(()=>ctx.setTransform(1,0,0,1,0,0))
+ ]);
+ "#,
+ r#"["TypeError","TypeError","TypeError","TypeError","TypeError","ok"]"#,
+ );
+}
+
+#[test]
+fn canvas_arc_argument_validation_ignores_nonfinite_before_negative_radius() {
+ check(
+ r#"
+ return JSON.stringify([
+ caught(()=>ctx.arc(NaN,0,-1,0,1)),caught(()=>ctx.arc(0,0,-1,0,1)),
+ caught(()=>ctx.ellipse(0,0,-1,2,Infinity,0,1)),caught(()=>ctx.ellipse(0,0,-1,2,0,0,1)),
+ caught(()=>ctx.arcTo(0,0,NaN,1,-1)),caught(()=>ctx.arcTo(0,0,1,1,-1))
+ ]);
+ "#,
+ r#"["ok","IndexSizeError","ok","IndexSizeError","ok","IndexSizeError"]"#,
+ );
+}
+
+#[test]
+fn canvas_hex_alpha_is_accepted_and_preserved_for_fill_and_stroke() {
+ for color in ["#0f08", "#00ff0088", "#0F08", "rgba(0,255,0,0.533)"] {
+ check(
+ &format!(
+ r#"
+ ctx.fillStyle='{color}';ctx.strokeStyle='{color}';
+ ctx.rect(0,0,10,10);ctx.fill();ctx.beginPath();
+ ctx.lineWidth=2;ctx.moveTo(20,20);ctx.lineTo(40,20);ctx.stroke();
+ return JSON.stringify([Array.from(ctx.getImageData(5,5,1,1).data),Array.from(ctx.getImageData(25,20,1,1).data)]);
+ "#
+ ),
+ "[[0,255,0,136],[0,255,0,136]]",
+ );
+ }
+}
diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs b/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs
index 920ec35e2..9180d8e60 100644
--- a/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs
+++ b/moli-renderer-v8/src/script_vm/tests/canvas_paths.rs
@@ -1,6 +1,6 @@
use super::*;
-fn canvas_pixels(script: &str, points: &[(u32, u32)], expected: &[u8]) {
+pub(super) fn canvas_pixels(script: &str, points: &[(u32, u32)], expected: &[u8]) {
for kind in ["html", "offscreen"] {
let mut vm = new_storage_test_vm("https://canvas-paths.test/");
let result = vm
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index d21c4b3d6..9b8f68082 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -15145,6 +15145,7 @@ fn decode_png_dimensions_from_data_url(data_url: &str) -> (u32, u32) {
}
mod browser_api;
+mod canvas_arguments;
mod canvas_paths;
mod canvas_webgl;
mod dom_elements;