[pull] main from VirusTotal:main

Cargo.toml

@@ -106,7 +106,7 @@ walrus = "0.26.1"
 wasm-bindgen = "0.2.117"
 wasm-bindgen-test = "0.3.67"
 wasm-opt = "0.116.1"
-wasmtime = { version = "40.0.4", default-features = false }
+wasmtime = { version = "43.0.1", default-features = false }
 x509-parser = "0.18.0"
 yansi = "1.0.1"
 yara-x = { path = "lib", version = "1.15.0" }

lib/src/compiler/errors.rs

@@ -652,7 +652,7 @@ pub struct InvalidModifier {
 #[associated_enum(CompileError)]
 #[error(code = "E034", title = "potentially slow loop")]
 #[label(
-"this range can be very large",
+    "this range can be very large",
     loc
 )]
 pub struct PotentiallySlowLoop {

lib/src/compiler/rules.rs

@@ -6,6 +6,7 @@ use std::slice::Iter;
 use std::time::Instant;
 
 use aho_corasick::AhoCorasick;
+use anyhow::anyhow;
 #[cfg(feature = "logging")]
 use log::*;
 use regex_automata::meta::Regex;
@@ -225,11 +226,13 @@ impl Rules {
             #[cfg(feature = "logging")]
             let start = Instant::now();
 
-            rules.compiled_wasm_mod =
-                Some(wasm::runtime::Module::from_binary(
+            rules.compiled_wasm_mod = Some(
+                wasm::runtime::Module::from_binary(
                     wasm::get_engine(),
                     rules.wasm_mod.as_slice(),
-                )?);
+                )
+                .map_err(|e| SerializationError::from(anyhow!(e)))?,
+            );
 
             #[cfg(feature = "logging")]
             info!("WASM build time: {:?}", Instant::elapsed(&start));

lib/src/wasm/mod.rs

@@ -99,8 +99,8 @@ use crate::types::{
 };
 use crate::wasm::integer::RangedInteger;
 use crate::wasm::runtime::{
-    AsContext, AsContextMut, Caller, Config, Engine, FuncType, Linker, ValRaw,
-    ValType,
+    AsContext, AsContextMut, Caller, Config, Engine, FuncType, Linker,
+    Trampoline, TrampolineResult, ValRaw, ValType,
 };
 use crate::wasm::string::RuntimeString;
 use crate::wasm::string::String as _;
@@ -279,7 +279,7 @@ impl WasmExport {
 pub(crate) trait WasmExportedFn {
     /// Returns the function that will be passed to the selected runtime linker
     /// while linking the WASM code to this function.
-    fn trampoline(&'static self) -> TrampolineFn;
+    fn trampoline(&'static self) -> Trampoline<ScanContext<'static, 'static>>;
 
     /// Returns a [`Vec<ValType>`] with the types of the function's
     /// arguments
@@ -302,13 +302,6 @@ pub(crate) trait WasmExportedFn {
     }
 }
 
-type TrampolineFn = Box<
-    dyn Fn(Caller<'_, ScanContext>, &mut [ValRaw]) -> anyhow::Result<()>
-        + Send
-        + Sync
-        + 'static,
->;
-
 const MAX_RESULTS: usize = 4;
 type WasmResultArray<T> = SmallVec<[T; MAX_RESULTS]>;
 
@@ -689,11 +682,11 @@ macro_rules! impl_wasm_exported_fn {
             #[allow(unused_variables)]
             #[allow(non_snake_case)]
             #[allow(unused_mut)]
-            fn trampoline(&'static self) -> TrampolineFn {
+            fn trampoline(&'static self) -> Trampoline<ScanContext<'static, 'static>> {
                 Box::new(
                     |mut caller: Caller<'_, ScanContext>,
                      args_and_results: &mut [ValRaw]|
-                     -> anyhow::Result<()> {
+                     -> TrampolineResult {
                         let mut i = 0;
                         $(
                             let $args = args_and_results[i].raw_into(caller.data_mut());
@@ -707,7 +700,8 @@ macro_rules! impl_wasm_exported_fn {
                         let num_results = result_slice.len();
 
                         args_and_results[0..num_results].clone_from_slice(result_slice);
-                        anyhow::Ok(())
+
+                        TrampolineResult::Ok(())
                     },
                 )
             }

lib/src/wasm/runtime/browser.rs

@@ -40,6 +40,9 @@ pub(crate) use super::common::{
     ValType,
 };
 
+pub(crate) type Trampoline<T> = common::Trampoline<T, Backend>;
+pub(crate) type TrampolineResult = common::TrampolineResult;
+
 struct GlobalInner {
     val_type: ValType,
     mutability: Mutability,

lib/src/wasm/runtime/common.rs

@@ -529,6 +529,15 @@ pub(crate) struct Linker<T, B: RuntimeBackend> {
     _phantom: PhantomData<T>,
 }
 
+pub(crate) type Trampoline<T, B> = Box<
+    dyn Fn(Caller<'_, T, B>, &mut [ValRaw]) -> TrampolineResult
+        + Send
+        + Sync
+        + 'static,
+>;
+
+pub(crate) type TrampolineResult = Result<()>;
+
 impl<T: 'static, B: RuntimeBackend> Linker<T, B> {
     /// Creates an empty linker.
     ///
@@ -552,13 +561,8 @@ impl<T: 'static, B: RuntimeBackend> Linker<T, B> {
         name: &str,
         ty: FuncType,
         sync_flags: u32,
-        trampoline: Box<
-            dyn Fn(Caller<'_, T, B>, &mut [ValRaw]) -> Result<()>
-                + Send
-                + Sync
-                + 'static,
-        >,
-    ) -> Result<()> {
+        trampoline: Trampoline<T, B>,
+    ) -> TrampolineResult {
         // This mirrors Wasmtime's unchecked registration API. The generated
         // WASM determines the ABI, so the runtime only needs to record the
         // metadata and trampoline here.
@@ -571,7 +575,8 @@ impl<T: 'static, B: RuntimeBackend> Linker<T, B> {
             sync_flags,
             trampoline: Arc::from(trampoline),
         });
-        Ok(())
+
+        TrampolineResult::Ok(())
     }
 
     /// Defines an extern import.

lib/src/wasm/runtime/native.rs

@@ -3,8 +3,9 @@
 //! This adapter exists only to normalize a couple of APIs so the rest of the
 //! crate can talk to native and custom runtimes through the same interface.
 
-use anyhow::Result;
-
+use crate::errors::SerializationError;
+use anyhow::anyhow;
+use std::mem::transmute;
 /// Wasmtime types re-exported by the native runtime.
 pub(crate) use wasmtime::{
     AsContext, AsContextMut, Caller, Config, Engine, Extern, FuncType, Global,
@@ -15,8 +16,14 @@ pub(crate) use wasmtime::{
 /// Thin wrapper around [`wasmtime::Linker`] with a backend-neutral API.
 pub(crate) struct Linker<T>(wasmtime::Linker<T>);
 
-type Trampoline<T> =
-    dyn Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static;
+pub(crate) type Trampoline<T> = Box<
+    dyn Fn(Caller<'_, T>, &mut [ValRaw]) -> TrampolineResult
+        + Send
+        + Sync
+        + 'static,
+>;
+
+pub(crate) type TrampolineResult = wasmtime::Result<()>;
 
 impl<T: 'static> Linker<T> {
     /// Creates a new linker.
@@ -35,11 +42,21 @@ impl<T: 'static> Linker<T> {
         name: &str,
         ty: FuncType,
         sync_flags: u32,
-        trampoline: Box<Trampoline<T>>,
-    ) -> Result<()> {
+        trampoline: Trampoline<T>,
+    ) -> TrampolineResult {
         let _ = sync_flags;
         unsafe {
-            self.0.func_new_unchecked(module, name, ty, trampoline).map(|_| ())
+            self.0
+                .func_new_unchecked(module, name, ty, move |caller, args| {
+                    trampoline(
+                        caller,
+                        transmute::<
+                            &mut [std::mem::MaybeUninit<ValRaw>],
+                            &mut [ValRaw],
+                        >(args),
+                    )
+                })
+                .map(|_| ())
         }
     }
 
@@ -50,7 +67,7 @@ impl<T: 'static> Linker<T> {
         module: &str,
         name: &str,
         item: impl Into<Extern>,
-    ) -> Result<&mut Self> {
+    ) -> wasmtime::Result<&mut Self> {
         self.0.define(store, module, name, item)?;
         Ok(self)
     }
@@ -60,7 +77,9 @@ impl<T: 'static> Linker<T> {
         &self,
         store: impl AsContextMut<Data = T>,
         module: &Module,
-    ) -> Result<Instance> {
-        self.0.instantiate(store, module)
+    ) -> Result<Instance, SerializationError> {
+        self.0
+            .instantiate(store, module)
+            .map_err(|e| SerializationError::InvalidWASM(anyhow!(e)))
     }
 }

ls/src/features/diagnostics.rs

@@ -163,7 +163,7 @@ pub fn compiler_diagnostics(
                         |meta| {
                             matches!(
                                 meta.value,
-                                yara_x_parser::ast::MetaValue::Float(_)
+                                yara_x_parser::ast::MetaValue::Bool(_)
                             )
                         },
                         format!(