WARK

WebAssembly RunKit, also known as WARK, is a highly efficient tool designed to execute WebAssembly (w/ WASI) modules within a secure sandboxed environment. It can meticulously calculate and report the precise resource usage of the module, including instruction cost and memory utilization.

You can use WARK as a Command-Line Interface (CLI) tool or as a web service, depending on your needs.

Table of Contents

• WARK
  • Table of Contents
  • Installation
    • Docker
    • Cargo
  • Usage
    • CLI
      • Options
      • IO
    • Web Service
      • Run
      • Judge
  • Cost Table

Installation

Docker

If you have Docker installed, you can use the following command to run WARK:

# Run the web service
docker run -it --rm -p 33000:33000 jacoblincool/wark server

Cargo

To install WARK using Cargo, use the following command:

cargo install wark

Usage

CLI

To run a WebAssembly module using the CLI, use the following command:

wark run [OPTIONS] <module>

Options

You can customize the execution with the following options:

  -m, --memory <memory>     Define memory limit in MB [default: 512]
  -c, --cost <cost>         Set computational cost limit in instruction count [default: 1000000000]
  -i, --input <input>       Specify input file path for the program [default: stdin]
      --stderr <file>       Redirect program's stderr to a file
  -n, --no-report           Suppress the report of the program's resource usage

IO

• You can use the --input option to specify the input file path for the program. If you want to use stdin as the input, use - as the input file path.
• The stdout of the module will be printed to the stdout of the CLI.
• The stderr of the module will not be printed to the stderr of the CLI. Instead, use the --stderr option to redirect it to a file.
• Unless suppressed with the --no-report option, the resource usage of the module will be printed to the stderr of the CLI.

Web Service

To start the WARK server, use the following command:

wark server

You can use the PORT environment variable to specify the port number. The default port number is 33000.

Run

To run a WebAssembly module, send a POST request with a JSON object in the body containing the following fields:

curl 'http://127.0.0.1:33000/run' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer <JWT_TOKEN>' \
--data '{
    "cost": 10000000,
    "memory": 512,
    "input": "I am stdin input",
    "wasm": "<base64 encoded wasm module>"
  }'

The server will respond with a JSON object containing the following fields:

{
    "success": true,
    "cost": 1234567,
    "memory": 345,
    "stdout": "I am stdout output",
    "stderr": "I am stderr output",
    "message": "I am message"
}

Judge

To run the program in judge mode, send a POST request with a JSON object in the body containing the following fields:

curl --location 'http://127.0.0.1:33000/judge' \
--header 'Content-Type: application/json' \
--header 'Authorization: Bearer <JWT_TOKEN>' \
--data '{
    "wasm": "<base64 encoded wasm module>",
    "specs": [
        {
            "judger": "IOFast",
            "input": "Jacob",
            "output_hash": "128783a055c41c0a79ad7376e8e22587cdca53ed1f9c47c46d02a7768992b325",
            "cost": 1000000000,
            "memory": 1024
        },
        {
            "judger": "IOFast",
            "input": "WOJ",
            "output_hash": "75787b1df461d0c48f0229a7769cbcc37c7d96d6613f825b77e76afdd1eb790a",
            "cost": 1000000000,
            "memory": 1024
        },
        {
            "judger": "IOFast",
            "input": "WASM OJ Wonderland",
            "output_hash": "8f02d3283b88d16766cb287090bf59135c873e9175759b73f96ffe674440ff21",
            "cost": 1000000000,
            "memory": 1024
        },
        {
            "judger": "IOFast",
            "input_url": "https://link-to-input.file/input.txt",
            "output_hash": "87c215c4afeaf7ff7684ef90fd44649b2051bc4c68cf58bdad402fa304487b8w",
            "cost": 1000000000,
            "memory": 1024
        }
    ]
}'

The server will respond with a JSON object containing the following fields:

{
    "results": [
        {
            "success": true,
            "cost": 3776,
            "memory": 1,
            "message": null,
            "exception": null
        },
        {
            "success": true,
            "cost": 3692,
            "memory": 1,
            "message": null,
            "exception": null
        },
        {
            "success": true,
            "cost": 4421,
            "memory": 1,
            "message": null,
            "exception": null
        },
        {
            "success": false,
            "cost": 5848,
            "memory": 1,
            "message": null,
            "exception": {
                "type": "Output",
                "reason": "Output hash mismatch. Expected 87c215c4afeaf7ff7684ef90fd44649b2051bc4c68cf58bdad402fa304487b8w, got 87c215c4afeaf7ff7684ef90fd44649b2051bc4c68cf58bdad402fa304487b8c"
            }
        }
    ]
}

Currently, the server only supports the IOFast judger, which is a simple judger that compares the trimmed output of the program with the output_hash field. If the output of the program matches the output_hash field, indicating that the program has passed the test case. Otherwise, an Output exception will be returned.

Remote inputs will be cached in the http-cache directory, the TTL of each cache is respecting the Cache-Control header of the response.

Cost Table

You can find the cost of each instruction in the src/cost.rs.

If you see Penalty Instruction [Instruction Name], it means that the specific instruction was not included in the cost table. Therefore, its cost defaults to 1000 points.

---

Feel free to contribute to this project by submitting pull requests or reporting issues. Your help is always welcomed and appreciated!