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

↩ module page · 227 lines · 11705 B
1// nx_varfacts_gate.nx -- PROVE THE .var LANE READS THE MANIFEST, NEVER THE ASSETS, AND REFUSES
2// RATHER THAN UNDERCOUNTS. The fixture ZIP is hand-built from the published PKZIP layout (local
3// headers + central directory + EOCD), not by our writer -- cross-implementation discipline.
4// license_tier: ORIGINAL   No hw writes (Rule 26).
5import "nx_syscalls.nx"
6import "nx_gate_verdict.nx"
7import "nx_varfacts_lib.nx"
8
9func zg_u16(b: *u8, at: i64, v: i64) -> i64 { b[at] = (v & 0xff) as u8; b[at+1] = ((v >> 8) & 0xff) as u8; return at + 2 }
10func zg_u32(b: *u8, at: i64, v: i64) -> i64 { b[at]=(v&0xff) as u8; b[at+1]=((v>>8)&0xff) as u8; b[at+2]=((v>>16)&0xff) as u8; b[at+3]=((v>>24)&0xff) as u8; return at + 4 }
11func zg_s(b: *u8, at: i64, s: *u8) -> i64 { var i: i64 = 0; var p: i64 = at; while s[i] != (0 as u8) { b[p] = s[i]; p = p + 1; i = i + 1 } return p }
12func zg_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
13
14// one local header + body; returns new offset. Records the entry's lho into lhos[idx].
15func zg_local(b: *u8, at: i64, name: *u8, body: *u8, blen: i64, method: i64, usize: i64, lhos: *i64, idx: i64) -> i64 {
  lhos[idx] = at
  var p: i64 = at
  p = zg_u32(b, p, 0x04034b50)
  p = zg_u16(b, p, 20)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, method)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 0)
  p = zg_u32(b, p, 0)
  p = zg_u32(b, p, blen)
  p = zg_u32(b, p, usize)
  p = zg_u16(b, p, zg_len(name))
  p = zg_u16(b, p, 0)
  p = zg_s(b, p, name)
  var i: i64 = 0
  while i < blen { b[p] = body[i]; p = p + 1; i = i + 1 }
  return p
33}
34// one central-directory entry; returns new offset
35func zg_cd(b: *u8, at: i64, name: *u8, blen: i64, method: i64, usize: i64, lho: i64) -> i64 {
  var p: i64 = at
  p = zg_u32(b, p, 0x02014b50)
  p = zg_u16(b, p, 20)
  p = zg_u16(b, p, 20)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, method)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 0)
  p = zg_u32(b, p, 0)
  p = zg_u32(b, p, blen)
  p = zg_u32(b, p, usize)
  p = zg_u16(b, p, zg_len(name))
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 0)
  p = zg_u32(b, p, 0)
  p = zg_u32(b, p, lho)
  p = zg_s(b, p, name)
  return p
56}
57
58func main(argc: i64, argv: *i64) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_varfacts_gate -- the manifest is read, the assets are not, refusal beats undercount" as *u8)
61
  let b: *u8 = sys_mmap(16384)
  let lhos: *i64 = sys_mmap(16 * 8) as *i64
  let facts: *i64 = sys_mmap(VF_N_SLOTS * 8) as *i64
