code wiki / (root) / nx_sevenz_gate.nx
`nx_sevenz_gate.nx` source

↩ module page · 363 lines · 22518 B
1// nx_sevenz_gate.nx -- THE 7z READER GATE (/compare/modding MD29 sz_walk, 2026-09-06). The subjects are two REAL archives mirrored
2// from the py7zr test corpus (knowledge/fetched/cmp_modding_py7zr_test_1.7z, an LZMA2 archive with an encoded header, and
3// cmp_modding_py7zr_copy.7z, a Copy-coder archive), never a fixture this lane authored -- a reader tested only on archives its
4// author wrote proves it can read its author. The oracle is the archive's OWN per-member CRC-32 digests written by the outside
5// encoder: every data member must decode to exactly its declared size AND hash to the digest the archive carries, through the
6// decoder nx_lzma_lib and the container reader nx_sevenz_lib, with nothing third-party in the path. Named refusals are
7// planted at runtime (a cut container, a forged start-header CRC, a forged header CRC, a corrupted packed byte) and each must be
8// refused by NAME, never read clean. The rung's done-rule fixture (an OBJ, its MTL, four PNG maps, a VMD) is written by the
9// estate's own Copy-coder writer and must walk to the SAME typed partition MD1's zip fixture reaches, through the lib and
10// through the bundle walker that dispatches on the magic. The command is a second witness through the ladder live -> staged ->
11// build fossil, and an extract is re-hashed by the SAME crc32 the archive used.
12// usage: nx_sevenz_gate   (no args)
13// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
14import "nx_syscalls.nx"
15import "nx_gate_verdict.nx"
16import "nx_gatekit_lib.nx"
17import "nx_bundle_ingest_lib.nx"
18import "nx_sevenz_lib.nx"
19
20const ZG_DIR: *u8 = "/tmp/nx_sevenz_gate"
21const ZG_T1: *u8 = "knowledge/fetched/cmp_modding_py7zr_test_1.7z"
22const ZG_CP: *u8 = "knowledge/fetched/cmp_modding_py7zr_copy.7z"
23const ZG_CUT: *u8 = "/tmp/nx_sevenz_gate/cut.7z"
24const ZG_BADSTART: *u8 = "/tmp/nx_sevenz_gate/badstart.7z"
25const ZG_BADHDR: *u8 = "/tmp/nx_sevenz_gate/badhdr.7z"
26const ZG_BADPACK: *u8 = "/tmp/nx_sevenz_gate/badpack.7z"
27const ZG_TYPED: *u8 = "/tmp/nx_sevenz_gate/typed.7z"
28const ZG_M0: *u8 = "/tmp/nx_sevenz_gate/member0.bin"
29const ZG_ELF_LIVE: *u8 = "./nx_sevenz.elf"
30const ZG_ELF_STAGE: *u8 = "./nx_sevenz.sov.elf.new"
31const ZG_ELF_BUILD: *u8 = "buildroot/_build/nx_sevenz.sov.elf"
32const ZG_BI_LIVE: *u8 = "./nx_bundle_ingest.elf"
33const ZG_BI_STAGE: *u8 = "./nx_bundle_ingest.sov.elf.new"
34const ZG_BI_BUILD: *u8 = "buildroot/_build/nx_bundle_ingest.sov.elf"
35const ZG_DIR_MODE: i64 = 493
36const ZG_FILE_MODE: i64 = 420
37const ZG_CAP: i64 = 65536
38const ZG_NAMES_HEADROOM: i64 = 4096
39const ZG_ST_N: i64 = 8
40const ZG_START_CRC_OFF: i64 = 8
41const ZG_FIRST_PACK_OFF: i64 = 32
42const ZG_TYPED_N: i64 = 7
43const ZG_PNG_LEN: i64 = 40
44const ZG_VMD_LEN: i64 = 30
45const ZG_VMD_MAGIC_LEN: i64 = 25
46const ZG_TYPED_CAP: i64 = 4096
47
48func zg_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
49func zg_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
50func zg_write_file(path: *u8, b: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, ZG_FILE_MODE)
  if fd < 0 { return 0 - 1 }
  var done: i64 = 0
  while done < n { let k: i64 = sys_write(fd, b + done, n - done); if k <= 0 { break } done = done + k }
  sys_close(fd)
  return done
