@memnox/interceptors 0.1.1

package/dist/egress-cli.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import {
+  EGRESS_DEFAULT_PORT,
+  EGRESS_MAX_BODY_BYTES,
+  buildAuthorizer,
+  buildHold,
+  log
+} from "./chunk-SB27OD2T.js";
+
+// src/egress-cli.ts
+import { connect } from "net";
+import { createServer, request as httpRequest } from "http";
+
+// src/egress-seam.ts
+import {
+  DECISION_EFFECT,
+  describeEgress,
+  digest,
+  inspectEgress,
+  isAllowed as holdAllowed
+} from "@memnox/core";
+var EGRESS_REQUEST_ACTION = "http.request";
+var EGRESS_CONNECT_ACTION = "http.connect";
+var EGRESS_BLIND_SPOTS = [
+  "the payload inside an HTTPS tunnel \u2014 the destination is gated, the body is not",
+  "any connection that does not go through this proxy",
+  "a protocol that is not HTTP or CONNECT"
+];
+var CARRIED_HEADERS = [
+  "authorization",
+  "cookie",
+  "x-api-key",
+  "proxy-authorization"
+];
+var EgressSeam = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async gateRequest(attempt) {
+    const fields = fieldsOf(attempt);
+    const inspection = inspectEgress({ destination: attempt.url, fields });
+    if (inspection.findings.length > 0) {
+      return { allowed: false, message: describeEgress(inspection) };
+    }
+    return this.rule({
+      action: EGRESS_REQUEST_ACTION,
+      target: attempt.url,
+      arguments: fields,
+      ...this.deps.sessionId === void 0 ? {} : { sessionId: this.deps.sessionId }
+    });
+  }
+  /**
+   * All that is knowable about a tunnel is where it goes. Ruling on the destination and
+   * saying plainly that the body is unseen beats pretending to inspect it.
+   */
+  async gateConnect(authority) {
+    return this.rule({
+      action: EGRESS_CONNECT_ACTION,
+      target: authority,
+      ...this.deps.sessionId === void 0 ? {} : { sessionId: this.deps.sessionId }
+    });
+  }
+  async rule(request) {
+    const verdict = await this.deps.authorizer.authorize(request);
+    if (verdict.effect === DECISION_EFFECT.ALLOW) return { allowed: true };
+    if (verdict.effect === DECISION_EFFECT.ASK) {
+      const asked = await this.ask(request, verdict);
+      if (asked === null) return { allowed: true };
+      return asked;
+    }
+    return { allowed: false, message: describe(verdict) };
+  }
+  /**
+   * Puts an ask to a person. Null when it was allowed and the request may go.
+   *
+   * Without this an `ask` rule refused the request outright and told the reader "you
+   * chose to be asked about this" while nobody had been asked — the rule's own words
+   * arguing with what had just happened to them.
+   */
+  async ask(request, verdict) {
+    const hold = this.deps.hold;
+    if (hold === void 0) {
+      return {
+        allowed: false,
+        message: `${describe(verdict)} Nobody could be asked, so it did not go.`
+      };
+    }
+    const result = await hold.hold({
+      sessionId: this.deps.sessionId ?? "ses_local",
+      agent: "an agent",
+      operation: request.action,
+      fingerprint: digest(`${request.action}:${request.target ?? ""}`),
+      reason: verdict.reason,
+      ...request.target === void 0 ? {} : { target: request.target }
+    });
+    return holdAllowed(result) ? null : { allowed: false, message: describe(verdict) };
+  }
+};
+function fieldsOf(attempt) {
+  const fields = { method: attempt.method, url: attempt.url };
+  for (const name of CARRIED_HEADERS) {
+    const value = attempt.headers === void 0 ? void 0 : attempt.headers[name];
+    if (value !== void 0 && value.length > 0) fields[name] = value;
+  }
+  if (attempt.body !== void 0 && attempt.body.length > 0)
+    fields["body"] = attempt.body;
+  return fields;
+}
+function describe(verdict) {
+  const parts = [verdict.reason];
+  if (verdict.alternative !== void 0) {
+    const target = verdict.alternative.resource === void 0 ? "" : ` ${verdict.alternative.resource}`;
+    parts.push(
+      `Instead: ${verdict.alternative.action}${target} \u2014 ${verdict.alternative.note}`
+    );
+  }
+  if (verdict.approvalId !== void 0) {
+    parts.push(`Ask a person: memnox approvals resolve ${verdict.approvalId} --by <you>`);
+  }
+  if (verdict.decisionId !== void 0) {
+    parts.push(`Why: memnox why ${verdict.decisionId}`);
+  }
+  return parts.join(" ");
+}
+
+// src/egress-cli.ts
+var REFUSED_STATUS = 403;
+var TUNNEL_OK = "HTTP/1.1 200 Connection Established\r\n\r\n";
+var USAGE = `Usage: memnox-egress [--port <port>]
+
+An HTTP forward proxy that rules on what leaves this machine. Point an agent at it:
+
+  HTTP_PROXY=http://127.0.0.1:${EGRESS_DEFAULT_PORT} HTTPS_PROXY=http://127.0.0.1:${EGRESS_DEFAULT_PORT} <your agent>
+
+Blind to:
+${EGRESS_BLIND_SPOTS.map((spot) => `  ${spot}`).join("\n")}`;
+function portFrom(argv) {
+  const index = argv.indexOf("--port");
+  if (index === -1) return EGRESS_DEFAULT_PORT;
+  const raw = argv[index + 1];
+  if (raw === void 0) return null;
+  const port = Number(raw);
+  return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
+async function readBody(message) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of message) {
+    const buffer = chunk;
+    size += buffer.length;
+    if (size > EGRESS_MAX_BODY_BYTES) return void 0;
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function refuse(response, message) {
+  response.writeHead(REFUSED_STATUS, { "content-type": "text/plain" });
+  response.end(`Memnox denied this request.
+${message}
+`);
+}
+function buildServer(seam) {
+  const server = createServer((request, response) => {
+    void (async () => {
+      const url = request.url;
+      const method = request.method;
+      if (url === void 0 || method === void 0)
+        return refuse(response, "no request");
+      const body = await readBody(request);
+      const outcome = await seam.gateRequest({
+        method,
+        url,
+        headers: headersOf(request),
+        // Undefined means it was larger than this seam reads, not that it was empty.
+        ...body === void 0 ? {} : { body }
+      });
+      if (!outcome.allowed) {
+        log(`denied ${method} ${url}: ${outcome.message ?? ""}`);
+        return refuse(response, outcome.message ?? "no reason recorded");
+      }
+      forward(request, response, url, method, body);
+    })();
+  });
+  server.on("connect", (request, socket, head) => {
+    void (async () => {
+      const authority = request.url;
+      if (authority === void 0) return socket.destroy();
+      const outcome = await seam.gateConnect(authority);
+      if (!outcome.allowed) {
+        log(`denied CONNECT ${authority}: ${outcome.message ?? ""}`);
+        socket.end(
+          `HTTP/1.1 ${REFUSED_STATUS} Forbidden\r
+\r
+${outcome.message ?? ""}`
+        );
+        return;
+      }
+      tunnel(authority, socket, head);
+    })();
+  });
+  return server;
+}
+function headersOf(request) {
+  const headers = {};
+  for (const [name, value] of Object.entries(request.headers)) {
+    if (typeof value === "string") headers[name] = value;
+  }
+  return headers;
+}
+function forward(request, response, url, method, body) {
+  let target;
+  try {
+    target = new URL(url);
+  } catch {
+    return refuse(response, "this proxy takes absolute-form requests only");
+  }
+  const upstream = httpRequest(
+    {
+      protocol: target.protocol,
+      hostname: target.hostname,
+      port: target.port,
+      path: `${target.pathname}${target.search}`,
+      method,
+      headers: request.headers
+    },
+    (answer) => {
+      response.writeHead(answer.statusCode ?? 502, answer.headers);
+      answer.pipe(response);
+    }
+  );
+  upstream.on("error", (err) => {
+    log(`upstream failed for ${url}: ${String(err)}`);
+    response.writeHead(502).end();
+  });
+  if (body !== void 0) upstream.write(body);
+  upstream.end();
+}
+function tunnel(authority, socket, head) {
+  const [host, rawPort] = authority.split(":");
+  if (host === void 0) {
+    socket.destroy();
+    return;
+  }
+  const upstream = connect(Number(rawPort ?? "443"), host, () => {
+    socket.write(TUNNEL_OK);
+    upstream.write(head);
+    upstream.pipe(socket);
+    socket.pipe(upstream);
+  });
+  upstream.on("error", () => socket.destroy());
+  socket.on("error", () => upstream.destroy());
+}
+async function main() {
+  const port = portFrom(process.argv.slice(2));
+  if (port === null) {
+    process.stderr.write(`${USAGE}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const seam = new EgressSeam({
+    authorizer: await buildAuthorizer(),
+    /* An ask on the network seam has to reach a person, or `ask` is a slower `deny`. */
+    hold: buildHold()
+  });
+  buildServer(seam).listen(port, "127.0.0.1", () => {
+    log(`egress seam on 127.0.0.1:${port}`);
+    for (const spot of EGRESS_BLIND_SPOTS) log(`blind to: ${spot}`);
+  });
+}
+main().catch((err) => {
+  log(`egress seam failed to start, ruling on nothing: ${String(err)}`);
+  process.exitCode = 1;
+});

package/dist/git-credential-cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import {
+  buildAuthorizer,
+  log,
+  readStdin
+} from "./chunk-SB27OD2T.js";
+
+// src/git-credential-seam.ts
+import { DECISION_EFFECT } from "@memnox/core";
+var GIT_CREDENTIAL_ACTION = "git.credential";
+var QUIT = "quit=1\n";
+var GitCredentialSeam = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async gate(input) {
+    const fields = parseGitInput(input);
+    const target = remoteOf(fields);
+    const request = {
+      action: GIT_CREDENTIAL_ACTION,
+      ...target === void 0 ? {} : { target },
+      // LOCAL ONLY, and it never contains the credential — git has not issued one yet.
+      arguments: { ...fields },
+      ...this.deps.sessionId === void 0 ? {} : { sessionId: this.deps.sessionId }
+    };
+    const verdict = await this.deps.authorizer.authorize(request);
+    if (verdict.effect === DECISION_EFFECT.ALLOW) return { stdout: "" };
+    const where = target === void 0 ? "this remote" : target;
+    if (verdict.unreachable === true) {
+      return {
+        stdout: "",
+        message: `could not rule on ${where} \u2014 the runtime is unreachable, so git was left alone. A denied remote is reachable until it is back.`
+      };
+    }
+    return {
+      stdout: QUIT,
+      message: `no credential for ${where}: ${verdict.reason}`
+    };
+  }
+};
+function parseGitInput(input) {
+  const fields = {};
+  for (const line of input.split("\n")) {
+    if (line.length === 0) continue;
+    const separator = line.indexOf("=");
+    if (separator <= 0) continue;
+    const key = line.slice(0, separator).trim();
+    if (key === "password" || key === "credential") continue;
+    fields[key] = line.slice(separator + 1).trim();
+  }
+  return fields;
+}
+function remoteOf(fields) {
+  const host = fields["host"];
+  if (host === void 0 || host.length === 0) return void 0;
+  const protocol = fields["protocol"] ?? "https";
+  const path = fields["path"];
+  return `${protocol}://${host}${path === void 0 ? "" : `/${path}`}`;
+}
+
+// src/git-credential-cli.ts
+var OPERATION_GET = "get";
+async function main() {
+  const operation = process.argv[2];
+  if (operation !== OPERATION_GET) return;
+  const seam = new GitCredentialSeam({ authorizer: await buildAuthorizer() });
+  const outcome = await seam.gate(await readStdin());
+  if (outcome.message !== void 0) log(outcome.message);
+  if (outcome.stdout.length > 0) process.stdout.write(outcome.stdout);
+}
+main().catch((err) => {
+  log(`git seam failed, ruling on nothing: ${String(err)}`);
+});