_idea_genealogy_gate.nx source
↩ module page · 182 lines · 7822 B
1// _idea_genealogy_gate.nx -- the no-mocks tamper gate for nx_idea_genealogist.
2//
3// AUTHOR=ORGAN, NO MOCKS: this gate FORKS + EXECVEs the REAL built elf
4// (/tmp/nx_idea_genealogist.sov.elf) over a /tmp SCRATCH WORLD (epoch-unique
5// filenames -> immune to the openat_wr no-TRUNC stale-tail landmine), passing
6// scratch spec/out/log via the organ's argv path-override while pointing the
7// BRIDGE at the REAL lineage.tsv + math_genealogy.tsv. The real registry is
8// NEVER touched. It asserts the organ's contract end-to-end:
9// C0 GOOD (2 valid rows, bridge resolves) -> exit 0 (GREEN) + 2 rows emitted
10// C1 SOURCED-empty (source_status=SOURCED, empty source) -> exit 1 (RED, liar-kill)
11// C2 broken-chain (descends_from points at a ghost idea) -> exit 1 (RED)
12// C3 bad-credit (credit_class not a declared posture) -> exit 1 (RED)
13// C4 idempotent (rerun C0 over the populated scratch out) -> exit 0 + STILL 2 rows (emitted=0)
14// TAMPER-PROOF: the gate is GREEN only if every tamper world is RED AND the good
15// world is GREEN -- a toothless organ that accepted a lie would flip the gate RED.
16// Sovereign syscalls only.
17//
18// module: nishi-core.genealogy.idea_genealogy_gate
19// depends: nishi-core.genealogy.idea_genealogist
20// capability: GATE
21// license_tier: ORIGINAL
22import "nx_syscalls.nx"
23
24const ELF: *u8 = "/tmp/nx_idea_genealogist.sov.elf"
25const LIN: *u8 = "knowledge/registry/lineage.tsv"
26const MATHG: *u8 = "knowledge/registry/math_genealogy.tsv"
27const GATELOG: *u8 = "knowledge/status/idea_genealogy_gate.log"
28
29func gg_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
30func gg_wn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48 as u8;k=1}; while m>0 {t[k]=(48+(m%10)) as u8; m=m/10; k=k+1}; var i: i64=0; while i<k {bb[i]=t[k-1-i]; i=i+1}; sys_write(fd, bb, k); return 0 }
31
32func gg_catstr(buf: *u8, pos: i64, s: *u8) -> i64 {
33 var i: i64 = 0
34 while s[i] != (0 as u8) { buf[pos + i] = s[i]; i = i + 1 }
35 return pos + i
36}
37func gg_catnum(buf: *u8, pos: i64, v: i64) -> i64 {
38 var m: i64 = v
39 if m < 0 { m = 0 - m }
40 let t: *u8 = sys_mmap(28)
41 var k: i64 = 0
42 if m == 0 { t[0] = 48 as u8; k = 1 }
43 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
44 var i: i64 = 0
45 while i < k { buf[pos + i] = t[k - 1 - i]; i = i + 1 }
46 return pos + k
47}
48func gg_mkpath(buf: *u8, epoch: i64, tag: *u8) -> i64 {
49 var p: i64 = 0
50 p = gg_catstr(buf, p, "/tmp/_iggate_" as *u8)
51 p = gg_catnum(buf, p, epoch)
52 p = gg_catstr(buf, p, "_" as *u8)
53 p = gg_catstr(buf, p, tag)
54 buf[p] = 0 as u8
55 return p
56}
57func gg_writefile(path: *u8, content: *u8) -> i64 {
58 let fd: i64 = sys_openat_wr(path, 420)
59 if fd < 0 { return -1 }
60 var n: i64 = 0
61 while content[n] != (0 as u8) { n = n + 1 }
62 sys_write(fd, content, n)
63 sys_close(fd)
64 return 0
65}
66// count non-comment, non-empty lines of a file (the emitted data rows).
67func gg_count_rows(path: *u8) -> i64 {
68 let buf: *u8 = sys_mmap(65536)
69 let fd: i64 = sys_openat_rd(path)
70 if fd < 0 { return 0 }
71 var n: i64 = 0
72 var r: i64 = sys_read(fd, buf, 65535)
73 while r > 0 { n = n + r; r = sys_read(fd, buf + n, 65535 - n) }
74 sys_close(fd)
75 var cnt: i64 = 0
76 var i: i64 = 0
77 while i < n {
78 if buf[i] == (35 as u8) { } else { if buf[i] != (10 as u8) { cnt = cnt + 1 } }
79 var le: i64 = i
80 var s: i64 = 1
81 while s == 1 { if le >= n { s = 0 } else { if buf[le] == (10 as u8) { s = 0 } else { le = le + 1 } } }
82 i = le + 1
83 }
84 return cnt
85}
86// fork + execve the REAL elf with argv [elf, spec, out, log, lin, mathg]; return child exit code.
87func gg_run(elf: *u8, spec: *u8, out: *u8, log: *u8, lin: *u8, mathg: *u8) -> i64 {
88 let pid: i64 = sys_fork()
89 if pid == 0 {
90 let dn: i64 = sys_openat_wr("/dev/null" as *u8, 420)
91 if dn >= 0 { sys_dup3(dn, 1, 0); sys_dup3(dn, 2, 0) }
92 let argv: *i64 = sys_mmap(64) as *i64
93 argv[0] = elf as i64
94 argv[1] = spec as i64
95 argv[2] = out as i64
96 argv[3] = log as i64
97 argv[4] = lin as i64
98 argv[5] = mathg as i64
99 argv[6] = 0
100 let envp: *i64 = sys_mmap(16) as *i64
101 envp[0] = 0
102 sys_execve(elf, argv, envp)
103 sys_exit(127)
104 return 127
105 }
106 let st: *i64 = sys_mmap(8) as *i64
107 st[0] = 0
108 sys_wait4(pid, st, 0)
109 let hi: i64 = st[0] / 256
110 return hi - (hi / 256) * 256
111}
112
113func gg_report(fd: i64, r0: i64, rows0: i64, r1: i64, r2: i64, r3: i64, r4: i64, rows1: i64, epoch: i64, ok: i64) -> i64 {
114 gg_w(fd, "IDEAGATE drive=real-elf no-mocks good_exit=" as *u8); gg_wn(fd, r0)
115 gg_w(fd, " good_rows=" as *u8); gg_wn(fd, rows0)
116 gg_w(fd, " tamper_sourced_empty=" as *u8); gg_wn(fd, r1)
117 gg_w(fd, " tamper_broken_chain=" as *u8); gg_wn(fd, r2)
118 gg_w(fd, " tamper_bad_credit=" as *u8); gg_wn(fd, r3)
119 gg_w(fd, " idem_exit=" as *u8); gg_wn(fd, r4)
120 gg_w(fd, " idem_rows=" as *u8); gg_wn(fd, rows1)
121 gg_w(fd, " epoch=" as *u8); gg_wn(fd, epoch)
122 if ok == 1 { gg_w(fd, " verdict=GREEN\n" as *u8) } else { gg_w(fd, " verdict=RED\n" as *u8) }
123 return 0
124}
125
126func main() -> i64 {
127 let epoch: i64 = sys_now_realtime_sec()
128
129 let c0s: *u8 = sys_mmap(128)
130 let c0o: *u8 = sys_mmap(128)
131 let c0l: *u8 = sys_mmap(128)
132 let c1s: *u8 = sys_mmap(128)
133 let c1o: *u8 = sys_mmap(128)
134 let c1l: *u8 = sys_mmap(128)
135 let c2s: *u8 = sys_mmap(128)
136 let c2o: *u8 = sys_mmap(128)
137 let c2l: *u8 = sys_mmap(128)
138 let c3s: *u8 = sys_mmap(128)
139 let c3o: *u8 = sys_mmap(128)
140 let c3l: *u8 = sys_mmap(128)
141 gg_mkpath(c0s, epoch, "c0_spec" as *u8)
142 gg_mkpath(c0o, epoch, "c0_out" as *u8)
143 gg_mkpath(c0l, epoch, "c0_log" as *u8)
144 gg_mkpath(c1s, epoch, "c1_spec" as *u8)
145 gg_mkpath(c1o, epoch, "c1_out" as *u8)
146 gg_mkpath(c1l, epoch, "c1_log" as *u8)
147 gg_mkpath(c2s, epoch, "c2_spec" as *u8)
148 gg_mkpath(c2o, epoch, "c2_out" as *u8)
149 gg_mkpath(c2l, epoch, "c2_log" as *u8)
150 gg_mkpath(c3s, epoch, "c3_spec" as *u8)
151 gg_mkpath(c3o, epoch, "c3_out" as *u8)
152 gg_mkpath(c3l, epoch, "c3_log" as *u8)
153
154 gg_writefile(c0s, "g0|insight zero|Tester|Nowhere|2000|because zero|how zero|-|nx_f64|cite-zero|RECORD-HINT|pd_classical\ng1|insight one|Tester|Nowhere|2001|because one|how one|g0|nx_bigfloat120|cite-one|RECORD-HINT|credit-only\n" as *u8)
155 gg_writefile(c1s, "t1|sourced no source|Tester|Nowhere|2002|because|how|-|nx_f64||SOURCED|pd_classical\n" as *u8)
156 gg_writefile(c2s, "t2|broken chain|Tester|Nowhere|2003|because|how|ghost_parent|nx_f64|cite|RECORD-HINT|pd_classical\n" as *u8)
157 gg_writefile(c3s, "t3|bad credit class|Tester|Nowhere|2004|because|how|-|nx_f64|cite|RECORD-HINT|not_a_class\n" as *u8)
158
159 let r0: i64 = gg_run(ELF, c0s, c0o, c0l, LIN, MATHG)
160 let rows0: i64 = gg_count_rows(c0o)
161 let r1: i64 = gg_run(ELF, c1s, c1o, c1l, LIN, MATHG)
162 let r2: i64 = gg_run(ELF, c2s, c2o, c2l, LIN, MATHG)
163 let r3: i64 = gg_run(ELF, c3s, c3o, c3l, LIN, MATHG)
164 let r4: i64 = gg_run(ELF, c0s, c0o, c0l, LIN, MATHG)
165 let rows1: i64 = gg_count_rows(c0o)
166
167 var ok: i64 = 1
168 if r0 != 0 { ok = 0 }
169 if rows0 != 2 { ok = 0 }
170 if r1 != 1 { ok = 0 }
171 if r2 != 1 { ok = 0 }
172 if r3 != 1 { ok = 0 }
173 if r4 != 0 { ok = 0 }
174 if rows1 != 2 { ok = 0 }
175
176 gg_report(1, r0, rows0, r1, r2, r3, r4, rows1, epoch, ok)
177 let glog: i64 = sys_openat_append(GATELOG, 420)
178 if glog >= 0 { gg_report(glog, r0, rows0, r1, r2, r3, r4, rows1, epoch, ok); sys_close(glog) }
179
180 if ok == 1 { sys_exit(0); return 0 }
181 sys_exit(1); return 1
182}