code wiki / _hdl_build / nx_gaterigor.nx
nx_gaterigor.nx source
↩ module page · 147 lines · 6460 B
1// nx_gaterigor.nx -- "DID WE BUILD JUNK" AUDITOR (operator 2026-07-21: "darpa level evaluation... so
2// itd pass nasa or darpa or any other sota org"). Applies the standards-body principle -- A TEST THAT
3// CANNOT FAIL PROVES NOTHING (DO-178C structural coverage / NASA IV&V / the liar-kill doctrine) -- to
4// OUR OWN verification layer. Scans *_gate.nx files and grades each: RIGOROUS if it shows evidence of a
5// NEGATIVE CONTROL or MUTATION proof (a tooth that expects FAILURE), else VACUOUS = junk confidence
6// (a green means nothing if the gate can't go red). Static heuristic (marker scan); the strong form
7// dynamically mutates + re-runs (filed rung). Rolls up a fleet RIGOR gauge.
8// argv: <dir> [dir2...]
9// Report: VACUOUS <gatefile> (each gate with NO neg-control evidence), then
10// NX-GATERIGOR gates=G rigorous=R vacuous=V rigor_permil=<g>
11// exit 0 = ran. Deterministic. license_tier: ORIGINAL No hw writes (Rule 26).
12import "nx_seat_drive_lib.nx"
13import "nx_deploy_lib.nx"
14import "nx_syscalls.nx"
15const GR_MAGIC_262144: i64 = 262144
16const GR_MAGIC_1024: i64 = 1024
17
18const GR_FILECAP: i64 = 2097152
19
20func gr_ends_gate(nm: *u8) -> i64 {
21 var n: i64 = 0
22 while nm[n] != (0 as u8) { n = n + 1 }
23 // "_gate.nx" = 8 chars
24 if n < 8 { return 0 }
25 let s: i64 = n - 8
26 if nm[s] != (95 as u8) { return 0 } // _
27 if nm[s+1] != (103 as u8) { return 0 } // g
28 if nm[s+2] != (97 as u8) { return 0 } // a
29 if nm[s+3] != (116 as u8) { return 0 } // t
30 if nm[s+4] != (101 as u8) { return 0 } // e
31 if nm[s+5] != (46 as u8) { return 0 } // .
32 if nm[s+6] != (110 as u8) { return 0 } // n
33 if nm[s+7] != (120 as u8) { return 0 } // x
34 return 1
35}
36// substring present in buf[0..n)?
37func gr_has(buf: *u8, n: i64, lit: *u8) -> i64 {
38 var ll: i64 = 0
39 while lit[ll] != (0 as u8) { ll = ll + 1 }
40 var p: i64 = 0
41 while p + ll <= n {
42 var k: i64 = 0
43 var hit: i64 = 1
44 while k < ll { if buf[p+k] != lit[k] { hit = 0; k = ll } else { k = k + 1 } }
45 if hit == 1 { return 1 }
46 p = p + 1
47 }
48 return 0
49}
50// a gate is RIGOROUS if it shows ANY negative-control / mutation evidence.
51// ⚠MARKER SET WIDENED 2026-07-21 after an IV&V precision check found v1 over-flagged 61% (crypto KATs
52// use tamper/wrong-key, not the word "neg") -- the DARPA "validate the validator against ground truth"
53// discipline applied to this auditor itself. EXCLUDED: bare "RED" (every gate prints its own verdict=RED
54// on failure) + "bad" (substring of "load") -- both would false-NEGATIVE (call vacuous gates rigorous).
55func gr_rigorous(buf: *u8, n: i64) -> i64 {
56 if gr_has(buf, n, "neg" as *u8) == 1 { return 1 }
57 if gr_has(buf, n, "mutation" as *u8) == 1 { return 1 }
58 if gr_has(buf, n, "MUTATION" as *u8) == 1 { return 1 }
59 if gr_has(buf, n, "REFUSED" as *u8) == 1 { return 1 }
60 if gr_has(buf, n, "negative" as *u8) == 1 { return 1 }
61 if gr_has(buf, n, "tamper" as *u8) == 1 { return 1 }
62 if gr_has(buf, n, "corrupt" as *u8) == 1 { return 1 }
63 if gr_has(buf, n, "forge" as *u8) == 1 { return 1 }
64 if gr_has(buf, n, "liar" as *u8) == 1 { return 1 }
65 if gr_has(buf, n, "fabricat" as *u8) == 1 { return 1 }
66 if gr_has(buf, n, "reject" as *u8) == 1 { return 1 }
67 if gr_has(buf, n, "invalid" as *u8) == 1 { return 1 }
68 if gr_has(buf, n, "wrong" as *u8) == 1 { return 1 }
69 return 0
70}
71
72func main(argc: i64, argv: *i64) -> i64 {
73 if argc < 2 { sd_w("usage: nx_gaterigor <dir> [dir2...]\n" as *u8); sys_exit(2); return 2 }
74 let src: *u8 = sys_mmap(GR_FILECAP)
75 let dbuf: *u8 = sys_mmap(GR_MAGIC_262144)
76 var gates: i64 = 0
77 var rigorous: i64 = 0
78 var vacuous: i64 = 0
79
80 var d: i64 = 1
81 while d < argc {
82 let dir: *u8 = argv[d] as *u8
83 let dfd: i64 = sys_openat_rd(dir)
84 if dfd >= 0 {
85 var go: i64 = 1
86 while go == 1 {
87 let dn: i64 = sys_getdents64(dfd, dbuf, GR_MAGIC_262144)
88 if dn <= 0 { go = 0 } else {
89 var off: i64 = 0
90 while off < dn {
91 let rec: *u8 = ((dbuf as i64) + off) as *u8
92 let ty: i64 = dirent_type(rec)
93 let nm: *u8 = dirent_name(rec)
94 if ty != 4 { if gr_ends_gate(nm) == 1 {
95 let p: *u8 = sys_mmap(GR_MAGIC_1024)
96 var po: i64 = 0
97 var di: i64 = 0
98 while dir[di] != (0 as u8) { p[po] = dir[di]; po = po + 1; di = di + 1 }
99 p[po] = 47 as u8; po = po + 1
100 var mi: i64 = 0
101 while nm[mi] != (0 as u8) { p[po] = nm[mi]; po = po + 1; mi = mi + 1 }
102 p[po] = 0 as u8
103 let fd: i64 = sys_openat_rd(p)
104 if fd >= 0 {
105 var slen: i64 = 0
106 var r: i64 = sys_read(fd, src, GR_FILECAP - 1)
107 while r > 0 { slen = slen + r; if slen >= GR_FILECAP - 1 { r = 0 } else { r = sys_read(fd, src + slen, GR_FILECAP - 1 - slen) } }
108 sys_close(fd)
109 if slen > 0 {
110 gates = gates + 1
111 if gr_rigorous(src, slen) == 1 { rigorous = rigorous + 1 } else {
112 vacuous = vacuous + 1
113 sd_w("VACUOUS " as *u8)
114 sd_w(p)
115 sd_w("\n" as *u8)
116 }
117 }
118 }
119 } }
120 off = off + dirent_reclen(rec)
121 }
122 }
123 }
124 sys_close(dfd)
125 }
126 d = d + 1
127 }
128
129 var health: i64 = 0
130 if gates > 0 { health = rigorous * 1000 / gates }
131 sd_w("NX-GATERIGOR gates=" as *u8)
132 let ob: *u8 = sys_mmap(64)
133 sd_num(ob, 0, gates)
134 sd_w(ob)
135 sd_w(" rigorous=" as *u8)
136 sd_num(ob, 0, rigorous)
137 sd_w(ob)
138 sd_w(" vacuous=" as *u8)
139 sd_num(ob, 0, vacuous)
140 sd_w(ob)
141 sd_w(" rigor_permil=" as *u8)
142 sd_num(ob, 0, health)
143 sd_w(ob)
144 sd_w("\n" as *u8)
145 sys_exit(0)
146 return 0
147}