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

↩ module page · 288 lines · 9724 B
1// nx_coe_frame.nx -- CHAIN-OF-EVIDENCE FRAME (F701 keystone + F702 signature, v1)
2// Emits a 5-pillar evidence frame as an ed25519-SIGNED row on an append-only CID hash-chain, then
3// VERIFIES the whole chain deny-by-default: re-hash every row (integrity) + ed25519_verify every
4// signature (authenticity) + check prev-hash linkage (chain). A forged OR tampered row -> RED.
5// Pillars: provenance | custody | environment | content-CID (immutability) | corroboration (re-hash + sig).
6// v1 signs with a dedicated deterministic CoE key (RFC-8032 ed25519, reproducible; pubkey printed).
7// Honest: production key custody (offline private seed / vault) = F702b. Append-only, never deletes.
8// Composes proven libs: nx_str/nx_syscalls/nx_sha256 + nx_ed25519_signature (via nx_fw_capsule lineage).
9// x86-lane. license_tier: ORIGINAL
10import "nx_str.nx"
11import "nx_itoa_lib.nx"   // shared MSB-first emitter (zero-alloc)
12import "nx_syscalls.nx"
13import "nx_sha256.nx"
14import "nx_ed25519_signature.nx"
15const CF_MAGIC_1024: i64 = 1024
16const CF_MAGIC_1500: i64 = 1500
17
18const CF_CAP: i64 = 1048576
19const CF_MAXROWS: i64 = 4096
20
21func cf_puts(s: *u8) -> i64 { sys_write(1, s, nx_str_len(s)); return 0 }
22
23// MIGRATED to the shared emitter (debt 1785563586). The old body mmapped a scratch buffer
24// per call and never freed it. At PAGE granularity that is 4096B leaked PER CALL -- the
25// defect that took 28.5GB of a 36GB host in nx_ts_lumadiff (2MB input, ~3.66M calls).
26// nxi_* is MSB-first, allocates NOTHING, and emits identical bytes including the sign.
27func cf_pi(v: i64) -> i64 { nxi_out(v); return 0 }
28
29func cf_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
33}
34
35func cf_catn(dst: *u8, off: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(32)
  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 { dst[off+i] = t[k-1-i]; i = i + 1 }
  return off + k
44}
45
46// n bytes -> 2n lowercase hex into out, NUL-terminated
47func cf_hexn(d: *u8, n: i64, out: *u8) -> i64 {
  let hx: *u8 = "0123456789abcdef" as *u8
  var i: i64 = 0
  while i < n {
      let b: i64 = d[i] as i64
      out[i*2] = hx[(b >> 4) & 15]
      out[i*2+1] = hx[b & 15]
      i = i + 1
  }
  out[n*2] = 0 as u8
  return n*2
58}
59
60func cf_nib(c: i64) -> i64 {
  if c >= 97 { return c - 87 }
  return c - 48
63}
64
65// 2n hex chars in -> n bytes into out
66func cf_unhex(hexin: *u8, hexlen: i64, out: *u8) -> i64 {
  var i: i64 = 0
  let n: i64 = hexlen / 2
  while i < n {
      let hi: i64 = cf_nib(hexin[i*2] as i64)
      let lo: i64 = cf_nib(hexin[i*2+1] as i64)
      out[i] = ((hi * 16) + lo) as u8
      i = i + 1
  }
  return n
76}
77
78func cf_hash_hex(buf: *u8, n: i64, out: *u8) -> i64 {
  let dg: *u8 = sys_mmap(32)
  sha256_digest(buf, n, dg)
  cf_hexn(dg, 32, out)
  return 64
83}
84
85func cf_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) {
      if a[i] != b[i] { return 0 }
      i = i + 1
  }
  if b[i] != (0 as u8) { return 0 }
  return 1
