@landstrip/landstrip 0.18.38 → 0.20.11

package/lib/proxy.js

@@ -1,304 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-'use strict';
-
-const { lookup } = require('node:dns/promises');
-const { BlockList, connect, createServer, isIP } = require('node:net');
-
-const prohibitedProxyAddresses = new 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.0.0.0', 24],
-  ['192.168.0.0', 16],
-  ['198.18.0.0', 15],
-  ['224.0.0.0', 4],
-  ['240.0.0.0', 4],
-]) {
-  prohibitedProxyAddresses.addSubnet(network, prefix, 'ipv4');
-}
-for (const [network, prefix] of [
-  ['::', 128],
-  ['::1', 128],
-  ['fc00::', 7],
-  ['fe80::', 10],
-  ['ff00::', 8],
-]) {
-  prohibitedProxyAddresses.addSubnet(network, prefix, 'ipv6');
-}
-
-function parseProxyPort(value, defaultPort) {
-  const rawPort = value ?? String(defaultPort);
-  if (!/^\d+$/.test(rawPort)) return null;
-
-  const port = Number(rawPort);
-  return port >= 1 && port <= 65535 ? port : null;
-}
-
-function splitHostPort(target, defaultPort) {
-  const bracketMatch = target.match(/^\[([^\]]+)\](?::(.*))?$/);
-  const host = bracketMatch?.[1];
-  if (host) {
-    const port = parseProxyPort(bracketMatch[2], defaultPort);
-    return port === null ? null : { host, port };
-  }
-
-  const lastColon = target.lastIndexOf(':');
-  if (lastColon > -1 && target.indexOf(':') === lastColon) {
-    const port = parseProxyPort(target.slice(lastColon + 1), defaultPort);
-    return port === null ? null : { host: target.slice(0, lastColon), port };
-  }
-
-  return { host: target, port: defaultPort };
-}
-
-function denyProxyRequest(client, status = '403 Forbidden') {
-  client.write(`HTTP/1.1 ${status}\r\nContent-Length: 0\r\n\r\n`);
-  client.end();
-}
-
-function isPublicProxyAddress(address, family = isIP(address)) {
-  if (family === 4) return !prohibitedProxyAddresses.check(address, 'ipv4');
-  if (family === 6) return !prohibitedProxyAddresses.check(address, 'ipv6');
-  return false;
-}
-
-async function resolveProxyEndpoint(host) {
-  const literalFamily = isIP(host);
-  if (literalFamily === 4 || literalFamily === 6) {
-    if (!isPublicProxyAddress(host, literalFamily)) {
-      throw new Error(`Proxy destination is not public: ${host}`);
-    }
-    return { address: host, family: literalFamily };
-  }
-
-  const addresses = await lookup(host, { all: true, verbatim: true });
-  if (
-    addresses.length === 0 ||
-    addresses.some(({ address, family }) => !isPublicProxyAddress(address, family))
-  ) {
-    throw new Error(`Proxy destination resolves to a non-public address: ${host}`);
-  }
-
-  const endpoint = addresses[0];
-  if (endpoint.family !== 4 && endpoint.family !== 6) {
-    throw new Error(`Proxy could not resolve destination: ${host}`);
-  }
-  return { address: endpoint.address, family: endpoint.family };
-}
-
-function pipeSockets(client, upstream, initialData) {
-  upstream.on('error', () => client.destroy());
-  client.on('error', () => upstream.destroy());
-
-  if (initialData?.length) upstream.write(initialData);
-
-  client.pipe(upstream);
-  upstream.pipe(client);
-}
-
-function startFilterProxy(options) {
-  const { isDomainAllowed, authorization, portRange } = options;
-  const sockets = new Set();
-
-  // Track the upstream socket so stop() tears it down, and abandon a still-
-  // connecting upstream when its client goes away — otherwise a connect to a
-  // black-holed host lingers in SYN-retry (~2 min), leaking an fd per request.
-  function trackUpstream(upstream, client, settled) {
-    sockets.add(upstream);
-    upstream.once('close', () => sockets.delete(upstream));
-    client.once('close', () => {
-      if (!settled()) upstream.destroy();
-    });
-  }
-
-  async function handleConnect(client, target, rest) {
-    const endpoint = splitHostPort(target, 443);
-    if (!endpoint) {
-      denyProxyRequest(client, '400 Bad Request');
-      return;
-    }
-
-    if (!(await isDomainAllowed(endpoint.host))) {
-      denyProxyRequest(client);
-      return;
-    }
-
-    const resolved = await resolveProxyEndpoint(endpoint.host);
-    let settled = false;
-    const upstream = connect(
-      { host: resolved.address, port: endpoint.port, family: resolved.family },
-      () => {
-        settled = true;
-        client.write('HTTP/1.1 200 Connection Established\r\n\r\n');
-        pipeSockets(client, upstream, rest);
-      },
-    );
-    trackUpstream(upstream, client, () => settled);
-    upstream.once('error', () => {
-      if (settled) return;
-      settled = true;
-      denyProxyRequest(client, '502 Bad Gateway');
-    });
-  }
-
-  async function handleHttp(client, headerText, rest) {
-    const lines = headerText.split(/\r?\n/);
-    const requestLine = lines[0];
-    if (!requestLine) {
-      denyProxyRequest(client, '400 Bad Request');
-      return;
-    }
-
-    const [method, rawTarget, version] = requestLine.split(' ');
-    if (!method || !rawTarget || !version) {
-      denyProxyRequest(client, '400 Bad Request');
-      return;
-    }
-
-    let url;
-    try {
-      url = new URL(rawTarget);
-    } catch {
-      const host = lines
-        .find((line) => line.toLowerCase().startsWith('host:'))
-        ?.slice(5)
-        .trim();
-      if (!host) {
-        denyProxyRequest(client, '400 Bad Request');
-        return;
-      }
-
-      try {
-        url = new URL(`http://${host}${rawTarget}`);
-      } catch {
-        denyProxyRequest(client, '400 Bad Request');
-        return;
-      }
-    }
-
-    if (!(await isDomainAllowed(url.hostname))) {
-      denyProxyRequest(client);
-      return;
-    }
-
-    const port = parseProxyPort(url.port || undefined, url.protocol === 'https:' ? 443 : 80);
-    if (port === null) {
-      denyProxyRequest(client, '400 Bad Request');
-      return;
-    }
-
-    const path = `${url.pathname}${url.search}` || '/';
-    lines[0] = `${method} ${path} ${version}`;
-
-    const rewrittenHeader = lines
-      .filter(
-        (line) =>
-          !line.toLowerCase().startsWith('proxy-connection:') &&
-          !line.toLowerCase().startsWith('proxy-authorization:'),
-      )
-      .map((line) => (line.toLowerCase().startsWith('host:') ? `Host: ${url.host}` : line))
-      .join('\r\n');
-    const resolved = await resolveProxyEndpoint(url.hostname);
-    let settled = false;
-    const upstream = connect({ host: resolved.address, port, family: resolved.family }, () => {
-      settled = true;
-      upstream.write(`${rewrittenHeader}\r\n\r\n`);
-      pipeSockets(client, upstream, rest);
-    });
-    trackUpstream(upstream, client, () => settled);
-    upstream.once('error', () => {
-      if (settled) return;
-      settled = true;
-      denyProxyRequest(client, '502 Bad Gateway');
-    });
-  }
-
-  function handleClient(client) {
-    sockets.add(client);
-    client.on('close', () => sockets.delete(client));
-    client.on('error', () => sockets.delete(client));
-
-    let buffered = Buffer.alloc(0);
-
-    client.on('data', (chunk) => {
-      buffered = Buffer.concat([buffered, chunk]);
-      const headerEnd = buffered.indexOf('\r\n\r\n');
-      if (headerEnd === -1) {
-        if (buffered.length > 65536) {
-          client.removeAllListeners('data');
-          client.pause();
-          denyProxyRequest(client, '431 Request Header Fields Too Large');
-        }
-        return;
-      }
-
-      client.pause();
-      client.removeAllListeners('data');
-
-      const header = buffered.subarray(0, headerEnd).toString('utf-8');
-      const rest = buffered.subarray(headerEnd + 4);
-      if (authorization) {
-        const supplied = header
-          .split(/\r?\n/)
-          .find((line) => line.toLowerCase().startsWith('proxy-authorization:'))
-          ?.slice('proxy-authorization:'.length)
-          .trim();
-        if (supplied !== authorization) {
-          denyProxyRequest(client, '407 Proxy Authentication Required');
-          return;
-        }
-      }
-      const [method, target] = header.split(/\r?\n/, 1)[0].split(' ');
-
-      const task =
-        method?.toUpperCase() === 'CONNECT' && target
-          ? handleConnect(client, target, rest)
-          : handleHttp(client, header, rest);
-      task.catch(() => denyProxyRequest(client, '502 Bad Gateway'));
-    });
-  }
-
-  const server = createServer(handleClient);
-  let stopped = false;
-
-  return new Promise((resolve, reject) => {
-    const listen = (port) => {
-      server.once('error', (error) => {
-        if (error.code === 'EADDRINUSE' && portRange && port < portRange.high) {
-          listen(port + 1);
-          return;
-        }
-        reject(error);
-      });
-      server.listen(port, '127.0.0.1', () => {
-        server.removeAllListeners('error');
-        const address = server.address();
-
-        resolve({
-          port: address.port,
-          stop: () =>
-            new Promise((done) => {
-              if (stopped) {
-                done();
-                return;
-              }
-              stopped = true;
-              for (const socket of sockets) socket.destroy();
-              server.close(() => done());
-            }),
-        });
-      });
-    };
-    listen(portRange ? portRange.low : 0);
-  });
-}
-
-module.exports = {
-  isPublicProxyAddress,
-  startFilterProxy,
-};

