AtlatestRepositorysigil-nat
1
// Owned, short-lived measurement reflectors. No unauthenticated UDP replies.2
import { createSocket } from 'node:dgram';3
import { once } from 'node:events';4
import { isIP } from 'node:net';5
import { closeUdpSocket } from './socket-cleanup.mjs';6
import { decodeProbeMessage, encodeProbeMessage, probeEndpoint, sameEndpoint,7
probeOperations as op } from './nat-probe-wire.mjs';9
export 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 an59
// 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; }123
}