93}
94
95func cf_copy(dst: *u8, src: *u8) -> i64 {
  var i: i64 = 0
  while src[i] != (0 as u8) { dst[i] = src[i]; i = i + 1 }
  dst[i] = 0 as u8
  return i
100}
101
102func cf_line_end(b: *u8, i0: i64, n: i64) -> i64 {
  var e: i64 = i0
  while e < n { if b[e] == (10 as u8) { return e } e = e + 1 }
  return n
106}
107
108func cf_find_tab(b: *u8, i0: i64, e: i64) -> i64 {
  var j: i64 = i0
  while j < e { if b[j] == (9 as u8) { return j } j = j + 1 }
  return e
112}
113
114func cf_slice(b: *u8, i0: i64, e: i64, dst: *u8) -> i64 {
  var o: i64 = 0
  var j: i64 = i0
  while j < e { dst[o] = b[j]; o = o + 1; j = j + 1 }
  dst[o] = 0 as u8
  return o
120}
121
122// dedicated CoE signing seed (deterministic v1; distinct from the platform key)
123func cf_coe_seed(out: *u8) -> i64 {
  var i: i64 = 0
  while i < 32 { out[i] = ((i * 11 + 29) & 0xff) as u8; i = i + 1 }
  return 0
127}
128
129// scan plane [0,n): copy last row's frame-hash (field 0) into lastfh (or GENESIS); return row count
130func cf_scan_last(vb: *u8, n: i64, lastfh: *u8) -> i64 {
  cf_copy(lastfh, "GENESIS" as *u8)
  var i: i64 = 0
  var rows: i64 = 0
  while i < n {
      let e: i64 = cf_line_end(vb, i, n)
      if e > i {
          let t: i64 = cf_find_tab(vb, i, e)
          if t < e { cf_slice(vb, i, t, lastfh); rows = rows + 1 }
      }
      i = e + 1
  }
  return rows
143}
144
145func main() -> i64 {
  cf_puts("=== COE-FRAME v1 (F701+F702): ed25519-signed 5-pillar CID hash-chain ===\n" as *u8)
  let plane: *u8 = "knowledge/status/coe_signed.log" as *u8
148
  let seed: *u8 = sys_mmap(32)
  cf_coe_seed(seed)
  let pub: *u8 = sys_mmap(32)
  ed25519_pub_from_priv(seed, pub)
  let pubhex: *u8 = sys_mmap(72)
  cf_hexn(pub, 32, pubhex)
155
  let lenp: *i64 = sys_mmap(16) as *i64
  lenp[0] = 0
  let buf: *u8 = sys_read_file(plane, lenp)
  var n: i64 = lenp[0]
  if n < 0 { n = 0 }
  if n > CF_CAP { n = CF_CAP }
162
  let prevfh: *u8 = sys_mmap(80)
  let seq: i64 = cf_scan_last(buf, n, prevfh)
165
  let now: i64 = sys_now_realtime_sec()
  let pay: *u8 = sys_mmap(256)
  var po: i64 = 0
  po = cf_cat(pay, po, "coe-selftest-payload-" as *u8)
  po = cf_catn(pay, po, now)
  pay[po] = 0 as u8
  let cid: *u8 = sys_mmap(80)
  cf_hash_hex(pay, po, cid)
174
  // record = prev \t cid \t seq \t now \t pillars ; fh = sha256(record) ; sig = ed25519(record)
  let rec: *u8 = sys_mmap(CF_MAGIC_1024)
  var ro: i64 = 0
  ro = cf_cat(rec, ro, prevfh)
  rec[ro] = 9 as u8; ro = ro + 1
  ro = cf_cat(rec, ro, cid)
  rec[ro] = 9 as u8; ro = ro + 1
  ro = cf_catn(rec, ro, seq)
  rec[ro] = 9 as u8; ro = ro + 1
  ro = cf_catn(rec, ro, now)
  rec[ro] = 9 as u8; ro = ro + 1
  ro = cf_cat(rec, ro, "prov=organ:nx_coe_frame;cust=cap;env=nas;corr=rehash+ed25519" as *u8)
  rec[ro] = 0 as u8
188
  let fh: *u8 = sys_mmap(80)
  cf_hash_hex(rec, ro, fh)
  let sig: *u8 = sys_mmap(64)
  ed25519_sign_full(seed, rec, ro, sig)
  let sighex: *u8 = sys_mmap(160)
  cf_hexn(sig, 64, sighex)
195
  // line = fh \t sighex \t rec \n
  let line: *u8 = sys_mmap(CF_MAGIC_1500)
  var lo: i64 = 0
  lo = cf_cat(line, lo, fh)
  line[lo] = 9 as u8; lo = lo + 1
  lo = cf_cat(line, lo, sighex)
  line[lo] = 9 as u8; lo = lo + 1
  lo = cf_cat(line, lo, rec)
  line[lo] = 10 as u8; lo = lo + 1
205
  let fd: i64 = sys_openat_append(plane, 0x1a4)
  if fd < 0 { cf_puts("COE-FRAME RED reason=no-plane\n" as *u8); sys_exit(1); return 1 }
  sys_write(fd, line, lo)
  sys_close(fd)
  cf_puts(" emitted seq=" as *u8); cf_pi(seq)
  cf_puts(" cid=" as *u8); cf_puts(cid)
  cf_puts(" frame=" as *u8); cf_puts(fh)
  cf_puts(" sig=" as *u8); cf_puts(sighex); cf_puts("\n" as *u8)
214
  // --- VERIFY whole chain: integrity (re-hash) + authenticity (ed25519) + linkage ---
  lenp[0] = 0
  let vb: *u8 = sys_read_file(plane, lenp)
  var vn: i64 = lenp[0]
  if vn < 0 { vn = 0 }
  var truncated: i64 = 0
  if vn > CF_CAP { vn = CF_CAP; truncated = 1 }
222
  let sfh: *u8 = sys_mmap(80)
  let rfh: *u8 = sys_mmap(80)
  let shx: *u8 = sys_mmap(160)
  let sbytes: *u8 = sys_mmap(64)
  let pfld: *u8 = sys_mmap(80)
  let carry: *u8 = sys_mmap(80)
  cf_copy(carry, "GENESIS" as *u8)
  var i: i64 = 0
  var rows: i64 = 0
  var okhash: i64 = 1
  var oksig: i64 = 1
  var oklink: i64 = 1
  var capped: i64 = 0
  while i < vn {
      let e: i64 = cf_line_end(vb, i, vn)
      if e > i {
          if rows < CF_MAXROWS {
              let t1: i64 = cf_find_tab(vb, i, e)
              if t1 < e {
                  let t2: i64 = cf_find_tab(vb, t1 + 1, e)
                  if t2 < e {
                      cf_slice(vb, i, t1, sfh)
                      cf_slice(vb, t1 + 1, t2, shx)
                      let rs: i64 = t2 + 1
                      let reclen: i64 = e - rs
                      let recp: *u8 = ((vb as i64) + rs) as *u8
                      cf_hash_hex(recp, reclen, rfh)
                      if cf_eq(sfh, rfh) == 0 { okhash = 0 }
                      cf_unhex(shx, 128, sbytes)
                      if ed25519_verify_full(pub, recp, reclen, sbytes) == NX_ED25519_SIG_OK {
                      } else { oksig = 0 }
                      let pt: i64 = cf_find_tab(vb, rs, e)
                      cf_slice(vb, rs, pt, pfld)
                      if cf_eq(pfld, carry) == 0 { oklink = 0 }
                      cf_copy(carry, sfh)
                      rows = rows + 1
                  }
              }
          }
          if rows >= CF_MAXROWS { capped = 1 }
      }
      i = e + 1
  }
266
  cf_puts(" pubkey=" as *u8); cf_puts(pubhex); cf_puts("\n" as *u8)
  if okhash == 1 {
      if oksig == 1 {
          if oklink == 1 {
              cf_puts("COE-FRAME GREEN frames=" as *u8); cf_pi(rows)
              cf_puts(" chain=OK signed=ed25519 sig-verify=OK bytes=" as *u8); cf_pi(vn)
              cf_puts(" envelope=cap:" as *u8); cf_pi(CF_CAP)
              cf_puts("/maxrows:" as *u8); cf_pi(CF_MAXROWS)
              if truncated == 1 { cf_puts(" TRUNCATED" as *u8) }
              if capped == 1 { cf_puts(" ROWCAP" as *u8) }
              cf_puts("\n" as *u8)
              return 0
          }
      }
  }
  cf_puts("COE-FRAME RED hash=" as *u8); cf_pi(okhash)
  cf_puts(" sig=" as *u8); cf_pi(oksig)
  cf_puts(" link=" as *u8); cf_pi(oklink)
  cf_puts(" frames=" as *u8); cf_pi(rows); cf_puts("\n" as *u8)
  sys_exit(1)
  return 1
288}
nx_coe_frame.nx source

`nx_coe_frame.nx` source
