@fntio/infra-client
Version:
Self-hosted AWS access portal: credential vending, target-account trust, and grant-driven private networking as CDK stacks and constructs.
287 lines (282 loc) • 10.9 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// lambdacode/network/keyminter.ts
var keyminter_exports = {};
__export(keyminter_exports, {
RECONCILER_START_TIMEOUT_MS: () => RECONCILER_START_TIMEOUT_MS,
connectorHandler: () => connectorHandler,
deviceHandler: () => deviceHandler
});
module.exports = __toCommonJS(keyminter_exports);
var import_client_lambda = require("@aws-sdk/client-lambda");
// lambdacode/network/headscale-http.ts
var https = __toESM(require("node:https"));
var import_client_ssm = require("@aws-sdk/client-ssm");
var ssm = new import_client_ssm.SSMClient({});
var sources = /* @__PURE__ */ new Map();
var cached = /* @__PURE__ */ new Map();
var CERT_TTL_MS = 6e4;
function trustHeadscale(url, certParam) {
if (certParam) sources.set(new URL(url).origin, certParam);
}
async function certificateFor(origin, fresh) {
const param = sources.get(origin);
if (!param) throw new Error(`no certificate source registered for ${origin}`);
const hit = cached.get(param);
if (!fresh && hit && Date.now() - hit.at < CERT_TTL_MS) return hit.pem;
const out = await ssm.send(new import_client_ssm.GetParameterCommand({ Name: param }));
const pem = out.Parameter?.Value;
if (!pem) throw new Error(`certificate parameter ${param} is empty`);
cached.set(param, { pem, at: Date.now() });
return pem;
}
var TLS_FAILURES = /* @__PURE__ */ new Set([
"DEPTH_ZERO_SELF_SIGNED_CERT",
"SELF_SIGNED_CERT_IN_CHAIN",
"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
"CERT_SIGNATURE_FAILURE",
"CERT_HAS_EXPIRED",
"ERR_TLS_CERT_ALTNAME_INVALID"
]);
var isTlsFailure = (err) => TLS_FAILURES.has(String(err?.code));
function request2(url, init, ca) {
return new Promise((resolve, reject) => {
const headers = {};
new Headers(init.headers ?? {}).forEach((v, k) => headers[k] = v);
const req = https.request(
url,
{ method: init.method ?? "GET", headers, ca: [ca] },
(res) => {
const chunks = [];
res.on("data", (c) => chunks.push(c));
res.on("error", reject);
res.on(
"end",
() => resolve(
new Response(Buffer.concat(chunks), {
status: res.statusCode ?? 0,
headers: Object.entries(res.headers).flatMap(
([k, v]) => v === void 0 ? [] : [v].flat().map((x) => [k, x])
)
})
)
);
}
);
req.on("error", reject);
const signal = init.signal;
if (signal) {
const abort = () => req.destroy(
signal.reason instanceof Error ? signal.reason : new Error("aborted")
);
if (signal.aborted) abort();
else signal.addEventListener("abort", abort, { once: true });
}
if (init.body !== void 0 && init.body !== null)
req.write(init.body);
req.end();
});
}
async function headscaleFetch(url, init = {}) {
if (!url.startsWith("https:")) return fetch(url, init);
const origin = new URL(url).origin;
try {
return await request2(url, init, await certificateFor(origin, false));
} catch (err) {
if (!isTlsFailure(err)) throw err;
return request2(url, init, await certificateFor(origin, true));
}
}
// lambdacode/network/naming.ts
var headscaleUserName = (cognitoSub) => `u-${cognitoSub}`;
var NODE_NAME_LABEL = "[a-z0-9]([a-z0-9-]{0,62}[a-z0-9])?";
var NODE_NAME_RE = new RegExp(`^${NODE_NAME_LABEL}$`);
var nodeDisplayName = (node) => (node.givenName || node.name || "").toLowerCase();
// lambdacode/network/keyminter.ts
var log = (msg, extra = {}) => console.log(JSON.stringify({ msg, ...extra }));
function sitesFromEnv() {
try {
const sites = JSON.parse(process.env.HEADSCALE_SITES ?? "{}");
for (const s of Object.values(sites)) trustHeadscale(s.url, s.certParam);
return sites;
} catch {
return {};
}
}
async function userIdFor(api, name) {
const headers = { Authorization: `Bearer ${api.key}` };
const list = await headscaleFetch(`${api.url}/api/v1/user`, { headers });
if (!list.ok) throw new Error(`user list: ${list.status}`);
const { users = [] } = await list.json();
const existing = users.find((u) => u.name === name);
if (existing) return { id: existing.id, created: false };
const created = await headscaleFetch(`${api.url}/api/v1/user`, {
method: "POST",
headers: { ...headers, "Content-Type": "application/json" },
body: JSON.stringify({ name })
});
if (!created.ok) {
const detail = await created.text().catch(() => "");
log("ERROR: headscale user create", { status: created.status, detail });
throw new Error(`user create: ${created.status}`);
}
const body = await created.json();
if (!body.user?.id) throw new Error("user create: no id in response");
return { id: body.user.id, created: true };
}
var lambda = new import_client_lambda.LambdaClient({});
var RECONCILER_START_TIMEOUT_MS = 2e3;
async function startReconciler(siteId) {
const fn = process.env.NETWORK_RECONCILER_FN_NAME ?? "";
if (!fn) {
log("WARN: new headscale user, but no reconciler to start", { siteId });
return;
}
try {
await lambda.send(new import_client_lambda.InvokeCommand({ FunctionName: fn, InvocationType: "Event", Payload: "{}" }), {
abortSignal: AbortSignal.timeout(RECONCILER_START_TIMEOUT_MS)
});
log("started reconciler for a new headscale user", { siteId });
} catch (err) {
log("WARN: reconciler start failed; the scheduled pass will pick the user up", {
siteId,
error: err.message
});
}
}
async function mint(api, userId, ttlSeconds, ephemeral = false) {
const expiresAt = new Date(Date.now() + ttlSeconds * 1e3).toISOString();
const res = await headscaleFetch(`${api.url}/api/v1/preauthkey`, {
method: "POST",
headers: {
Authorization: `Bearer ${api.key}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
user: userId,
reusable: false,
ephemeral,
expiration: expiresAt
})
});
if (!res.ok) {
const detail = await res.text().catch(() => "");
log("ERROR: headscale preauthkey", { status: res.status, detail });
throw new Error(`Headscale admin API returned ${res.status}`);
}
const body = await res.json();
const key = body.preAuthKey?.key;
if (!key) throw new Error("Headscale response had no key");
return { key, expiresAt };
}
async function nodesOf(api, headscaleUser) {
const res = await headscaleFetch(`${api.url}/api/v1/node`, { headers: { Authorization: `Bearer ${api.key}` } });
if (!res.ok) throw new Error(`node list: ${res.status}`);
const { nodes = [] } = await res.json();
return nodes.filter((n) => n.user?.name === headscaleUser);
}
var deviceHandler = async (event) => {
const userName = event?.userName ?? "";
if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(userName)) {
throw new Error("device operations need a valid userName (Cognito sub)");
}
const owner = headscaleUserName(userName);
const sites = sitesFromEnv();
const siteIds = Object.keys(sites);
const op = event?.op ?? "mint";
if (op === "list") {
const results = await Promise.allSettled(siteIds.map((siteId2) => nodesOf(sites[siteId2], owner)));
const devices = [];
const unreachable = [];
results.forEach((r, i) => {
const siteId2 = siteIds[i];
if (r.status === "rejected") {
log("ERROR: device list: site unreachable", { siteId: siteId2, error: r.reason?.message });
unreachable.push(siteId2);
return;
}
for (const n of r.value) {
devices.push({
siteId: siteId2,
name: nodeDisplayName(n),
ips: n.ipAddresses ?? [],
online: n.online === true,
...n.lastSeen ? { lastSeen: n.lastSeen } : {},
ephemeral: n.preAuthKey?.ephemeral === true
});
}
});
return { devices, unreachable };
}
const siteId = event?.siteId ?? siteIds[0] ?? "";
const api = sites[siteId];
if (!api) throw new Error(`unknown siteId "${siteId}"`);
if (op === "delete") {
const name = String(event?.name ?? "");
if (!name) throw new Error("device delete needs a name");
let deleted = 0;
for (const n of (await nodesOf(api, owner)).filter((x) => x.id && nodeDisplayName(x) === name)) {
const res = await headscaleFetch(`${api.url}/api/v1/node/${n.id}`, {
method: "DELETE",
headers: { Authorization: `Bearer ${api.key}` }
});
if (!res.ok) throw new Error(`node delete: ${res.status}`);
deleted++;
}
log("deleted devices", { siteId, deleted });
return { deleted };
}
const user = await userIdFor(api, owner);
try {
const result = await mint(api, user.id, 30 * 60, event?.ephemeral === true);
log("minted", { keyType: "device", siteId, ephemeral: event?.ephemeral === true, expiresAt: result.expiresAt });
return result;
} finally {
if (user.created) await startReconciler(siteId);
}
};
var connectorHandler = async () => {
const api = {
url: process.env.HEADSCALE_API_URL ?? "",
key: process.env.HEADSCALE_API_KEY ?? "",
certParam: process.env.HEADSCALE_TLS_PARAM
};
trustHeadscale(api.url, api.certParam);
const userId = process.env.HEADSCALE_USER_ID ?? "1";
const result = await mint(api, userId, 5 * 60);
log("minted", { keyType: "connector", expiresAt: result.expiresAt });
return result;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
RECONCILER_START_TIMEOUT_MS,
connectorHandler,
deviceHandler
});