code wiki / _hdl_build / nx_germinate_test.nx
`nx_germinate_test.nx` source

↩ module page · 109 lines · 5152 B
1// nx_germinate_test.nx -- the SEED's per-piece GERMINATION trust layer. The seed
2// torrent-streams capability pieces onto the hardware; each piece must clear three
3// gates before it joins the growing system:
4//   1. INTEGRITY  -- the received bytes hash to the manifest hash (FNV-1a), exactly
5//                    like a torrent piece hash. A corrupted/tampered piece is
6//                    REJECTED HERE and NEVER RUN (you don't execute untrusted bytes).
7//   2. CORRECTNESS-- its proof gate passes 1:1 (the Engineer leg).
8//   3. GOVERNANCE -- the 3->2->1 crew clears it (verified + safe + recorded).
9// Only an integrity-clean, proven, governed piece is ADMITTED. This is the same
10// trust the research-ingestion uses, pointed at the streamed capability instead.
11//
12// Known answer: 3 received pieces -> 1 ADMITTED, 2 REJECTED (1 corrupted-hash,
13// 1 unproven). exit 0.
14
15import "nx_crew_council.nx"
16
17const GM_FNV_OFFSET: i64 = 0 - 3750763034362895579   // 0xcbf29ce484222325
18const GM_FNV_PRIME:  i64 = 1099511628211             // 0x100000001b3
19
20func gm_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
21
22// FNV-1a over len bytes -- the manifest/piece hash.
23func gm_hash(s: *u8, len: i64) -> i64 {
24    var h: i64 = GM_FNV_OFFSET
25    var i: i64 = 0
26    while i < len {
27        h = h ^ (s[i] as i64)
28        h = h * GM_FNV_PRIME
29        i = i + 1
30    }
31    return h
32}
33
34// simulate a corrupted transfer: copy src, flip one byte. (different hash -> caught)
35func gm_corrupt(src: *u8, len: i64) -> *u8 {
36    let buf: *u8 = sys_mmap(len + 1)
37    var i: i64 = 0
38    while i < len { buf[i] = src[i]; i = i + 1 }
39    buf[0] = (buf[0] ^ 1) as u8
40    return buf
41}
42
43// germinate ONE received piece. Returns: 0 ADMIT, 1 REJECT-integrity, 2 REJECT-gov.
44func gm_germinate(name: *u8, recv: *u8, len: i64, manifest_hash: i64, proof_ok: i64,
45                  a: *CrewAction, why: *i64) -> i64 {
46    cc_puts(" piece: " as *u8); cc_puts(name); cc_puts("\n" as *u8)
47    let hh: i64 = gm_hash(recv, len)
48    if hh != manifest_hash {
49        cc_puts("        INTEGRITY: hash MISMATCH -> REJECT (corrupt/tampered, never run)\n" as *u8)
50        return 1
51    }
52    cc_puts("        integrity: hash ok" as *u8)
53    cc_set(a, name, proof_ok, 1, 1, 1, 1)        // verifies = proof passes
54    let vd: i64 = cc_council(a, why)
55    if vd == CC_ACT {
56        cc_puts("  proof ok  council ACT -> ADMITTED\n" as *u8)
57        return 0
58    }
59    cc_puts("  -> REJECT (" as *u8); cc_puts(why[0] as *u8); cc_puts(")\n" as *u8)
60    return 2
61}
62
63func main() -> i64 {
64    let a: *CrewAction = sys_mmap(64) as *CrewAction
65    let why: *i64 = sys_mmap(8) as *i64
66
67    cc_puts("================================================================\n" as *u8)
68    cc_puts(" SEED GERMINATION -- a streamed capability piece must clear\n" as *u8)
69    cc_puts(" INTEGRITY (hash) + CORRECTNESS (proof) + GOVERNANCE to be admitted\n" as *u8)
70    cc_puts("================================================================\n" as *u8)
71
72    // canonical capability pieces (manifest = hash of the true bytes).
73    let c1: *u8 = "alu-28x28-gatenet-verified" as *u8
74    let c2: *u8 = "goldschmidt-64bit-divider" as *u8
75    let c3: *u8 = "speculative-optimizer-unproven" as *u8
76    let m1: i64 = gm_hash(c1, gm_slen(c1))
77    let m2: i64 = gm_hash(c2, gm_slen(c2))
78    let m3: i64 = gm_hash(c3, gm_slen(c3))
79
80    var admitted: i64 = 0
81    var rej_int: i64 = 0
82    var rej_gov: i64 = 0
83
84    // 1) received intact, proof passes -> ADMIT
85    let r1: i64 = gm_germinate(c1, c1, gm_slen(c1), m1, 1, a, why)
86    if r1 == 0 { admitted = admitted + 1 } else { if r1 == 1 { rej_int = rej_int + 1 } else { rej_gov = rej_gov + 1 } }
87
88    // 2) received CORRUPTED in transit -> INTEGRITY reject (never run)
89    let cor: *u8 = gm_corrupt(c2, gm_slen(c2))
90    let r2: i64 = gm_germinate(c2, cor, gm_slen(c2), m2, 1, a, why)
91    if r2 == 0 { admitted = admitted + 1 } else { if r2 == 1 { rej_int = rej_int + 1 } else { rej_gov = rej_gov + 1 } }
92
93    // 3) received intact but its proof FAILS -> governance reject (Engineer)
94    let r3: i64 = gm_germinate(c3, c3, gm_slen(c3), m3, 0, a, why)
95    if r3 == 0 { admitted = admitted + 1 } else { if r3 == 1 { rej_int = rej_int + 1 } else { rej_gov = rej_gov + 1 } }
96
97    cc_puts("----------------------------------------------------------------\n" as *u8)
98    cc_puts(" germinated: ADMITTED " as *u8); let ab: *u8 = sys_mmap(2); ab[0] = 48 + admitted; sys_write(1, ab, 1)
99    cc_puts(" | REJECT-corrupt " as *u8); let ri: *u8 = sys_mmap(2); ri[0] = 48 + rej_int; sys_write(1, ri, 1)
100    cc_puts(" | REJECT-unproven " as *u8); let rg: *u8 = sys_mmap(2); rg[0] = 48 + rej_gov; sys_write(1, rg, 1)
101    cc_puts("\n the seed grows only with pieces that arrive INTACT, PROVE out, and\n" as *u8)
102    cc_puts(" pass the crew -- corrupt bytes never run; unproven code never enters.\n" as *u8)
103    cc_puts("----------------------------------------------------------------\n" as *u8)
104
105    if admitted != 1 { sys_exit(1); return 1 }
106    if rej_int != 1  { sys_exit(2); return 2 }
107    if rej_gov != 1  { sys_exit(3); return 3 }
108    sys_exit(0); return 0
109}
nx_germinate_test.nx source

`nx_germinate_test.nx` source
