Sandboxes can protect the user’s computer from malicious or buggy scripts.But sandboxes are difficult to get right; you need to be very careful with whatyou expose, and make sure you test for vulnerabilities.The Sandboxes on the Lua wiki is requiredreading, as it contains very helpful advice.

Introduction to AI sandbox. AI sandbox is a framework that is designed to do away with the tedious job of application management, resource handling, memory management, and Lua binding, so that you can focus immediately on creating AI in Lua. While the sandbox does the dirty work of a small game engine, none of the internals of the sandbox are. Introduction to AI sandbox. AI sandbox is a framework that is designed to do away with the tedious job of application management, resource handling, memory management, and Lua binding, so that you can focus immediately on creating AI in Lua. While the sandbox does the dirty work of a small game engine, none of the internals of the sandbox are.

Environments

An environment is a table that stores the global variables available to a function.Each function will have an environment assigned to it, and we can use this to sandboxcode. To manage environments in sol3, you will usesol::environment.

To sandbox, you will want to create an environment with only whitelisted,safe functions. Let’s list all the safe global functions:

Now, let’s copy the whitelisted globals into the environment:

Next, you’ll want to define and copy whitelisted modules.We didn’t include these in the above list, as we want to copy the tables themselves.This prevents changes that untrusted code makes to modules from affecting trusted code.

Finally, you’ll want to partially copy modules that contain unsafe functions:

Safe loadstring, loadfile, and dofile

What?

Let’s first revise what each function does:

loadstring(string [, chunkname])
- Attempts to load string as a function.
- Returns either the function, or nil, error_msg.
loadfile(path)
- Attempts to load file file as a function.
- Returns either the function, or nil, error_msg.
dofile(path)
- Loads from the file, and executes it. Returns the return value of the file.
- If there is an error, it is not caught by dofile.

We need to provide safe implementations of each of these functions.We will do this be making sure that the following things are checked:

The environment is set on any functions. The default loadstring will set theglobal environment on the returned function, which allows escaping the sandbox.
Bytecode cannot be loaded, as it can beused to escape the sandbox.
In loadfile, we check that the file path is within the sandbox path.

loadstring

LUA_SIGNATURE is the character used to indicate that some source code isbytecode.

env.set_on(func) is used to set the environment.

loadfile

checkPath is a method that will be used later to verify that path is allowed,for now it can be defined to always return true.

dofile

dofile will need to check the load result, and run the function in unsafe mode.

Adding to the environment

Don’t forget to actually set them on the environment!

Running scripts safely

The easiest way to run a script safely is to pass the environment into script_file:

Setting the global environment

In order to safely execute our scripts, we need to remember to set the safeenvironment. Wouldn’t it be nicer to change the default environment in Lua?

The default environment in Lua is stored in a registry value, and so can be assignedlike so:

Unfortunately, the preprocessors to support multiple versions of Lua makes thisugly. If you’re only targeting a specific version, you can remove the unused branch.

We can now safely load scripts directly, without specifying the environment:

Checking file paths

Ideally, you’d not allow any file system access to untrusted scripts. You canuse virtual file systems to load all allowed resources into memory, and then onlyread from memory.

However, sometimes the scripts aren’t totally untrusted, and you would like to allowsome access to the file system. TO do this, you can check the path to make sure it’sin an allowed location. Note that this isn’t completely safe, symlinks can be usedto escaped the allowed path - however, if scripts can’t make symlinks thenit’s the user’s stupidity.

C++17’s filesystem provides useful path-parsing methods:

You may wish to extend this to add multiple base paths, and also add a way torestrict writing to a subset of the paths.

Preventing infinite loops

You can use lua_sethook to run a callback after a number of instructions,and then raise a Lua error.

Summary

I hope you found this article useful. This doesn’t cover all possible exploits -untrusted code may still crash or freeze the program - but it aims to at leastprotect the host from the code.

I’d like to finish by reminding you to add sandbox unit tests to make sure thatit’s working correctly, and you don’t accidentally break it. This can be assimple as some asserts in a builtin Lua file somewhere.

Links

1995

Sandboc Lua From C