| --- |
| language: |
| - en |
| license: mit |
| task_categories: |
| - text-generation |
| tags: |
| - assembly |
| - security |
| - constant-time |
| - side-channels |
| - binsec |
| size_categories: |
| - n<1K |
| --- |
| |
| # RelBench-O2: Constant-Time Assembly at -O2 |
|
|
| ## Overview |
|
|
| This dataset collects the **rel_bench** constant-time programs, re-cut into one |
| self-contained program per record, compiled with LLVM/Clang-17 at **-O2** for three |
| targets, and checked for constant-timeness with `binsec -sse -checkct`. |
| |
| Constant-time source code is not enough: the optimizer can reintroduce a secret-dependent |
| branch or memory access that the -O0 build does not have, and it does so *differently per |
| target*. The intended tasks are **transpilation** (translate the assembly to another ISA) |
| and **classification/repair** (decide whether a build leaks, and fix it if it does). |
| |
| ## Dataset Structure |
| |
| | Column | Description | |
| |--------|-------------| |
| | `task_name` | Sample identifier, e.g. `ct_select_1` | |
| | `flag_x86_64` | BinSec constant-time verdict for the x86-64 `-O2` build: `secure`, `insecure`, or `unknown` | |
| | `flag_aarch64_linux` | Same, for the AArch64 `-O2` build | |
| | `flag_riscv` | Same, for the RISC-V `-O2` build | |
| | `x86_64` | x86-64 assembly at -O2 (**Intel syntax**, built with `-masm=intel`) | |
| | `aarch64_linux` | AArch64 assembly at -O2 | |
| | `riscv` | RISC-V RV64 (`rv64gc`/`lp64d`) assembly at -O2 | |
| | `test_c` | C source of the BinSec harness (`test.c`) -- tags inputs secret/public through the `high_input_N` / `low_input_N` markers and calls the function under analysis | |
| | `binsec_output_x86_64` | Full `binsec -checkct` log for the x86-64 `-O2` build -- the evidence `flag_x86_64` was parsed from, including the leaking instruction addresses | |
| | `binsec_output_aarch64_linux` | Same, for the AArch64 `-O2` build | |
| | `binsec_output_riscv` | Same, for the RISC-V `-O2` build | |
| |
| ## Statistics |
| |
| - **Total records**: 36 |
| |
| | column | secure | insecure | unknown | |
| |---|---|---|---| |
| | `flag_x86_64` | 31 | 5 | 0 | |
| | `flag_aarch64_linux` | 34 | 2 | 0 | |
| | `flag_riscv` | 29 | 7 | 0 | |
| |
| ## The constant-time oracle |
| |
| Each build is analysed by BinSec's `checkct` plugin: |
| |
| ```bash |
| binsec -sse -checkct -sse-script "libsym.ini,checkct.cfg" -sse-depth 50000 test_bin |
| ``` |
| |
| `libsym.ini` replaces the `high_input_N` markers with `secret` and the `low_input_N` |
| markers with `nondet` (public), so BinSec knows which bytes are secret. It then reports: |
| |
| - `secure` -- no control flow or memory access depends on a secret |
| - `insecure` -- at least one secret-dependent branch or address was found |
| - `unknown` -- BinSec could not decide (path cut, depth limit, unresolved symbol) |
| |
| **The verdict is per build.** The same program can be secure on one target and insecure on |
| another, because the three backends make different branch/`cmov`/`csel` choices at -O2. |
| That is why the verdict is not collapsed into one label: each target carries its own |
| `flag_*` column, with the full analysis log in the matching `binsec_output_*` column -- |
| that log names the control-flow and memory-access checks that failed and at which |
| addresses, so an `insecure` verdict can be traced back to a specific instruction. |
|
|
| ## Usage |
|
|
| ```python |
| from datasets import load_dataset |
| |
| ds = load_dataset("Akirayasha/relbench_O2", split="test") |
| |
| record = ds[0] |
| src_asm = record["x86_64"] # source-side assembly |
| tgt_asm = record["riscv"] # reference target-side assembly |
| leaky = record["flag_riscv"] == "insecure" # per-target verdict |
| harness = record["test_c"] # rebuild + recheck a candidate against BinSec |
| why = record["binsec_output_riscv"] # the BinSec log behind flag_riscv |
| ``` |
|
|
| ## Citation |
|
|
| Part of the CISC-to-RISC transpilation research project at MBZUAI. |
|
|
