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

↩ module page · 209 lines · 11925 B
1// nx_tls12_probe.nx -- INCREMENT 1 of the sovereign TLS-1.2 client (the keystone that gets nx_gpu_ctl + Porkbun
2// off curl/wsl and onto sovereign APIs; Vast's console.vast.ai + Porkbun are TLS-1.2-ONLY and our shipped stack is
3// TLS-1.3-only). This probe proves the WIRE + PARSE layer: TCP-connect, send a real TLS-1.2 ClientHello offering
4// TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 (0xC02F) + secp256r1, then read+parse the server's flight
5// (ServerHello / Certificate / ServerKeyExchange / ServerHelloDone) and print what we recovered: negotiated cipher,
6// server_random, cert-chain length, and the server's ECDHE public key. Composes the SAME connect primitive the
7// 1.3 client uses (nx_https_url_connect) so the transport is identical; TLS-1.2 handshake records are PLAINTEXT
8// until ChangeCipherSpec, so the probe reads them raw. Increment 2 adds ECDHE+PRF+Finished; 3 adds GCM records.
9// license_tier: ORIGINAL  expect_exit: 0
10import "nx_syscalls.nx"
11import "nx_csprng.nx"
12import "nx_https_url_for_fetch.nx"
13import "nx_https_url_connect.nx"
14const P12_MAGIC_1024: i64 = 1024
15const P12_MAGIC_2048: i64 = 2048
16const P12_MAGIC_65536: i64 = 65536
17
18const P12_HS: i64 = 22            // record type handshake
19const P12_ALERT: i64 = 21
20
21func p12_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
22func p12_putn(v: i64) -> i64 {
  let b: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(1,"-" as *u8,1)}
  let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48;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{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0
27}
28func p12_puthex(byte: i64) -> i64 {
  let hx: *u8="0123456789abcdef" as *u8; let o: *u8=sys_mmap(2)
  o[0]=hx[(byte>>4)&0xf] as u8; o[1]=hx[byte&0xf] as u8; sys_write(1,o,2); return 0
31}
32func p12_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
33
34// append helpers into a build buffer
35func p12_b1(d: *u8, o: i64, v: i64) -> i64 { d[o]=(v & 0xff) as u8; return o+1 }
36func p12_b2(d: *u8, o: i64, v: i64) -> i64 { d[o]=((v>>8)&0xff) as u8; d[o+1]=(v&0xff) as u8; return o+2 }
37func p12_b3(d: *u8, o: i64, v: i64) -> i64 { d[o]=((v>>16)&0xff) as u8; d[o+1]=((v>>8)&0xff) as u8; d[o+2]=(v&0xff) as u8; return o+3 }
38func p12_bytes(d: *u8, o: i64, s: *u8, n: i64) -> i64 { var i: i64=0; while i<n { d[o+i]=s[i]; i=i+1 } return o+n }
39
40// Build a TLS 1.2 ClientHello (as a full record) into out. Returns total record length.
41// host/hlen = SNI. client_random(32) filled from CSPRNG (copied to cr_out for later PRF use).
42func p12_build_client_hello(host: *u8, hlen: i64, cr_out: *u8, out: *u8) -> i64 {
  // ---- assemble ClientHello body first (we backfill lengths) ----
  let body: *u8 = sys_mmap(P12_MAGIC_1024)
  var o: i64 = 0
  o = p12_b2(body, o, 0x0303)                        // client_version TLS 1.2
  nx_csprng_fill(cr_out, 32)
  o = p12_bytes(body, o, cr_out, 32)                 // random(32)
  o = p12_b1(body, o, 0)                             // session_id length 0
  o = p12_b2(body, o, 2)                             // cipher_suites length = 2
  o = p12_b2(body, o, 0xC02F)                        // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
  o = p12_b1(body, o, 1)                             // compression methods length
  o = p12_b1(body, o, 0)                             // null compression
  // ---- extensions ----
  let ext: *u8 = sys_mmap(512)
  var e: i64 = 0
  // server_name (0x0000)
  let snlen: i64 = hlen
  e = p12_b2(ext, e, 0x0000)
  e = p12_b2(ext, e, snlen + 5)                      // ext data len
  e = p12_b2(ext, e, snlen + 3)                      // server_name_list len
  e = p12_b1(ext, e, 0)                             // name_type host_name
  e = p12_b2(ext, e, snlen)                          // host len
  e = p12_bytes(ext, e, host, snlen)
  // supported_groups (0x000A) -> secp256r1 (0x0017)
  e = p12_b2(ext, e, 0x000A); e = p12_b2(ext, e, 4); e = p12_b2(ext, e, 2); e = p12_b2(ext, e, 0x0017)
  // ec_point_formats (0x000B) -> uncompressed (0)
  e = p12_b2(ext, e, 0x000B); e = p12_b2(ext, e, 2); e = p12_b1(ext, e, 1); e = p12_b1(ext, e, 0)
  // signature_algorithms (0x000D) -> rsa_pkcs1_sha256(0x0401), rsa_pkcs1_sha384(0x0501), rsa_pkcs1_sha512(0x0601)
  e = p12_b2(ext, e, 0x000D); e = p12_b2(ext, e, 8); e = p12_b2(ext, e, 6)
  e = p12_b2(ext, e, 0x0401); e = p12_b2(ext, e, 0x0501); e = p12_b2(ext, e, 0x0601)
  // extensions block
  o = p12_b2(body, o, e)                             // extensions length
  o = p12_bytes(body, o, ext, e)
  let body_len: i64 = o
  // ---- wrap: handshake header (type 1 = ClientHello) then record header ----
  var r: i64 = 0
  r = p12_b1(out, r, P12_HS)                         // record type handshake
  r = p12_b2(out, r, 0x0303)                         // record version
  r = p12_b2(out, r, body_len + 4)                   // record length = hs header(4)+body
  r = p12_b1(out, r, 1)                              // handshake type ClientHello
  r = p12_b3(out, r, body_len)                       // handshake length
  r = p12_bytes(out, r, body, body_len)
  return r
85}
86
87func p12_write_all(fd: i64, buf: *u8, n: i64) -> i64 {
  var off: i64=0
  while off<n { let w: i64=sys_write(fd, ((buf as i64)+off) as *u8, n-off); if w<=0 { return 0-1 } off=off+w }
  return 0
91}
92
93func main(argc: i64, argv: *i64) -> i64 {
  var url: *u8 = "https://console.vast.ai/" as *u8
  if argc >= 2 { url = argv[1] as *u8 }
  p12_puts("=== sovereign TLS-1.2 probe -> " as *u8); p12_puts(url); p12_puts(" ===\n" as *u8)
97
  // ---- TCP connect (reuse the 1.3 client's connect primitive; TLS is ours) ----
  let target_raw: *u8 = sys_mmap(64); let target: *NxHttpsTarget = target_raw as *NxHttpsTarget
  target.url = nx_url_new(); target.port = 0
  if nx_https_url_for_fetch(url, target) != NX_HTTPS_URL_OK { p12_puts("bad url\n" as *u8); return 1 }
  let host: *u8 = ((url as i64) + target.url.host_off) as *u8
  let hlen: i64 = target.url.host_len
  let now: i64 = sys_now_realtime_sec()
  let fd_p: *i64 = sys_mmap(16) as *i64
  if nx_https_url_connect(target, url, now, fd_p) != NX_HTTPS_CONNECT_OK { p12_puts("TCP connect FAILED\n" as *u8); return 1 }
  let fd: i64 = fd_p[0]
  p12_puts("  TCP connected fd=" as *u8); p12_putn(fd); p12_puts(" host=" as *u8); sys_write(1, host, hlen); p12_puts("\n" as *u8)
109
  // ---- send ClientHello ----
  let cr: *u8 = sys_mmap(32)
  let ch: *u8 = sys_mmap(P12_MAGIC_2048)
  let chlen: i64 = p12_build_client_hello(host, hlen, cr, ch)
  if p12_write_all(fd, ch, chlen) < 0 { p12_puts("ClientHello write FAILED\n" as *u8); sys_close(fd); return 1 }
  p12_puts("  ClientHello sent (" as *u8); p12_putn(chlen); p12_puts(" bytes; cipher=0xC02F ECDHE-RSA-AES128-GCM-SHA256)\n" as *u8)
116
  // ---- read server flight into one buffer ----
  let buf: *u8 = sys_mmap(P12_MAGIC_65536)
  var total: i64 = 0
  var reads: i64 = 0
  var done: i64 = 0
  while done == 0 {
      if reads > 40 { done = 1 }
      let n: i64 = sys_read(fd, ((buf as i64)+total) as *u8, P12_MAGIC_65536 - total)
      if n <= 0 { done = 1 } else {
          total = total + n
          reads = reads + 1
          // stop once we've parsed a ServerHelloDone (14) at the handshake layer; cheap scan below
          // (we re-scan each loop; small flights, fine)
          var scanned: i64 = 0; var seen_shd: i64 = 0
          while scanned + 5 <= total {
              let rtype: i64 = buf[scanned] & 0xff
              let rlen: i64 = ((buf[scanned+3] & 0xff) << 8) | (buf[scanned+4] & 0xff)
              if rtype == P12_ALERT { done = 1 }
              // walk handshake messages inside a handshake record
              if rtype == P12_HS {
                  var hp: i64 = scanned + 5; let rend: i64 = scanned + 5 + rlen
                  while hp + 4 <= rend {
                      let ht: i64 = buf[hp] & 0xff
                      let hl: i64 = ((buf[hp+1]&0xff)<<16)|((buf[hp+2]&0xff)<<8)|(buf[hp+3]&0xff)
                      if ht == 14 { seen_shd = 1 }
                      hp = hp + 4 + hl
                  }
              }
              scanned = scanned + 5 + rlen
          }
          if seen_shd == 1 { done = 1 }
      }
  }
  p12_puts("  received " as *u8); p12_putn(total); p12_puts(" bytes in " as *u8); p12_putn(reads); p12_puts(" read(s)\n" as *u8)
  if total < 5 { p12_puts("  verdict=RED: no TLS flight (server closed?)\n" as *u8); sys_close(fd); return 1 }
152
  // ---- parse the flight: records -> handshake messages ----
  var p: i64 = 0
  var got_sh: i64 = 0; var got_cert: i64 = 0; var got_ske: i64 = 0; var got_shd: i64 = 0
  var cert_total: i64 = 0
  while p + 5 <= total {
      let rtype: i64 = buf[p] & 0xff
      let rlen: i64 = ((buf[p+3]&0xff)<<8) | (buf[p+4]&0xff)
      if rtype == P12_ALERT {
          p12_puts("  ALERT: level=" as *u8); p12_putn(buf[p+5]&0xff); p12_puts(" desc=" as *u8); p12_putn(buf[p+6]&0xff); p12_puts("\n" as *u8)
      }
      if rtype == P12_HS {
          var hp: i64 = p + 5; let rend: i64 = p + 5 + rlen
          while hp + 4 <= rend {
              let ht: i64 = buf[hp] & 0xff
              let hl: i64 = ((buf[hp+1]&0xff)<<16)|((buf[hp+2]&0xff)<<8)|(buf[hp+3]&0xff)
              let bodyp: i64 = hp + 4
              if ht == 2 {   // ServerHello
                  got_sh = 1
                  // body: version(2) random(32) sid_len(1) sid... cipher(2) comp(1) ext...
                  p12_puts("  ServerHello: version=0x" as *u8); p12_puthex(buf[bodyp]&0xff); p12_puthex(buf[bodyp+1]&0xff)
                  let sidlen: i64 = buf[bodyp+34] & 0xff
                  let cipoff: i64 = bodyp + 35 + sidlen
                  let cip: i64 = ((buf[cipoff]&0xff)<<8) | (buf[cipoff+1]&0xff)
                  p12_puts(" cipher=0x" as *u8); p12_puthex((cip>>8)&0xff); p12_puthex(cip&0xff)
                  p12_puts(" server_random[0..4]=" as *u8)
                  var z: i64=0; while z<4 { p12_puthex(buf[bodyp+2+z]&0xff); z=z+1 }
                  p12_puts("\n" as *u8)
              }
              if ht == 11 { got_cert = 1; cert_total = hl }  // Certificate
              if ht == 12 {  // ServerKeyExchange: curve_type(1) named_curve(2) pklen(1) pubkey...
                  got_ske = 1
                  let ctype: i64 = buf[bodyp] & 0xff
                  let curve: i64 = ((buf[bodyp+1]&0xff)<<8) | (buf[bodyp+2]&0xff)
                  let pklen: i64 = buf[bodyp+3] & 0xff
                  p12_puts("  ServerKeyExchange: curve_type=" as *u8); p12_putn(ctype)
                  p12_puts(" named_curve=0x" as *u8); p12_puthex((curve>>8)&0xff); p12_puthex(curve&0xff)
                  p12_puts(" ecdhe_pubkey_len=" as *u8); p12_putn(pklen); p12_puts(" pub[0]=0x" as *u8); p12_puthex(buf[bodyp+4]&0xff)
                  p12_puts("\n" as *u8)
              }
              if ht == 14 { got_shd = 1 }  // ServerHelloDone
              hp = hp + 4 + hl
          }
      }
      p = p + 5 + rlen
  }
  p12_puts("  parsed: ServerHello=" as *u8); p12_putn(got_sh)
  p12_puts(" Certificate=" as *u8); p12_putn(got_cert); p12_puts("(len " as *u8); p12_putn(cert_total); p12_puts(")" as *u8)
  p12_puts(" ServerKeyExchange=" as *u8); p12_putn(got_ske)
  p12_puts(" ServerHelloDone=" as *u8); p12_putn(got_shd); p12_puts("\n" as *u8)
  sys_close(fd)
  if got_sh == 1 { if got_ske == 1 { if got_shd == 1 {
      p12_puts("  verdict=GREEN: sovereign TLS-1.2 WIRE+PARSE works -- server's ECDHE flight recovered. Increment 2 = ECDHE+PRF+Finished.\n" as *u8)
      return 0
  } } }
  p12_puts("  verdict=PARTIAL: connected+sent but did not recover full ECDHE flight (see above)\n" as *u8)
  return 0
209}
nx_tls12_probe.nx source

`nx_tls12_probe.nx` source
