AtlatestRepositorysigil-http3
1// Linux real Chrome gate. No public-host connection, tunnel or root rule.
2import assert from 'node:assert/strict';
3import { spawn, execFileSync } from 'node:child_process';
4import { accessSync, constants, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
5import { hostname, networkInterfaces } from 'node:os';
6import { resolve, join } from 'node:path';
7import { identity, sameIdentity } from '../../scripts/echo-lifecycle.mjs';
8import { startPeer, candidateInventory } from './peer.mjs';
9
10const directory = resolve('build/webrtc-gate'); mkdirSync(directory, { mode: 0o700, recursive: true });
11const pause = ms => new Promise(done => setTimeout(done, ms));
12let interrupted = false, app, browser, closed = false, browserError = '', admissionTimer;
13const interrupt = () => { interrupted = true; };
14process.on('SIGTERM', interrupt); process.on('SIGINT', interrupt);
15const timeout = setTimeout(interrupt, 60000);
16const admitted = new Map();
17function admit(pid) {
18 const value = identity(pid); if (!value || value.uid !== process.getuid()) return;
19 const previous = admitted.get(pid); if (previous && !sameIdentity(previous, value)) return;
20 admitted.set(pid, value);
21 try { for (const child of readFileSync(`/proc/${pid}/task/${pid}/children`, 'utf8').trim().split(/\s+/).filter(Boolean)) admit(Number(child)); } catch {}
23function signalTree(signal) {
24 for (const value of [...admitted.values()].reverse()) {
25 const now = identity(value.pid);
26 if (sameIdentity(value, now) && now.state !== 'Z') try { process.kill(value.pid, signal); } catch (error) { if (error.code !== 'ESRCH') throw error; }
27 }
29const receipt = { mode: 'real-chrome-webrtc', passed: false, sourceRevision: execFileSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).trim() };
30let browserDone;
31try {
32 const sample = 'v=0\r\nm=application 9 UDP/DTLS/SCTP webrtc-datachannel\r\na=candidate:1 1 UDP 1 test.local 45000 typ host\r\na=candidate:2 1 UDP 2 192.0.2.1 45001 typ srflx\r\na=candidate:3 1 UDP 3 2001:db8::1 45002 typ srflx\r\na=candidate:4 1 UDP 4 2001:db8::2 45003 typ host\r\n';
33 const filtered = candidateInventory(sample, address => address === '2001:db8::1');
34 assert.equal(filtered.inventory.filter(c => c.accepted).length, 1);
35 assert.ok(filtered.sdp.includes('2001:db8::1') && !filtered.sdp.includes('test.local') && !filtered.sdp.includes('2001:db8::2'));
36 const bindAddress = networkInterfaces()[process.env.HTTP3_INTERFACE]?.find(a => a.family === 'IPv6' && /^[23]/.test(a.address) && !a.internal)?.address;
37 assert.ok(bindAddress, 'No global IPv6 on configured physical interface');
38 app = await startPeer({ scope: 'gate', bindAddress, signalPort: 0, directory: join(directory, 'peer'), lifetimeSeconds: 60 });
39 const arm = app.armSession({ name: 'phantom-chrome', address: bindAddress });
40 assert.ok(Date.parse(arm.expiresAt) <= Date.now() + 300000);
41 const chrome = ['chromium', 'chromium-browser', 'google-chrome', 'google-chrome-stable']
42 .flatMap(n => process.env.PATH.split(':').map(p => join(p, n)))
43 .find(p => { try { accessSync(p, constants.X_OK); return true; } catch { return false; } });
44 assert.ok(chrome, 'Chrome not found');
45 browser = spawn(chrome, ['--headless=new', '--no-sandbox', '--disable-gpu', '--no-first-run',
46 '--no-default-browser-check', '--disable-background-networking', '--disable-breakpad', '--disable-crash-reporter',
47 '--remote-debugging-pipe', `--user-data-dir=${directory}/profile`, `--log-net-log=${directory}/net-export.json`,
48 '--net-log-capture-mode=Default'], { stdio: ['ignore', 'ignore', 'pipe', 'pipe', 'pipe'] });
49 browserDone = new Promise(done => browser.once('close', () => { closed = true; done(); }));
50 browser.on('error', error => { browserError += error.message; interrupt(); });
51 browser.stderr.on('data', bytes => { browserError += bytes.toString().slice(0, Math.max(0, 1048576 - browserError.length)); });
52 admit(browser.pid); admissionTimer = setInterval(() => admit(browser.pid), 100);
53 let sequence = 0, pending = ''; const requests = new Map();
54 browser.stdio[3].on('error', interrupt);
55 browser.stdio[4].on('data', bytes => {
56 pending += bytes.toString();
57 if (pending.length > 4194304) { interrupt(); return; }
58 for (;;) {
59 const end = pending.indexOf('\0'); if (end < 0) break;
60 const message = JSON.parse(pending.slice(0, end)); pending = pending.slice(end + 1);
61 const request = requests.get(message.id);
62 if (request) { requests.delete(message.id); clearTimeout(request.timer); message.error ? request.reject(new Error(JSON.stringify(message.error))) : request.done(message.result); }
63 }
64 });
65 const cdp = (method, params = {}, sessionId) => new Promise((done, reject) => {
66 const id = ++sequence, timer = setTimeout(() => { requests.delete(id); reject(new Error('DevTools deadline: ' + method)); }, 8000);
67 requests.set(id, { done, reject, timer });
68 browser.stdio[3].write(JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }) + '\0');
69 });
70 receipt.browser = await cdp('Browser.getVersion');
71 const target = await cdp('Target.createTarget', { url: 'about:blank' });
72 const { sessionId } = await cdp('Target.attachToTarget', { targetId: target.targetId, flatten: true });
73 const evaluate = async expression => {
74 const r = await cdp('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, sessionId);
75 if (r.exceptionDetails) throw new Error(JSON.stringify(r.exceptionDetails)); return r.result?.value;
76 };
77 await cdp('Page.enable', {}, sessionId);
78 await cdp('Page.navigate', { url: arm.phoneURL }, sessionId);
79 const waitFor = async predicate => {
80 const end = Date.now() + 35000; let value;
81 while (!interrupted && !closed && Date.now() < end) {
82 value = await evaluate('window.__rtcSpike?.()');
83 if (predicate(value)) return value;
84 if (value?.state === 'failed') throw new Error('Page failed: ' + JSON.stringify(value.events.slice(-6)));
85 await pause(100);
86 }
87 throw new Error('WebRTC Chrome gate deadline: ' + JSON.stringify(value));
88 };
89 await waitFor(v => v?.state === 'idle');
90 await evaluate(`Object.defineProperty(navigator, 'onLine', { configurable: true, get: () => false }); window.dispatchEvent(new Event('offline'))`);
91 assert.equal(await evaluate("document.getElementById('connect').disabled"), true);
92 await evaluate("document.getElementById('connect').dispatchEvent(new Event('click'))");
93 assert.equal(await evaluate('window.__rtcSpike().events.some(e => e.kind === "offer-ready")'), false);
94 await evaluate(`Object.defineProperty(navigator, 'onLine', { configurable: true, get: () => true }); window.dispatchEvent(new Event('online'))`);
95 assert.equal(await evaluate("document.getElementById('connect').disabled"), false);
96 await evaluate("document.getElementById('connect').click()");
97 receipt.page = await waitFor(v => v?.state === 'open' && v.received >= 8 && v.selectedPair);
98 assert.equal(receipt.page.selectedPair.remote.candidateType, 'host');
99 assert.equal(receipt.page.selectedPair.remote.protocol, 'udp');
100 assert.ok(receipt.page.selectedPair.remote.address?.includes(':'));
101 const replay = await fetch(app.origin + '/wt-spike/signal', { method: 'POST', headers: { Origin: app.origin,
102 'Content-Type': 'application/json', Authorization: 'Bearer ' + arm.token }, body: '{}' });
103 assert.equal(replay.status, 401, 'Session token was reused');
104 await evaluate("document.getElementById('stop').click()");
105 await waitFor(v => v?.state === 'stopped');
106 assert.ok(app.counters.echoMessages >= 8);
107 assert.ok(app.counters.txChecks > 0 && app.counters.rxChecks > 0 && app.counters.txResponses > 0 && app.counters.rxResponses > 0);
108 assert.ok(app.selected);
109 receipt.tokenReplayRejected = true; receipt.offlineGate = true; receipt.onlineRecovery = true;
110 receipt.passed = true;
111} catch (error) { receipt.error = error.message; process.exitCode = 1; }
112finally {
113 clearTimeout(timeout); clearInterval(admissionTimer);
114 if (browser) {
115 admit(browser.pid);
116 if (!closed) { signalTree('SIGTERM'); await Promise.race([browserDone, pause(2000)]); }
117 signalTree('SIGKILL');
118 await Promise.race([browserDone, pause(2000)]);
119 receipt.chromeReaped = closed && [...admitted.values()].every(v => { const now = identity(v.pid); return !sameIdentity(v, now) || now.state === 'Z'; });
120 }
121 try { receipt.peer = await app?.close(); } catch (error) { receipt.cleanupError = error.message; process.exitCode = 1; }
122 receipt.peerClosed = receipt.peer?.socketsClosed === true;
123 if (!receipt.chromeReaped || !receipt.peerClosed) { receipt.passed = false; process.exitCode = 1; }
124 writeFileSync(join(directory, 'chrome.stderr'), browserError, { mode: 0o600 });
125 writeFileSync(join(directory, 'receipt.json'), JSON.stringify(receipt, null, 2) + '\n', { mode: 0o600 });
126 process.off('SIGTERM', interrupt); process.off('SIGINT', interrupt);
127 console.log(`RESULT webrtc-chrome passed=${receipt.passed} chrome-reaped=${receipt.chromeReaped} peer-closed=${receipt.peerClosed}`);