`nx_pex_gate.nx` source

↩ module page · 159 lines · 8674 B
1// nx_pex_gate.nx -- SOVEREIGN LOOPBACK gate for BEP-11 ut_pex: proves PEX rides the REAL BEP-10
2// extension channel over a real TCP socket (not just the deterministic parser, which nx_pex's baked
3// KAT already covers). A mock peer does the BEP-3 handshake (ext bit) + BEP-10 ext handshake
4// (advertising ut_pex) + sends a real ut_pex ext message carrying a compact peer list; the client
5// dispatches on the ext-id WE advertised, learns the peer's ut_pex id, and pex_parse_added's the
6// gossiped peers. This is the live-channel proof that, once connected to ONE peer, we harvest MORE.
7// license_tier: ORIGINAL
8//
9// module: nishi-core.torrent.pex_gate
10// depends: nishi-core.torrent.pex, nishi-core.torrent.peerwire
11import "nx_pex.nx"
12import "nx_connect.nx"   // bounded connect: a raw sys_connect hangs ~127s on a black-holed host
13import "nx_peerwire.nx"
14import "nx_gate_verdict.nx"
15
16const PW_EXTENDED: i64 = 20
17
18func gx_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
19func gx_wn(fd: i64, v: i64) -> i64 {
  let t: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m; sys_write(fd, "-" as *u8, 1) }
  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 }
  let b: *u8 = sys_mmap(28); var i: i64 = 0; while i < k { b[i] = t[k - 1 - i]; i = i + 1 }; sys_write(fd, b, k); return 0
