code wiki / (root) / nx_evoracle_emit.nx

nx_evoracle_emit.nx

buildroot/runtime/nx_evoracle_emit.nx

7589 B168 linesdepth 2pulls 2 transitivereach 0 importersview sourcekind tooltopic evoracle
docsdependenciesstructsconstsfunctions

about

nx_evoracle_emit.nx -- THE MISSING PRODUCER for EV_CLASS_ORACLE (closes M3). EV_CLASS_ORACLE had exactly ONE consumer (nx_sota_status.nx:220) and NO producer, so an oracle row was hand-typed prose: an agent could write `class=oracle ref=RFC7748` having compared nothing. Without a second class no mechanical domain can reach min_classes=2, which is why the board reads PROVEN 0/41 -- pinned by an EMPTY TABLE, not by any failed measurement. ★★★★★THE LAW THIS ENFORCES (nx_evoracle.nx): AN ORACLE ATTESTATION MUST BE DERIVED FROM AN EXECUTION, NEVER DECLARED IN PROSE. A signature buys attribution and tamper-evidence; it does NOT buy truth, because whoever holds the key can sign a false claim. What buys truth is RE-DERIVABILITY. So this organ REFUSES to accept a verdict as an argument -- it RUNS the named gate and reads the verdict off the actual exit code, and it pins WHICH external vector block was compared by digesting that file. Anti-gaming properties, by construction rather than by promise: - verdict is DERIVED (exit code), never passed in. There is no argument that can assert "pass". - a missing or unreadable vector file REFUSES (exit 3). "It matched" is not evidence unless it says what it matched. - a gate that cannot be executed REFUSES (exit 4). A row is never written for a run that did not happen -- the failure mode the whole evidence lane exists to kill. - ref= carries authority + digest, so a later reader re-runs the comparison and gets the same answer. The digest is FNV-1a 64: it pins WHICH block was used and detects drift. It is NOT cryptographic and is not claimed to be -- tamper-resistance here comes from re-derivability, not from the hash. nx_evoracle_emit <domain> <gate_elf> <vector_file> <authority> <scope> license_tier: ORIGINAL layer: evidence module: nishi-core.evidence.evoracle_emit

dependencies 1 imports · 0 importers

nx_syscalls.nx nx_evoracle_emit.nx

imports: nx_syscalls.nx

imported by: nobody (leaf or entry point)

call flow from main pre-order; caps 40 nodes / depth 6 declared; ↻ = already shown

main eo_p sys_write sys_exit sys_openat_rd sys_mmap nxa_die sys_write ↻ sys_exit ↻ nxa_lock_take nxa_lock_addr sys_write ↻ nxa_lock_give nxa_lock_addr ↻ nxa_report_overrun sys_write ↻ nxa_dump_printable sys_write ↻ nxa_dump_sizes sys_write ↻ sys_read sys_close eo_fnv sys_fork sys_execve sys_wait4 wait_exit_code eo_n sys_mmap ↻ sys_write ↻ eo_cat eo_catx eo_catn sys_mmap ↻ sys_now_realtime_sec sys_mmap ↻ sys_clock_gettime_real sys_openat_append sys_write ↻

structs

none

consts

30const EO_MAXV: i64 = 4194304

functions

36func eo_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
called by 1: main calls 1: sys_write
37func eo_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
38func eo_n(v: i64) -> i64
called by 1: main calls 2: sys_mmapsys_write
49func eo_cat(dst: *u8, off: i64, s: *u8) -> i64 { var o: i64=off; var i: i64=0; while s[i]!=(0 as u8){ dst[o]=s[i]; o=o+1; i=i+1 } return o }
called by 1: main
50func eo_catn(dst: *u8, off: i64, v: i64) -> i64
called by 1: main calls 1: sys_mmap
60func eo_catx(dst: *u8, off: i64, v: i64) -> i64
called by 1: main
71func eo_fnv(b: *u8, n: i64) -> i64
called by 1: main
78func main(argc: i64, argv: *i64) -> i64