AtlatestRepositorysigil-http3

sigil-http3 / tree / scriptsvpn-phone-run.mjs

1// operator-configured VPN window. No public binds, firewall changes or publishing.
2import { createHash } from 'node:crypto';
3import { createSocket } from 'node:dgram';
4import { copyFileSync, chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
5import { createServer } from 'node:net';
6import { hostname, networkInterfaces } from 'node:os';
7import { resolve, join } from 'node:path';
8import { identity, inspectPlan, runTest, stopRun } from './echo-lifecycle.mjs';
9import { startPhonePage } from './phone-page-host.mjs';
11const pause = ms => new Promise(done => setTimeout(done, ms));
12const digest = path => createHash('sha256').update(readFileSync(path)).digest('hex');
13function check(value, message) { if (!value) throw new Error(message); }
14function json(path) { return JSON.parse(readFileSync(path, 'utf8')); }
15function privateJson(path, value) {
16 writeFileSync(path + '.next', JSON.stringify(value, null, 2) + '\n', { mode: 0o600 });
17 renameSync(path + '.next', path);
19async function unusedPort(kind, address) {
20 const socket = kind === 'udp' ? createSocket('udp4') : createServer();
21 try {
22 await new Promise((ready, reject) => {
23 socket.once('error', reject);
24 if (kind === 'udp') socket.bind(0, address, ready);
25 else socket.listen(0, address, ready);
26 });
27 return socket.address().port;
28 } finally {
29 await new Promise(done => {
30 try { socket.close(done); } catch { done(); }
31 });
32 }
35async function runVpnPhone() {
37 const direct = process.env.HTTP3_PHONE_SCOPE === 'ipv6-direct';
38 const traced = process.env.HTTP3_PHONE_TRACE === '1';
39 const bindAddress = direct ? process.env.HTTP3_IPV6_ADDRESS : (process.env.HTTP3_IPV4_ADDRESS ?? '127.0.0.1');
40 if (direct) check(Object.values(networkInterfaces()).flat().some(address =>
41 address?.family === 'IPv6' && address.address === bindAddress && !address.internal),
42 'configured IPv6 address is not assigned');
43 const verifiedJob = process.env.HTTP3_VERIFIED_NATIVE_JOB;
44 check(/^[a-z0-9][a-z0-9-]{0,63}$/.test(verifiedJob ?? ''), 'Expected the admitted native gate');
45 const verified = `${process.env.HTTP3_WORKSPACE_ROOT ?? (process.cwd() + "/build/workspaces")}/${verifiedJob}`;
46 check(readFileSync(verified + '/rc', 'utf8').trim() === '0', 'Native gate must have completed successfully');
47 check(readFileSync(verified + '/src/build/spike-echo/result.txt', 'utf8')
48 .includes('RESULT spike-echo-native-v4-v6-and-lifecycle=PASS'), 'Full family/lifecycle gate missing');
49 const nativeReceipt = json(verified + '/src/build/browser/capabilities.json');
50 const receipt = direct ? json(resolve('build/browser/capabilities.json')) : nativeReceipt;
51 check(receipt.quicRevision === readFileSync('quic.rev', 'utf8').trim() &&
52 receipt.spikeSdkRevision === readFileSync('spike-sdk.rev', 'utf8').trim(), 'Verified QUIC/SDK pair mismatch');
53 check(['ready', 'bidirectionalEcho', 'unidirectionalEcho', 'datagramEcho', 'chromeReaped', 'serverReaped']
54 .every(key => receipt[key] === true), 'Real echo/reaping gate missing');
55 check(['configurableBind', 'retry', 'antiAmplification', 'boundedAdmission', 'peerAddressLogging',
56 'pathChangeLogging', 'cidChangeLogging', 'echoOnly'].every(key => receipt.server?.[key] === true),
57 'Reviewed server capability gate missing');
58 if (traced) {
59 check(direct && receipt.traceProbe?.newTuple === true && receipt.traceProbe?.dropRecorded === true,
60 'Traced loopback probe receipt missing');
61 check(readFileSync('build/spike-echo/trace-result.txt', 'utf8').includes('private-trace-native-browser-regressions=PASS'),
62 'Private traced native/browser gate missing');
63 check(json(resolve('build/spike-echo/trace-manifest.json')).base === receipt.quicRevision,
64 'Private trace base pin mismatch');
65 }
66 const originalBinary = traced ? resolve('tools/interop/build/native/bin/http3-preflight') : verified + '/src/tools/interop/build/native/bin/http3-preflight';
67 const originalCertificate = direct ? resolve('build/browser') : verified + '/src/build/browser';
68 check((traced || receipt.binarySha256 === nativeReceipt.binarySha256) && digest(originalBinary) === receipt.binarySha256 &&
69 digest(originalCertificate + '/cert.der') === receipt.certificateSha256, 'Verified input hash mismatch');
71 mkdirSync('build', { recursive: true, mode: 0o700 });
72 const directory = resolve(direct ? 'build/phone-ipv6' : 'build/phone-vpn');
73 mkdirSync(directory, { mode: 0o700 }); // Exclusive; never reuse another window.
74 const certificateDirectory = join(directory, 'certificate');
75 mkdirSync(certificateDirectory, { mode: 0o700 });
76 for (const name of ['cert.pem', 'cert.der', 'key.pem', 'private.raw', 'certificate.json']) {
77 copyFileSync(join(originalCertificate, name), join(certificateDirectory, name));
78 chmodSync(join(certificateDirectory, name), 0o600);
79 }
80 const binary = join(directory, 'echo-server');
81 copyFileSync(originalBinary, binary);
82 chmodSync(binary, 0o700);
83 privateJson(join(directory, 'interop.json'), receipt);
84 const pageBindAddress = (process.env.HTTP3_IPV4_ADDRESS ?? '127.0.0.1');
85 const requestedLifetime = direct ? 2700 : 5400;
86 const lifetimeSeconds = process.env.HTTP3_PHONE_DEADLINE ? Math.min(requestedLifetime,
87 Math.floor((Date.parse(process.env.HTTP3_PHONE_DEADLINE) - Date.now()) / 1000)) : requestedLifetime;
88 check(Number.isInteger(lifetimeSeconds) && lifetimeSeconds >= 120, 'Phone window deadline is too close or invalid');
89 const cancellation = new AbortController();
90 const deadline = Date.now() + lifetimeSeconds * 1000;
91 const timer = setTimeout(() => cancellation.abort(), lifetimeSeconds * 1000);
92 const terminate = () => cancellation.abort();
93 process.on('SIGTERM', terminate);
94 process.on('SIGINT', terminate);
95 const statePath = join(directory, 'state.json');
96 const state = { schema: 1, kind: direct ? 'phone-ipv6-controller' : 'phone-vpn-controller', phase: 'starting',
97 supervisor: identity(process.pid), startedAt: new Date().toISOString(),
98 expiresAt: new Date(deadline).toISOString(), verifiedJob,
99 sourceRevision: receipt.sourceRevision, quicRevision: receipt.quicRevision,
100 sdkRevision: receipt.spikeSdkRevision, binarySha256: receipt.binarySha256,
101 certificateSha256: receipt.certificateSha256 };
102 let page;
103 let server;
104 let serverEnded = false;
105 let serverError;
106 let failure;
107 const serverDirectory = join(directory, 'server');
108 try {
109 privateJson(statePath, state);
110 const port = direct ? 43443 : await unusedPort('udp', bindAddress);
111 const pagePort = await unusedPort('tcp', pageBindAddress);
112 cancellation.signal.throwIfAborted();
113 const origin = `https://${pageBindAddress}:${pagePort}`;
114 const config = { schema: 1, testId: direct ? 'phone-ipv6-001' : 'phone-vpn-001', expectedHost: hostname(), scope: direct ? 'ipv6-direct' : 'vpn',
115 binary, binarySha256: receipt.binarySha256, certificateDirectory,
116 runDirectory: serverDirectory, interopReceipt: join(directory, 'interop.json'),
117 bindAddress, port, lifetimeSeconds, authority: direct ? `[${bindAddress}]:${port}` : `${bindAddress}:${port}`, origins: [origin] };
118 const configPath = join(directory, 'server-config.json');
119 privateJson(configPath, config);
120 check(inspectPlan(configPath).ready, 'Phone lifecycle prerequisites are incomplete');
121 page = await startPhonePage({ schema: 1, scope: 'vpn', expectedHost: hostname(), bindAddress: pageBindAddress,
122 port: pagePort, lifetimeSeconds, page: resolve('web/phone.html'), certificateDirectory });
123 page.closed.then(() => cancellation.abort());
124 server = runTest(configPath, { signal: cancellation.signal }).then(
125 value => { serverEnded = true; return value; },
126 error => { serverEnded = true; serverError = error; });
127 const readyDeadline = Date.now() + 15000;
128 let serverState;
129 while (!serverEnded && !cancellation.signal.aborted) {
130 if (existsSync(join(serverDirectory, 'state.json'))) {
131 serverState = json(join(serverDirectory, 'state.json'));
132 if (serverState.phase === 'ready') break;
133 }
134 check(Date.now() < readyDeadline, 'Phone server readiness deadline');
135 await pause(50);
136 }
137 check(serverState?.phase === 'ready' && !serverEnded && !cancellation.signal.aborted,
138 serverError?.message ?? 'Phone server ended before readiness');
139 const query = new URLSearchParams({ host: bindAddress, port: String(port), hash: receipt.certificateSha256 });
140 const parameters = { scope: direct ? 'ipv6-direct' : 'vpn', host: bindAddress, port, hash: receipt.certificateSha256,
141 pagePort, pageURL: page.url, phoneURL: `${page.url}?${query}`, expiresAt: state.expiresAt,
142 sourceRevision: receipt.sourceRevision, binarySha256: receipt.binarySha256,
143 quicRevision: receipt.quicRevision, sdkRevision: receipt.spikeSdkRevision,
144 serverState: join(serverDirectory, 'state.json'), serverLog: join(serverDirectory, 'stdout.log') };
145 privateJson(join(directory, 'parameters.json'), parameters);
146 Object.assign(state, { phase: 'ready', readyAt: new Date().toISOString(), child: serverState.child });
147 privateJson(statePath, state);
148 console.log(`RESULT phone-window-ready parameters=${directory}/parameters.json expires=${state.expiresAt}`);
149 await server;
150 if (serverError) throw serverError;
151 } catch (error) { failure = error; }
152 finally {
153 clearTimeout(timer);
154 cancellation.abort();
155 const cleanup = await Promise.allSettled([page?.close(), server]);
156 if (cleanup[0].status === 'rejected') failure ??= cleanup[0].reason;
157 process.off('SIGTERM', terminate);
158 process.off('SIGINT', terminate);
159 const terminal = existsSync(join(serverDirectory, 'state.json')) ? json(join(serverDirectory, 'state.json')) : null;
160 Object.assign(state, { phase: 'finished', endedAt: new Date().toISOString(), pageClosed: cleanup[0].status === 'fulfilled',
161 childReaped: terminal?.childReaped ?? !server, error: failure?.message ?? serverError?.message });
162 privateJson(statePath, state);
163 check(state.childReaped, 'Phone child cleanup was not confirmed');
164 console.log(`RESULT phone-vpn-finished pageClosed=${state.pageClosed} childReaped=true`);
165 }
166 if (failure) throw failure;
167 if (serverError) throw serverError;
170try {
171 const [command, directory] = process.argv.slice(2);
172 if (command === 'stop' && directory) console.log(JSON.stringify(stopRun(resolve(directory))));
173 else { check(command === 'run' && !directory, 'Usage: vpn-phone-run.mjs run | stop RUN_DIRECTORY'); await runVpnPhone(); }
174} catch (error) { console.error(`RESULT phone-vpn-error ${error.message}`); process.exitCode = 1; }