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" 21 22const GERM_FNV_OFFSET: i64 = 0 - 3750763034362895579 // 0xcbf29ce484222325 23const GERM_FNV_PRIME: i64 = 1099511628211 // 0x100000001b3 24const MAN_PATH: *u8 = "knowledge/registry/germination_manifest.tsv" 25const N_PIECES: i64 = 2 26 27func germ_hash(buf: *u8, len: i64) -> i64 { 28 var h: i64 = GERM_FNV_OFFSET 29 var i: i64 = 0 30 while i < len { h = h ^ (buf[i] as i64); h = h * GERM_FNV_PRIME; i = i + 1 } 31 return h 32} 33func g_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n } 34func g_puts(s: *u8) -> i64 { sys_write(1, s, g_slen(s)); return 0 } 35func g_puts_fd(fd: i64, s: *u8) -> i64 { sys_write(fd, s, g_slen(s)); return 0 } 36func g_tab(fd: i64) -> i64 { let t: *u8 = sys_mmap(8); t[0] = 9; sys_write(fd, t, 1); return 0 } 37func g_putn(fd: i64, v: i64) -> i64 { 38 let bb: *u8 = sys_mmap(28) 39 var m: i64 = v 40 if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) } 41 let t: *u8 = sys_mmap(28) 42 var k: i64 = 0 43 if m == 0 { t[0] = 48; k = 1 } 44 while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 } 45 var i: i64 = 0 46 while i < k { bb[i] = t[k - 1 - i]; i = i + 1 } 47 sys_write(fd, bb, k) 48 return 0 49} 50// fork + optional redirect + execve; parent waits; 128+sig on signal-death (no fake success). 51func g_run(path: *u8, argv: *i64, redir_out: i64, redir_err: i64) -> i64 { 52 let pid: i64 = sys_fork() 53 if pid == 0 { 54 if redir_out >= 0 { sys_dup3(redir_out, 1, 0) } 55 if redir_err >= 0 { sys_dup3(redir_err, 2, 0) } 56 sys_execve(path, argv, 0 as *i64) 57 sys_exit(127) 58 } 59 let st: *i64 = sys_mmap(16) as *i64 60 sys_wait4(pid, st, 0) 61 let sig: i64 = st[0] & 0x7f 62 if sig != 0 { return 128 + sig } 63 return (st[0] >> 8) & 0xff 64} 65// rebuild+run a materialized piece by basename via the sovereign lane; returns its run-exit. 66func g_rebuild_run(basename: *u8) -> i64 { 67 let builder: *u8 = "_offc/nx_sov_build_run.elf" as *u8 68 let a: *i64 = sys_mmap(32) as *i64 69 a[0] = builder as i64 70 a[1] = basename as i64 71 a[2] = 0 72 return g_run(builder, a, 0 - 1, 0 - 1) 73} 74// one manifest row: id \t source \t hash \t layer \t kat \n 75func g_man_row(fd: i64, id: *u8, src: *u8, hash: i64, layer: i64, kat: i64) -> i64 { 76 g_puts_fd(fd, id); g_tab(fd) 77 g_puts_fd(fd, src); g_tab(fd) 78 g_putn(fd, hash); g_tab(fd) 79 g_putn(fd, layer); g_tab(fd) 80 g_putn(fd, kat); sys_write(fd, "\n" as *u8, 1) 81 return 0 82} 83 84func main() -> i64 { 85 g_puts("================================================================\n" as *u8) 86 g_puts(" GERMINATION MANIFEST -- layered multi-piece seed: pack -> emit ->\n" as *u8) 87 g_puts(" germinate each (hash+rebuild+KAT) in layer order; tamper rejected.\n" as *u8) 88 g_puts("================================================================\n" as *u8) 89 90 // ---- inline piece table (the seed's pieces; layer = hardware-up order, pre-sorted) ---- 91 let ids: *i64 = sys_mmap(8 * N_PIECES) as *i64 92 let srcs: *i64 = sys_mmap(8 * N_PIECES) as *i64 93 let scratches: *i64 = sys_mmap(8 * N_PIECES) as *i64 94 let bases: *i64 = sys_mmap(8 * N_PIECES) as *i64 95 let layers: *i64 = sys_mmap(8 * N_PIECES) as *i64 96 let kats: *i64 = sys_mmap(8 * N_PIECES) as *i64 97 let hashes: *i64 = sys_mmap(8 * N_PIECES) as *i64 98 99 ids[0] = ("nx_exit42" as *u8) as i64 100 srcs[0] = ("runtime/nx_exit42.nx" as *u8) as i64 101 scratches[0] = ("runtime/_germ_man_nx_exit42.nx" as *u8) as i64 102 bases[0] = ("_germ_man_nx_exit42" as *u8) as i64 103 layers[0] = 0; kats[0] = 42 104 105 ids[1] = ("nx_kat_add7" as *u8) as i64 106 srcs[1] = ("runtime/nx_kat_add7.nx" as *u8) as i64 107 scratches[1] = ("runtime/_germ_man_nx_kat_add7.nx" as *u8) as i64 108 bases[1] = ("_germ_man_nx_kat_add7" as *u8) as i64 109 layers[1] = 1; kats[1] = 7 110 111 // ---- PACK: FNV-1a each source, emit germination_manifest.tsv ---- 112 g_puts("\n [PACK] hash sources -> emit manifest\n" as *u8) 113 let mfd: i64 = sys_openat_wr(MAN_PATH, 0x1a4) 114 if mfd < 0 { g_puts(" FAIL: cannot write manifest\n" as *u8); sys_exit(10); return 10 } 115 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) 116 var i: i64 = 0 117 while i < N_PIECES { 118 let lenp: *i64 = sys_mmap(8) as *i64 119 let b: *u8 = sys_read_file((srcs[i]) as *u8, lenp) 120 let n: i64 = *lenp 121 if (b as i64) == 0 { g_puts(" FAIL: unreadable source\n" as *u8); sys_close(mfd); sys_exit(11); return 11 } 122 if n <= 0 { g_puts(" FAIL: empty source\n" as *u8); sys_close(mfd); sys_exit(11); return 11 } 123 hashes[i] = germ_hash(b, n) 124 g_man_row(mfd, (ids[i]) as *u8, (srcs[i]) as *u8, hashes[i], layers[i], kats[i]) 125 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) 126 i = i + 1 127 } 128 sys_close(mfd) 129 g_puts(" manifest -> " as *u8); g_puts(MAN_PATH); g_puts("\n" as *u8) 130 131 // ---- GERMINATE in layer order: integrity -> materialize -> rebuild -> KAT ---- 132 g_puts("\n [GERMINATE] layer-ordered\n" as *u8) 133 var admitted: i64 = 0 134 i = 0 135 while i < N_PIECES { 136 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) 137 let lenp: *i64 = sys_mmap(8) as *i64 138 let recv: *u8 = sys_read_file((srcs[i]) as *u8, lenp) 139 let n: i64 = *lenp 140 let rh: i64 = germ_hash(recv, n) 141 if rh != hashes[i] { 142 g_puts("INTEGRITY mismatch -> REJECT (never built)\n" as *u8) 143 } else { 144 let wfd: i64 = sys_openat_wr((scratches[i]) as *u8, 0x1a4) 145 if wfd < 0 { 146 g_puts("materialize FAIL\n" as *u8) 147 } else { 148 sys_write(wfd, recv, n) 149 sys_close(wfd) 150 let rc: i64 = g_rebuild_run((bases[i]) as *u8) 151 g_puts("germ_rc=" as *u8); g_putn(1, rc); g_puts(" (kat=" as *u8); g_putn(1, kats[i]); g_puts(") " as *u8) 152 if rc == kats[i] { admitted = admitted + 1; g_puts("ADMIT\n" as *u8) } else { g_puts("REJECT(kat)\n" as *u8) } 153 } 154 } 155 i = i + 1 156 } 157 158 // ---- NEGATIVE control: tamper piece 0's received bytes -> integrity reject ---- 159 g_puts("\n [NEG] tamper " as *u8); g_puts((ids[0]) as *u8); g_puts(": " as *u8) 160 var neg_reject: i64 = 0 161 let lp: *i64 = sys_mmap(8) as *i64 162 let ob: *u8 = sys_read_file((srcs[0]) as *u8, lp) 163 let on: i64 = *lp 164 let cor: *u8 = sys_mmap(on + 16) 165 var c: i64 = 0 166 while c < on { cor[c] = ob[c]; c = c + 1 } 167 cor[0] = (cor[0] ^ 1) as u8 168 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) } 169 170 // ---- READ-BACK: the emitted manifest persisted with N data rows ---- 171 let rbp: *i64 = sys_mmap(8) as *i64 172 let mb: *u8 = sys_read_file(MAN_PATH, rbp) 173 let mn: i64 = *rbp 174 var nl: i64 = 0 175 var j: i64 = 0 176 while j < mn { if mb[j] == (10 as u8) { nl = nl + 1 } j = j + 1 } 177 let data_rows: i64 = nl - 1 // minus the # header line 178 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) 179 180 // ---- VERDICT (sealed): GREEN iff exactly the known answer ---- 181 var green: i64 = 1 182 if admitted != N_PIECES { green = 0 } 183 if neg_reject != 1 { green = 0 } 184 if data_rows != N_PIECES { green = 0 } 185 186 let lfd: i64 = sys_openat_append("knowledge/status/spore_germ.log" as *u8, 0x1a4) 187 if lfd >= 0 { 188 g_puts_fd(lfd, "SPOREMANIFEST-GATE epoch=" as *u8); g_putn(lfd, sys_now_realtime_sec()) 189 g_puts_fd(lfd, " pieces=" as *u8); g_putn(lfd, N_PIECES) 190 g_puts_fd(lfd, " admitted=" as *u8); g_putn(lfd, admitted) 191 g_puts_fd(lfd, " neg_reject=" as *u8); g_putn(lfd, neg_reject) 192 g_puts_fd(lfd, " manifest_rows=" as *u8); g_putn(lfd, data_rows) 193 if green == 1 { g_puts_fd(lfd, " verdict=GREEN\n" as *u8) } else { g_puts_fd(lfd, " verdict=RED\n" as *u8) } 194 sys_close(lfd) 195 } 196 197 g_puts("----------------------------------------------------------------\n" as *u8) 198 if green == 1 { 199 g_puts(" verdict=GREEN -- a layered multi-piece seed was emitted; every piece\n" as *u8) 200 g_puts(" germinated + KAT-proved in layer order; the tampered piece was rejected.\n" as *u8) 201 sys_exit(0); return 0 202 } 203 g_puts(" verdict=RED -- see fields above\n" as *u8) 204 sys_exit(1); return 1 205}