• Continuously grow a string, an array, a BLOB or object map until all memory is consumed.

• Continuously create new variables with large data until all memory is consumed.

• Continuously define new functions all memory is consumed (e.g. a simple closure ||, as short as two characters, is a function – an attractive target for DOS attacks).

• Infinite tight loop that consumes all CPU cycles.

• Run indefinitely, thereby blocking the calling system which is waiting for a result.

• Deep recursive call that exhausts the call stack.

• Large array or object map literal that exhausts the stack during parsing.

• Degenerated deep expression with so many levels that the parser exhausts the call stack when parsing the expression; or even deeply-nested statements blocks, if nested deep enough.

• Self-referencing module.

• Numeric overflows and/or underflows.

• Divide by zero.

• Bad floating-point representations.

• Continuously import an external module within an infinite loop, thus putting heavy load on the file-system (or even the network if the file is not local).

  Even when modules are not created from files, they still typically consume a lot of resources to load.

• Read from and/or write to private, secret, sensitive data.

  Such security breach may put the entire system at risk.

The internals feature allows third-party access to Rust internal data types and functions (for example, the AST and related types).

This is usually a Very Bad Idea™ because:

• Messing up Rhai’s internal data structures will easily create panics that bring down the host environment, violating the Don’t Panic guarantee.

• Allowing access to internal types may open up new attack vectors.

• Internal Rhai types and functions are volatile, so they may change from version to version and break code.

Use internals only if the operating environment has absolutely no safety concerns – you’d be surprised under how few scenarios this assumption holds.

One example of such an environment is a Rhai scripting Engine compiled to WASM where the AST is further translated to include environment-specific modifications.