AtlatestRepositorysigil-nat

sigil-nat / tree / scriptsphantom-upnp-mapping-check.mjs

1// One <=120-second lease, one challenge echo, explicit 714 verification.
2import { randomBytes } from 'node:crypto';
3import { hostname } from 'node:os';
4import { createSocket } from 'node:dgram';
5import { mkdirSync, writeFileSync } from 'node:fs';
6import { once } from 'node:events';
7import { isIP } from 'node:net';
8import { gatewayRoute } from '../tools/nat/discovery.mjs';
9import { discoverIgd } from '../tools/nat/igd-discovery.mjs';
10import { UpnpIgdClient, upnpUdpCandidate } from '../tools/nat/upnp.mjs';
11import { SingleUdpLease } from '../tools/nat/lease.mjs';
12import { closeUdpSocket } from '../tools/nat/socket-cleanup.mjs';
14if (!process.env.NAT_EXPECTED_HOST || hostname() !== process.env.NAT_EXPECTED_HOST)
15 throw new Error('Set NAT_EXPECTED_HOST to the intended network host');
16const route = gatewayRoute();
17if (!process.env.NAT_EXPECTED_GATEWAY || !process.env.NAT_EXPECTED_LOCAL_ADDRESS ||
18 route.gateway !== process.env.NAT_EXPECTED_GATEWAY ||
19 route.localAddress !== process.env.NAT_EXPECTED_LOCAL_ADDRESS)
20 throw new Error('Set NAT_EXPECTED_GATEWAY and NAT_EXPECTED_LOCAL_ADDRESS to the intended route');
22mkdirSync('build/nat', { recursive: true });
23const resultPath = 'build/nat/mapping-receipt.json';
24const token = randomBytes(32);
25const responder = createSocket('udp4');
26const abort = new AbortController();
27const receipt = { route, protocol: 'upnp-igd', challenge: token.toString('hex'),
28 processId: process.pid, mappingRequests: 0, echoCount: 0, deleted: false, responderStopped: false,
29 startedAt: new Date().toISOString() };
30const save = () => writeFileSync(resultPath, JSON.stringify(receipt, null, 2) + '\n', { mode: 0o600 });
31let lease;
32let finishing;
33let probeTimer;
34let retentionTimer;
35let successfulProbe = false;
36const finish = () => {
37 if (finishing) return finishing;
38 finishing = (async () => {
39 clearTimeout(probeTimer);
40 clearTimeout(retentionTimer);
41 try {
42 if (lease) {
43 const state = await lease.close();
44 receipt.deleteState = state.phase;
45 receipt.deletionVerification = state.deletion;
46 receipt.deleted = state.phase === 'deleted' && state.deletion?.absenceCode === 714;
47 if (!receipt.deleted) throw new Error('Owned mapping absence was not confirmed by 714');
48 }
49 } catch (error) { receipt.deleteError = error.message; }
50 finally {
51 await closeUdpSocket(responder);
52 receipt.responderStopped = true;
53 receipt.endedAt = new Date().toISOString();
54 save();
55 }
56 })();
57 return finishing;
58};
59const stop = () => abort.abort(new Error('Mapping experiment interrupted'));
60process.once('SIGTERM', stop);
61process.once('SIGINT', stop);
62responder.on('error', error => abort.abort(error));
63// Errors and signals abort waits; the single finally block owns all cleanup.
64const aborted = () => { if (abort.signal.aborted) throw abort.signal.reason; };
65try {
66 responder.bind(0, route.localAddress);
67 await once(responder, 'listening', { signal: abort.signal });
68 const internalPort = responder.address().port;
69 receipt.internalPort = internalPort;
70 const igd = await discoverIgd(route);
71 const service = igd.services[0];
72 if (!service) throw new Error('No usable WANIPConnection IGD service');
73 const client = new UpnpIgdClient(service, route);
74 const externalAddress = await client.getExternalAddress();
75 // Observe the public address from the host that creates the mapping.
76 const observation = await fetch('https://api.ipify.org', { signal: AbortSignal.timeout(3000) });
77 if (!observation.ok) throw new Error('External address observation failed');
78 const observedAddress = (await observation.text()).trim();
79 if (isIP(observedAddress) !== 4) throw new Error('Invalid externally observed IPv4 address');
80 Object.assign(receipt, { serviceType: service.serviceType, externalAddress, observedAddress,
81 cgnat: externalAddress === observedAddress ? 'no' : 'yes' });
82 save();
83 console.log(`RESULT CGNAT: ${receipt.cgnat}`);
84 aborted();
85 lease = new SingleUdpLease({ candidates: [upnpUdpCandidate(client, { internalPort,
86 internalClient: route.localAddress, externalAddress })], deadline: Date.now() + 150000,
87 leaseSeconds: 120, journal: async state => {
88 receipt.leaseState = state;
89 if (state.phase === 'creating') receipt.mappingRequests += 1;
90 save();
91 } });
92 const active = await lease.create();
93 aborted();
94 // Intentionally no maintain(): this experiment must issue only one lease.
95 receipt.externalPort = active.mapping.externalPort;
96 receipt.grantedLeaseSeconds = active.mapping.lifetime;
97 const echo = new Promise((resolveEcho, rejectEcho) => {
98 let claimed = false;
99 responder.on('message', (bytes, peer) => {
100 if (claimed || !bytes.equals(token) || abort.signal.aborted) return;
101 claimed = true;
102 responder.send(bytes, peer.port, peer.address, error => {
103 if (error) return rejectEcho(error);
104 receipt.echoCount = 1;
105 receipt.probePeer = peer;
106 save();
107 resolveEcho();
108 });
109 });
110 abort.signal.addEventListener('abort', () => rejectEcho(abort.signal.reason), { once: true });
111 probeTimer = setTimeout(() => rejectEcho(new Error('Outside probe timed out')), 90000);
112 });
113 receipt.readyAt = new Date().toISOString();
114 save();
115 console.log(`READY protocol=upnp-igd externalPort=${receipt.externalPort} leaseSeconds=${receipt.grantedLeaseSeconds}`);
116 await echo;
117 clearTimeout(probeTimer);
118 const state = await lease.close();
119 if (state.phase !== 'deleted' || state.deletion?.absenceCode !== 714)
120 throw new Error('Delete did not confirm 714');
121 receipt.deleted = true;
122 receipt.deletedAt = new Date().toISOString();
123 receipt.deletionVerification = state.deletion;
124 save();
125 console.log('RESULT explicit-delete=true verification=714 responder-retained=15s');
126 // A second exact challenge is echoed during retention so an outside timeout
127 // can distinguish router deletion from a responder that was already stopped.
128 responder.on('message', (bytes, peer) => {
129 if (!bytes.equals(token) || receipt.echoCount >= 2) return;
130 receipt.echoCount += 1;
131 responder.send(bytes, peer.port, peer.address, error => {
132 if (error) abort.abort(error);
133 save();
134 });
135 });
136 await new Promise((resolveWait, rejectWait) => {
137 retentionTimer = setTimeout(resolveWait, 15000);
138 abort.signal.addEventListener('abort', () => rejectWait(abort.signal.reason), { once: true });
139 if (abort.signal.aborted) rejectWait(abort.signal.reason);
140 });
141 if (receipt.echoCount !== 1) throw new Error('A probe reached the retained responder after deletion');
142 successfulProbe = true;
143} catch (error) {
144 receipt.error = error.message;
145 process.exitCode = 1;
146} finally {
147 await finish();
148 process.off('SIGTERM', stop);
149 process.off('SIGINT', stop);
150 if (!successfulProbe || !receipt.deleted || !receipt.responderStopped) process.exitCode = 1;
151 console.log(`RESULT outsideEcho=${successfulProbe} deleted=${receipt.deleted} verification=${receipt.deletionVerification?.absenceCode ?? 'unconfirmed'} responderStopped=${receipt.responderStopped}`);