@agimon-ai/po-core 0.0.0-alpha.0

package/dist/src/services/deviceSessions/index.mjs

@@ -0,0 +1,141 @@
+//#region src/services/deviceSessions/index.ts
+const MS_PER_MINUTE = 6e4;
+const MS_PER_HOUR = 36e5;
+const MS_PER_SECOND = 1e3;
+/** Long enough to tell an iPhone from a laptop, short enough not to be a fingerprint in a log. */
+const MAX_USER_AGENT = 200;
+/** Upper bound of the C0 block, and the bounds of C1. Codepoints rather than a character class:
+* a regex over control characters is unreadable, hard to review, and trips no-control-regex. */
+const C0_END = 31;
+const C1_START = 127;
+const C1_END = 159;
+const UNKNOWN_DEVICE = "unknown device";
+/** Whether this record still authorizes a request, under the settings in force right now. */
+function evaluateDevice(record, now, settings) {
+	if (record === void 0) return {
+		ok: false,
+		reason: "unknown"
+	};
+	if (!settings.sessionExpiryEnabled) return {
+		ok: true,
+		record
+	};
+	if (now - record.lastSeenAt >= settings.idleMinutes * MS_PER_MINUTE) return {
+		ok: false,
+		reason: "idle"
+	};
+	if (now - record.createdAt >= settings.absoluteHours * MS_PER_HOUR) return {
+		ok: false,
+		reason: "absolute"
+	};
+	return {
+		ok: true,
+		record
+	};
+}
+/** Exact deadline at which this device stops authorizing, or undefined while expiry is disabled. */
+function deviceExpiryAt(record, settings) {
+	if (!settings.sessionExpiryEnabled) return void 0;
+	return Math.min(record.lastSeenAt + settings.idleMinutes * MS_PER_MINUTE, record.createdAt + settings.absoluteHours * MS_PER_HOUR);
+}
+function touchDevice(record, now) {
+	return {
+		...record,
+		lastSeenAt: now
+	};
+}
+/** How long the cookie should live, so the browser forgets roughly when the server does. */
+function cookieMaxAgeSeconds(settings, ceilingSeconds) {
+	if (!settings.sessionExpiryEnabled) return ceilingSeconds;
+	return Math.min(ceilingSeconds, Math.round(settings.absoluteHours * MS_PER_HOUR / MS_PER_SECOND));
+}
+/** Replaces every C0 and C1 control character with a space; those are what could forge a log line. */
+function withoutControlCharacters(value) {
+	let out = "";
+	for (const character of value) {
+		const code = character.codePointAt(0) ?? 0;
+		out += code <= C0_END || code >= C1_START && code <= C1_END ? " " : character;
+	}
+	return out;
+}
+/**
+* Strips anything that could forge a second line in a log or a second element
+* in the approval dialog, then truncates.
+*
+* The user agent is attacker-supplied and lands in both `notice()` output and
+* the host's approval prompt, so control characters are the concern rather than
+* length.
+*/
+function sanitizeUserAgent(raw) {
+	if (raw === void 0) return UNKNOWN_DEVICE;
+	const stripped = withoutControlCharacters(raw).replaceAll(/\s+/gu, " ").trim();
+	if (stripped === "") return UNKNOWN_DEVICE;
+	return stripped.slice(0, MAX_USER_AGENT);
+}
+/**
+* The address Cloudflare's edge reported, reduced to a safe display and key value.
+*
+* It never authorizes a request. The tunnel route may use it only for abuse
+* throttling when Cloudflare is the trusted proxy. A local process can forge it,
+* but local processes are outside that public-internet boundary.
+*/
+function sanitizeEdgeIp(raw) {
+	if (raw === void 0) return "unknown";
+	const candidate = raw.split(",")[0]?.trim() ?? "";
+	return /^[0-9a-f:.]{1,45}$/iu.test(candidate) ? candidate : "unknown";
+}
+const DEVICE_HINTS = [
+	{
+		pattern: /iphone/iu,
+		label: "iPhone"
+	},
+	{
+		pattern: /ipad/iu,
+		label: "iPad"
+	},
+	{
+		pattern: /android/iu,
+		label: "Android"
+	},
+	{
+		pattern: /macintosh|mac os x/iu,
+		label: "Mac"
+	},
+	{
+		pattern: /windows/iu,
+		label: "Windows"
+	},
+	{
+		pattern: /linux/iu,
+		label: "Linux"
+	}
+];
+const BROWSER_HINTS = [
+	{
+		pattern: /edg\//iu,
+		label: "Edge"
+	},
+	{
+		pattern: /firefox\//iu,
+		label: "Firefox"
+	},
+	{
+		pattern: /chrome\/|crios\//iu,
+		label: "Chrome"
+	},
+	{
+		pattern: /safari\//iu,
+		label: "Safari"
+	}
+];
+/** A human label for the device list, best effort; the full user agent is shown alongside. */
+function deviceLabelFor(userAgent) {
+	const device = DEVICE_HINTS.find((hint) => hint.pattern.test(userAgent))?.label;
+	const browser = BROWSER_HINTS.find((hint) => hint.pattern.test(userAgent))?.label;
+	if (device !== void 0 && browser !== void 0) return `${device} · ${browser}`;
+	return device ?? browser ?? "paired device";
+}
+//#endregion
+export { cookieMaxAgeSeconds, deviceExpiryAt, deviceLabelFor, evaluateDevice, sanitizeEdgeIp, sanitizeUserAgent, touchDevice };
+
+//# sourceMappingURL=index.mjs.map

