vestigia

CHANGELOG (4578B)

---

 # Changelog
 
 - 0.2.0 (2026-10-31)
   * Data-independent-timing contracts: `record --contract arm-dit`
     or `intel-doitm`, with `--object` and `--objdump`, has the plugin
     fingerprint the operands of every instruction outside the ISA's
     contract in the objects named, as it does a division's. The
     tables are transcribed from the vendors' statements: Arm's A64
     ISA XML (2022-12), every encoding with its source registers, and
     Intel's list 768547 (2026-02-23).
   * `diff` reports such an instruction on other operands under
     `outside`, apart from the origins, with its text, and how many
     ran (vestigia/diff-v4, which also names the ISA and contract, and
     gives an operand origin its text where the watch list named it).
     Runs recorded under other contracts are refused.
   * `vestigia watch` writes the watch list once, for `record --watch`
     to read in every run of one program; `diffOf` does so.
   * `record` appends the guest's ISA to its dump.
   * `diffOf` takes a `contract`; the command finds LLVM's
     `llvm-objdump` through `$VESTIGIA_OBJDUMP`.
   * `read` resolves the objects a harness reports to the files they
     name, as memcheck names a frame's object, so a library reached by
     its soname's link has its sites placed by offset.
   * `record --cpu MODEL` has QEMU emulate MODEL (its -cpu), which the
     dump records (a `P` line); `diff` refuses runs recorded on other
     models and names the model in its report; `diffOf` takes `cpu`.
   * QEMU's AArch64 models take `crypto=off`, removing the
     cryptographic extension as a CPU without it reports
     (qemu-crypto.patch).
 
 - 0.1.0 (2026-10-22)
   * Initial version, with two instruments over a harness that marks
     its secret (`vestigia.h`, defined by `vestigia.c`, which serves
     a foreign function interface too and records where the loader
     put each object). A taint run that marked no secret is refused.
   * `vestigia run`: the harness under memcheck with the secret's
     bytes undefined, reporting each branch, address, and integer
     division operand computed from them (the last through a memcheck
     patch, `nix/memcheck-operand.patch`), each at its own
     instruction. `--dir` keeps a run, and `vestigia read` reports on
     several kept runs, or memcheck XML made elsewhere, as one
     (vestigia/trace-v2: each run with its command, exit, and
     objects; each site with the runs that reached it).
   * `vestigia record` and `vestigia diff`: the harness under QEMU
     with vestigia's plugin, its leakage trace summarised per
     instruction, and where runs differing only in the secret diverge
     (vestigia/diff-v3):
     * each run with how it was made, its arguments and exit status;
     * the origins: a branch taking its outcomes in another proportion
       or order, an instruction touching other addresses, and an
       integer division on other operands, a return never one; each
       with the runs alike there, the runs that never reached it, and
       the calls that reached it;
     * what ran downstream, and what every run executed, per object;
     * controls repeating a secret, what differs in them set apart as
       unsteady, and runs designed to reach particular paths, compared
       for control and coverage alone (`--designed`).
   * `record` runs an x86_64 or aarch64 harness on either host, with
     randomisation off (or not at all), the guest's entropy, its
     getrandom included, seeded, and QEMU's own allocations kept off
     the guest's mappings, which under load can otherwise take the
     room of a guest library or heap. The plugin names each
     instruction by its address in its object, and stops a guest that
     starts a second thread.
   * `diff` refuses runs that loaded an object at different
     addresses; runs of another program, or with arguments or an
     environment of another size, than the first run's; a control
     that does not repeat the first run's arguments; and a stopped
     guest's dump. It names sources with LLVM's addr2line.
   * `traceOf` and `diffOf` run either as a derivation, over a list of
     runs; `nix/lib.nix` holds them for any package set, with the
     version the command reports.
   * `--object` keeps a taint run's sites (`run`, `read`, and
     `traceOf`'s `objects`) to objects whose path contains the given
     text, as it keeps a differential run's origins.
   * The flake's probe check (`checks.<system>.probe`, on Linux) holds
     both instruments' reports on a known harness to what it does, and
     on an x86_64 host the differential one on the same harness built
     for aarch64.