57}
58// a byte-flipped twin of b written to path; returns the twin
59func zg_twin(b: *u8, n: i64, flip_off: i64, path: *u8) -> *u8 {
  let t: *u8 = sys_mmap(n + 16)
  var i: i64 = 0
  while i < n { t[i] = b[i]; i = i + 1 }
  if flip_off >= 0 { if flip_off < n { t[flip_off] = (((t[flip_off] & 0xff) as i64) ^ 255) as u8 } }
  zg_write_file(path, t, n)
  return t
66}
67// walk an in-memory archive into a fresh table; returns rows (or the named error); st gets dirs/empty/folders/encoded
68func zg_walk(b: *u8, n: i64, out_tbl: *i64, out_names: *i64, st: *i64) -> i64 {
  let total: i64 = sz_count(b, n)
  if total < 0 { return total }
  let tbl: *i64 = sys_mmap(8 * BI_F_N * (total + 1)) as *i64
  let ncap: i64 = n * 2 + ZG_NAMES_HEADROOM
  let names: *u8 = sys_mmap(ncap)
  let m: i64 = sz_walk(b, n, tbl, total, names, ncap, st)
  out_tbl[0] = tbl as i64
  out_names[0] = names as i64
  return m
78}
79// per-archive census over the walked table: res[0]=data rows, [1]=ok, [2]=stored, [3]=failed, [4]=unsupported, [5]=rows with a
80// non-zero digest, [6]=rows whose bytes equal their declared size, [7]=rows with a non-empty name, [8]=rows on the lzma2 coder,
81// [9]=rows on the copy coder, [10]=empty files
82func zg_census(tbl: *i64, m: i64, res: *i64) -> i64 {
  var k: i64 = 0
  while k < 12 { res[k] = 0; k = k + 1 }
  var i: i64 = 0
  while i < m {
      let r: *i64 = bi_rec(tbl, i)
      if r[BI_F_NAMELEN] > 0 { res[7] = res[7] + 1 }
      if r[BI_F_USIZE] == 0 { if r[BI_F_INFLATE] == BI_INF_STORED { res[10] = res[10] + 1 } }
      else {
          res[0] = res[0] + 1
          if r[BI_F_INFLATE] == BI_INF_OK { res[1] = res[1] + 1 }
          else { if r[BI_F_INFLATE] == BI_INF_STORED { res[2] = res[2] + 1 }
          else { if r[BI_F_INFLATE] == BI_INF_UNSUPPORTED { res[4] = res[4] + 1 } else { res[3] = res[3] + 1 } } }
          if r[BI_F_CRC] != 0 { res[5] = res[5] + 1 }
          if r[BI_F_DLEN] == r[BI_F_USIZE] { res[6] = res[6] + 1 }
          if r[BI_F_METHOD] == SZ_CODER_LZMA2 { res[8] = res[8] + 1 }
          if r[BI_F_METHOD] == SZ_CODER_COPY { res[9] = res[9] + 1 }
      }
      i = i + 1
  }
  return m
103}
104// the ladder: live, then staged, then the build fossil
105func zg_ladder(live: *u8, stage: *u8, build: *u8) -> *u8 {
  if zg_exists(live) == 1 { return live }
  if zg_exists(stage) == 1 { return stage }
  if zg_exists(build) == 1 { return build }
  return 0 as *u8
110}
111
112func main(argc: i64, argv: *i64) -> i64 {
  let ctr: *i64 = gv_ctr()
  sys_mkdir(ZG_DIR, ZG_DIR_MODE)
  let l1: *i64 = sys_mmap(16) as *i64
  let b1: *u8 = sys_read_file(ZG_T1, l1)
  gv_need("real-lzma2-archive-mirrored (py7zr test_1.7z)" as *u8, ((b1 as i64) != 0) as i64, ctr)
  let l2: *i64 = sys_mmap(16) as *i64
  let b2: *u8 = sys_read_file(ZG_CP, l2)
  gv_need("real-copy-coder-archive-mirrored (py7zr copy.7z)" as *u8, ((b2 as i64) != 0) as i64, ctr)
  if (b1 as i64) == 0 { return gv_verdict("NX-SEVENZ" as *u8, ctr, "fixtures absent" as *u8) }
  if (b2 as i64) == 0 { return gv_verdict("NX-SEVENZ" as *u8, ctr, "fixtures absent" as *u8) }
  let n1: i64 = l1[0]
  let n2: i64 = l2[0]
  // ---- 1. signature ----
  gv_check("signature-recognised-on-the-real-archive" as *u8, sz_is_7z(b1, n1), ctr)
  let notz: *u8 = sys_mmap(64)
  notz[0] = 80 as u8; notz[1] = 75 as u8; notz[2] = 3 as u8; notz[3] = 4 as u8
  gv_check("neg-control-zip-magic-is-not-a-7z" as *u8, (sz_is_7z(notz, 64) == 0) as i64, ctr)
  gv_check_eq("neg-control-zip-magic-count-refuses-not-a-7z" as *u8, sz_count(notz, 64), SZ_ERR_NOT_7Z, ctr)
  // ---- 2. the LZMA2 archive walks and every member matches the archive's own digest ----
  let ot: *i64 = sys_mmap(16) as *i64
  let on: *i64 = sys_mmap(16) as *i64
  let st: *i64 = sys_mmap(8 * ZG_ST_N) as *i64
  let m1: i64 = zg_walk(b1, n1, ot, on, st)
  gv_check("lzma2-archive-walks (rows>0)" as *u8, (m1 > 0) as i64, ctr)
  let res: *i64 = sys_mmap(8 * 16) as *i64
  if m1 > 0 {
      zg_census(ot[0] as *i64, m1, res)
      gv_kv("t1_rows" as *u8, m1); gv_kv("t1_data" as *u8, res[0]); gv_kv("t1_ok" as *u8, res[1]); gv_kv("t1_failed" as *u8, res[3])
      gv_kv("t1_unsupported" as *u8, res[4]); gv_kv("t1_digests" as *u8, res[5]); gv_kv("t1_folders" as *u8, st[2]); gv_kv("t1_encoded_header" as *u8, st[3]); gv_kv("t1_dirs" as *u8, st[0])
      gv_check("fixture-reached-the-condition: at least one data member" as *u8, (res[0] > 0) as i64, ctr)
      gv_check("fixture-reached-the-condition: members ride the lzma2 coder" as *u8, (res[8] > 0) as i64, ctr)
      gv_check("fixture-reached-the-condition: the archive carries per-member digests" as *u8, (res[5] > 0) as i64, ctr)
      gv_check_eq("every-data-member-decoded-and-crc-verified (ok == data)" as *u8, res[1], res[0], ctr)
      gv_check_eq("no-member-failed" as *u8, res[3], 0, ctr)
      gv_check_eq("no-member-unsupported" as *u8, res[4], 0, ctr)
      gv_check_eq("every-data-member-yields-exactly-its-declared-size" as *u8, res[6], res[0], ctr)
      gv_check_eq("every-row-carries-a-name" as *u8, res[7], m1, ctr)
      gv_check_eq("partition-sums: data == ok + stored + failed + unsupported" as *u8, res[1] + res[2] + res[3] + res[4], res[0], ctr)
      gv_check_eq("rows == data + empty" as *u8, res[0] + res[10], m1, ctr)
      // determinism: a second walk yields byte-identical member bytes
      let ot2: *i64 = sys_mmap(16) as *i64
      let on2: *i64 = sys_mmap(16) as *i64
      let st2: *i64 = sys_mmap(8 * ZG_ST_N) as *i64
      let m1b: i64 = zg_walk(b1, n1, ot2, on2, st2)
      var same: i64 = 0
      if m1b == m1 {
          same = 1
          var i: i64 = 0
          while i < m1 {
              let ra: *i64 = bi_rec(ot[0] as *i64, i)
              let rb: *i64 = bi_rec(ot2[0] as *i64, i)
              if ra[BI_F_DLEN] != rb[BI_F_DLEN] { same = 0 }
              else {
                  let da: *u8 = ra[BI_F_DATA] as *u8
                  let db: *u8 = rb[BI_F_DATA] as *u8
                  var k: i64 = 0
                  while k < ra[BI_F_DLEN] { if da[k] != db[k] { same = 0; break } k = k + 1 }
              }
              i = i + 1
          }
      }
      gv_check("walk-is-deterministic (second walk byte-identical)" as *u8, same, ctr)
  }
  // ---- 3. the Copy-coder archive ----
  let ot3: *i64 = sys_mmap(16) as *i64
  let on3: *i64 = sys_mmap(16) as *i64
  let st3: *i64 = sys_mmap(8 * ZG_ST_N) as *i64
  let m2: i64 = zg_walk(b2, n2, ot3, on3, st3)
  gv_check("copy-archive-walks (rows>0)" as *u8, (m2 > 0) as i64, ctr)
  let res2: *i64 = sys_mmap(8 * 16) as *i64
  if m2 > 0 {
      zg_census(ot3[0] as *i64, m2, res2)
      gv_kv("cp_rows" as *u8, m2); gv_kv("cp_data" as *u8, res2[0]); gv_kv("cp_stored" as *u8, res2[2]); gv_kv("cp_copy_coder" as *u8, res2[9]); gv_kv("cp_encoded_header" as *u8, st3[3])
      gv_check("fixture-reached-the-condition: copy archive has a data member" as *u8, (res2[0] > 0) as i64, ctr)
      gv_check_eq("copy-members-ride-the-copy-coder" as *u8, res2[9], res2[0], ctr)
      gv_check_eq("copy-members-read-in-place-and-crc-verified (stored == data)" as *u8, res2[2], res2[0], ctr)
      gv_check_eq("copy-archive-no-failures" as *u8, res2[3] + res2[4], 0, ctr)
  }
  // ---- 3b. the rung's done-rule fixture: an OBJ, its MTL, four PNG maps and a VMD in a 7z the estate wrote itself (Copy
  //          coder), walked to the SAME typed partition MD1's zip fixture reaches, textures bound through the MTL ----
  let fnames: *i64 = sys_mmap(8 * 8) as *i64
  let fdatas: *i64 = sys_mmap(8 * 8) as *i64
  let flens: *i64 = sys_mmap(8 * 8) as *i64
  let obj: *u8 = "v 0 0 0\nv 1 0 0\nv 0 1 0\nf 1 2 3\n" as *u8
  let mtl: *u8 = "newmtl skin\nmap_Kd skin.png\n" as *u8
  let vmdsrc: *u8 = "Vocaloid Motion Data 0002" as *u8
  let vmd: *u8 = sys_mmap(64)
  var vi: i64 = 0
  while vi < ZG_VMD_MAGIC_LEN { vmd[vi] = vmdsrc[vi]; vi = vi + 1 }
  let png: *u8 = sys_mmap(64)
  png[0] = 137 as u8; png[1] = 80 as u8; png[2] = 78 as u8; png[3] = 71 as u8; png[4] = 13 as u8; png[5] = 10 as u8; png[6] = 26 as u8; png[7] = 10 as u8
  var pk: i64 = 8
  while pk < ZG_PNG_LEN { png[pk] = (pk * 7 % 251) as u8; pk = pk + 1 }
  let nm0: *u8 = "cube.obj" as *u8
  let nm1: *u8 = "cube.mtl" as *u8
  let nm2: *u8 = "skin.png" as *u8
  let nm3: *u8 = "maps/normal.png" as *u8
  let nm4: *u8 = "maps/rough.png" as *u8
  let nm5: *u8 = "maps/ao.png" as *u8
  let nm6: *u8 = "dance.vmd" as *u8
  fnames[0] = nm0 as i64; fdatas[0] = obj as i64; flens[0] = zg_len(obj)
  fnames[1] = nm1 as i64; fdatas[1] = mtl as i64; flens[1] = zg_len(mtl)
  fnames[2] = nm2 as i64; fdatas[2] = png as i64; flens[2] = ZG_PNG_LEN
  fnames[3] = nm3 as i64; fdatas[3] = png as i64; flens[3] = ZG_PNG_LEN
  fnames[4] = nm4 as i64; fdatas[4] = png as i64; flens[4] = ZG_PNG_LEN
  fnames[5] = nm5 as i64; fdatas[5] = png as i64; flens[5] = ZG_PNG_LEN
  fnames[6] = nm6 as i64; fdatas[6] = vmd as i64; flens[6] = ZG_VMD_LEN
  let tbuf: *u8 = sys_mmap(ZG_TYPED_CAP)
  let tn: i64 = sz_write_copy(fnames, fdatas, flens, ZG_TYPED_N, tbuf, ZG_TYPED_CAP)
  gv_check("typed-fixture-written-by-the-copy-writer (bytes>0)" as *u8, (tn > 0) as i64, ctr)
  gv_kv("typed_bytes" as *u8, tn)
  if tn > 0 {
      zg_write_file(ZG_TYPED, tbuf, tn)
      gv_check("typed-fixture-carries-the-signature" as *u8, sz_is_7z(tbuf, tn), ctr)
      gv_check_eq("typed-fixture-counts-7-members" as *u8, sz_count(tbuf, tn), ZG_TYPED_N, ctr)
      let ot4: *i64 = sys_mmap(16) as *i64
      let on4: *i64 = sys_mmap(16) as *i64
      let st4: *i64 = sys_mmap(8 * ZG_ST_N) as *i64
      let m4: i64 = zg_walk(tbuf, tn, ot4, on4, st4)
      gv_check_eq("typed-fixture-walks-7-rows" as *u8, m4, ZG_TYPED_N, ctr)
      if m4 == ZG_TYPED_N {
          let t4: *i64 = ot4[0] as *i64
          let nm4b: *u8 = on4[0] as *u8
          bi_bind_textures(t4, m4, nm4b)
          let part: *i64 = sys_mmap(8 * BI_P_N) as *i64
          let psum: i64 = bi_partition(t4, m4, part)
          gv_check_eq("typed-partition-sums-to-the-member-count" as *u8, psum, ZG_TYPED_N, ctr)
          gv_check_eq("typed-partition-model-1 (the OBJ typed by its bytes)" as *u8, part[BI_P_MODEL], 1, ctr)
          gv_check_eq("typed-partition-material-1 (the MTL)" as *u8, part[BI_P_MATERIAL], 1, ctr)
          gv_check_eq("typed-partition-texture-4 (the PNG magics)" as *u8, part[BI_P_TEXTURE], 4, ctr)
          gv_check_eq("typed-partition-motion-1 (the VMD)" as *u8, part[BI_P_MOTION], 1, ctr)
          gv_check_eq("typed-partition-unknown-0" as *u8, part[BI_P_UNKNOWN], 0, ctr)
          gv_check_eq("typed-members-all-stored-and-crc-verified" as *u8, part[BI_P_STORED], ZG_TYPED_N, ctr)
          gv_check_eq("typed-members-none-failed" as *u8, part[BI_P_FAILED], 0, ctr)
          gv_check_eq("typed-skin.png-bound-through-the-MTL (bound 1)" as *u8, part[BI_P_BOUND], 1, ctr)
          gv_check_eq("typed-three-maps-unbound (nothing references them)" as *u8, part[BI_P_UNBOUND], 3, ctr)
          let rm: *i64 = bi_rec(t4, 3)
          gv_check_eq("typed-utf16-path-name-round-trips (maps/normal.png = 15 bytes)" as *u8, rm[BI_F_NAMELEN], zg_len(nm3), ctr)
      }
      // the bundle walker as the third witness: it must dispatch on the MAGIC and reach the same partition
      let belf: *u8 = zg_ladder(ZG_BI_LIVE, ZG_BI_STAGE, ZG_BI_BUILD)
      gv_need("bundle-walker-witness-present (live, staged or build fossil of nx_bundle_ingest)" as *u8, ((belf as i64) != 0) as i64, ctr)
      if (belf as i64) != 0 {
          let out3: *u8 = sys_mmap(ZG_CAP)
          let bl3: *i64 = sys_mmap(16) as *i64
          let rcb: i64 = gk_run_capture(belf, ZG_TYPED, 0 as *u8, 0 as *u8, 0 as *u8, out3, ZG_CAP, bl3)
          gv_check_eq("bundle-walker-exits-0-on-the-typed-7z" as *u8, rcb, 0, ctr)
          gv_check("bundle-walker-names-the-container-7z" as *u8, gk_out_has(out3, bl3[0], "container=7z" as *u8), ctr)
          gv_check("bundle-walker-reaches-the-typed-partition (model=1 material=1 texture=4 motion=1)" as *u8, gk_out_has(out3, bl3[0], "model=1 material=1 texture=4 motion=1" as *u8), ctr)
          gv_check("bundle-walker-partition-sums-to-7" as *u8, gk_out_has(out3, bl3[0], "sum=7" as *u8), ctr)
          gv_check("bundle-walker-binds-the-skin-map (textures_bound=1)" as *u8, gk_out_has(out3, bl3[0], "textures_bound=1" as *u8), ctr)
      }
  }
  // ---- 3c. the x86 BCJ branch converter, transliterated from the mirrored Bra86.c: proven by ROUND-TRIP against its own
  //          encode direction on a buffer carrying CALL/JMP rel32 patterns -- a self-consistency proof, not an outside oracle;
  //          a real 7z with a BCJ folder written by 7-Zip is the oracle still owed and is named on the board ----
  let xb: *u8 = sys_mmap(512)
  let xo: *u8 = sys_mmap(512)
  var xi: i64 = 0
  while xi < 400 { xb[xi] = ((xi * 37 + 11) % 251) as u8; xi = xi + 1 }
  // plant six CALL rel32 and two JMP rel32 sites whose top byte is 00 or FF (the converter only touches those)
  var site: i64 = 8
  var planted: i64 = 0
  while site + 5 < 380 {
      if (planted & 1) == 0 { xb[site] = 232 as u8 } else { xb[site] = 233 as u8 }
      xb[site + 1] = ((site * 3) % 256) as u8; xb[site + 2] = 1 as u8; xb[site + 3] = 0 as u8
      if (planted & 2) == 0 { xb[site + 4] = 0 as u8 } else { xb[site + 4] = 255 as u8 }
      planted = planted + 1
      site = site + 47
  }
  xi = 0
  while xi < 400 { xo[xi] = xb[xi]; xi = xi + 1 }
  let xs: *i64 = sys_mmap(16) as *i64
  xs[0] = 0
  let enc_n: i64 = lz_bcj_x86(xb, 400, 0, xs, 1)
  var changed: i64 = 0
  xi = 0
  while xi < 400 { if xb[xi] != xo[xi] { changed = changed + 1 } xi = xi + 1 }
  gv_kv("bcj_sites_planted" as *u8, planted); gv_kv("bcj_bytes_changed_by_encode" as *u8, changed); gv_kv("bcj_encode_processed" as *u8, enc_n)
  gv_check("fixture-reached-the-condition: bcj encode changed bytes (the planted rel32 sites were converted)" as *u8, (changed > 0) as i64, ctr)
  gv_check("bcj-encode-processed-the-buffer-up-to-the-four-byte-tail" as *u8, (enc_n >= 400 - 4 - 4) as i64, ctr)
  xs[0] = 0
  lz_bcj_x86(xb, 400, 0, xs, 0)
  var back: i64 = 1
  xi = 0
  while xi < 400 { if xb[xi] != xo[xi] { back = 0 } xi = xi + 1 }
  gv_check("bcj-decode-restores-the-original-byte-for-byte (round trip over 400 bytes)" as *u8, back, ctr)
  xs[0] = 0
  gv_check_eq("bcj-refuses-a-buffer-shorter-than-five-bytes (returns 0, touches nothing)" as *u8, lz_bcj_x86(xb, 4, 0, xs, 0), 0, ctr)
  gv_check("bcj-chain-coder-class-is-named" as *u8, gk_out_has(sz_coder_name(SZ_CODER_BCJ_X86), 12, "bcj-x86+lzma" as *u8), ctr)
  // ---- 4. named refusals, planted at runtime on the real archive ----
  let cut: *u8 = zg_twin(b1, n1, 0 - 1, ZG_CUT)
  gv_check_eq("neg-control-container-cut-before-its-end-header-is-refused-by-name" as *u8, sz_count(cut, n1 - 1), SZ_ERR_TRUNCATED, ctr)
  gv_check_eq("neg-control-half-a-container-is-refused-by-name" as *u8, sz_count(cut, n1 / 2), SZ_ERR_TRUNCATED, ctr)
  let bs: *u8 = zg_twin(b1, n1, ZG_START_CRC_OFF, ZG_BADSTART)
  gv_check_eq("neg-control-forged-start-header-crc-is-refused-by-name" as *u8, sz_count(bs, n1), SZ_ERR_START_CRC, ctr)
  let bh: *u8 = zg_twin(b1, n1, n1 - 1, ZG_BADHDR)
  gv_check_eq("neg-control-forged-header-byte-is-refused-by-name (header crc)" as *u8, sz_count(bh, n1), SZ_ERR_HEADER_CRC, ctr)
  let bp: *u8 = zg_twin(b1, n1, ZG_FIRST_PACK_OFF, ZG_BADPACK)
  let otp: *i64 = sys_mmap(16) as *i64
  let onp: *i64 = sys_mmap(16) as *i64
  let stp: *i64 = sys_mmap(8 * ZG_ST_N) as *i64
  let mp: i64 = zg_walk(bp, n1, otp, onp, stp)
  var corrupt_seen: i64 = 0
  var corrupt_how: i64 = 0
  if mp < 0 { corrupt_seen = 1; corrupt_how = 1 }
  else {
      let resp: *i64 = sys_mmap(8 * 16) as *i64
      zg_census(otp[0] as *i64, mp, resp)
      if resp[3] > 0 { corrupt_seen = 1; corrupt_how = 2 }
  }
  gv_kv("badpack_named_by" as *u8, corrupt_how)
  gv_check("neg-control-corrupted-packed-byte-is-never-read-clean (header refused=1 or a member FAILED its digest=2)" as *u8, corrupt_seen, ctr)
  // the cut twin was written by this gate to disk at full length; the cut is applied by LENGTH at the call, so the disk file
  // is the full archive and the on-disk witness below (the command's cut run) needs a genuinely short file
  let cutn: i64 = n1 - 1
  zg_write_file(ZG_CUT, cut, cutn)
  let lc: *i64 = sys_mmap(16) as *i64
  let cb: *u8 = sys_read_file(ZG_CUT, lc)
  var cut_ok: i64 = 0
  if (cb as i64) != 0 { if lc[0] == cutn { cut_ok = 1 } }
  gv_check("fixture-reached-the-condition: the cut twin on disk is one byte short" as *u8, cut_ok, ctr)
  // ---- 5. the command as a second witness, through the ladder ----
  let elf: *u8 = zg_ladder(ZG_ELF_LIVE, ZG_ELF_STAGE, ZG_ELF_BUILD)
  gv_need("cli-witness-present (live, staged or build fossil of nx_sevenz)" as *u8, ((elf as i64) != 0) as i64, ctr)
  if (elf as i64) != 0 {
      let out2: *u8 = sys_mmap(ZG_CAP)
      let bl2: *i64 = sys_mmap(16) as *i64
      let rcl: i64 = gk_run_capture(elf, "list" as *u8, ZG_T1, 0 as *u8, 0 as *u8, out2, ZG_CAP, bl2)
      gv_check_eq("cli-list-exits-0-on-the-real-archive" as *u8, rcl, 0, ctr)
      gv_check("cli-summary-reads-GREEN" as *u8, gk_out_has(out2, bl2[0], "verdict=GREEN" as *u8), ctr)
      gv_check("cli-summary-names-the-coder" as *u8, gk_out_has(out2, bl2[0], "coder=lzma2" as *u8), ctr)
      let rcc: i64 = gk_run_capture(elf, "list" as *u8, ZG_CUT, 0 as *u8, 0 as *u8, out2, ZG_CAP, bl2)
      gv_check_eq("cli-refuses-the-cut-container-with-exit-3" as *u8, rcc, 3, ctr)
      gv_check("cli-names-the-cut-refusal" as *u8, gk_out_has(out2, bl2[0], "SEVENZ-REFUSE truncated" as *u8), ctr)
      // extract member 0 and re-hash it with the archive's own crc
      let rce: i64 = gk_run_capture(elf, "extract" as *u8, ZG_T1, "0" as *u8, ZG_M0, out2, ZG_CAP, bl2)
      gv_check_eq("cli-extract-exits-0" as *u8, rce, 0, ctr)
      if m1 > 0 {
          let r0: *i64 = bi_rec(ot[0] as *i64, 0)
          let lm: *i64 = sys_mmap(16) as *i64
          let mb: *u8 = sys_read_file(ZG_M0, lm)
          var mlen: i64 = 0 - 1
          var mcrc: i64 = 0 - 1
          if (mb as i64) != 0 { mlen = lm[0]; mcrc = nxzip_crc32(mb, mlen) }
          gv_check_eq("extracted-member-0-has-its-declared-size" as *u8, mlen, r0[BI_F_USIZE], ctr)
          gv_check_eq("extracted-member-0-rehashes-to-the-archive-digest" as *u8, mcrc, r0[BI_F_CRC], ctr)
      }
  }
  return gv_verdict("NX-SEVENZ" as *u8, ctr, "two real py7zr archives (lzma2 with an encoded header, copy coder) walk through the one container reader and the one decoder to members that match the archive's own digests, the rung's typed fixture reaches MD1's partition through the lib and the bundle walker, every planted corruption is refused by name, and the command agrees through the ladder" as *u8)
363}
nx_sevenz_gate.nx source

`nx_sevenz_gate.nx` source