package/lib/shared.d.ts

@@ -1,57 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-import type {
-  LandstripControlResponse,
-  LandstripFilesystemTrap,
-  LandstripNetworkTrap,
-  LandstripTrap,
-} from './index.js';
-
-export type LandstripDenialTrap = LandstripFilesystemTrap | LandstripNetworkTrap;
-
-export function isRecord(value: unknown): value is Record<string, unknown>;
-
-export function expandHomePath(path: string): string;
-
-export function expandPath(filePath: string, baseDirectory: string): string;
-
-export function canonicalizePath(filePath: string, baseDirectory: string): string;
-
-export function canonicalizeGlobPattern(pattern: string, baseDirectory: string): string;
-
-export function normalizePathSeparators(path: string): string;
-
-export function globToRegExp(globPattern: string): RegExp;
-
-export function pathUnderDirectory(filePath: string, dir: string): boolean;
-
-export function sessionAllows(prefixes: Set<string>, filePath: string): boolean;
-
-export function sessionScopeFor(filePath: string, baseDirectory: string): string;
-
-export function domainMatchesPattern(domain: string, pattern: string): boolean;
-
-export function domainMatchesAny(domain: string, patterns: string[]): boolean;
-
-export function allowsAllDomains(allowedDomains: string[]): boolean;
-
-export function decodeLandstripTrap(value: unknown): LandstripTrap | null;
-
-export function parseTrapLine(line: string): LandstripTrap | null;
-
-export function parseLandstripTraps(output: string): LandstripTrap[];
-
-export function isFilesystemTrap(trap: LandstripTrap): trap is LandstripFilesystemTrap;
-
-export function isDenialTrap(trap: LandstripTrap): trap is LandstripDenialTrap;
-
-export function isQueryTrap(trap: LandstripTrap): trap is LandstripDenialTrap;
-
-export function formatLandstripTrap(trap: LandstripTrap): string;
-
-export function formatLandstripTraps(traps: LandstripTrap[]): string;
-
-export function controlResponseLine(
-  queryId: string,
-  action: LandstripControlResponse['action'],
-): string;

