AtlatestRepositorysigil-nat

sigil-nat / tree / tools / natnat-probe-reflector.mjs

1// Owned, short-lived measurement reflectors. No unauthenticated UDP replies.
2import { createSocket } from 'node:dgram';
3import { once } from 'node:events';
4import { isIP } from 'node:net';
5import { closeUdpSocket } from './socket-cleanup.mjs';
6import { decodeProbeMessage, encodeProbeMessage, probeEndpoint, sameEndpoint,
7 probeOperations as op } from './nat-probe-wire.mjs';
8
9export async function openNatProbeReflector({ role, bindAddress, ports, token,
10 clientAddresses, peer, lifetimeMs = 180000 }) {
11 if (!['a', 'b'].includes(role) || isIP(bindAddress) !== 4 || bindAddress === '0.0.0.0' ||
12 !Array.isArray(ports) || ports.length !== (role === 'a' ? 2 : 1) ||
13 ports.some(port => !Number.isInteger(port) || port < 0 || port > 65535) ||
14 !Buffer.isBuffer(token) || token.length !== 32 || !Array.isArray(clientAddresses) ||
15 clientAddresses.length < 1 || clientAddresses.length > 4 || clientAddresses.some(address => isIP(address) !== 4) ||
16 !Number.isInteger(lifetimeMs) || lifetimeMs < 1 || lifetimeMs > 240000)
17 throw new Error('Invalid bounded NAT reflector configuration');
18 const sockets = [];
19 const entries = new Map();
20 const pending = new Map();
21 const forwarded = new Set();
22 const errors = [];
23 const counts = { received: 0, accepted: 0, sent: 0, discarded: 0 };
24 let remotePeer = peer ? probeEndpoint(peer) : undefined;
25 let closing;
26 let timer;
27 let resolveClosed;
28 const closed = new Promise(done => { resolveClosed = done; });
29 const close = () => {
30 if (closing) return closing;
31 clearTimeout(timer);
32 closing = (async () => {
33 const results = await Promise.allSettled(sockets.map(closeUdpSocket));
34 for (const result of results) if (result.status === 'rejected') errors.push(result.reason.code ?? 'close-error');
35 entries.clear(); pending.clear(); forwarded.clear();
36 resolveClosed();
37 })();
38 return closing;
39 };
40 const send = async (index, destination, operation, transaction, endpoint) => {
41 if (closing || counts.sent >= 256) throw new Error('Reflector stopped or outbound budget exhausted');
42 probeEndpoint(destination);
43 counts.sent += 1;
44 const packet = encodeProbeMessage({ token, transaction, operation, endpoint });
45 await new Promise((done, reject) => sockets[index].send(packet, destination.port, destination.address,
46 error => error ? reject(error) : done()));
47 };
48 const handle = async (index, bytes, source) => {
49 counts.received += 1;
50 if (counts.received > 512) { await close(); return; }
51 let message;
52 try { message = decodeProbeMessage(bytes, token); }
53 catch { counts.discarded += 1; return; }
54 const sender = { address: source.address, port: source.port };
55 const id = message.transaction.toString('hex');
56 const fromClient = clientAddresses.includes(sender.address) && sender.port >= 1024;
57 const fromPeer = sameEndpoint(sender, remotePeer);
58 // Forwarding can only come from the single admitted peer reflector, to an
59 // admitted client's address. It never accepts an arbitrary external target.
60 if (role === 'b' && index === 0 && fromPeer && message.operation === op.forward) {
61 if (!message.endpoint || !clientAddresses.includes(message.endpoint.address) ||
62 message.endpoint.port < 1024 || forwarded.has(id) || forwarded.size >= 64) return;
63 forwarded.add(id);
64 counts.accepted += 1;
65 await send(0, message.endpoint, op.probe, message.transaction);
66 await send(0, sender, op.sent, message.transaction);
67 return;
68 }
69 if (role === 'a' && index === 0 && fromPeer && message.operation === op.sent) {
70 const destination = pending.get(id);
71 if (!destination || message.endpoint) return;
72 pending.delete(id);
73 await send(0, destination, op.sent, message.transaction);
74 return;
75 }
76 if (!fromClient || message.endpoint) { counts.discarded += 1; return; }
77 counts.accepted += 1;
78 if (message.operation === op.lookup) {
79 const previous = entries.get(id);
80 if (previous && !sameEndpoint(previous.sender, sender)) return;
81 if (!previous && entries.size >= 64) return;
82 entries.set(id, previous ?? { sender, delivered: false });
83 await send(index, sender, op.observed, message.transaction, sender);
84 } else if (role === 'a' && index === 0 && message.operation === op.alternatePort) {
85 await send(1, sender, op.probe, message.transaction);
86 await send(0, sender, op.sent, message.transaction);
87 } else if (role === 'a' && index === 0 && message.operation === op.alternateAddress && remotePeer) {
88 if (pending.has(id) || pending.size >= 32) return;
89 pending.set(id, sender);
90 await send(0, remotePeer, op.forward, message.transaction, sender);
91 } else if (role === 'a' && index === 0 && message.operation === op.deliverStored) {
92 const stored = entries.get(id);
93 if (!stored || stored.delivered) return;
94 stored.delivered = true;
95 // The destination was observed by lookup, never supplied by this request.
96 await send(0, stored.sender, op.probe, message.transaction);
97 await send(0, sender, op.sent, message.transaction);
98 }
99 };
100 try {
101 for (let index = 0; index < ports.length; index += 1) {
102 const socket = createSocket('udp4');
103 sockets.push(socket);
104 socket.on('error', error => { errors.push(error.code ?? 'socket-error'); void close(); });
105 socket.on('message', (bytes, source) => {
106 void handle(index, bytes, source).catch(error => {
107 errors.push(error.code ?? 'send-error');
108 void close();
109 });
110 });
111 socket.bind(ports[index], bindAddress);
112 await once(socket, 'listening');
113 if (closing) throw new Error('Reflector stopped during binding');
114 }
115 const endpoints = sockets.map(socket => ({ address: bindAddress, port: socket.address().port }));
116 timer = setTimeout(() => { void close(); }, lifetimeMs);
117 return { endpoints, counts, errors, close, closed,
118 setPeer(endpoint) {
119 if (remotePeer) throw new Error('Reflector peer is already fixed');
120 remotePeer = probeEndpoint(endpoint);
121 } };
122 } catch (error) { await close(); throw error; }