65
  // ---- fixture: 8 entries covering every class; meta.json STORED ----
  let meta: *u8 = "{\"licenseType\":\"CC BY\",\"contentList\":[]}" as *u8
  let ml: i64 = zg_len(meta)
  let tiny: *u8 = "{}" as *u8
  var p: i64 = 0
  p = zg_local(b, p, "meta.json" as *u8, meta, ml, 0, ml, lhos, 0)
  p = zg_local(b, p, "Custom/Atom/Person/Morphs/female/a.vmi" as *u8, tiny, 2, 0, 2, lhos, 1)
  p = zg_local(b, p, "Saves/scene/s.json" as *u8, tiny, 2, 0, 2, lhos, 2)
  p = zg_local(b, p, "Custom/Skin/t.jpg" as *u8, tiny, 2, 0, 2, lhos, 3)
  p = zg_local(b, p, "Custom/Clothing/x/i.vam" as *u8, tiny, 2, 0, 2, lhos, 4)
  p = zg_local(b, p, "Custom/Hair/h/z.vam" as *u8, tiny, 2, 0, 2, lhos, 5)
  p = zg_local(b, p, "ADD.cs" as *u8, tiny, 2, 0, 2, lhos, 6)
  p = zg_local(b, p, "look.vap" as *u8, tiny, 2, 0, 2, lhos, 7)
  let cd0: i64 = p
  p = zg_cd(b, p, "meta.json" as *u8, ml, 0, ml, lhos[0])
  p = zg_cd(b, p, "Custom/Atom/Person/Morphs/female/a.vmi" as *u8, 2, 0, 2, lhos[1])
  p = zg_cd(b, p, "Saves/scene/s.json" as *u8, 2, 0, 2, lhos[2])
  p = zg_cd(b, p, "Custom/Skin/t.jpg" as *u8, 2, 0, 2, lhos[3])
  p = zg_cd(b, p, "Custom/Clothing/x/i.vam" as *u8, 2, 0, 2, lhos[4])
  p = zg_cd(b, p, "Custom/Hair/h/z.vam" as *u8, 2, 0, 2, lhos[5])
  p = zg_cd(b, p, "ADD.cs" as *u8, 2, 0, 2, lhos[6])
  p = zg_cd(b, p, "look.vap" as *u8, 2, 0, 2, lhos[7])
  let cdsz: i64 = p - cd0
  p = zg_u32(b, p, 0x06054b50)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 0)
  p = zg_u16(b, p, 8)
  p = zg_u16(b, p, 8)
  p = zg_u32(b, p, cdsz)
  p = zg_u32(b, p, cd0)
  p = zg_u16(b, p, 0)
  let total: i64 = p
98
  // T1 full census from the central directory
  vf_probe(b, total, total, facts)
  var t1: i64 = 0
  if facts[0] == 1 { if facts[1] == 8 { if facts[2] == 1 { if facts[3] == 1 { if facts[4] == 1 { if facts[5] == 1 { if facts[6] == 1 { if facts[7] == 1 { if facts[8] == 1 { if facts[9] == 1 { t1 = 1 } } } } } } } } } }
  gv_check("T1 MANIFEST CENSUS: 8 entries classify into morphs/scenes/textures/clothing/hair/plugins/appearance and meta.json is located -- all from central-directory NAMES, no member opened" as *u8, t1, ctr)
104
  // T2 the declared license reads from a STORED meta.json body
  let lic: *u8 = sys_mmap(64)
  let mbody: *u8 = ((b as i64) + lhos[0] + 30 + 9) as *u8
  let r2: i64 = vf_license(mbody, ml, 0, ml, lic)
  var t2: i64 = 0
  if r2 > 0 { if lic[0] == 67 { if lic[1] == 67 { if lic[2] == 32 { if lic[3] == 66 { if lic[4] == 89 { t2 = 1 } } } } } }
  gv_check("T2 DECLARED LICENSE READ (stored): licenseType CC BY extracted from the package's own meta.json" as *u8, t2, ctr)
112
  // T3 method-8 meta.json: a raw-DEFLATE stored-block wrap of the same body decodes through the
  // INCUMBENT nx_deflate_inflate and yields the same label
  let dz: *u8 = sys_mmap(256)
  dz[0] = 1 as u8
  zg_u16(dz, 1, ml)
  zg_u16(dz, 3, 65535 - ml)
  var di: i64 = 0
  while di < ml { dz[5+di] = meta[di]; di = di + 1 }
  let r3: i64 = vf_license(dz, 5 + ml, 8, ml, lic)
  var t3: i64 = 0
  if r3 > 0 { if lic[0] == 67 { if lic[4] == 89 { t3 = 1 } } }
  gv_check("T3 DEFLATED meta.json DECODES: ZIP method 8 rides the incumbent raw-DEFLATE core (nx_deflate_inflate) and yields the same CC BY" as *u8, t3, ctr)
