sailfork / t3code-github / apps/ server/ src/ htmlRender/ publicProxy.ts

// @effect-diagnostics nodeBuiltinImport:off - Effect has no SOCKS proxy or address block list.
import * as NodeDnsPromises from "node:dns/promises";
import * as NodeNet from "node:net";
import * as NodeOS from "node:os";

import * as Effect from "effect/Effect";

const LOCAL_ADDRESSES = new NodeNet.BlockList();
for (const [network, prefix] of [
  ["0.0.0.0", 8],
  ["10.0.0.0", 8],
  ["100.64.0.0", 10],
  ["127.0.0.0", 8],
  ["169.254.0.0", 16],
  ["172.16.0.0", 12],
  ["192.168.0.0", 16],
  ["198.18.0.0", 15],
  ["224.0.0.0", 3],
] as const) {
  LOCAL_ADDRESSES.addSubnet(network, prefix, "ipv4");
}
// Block IPv4-carrying IPv6 ranges that translators may route without checking.
for (const [network, prefix] of [
  ["::", 96],
  ["64:ff9b:1::", 48],
  ["2001::", 32],
  ["fc00::", 7],
  ["fe80::", 10],
  ["ff00::", 8],
] as const) {
  LOCAL_ADDRESSES.addSubnet(network, prefix, "ipv6");
}

// Clash and Mihomo fake-IP DNS answers from here, inside the blocked 198.18.0.0/15.
const FAKE_IP = new NodeNet.BlockList();
FAKE_IP.addSubnet("198.18.0.0", 15, "ipv4");
const MAX_FAKE_IP_HOSTS = 3;

const NAT64 = new NodeNet.BlockList();
NAT64.addSubnet("64:ff9b::", 96, "ipv6");
const SIX_TO_FOUR = new NodeNet.BlockList();
SIX_TO_FOUR.addSubnet("2002::", 16, "ipv6");

const ipv6Groups = (address: string) => {
  const bare = address.split("%", 1)[0]!;
  const dotted = /(\d+)\.(\d+)\.(\d+)\.(\d+)$/.exec(bare);
  const text = dotted
    ? `${bare.slice(0, dotted.index)}${((+dotted[1]! << 8) | +dotted[2]!).toString(16)}:${((+dotted[3]! << 8) | +dotted[4]!).toString(16)}`
    : bare;
  const [head = "", tail] = text.split("::");
  const left = head ? head.split(":") : [];
  const right = tail ? tail.split(":") : [];
  const fill = tail === undefined ? 0 : 8 - left.length - right.length;
  return [...left, ...Array<string>(fill).fill("0"), ...right].map((group) =>
    Number.parseInt(group, 16),
  );
};

// Check the translated IPv4 too, while allowing public NAT64 targets on IPv6-only networks.
const embeddedIPv4 = (address: string) => {
  const at = NAT64.check(address, "ipv6") ? 6 : SIX_TO_FOUR.check(address, "ipv6") ? 1 : -1;
  if (at === -1) return undefined;
  const groups = ipv6Groups(address);
  const high = groups[at] ?? 0;
  const low = groups[at + 1] ?? 0;
  return [high >> 8, high & 0xff, low >> 8, low & 0xff].join(".");
};

const ownAddresses = () => {
  const own = new NodeNet.BlockList();
  for (const entry of Object.values(NodeOS.networkInterfaces()).flat()) {
    if (entry) own.addAddress(entry.address, entry.family === "IPv6" ? "ipv6" : "ipv4");
  }
  return own;
};

const isLocal = (address: string, family: number): boolean => {
  const type = family === 6 ? "ipv6" : "ipv4";
  if (LOCAL_ADDRESSES.check(address, type) || ownAddresses().check(address, type)) return true;
  const embedded = family === 6 ? embeddedIPv4(address) : undefined;
  return embedded !== undefined && isLocal(embedded, 4);
};

// Connect only to checked addresses to prevent DNS rebinding.
const publicAddresses = async (host: string, fakeIpHosts: Map<string, string>) => {
  const addresses = NodeNet.isIP(host)
    ? [{ address: host, family: NodeNet.isIP(host) }]
    : await NodeDnsPromises.lookup(host, { all: true, verbatim: true }).catch(() => []);
  if (addresses.length === 0) return undefined;
  const local = addresses.some(({ address, family }) => isLocal(address, family));
  if (!local) return addresses;
  const fake =
    !NodeNet.isIP(host) &&
    addresses.every(({ address, family }) => family === 4 && FAKE_IP.check(address, "ipv4"));
  if (fake && fakeIpHosts.size < MAX_FAKE_IP_HOSTS && !fakeIpHosts.has(host)) {
    fakeIpHosts.set(host, addresses[0]!.address);
  }
  return undefined;
};