package/lib/shared.js

@@ -1,299 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-'use strict';
-
-const { lstatSync, readlinkSync, realpathSync } = require('node:fs');
-const { homedir } = require('node:os');
-const { basename, dirname, isAbsolute, join, relative, resolve, sep } = require('node:path');
-
-function isRecord(value) {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function expandHomePath(value) {
-  if (value === '~' || value === '$HOME') return homedir();
-  if (value.startsWith('~/')) return join(homedir(), value.slice(2));
-  if (value.startsWith('$HOME/')) return join(homedir(), value.slice(6));
-  return value;
-}
-
-function pathUnderDirectory(filePath, dir) {
-  const child = relative(dir, filePath);
-  return child === '' || (!isAbsolute(child) && child !== '..' && !child.startsWith(`..${sep}`));
-}
-
-function sessionAllows(prefixes, filePath) {
-  for (const prefix of prefixes) {
-    if (pathUnderDirectory(filePath, prefix)) return true;
-  }
-  return false;
-}
-
-// The broadest ancestor worth approving in one action: the immediate child of
-// `$HOME` (e.g. `~/.cargo`) for paths under the user's home, the project root
-// for paths under it, otherwise the containing directory. A file sitting
-// directly on a boundary falls back to the exact file so nothing widens
-// silently.
-function sessionScopeFor(filePath, baseDirectory) {
-  const dir = dirname(filePath);
-  const homeBoundaries = new Set([homedir()]);
-  try {
-    homeBoundaries.add(realpathSync.native(homedir()));
-  } catch {
-    // $HOME not resolvable — fall back to the raw value only.
-  }
-
-  for (const boundary of homeBoundaries) {
-    if (pathUnderDirectory(dir, boundary)) {
-      const first = relative(boundary, dir).split(sep)[0];
-      if (!first) return filePath;
-      return join(boundary, first);
-    }
-  }
-
-  const projectBoundaries = new Set([baseDirectory]);
-  try {
-    projectBoundaries.add(realpathSync.native(baseDirectory));
-  } catch {
-    // Project directory not resolvable — fall back to the raw value only.
-  }
-
-  for (const boundary of projectBoundaries) {
-    if (pathUnderDirectory(dir, boundary)) return boundary;
-  }
-
-  return dir;
-}
-
-function domainMatchesPattern(domain, pattern) {
-  // A trailing dot ("pastebin.com.") is the same host to DNS but would slip
-  // past a literal deny entry; strip it from both sides before matching.
-  const normalizedDomain = domain.toLowerCase().replace(/\.+$/, '');
-  const normalizedPattern = pattern.toLowerCase().replace(/\.+$/, '');
-
-  if (normalizedPattern === '*') return true;
-  if (normalizedPattern.startsWith('*.')) {
-    const base = normalizedPattern.slice(2);
-    return normalizedDomain === base || normalizedDomain.endsWith(`.${base}`);
-  }
-
-  return normalizedDomain === normalizedPattern;
-}
-
-function domainMatchesAny(domain, patterns) {
-  return patterns.some((pattern) => domainMatchesPattern(domain, pattern));
-}
-
-function allowsAllDomains(allowedDomains) {
-  return allowedDomains.includes('*');
-}
-
-// landstrip emits each trap as a flat JSON record tagged by a `kind`
-// discriminant (`filesystem`, `network`, `launch`, `usage`, `internal`)
-// alongside a stable `code` and variant-specific fields. The declarations it
-// ships are erased at compile time, so validate the fields callers read
-// before trusting a decoded line. `state` is deliberately not validated: a
-// missing or unknown state degrades to "informational", the safe direction.
-// `query_id` must be a string — landstrip < 0.17 sent a number, and a
-// numeric id fails its own deserializer when echoed back.
-const LANDSTRIP_OPERATIONS = new Set(['read', 'write']);
-
-function isLandstripTrap(value) {
-  if (!isRecord(value)) return false;
-
-  switch (value.kind) {
-    case 'filesystem':
-      return (
-        LANDSTRIP_OPERATIONS.has(value.operation) &&
-        typeof value.path === 'string' &&
-        typeof value.query_id === 'string'
-      );
-    case 'network':
-      return (
-        typeof value.operation === 'string' &&
-        typeof value.target === 'string' &&
-        typeof value.query_id === 'string'
-      );
-    case 'launch':
-      return typeof value.program === 'string' && typeof value.message === 'string';
-    case 'usage':
-      return typeof value.message === 'string';
-    case 'internal':
-      return typeof value.code === 'string' && typeof value.message === 'string';
-    default:
-      return false;
-  }
-}
-
-function decodeLandstripTrap(value) {
-  return isLandstripTrap(value) ? value : null;
-}
-
-function parseTrapLine(line) {
-  try {
-    const parsed = JSON.parse(line);
-    return isLandstripTrap(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function parseLandstripTraps(output) {
-  const traps = [];
-
-  for (const line of output.split('\n')) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0 || trimmed[0] !== '{') continue;
-    const trap = parseTrapLine(trimmed);
-    if (trap) traps.push(trap);
-  }
-
-  return traps;
-}
-
-function isFilesystemTrap(trap) {
-  return trap.kind === 'filesystem';
-}
-
-// filesystem and network traps report an access the policy denied; launch,
-// usage and internal traps report that landstrip itself failed.
-function isDenialTrap(trap) {
-  return trap.kind === 'filesystem' || trap.kind === 'network';
-}
-
-// A `state: "query"` trap suspends the child's syscall until the host answers
-// it on the trap socket. An `info` trap is terminal.
-function isQueryTrap(trap) {
-  return isDenialTrap(trap) && trap.state === 'query';
-}
-
-function formatLandstripTrap(trap) {
-  switch (trap.kind) {
-    case 'filesystem':
-      return `landstrip: filesystem ${trap.operation} denied (${trap.path})${
-        trap.mechanism ? ` [${trap.mechanism}]` : ''
-      }`;
-    case 'network':
-      return `landstrip: network ${trap.operation} denied (${trap.target})${
-        trap.mechanism ? ` [${trap.mechanism}]` : ''
-      }`;
-    case 'launch':
-      return `landstrip: launch failed (${trap.program})${trap.message ? `: ${trap.message}` : ''}`;
-    case 'usage':
-      return `landstrip: usage error: ${trap.message}`;
-    case 'internal': {
-      const mechanism = trap.mechanism ? ` [${trap.mechanism}]` : '';
-      return `landstrip: ${trap.code}${mechanism}: ${trap.message}`;
-    }
-  }
-}
-
-function formatLandstripTraps(traps) {
-  return traps.map(formatLandstripTrap).join('\n');
-}
-
-// Relative entries (notably ".") resolve against the caller-supplied base
-// directory — the command's working directory that landstrip itself uses as
-// its policy base — never the host process's own cwd.
-function expandPath(filePath, baseDirectory) {
-  return resolve(baseDirectory, expandHomePath(filePath));
-}
-
-function canonicalizePath(filePath, baseDirectory, seen = new Set()) {
-  const abs = expandPath(filePath, baseDirectory);
-  const missing = [];
-  let existing = abs;
-
-  for (;;) {
-    try {
-      const stat = lstatSync(existing);
-      if (stat.isSymbolicLink()) {
-        if (seen.has(existing)) return abs;
-        seen.add(existing);
-        const target = resolve(dirname(existing), readlinkSync(existing), ...missing);
-        return canonicalizePath(target, baseDirectory, seen);
-      }
-      break;
-    } catch {
-      const parent = dirname(existing);
-      if (parent === existing) return abs;
-      missing.unshift(basename(existing));
-      existing = parent;
-    }
-  }
-
-  try {
-    return resolve(realpathSync.native(existing), ...missing);
-  } catch {
-    return abs;
-  }
-}
-
-function canonicalizeGlobPattern(pattern, baseDirectory) {
-  const expanded = expandPath(pattern, baseDirectory);
-  const wildcard = expanded.indexOf('*');
-  if (wildcard < 0) return canonicalizePath(expanded, baseDirectory);
-
-  const prefix = expanded.slice(0, wildcard);
-  const base = prefix.endsWith(sep) ? prefix : dirname(prefix);
-  const suffixOffset = base.endsWith(sep) ? base.length - 1 : base.length;
-  const canonicalBase = canonicalizePath(base, baseDirectory);
-  const suffix = expanded.slice(suffixOffset);
-  return canonicalBase.endsWith(sep) && suffix.startsWith(sep)
-    ? `${canonicalBase}${suffix.slice(1)}`
-    : `${canonicalBase}${suffix}`;
-}
-
-function normalizePathSeparators(path) {
-  return process.platform === 'win32' ? path.replaceAll('\\', '/') : path;
-}
-
-const globRegExpCache = new Map();
-
-// Translates an absolute glob pattern to a regular expression using standard
-// path semantics: `**` crosses directory boundaries (and `**/` may match zero
-// segments), while a single `*` is confined to one path segment.
-function globToRegExp(globPattern) {
-  const cached = globRegExpCache.get(globPattern);
-  if (cached) return cached;
-
-  const escaped = globPattern
-    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-    .replace(/\*\*\/|\*\*|\*/g, (token) =>
-      token === '**/' ? '(?:.*/)?' : token === '**' ? '.*' : '[^/]*',
-    );
-  const result = new RegExp(`^${escaped}$`);
-  globRegExpCache.set(globPattern, result);
-  return result;
-}
-
-// The broker matches an answer to its query by the exact decimal `query_id`
-// string the trap carried. A numeric id fails its deserializer, the line is
-// dropped, and the child's syscall stays suspended.
-function controlResponseLine(queryId, action) {
-  return JSON.stringify({ query_id: queryId, action }) + '\n';
-}
-
-module.exports = {
-  isRecord,
-  expandHomePath,
-  expandPath,
-  canonicalizePath,
-  canonicalizeGlobPattern,
-  normalizePathSeparators,
-  globToRegExp,
-  pathUnderDirectory,
-  sessionAllows,
-  sessionScopeFor,
-  domainMatchesPattern,
-  domainMatchesAny,
-  allowsAllDomains,
-  decodeLandstripTrap,
-  parseTrapLine,
-  parseLandstripTraps,
-  isFilesystemTrap,
-  isDenialTrap,
-  isQueryTrap,
-  formatLandstripTrap,
-  formatLandstripTraps,
-  controlResponseLine,
-};