nx_hls_live_probe.nx source
↩ module page · 135 lines · 7898 B
1// nx_hls_live_probe.nx -- X-DLP capstone: prove the WHOLE sovereign HLS download
2// chain end-to-end on a REAL live public stream, composing ONLY verified organs
3// (no JS, no curl, no ffmpeg):
4// sovereign HTTPS fetch (TLS1.3 + X.509) -> nx_hls_parse -> nx_hls_resolve ->
5// fetch media playlist -> parse -> resolve -> fetch the first .ts SEGMENT ->
6// confirm real MPEG-TS bytes (sync byte 0x47 @ 0 and 188).
7// Target = Apple's classic bipbop (stable, pure-TS): master -> variant -> segment.
8// license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_x509_trust_store.nx"
11import "nx_trust_store_load_from_certdata.nx"
12import "nx_tls13_client_validate_certificate.nx"
13import "nx_tls13_client_session_run.nx"
14import "nx_https_url_for_fetch.nx"
15import "nx_https_url_connect.nx"
16import "nx_https_get.nx"
17import "nx_https_get_complete.nx"
18import "nx_http_response_parse.nx"
19import "nx_hls_resolve.nx"
20const K_MAGIC_4194304: i64 = 4194304
21const K_MAGIC_1048576: i64 = 1048576
22const K_MAGIC_1048575: i64 = 1048575
23const K_MAGIC_1024: i64 = 1024
24
25func lp_puts(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_num(v: i64) -> i64 { let bb: *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);m=m/10;k=k+1}; var i: i64=0; while i<k{bb[i]=t[k-1-i];i=i+1}; sys_write(1,bb,k); return 0 }
27func lp_slen(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
28
29// Fetch `url` (NUL-term) via sovereign HTTPS. Writes the dechunked/raw BODY into
30// `body` (cap), returns body length (>0) or a negative stage code; sets status.
31func hl_fetch(store: *TrustStore, url: *u8, body: *u8, body_cap: i64, status_box: *i64) -> i64 {
32 status_box[0] = 0
33 let url_p: *NxUrl = nx_url_new()
34 let target_raw: *u8 = sys_mmap(64)
35 let target: *NxHttpsTarget = target_raw as *NxHttpsTarget
36 target.url = url_p; target.port = 0
37 if nx_https_url_for_fetch(url, target) != NX_HTTPS_URL_OK { return 0 - 41 }
38 let fd_p: *i64 = sys_mmap(16) as *i64
39 if nx_https_url_connect(target, url, sys_now_realtime_sec(), fd_p) != NX_HTTPS_CONNECT_OK { return 0 - 42 }
40 let fd: i64 = fd_p[0]
41 let vc_raw: *u8 = sys_mmap(64)
42 let vc: *TlsValidationContext = vc_raw as *TlsValidationContext
43 vc.store = store; vc.sni_host = url + target.url.host_off; vc.sni_host_len = target.url.host_len; vc.now_epoch = sys_now_realtime_sec()
44 let cr: *u8 = sys_mmap(32); var i: i64=0; while i<32 { cr[i]=(0xC0+i) as u8; i=i+1 }
45 let pk: *u8 = sys_mmap(32); i=0; while i<32 { pk[i]=(0xA0+i) as u8; i=i+1 }
46 let sr: i64 = nx_tls13_client_session_run(fd, url + target.url.host_off, target.url.host_len, cr, pk, vc)
47 if sr <= 0 { sys_close(fd); return 0 - 200 + sr }
48 let session: *Tls13ClientSession = sr as *Tls13ClientSession
49 // path = url after host (host_off+host_len .. end); default "/".
50 let host_after: i64 = target.url.host_off + target.url.host_len
51 let urllen: i64 = lp_slen(url)
52 var path: *u8 = (url as i64 + host_after) as *u8
53 var plen: i64 = urllen - host_after
54 if plen <= 0 { path = "/\x00" as *u8; plen = 1 }
55 let raw: *u8 = sys_mmap(K_MAGIC_4194304)
56 let gc: i64 = nx_https_get_complete(session, fd, path, plen, url + target.url.host_off, target.url.host_len, raw, K_MAGIC_4194304)
57 sys_close(fd)
58 if gc < 0 { return 0 - 100 + gc }
59 let r: *i64 = sys_mmap(128) as *i64
60 if nx_http_response_parse(raw, gc, r) != 0 { return 0 - 50 }
61 status_box[0] = r[1]
62 let body_off: i64 = r[6]
63 let body_kind: i64 = r[8]
64 if body_kind == 2 {
65 let n: i64 = nx_http_dechunk((raw as i64 + body_off) as *u8, gc - body_off, body, body_cap)
66 if n < 0 { return 0 - 60 }
67 return n
68 }
69 var blen: i64 = gc - body_off
70 if blen > body_cap { blen = body_cap }
71 var j: i64 = 0
72 while j < blen { body[j] = raw[body_off + j]; j = j + 1 }
73 return blen
74}
75
76// fetch a URL, parse as HLS, return entry count (sets meta); body kept in `pbuf`.
77func hl_get_playlist(store: *TrustStore, url: *u8, pbuf: *u8, pcap: i64, entries: *i64, meta: *i64, label: *u8) -> i64 {
78 lp_puts("[fetch] " as *u8); lp_puts(label); lp_puts(" " as *u8); lp_puts(url); lp_puts("\n" as *u8)
79 let st: *i64 = sys_mmap(16) as *i64
80 let bl: i64 = hl_fetch(store, url, pbuf, pcap, st)
81 if bl < 0 { lp_puts(" FETCH FAIL code=" as *u8); lp_num(bl); lp_puts("\n" as *u8); return bl }
82 lp_puts(" :status=" as *u8); lp_num(st[0]); lp_puts(" body_bytes=" as *u8); lp_num(bl); lp_puts("\n" as *u8)
83 pbuf[bl] = 0 as u8
84 let c: i64 = nx_hls_parse(pbuf, bl, entries, 512, meta)
85 lp_puts(" hls_parse: is_master=" as *u8); lp_num(meta[0]); lp_puts(" entries=" as *u8); lp_num(c); lp_puts("\n" as *u8)
86 return c
87}
88
89func main() -> i64 {
90 lp_puts("=== nx_hls_live_probe : sovereign end-to-end HLS download (Apple bipbop) ===\n" as *u8)
91 let r: i64 = nx_trust_store_load_from_certdata("/tmp/mozilla_certdata.txt" as *u8, 512, K_MAGIC_4194304)
92 if r <= 0 { lp_puts("trust store FAIL\n" as *u8); sys_exit(2); return 2 }
93 let store: *TrustStore = r as *TrustStore
94
95 let master_url: *u8 = "https://devstreaming-cdn.apple.com/videos/streaming/examples/bipbop_4x3/bipbop_4x3_variant.m3u8\x00" as *u8
96 let pbuf: *u8 = sys_mmap(K_MAGIC_1048576)
97 let entries: *i64 = sys_mmap(8*3*512) as *i64
98 let meta: *i64 = sys_mmap(8*8) as *i64
99
100 // ---- 1: master playlist ----
101 let mc: i64 = hl_get_playlist(store, master_url, pbuf, K_MAGIC_1048575, entries, meta, "MASTER" as *u8)
102 if mc <= 0 { lp_puts("STOP: master fetch/parse failed\n" as *u8); sys_exit(1); return 1 }
103
104 // ---- 2: resolve + fetch the first VARIANT (media playlist) ----
105 let vstart: i64 = entries[0*3+0]; let vlen: i64 = entries[0*3+1]
106 let vurl: *u8 = sys_mmap(K_MAGIC_1024)
107 let vn: i64 = nx_hls_resolve_uri(master_url, lp_slen(master_url), (pbuf as i64 + vstart) as *u8, vlen, vurl, 1023)
108 vurl[vn] = 0 as u8
109 let pbuf2: *u8 = sys_mmap(K_MAGIC_1048576)
110 let entries2: *i64 = sys_mmap(8*3*512) as *i64
111 let meta2: *i64 = sys_mmap(8*8) as *i64
112 let sc: i64 = hl_get_playlist(store, vurl, pbuf2, K_MAGIC_1048575, entries2, meta2, "MEDIA " as *u8)
113 if sc <= 0 { lp_puts("STOP: media playlist fetch/parse failed\n" as *u8); sys_exit(1); return 1 }
114
115 // ---- 3: resolve + fetch the first SEGMENT (.ts) ----
116 let sstart: i64 = entries2[0*3+0]; let slen2: i64 = entries2[0*3+1]
117 let surl: *u8 = sys_mmap(K_MAGIC_1024)
118 let sn: i64 = nx_hls_resolve_uri(vurl, lp_slen(vurl), (pbuf2 as i64 + sstart) as *u8, slen2, surl, 1023)
119 surl[sn] = 0 as u8
120 lp_puts("[fetch] SEGMENT " as *u8); lp_puts(surl); lp_puts("\n" as *u8)
121 let seg: *u8 = sys_mmap(K_MAGIC_4194304)
122 let sst: *i64 = sys_mmap(16) as *i64
123 let seglen: i64 = hl_fetch(store, surl, seg, K_MAGIC_4194304, sst)
124 if seglen < 0 { lp_puts(" SEGMENT FETCH FAIL code=" as *u8); lp_num(seglen); lp_puts("\n" as *u8); sys_exit(1); return 1 }
125 lp_puts(" :status=" as *u8); lp_num(sst[0]); lp_puts(" segment_bytes=" as *u8); lp_num(seglen); lp_puts("\n" as *u8)
126
127 // ---- 4: confirm real MPEG-TS (sync byte 0x47 @ 0 and 188) ----
128 var ts_ok: i64 = 0
129 if seglen > 188 { if (seg[0] & 0xff) == 0x47 { if (seg[188] & 0xff) == 0x47 { ts_ok = 1 } } }
130 lp_puts(" first_byte=0x" as *u8); lp_num(seg[0] & 0xff); lp_puts(" ts_sync_0_and_188=" as *u8); lp_num(ts_ok)
131 if ts_ok == 1 { lp_puts(" -> REAL MPEG-TS SEGMENT downloaded SOVEREIGN end-to-end (fetch+parse+resolve+fetch).\n" as *u8) }
132 else { lp_puts(" -> got media bytes (non-TS or short); chain reached the segment.\n" as *u8) }
133 lp_puts("=== CAPSTONE: status=" as *u8); lp_num(sst[0]); lp_puts(" bytes=" as *u8); lp_num(seglen); lp_puts(" ts=" as *u8); lp_num(ts_ok); lp_puts(" ===\n" as *u8)
134 sys_exit(0); return 0
135}