// SOCKS5 (RFC 1928) replies: success, refused by rule, host unreachable, command unsupported.
const reply = (code: number) => Buffer.from([5, code, 0, 1, 0, 0, 0, 0, 0, 0]);

const MAX_EARLY_BYTES = 64 * 1024;

const refuse = (client: NodeNet.Socket, code: number) => {
  client.end(reply(code), () => client.destroy());
};

const readRequest = (data: Buffer) => {
  if (data.length < 5) return "short" as const;
  if (data[0] !== 5 || data[2] !== 0) return undefined;
  const type = data[3];
  const end = type === 1 ? 10 : type === 3 ? 7 + data[4]! : type === 4 ? 22 : -1;
  if (end === -1) return undefined;
  if (data.length < end) return "short" as const;
  const host =
    type === 1
      ? [...data.subarray(4, 8)].join(".")
      : type === 3
        ? data.subarray(5, 5 + data[4]!).toString("latin1")
        : Array.from({ length: 8 }, (_, index) =>
            data.readUInt16BE(4 + index * 2).toString(16),
          ).join(":");
  return { command: data[1], host, port: data.readUInt16BE(end - 2), rest: data.subarray(end) };
};

/** Covers requests Chrome's Local Network Access misses, including speculation prefetches. */
export const publicProxy = Effect.acquireRelease(
  Effect.callback<
    {
      readonly server: NodeNet.Server;
      readonly sockets: Set<NodeNet.Socket>;
      readonly fakeIpHosts: ReadonlyMap<string, string>;
    },
    Error
  >((resume) => {
    const sockets = new Set<NodeNet.Socket>();
    const fakeIpHosts = new Map<string, string>();
    const track = (socket: NodeNet.Socket) => {
      sockets.add(socket);
      socket.on("close", () => sockets.delete(socket));
      socket.on("error", () => socket.destroy());
      return socket;
    };
    const server = NodeNet.createServer((client) => {
      track(client);
      let data = Buffer.alloc(0);
      let greeted = false;
      const onData = (chunk: Buffer) => {
        data = Buffer.concat([data, chunk]);
        if (!greeted) {
          if (data.length < 2 || data.length < 2 + data[1]!) return;
          if (data[0] !== 5 || !data.subarray(2, 2 + data[1]!).includes(0)) {
            return void client.end(Buffer.from([5, 0xff]));
          }
          data = data.subarray(2 + data[1]!);
          greeted = true;
          client.write(Buffer.from([5, 0]));
        }
        const request = readRequest(data);
        if (request === "short") return;
        client.off("data", onData);
        if (request === undefined || request.command !== 1 || request.port === 0) {
          return refuse(client, 7);
        }
        const early: Array<Buffer> = [request.rest];
        let earlyBytes = request.rest.length;
        const holdEarly = (chunk: Buffer) => {
          earlyBytes += chunk.length;
          if (earlyBytes > MAX_EARLY_BYTES) return void client.destroy();
          early.push(chunk);
        };
        client.on("data", holdEarly);
        void publicAddresses(request.host, fakeIpHosts).then((addresses) => {
          if (client.destroyed) return;
          client.off("data", holdEarly);
          if (addresses === undefined) return refuse(client, 2);
          client.pause();
          // Try all checked addresses so broken IPv6 routes do not block IPv4 access.
          const upstream = track(
            NodeNet.connect({
              host: request.host,
              port: request.port,
              autoSelectFamily: true,
              lookup: (_host, options, callback) =>
                options.all
                  ? callback(null, addresses)
                  : callback(null, addresses[0]!.address, addresses[0]!.family),
            }),
          );
          upstream.once("connect", () => {
            client.write(reply(0));
            for (const chunk of early) upstream.write(chunk);
            upstream.pipe(client);
            client.pipe(upstream);
          });
          upstream.on("close", () => client.destroy());
          client.on("close", () => upstream.destroy());
        });
      };
      client.on("data", onData);
    });
    let listening = false;
    server.on("error", (error) => {
      if (!listening) resume(Effect.fail(error));
    });
    server.listen(0, "127.0.0.1", () => {
      listening = true;
      resume(Effect.succeed({ server, sockets, fakeIpHosts }));
    });
  }),
  ({ server, sockets }) =>
    Effect.callback<void>((resume) => {
      for (const socket of sockets) socket.destroy();
      server.close(() => resume(Effect.void));
    }),
).pipe(
  Effect.map(({ server, fakeIpHosts }) => {
    const address = server.address();
    const port = typeof address === "object" && address !== null ? address.port : 0;
    return { port, fakeIpHosts };
  }),
);