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

↩ module page · 336 lines · 17048 B
1import "nx_gate_base.nx"
2// nx_cbx_pages_gate.nx -- HANDOFF-CHAIN GATE for the CBX format-fix (natural sort + per-page magic gate
3// + rar4/rar5 STORE + container sniffing). NO-FAKE-GREEN: the gate CRAFTS byte-exact fixture archives
4// (zip with out-of-order page names + __MACOSX AppleDouble junk + a text file wearing .jpg; rar4 STORE;
5// rar5 STORE; a ZIP renamed .cbr), EXECS the real built extractor (/tmp/nx_cbx_pages.sov.elf), then
6// asserts page ORDER BY CONTENT (page000 bytes must be PAGEONE, ...) and honest skip behavior.
7// Stale outputs are UNLINKED before each exec so a leftover cbx.json can never fake a green.
8// license_tier: ORIGINAL
9import "nx_syscalls.nx"
10
11func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw("  PASS " as *u8) } else { gw("  FAIL " as *u8) } gw(name); gw("
12" as *u8); return ok }
13func g_w(fd: i64, s: *u8) -> i64 { sys_write(fd, s, g_slen(s)); return 0 }
14func g_n(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 }
15func g_p(s: *u8) -> i64 { g_w(1, s); return 0 }
16func g_pn(v: i64) -> i64 { g_n(1, v); return 0 }
17func g_cat(dst: *u8, off: i64, s: *u8) -> i64 { var i: i64=0; while s[i]!=(0 as u8){dst[off+i]=s[i];i=i+1} return off+i }
18
19func find_sub(hay: *u8, hl: i64, needle: *u8) -> i64 {
  let nl: i64 = g_slen(needle)
  if nl == 0 { return 0-1 }
  var i: i64 = 0
  while i + nl <= hl {
      var k: i64 = 0
      var hit: i64 = 1
      while k < nl { if hay[i+k] != needle[k] { hit = 0; k = nl } else { k = k + 1 } }
      if hit == 1 { return i }
      i = i + 1
  }
  return 0-1
31}
32
33func wle16(b: *u8, o: i64, v: i64) -> i64 { b[o] = (v & 255) as u8; b[o+1] = ((v >> 8) & 255) as u8; return o + 2 }
34func wle32(b: *u8, o: i64, v: i64) -> i64 { b[o] = (v & 255) as u8; b[o+1] = ((v >> 8) & 255) as u8; b[o+2] = ((v >> 16) & 255) as u8; b[o+3] = ((v >> 24) & 255) as u8; return o + 4 }
35func wraw(b: *u8, o: i64, s: *u8, n: i64) -> i64 { var i: i64=0; while i<n { b[o+i]=s[i]; i=i+1 } return o+n }
36
37// unlinkat(AT_FDCWD, p, 0) -- stale-output scrub (idempotent; ENOENT harmless)
38func rmf(p: *u8) -> i64 { __syscall(263, 0-100, p, 0, 0, 0, 0); return 0 }
39
40// ---- zip fixture emitters (stored, crc=0 -- the extractor never checks crc) ----
41// local file header + data; returns new offset
42func zlfh(b: *u8, o: i64, nm: *u8, d: *u8, dn: i64) -> i64 {
  let nl: i64 = g_slen(nm)
  var p: i64 = o
  b[p]=0x50 as u8; b[p+1]=0x4b as u8; b[p+2]=0x03 as u8; b[p+3]=0x04 as u8; p=p+4
  p = wle16(b,p,20); p = wle16(b,p,0); p = wle16(b,p,0)      // ver, flags, method=0
  p = wle16(b,p,0); p = wle16(b,p,0); p = wle32(b,p,0)       // time, date, crc
  p = wle32(b,p,dn); p = wle32(b,p,dn)                       // csize, usize
  p = wle16(b,p,nl); p = wle16(b,p,0)                        // fnlen, extralen
  p = wraw(b,p,nm,nl)
  p = wraw(b,p,d,dn)
  return p
53}
54// central-dir entry; returns new offset
55func zcde(b: *u8, o: i64, nm: *u8, dn: i64, lho: i64) -> i64 {
  let nl: i64 = g_slen(nm)
  var p: i64 = o
  b[p]=0x50 as u8; b[p+1]=0x4b as u8; b[p+2]=0x01 as u8; b[p+3]=0x02 as u8; p=p+4
  p = wle16(b,p,20); p = wle16(b,p,20); p = wle16(b,p,0); p = wle16(b,p,0)   // vermade, verneed, flags, method
  p = wle16(b,p,0); p = wle16(b,p,0); p = wle32(b,p,0)                       // time, date, crc
  p = wle32(b,p,dn); p = wle32(b,p,dn)                                       // csize, usize
  p = wle16(b,p,nl); p = wle16(b,p,0); p = wle16(b,p,0)                      // fnlen, extra, comment
  p = wle16(b,p,0); p = wle16(b,p,0); p = wle32(b,p,0)                       // disk, iattr, eattr
  p = wle32(b,p,lho)
  p = wraw(b,p,nm,nl)
  return p
67}
68func zeocd(b: *u8, o: i64, nent: i64, cdoff: i64, cdsize: i64) -> i64 {
  var p: i64 = o
  b[p]=0x50 as u8; b[p+1]=0x4b as u8; b[p+2]=0x05 as u8; b[p+3]=0x06 as u8; p=p+4
  p = wle16(b,p,0); p = wle16(b,p,0); p = wle16(b,p,nent); p = wle16(b,p,nent)
  p = wle32(b,p,cdsize); p = wle32(b,p,cdoff); p = wle16(b,p,0)
  return p
74}
75
76// ---- rar4 STORE fixture: marker + per-file block (method 0x30) ----
77func r4file(b: *u8, o: i64, nm: *u8, d: *u8, dn: i64) -> i64 {
  let nl: i64 = g_slen(nm)
  var p: i64 = o
  p = wle16(b,p,0)                       // head_crc (unchecked)
  b[p] = 0x74 as u8; p = p + 1           // type = file
  p = wle16(b,p,0)                       // flags = 0 (not dir, not enc, not large)
  p = wle16(b,p,32+nl)                   // hsize
  p = wle32(b,p,dn); p = wle32(b,p,dn)   // pack, unp
  b[p] = 0 as u8; p = p + 1              // host_os
  p = wle32(b,p,0); p = wle32(b,p,0)     // file_crc, ftime
  b[p] = 20 as u8; p = p + 1             // unp_ver
  b[p] = 0x30 as u8; p = p + 1           // method = stored
  p = wle16(b,p,nl)                      // namesize
  p = wle32(b,p,0)                       // attr
  p = wraw(b,p,nm,nl)
  p = wraw(b,p,d,dn)
  return p
94}
95
96// ---- rar5 STORE fixture: marker + per-file block (all vints single-byte: values < 128) ----
97func r5file(b: *u8, o: i64, nm: *u8, d: *u8, dn: i64) -> i64 {
  let nl: i64 = g_slen(nm)
  var p: i64 = o
  p = wle32(b,p,0)                       // header crc (unchecked)
  b[p] = (9+nl) as u8; p = p + 1         // vint hsize = type..name inclusive
  b[p] = 2 as u8; p = p + 1              // vint type = file
  b[p] = 2 as u8; p = p + 1              // vint flags = data area present
  b[p] = dn as u8; p = p + 1             // vint data_size (dn < 128)
  b[p] = 0 as u8; p = p + 1              // vint file_flags
  b[p] = dn as u8; p = p + 1             // vint unpacked
  b[p] = 0 as u8; p = p + 1              // vint attr
  b[p] = 0 as u8; p = p + 1              // vint cinfo (method bits 7..9 = 0 = store)
  b[p] = 1 as u8; p = p + 1              // vint host_os
  b[p] = nl as u8; p = p + 1             // vint name_len
  p = wraw(b,p,nm,nl)
  p = wraw(b,p,d,dn)
  return p
114}
115
116func put_file(path: *u8, b: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, 0x1a4)
  if fd < 0 { return 0-1 }
  sys_write(fd, b, n)
  sys_close(fd)
  return 0
122}
123
124// exec the real extractor on a fixture; returns wait4 status (0 = clean exit 0)
125func run_x(fixture: *u8, slug: *u8) -> i64 {
  // stale-output scrub: a leftover cbx.json/page must never fake a green
  let sp: *u8 = sys_mmap(512)
  var so: i64 = g_cat(sp, 0, "knowledge/staging/media/reader/" as *u8)
  so = g_cat(sp, so, slug)
  let base: i64 = so
  so = g_cat(sp, base, "/cbx.json" as *u8); sp[so] = 0 as u8; rmf(sp)
  so = g_cat(sp, base, "/page000.jpg" as *u8); sp[so] = 0 as u8; rmf(sp)
  so = g_cat(sp, base, "/page001.jpg" as *u8); sp[so] = 0 as u8; rmf(sp)
  so = g_cat(sp, base, "/page002.jpg" as *u8); sp[so] = 0 as u8; rmf(sp)
  so = g_cat(sp, base, "/page003.jpg" as *u8); sp[so] = 0 as u8; rmf(sp)
136
  // ARTIFACT-TRUTH verdict: sys_wait4's status word proved UNRELIABLE on this lane (zero-filled st
  // faked green once; poisoned st faked red next). The media server itself never trusts it -- it
  // checks the produced file after waiting. Same here: the scrub above deleted cbx.json, so its
  // EXISTENCE after the run is the truth. Retry x3: degraded WSL drops forks.
  let jp: *u8 = sys_mmap(512)
  var jo: i64 = g_cat(jp, 0, "knowledge/staging/media/reader/" as *u8)
  jo = g_cat(jp, jo, slug)
  jo = g_cat(jp, jo, "/cbx.json" as *u8); jp[jo] = 0 as u8
  var rc: i64 = 0-1
  var att: i64 = 0
  while att < 3 {
      if rc != 0 {
          let pid: i64 = sys_fork()
          if pid == 0 {
              let av: *i64 = sys_mmap(64) as *i64
              av[0] = "/tmp/nx_cbx_pages.sov.elf" as *u8 as i64
              av[1] = fixture as i64
              av[2] = slug as i64
              av[3] = 0
              sys_execve("/tmp/nx_cbx_pages.sov.elf" as *u8, av, 0 as *i64)
              sys_exit(127)
          }
          if pid > 0 {
              let st: *i64 = sys_mmap(8) as *i64
              sys_wait4(pid, st, 0)
          }
          let tf: i64 = sys_openat_rd(jp)
          if tf >= 0 { sys_close(tf); rc = 0 }
          else { rc = 0-1; g_p("  [gate] no cbx.json att=" as *u8); g_pn(att); g_p("\n" as *u8); sys_sleep_ms(300) }
      }
      att = att + 1
  }
  return rc
170}
171
172// read a produced file and check it CONTAINS tag; 1/0
173func page_has(slug: *u8, fname: *u8, tag: *u8) -> i64 {
  let sp: *u8 = sys_mmap(512)
  var so: i64 = g_cat(sp, 0, "knowledge/staging/media/reader/" as *u8)
  so = g_cat(sp, so, slug)
  so = g_cat(sp, so, "/" as *u8)
  so = g_cat(sp, so, fname); sp[so] = 0 as u8
  let lb: *i64 = sys_mmap(16) as *i64
  let d: *u8 = sys_read_file(sp, lb)
  if (d as i64) == 0 { return 0 }
  if find_sub(d, lb[0], tag) >= 0 { return 1 }
  return 0
184}
185
186// cnt[0]=pass cnt[1]=fail (NishiLang: no top-level vars -- counters ride a pointer)
187func chk(cnt: *i64, ok: i64, label: *u8) -> i64 {
  if ok == 1 { cnt[0] = cnt[0] + 1; g_p("  PASS " as *u8) } else { cnt[1] = cnt[1] + 1; g_p("  FAIL " as *u8) }
  g_w(1, label); g_p("\n" as *u8)
  return 0
191}
192
193func g_atoi(s: *u8) -> i64 { var v: i64=0; var i: i64=0; while s[i]!=(0 as u8){ let c: i64=s[i] as i64; if c>=48 { if c<=57 { v=v*10+(c-48) } } i=i+1 } return v }
194func g_itoa(v: i64, out: *u8) -> i64 { let t: *u8=sys_mmap(28); var m: i64=v; 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{out[i]=t[k-1-i];i=i+1}; out[k]=0 as u8; return k }
195
196// SELF-EXEC CHAIN to the next stage: execve REPLACES the process, resetting the runtime's fork budget.
197// (Empirically this lane only completes ~2 fork+exec cycles per process -- the 3rd child dies silently
198// before its first write. One fixture per process stays inside that; counters ride argv.)
199func selfexec(self: *u8, stage: i64, cnt: *i64) -> i64 {
  let s1: *u8 = sys_mmap(28); g_itoa(stage, s1)
  let s2: *u8 = sys_mmap(28); g_itoa(cnt[0], s2)
  let s3: *u8 = sys_mmap(28); g_itoa(cnt[1], s3)
  let av: *i64 = sys_mmap(64) as *i64
  av[0] = self as i64
  av[1] = s1 as i64
  av[2] = s2 as i64
  av[3] = s3 as i64
  av[4] = 0
  sys_execve(self, av, 0 as *i64)
  g_p("CBX-GATE-RED selfexec-failed\n" as *u8)
  sys_exit(9)
  return 9
213}
214
215func main(argc: i64, argv: *i64) -> i64 {
  var stage: i64 = 1
  let cnt: *i64 = sys_mmap(16) as *i64
  cnt[0] = 0; cnt[1] = 0
  if argc >= 4 {
      stage = g_atoi(argv[1] as *u8)
      cnt[0] = g_atoi(argv[2] as *u8)
      cnt[1] = g_atoi(argv[3] as *u8)
  }
  let self: *u8 = argv[0] as *u8
225
  // distinct real-magic page payloads (ff d8 = JPEG SOI) + a liar (text wearing .jpg) + apple junk
  let j1:  *u8 = sys_mmap(32);  j1[0]=0xff as u8;  j1[1]=0xd8 as u8;  g_cat(j1, 2, "NXPAGEONE" as *u8)
  let j2:  *u8 = sys_mmap(32);  j2[0]=0xff as u8;  j2[1]=0xd8 as u8;  g_cat(j2, 2, "NXPAGETWO" as *u8)
  let j10: *u8 = sys_mmap(32);  j10[0]=0xff as u8; j10[1]=0xd8 as u8; g_cat(j10, 2, "NXPAGETEN" as *u8)
  let txt: *u8 = sys_mmap(32);  g_cat(txt, 0, "notanimageatall" as *u8)
  let jnk: *u8 = sys_mmap(32);  g_cat(jnk, 0, "APPLJUNKBYTES" as *u8)
  let n1: i64 = 11
  let n2: i64 = 11
  let n10: i64 = 11
  let ntxt: i64 = 15
  let njnk: i64 = 13
237
  if stage == 1 {
      g_p("CBX-GATE: fixture-crafted zip/rar4/rar5 vs the REAL built extractor (self-exec chain)\n" as *u8)
      __syscall(258, 0-100, "/tmp/cbxgate" as *u8, 0x1ed, 0, 0, 0)
241
      // ---------- write ALL fixtures once (later stages only read them) ----------
      // fixture 1: t1.cbz -- zip, archive order 10,1,junk,2,txt
      let zb: *u8 = sys_mmap(65536)
      var zo: i64 = 0
      let l0: i64 = zo; zo = zlfh(zb, zo, "b/page10.jpg" as *u8, j10, n10)
      let l1: i64 = zo; zo = zlfh(zb, zo, "b/page1.jpg" as *u8, j1, n1)
      let l2: i64 = zo; zo = zlfh(zb, zo, "__MACOSX/._page1.jpg" as *u8, jnk, njnk)
      let l3: i64 = zo; zo = zlfh(zb, zo, "b/page2.jpg" as *u8, j2, n2)
      let l4: i64 = zo; zo = zlfh(zb, zo, "b/pagetxt.jpg" as *u8, txt, ntxt)
      let cd: i64 = zo
      zo = zcde(zb, zo, "b/page10.jpg" as *u8, n10, l0)
      zo = zcde(zb, zo, "b/page1.jpg" as *u8, n1, l1)
      zo = zcde(zb, zo, "__MACOSX/._page1.jpg" as *u8, njnk, l2)
      zo = zcde(zb, zo, "b/page2.jpg" as *u8, n2, l3)
      zo = zcde(zb, zo, "b/pagetxt.jpg" as *u8, ntxt, l4)
      zo = zeocd(zb, zo, 5, cd, zo - cd)
      put_file("/tmp/cbxgate/t1.cbz" as *u8, zb, zo)
259
      // fixture 2: t2.cbr -- rar4 STORE, archive order 10,2
      let rb: *u8 = sys_mmap(65536)
      var ro: i64 = 0
      rb[0]=0x52 as u8; rb[1]=0x61 as u8; rb[2]=0x72 as u8; rb[3]=0x21 as u8; rb[4]=0x1a as u8; rb[5]=0x07 as u8; rb[6]=0x00 as u8
      ro = 7
      ro = r4file(rb, ro, "p10.jpg" as *u8, j10, n10)
      ro = r4file(rb, ro, "p2.jpg" as *u8, j2, n2)
      put_file("/tmp/cbxgate/t2.cbr" as *u8, rb, ro)
268
      // fixture 3: t3.cbr -- rar5 STORE, archive order 10,2
      let qb: *u8 = sys_mmap(65536)
      var qo: i64 = 0
      qb[0]=0x52 as u8; qb[1]=0x61 as u8; qb[2]=0x72 as u8; qb[3]=0x21 as u8; qb[4]=0x1a as u8; qb[5]=0x07 as u8; qb[6]=0x01 as u8; qb[7]=0x00 as u8
      qo = 8
      qo = r5file(qb, qo, "x10.jpg" as *u8, j10, n10)
      qo = r5file(qb, qo, "x2.jpg" as *u8, j2, n2)
      put_file("/tmp/cbxgate/t3.cbr" as *u8, qb, qo)
277
      // fixture 4: t4.cbr -- a ZIP wearing .cbr (magic sniff must route it)
      let vb: *u8 = sys_mmap(65536)
      var vo: i64 = 0
      let v0: i64 = vo; vo = zlfh(vb, vo, "z1.jpg" as *u8, j1, n1)
      let vcd: i64 = vo
      vo = zcde(vb, vo, "z1.jpg" as *u8, n1, v0)
      vo = zeocd(vb, vo, 1, vcd, vo - vcd)
      put_file("/tmp/cbxgate/t4.cbr" as *u8, vb, vo)
286
      // ---------- stage 1 checks: zip ----------
      let st1: i64 = run_x("/tmp/cbxgate/t1.cbz" as *u8, "cbxgate_zip" as *u8)
      var ok1: i64 = 0; if st1 == 0 { ok1 = 1 }
      chk(cnt, ok1, "zip: extractor produced cbx.json" as *u8)
      let jz: *u8 = sys_mmap(512)
      var jzo: i64 = g_cat(jz, 0, "knowledge/staging/media/reader/cbxgate_zip/cbx.json" as *u8); jz[jzo] = 0 as u8
      let lbz: *i64 = sys_mmap(16) as *i64
      let dz: *u8 = sys_read_file(jz, lbz)
      var okn: i64 = 0
      var okc: i64 = 0
      if (dz as i64) != 0 {
          if find_sub(dz, lbz[0], "\"npages\":3" as *u8) >= 0 { okn = 1 }
          if find_sub(dz, lbz[0], "\"cfix\":2" as *u8) >= 0 { okc = 1 }
      }
      chk(cnt, okn, "zip: npages==3 (junk name + nonimage bytes both skipped)" as *u8)
      chk(cnt, okc, "zip: cbx.json carries cfix:2 cache-heal tag" as *u8)
      chk(cnt, page_has("cbxgate_zip" as *u8, "page000.jpg" as *u8, "NXPAGEONE" as *u8), "zip: page000 == page1 (natural order)" as *u8)
      chk(cnt, page_has("cbxgate_zip" as *u8, "page001.jpg" as *u8, "NXPAGETWO" as *u8), "zip: page001 == page2 (natural order)" as *u8)
      chk(cnt, page_has("cbxgate_zip" as *u8, "page002.jpg" as *u8, "NXPAGETEN" as *u8), "zip: page002 == page10 (10 AFTER 2 -- ascii bug dead)" as *u8)
      selfexec(self, 2, cnt)
  }
308
  if stage == 2 {
      let st2: i64 = run_x("/tmp/cbxgate/t2.cbr" as *u8, "cbxgate_rar4" as *u8)
      var ok2: i64 = 0; if st2 == 0 { ok2 = 1 }
      chk(cnt, ok2, "rar4: produced cbx.json (STORE walker)" as *u8)
      chk(cnt, page_has("cbxgate_rar4" as *u8, "page000.jpg" as *u8, "NXPAGETWO" as *u8), "rar4: page000 == p2 (natural order)" as *u8)
      chk(cnt, page_has("cbxgate_rar4" as *u8, "page001.jpg" as *u8, "NXPAGETEN" as *u8), "rar4: page001 == p10" as *u8)
      selfexec(self, 3, cnt)
  }
317
  if stage == 3 {
      let st3: i64 = run_x("/tmp/cbxgate/t3.cbr" as *u8, "cbxgate_rar5" as *u8)
      var ok3: i64 = 0; if st3 == 0 { ok3 = 1 }
      chk(cnt, ok3, "rar5: produced cbx.json (vint STORE walker)" as *u8)
      chk(cnt, page_has("cbxgate_rar5" as *u8, "page000.jpg" as *u8, "NXPAGETWO" as *u8), "rar5: page000 == x2 (natural order)" as *u8)
      chk(cnt, page_has("cbxgate_rar5" as *u8, "page001.jpg" as *u8, "NXPAGETEN" as *u8), "rar5: page001 == x10" as *u8)
      selfexec(self, 4, cnt)
  }
326
  // stage 4: renamed-container sniff + verdict
  let st4: i64 = run_x("/tmp/cbxgate/t4.cbr" as *u8, "cbxgate_ziplie" as *u8)
  var ok4: i64 = 0; if st4 == 0 { ok4 = 1 }
  chk(cnt, ok4, "renamed: .cbr that is really zip produced cbx.json (sniff)" as *u8)
  chk(cnt, page_has("cbxgate_ziplie" as *u8, "page000.jpg" as *u8, "NXPAGEONE" as *u8), "renamed: page000 == z1" as *u8)
332
  g_p("CBX-GATE: pass=" as *u8); g_pn(cnt[0]); g_p(" fail=" as *u8); g_pn(cnt[1]); g_p("\n" as *u8)
  if cnt[1] == 0 { g_p("CBX-GATE-GREEN\n" as *u8); sys_exit(0); return 0 }
  g_p("CBX-GATE-RED\n" as *u8); sys_exit(1); return 1
336}
nx_cbx_pages_gate.nx source

`nx_cbx_pages_gate.nx` source