package/dist/src/services/deviceSessions/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../src/services/deviceSessions/index.ts"],"sourcesContent":["/**\n * What makes a paired device's session still valid.\n *\n * Expiry is derived from the settings in force at the moment of the check,\n * never stamped onto the record when it was minted. That is what makes the\n * setting honest in both directions: switching expiry on has to invalidate a\n * session that is already idle, and switching it off has to bring it back. A\n * stored `expiresAt` would do neither.\n */\n\nimport type { DeviceTrust, RemoteAccessSettings } from '../../types/remote';\n\nconst MS_PER_MINUTE = 60_000;\nconst MS_PER_HOUR = 3_600_000;\nconst MS_PER_SECOND = 1000;\n/** Long enough to tell an iPhone from a laptop, short enough not to be a fingerprint in a log. */\nconst MAX_USER_AGENT = 200;\n/** Upper bound of the C0 block, and the bounds of C1. Codepoints rather than a character class:\n * a regex over control characters is unreadable, hard to review, and trips no-control-regex. */\nconst C0_END = 0x1f;\nconst C1_START = 0x7f;\nconst C1_END = 0x9f;\nconst UNKNOWN_DEVICE = 'unknown device';\n\nexport interface DeviceRecord {\n  /** Opaque, safe to display and to name in a revoke call. Never the secret. */\n  id: string;\n  /** SHA-256 of the session token. The token itself is never retained. */\n  tokenHash: string;\n  label: string;\n  userAgent: string;\n  /** Epoch milliseconds. */\n  createdAt: number;\n  /** Epoch milliseconds, bumped on every authenticated request. */\n  lastSeenAt: number;\n  /** How this session was earned; decides registration rights and step-up. */\n  trust: DeviceTrust;\n}\n\nexport type DeviceRejection = 'unknown' | 'idle' | 'absolute';\n\nexport type DeviceVerdict = { ok: true; record: DeviceRecord } | { ok: false; reason: DeviceRejection };\n\n/** Whether this record still authorizes a request, under the settings in force right now. */\nexport function evaluateDevice(\n  record: DeviceRecord | undefined,\n  now: number,\n  settings: RemoteAccessSettings,\n): DeviceVerdict {\n  if (record === undefined) return { ok: false, reason: 'unknown' };\n  if (!settings.sessionExpiryEnabled) return { ok: true, record };\n  if (now - record.lastSeenAt >= settings.idleMinutes * MS_PER_MINUTE) return { ok: false, reason: 'idle' };\n  if (now - record.createdAt >= settings.absoluteHours * MS_PER_HOUR) return { ok: false, reason: 'absolute' };\n  return { ok: true, record };\n}\n\n/** Exact deadline at which this device stops authorizing, or undefined while expiry is disabled. */\nexport function deviceExpiryAt(record: DeviceRecord, settings: RemoteAccessSettings): number | undefined {\n  if (!settings.sessionExpiryEnabled) return undefined;\n  return Math.min(\n    record.lastSeenAt + settings.idleMinutes * MS_PER_MINUTE,\n    record.createdAt + settings.absoluteHours * MS_PER_HOUR,\n  );\n}\n\nexport function touchDevice(record: DeviceRecord, now: number): DeviceRecord {\n  return { ...record, lastSeenAt: now };\n}\n\n/** How long the cookie should live, so the browser forgets roughly when the server does. */\nexport function cookieMaxAgeSeconds(settings: RemoteAccessSettings, ceilingSeconds: number): number {\n  if (!settings.sessionExpiryEnabled) return ceilingSeconds;\n  return Math.min(ceilingSeconds, Math.round((settings.absoluteHours * MS_PER_HOUR) / MS_PER_SECOND));\n}\n\n/** Replaces every C0 and C1 control character with a space; those are what could forge a log line. */\nfunction withoutControlCharacters(value: string): string {\n  let out = '';\n  for (const character of value) {\n    const code = character.codePointAt(0) ?? 0;\n    out += code <= C0_END || (code >= C1_START && code <= C1_END) ? ' ' : character;\n  }\n  return out;\n}\n\n/**\n * Strips anything that could forge a second line in a log or a second element\n * in the approval dialog, then truncates.\n *\n * The user agent is attacker-supplied and lands in both `notice()` output and\n * the host's approval prompt, so control characters are the concern rather than\n * length.\n */\nexport function sanitizeUserAgent(raw: string | undefined): string {\n  if (raw === undefined) return UNKNOWN_DEVICE;\n  const stripped = withoutControlCharacters(raw).replaceAll(/\\s+/gu, ' ').trim();\n  if (stripped === '') return UNKNOWN_DEVICE;\n  return stripped.slice(0, MAX_USER_AGENT);\n}\n\n/**\n * The address Cloudflare's edge reported, reduced to a safe display and key value.\n *\n * It never authorizes a request. The tunnel route may use it only for abuse\n * throttling when Cloudflare is the trusted proxy. A local process can forge it,\n * but local processes are outside that public-internet boundary.\n */\nexport function sanitizeEdgeIp(raw: string | undefined): string {\n  if (raw === undefined) return 'unknown';\n  const candidate = raw.split(',')[0]?.trim() ?? '';\n  return /^[0-9a-f:.]{1,45}$/iu.test(candidate) ? candidate : 'unknown';\n}\n\nconst DEVICE_HINTS: readonly { pattern: RegExp; label: string }[] = [\n  { pattern: /iphone/iu, label: 'iPhone' },\n  { pattern: /ipad/iu, label: 'iPad' },\n  { pattern: /android/iu, label: 'Android' },\n  { pattern: /macintosh|mac os x/iu, label: 'Mac' },\n  { pattern: /windows/iu, label: 'Windows' },\n  { pattern: /linux/iu, label: 'Linux' },\n];\n\nconst BROWSER_HINTS: readonly { pattern: RegExp; label: string }[] = [\n  // Order matters: every Chromium user agent also says Safari, and Edge says both.\n  { pattern: /edg\\//iu, label: 'Edge' },\n  { pattern: /firefox\\//iu, label: 'Firefox' },\n  { pattern: /chrome\\/|crios\\//iu, label: 'Chrome' },\n  { pattern: /safari\\//iu, label: 'Safari' },\n];\n\n/** A human label for the device list, best effort; the full user agent is shown alongside. */\nexport function deviceLabelFor(userAgent: string): string {\n  const device = DEVICE_HINTS.find((hint) => hint.pattern.test(userAgent))?.label;\n  const browser = BROWSER_HINTS.find((hint) => hint.pattern.test(userAgent))?.label;\n  if (device !== undefined && browser !== undefined) return `${device} · ${browser}`;\n  return device ?? browser ?? 'paired device';\n}\n"],"mappings":";AAYA,MAAM,gBAAgB;AACtB,MAAM,cAAc;AACpB,MAAM,gBAAgB;;AAEtB,MAAM,iBAAiB;;;AAGvB,MAAM,SAAS;AACf,MAAM,WAAW;AACjB,MAAM,SAAS;AACf,MAAM,iBAAiB;;AAsBvB,SAAgB,eACd,QACA,KACA,UACe;CACf,IAAI,WAAW,KAAA,GAAW,OAAO;EAAE,IAAI;EAAO,QAAQ;CAAU;CAChE,IAAI,CAAC,SAAS,sBAAsB,OAAO;EAAE,IAAI;EAAM;CAAO;CAC9D,IAAI,MAAM,OAAO,cAAc,SAAS,cAAc,eAAe,OAAO;EAAE,IAAI;EAAO,QAAQ;CAAO;CACxG,IAAI,MAAM,OAAO,aAAa,SAAS,gBAAgB,aAAa,OAAO;EAAE,IAAI;EAAO,QAAQ;CAAW;CAC3G,OAAO;EAAE,IAAI;EAAM;CAAO;AAC5B;;AAGA,SAAgB,eAAe,QAAsB,UAAoD;CACvG,IAAI,CAAC,SAAS,sBAAsB,OAAO,KAAA;CAC3C,OAAO,KAAK,IACV,OAAO,aAAa,SAAS,cAAc,eAC3C,OAAO,YAAY,SAAS,gBAAgB,WAC9C;AACF;AAEA,SAAgB,YAAY,QAAsB,KAA2B;CAC3E,OAAO;EAAE,GAAG;EAAQ,YAAY;CAAI;AACtC;;AAGA,SAAgB,oBAAoB,UAAgC,gBAAgC;CAClG,IAAI,CAAC,SAAS,sBAAsB,OAAO;CAC3C,OAAO,KAAK,IAAI,gBAAgB,KAAK,MAAO,SAAS,gBAAgB,cAAe,aAAa,CAAC;AACpG;;AAGA,SAAS,yBAAyB,OAAuB;CACvD,IAAI,MAAM;CACV,KAAK,MAAM,aAAa,OAAO;EAC7B,MAAM,OAAO,UAAU,YAAY,CAAC,KAAK;EACzC,OAAO,QAAQ,UAAW,QAAQ,YAAY,QAAQ,SAAU,MAAM;CACxE;CACA,OAAO;AACT;;;;;;;;;AAUA,SAAgB,kBAAkB,KAAiC;CACjE,IAAI,QAAQ,KAAA,GAAW,OAAO;CAC9B,MAAM,WAAW,yBAAyB,GAAG,CAAC,CAAC,WAAW,SAAS,GAAG,CAAC,CAAC,KAAK;CAC7E,IAAI,aAAa,IAAI,OAAO;CAC5B,OAAO,SAAS,MAAM,GAAG,cAAc;AACzC;;;;;;;;AASA,SAAgB,eAAe,KAAiC;CAC9D,IAAI,QAAQ,KAAA,GAAW,OAAO;CAC9B,MAAM,YAAY,IAAI,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,KAAK,KAAK;CAC/C,OAAO,uBAAuB,KAAK,SAAS,IAAI,YAAY;AAC9D;AAEA,MAAM,eAA8D;CAClE;EAAE,SAAS;EAAY,OAAO;CAAS;CACvC;EAAE,SAAS;EAAU,OAAO;CAAO;CACnC;EAAE,SAAS;EAAa,OAAO;CAAU;CACzC;EAAE,SAAS;EAAwB,OAAO;CAAM;CAChD;EAAE,SAAS;EAAa,OAAO;CAAU;CACzC;EAAE,SAAS;EAAW,OAAO;CAAQ;AACvC;AAEA,MAAM,gBAA+D;CAEnE;EAAE,SAAS;EAAW,OAAO;CAAO;CACpC;EAAE,SAAS;EAAe,OAAO;CAAU;CAC3C;EAAE,SAAS;EAAsB,OAAO;CAAS;CACjD;EAAE,SAAS;EAAc,OAAO;CAAS;AAC3C;;AAGA,SAAgB,eAAe,WAA2B;CACxD,MAAM,SAAS,aAAa,MAAM,SAAS,KAAK,QAAQ,KAAK,SAAS,CAAC,CAAC,EAAE;CAC1E,MAAM,UAAU,cAAc,MAAM,SAAS,KAAK,QAAQ,KAAK,SAAS,CAAC,CAAC,EAAE;CAC5E,IAAI,WAAW,KAAA,KAAa,YAAY,KAAA,GAAW,OAAO,GAAG,OAAO,KAAK;CACzE,OAAO,UAAU,WAAW;AAC9B"}

package/dist/src/services/deviceTrust/index.cjs

@@ -0,0 +1,294 @@
+const require_remote = require("../../constants/remote.cjs");
+const require_index = require("../deviceSessions/index.cjs");
+const require_index$1 = require("../webauthnPolicy/index.cjs");
+let node_crypto = require("node:crypto");
+let _agimon_ai_po_web_security_node = require("@agimon-ai/po-web-security/node");
+//#region src/services/deviceTrust/index.ts
+/**
+* Native device trust: message layout, key checks, and single-use challenges.
+*
+* A phone paired by QR registers two P-256 keys over the sealed gateway: an
+* identity key that signs silent reconnects, and a step-up key that only
+* biometrics unlock. Every signed message is `tag + "\n" + JSON.stringify(fields)`
+* with the fields in the fixed order below, so the phone and the host build the
+* same bytes and no message can be passed off as another or as a manifest.
+*
+* No I/O and no hidden clock: the caller passes the clock, the challenge store,
+* and the record lookup, so every rule here is testable without a server.
+*/
+/** Challenges and nonces are 32 random bytes, which is 43 base64url characters. */
+const RANDOM_BYTES = 32;
+const RANDOM_VALUE = /^[A-Za-z0-9_-]{43}$/u;
+const CHALLENGE_ID_BYTES = 16;
+/** Opaque ids: trusted device ids, session device ids, and challenge ids. */
+const OPAQUE_ID = /^[A-Za-z0-9_-]{1,64}$/u;
+const MAX_SPKI_LENGTH = 512;
+const MAX_CHANNEL_KEY_LENGTH = 128;
+const MAX_SIGNATURE_LENGTH = 128;
+const BASE64URL = /^[A-Za-z0-9_-]+$/u;
+const P256_CURVE = "prime256v1";
+const PLATFORMS = /* @__PURE__ */ new Set(["ios", "android"]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isBase64Url(value, maximum) {
+	return typeof value === "string" && value.length > 0 && value.length <= maximum && BASE64URL.test(value);
+}
+function ttlOf(purpose) {
+	return purpose.kind === "auth" ? require_remote.DEVICE_AUTH_CHALLENGE_TTL_MS : require_remote.DEVICE_STEP_UP_CHALLENGE_TTL_MS;
+}
+/** `po/host-channel-key/v1`, signed by the host bundle signer. */
+function hostChannelKeyFields(origin, hostPublicKey, deviceNonce) {
+	return [
+		origin,
+		hostPublicKey,
+		deviceNonce
+	];
+}
+/** `po/device-register/v1`, signed by the identity key and separately by the step-up key. */
+function deviceRegisterFields(input) {
+	return [
+		input.origin,
+		input.hostPublicKey,
+		input.sessionDeviceId,
+		input.identityPublicKey,
+		input.stepUpPublicKey,
+		input.platform
+	];
+}
+/** `po/device-auth/v1`, signed by the identity key. All three channel keys are covered. */
+function deviceAuthFields(input) {
+	return [
+		input.origin,
+		input.challenge,
+		input.hostPublicKey,
+		input.trustedDeviceId,
+		input.channels.session,
+		input.channels.protocol,
+		input.channels.http
+	];
+}
+/** `po/device-step-up/v1`, signed by the biometric step-up key. */
+function deviceStepUpFields(input) {
+	return [
+		input.origin,
+		input.action,
+		input.sessionDeviceId,
+		input.challengeId,
+		input.challenge
+	];
+}
+/** Whether a value is a base64url DER SPKI for an EC P-256 public key, the only kind a device may register. */
+function isP256PublicKey(value) {
+	if (!isBase64Url(value, MAX_SPKI_LENGTH)) return false;
+	try {
+		const key = (0, node_crypto.createPublicKey)({
+			key: Buffer.from(value, "base64url"),
+			format: "der",
+			type: "spki"
+		});
+		return key.asymmetricKeyType === "ec" && key.asymmetricKeyDetails?.namedCurve === P256_CURVE;
+	} catch {
+		return false;
+	}
+}
+/** Whether a value is a fresh-looking 32-byte base64url nonce. */
+function isDeviceNonce(value) {
+	return typeof value === "string" && RANDOM_VALUE.test(value);
+}
+function isOpaqueId(value) {
+	return typeof value === "string" && OPAQUE_ID.test(value);
+}
+/**
+* Single-use challenges, bounded in count and lifetime.
+*
+* Deleted on first `take`, whatever the outcome of the check that follows, so a
+* challenge cannot be retried. Expired entries are swept on every issue, and the
+* oldest entry goes when the store is full.
+*/
+function createDeviceChallenges(options) {
+	const random = options.random ?? ((bytes) => (0, node_crypto.randomBytes)(bytes).toString("base64url"));
+	const pending = /* @__PURE__ */ new Map();
+	const live = (entry, at) => at - entry.issuedAt < ttlOf(entry.purpose);
+	return {
+		issue(hostPublicKey, purpose) {
+			const at = options.now();
+			for (const [id, entry] of pending) if (!live(entry, at)) pending.delete(id);
+			while (pending.size >= require_remote.DEVICE_CHALLENGE_LIMIT) {
+				const oldest = pending.keys().next().value;
+				if (oldest === void 0) break;
+				pending.delete(oldest);
+			}
+			const entry = {
+				id: random(CHALLENGE_ID_BYTES),
+				challenge: random(RANDOM_BYTES),
+				hostPublicKey,
+				issuedAt: at,
+				purpose
+			};
+			pending.set(entry.id, entry);
+			return entry;
+		},
+		take(id) {
+			const entry = pending.get(id);
+			if (entry === void 0) return void 0;
+			pending.delete(id);
+			return live(entry, options.now()) ? entry : void 0;
+		},
+		dropWhere(predicate) {
+			for (const [id, entry] of pending) if (predicate(entry)) pending.delete(id);
+		},
+		clear: () => pending.clear(),
+		size: () => pending.size
+	};
+}
+/**
+* The public reconnect challenge.
+*
+* It never consults the trusted-device list, so a known id and an unknown one
+* produce the same shape and the route cannot be used to enumerate devices.
+* The attestation proves the fresh tunnel key with the signer the phone pinned
+* at pairing, over the phone's own nonce. Undefined while the host cannot attest.
+*/
+function deviceAuthChallenge(input) {
+	const attestation = input.attest(hostChannelKeyFields(input.origin, input.hostPublicKey, input.nonce));
+	if (attestation === void 0) return void 0;
+	const issued = input.challenges.issue(input.hostPublicKey, {
+		kind: "auth",
+		trustedDeviceId: input.trustedDeviceId
+	});
+	return {
+		challengeId: issued.id,
+		challenge: issued.challenge,
+		hostPublicKey: input.hostPublicKey,
+		attestation
+	};
+}
+/** A step-up challenge bound to one action and one session, answered by the biometric key. */
+function deviceStepUpChallenge(input) {
+	const issued = input.challenges.issue(input.hostPublicKey, {
+		kind: "step-up",
+		sessionDeviceId: input.sessionDeviceId,
+		action: input.action
+	});
+	return {
+		ceremonyId: issued.id,
+		challenge: issued.challenge,
+		kind: "device-key"
+	};
+}
+/**
+* Checks a registration from a sealed `pairing` session.
+*
+* Both keys must be distinct P-256 SPKIs and both must sign the same
+* `po/device-register/v1` message, which binds them to this origin, this
+* tunnel key, and this exact session.
+*/
+function verifyRegistration(input) {
+	if (input.trust?.kind !== "pairing") return {
+		ok: false,
+		reason: "not-pairing"
+	};
+	const body = input.body;
+	if (!isRecord(body)) return {
+		ok: false,
+		reason: "invalid"
+	};
+	const { identityPublicKey, stepUpPublicKey, label, platform, identityProof, stepUpProof } = body;
+	if (!isP256PublicKey(identityPublicKey) || !isP256PublicKey(stepUpPublicKey) || identityPublicKey === stepUpPublicKey || typeof label !== "string" || typeof platform !== "string" || !PLATFORMS.has(platform) || !isBase64Url(identityProof, MAX_SIGNATURE_LENGTH) || !isBase64Url(stepUpProof, MAX_SIGNATURE_LENGTH)) return {
+		ok: false,
+		reason: "invalid"
+	};
+	const fields = deviceRegisterFields({
+		origin: input.origin,
+		hostPublicKey: input.hostPublicKey,
+		sessionDeviceId: input.sessionDeviceId,
+		identityPublicKey,
+		stepUpPublicKey,
+		platform
+	});
+	if (!(0, _agimon_ai_po_web_security_node.verifyDeviceSignature)(identityPublicKey, "po/device-register/v1", fields, identityProof) || !(0, _agimon_ai_po_web_security_node.verifyDeviceSignature)(stepUpPublicKey, "po/device-register/v1", fields, stepUpProof)) return {
+		ok: false,
+		reason: "invalid"
+	};
+	return {
+		ok: true,
+		identityPublicKey,
+		stepUpPublicKey,
+		label: require_index.sanitizeUserAgent(label),
+		platform
+	};
+}
+function channelKeysOf(value) {
+	if (!isRecord(value)) return void 0;
+	const { session, protocol, http } = value;
+	if (!isBase64Url(session, MAX_CHANNEL_KEY_LENGTH) || !isBase64Url(protocol, MAX_CHANNEL_KEY_LENGTH) || !isBase64Url(http, MAX_CHANNEL_KEY_LENGTH)) return void 0;
+	if (session === protocol || session === http || protocol === http) return void 0;
+	return {
+		session,
+		protocol,
+		http
+	};
+}
+/**
+* Checks a device sign-in. The challenge is consumed before anything else is
+* looked at, so every attempt, good or bad, burns it.
+*/
+function verifyAuthentication(input) {
+	const body = input.body;
+	if (!isRecord(body) || !isOpaqueId(body.challengeId)) return { ok: false };
+	const issued = input.challenges.take(body.challengeId);
+	if (issued === void 0 || issued.purpose.kind !== "auth") return { ok: false };
+	if (input.hostPublicKey === void 0 || issued.hostPublicKey !== input.hostPublicKey) return { ok: false };
+	if (!isOpaqueId(body.trustedDeviceId) || body.trustedDeviceId !== issued.purpose.trustedDeviceId) return { ok: false };
+	if (!isBase64Url(body.signature, MAX_SIGNATURE_LENGTH)) return { ok: false };
+	const channels = channelKeysOf(body.channels);
+	if (channels === void 0) return { ok: false };
+	const record = input.find(body.trustedDeviceId);
+	if (record === void 0) return { ok: false };
+	const fields = deviceAuthFields({
+		origin: input.origin,
+		challenge: issued.challenge,
+		hostPublicKey: issued.hostPublicKey,
+		trustedDeviceId: record.id,
+		channels
+	});
+	if (!(0, _agimon_ai_po_web_security_node.verifyDeviceSignature)(record.identityPublicKey, "po/device-auth/v1", fields, body.signature)) return { ok: false };
+	return {
+		ok: true,
+		record,
+		channels
+	};
+}
+/** Checks a biometric step-up signature for one action from one device-key session. */
+function verifyStepUp(input) {
+	if (!isOpaqueId(input.ceremonyId) || !require_index$1.isStepUpAction(input.action)) return false;
+	const issued = input.challenges.take(input.ceremonyId);
+	if (issued === void 0 || issued.purpose.kind !== "step-up") return false;
+	if (input.hostPublicKey === void 0 || issued.hostPublicKey !== input.hostPublicKey) return false;
+	if (issued.purpose.sessionDeviceId !== input.sessionDeviceId || issued.purpose.action !== input.action) return false;
+	if (!isBase64Url(input.signature, MAX_SIGNATURE_LENGTH)) return false;
+	return (0, _agimon_ai_po_web_security_node.verifyDeviceSignature)(input.stepUpPublicKey, require_remote.DEVICE_STEP_UP_TAG, deviceStepUpFields({
+		origin: input.origin,
+		action: input.action,
+		sessionDeviceId: input.sessionDeviceId,
+		challengeId: issued.id,
+		challenge: issued.challenge
+	}), input.signature);
+}
+//#endregion
+exports.createDeviceChallenges = createDeviceChallenges;
+exports.deviceAuthChallenge = deviceAuthChallenge;
+exports.deviceAuthFields = deviceAuthFields;
+exports.deviceRegisterFields = deviceRegisterFields;
+exports.deviceStepUpChallenge = deviceStepUpChallenge;
+exports.deviceStepUpFields = deviceStepUpFields;
+exports.hostChannelKeyFields = hostChannelKeyFields;
+exports.isDeviceNonce = isDeviceNonce;
+exports.isOpaqueId = isOpaqueId;
+exports.isP256PublicKey = isP256PublicKey;
+exports.verifyAuthentication = verifyAuthentication;
+exports.verifyRegistration = verifyRegistration;
+exports.verifyStepUp = verifyStepUp;
+
+//# sourceMappingURL=index.cjs.map

package/dist/src/services/deviceTrust/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["DEVICE_AUTH_CHALLENGE_TTL_MS","DEVICE_STEP_UP_CHALLENGE_TTL_MS","createPublicKey","randomBytes","DEVICE_CHALLENGE_LIMIT","verifyDeviceSignature","sanitizeUserAgent","isStepUpAction","DEVICE_STEP_UP_TAG"],"sources":["../../../../src/services/deviceTrust/index.ts"],"sourcesContent":["/**\n * Native device trust: message layout, key checks, and single-use challenges.\n *\n * A phone paired by QR registers two P-256 keys over the sealed gateway: an\n * identity key that signs silent reconnects, and a step-up key that only\n * biometrics unlock. Every signed message is `tag + \"\\n\" + JSON.stringify(fields)`\n * with the fields in the fixed order below, so the phone and the host build the\n * same bytes and no message can be passed off as another or as a manifest.\n *\n * No I/O and no hidden clock: the caller passes the clock, the challenge store,\n * and the record lookup, so every rule here is testable without a server.\n */\n\nimport { createPublicKey, randomBytes } from 'node:crypto';\n\nimport { verifyDeviceSignature } from '@agimon-ai/po-web-security/node';\n\nimport {\n  DEVICE_AUTH_CHALLENGE_TTL_MS,\n  DEVICE_AUTH_TAG,\n  DEVICE_CHALLENGE_LIMIT,\n  DEVICE_REGISTER_TAG,\n  DEVICE_STEP_UP_CHALLENGE_TTL_MS,\n  DEVICE_STEP_UP_TAG,\n} from '../../constants/remote';\nimport type { DeviceTrust, TrustedDevicePlatform, TrustedDeviceRecord } from '../../types/remote';\nimport { sanitizeUserAgent } from '../deviceSessions';\nimport { isStepUpAction, type StepUpAction } from '../webauthnPolicy';\n\n/** Challenges and nonces are 32 random bytes, which is 43 base64url characters. */\nconst RANDOM_BYTES = 32;\nconst RANDOM_VALUE = /^[A-Za-z0-9_-]{43}$/u;\nconst CHALLENGE_ID_BYTES = 16;\n/** Opaque ids: trusted device ids, session device ids, and challenge ids. */\nconst OPAQUE_ID = /^[A-Za-z0-9_-]{1,64}$/u;\nconst MAX_SPKI_LENGTH = 512;\nconst MAX_CHANNEL_KEY_LENGTH = 128;\nconst MAX_SIGNATURE_LENGTH = 128;\nconst BASE64URL = /^[A-Za-z0-9_-]+$/u;\nconst P256_CURVE = 'prime256v1';\nconst PLATFORMS: ReadonlySet<string> = new Set<TrustedDevicePlatform>(['ios', 'android']);\n\nexport type DeviceChallengePurpose =\n  | { kind: 'auth'; trustedDeviceId: string }\n  | { kind: 'step-up'; sessionDeviceId: string; action: StepUpAction };\n\nexport interface DeviceChallenge {\n  id: string;\n  challenge: string;\n  /** The tunnel key in force when the challenge was issued; it must still be the current one. */\n  hostPublicKey: string;\n  issuedAt: number;\n  purpose: DeviceChallengePurpose;\n}\n\nexport interface DeviceChallenges {\n  issue(hostPublicKey: string, purpose: DeviceChallengePurpose): DeviceChallenge;\n  /** Removes and returns a live challenge. Undefined when unknown, already used, or expired. */\n  take(id: string): DeviceChallenge | undefined;\n  /** Drops every challenge the predicate selects, such as those of a revoked device. */\n  dropWhere(predicate: (challenge: DeviceChallenge) => boolean): void;\n  clear(): void;\n  size(): number;\n}\n\nexport interface DeviceChallengesOptions {\n  now: () => number;\n  /** Base64url random value of the given byte length; injectable for tests. */\n  random?: (bytes: number) => string;\n}\n\nexport interface DeviceChannelKeys {\n  session: string;\n  protocol: string;\n  http: string;\n}\n\nexport type RegistrationVerdict =\n  | {\n      ok: true;\n      identityPublicKey: string;\n      stepUpPublicKey: string;\n      label: string;\n      platform: TrustedDevicePlatform;\n    }\n  | { ok: false; reason: 'not-pairing' | 'invalid' };\n\nexport type AuthenticationVerdict =\n  | { ok: true; record: TrustedDeviceRecord; channels: DeviceChannelKeys }\n  | { ok: false };\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction isBase64Url(value: unknown, maximum: number): value is string {\n  return typeof value === 'string' && value.length > 0 && value.length <= maximum && BASE64URL.test(value);\n}\n\nfunction ttlOf(purpose: DeviceChallengePurpose): number {\n  return purpose.kind === 'auth' ? DEVICE_AUTH_CHALLENGE_TTL_MS : DEVICE_STEP_UP_CHALLENGE_TTL_MS;\n}\n\n/** `po/host-channel-key/v1`, signed by the host bundle signer. */\nexport function hostChannelKeyFields(origin: string, hostPublicKey: string, deviceNonce: string): string[] {\n  return [origin, hostPublicKey, deviceNonce];\n}\n\n/** `po/device-register/v1`, signed by the identity key and separately by the step-up key. */\nexport function deviceRegisterFields(input: {\n  origin: string;\n  hostPublicKey: string;\n  sessionDeviceId: string;\n  identityPublicKey: string;\n  stepUpPublicKey: string;\n  platform: string;\n}): string[] {\n  return [\n    input.origin,\n    input.hostPublicKey,\n    input.sessionDeviceId,\n    input.identityPublicKey,\n    input.stepUpPublicKey,\n    input.platform,\n  ];\n}\n\n/** `po/device-auth/v1`, signed by the identity key. All three channel keys are covered. */\nexport function deviceAuthFields(input: {\n  origin: string;\n  challenge: string;\n  hostPublicKey: string;\n  trustedDeviceId: string;\n  channels: DeviceChannelKeys;\n}): string[] {\n  return [\n    input.origin,\n    input.challenge,\n    input.hostPublicKey,\n    input.trustedDeviceId,\n    input.channels.session,\n    input.channels.protocol,\n    input.channels.http,\n  ];\n}\n\n/** `po/device-step-up/v1`, signed by the biometric step-up key. */\nexport function deviceStepUpFields(input: {\n  origin: string;\n  action: string;\n  sessionDeviceId: string;\n  challengeId: string;\n  challenge: string;\n}): string[] {\n  return [input.origin, input.action, input.sessionDeviceId, input.challengeId, input.challenge];\n}\n\n/** Whether a value is a base64url DER SPKI for an EC P-256 public key, the only kind a device may register. */\nexport function isP256PublicKey(value: unknown): value is string {\n  if (!isBase64Url(value, MAX_SPKI_LENGTH)) return false;\n  try {\n    const key = createPublicKey({ key: Buffer.from(value, 'base64url'), format: 'der', type: 'spki' });\n    return key.asymmetricKeyType === 'ec' && key.asymmetricKeyDetails?.namedCurve === P256_CURVE;\n  } catch {\n    // Not a parseable SPKI, which is the answer: refuse it.\n    return false;\n  }\n}\n\n/** Whether a value is a fresh-looking 32-byte base64url nonce. */\nexport function isDeviceNonce(value: unknown): value is string {\n  return typeof value === 'string' && RANDOM_VALUE.test(value);\n}\n\nexport function isOpaqueId(value: unknown): value is string {\n  return typeof value === 'string' && OPAQUE_ID.test(value);\n}\n\n/**\n * Single-use challenges, bounded in count and lifetime.\n *\n * Deleted on first `take`, whatever the outcome of the check that follows, so a\n * challenge cannot be retried. Expired entries are swept on every issue, and the\n * oldest entry goes when the store is full.\n */\nexport function createDeviceChallenges(options: DeviceChallengesOptions): DeviceChallenges {\n  const random = options.random ?? ((bytes: number): string => randomBytes(bytes).toString('base64url'));\n  const pending = new Map<string, DeviceChallenge>();\n  const live = (entry: DeviceChallenge, at: number): boolean => at - entry.issuedAt < ttlOf(entry.purpose);\n\n  return {\n    issue(hostPublicKey, purpose) {\n      const at = options.now();\n      for (const [id, entry] of pending) if (!live(entry, at)) pending.delete(id);\n      while (pending.size >= DEVICE_CHALLENGE_LIMIT) {\n        const oldest = pending.keys().next().value;\n        if (oldest === undefined) break;\n        pending.delete(oldest);\n      }\n      const entry: DeviceChallenge = {\n        id: random(CHALLENGE_ID_BYTES),\n        challenge: random(RANDOM_BYTES),\n        hostPublicKey,\n        issuedAt: at,\n        purpose,\n      };\n      pending.set(entry.id, entry);\n      return entry;\n    },\n\n    take(id) {\n      const entry = pending.get(id);\n      if (entry === undefined) return undefined;\n      pending.delete(id);\n      return live(entry, options.now()) ? entry : undefined;\n    },\n\n    dropWhere(predicate) {\n      for (const [id, entry] of pending) if (predicate(entry)) pending.delete(id);\n    },\n\n    clear: () => pending.clear(),\n    size: () => pending.size,\n  };\n}\n\n/**\n * The public reconnect challenge.\n *\n * It never consults the trusted-device list, so a known id and an unknown one\n * produce the same shape and the route cannot be used to enumerate devices.\n * The attestation proves the fresh tunnel key with the signer the phone pinned\n * at pairing, over the phone's own nonce. Undefined while the host cannot attest.\n */\nexport function deviceAuthChallenge(input: {\n  challenges: DeviceChallenges;\n  trustedDeviceId: string;\n  nonce: string;\n  origin: string;\n  hostPublicKey: string;\n  attest: (fields: readonly string[]) => string | undefined;\n}): { challengeId: string; challenge: string; hostPublicKey: string; attestation: string } | undefined {\n  const attestation = input.attest(hostChannelKeyFields(input.origin, input.hostPublicKey, input.nonce));\n  if (attestation === undefined) return undefined;\n  const issued = input.challenges.issue(input.hostPublicKey, { kind: 'auth', trustedDeviceId: input.trustedDeviceId });\n  return { challengeId: issued.id, challenge: issued.challenge, hostPublicKey: input.hostPublicKey, attestation };\n}\n\n/** A step-up challenge bound to one action and one session, answered by the biometric key. */\nexport function deviceStepUpChallenge(input: {\n  challenges: DeviceChallenges;\n  sessionDeviceId: string;\n  action: StepUpAction;\n  hostPublicKey: string;\n}): { ceremonyId: string; challenge: string; kind: 'device-key' } {\n  const issued = input.challenges.issue(input.hostPublicKey, {\n    kind: 'step-up',\n    sessionDeviceId: input.sessionDeviceId,\n    action: input.action,\n  });\n  return { ceremonyId: issued.id, challenge: issued.challenge, kind: 'device-key' };\n}\n\n/**\n * Checks a registration from a sealed `pairing` session.\n *\n * Both keys must be distinct P-256 SPKIs and both must sign the same\n * `po/device-register/v1` message, which binds them to this origin, this\n * tunnel key, and this exact session.\n */\nexport function verifyRegistration(input: {\n  origin: string;\n  hostPublicKey: string;\n  sessionDeviceId: string;\n  trust: DeviceTrust | undefined;\n  body: unknown;\n}): RegistrationVerdict {\n  if (input.trust?.kind !== 'pairing') return { ok: false, reason: 'not-pairing' };\n  const body = input.body;\n  if (!isRecord(body)) return { ok: false, reason: 'invalid' };\n  const { identityPublicKey, stepUpPublicKey, label, platform, identityProof, stepUpProof } = body;\n  if (\n    !isP256PublicKey(identityPublicKey) ||\n    !isP256PublicKey(stepUpPublicKey) ||\n    identityPublicKey === stepUpPublicKey ||\n    typeof label !== 'string' ||\n    typeof platform !== 'string' ||\n    !PLATFORMS.has(platform) ||\n    !isBase64Url(identityProof, MAX_SIGNATURE_LENGTH) ||\n    !isBase64Url(stepUpProof, MAX_SIGNATURE_LENGTH)\n  )\n    return { ok: false, reason: 'invalid' };\n  const fields = deviceRegisterFields({\n    origin: input.origin,\n    hostPublicKey: input.hostPublicKey,\n    sessionDeviceId: input.sessionDeviceId,\n    identityPublicKey,\n    stepUpPublicKey,\n    platform,\n  });\n  if (\n    !verifyDeviceSignature(identityPublicKey, DEVICE_REGISTER_TAG, fields, identityProof) ||\n    !verifyDeviceSignature(stepUpPublicKey, DEVICE_REGISTER_TAG, fields, stepUpProof)\n  )\n    return { ok: false, reason: 'invalid' };\n  return {\n    ok: true,\n    identityPublicKey,\n    stepUpPublicKey,\n    // Attacker-supplied and shown in the host UI, so it is cleaned like a user agent.\n    label: sanitizeUserAgent(label),\n    platform: platform as TrustedDevicePlatform,\n  };\n}\n\nfunction channelKeysOf(value: unknown): DeviceChannelKeys | undefined {\n  if (!isRecord(value)) return undefined;\n  const { session, protocol, http } = value;\n  if (\n    !isBase64Url(session, MAX_CHANNEL_KEY_LENGTH) ||\n    !isBase64Url(protocol, MAX_CHANNEL_KEY_LENGTH) ||\n    !isBase64Url(http, MAX_CHANNEL_KEY_LENGTH)\n  )\n    return undefined;\n  if (session === protocol || session === http || protocol === http) return undefined;\n  return { session, protocol, http };\n}\n\n/**\n * Checks a device sign-in. The challenge is consumed before anything else is\n * looked at, so every attempt, good or bad, burns it.\n */\nexport function verifyAuthentication(input: {\n  challenges: DeviceChallenges;\n  origin: string;\n  /** The tunnel key in force now; a challenge issued under another one is refused. */\n  hostPublicKey: string | undefined;\n  find: (trustedDeviceId: string) => TrustedDeviceRecord | undefined;\n  body: unknown;\n}): AuthenticationVerdict {\n  const body = input.body;\n  if (!isRecord(body) || !isOpaqueId(body.challengeId)) return { ok: false };\n  const issued = input.challenges.take(body.challengeId);\n  if (issued === undefined || issued.purpose.kind !== 'auth') return { ok: false };\n  if (input.hostPublicKey === undefined || issued.hostPublicKey !== input.hostPublicKey) return { ok: false };\n  if (!isOpaqueId(body.trustedDeviceId) || body.trustedDeviceId !== issued.purpose.trustedDeviceId)\n    return { ok: false };\n  if (!isBase64Url(body.signature, MAX_SIGNATURE_LENGTH)) return { ok: false };\n  const channels = channelKeysOf(body.channels);\n  if (channels === undefined) return { ok: false };\n  const record = input.find(body.trustedDeviceId);\n  if (record === undefined) return { ok: false };\n  const fields = deviceAuthFields({\n    origin: input.origin,\n    challenge: issued.challenge,\n    hostPublicKey: issued.hostPublicKey,\n    trustedDeviceId: record.id,\n    channels,\n  });\n  if (!verifyDeviceSignature(record.identityPublicKey, DEVICE_AUTH_TAG, fields, body.signature)) return { ok: false };\n  return { ok: true, record, channels };\n}\n\n/** Checks a biometric step-up signature for one action from one device-key session. */\nexport function verifyStepUp(input: {\n  challenges: DeviceChallenges;\n  origin: string;\n  hostPublicKey: string | undefined;\n  sessionDeviceId: string;\n  action: string;\n  ceremonyId: unknown;\n  signature: unknown;\n  stepUpPublicKey: string;\n}): boolean {\n  if (!isOpaqueId(input.ceremonyId) || !isStepUpAction(input.action)) return false;\n  const issued = input.challenges.take(input.ceremonyId);\n  if (issued === undefined || issued.purpose.kind !== 'step-up') return false;\n  if (input.hostPublicKey === undefined || issued.hostPublicKey !== input.hostPublicKey) return false;\n  if (issued.purpose.sessionDeviceId !== input.sessionDeviceId || issued.purpose.action !== input.action) return false;\n  if (!isBase64Url(input.signature, MAX_SIGNATURE_LENGTH)) return false;\n  return verifyDeviceSignature(\n    input.stepUpPublicKey,\n    DEVICE_STEP_UP_TAG,\n    deviceStepUpFields({\n      origin: input.origin,\n      action: input.action,\n      sessionDeviceId: input.sessionDeviceId,\n      challengeId: issued.id,\n      challenge: issued.challenge,\n    }),\n    input.signature,\n  );\n}\n"],"mappings":"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"}