125
  // T4 garbage refuses: no EOCD -> ok=0 and no counts
  let g: *u8 = sys_mmap(256)
  var gi: i64 = 0
  while gi < 200 { g[gi] = 0x41 as u8; gi = gi + 1 }
  vf_probe(g, 200, 200, facts)
  var t4: i64 = 0
  if facts[0] == 0 { if facts[1] == 0 - 1 { t4 = 1 } }
  gv_check("T4 NOT-A-ZIP REFUSES: no EOCD yields ok=0 and every count stays -1" as *u8, t4, ctr)
134
  // T5 window honesty: pretend the file is 1000 bytes longer than the window -> the CD's absolute
  // offset lands before the window start -> REFUSE, never a partial census
  vf_probe(b, total, total + 1000, facts)
  var t5: i64 = 0
  if facts[0] == 0 { t5 = 1 }
  gv_check("T5 A PARTIAL CENSUS IS REFUSED: when the central directory starts before the tail window the probe returns ok=0 rather than an undercount" as *u8, t5, ctr)
141
  // T6 tail semantics: hand the probe only the LAST total-50 bytes (as a real tail read would)
  // and the census still resolves through absolute-offset arithmetic
  let tailp: *u8 = ((b as i64) + 50) as *u8
  vf_probe(tailp, total - 50, total, facts)
  var t6: i64 = 0
  if facts[0] == 1 { if facts[1] == 8 { if facts[2] == 1 { t6 = 1 } } }
  gv_check("T6 TAIL-WINDOW CONTRACT: the census is identical when only the archive tail is in memory -- a 519MB look pack measures from its last few MB" as *u8, t6, ctr)
149
  // T7 ZIP64 EXTRA RESOLUTION -- MEASURED 2026-09-11 on real VaM packages (101,040 members in 1,633 of 2,179 readable
  // packages): a writer marks the CD sizes 0xFFFFFFFF and carries the true values in extra 0x0001 under a plain 32-bit EOCD.
  let z: *u8 = sys_mmap(4096)
  let zl: *i64 = sys_mmap(16 * 8) as *i64
  var zp: i64 = 0
  zp = zg_local(z, zp, "meta.json" as *u8, meta, ml, 0, ml, zl, 0)
  let zcd0: i64 = zp
  zp = zg_u32(z, zp, 0x02014b50)
  zp = zg_u16(z, zp, 45)
  zp = zg_u16(z, zp, 45)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 0)
  zp = zg_u32(z, zp, 0)
  zp = zg_u32(z, zp, 0xffffffff)
  zp = zg_u32(z, zp, 0xffffffff)
  zp = zg_u16(z, zp, 9)
  zp = zg_u16(z, zp, 20)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 0)
  zp = zg_u32(z, zp, 0)
  zp = zg_u32(z, zp, zl[0])
  zp = zg_s(z, zp, "meta.json" as *u8)
  let zxid: i64 = zp
  zp = zg_u16(z, zp, 1)
  zp = zg_u16(z, zp, 16)
  zp = zg_u32(z, zp, ml)
  zp = zg_u32(z, zp, 0)
  zp = zg_u32(z, zp, ml)
  zp = zg_u32(z, zp, 0)
  let zcdsz: i64 = zp - zcd0
  zp = zg_u32(z, zp, 0x06054b50)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 0)
  zp = zg_u16(z, zp, 1)
  zp = zg_u16(z, zp, 1)
  zp = zg_u32(z, zp, zcdsz)
  zp = zg_u32(z, zp, zcd0)
  zp = zg_u16(z, zp, 0)
  let ztotal: i64 = zp
  let zbox: *i64 = sys_mmap(VF_L_N * 8) as *i64
  let zrec: *i64 = sys_mmap(VF_E_N * 8) as *i64
  gv_check_eq("T7 ZIP64-EXTRA ARCHIVE LOCATES: a plain 32-bit EOCD over overflowed CD sizes is still an OK archive" as *u8, vf_cd_locate(z, ztotal, ztotal, zbox), VF_LOC_OK, ctr)
  vf_cd_entry(z, ztotal, zbox[VF_L_CD], zrec)
  gv_check_eq("T7a usize RESOLVED from extra 0x0001, not read as 4294967295" as *u8, zrec[VF_E_USIZE], ml, ctr)
  gv_check_eq("T7b csize RESOLVED from extra 0x0001" as *u8, zrec[VF_E_CSIZE], ml, ctr)
  gv_check_eq("T7c the record names its state RESOLVED" as *u8, zrec[VF_E_Z64], VF_Z64_RESOLVED, ctr)
  vf_probe(z, ztotal, ztotal, facts)
  gv_check_eq("T7d the legacy probe now carries the REAL meta.json csize, so its licence read can succeed" as *u8, facts[12], ml, ctr)
  z[zxid] = 2 as u8
  vf_cd_entry(z, ztotal, zbox[VF_L_CD], zrec)
  gv_check_eq("neg-control-T7e an overflowed size with no 0x0001 record reads UNRESOLVED, never a guessed size" as *u8, zrec[VF_E_Z64], VF_Z64_UNRESOLVED, ctr)
  gv_check_eq("neg-control-T7f and the unresolved usize stays the overflow marker for the caller to refuse by name" as *u8, zrec[VF_E_USIZE], VF_U32_ALL, ctr)
