nx_spore_manifest_gate.nx source

1// nx_spore_manifest_gate.nx -- X-SEED-001 / V-SPORE manifest: the GERMINATION MANIFEST 2// (the seed body, "the .torrent of the organism"). Generalizes the proven single-piece 3// germination (V-SPORE-1, nx_spore_germ_gate) to a LAYERED, MULTI-piece, content-addressed seed: 4// PACK -- FNV-1a each piece's source bytes; EMIT germination_manifest.tsv 5// (id <tab> source <tab> hash <tab> layer <tab> kat_expect) = a real persisted seed. 6// GERMINATE -- in LAYER order, per piece: re-read source (received), FNV-1a, verify == packed 7// hash (INTEGRITY), materialize, REBUILD via the sovereign toolchain, run -> exit 8// == kat_expect (BEHAVIOR/KAT). ADMIT iff both. 9// NEG -- one piece tampered (a byte flipped) -> hash mismatch -> REJECTED, never built. 10// READ-BACK -- re-read the emitted manifest; data-row count must == piece count (seed persisted). 11// verdict GREEN iff ADMIT-ALL + NEG-REJECT + ROWS==N. 12// 13// HONEST scope: verification uses the in-run packed hashes + a persisted-manifest read-back; 14// full content-addressing FROM the persisted manifest (re-parse the recorded hash) and 15// AUTO-DERIVING the piece set from the capability registry/lineage (X-SEED-001 full) are next rungs. 16// 17// Build/run (from nxc2 cwd): _offc/nx_sov_build_run.elf nx_spore_manifest_gate 18// genealogy_id: nishi_spore_seed_portability_charter (X-SEED-001 / V-SPORE manifest) 19 20import "nx_syscalls.nx" 21import "nx_gate_verdict.nx" 22 23const GERM_FNV_OFFSET: i64 = 0 - 3750763034362895579 // 0xcbf29ce484222325 24const GERM_FNV_PRIME: i64 = 1099511628211 // 0x100000001b3 25const MAN_PATH: *u8 = "knowledge/registry/germination_manifest.tsv" 26const N_PIECES: i64 = 2 27 28func germ_hash(buf: *u8, len: i64) -> i64 { 29 var h: i64 = GERM_FNV_OFFSET 30 var i: i64 = 0 31 while i < len { h = h ^ (buf[i] as i64); h = h * GERM_FNV_PRIME; i = i + 1 } 32 return h 33} 34func g_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n } 35func g_puts(s: *u8) -> i64 { sys_write(1, s, g_slen(s)); return 0 } 36func g_puts_fd(fd: i64, s: *u8) -> i64 { sys_write(fd, s, g_slen(s)); return 0 } 37func g_tab(fd: i64) -> i64 { let t: *u8 = sys_mmap(8); t[0] = 9; sys_write(fd, t, 1); return 0 } 38func g_putn(fd: i64, v: i64) -> i64 { 39 let bb: *u8 = sys_mmap(28) 40 var m: i64 = v 41 if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) } 42 let t: *u8 = sys_mmap(28) 43 var k: i64 = 0 44 if m == 0 { t[0] = 48; k = 1 } 45 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 } 46 var i: i64 = 0 47 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } 48 sys_write(fd, bb, k) 49 return 0 50} 51// fork + optional redirect + execve; parent waits; 128+sig on signal-death (no fake success). 52func g_run(path: *u8, argv: *i64, redir_out: i64, redir_err: i64) -> i64 { 53 let pid: i64 = sys_fork() 54 if pid == 0 { 55 if redir_out >= 0 { sys_dup3(redir_out, 1, 0) } 56 if redir_err >= 0 { sys_dup3(redir_err, 2, 0) } 57 sys_execve(path, argv, 0 as *i64) 58 sys_exit(127) 59 } 60 let st: *i64 = sys_mmap(16) as *i64 61 sys_wait4(pid, st, 0) 62 let sig: i64 = st[0] & 0x7f 63 if sig != 0 { return 128 + sig } 64 return (st[0] >> 8) & 0xff 65} 66// rebuild+run a materialized piece by basename via the sovereign lane; returns its run-exit. 67func g_rebuild_run(basename: *u8) -> i64 { 68 let builder: *u8 = "_offc/nx_sov_build_run.elf" as *u8 69 let a: *i64 = sys_mmap(32) as *i64 70 a[0] = builder as i64 71 a[1] = basename as i64 72 a[2] = 0 73 return g_run(builder, a, 0 - 1, 0 - 1) 74} 75// one manifest row: id \t source \t hash \t layer \t kat \n 76func g_man_row(fd: i64, id: *u8, src: *u8, hash: i64, layer: i64, kat: i64) -> i64 { 77 g_puts_fd(fd, id); g_tab(fd) 78 g_puts_fd(fd, src); g_tab(fd) 79 g_putn(fd, hash); g_tab(fd) 80 g_putn(fd, layer); g_tab(fd) 81 g_putn(fd, kat); sys_write(fd, "\n" as *u8, 1) 82 return 0 83} 84 85func main() -> i64 { 86 g_puts("================================================================\n" as *u8) 87 g_puts(" GERMINATION MANIFEST -- layered multi-piece seed: pack -> emit ->\n" as *u8) 88 g_puts(" germinate each (hash+rebuild+KAT) in layer order; tamper rejected.\n" as *u8) 89 g_puts("================================================================\n" as *u8) 90 91 // ---- inline piece table (the seed's pieces; layer = hardware-up order, pre-sorted) ---- 92 let ids: *i64 = sys_mmap(8 * N_PIECES) as *i64 93 let srcs: *i64 = sys_mmap(8 * N_PIECES) as *i64 94 let scratches: *i64 = sys_mmap(8 * N_PIECES) as *i64 95 let bases: *i64 = sys_mmap(8 * N_PIECES) as *i64 96 let layers: *i64 = sys_mmap(8 * N_PIECES) as *i64 97 let kats: *i64 = sys_mmap(8 * N_PIECES) as *i64 98 let hashes: *i64 = sys_mmap(8 * N_PIECES) as *i64 99 100 ids[0] = ("nx_exit42" as *u8) as i64 101 srcs[0] = ("runtime/nx_exit42.nx" as *u8) as i64 102 scratches[0] = ("runtime/_germ_man_nx_exit42.nx" as *u8) as i64 103 bases[0] = ("_germ_man_nx_exit42" as *u8) as i64 104 layers[0] = 0; kats[0] = 42 105 106 ids[1] = ("nx_kat_add7" as *u8) as i64 107 srcs[1] = ("runtime/nx_kat_add7.nx" as *u8) as i64 108 scratches[1] = ("runtime/_germ_man_nx_kat_add7.nx" as *u8) as i64 109 bases[1] = ("_germ_man_nx_kat_add7" as *u8) as i64 110 layers[1] = 1; kats[1] = 7 111 112 // ---- PACK: FNV-1a each source, emit germination_manifest.tsv ---- 113 g_puts("\n [PACK] hash sources -> emit manifest\n" as *u8) 114 let mfd: i64 = sys_openat_wr(MAN_PATH, 0x1a4) 115 if mfd < 0 { g_puts(" FAIL: cannot write manifest\n" as *u8); sys_exit(10); return 10 } 116 g_puts_fd(mfd, "# germination_manifest.tsv -- AUTHORED by nx_spore_manifest_gate (PACK). cols: id <tab> source <tab> hash <tab> layer <tab> kat_expect\n" as *u8) 117 var i: i64 = 0 118 while i < N_PIECES { 119 let lenp: *i64 = sys_mmap(8) as *i64 120 let b: *u8 = sys_read_file((srcs[i]) as *u8, lenp) 121 let n: i64 = *lenp 122 if (b as i64) == 0 { g_puts(" FAIL: unreadable source\n" as *u8); sys_close(mfd); sys_exit(11); return 11 } 123 if n <= 0 { g_puts(" FAIL: empty source\n" as *u8); sys_close(mfd); sys_exit(11); return 11 } 124 hashes[i] = germ_hash(b, n) 125 g_man_row(mfd, (ids[i]) as *u8, (srcs[i]) as *u8, hashes[i], layers[i], kats[i]) 126 g_puts(" packed " as *u8); g_puts((ids[i]) as *u8); g_puts(" layer=" as *u8); g_putn(1, layers[i]); g_puts(" bytes=" as *u8); g_putn(1, n); g_puts("\n" as *u8) 127 i = i + 1 128 } 129 sys_close(mfd) 130 g_puts(" manifest -> " as *u8); g_puts(MAN_PATH); g_puts("\n" as *u8) 131 132 // ---- GERMINATE in layer order: integrity -> materialize -> rebuild -> KAT ---- 133 g_puts("\n [GERMINATE] layer-ordered\n" as *u8) 134 var admitted: i64 = 0 135 i = 0 136 while i < N_PIECES { 137 g_puts(" piece " as *u8); g_puts((ids[i]) as *u8); g_puts(" (layer " as *u8); g_putn(1, layers[i]); g_puts("): " as *u8) 138 let lenp: *i64 = sys_mmap(8) as *i64 139 let recv: *u8 = sys_read_file((srcs[i]) as *u8, lenp) 140 let n: i64 = *lenp 141 let rh: i64 = germ_hash(recv, n) 142 if rh != hashes[i] { 143 g_puts("INTEGRITY mismatch -> REJECT (never built)\n" as *u8) 144 } else { 145 let wfd: i64 = sys_openat_wr((scratches[i]) as *u8, 0x1a4) 146 if wfd < 0 { 147 g_puts("materialize FAIL\n" as *u8) 148 } else { 149 sys_write(wfd, recv, n) 150 sys_close(wfd) 151 let rc: i64 = g_rebuild_run((bases[i]) as *u8) 152 g_puts("germ_rc=" as *u8); g_putn(1, rc); g_puts(" (kat=" as *u8); g_putn(1, kats[i]); g_puts(") " as *u8) 153 if rc == kats[i] { admitted = admitted + 1; g_puts("ADMIT\n" as *u8) } else { g_puts("REJECT(kat)\n" as *u8) } 154 } 155 } 156 i = i + 1 157 } 158 159 // ---- NEGATIVE control: tamper piece 0's received bytes -> integrity reject ---- 160 g_puts("\n [NEG] tamper " as *u8); g_puts((ids[0]) as *u8); g_puts(": " as *u8) 161 var neg_reject: i64 = 0 162 let lp: *i64 = sys_mmap(8) as *i64 163 let ob: *u8 = sys_read_file((srcs[0]) as *u8, lp) 164 let on: i64 = *lp 165 let cor: *u8 = sys_mmap(on + 16) 166 var c: i64 = 0 167 while c < on { cor[c] = ob[c]; c = c + 1 } 168 cor[0] = (cor[0] ^ 1) as u8 169 if germ_hash(cor, on) != hashes[0] { neg_reject = 1; g_puts("hash MISMATCH -> REJECTED pre-build\n" as *u8) } else { g_puts("collision?! gate broken\n" as *u8) } 170 171 // ---- READ-BACK: the emitted manifest persisted with N data rows ---- 172 let rbp: *i64 = sys_mmap(8) as *i64 173 let mb: *u8 = sys_read_file(MAN_PATH, rbp) 174 let mn: i64 = *rbp 175 var nl: i64 = 0 176 var j: i64 = 0 177 while j < mn { if mb[j] == (10 as u8) { nl = nl + 1 } j = j + 1 } 178 let data_rows: i64 = nl - 1 // minus the # header line 179 g_puts("\n [READ-BACK] manifest data rows=" as *u8); g_putn(1, data_rows); g_puts(" (expect " as *u8); g_putn(1, N_PIECES); g_puts(")\n" as *u8) 180 181 // ---- VERDICT (sealed): GREEN iff exactly the known answer ---- 182 var green: i64 = 1 183 if admitted != N_PIECES { green = 0 } 184 if neg_reject != 1 { green = 0 } 185 if data_rows != N_PIECES { green = 0 } 186 187 let lfd: i64 = sys_openat_append("knowledge/status/spore_germ.log" as *u8, 0x1a4) 188 if lfd >= 0 { 189 g_puts_fd(lfd, "SPOREMANIFEST-GATE epoch=" as *u8); g_putn(lfd, sys_now_realtime_sec()) 190 g_puts_fd(lfd, " pieces=" as *u8); g_putn(lfd, N_PIECES) 191 g_puts_fd(lfd, " admitted=" as *u8); g_putn(lfd, admitted) 192 g_puts_fd(lfd, " neg_reject=" as *u8); g_putn(lfd, neg_reject) 193 g_puts_fd(lfd, " manifest_rows=" as *u8); g_putn(lfd, data_rows) 194 if green == 1 { g_puts_fd(lfd, " verdict=GREEN\n" as *u8) } else { g_puts_fd(lfd, " verdict=RED\n" as *u8) } 195 sys_close(lfd) 196 } 197 198 g_puts("----------------------------------------------------------------\n" as *u8) 199 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check 200 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled 201 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify. 202 let ctr__dry: *i64 = gv_ctr() 203 ctr__dry[0] = green 204 ctr__dry[1] = 1 205 let rc__dry: i64 = gv_verdict("SPORE-MANIFEST-GATE" as *u8, ctr__dry, "a layered multi-piece seed was emitted; every piece" as *u8) 206 sys_exit(rc__dry) 207 return rc__dry 208}