use rhai::packages::{
ArithmeticPackage, BasicArrayPackage, BasicFnPackage, BasicIteratorPackage, BasicMapPackage,
BasicMathPackage, BasicStringPackage, LogicPackage, MoreStringPackage, Package,
};
use rhai::{AST, Dynamic, Engine, EvalAltResult, Scope};
use serde_json::Value;
use super::json::{from_dynamic_value, to_dynamic_value};
use super::validate::check_ast;
use crate::{Error, ExprIssue, ExprIssueKind, LimitKind, Result, ValidationError};
pub const DEFAULT_MAX_OPERATIONS: u64 = 50_000;
pub const DEFAULT_MAX_CALL_LEVELS: usize = 64;
pub const DEFAULT_MAX_STRING_SIZE: usize = 64 * 1024;
pub const DEFAULT_MAX_ARRAY_SIZE: usize = 4096;
pub const DEFAULT_MAX_MAP_SIZE: usize = 4096;
pub use crate::DEFAULT_MAX_SOURCE_LEN;
#[derive(Debug, Clone)]
pub struct CompiledExpr(AST);
pub struct BoundedRhaiEngine {
engine: Engine,
scope: Scope<'static>,
max_source_len: usize,
}
impl BoundedRhaiEngine {
pub fn new() -> Self {
Self {
engine: default_limited_engine(
DEFAULT_MAX_OPERATIONS,
DEFAULT_MAX_CALL_LEVELS,
DEFAULT_MAX_STRING_SIZE,
DEFAULT_MAX_ARRAY_SIZE,
DEFAULT_MAX_MAP_SIZE,
),
scope: Scope::new(),
max_source_len: DEFAULT_MAX_SOURCE_LEN,
}
}
pub fn with_defaults() -> Self {
Self::new()
}
pub fn with_max_operations(mut self, max: u64) -> Self {
self.engine.set_max_operations(max);
self
}
pub fn with_max_call_levels(mut self, max: usize) -> Self {
self.engine.set_max_call_levels(max);
self
}
pub fn with_max_string_size(mut self, max: usize) -> Self {
self.engine.set_max_string_size(max);
self
}
pub fn with_max_array_size(mut self, max: usize) -> Self {
self.engine.set_max_array_size(max);
self
}
pub fn with_max_map_size(mut self, max: usize) -> Self {
self.engine.set_max_map_size(max);
self
}
pub fn with_max_source_len(mut self, max: usize) -> Self {
self.max_source_len = max;
self
}
pub fn eval(&mut self, code: &str) -> Result<String> {
if code.len() > self.max_source_len {
return Err(Error::ResourceExhausted {
backend: crate::EngineType::Rhai,
kind: LimitKind::Source,
});
}
match self
.engine
.eval_with_scope::<rhai::Dynamic>(&mut self.scope, code)
{
Ok(result) => Ok(result.to_string()),
Err(e) => Err(map_rhai_error(e)),
}
}
pub fn compile(&self, src: &str) -> Result<CompiledExpr> {
if src.len() > self.max_source_len {
return Err(Error::ResourceExhausted {
backend: crate::EngineType::Rhai,
kind: LimitKind::Source,
});
}
self.engine
.compile(src)
.map(CompiledExpr)
.map_err(|e| Error::Rhai(e.to_string()))
}
pub fn eval_ast_with_scope(
&mut self,
ast: &CompiledExpr,
scope: &mut Scope,
) -> Result<Dynamic> {
self.engine
.eval_ast_with_scope::<Dynamic>(scope, &ast.0)
.map_err(map_rhai_error)
}
pub fn set_var(&self, scope: &mut Scope, name: &str, value: &Value) -> Result<()> {
crate::check_var_name(name)?;
let dynamic = to_dynamic_value(value)?;
scope.set_value(name, dynamic);
Ok(())
}
pub fn to_json(&self, value: &Dynamic) -> Result<Value> {
from_dynamic_value(value)
}
pub fn check_expression(
&self,
src: &str,
locator: &str,
allowed_roots: &[&str],
) -> std::result::Result<(), ValidationError> {
if src.len() > self.max_source_len {
return Err(ValidationError(vec![ExprIssue {
locator: locator.to_string(),
message: format!(
"expression too long ({} bytes, max {})",
src.len(),
self.max_source_len
),
kind: ExprIssueKind::Syntax,
}]));
}
let ast = match self.engine.compile(src) {
Ok(ast) => ast,
Err(e) => {
return Err(ValidationError(vec![ExprIssue {
locator: locator.to_string(),
message: format!("invalid expression: {e}"),
kind: ExprIssueKind::Syntax,
}]));
}
};
let issues = check_ast(&ast, locator, allowed_roots);
if issues.is_empty() {
Ok(())
} else {
Err(ValidationError(issues))
}
}
pub fn fork_scope<'a>(&self, scope: &Scope<'a>) -> Scope<'a> {
scope.clone()
}
pub fn clear_scope(&self, scope: &mut Scope) {
scope.clear();
}
}
impl Default for BoundedRhaiEngine {
fn default() -> Self {
Self::new()
}
}
fn default_limited_engine(
max_operations: u64,
max_call_levels: usize,
max_string_size: usize,
max_array_size: usize,
max_map_size: usize,
) -> Engine {
let mut engine = Engine::new_raw();
ArithmeticPackage::new().register_into_engine(&mut engine);
BasicArrayPackage::new().register_into_engine(&mut engine);
BasicMapPackage::new().register_into_engine(&mut engine);
BasicStringPackage::new().register_into_engine(&mut engine);
MoreStringPackage::new().register_into_engine(&mut engine);
LogicPackage::new().register_into_engine(&mut engine);
BasicFnPackage::new().register_into_engine(&mut engine);
BasicMathPackage::new().register_into_engine(&mut engine);
BasicIteratorPackage::new().register_into_engine(&mut engine);
engine.on_print(|_| {});
engine.on_debug(|_, _, _| {});
register_deterministic_helpers(&mut engine);
engine.set_max_operations(max_operations);
engine.set_max_call_levels(max_call_levels);
engine.set_max_string_size(max_string_size);
engine.set_max_array_size(max_array_size);
engine.set_max_map_size(max_map_size);
engine
}
fn register_deterministic_helpers(engine: &mut Engine) {
engine.register_fn("hash", |value: Dynamic| {
fnv1a_64(value.to_string().as_bytes()) as i64
});
}
fn fnv1a_64(bytes: &[u8]) -> u64 {
const OFFSET_BASIS: u64 = 14695981039346656037;
const PRIME: u64 = 1099511628211;
let mut hash = OFFSET_BASIS;
for byte in bytes {
hash ^= *byte as u64;
hash = hash.wrapping_mul(PRIME);
}
hash
}
fn map_rhai_error(e: Box<EvalAltResult>) -> Error {
let kind = match *e {
EvalAltResult::ErrorTooManyOperations(_) => Some(LimitKind::Operations),
EvalAltResult::ErrorStackOverflow(_) => Some(LimitKind::CallDepth),
EvalAltResult::ErrorDataTooLarge(ref discriminator, _) => {
data_too_large_kind(discriminator)
}
_ => None,
};
match kind {
Some(kind) => Error::ResourceExhausted {
backend: crate::EngineType::Rhai,
kind,
},
None => Error::Rhai(e.to_string()),
}
}
fn data_too_large_kind(discriminator: &str) -> Option<LimitKind> {
if discriminator.starts_with("Length of string") {
Some(LimitKind::String)
} else if discriminator.starts_with("Size of array") {
Some(LimitKind::Array)
} else if discriminator.starts_with("Size of object map") {
Some(LimitKind::Map)
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builder_defaults_match_pub_consts() {
let mut engine = BoundedRhaiEngine::with_defaults();
assert_eq!(engine.max_source_len, DEFAULT_MAX_SOURCE_LEN);
let mut tiny = BoundedRhaiEngine::new().with_max_operations(10);
let err = tiny.eval("while true {}").unwrap_err();
assert!(
matches!(
err,
Error::ResourceExhausted {
kind: LimitKind::Operations,
..
}
),
"expected fuel exhaustion, got: {err:?}"
);
assert_eq!(engine.eval("40 + 2").unwrap(), "42");
}
#[test]
fn source_len_cap_is_enforced_host_side() {
let mut engine = BoundedRhaiEngine::new().with_max_source_len(10);
let err = engine.eval("1 + 2 + 3 + 4").unwrap_err();
assert!(
matches!(
err,
Error::ResourceExhausted {
kind: LimitKind::Source,
..
}
),
"expected source cap, got: {err:?}"
);
assert_eq!(engine.eval("1 + 2").unwrap(), "3");
}
}