Skip to content

An open source, self-hosted, real-time port monitoring and discovery tool.

3.5 KB
Raw Blame
const dns = require("dns").promises;
const net = require("net");

const blockedAddresses = new net.BlockList();

for (const [network, prefix] of [
  ["0.0.0.0", 8],
  ["127.0.0.0", 8],
  ["169.254.0.0", 16],
  ["192.0.0.0", 24],
  ["192.0.2.0", 24],
  ["192.88.99.0", 24],
  ["198.18.0.0", 15],
  ["198.51.100.0", 24],
  ["203.0.113.0", 24],
  ["224.0.0.0", 4],
  ["240.0.0.0", 4],
]) {
  blockedAddresses.addSubnet(network, prefix, "ipv4");
}

for (const [network, prefix] of [
  ["::", 128],
  ["::", 96],
  ["::1", 128],
  ["64:ff9b::", 96],
  ["64:ff9b:1::", 48],
  ["fe80::", 10],
  ["fec0::", 10],
  ["ff00::", 8],
  ["2001::", 32],
  ["2001:db8::", 32],
  ["2002::", 16],
]) {
  blockedAddresses.addSubnet(network, prefix, "ipv6");
}

function cleanAddress(address) {
  return String(address || "")
    .replace(/^\[|\]$/g, "")
    .split("%")[0];
}

function isBlockedAddress(address) {
  const clean = cleanAddress(address);
  const family = net.isIP(clean);
  if (family === 4) {
    return blockedAddresses.check(clean, "ipv4");
  }
  if (family === 6) {
    if (clean.toLowerCase().startsWith("::ffff:")) {
      return true;
    }
    return blockedAddresses.check(clean, "ipv6");
  }
  return true;
}

function normalizeUrl(parsed) {
  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
  return parsed.toString().replace(/\/$/, "");
}

async function resolveAddresses(hostname, lookup) {
  const clean = cleanAddress(hostname);
  const family = net.isIP(clean);
  if (family) {
    return [{ address: clean, family }];
  }

  const records = await lookup(clean, { all: true, verbatim: true });
  const addresses = Array.isArray(records) ? records : [records];
  if (!addresses.length) {
    throw new Error("Autoxpose URL hostname did not resolve");
  }
  return addresses;
}

async function resolveAutoxposeUrl(value, options = {}) {
  if (typeof value !== "string" || !value.trim()) {
    throw new Error("Autoxpose URL is required");
  }

  let parsed;
  try {
    parsed = new URL(value.trim());
  } catch {
    throw new Error("Autoxpose URL is invalid");
  }

  if (!['http:', 'https:'].includes(parsed.protocol)) {
    throw new Error("Autoxpose URL must use HTTP or HTTPS");
  }
  if (parsed.username || parsed.password) {
    throw new Error("Autoxpose URL cannot include credentials");
  }
  if (parsed.search || parsed.hash) {
    throw new Error("Autoxpose URL cannot include a query or fragment");
  }

  const lookup = options.lookup || dns.lookup;
  const addresses = await resolveAddresses(parsed.hostname, lookup);
  const normalizedAddresses = addresses.map(({ address }) => {
    const clean = cleanAddress(address);
    const family = net.isIP(clean);
    if (!family) {
      throw new Error("Autoxpose URL hostname returned an invalid address");
    }
    return { address: clean, family };
  });
  if (normalizedAddresses.some(({ address }) => isBlockedAddress(address))) {
    throw new Error("Autoxpose URL resolves to an address that is not allowed");
  }

  return {
    url: normalizeUrl(parsed),
    addresses: normalizedAddresses,
  };
}

async function validateAutoxposeUrl(value, options = {}) {
  const resolution = await resolveAutoxposeUrl(value, options);
  return resolution.url;
}

function buildAutoxposeEndpoint(baseUrl, endpoint) {
  const base = `${String(baseUrl).replace(/\/+$/, "")}/`;
  const relative = String(endpoint || "").replace(/^\/+/, "");
  return new URL(relative, base).toString();
}

module.exports = {
  buildAutoxposeEndpoint,
  isBlockedAddress,
  resolveAutoxposeUrl,
  validateAutoxposeUrl,
};