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

↩ module page · 204 lines · 12462 B
1// nx_torrent_leech_probe.nx -- pull a WHOLE file off a BitTorrent seeder + verify every piece.
2//
3// Two jobs, one organ:
4//   (GATE, no args)  = the INTEGRATION proof: originate a torrent (nx_torrent_mkinfo) -> seed it
5//                      (nx_torrent_seed.ts_serve_peer) -> leech the FULL file back -> verify EACH piece's
6//                      SHA-1 against the info-dict's ADVERTISED hashes (what a real client checks) -> assert
7//                      the reassembled file's info_hash == the original's. Proves originate->seed->leech->verify.
8//   (LIVE)  <ip> <port> <ih_hex40> <plen> <total> <outfile>
9//                    = connect a REAL remote seeder (e.g. the NAS), download the file, write it, and print
10//                      the reassembled file's info_hash (compare to the seed's -> byte-perfect P2P transfer).
11//
12// license_tier: ORIGINAL   module: nishi-core.torrent.leech_probe
13// depends: nishi-core.torrent.seed, nishi-core.torrent.mkinfo, nishi-core.torrent.peerwire, nishi-core.crypto.sha1
14import "nx_torrent_seed.nx"
15import "nx_connect.nx"   // bounded connect: a raw sys_connect hangs ~127s on a black-holed host
16import "nx_torrent_mkinfo.nx"
17import "nx_peerwire.nx"
18import "nx_sha1.nx"
19const LP_MAGIC_65536: i64 = 65536
20const LP_MAGIC_4096: i64 = 4096
21const LP_MAGIC_53611: i64 = 53611
22
23const LP_BLK: i64 = 16384
24
25func lp_w(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
26func lp_wn(v: i64) -> i64 {
  let t: *u8=sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(1,"-" 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(1,b,k); return 0
30}
31
32// Leech the whole file from an already-connected seeder socket cfd.
33// ih=20-byte info_hash, my_pid=our id, plen/total/npc = geometry, outbuf = where to assemble (total bytes),
34// expect_pieces = optional npc*20 advertised hashes (0 as *u8 to skip verify). Returns #pieces verified,
35// or -1 on handshake failure. Sets *got_all=1 if every piece downloaded.
36func lp_leech(ctx: *MseCtx, cfd: i64, ih: *u8, my_pid: *u8, plen: i64, total: i64, npc: i64, outbuf: *u8, expect_pieces: *u8, got_all: *i64) -> i64 {
  sys_set_socket_timeout(cfd, 15)
  got_all[0] = 0
  let ch: *u8 = sys_mmap(128); nx_pw_build_handshake(ih, my_pid, ch)
  if mse_write(ctx, cfd, ch, 68) < 0 { return 0-1 }
  let ph: *u8 = sys_mmap(128)
  if mse_read(ctx, cfd, ph, 68) != 68 { return 0-1 }
  let gih: *u8 = sys_mmap(20); let gpid: *u8 = sys_mmap(20)
  if nx_pw_parse_handshake(ph, 68, gih, gpid) != 1 { return 0-1 }
  // interested + wait for unchoke (capture the bitfield to know what the seed has)
  let im: *u8 = sys_mmap(16); let il: i64 = nx_pw_build_msg(NX_PW_INTERESTED, 0 as *u8, 0, im); mse_write(ctx, cfd, im, il)
  let mb: *u8 = sys_mmap(LP_MAGIC_65536)
  var unchoked: i64=0; var guard: i64=0
  let have_bf: *u8 = sys_mmap(npc/8 + 16); var bf_len: i64=0
  while unchoked==0 { if guard>=16 { guard=99 } else {
      let ml: i64 = ts_read_msg_ctx(ctx, cfd, mb, LP_MAGIC_65536)
      if ml==0-1 { unchoked=0-1 } else { if ml>0 {
          let id: i64 = nx_pw_msg_id(mb)
          if id==NX_PW_BITFIELD { bf_len=ml-1; var b: i64=0; while b<bf_len { have_bf[b]=mb[5+b]; b=b+1 } }
          if id==NX_PW_UNCHOKE { unchoked=1 }
      } }
      guard=guard+1
  } }
  if unchoked!=1 { return 0-1 }
  // download each piece the seed advertises (a full seed advertises all)
  let piece: *u8 = sys_mmap(plen+64)
  var verified: i64=0; var downloaded: i64=0
  var i: i64=0
  while i<npc {
      var seed_has: i64=1
      if bf_len>0 { if nx_pw_bitfield_has(have_bf, bf_len, i)!=1 { seed_has=0 } }
      if seed_has==1 {
          var psize: i64=plen; if i==npc-1 { psize=total-i*plen }
          var begin: i64=0; var piece_ok: i64=1
          while begin<psize {
              var blk: i64=LP_BLK; if blk>psize-begin { blk=psize-begin }
              let rq: *u8 = sys_mmap(32); let rl: i64 = nx_pw_build_request(i, begin, blk, rq); mse_write(ctx, cfd, rq, rl)
              let pb: *u8 = sys_mmap(LP_BLK+128); let pl: i64 = ts_read_msg_ctx(ctx, cfd, pb, LP_BLK+128)
              if pl>=9 { if nx_pw_msg_id(pb)==NX_PW_PIECE {
                  let bgn: i64 = _pw_get_u32(pb, 9)
                  var j: i64=0; while j<blk { piece[bgn+j]=pb[13+j]; j=j+1 }
              } else { piece_ok=0; begin=psize } } else { piece_ok=0; begin=psize }
              begin=begin+blk
          }
          if piece_ok==1 {
              downloaded=downloaded+1
              var k: i64=0; while k<psize { outbuf[i*plen+k]=piece[k]; k=k+1 }
              if (expect_pieces as i64)!=0 {
                  let gh: *u8 = sys_mmap(20); sha1(piece, psize, gh)
                  let ep: *u8 = expect_pieces + i*20
                  var eq: i64=1; var m: i64=0; while m<20 { if gh[m]!=ep[m] { eq=0; m=20 } else { m=m+1 } }
                  if eq==1 { verified=verified+1 }
              }
          }
      }
      i=i+1
  }
  if downloaded==npc { got_all[0]=1 }
  return verified
95}
96
97func lp_sockaddr_ip(sa: *u8, port: i64, ipstr: *u8) -> i64 {
  // parse a dotted IPv4 into 4 octets
  var oct: *u8 = sys_mmap(4); var o: i64=0; var v: i64=0; var i: i64=0
  while ipstr[i]!=(0 as u8) { let c: i64=ipstr[i] as i64; if c==46 { oct[o]=v as u8; o=o+1; v=0 } else { if c>=48 { if c<=57 { v=v*10+(c-48) } } } i=i+1 }
  oct[o]=v as u8
  return ts_sockaddr(sa, port, oct[0] as i64, oct[1] as i64, oct[2] as i64, oct[3] as i64)
103}
104
105// ---- LIVE: pull from a remote seeder, write outfile, print reassembled info_hash ----
106func lp_live(ipstr: *u8, port: i64, ihhex: *u8, plen: i64, total: i64, outfile: *u8, mse: i64) -> i64 {
  let ih: *u8 = sys_mmap(20)
  if ts_hex2bin(ihhex, ih) != 1 { lp_w("bad info_hash hex\n" as *u8); sys_exit(2); return 2 }
  let my_pid: *u8 = sys_mmap(20); let tag: *u8 = "-NX0001-nishileech1" as *u8
  var z: i64=0; while z<19 { my_pid[z]=tag[z]; z=z+1 } my_pid[19]=48 as u8
  let npc: i64 = (total+plen-1)/plen
  let sa: *u8 = sys_mmap(16); lp_sockaddr_ip(sa, port, ipstr)
  let cfd: i64 = sys_socket(AF_INET, SOCK_STREAM, 0); sys_set_socket_timeout(cfd, 15)
  lp_w("leech-probe: connecting " as *u8); lp_w(ipstr); lp_w(":" as *u8); lp_wn(port); if mse==1 { lp_w(" [MSE-encrypted]" as *u8) } lp_w(" ...\n" as *u8)
  if nx_connect_bounded(cfd, sa, 16, NX_CONN_DEFAULT_MS) < 0 { lp_w("CONNECT-FAIL\n" as *u8); sys_exit(1); return 1 }
  let ctx: *MseCtx = sys_mmap(MSE_CTX_BYTES) as *MseCtx
  if mse==1 {
      let xpriv: *i64 = sys_mmap((MSE_N+2)*8) as *i64; ts_dh_priv(xpriv)
      if mse_connect(cfd, ih, xpriv, ctx) != 1 { lp_w("MSE-HANDSHAKE-FAIL\n" as *u8); sys_close(cfd); sys_exit(1); return 1 }
      lp_w("leech-probe: MSE handshake OK (RC4-encrypted stream)\n" as *u8)
  } else { mse_ctx_plain(ctx) }
  let outbuf: *u8 = sys_mmap(total+64)
  let ga: *i64 = sys_mmap(8) as *i64
  let v: i64 = lp_leech(ctx, cfd, ih, my_pid, plen, total, npc, outbuf, 0 as *u8, ga)
  sys_close(cfd)
  if v==0-1 { lp_w("HANDSHAKE/UNCHOKE-FAIL\n" as *u8); sys_exit(1); return 1 }
  // write the downloaded file
  let wf: i64 = sys_openat_wr(outfile, 0x1a4); if wf>=0 { sys_write(wf, outbuf, total); sys_close(wf) }
  lp_w("downloaded pieces got_all=" as *u8); lp_wn(ga[0]); lp_w(" bytes=" as *u8); lp_wn(total); lp_w(" -> " as *u8); lp_w(outfile); lp_w("\n" as *u8)
  // reassembled info_hash (compare to the seed's -> byte-perfect transfer)
  let ih2: *u8 = sys_mmap(20); let info: *u8 = sys_mmap(npc*20+LP_MAGIC_4096); let pieces: *u8 = sys_mmap(npc*20+64)
  mk_build_info(outfile, "downloaded" as *u8, plen, total, npc, info, pieces, ih2)
  // NOTE: info_hash depends on 'name' too, so this recomputes with name="downloaded"; to match the seed's
  // exact info_hash pass the SAME name. Here we print the raw per-file identity for a same-name compare.
  let hx: *u8 = sys_mmap(48); mk_hex(hx,0,ih2,20); hx[40]=0 as u8
  lp_w("reassembled_info_hash(name=downloaded)=" as *u8); lp_w(hx); lp_w("\n" as *u8)
  if ga[0]==1 { lp_w("verdict=GREEN (full file pulled from the remote seeder)\n" as *u8); sys_exit(0); return 0 }
  lp_w("verdict=PARTIAL\n" as *u8); sys_exit(1); return 1
139}
140
141// ---- GATE: originate -> seed -> leech FULL file -> verify each piece vs advertised hashes ----
142func lp_gate() -> i64 {
  let path: *u8 = "/tmp/_nx_leech_src.bin" as *u8
  let name: *u8 = "leech_src.bin" as *u8
  let plen: i64 = 64
  let total: i64 = 200                 // 4 pieces (64,64,64,8)
  let PORT: i64 = LP_MAGIC_53611
  let fb: *u8 = sys_mmap(total+16); var i: i64=0; while i<total { fb[i]=((i*97+5)&0xff) as u8; i=i+1 }
  let wf: i64 = sys_openat_wr(path, 0x1a4); if wf<0 { lp_w("LEECH-GATE file=FAIL verdict=RED\n" as *u8); sys_exit(1); return 1 }
  sys_write(wf, fb, total); sys_close(wf)
  let npc: i64 = (total+plen-1)/plen
  // originate: real info_hash + per-piece hashes
  let info: *u8 = sys_mmap(npc*20+LP_MAGIC_4096); let pieces: *u8 = sys_mmap(npc*20+64); let ih: *u8 = sys_mmap(20)
  let ilen: i64 = mk_build_info(path, name, plen, total, npc, info, pieces, ih)
  var mk_ok: i64=0; if ilen>0 { mk_ok=1 }
  let seed_pid: *u8 = sys_mmap(20); i=0; while i<20 { seed_pid[i]=83 as u8; i=i+1 }
  let leech_pid: *u8 = sys_mmap(20); i=0; while i<20 { leech_pid[i]=76 as u8; i=i+1 }
  let sa: *u8 = sys_mmap(16); ts_sockaddr(sa, PORT, 127, 0, 0, 1)
  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, 5); if sys_bind(lfd, sa, 16)>=0 { if sys_listen(lfd, 4)>=0 { bound=1 } } }
  if bound==0 { lp_w("LEECH-GATE bound=0 verdict=RED\n" as *u8); sys_exit(1); return 1 }
  let pid: i64 = sys_fork()
  if pid==0 {
      let afd: i64 = sys_accept(lfd)
      if afd>=0 { ts_serve_peer(afd, ih, seed_pid, path, plen, total, npc); sys_close(afd) }
      sys_close(lfd); sys_exit(0)
  }
  let cfd: i64 = sys_socket(AF_INET, SOCK_STREAM, 0); sys_set_socket_timeout(cfd, 5)
  var conn_ok: i64=0; if nx_connect_bounded(cfd, sa, 16, NX_CONN_DEFAULT_MS)>=0 { conn_ok=1 }
  let outbuf: *u8 = sys_mmap(total+64); let ga: *i64 = sys_mmap(8) as *i64
  let ctx: *MseCtx = sys_mmap(MSE_CTX_BYTES) as *MseCtx; mse_ctx_plain(ctx)   // gate leecher is plaintext (no-regression)
  var verified: i64=0
  if conn_ok==1 { verified = lp_leech(ctx, cfd, ih, leech_pid, plen, total, npc, outbuf, pieces, ga) }
  sys_close(cfd)
  let st: *i64 = sys_mmap(16) as *i64; sys_wait4(pid, st, 0); sys_close(lfd)
  // reassembled file byte-equal to source?
  var file_eq: i64=1; i=0; while i<total { if outbuf[i]!=fb[i] { file_eq=0; i=total } else { i=i+1 } }
  lp_w("LEECH-GATE authored=organ originate=" as *u8); lp_wn(mk_ok)
  lp_w(" conn=" as *u8); lp_wn(conn_ok)
  lp_w(" got_all=" as *u8); lp_wn(ga[0])
  lp_w(" pieces_verified=" as *u8); lp_wn(verified); lp_w("/" as *u8); lp_wn(npc)
  lp_w(" file_eq_source=" as *u8); lp_wn(file_eq)
  var allok: i64=0
  if mk_ok==1 { if conn_ok==1 { if ga[0]==1 { if verified==npc { if file_eq==1 { allok=1 } } } } }
  if allok==1 { lp_w(" verdict=GREEN (originate->seed->leech, every piece sha1-verified vs advertised)\n" as *u8); sys_exit(0); return 0 }
  lp_w(" verdict=RED\n" as *u8); sys_exit(1); return 1
188}
189
190func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { return lp_gate() }
  // optional leading "mse" token selects the encrypted path: nx_torrent_leech_probe mse <ip> <port> ...
  var base: i64 = 1; var mse: i64 = 0
  let a1: *u8 = argv[1] as *u8
  if a1[0]==(109 as u8) { if a1[1]==(115 as u8) { if a1[2]==(101 as u8) { mse=1; base=2 } } }   // "mse"
  if argc < base+6 { lp_w("usage: nx_torrent_leech_probe [mse] <ip> <port> <ih_hex40> <plen> <total> <outfile>\n" as *u8); sys_exit(2); return 2 }
  let ipstr: *u8 = argv[base] as *u8
  let port: i64 = mk_atoi(argv[base+1] as *u8)
  let ihhex: *u8 = argv[base+2] as *u8
  let plen: i64 = mk_atoi(argv[base+3] as *u8)
  let total: i64 = mk_atoi(argv[base+4] as *u8)
  let outfile: *u8 = argv[base+5] as *u8
  return lp_live(ipstr, port, ihhex, plen, total, outfile, mse)
204}
nx_torrent_leech_probe.nx source

`nx_torrent_leech_probe.nx` source