205
  // T8 DEPTH-AWARE meta.json: a nested dependency's licenseType PRECEDES the package's own in the bytes
  let jj: *u8 = "{\"dependencies\":{\"X.Y.1\":{\"licenseType\":\"PC\",\"dependencies\":{}}},\"licenseType\":\"CC BY\"}" as *u8
  let jn: i64 = zg_len(jj)
  let jlen: *i64 = sys_mmap(16) as *i64
  let jbox: *i64 = sys_mmap(VF_JM_N * 8) as *i64
  let jtop: *u8 = vf_json_get_str(jj, jn, 0, "licenseType" as *u8, jlen)
  var t8: i64 = 0
  if (jtop as i64) != 0 { if jlen[0] == 5 { if jtop[0] == 67 { if jtop[3] == 66 { if jtop[4] == 89 { t8 = 1 } } } } }
  gv_check("T8 DEPTH-AWARE licenseType: the package's DIRECT member answers CC BY, not the nested PC that precedes it" as *u8, t8, ctr)
  let jleg: *u8 = sys_mmap(64)
  gv_check_eq("T8a the legacy first-occurrence reader returns the nested label (length 2) -- the flaw the census checks for on every package (census run 1 measured 0 disagreements over 2,177 parsed metas)" as *u8, vf_license(jj, jn, 0, jn, jleg), 2, ctr)
  gv_check_eq("T8b one DIRECT dependency member, its nested dependencies not counted" as *u8, vf_json_count_members(jj, jn, vf_json_find(jj, jn, 0, "dependencies" as *u8, jbox)), 1, ctr)
218
  // T9 THE WINDOW IS NAMED AND DERIVED: a CD before the window is WINDOW, and the window to read is the archive's own cd_abs
  let wbox: *i64 = sys_mmap(VF_L_N * 8) as *i64
  gv_check_eq("T9 a central directory before the window reads WINDOW, not a generic refusal" as *u8, vf_cd_locate(b, total, total + 1000, wbox), VF_LOC_WINDOW, ctr)
  gv_check_eq("T9a the caller's window is derived from cd_abs in the EOCD" as *u8, wbox[VF_L_CDABS], cd0, ctr)
223
  let rc: i64 = gv_verdict("VARFACTS-GATE", ctr, "hand-built PKZIP fixture, manifest-only reads, refusal over undercount, incumbent deflate" as *u8)
  sys_exit(rc)
  return rc
227}
nx_varfacts_gate.nx source

`nx_varfacts_gate.nx` source
