feat(crypto): Improve crypto.getRandomValues() compatibility

Author: nabetti1720

Cargo.lock

@@ -14,8 +14,9 @@ fs = ["tokio/fs"]
 bytearray-buffer = ["tokio/sync"]
 
 [dependencies]
+half = { version = "2", default-features= false }
 memchr = { version = "2", default-features = false, features = ["std"] }
-rquickjs = { version = "0.12", features = ["macro"], default-features = false }
+rquickjs = { version = "0.12", features = ["half", "macro"], default-features = false }
 simdutf8 = { version = "0.1", default-features = false, features = ["std", "aarch64_neon"] }
 tokio = { version = "1", features = ["sync"], default-features = false }
 tracing = { version = "0.1", default-features = false }

libs/llrt_utils/Cargo.toml

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 use std::{rc::Rc, slice};
 
+use half::f16;
 use rquickjs::{
     atom::PredefinedAtom,
     class::{Trace, Tracer},
@@ -228,9 +229,11 @@ pub enum ObjectBytes<'js> {
     I32Array(TypedArray<'js, i32>),
     U64Array(TypedArray<'js, u64>),
     I64Array(TypedArray<'js, i64>),
+    F16Array(TypedArray<'js, f16>),
     F32Array(TypedArray<'js, f32>),
     F64Array(TypedArray<'js, f64>),
-    DataView(ArrayBuffer<'js>, usize, usize), // buffer, offset, length
+    U8ClampedArray(ArrayBuffer<'js>, usize, usize), // buffer, offset, length
+    DataView(ArrayBuffer<'js>, usize, usize),       // buffer, offset, length
     Vec(Vec<u8>),
 }
 
@@ -250,9 +253,11 @@ impl<'js> Trace<'js> for ObjectBytes<'js> {
             ObjectBytes::I32Array(a) => a.trace(tracer),
             ObjectBytes::U64Array(a) => a.trace(tracer),
             ObjectBytes::I64Array(a) => a.trace(tracer),
+            ObjectBytes::F16Array(a) => a.trace(tracer),
             ObjectBytes::F32Array(a) => a.trace(tracer),
             ObjectBytes::F64Array(a) => a.trace(tracer),
-            ObjectBytes::DataView(d, _, _) => d.trace(tracer),
+            ObjectBytes::U8ClampedArray(ab, _, _) => ab.trace(tracer),
+            ObjectBytes::DataView(ab, _, _) => ab.trace(tracer),
             ObjectBytes::Vec(v) => v.trace(tracer),
         }
     }
@@ -269,11 +274,16 @@ impl<'js> IntoJs<'js> for ObjectBytes<'js> {
             ObjectBytes::I32Array(a) => a.into_js(ctx),
             ObjectBytes::U64Array(a) => a.into_js(ctx),
             ObjectBytes::I64Array(a) => a.into_js(ctx),
+            ObjectBytes::F16Array(a) => a.into_js(ctx),
             ObjectBytes::F32Array(a) => a.into_js(ctx),
             ObjectBytes::F64Array(a) => a.into_js(ctx),
-            ObjectBytes::DataView(d, _, _) => {
+            ObjectBytes::U8ClampedArray(ab, _, _) => {
+                let ctor: Constructor = ctx.globals().get(PredefinedAtom::Uint8ClampedArray)?;
+                ctor.construct((ab,))
+            },
+            ObjectBytes::DataView(ab, _, _) => {
                 let ctor: Constructor = ctx.globals().get(PredefinedAtom::DataView)?;
-                ctor.construct((d,))
+                ctor.construct((ab,))
             },
             ObjectBytes::Vec(v) => v.into_js(ctx),
         }
@@ -359,11 +369,15 @@ impl<'js> ObjectBytes<'js> {
             ObjectBytes::I32Array(array) => array.as_bytes(),
             ObjectBytes::U64Array(array) => array.as_bytes(),
             ObjectBytes::I64Array(array) => array.as_bytes(),
+            ObjectBytes::F16Array(array) => array.as_bytes(),
             ObjectBytes::F32Array(array) => array.as_bytes(),
             ObjectBytes::F64Array(array) => array.as_bytes(),
-            ObjectBytes::DataView(array_buffer, offset, length) => array_buffer
-                .as_bytes()
-                .map(|b| &b[*offset..*offset + *length]),
+            ObjectBytes::U8ClampedArray(ab, offset, length) => {
+                ab.as_bytes().map(|b| &b[*offset..*offset + *length])
+            },
+            ObjectBytes::DataView(ab, offset, length) => {
+                ab.as_bytes().map(|b| &b[*offset..*offset + *length])
+            },
             ObjectBytes::Vec(bytes) => Some(bytes.as_ref()),
         }
         .ok_or(ERROR_MSG_ARRAY_BUFFER_DETACHED.into())
@@ -419,6 +433,10 @@ impl<'js> ObjectBytes<'js> {
             return Ok(Some(ObjectBytes::I64Array(typed_array)));
         }
 
+        if let Ok(typed_array) = TypedArray::<f16>::from_object(obj.clone()) {
+            return Ok(Some(ObjectBytes::F16Array(typed_array)));
+        }
+
         if let Ok(typed_array) = TypedArray::<f32>::from_object(obj.clone()) {
             return Ok(Some(ObjectBytes::F32Array(typed_array)));
         }
@@ -427,24 +445,23 @@ impl<'js> ObjectBytes<'js> {
             return Ok(Some(ObjectBytes::F64Array(typed_array)));
         }
 
-        if let Ok(array_buffer) = obj.get::<_, ArrayBuffer>("buffer") {
-            let byte_offset: usize = obj.get("byteOffset").unwrap_or(0);
-            let byte_length: usize = obj.get("byteLength").unwrap_or_else(|_| array_buffer.len());
-            return Ok(Some(ObjectBytes::DataView(
-                array_buffer,
-                byte_offset,
-                byte_length,
-            )));
+        if let Ok(ab) = obj.get::<_, ArrayBuffer>("buffer") {
+            let tag: String = obj
+                .get(PredefinedAtom::SymbolToStringTag)
+                .unwrap_or_default();
+            let offset: usize = obj.get("byteOffset").unwrap_or(0);
+            let length: usize = obj.get("byteLength").unwrap_or_else(|_| ab.len());
+            return Ok(Some(match tag.as_str() {
+                "Uint8ClampedArray" => ObjectBytes::U8ClampedArray(ab, offset, length),
+                _ => ObjectBytes::DataView(ab, offset, length),
+            }));
         }
 
         Ok(None)
     }
 
     pub fn get_array_buffer(&self) -> Result<Option<(ArrayBuffer<'js>, usize, usize)>> {
         let buffer = match self {
-            ObjectBytes::DataView(array_buffer, offset, length) => {
-                (array_buffer.clone(), *length, *offset)
-            },
             ObjectBytes::U8Array(typed_array) => {
                 let byte_length = typed_array.len();
                 (
@@ -509,6 +526,14 @@ impl<'js> ObjectBytes<'js> {
                     typed_array.get("byteOffset")?,
                 )
             },
+            ObjectBytes::F16Array(typed_array) => {
+                let byte_length = typed_array.len() * 2;
+                (
+                    typed_array.arraybuffer()?,
+                    byte_length,
+                    typed_array.get("byteOffset")?,
+                )
+            },
             ObjectBytes::F32Array(typed_array) => {
                 let byte_length = typed_array.len() * 4;
                 (
@@ -525,6 +550,12 @@ impl<'js> ObjectBytes<'js> {
                     typed_array.get("byteOffset")?,
                 )
             },
+            ObjectBytes::U8ClampedArray(buffer, offset, length) => {
+                (buffer.clone(), *length, *offset)
+            },
+            ObjectBytes::DataView(array_buffer, offset, length) => {
+                (array_buffer.clone(), *length, *offset)
+            },
             _ => return Ok(None),
         };
 

libs/llrt_utils/src/bytes.rs

@@ -52,6 +52,7 @@ crc32fast = { version = "1", default-features = false }
 llrt_buffer = { version = "0.8.1-beta", path = "../llrt_buffer" }
 llrt_context = { version = "0.8.1-beta", path = "../../libs/llrt_context" }
 llrt_encoding = { version = "0.8.1-beta", path = "../../libs/llrt_encoding" }
+llrt_exceptions = { version = "0.8.1-beta", path = "../llrt_exceptions" }
 llrt_utils = { version = "0.8.1-beta", path = "../../libs/llrt_utils", default-features = false }
 md-5 = { version = "0.11", default-features = false }
 once_cell = { version = "1", features = ["std"], default-features = false }

modules/llrt_crypto/Cargo.toml

@@ -31,6 +31,7 @@ use std::slice;
 use llrt_buffer::Buffer;
 use llrt_context::CtxExtension;
 use llrt_encoding::{bytes_to_b64_string, bytes_to_hex_string};
+use llrt_exceptions::{DOMException, QuotaExceededError};
 use llrt_utils::{
     bytes::{get_start_end_indexes, ObjectBytes},
     error::ErrorExtensions,
@@ -162,9 +163,15 @@ fn get_random_values<'js>(ctx: Ctx<'js>, obj: Object<'js>) -> Result<Object<'js>
     if let Some(object_bytes) = ObjectBytes::from_array_buffer(&obj)? {
         if matches!(
             object_bytes,
-            ObjectBytes::F64Array(_) | ObjectBytes::F32Array(_)
+            ObjectBytes::F64Array(_)
+                | ObjectBytes::F32Array(_)
+                | ObjectBytes::F16Array(_)
+                | ObjectBytes::DataView(_, _, _)
         ) {
-            return Err(Exception::throw_message(&ctx, "Unsupported TypedArray"));
+            return Err(DOMException::type_mismatch_error(
+                &ctx,
+                "getRandomValues requires an integer TypedArray",
+            ));
         }
 
         let (array_buffer, source_length, source_offset) = object_bytes
@@ -176,9 +183,9 @@ fn get_random_values<'js>(ctx: Ctx<'js>, obj: Object<'js>) -> Result<Object<'js>
             .or_throw(&ctx)?;
 
         if source_length > 0x10000 {
-            return Err(Exception::throw_message(
+            return Err(QuotaExceededError::quota_exceeded_error(
                 &ctx,
-                "QuotaExceededError: The requested length exceeds 65,536 bytes",
+                "The requested length exceeds 65,536 bytes",
             ));
         }
 

modules/llrt_crypto/src/lib.rs

@@ -1,5 +1,10 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+mod quota_exceeded_error;
+
+use core::fmt;
+use std::fmt::Debug;
+
 use llrt_utils::{
     option::Undefined,
     primordials::{BasePrimordials, Primordial},
@@ -8,22 +13,35 @@ use rquickjs::{
     atom::PredefinedAtom,
     class::{
         impl_::{CloneTrait, CloneWrapper},
-        JsClass,
+        JsClass, Trace,
     },
-    function::{Constructor, Func, Opt},
+    function::{Constructor, Opt},
     object::Property,
-    prelude::This,
-    Class, Coerced, Ctx, Exception, FromJs, IntoJs, Object, Result, Value,
+    prelude::{Func, This},
+    qjs, Class, Coerced, Ctx, Error, Exception, FromJs, IntoJs, JsLifetime, Object, Result, Value,
 };
 
-#[derive(rquickjs::class::Trace, rquickjs::JsLifetime)]
+pub use crate::quota_exceeded_error::QuotaExceededError;
+use crate::DOMExceptionName::{NotSupportedError, OperationError, TypeMismatchError};
+
+#[derive(Trace, JsLifetime, Debug)]
 pub struct DOMException {
     name: String,
     message: String,
     stack: String,
     code: u8,
 }
 
+impl fmt::Display for DOMException {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("DOMException")
+            .field("name", &self.name())
+            .field("message", &self.message())
+            .field("stack", &self.stack())
+            .finish()
+    }
+}
+
 fn add_constants(obj: &Object<'_>) -> Result<()> {
     const CONSTANTS: [(&str, u8); 25] = [
         ("INDEX_SIZE_ERR", 1),
@@ -175,6 +193,43 @@ impl DOMException {
     }
 }
 
+impl<'js> DOMException {
+    fn create(
+        ctx: &Ctx<'js>,
+        name: DOMExceptionName,
+        message: impl Into<String>,
+    ) -> Result<Value<'js>> {
+        let exception = Self::new_with_name(ctx, name, message.into())?;
+        let ctor: Constructor = ctx.globals().get("DOMException")?;
+        ctor.construct((exception.message, exception.name))
+    }
+
+    fn throw_value(ctx: &Ctx<'js>, value: Value<'js>) -> Error {
+        unsafe {
+            let dup = qjs::JS_DupValue(ctx.as_raw().as_ptr(), value.as_raw());
+            qjs::JS_Throw(ctx.as_raw().as_ptr(), dup);
+        }
+        Error::Exception
+    }
+
+    fn create_error(ctx: &Ctx<'js>, name: DOMExceptionName, message: impl Into<String>) -> Error {
+        let value = Self::create(ctx, name, message).expect("failed to create DOMException");
+        Self::throw_value(ctx, value)
+    }
+
+    pub fn not_supported_error(ctx: &Ctx<'js>, message: impl Into<String>) -> Error {
+        Self::create_error(ctx, NotSupportedError, message)
+    }
+
+    pub fn type_mismatch_error(ctx: &Ctx<'js>, message: impl Into<String>) -> Error {
+        Self::create_error(ctx, TypeMismatchError, message)
+    }
+
+    pub fn operation_error(ctx: &Ctx<'js>, message: impl Into<String>) -> Error {
+        Self::create_error(ctx, OperationError, message)
+    }
+}
+
 macro_rules! create_dom_exception {
     ($name:ident, $($variant:ident),+ $(,)?) => {
         #[derive(Debug)]
@@ -294,6 +349,17 @@ pub fn init(ctx: &Ctx<'_>) -> Result<()> {
     let primordials = BasePrimordials::get(ctx)?;
     dom_ex_proto.set_prototype(Some(&primordials.prototype_error))?;
 
+    if let Some(constructor) = Class::<QuotaExceededError>::create_constructor(ctx)? {
+        // the wpt tests expect this particular property descriptor
+        globals.prop(
+            QuotaExceededError::NAME,
+            Property::from(constructor).writable().configurable(),
+        )?;
+    }
+
+    let qee_ex_proto = Class::<QuotaExceededError>::prototype(ctx)?.unwrap();
+    qee_ex_proto.set_prototype(Some(&primordials.prototype_error))?;
+
     // `Error.isError(v)` only returns `true` for objects with QuickJS's
     // `[[ErrorData]]` internal slot (class id `JS_CLASS_ERROR`). There is
     // no public rquickjs API to tag a class-derived instance with that
@@ -314,5 +380,9 @@ fn is_error<'js>(ctx: Ctx<'js>, value: Value<'js>) -> Result<bool> {
         return Ok(false);
     };
     let dom_exception: Value = ctx.globals().get(DOMException::NAME)?;
-    Ok(obj.is_instance_of(&dom_exception))
+    if obj.is_instance_of(&dom_exception) {
+        return Ok(true);
+    }
+    let quota_exceeded_error: Value = ctx.globals().get(QuotaExceededError::NAME)?;
+    Ok(obj.is_instance_of(&quota_exceeded_error))
 }