23}
24func gx_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
25func gx_sockaddr(sa: *u8, port: i64, i0: i64, i1: i64, i2: i64, i3: i64) -> i64 {
  sa[0] = 2 as u8; sa[1] = 0 as u8
  sa[2] = ((port >> 8) & 0xff) as u8; sa[3] = (port & 0xff) as u8
  sa[4] = i0 as u8; sa[5] = i1 as u8; sa[6] = i2 as u8; sa[7] = i3 as u8
  var k: i64 = 8; while k < 16 { sa[k] = 0 as u8; k = k + 1 }
  return 0
31}
32func gx_read_n(fd: i64, buf: *u8, n: i64) -> i64 {
  var got: i64 = 0
  while got < n { let r: i64 = sys_read(fd, buf + got, n - got); if r <= 0 { return 0 - 1 } got = got + r }
  return got
36}
37func gx_write_n(fd: i64, buf: *u8, n: i64) -> i64 {
  var off: i64 = 0
  while off < n { let w: i64 = sys_write(fd, buf + off, n - off); if w <= 0 { return 0 - 1 } off = off + w }
  return n
41}
42func gx_read_msg(fd: i64, mb: *u8, cap: i64) -> i64 {
  if gx_read_n(fd, mb, 4) != 4 { return 0 - 1 }
  let blen: i64 = _pw_get_u32(mb, 0)
  if blen == 0 { return 0 }
  if blen > cap - 4 { return 0 - 1 }
  if gx_read_n(fd, mb + 4, blen) != blen { return 0 - 1 }
  return blen
49}
50// build extended message id=20: payload = [ext_id] + ben(benlen); EXPLICIT length (compact peer
51// bytes can contain NUL, so a strlen-based builder would truncate). returns total bytes.
52func px_build_ext(ext_id: i64, ben: *u8, benlen: i64, out: *u8) -> i64 {
  let pl: *u8 = sys_mmap(4096)
  pl[0] = ext_id as u8
  var i: i64 = 0; while i < benlen { pl[1 + i] = ben[i]; i = i + 1 }
  return nx_pw_build_msg(PW_EXTENDED, pl, 1 + benlen, out)
57}
58
59func main() -> i64 {
  let PORT: i64 = 53441
  let ih: *u8 = sys_mmap(20); var z: i64 = 0; while z < 20 { ih[z] = (z + 1) as u8; z = z + 1 }
  let pidb: *u8 = sys_mmap(20); z = 0; while z < 20 { pidb[z] = 80 as u8; z = z + 1 }
  let sa: *u8 = sys_mmap(16); gx_sockaddr(sa, PORT, 127, 0, 0, 1)
64
  // the 3 peers the mock will gossip via PEX
  let gips: *i64 = sys_mmap(8 * 8) as *i64
  let gpts: *i64 = sys_mmap(8 * 8) as *i64
  gips[0] = (11 << 24) | (22 << 16) | (33 << 8) | 44;   gpts[0] = 12345
  gips[1] = (99 << 24) | (88 << 16) | (77 << 8) | 66;   gpts[1] = 6881
  gips[2] = (203 << 24) | (0 << 16) | (113 << 8) | 7;   gpts[2] = 51999
71
  let lfd: i64 = sys_socket(AF_INET, SOCK_STREAM, 0)
  var bound: i64 = 0
  if lfd >= 0 {
      let one: *u8 = sys_mmap(4); one[0] = 1 as u8; one[1] = 0 as u8; one[2] = 0 as u8; one[3] = 0 as u8
      sys_setsockopt(lfd, SOL_SOCKET, 2, one, 4)
      sys_set_socket_timeout(lfd, 3)
      if sys_bind(lfd, sa, 16) >= 0 { if sys_listen(lfd, 1) >= 0 { bound = 1 } }
  }
  if bound == 0 { gx_w(1, "PEX-GATE authored=organ bound=0 verdict=RED\n" as *u8); sys_exit(1); return 1 }
81
  let pid: i64 = sys_fork()
  if pid == 0 {
      // ---- MOCK PEER ----
      let afd: i64 = sys_accept(lfd)
      if afd >= 0 {
          sys_set_socket_timeout(afd, 3)
          let hb: *u8 = sys_mmap(128); gx_read_n(afd, hb, 68)
          let oh: *u8 = sys_mmap(128); nx_pw_build_handshake(ih, pidb, oh); oh[25] = (oh[25] as i64 | 0x10) as u8; gx_write_n(afd, oh, 68)
          let cmb: *u8 = sys_mmap(512); gx_read_msg(afd, cmb, 512)        // client ext handshake
          // mock's own ext handshake: advertise ut_pex=7 (so the client can learn our id)
          let mben: *u8 = "d1:md6:ut_pexi7eee" as *u8
          let om: *u8 = sys_mmap(512); let oml: i64 = px_build_ext(0, mben, gx_len(mben), om); gx_write_n(afd, om, oml)
          // mock's PEX message: ext-id = PEX_OUR_ID (the id the client advertised for incoming ut_pex)
          let pdict: *u8 = sys_mmap(512); let pdl: i64 = pex_build_added(gips, gpts, 3, pdict)
          let pm: *u8 = sys_mmap(512); let pml: i64 = px_build_ext(PEX_OUR_ID, pdict, pdl, pm); gx_write_n(afd, pm, pml)
          sys_close(afd)
      }
      sys_close(lfd)
      sys_exit(0)
  }
102
  // ---- CLIENT ----
  let cfd: i64 = sys_socket(AF_INET, SOCK_STREAM, 0)
  sys_set_socket_timeout(cfd, 3)
  var conn_ok: i64 = 0
  if nx_connect_bounded(cfd, sa, 16, NX_CONN_DEFAULT_MS) >= 0 { conn_ok = 1 }
  var hs_ok: i64 = 0; var ext_ok: i64 = 0; var peer_id_ok: i64 = 0
  var pex_count: i64 = 0; var p0_ok: i64 = 0; var p2_ok: i64 = 0
  if conn_ok == 1 {
      let ch: *u8 = sys_mmap(128); nx_pw_build_handshake(ih, pidb, ch); ch[25] = (ch[25] as i64 | 0x10) as u8; gx_write_n(cfd, ch, 68)
      let ph: *u8 = sys_mmap(128)
      if gx_read_n(cfd, ph, 68) == 68 {
          let gih: *u8 = sys_mmap(20); let gpid: *u8 = sys_mmap(20)
          if nx_pw_parse_handshake(ph, 68, gih, gpid) == 1 { hs_ok = 1 }
      }
      if hs_ok == 1 {
          // advertise ut_metadata=1 + ut_pex=PEX_OUR_ID(3); keys sorted (ut_metadata < ut_pex)
          let cben: *u8 = "d1:md11:ut_metadatai1e6:ut_pexi3eee" as *u8
          let cm: *u8 = sys_mmap(512); let cml: i64 = px_build_ext(0, cben, gx_len(cben), cm); gx_write_n(cfd, cm, cml)
          // msg1: peer ext handshake (id20 ext-id0) -> learn peer ut_pex id
          let mb1: *u8 = sys_mmap(512); let bl1: i64 = gx_read_msg(cfd, mb1, 512)
          if bl1 > 2 { if nx_pw_msg_id(mb1) == PW_EXTENDED { if (mb1[5] as i64) == 0 {
              ext_ok = 1
              if pex_peer_id(mb1, 6, 4 + bl1) == 7 { peer_id_ok = 1 }
          } } }
          // msg2: peer PEX message (id20 ext-id == PEX_OUR_ID) -> harvest gossiped peers
          let mb2: *u8 = sys_mmap(512); let bl2: i64 = gx_read_msg(cfd, mb2, 512)
          if bl2 > 2 { if nx_pw_msg_id(mb2) == PW_EXTENDED { if (mb2[5] as i64) == PEX_OUR_ID {
              let oip: *i64 = sys_mmap(8 * 8) as *i64; let opt: *i64 = sys_mmap(8 * 8) as *i64
              pex_count = pex_parse_added(mb2, 6, 4 + bl2, oip, opt, 8)
              if pex_count == 3 {
                  if oip[0] == gips[0] { if opt[0] == gpts[0] { p0_ok = 1 } }
                  if oip[2] == gips[2] { if opt[2] == gpts[2] { p2_ok = 1 } }
              }
          } } }
      }
  }
  let st: *i64 = sys_mmap(16) as *i64; sys_wait4(pid, st, 0); sys_close(cfd); sys_close(lfd)
140
  gx_w(1, "PEX-GATE authored=organ conn_ok=" as *u8); gx_wn(1, conn_ok)
  gx_w(1, " handshake_ok=" as *u8); gx_wn(1, hs_ok)
  gx_w(1, " ext_ok=" as *u8); gx_wn(1, ext_ok)
  gx_w(1, " peer_ut_pex_id_ok=" as *u8); gx_wn(1, peer_id_ok)
  gx_w(1, " pex_count=" as *u8); gx_wn(1, pex_count)
  gx_w(1, " peer0_ok=" as *u8); gx_wn(1, p0_ok)
  gx_w(1, " peer2_ok=" as *u8); gx_wn(1, p2_ok)
  var allok: i64 = 0
  if conn_ok == 1 { if hs_ok == 1 { if ext_ok == 1 { if peer_id_ok == 1 { if pex_count == 3 { if p0_ok == 1 { if p2_ok == 1 { allok = 1 } } } } } } }
  // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check
  // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled
  // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify.
  let ctr__dry: *i64 = gv_ctr()
  ctr__dry[0] = allok
  ctr__dry[1] = 1
  let rc__dry: i64 = gv_verdict("PEX-GATE" as *u8, ctr__dry, "teeth unchanged; verdict emission migrated onto the shared base class" as *u8)
  sys_exit(rc__dry)
  return rc__dry
159}
nx_pex_gate.nx source

`nx_pex_gate.nx` source
