machine-bridge-mcp 2.0.0 → 3.0.0-beta.9

package/src/worker/daemon-auth.ts

@@ -1,6 +1,15 @@
 import { DAEMON_AUTH_CHALLENGE_TTL_SECONDS, DAEMON_AUTH_SCHEME, DAEMON_PREFLIGHT_SCHEME, DAEMON_PREFLIGHT_TTL_SECONDS, daemonAuthTranscript, daemonPreflightTranscript } from "../shared/daemon-auth.mjs";
 import { safeEqual } from "./oauth-state.ts";
 import { consumeBoundedNonce } from "./nonce-store.ts";
+import {
+  decodeBase64Url,
+  parsePublicJwk,
+  publicKeyId,
+  verifyDeviceSessionCertificate,
+  verifyP256Signature,
+} from "./device-session-verifier.ts";
+
+const SESSION_CERTIFICATE_HEADER = "X-Bridge-Device-Certificate";
 
 export interface DaemonChallenge {
   scheme: typeof DAEMON_AUTH_SCHEME;
@@ -22,26 +31,37 @@ export function createDaemonChallenge(workerOrigin: string, now = Math.floor(Dat
   };
 }
 
-
 export function sanitizeDaemonChallengeAttachment(value: Record<string, unknown>): Partial<{
   authChallenge: string;
   authIssuedAt: number;
   authExpiresAt: number;
   workerOrigin: string;
+  authSessionPublicKeyJson: string;
+  authSessionKeyId: string;
+  authCertificateExpiresAt: number;
 }> {
   const authChallenge = typeof value.authChallenge === "string" && /^daemon_challenge_[A-Za-z0-9_-]{40,96}$/.test(value.authChallenge)
     ? value.authChallenge
     : undefined;
   const authIssuedAt = positiveSafeInteger(value.authIssuedAt);
   const authExpiresAt = positiveSafeInteger(value.authExpiresAt);
+  const authCertificateExpiresAt = positiveSafeInteger(value.authCertificateExpiresAt);
+  const authSessionKeyId = typeof value.authSessionKeyId === "string" && /^device_[A-Za-z0-9_-]{32}$/.test(value.authSessionKeyId)
+    ? value.authSessionKeyId
+    : undefined;
   let workerOrigin: string | undefined;
   try { workerOrigin = normalizeWorkerOrigin(String(value.workerOrigin || "")); } catch {}
-  return { authChallenge, authIssuedAt, authExpiresAt, workerOrigin };
+  let authSessionPublicKeyJson: string | undefined;
+  try { authSessionPublicKeyJson = JSON.stringify(parsePublicJwk(String(value.authSessionPublicKeyJson || ""))); } catch {}
+  return { authChallenge, authIssuedAt, authExpiresAt, workerOrigin, authSessionPublicKeyJson, authSessionKeyId, authCertificateExpiresAt };
 }
 
 export interface DaemonPreflightAuthorization {
   nonce: string;
   expiresAt: number;
+  sessionPublicKeyJson: string;
+  sessionKeyId: string;
+  certificateExpiresAt: number;
 }
 
 export async function verifyDaemonPreflight(input: {
@@ -53,6 +73,15 @@ export async function verifyDaemonPreflight(input: {
   now?: number;
 }): Promise<DaemonPreflightAuthorization | null> {
   const now = Number.isSafeInteger(input.now) ? Number(input.now) : Math.floor(Date.now() / 1000);
+  const certificate = await verifyDeviceSessionCertificate({
+    encodedCertificate: input.headers.get(SESSION_CERTIFICATE_HEADER) || "",
+    rootPublicKeyJson: input.publicKeyJson,
+    workerOrigin: input.workerOrigin,
+    server: input.server,
+    version: input.version,
+    now,
+  });
+  if (!certificate) return null;
   const scheme = input.headers.get("X-Bridge-Device-Scheme") || "";
   const keyId = input.headers.get("X-Bridge-Device-Key") || "";
   const nonce = input.headers.get("X-Bridge-Device-Nonce") || "";
@@ -61,36 +90,23 @@ export async function verifyDaemonPreflight(input: {
   if (scheme !== DAEMON_PREFLIGHT_SCHEME || !signature) return null;
   if (!Number.isSafeInteger(issuedAt) || Math.abs(now - issuedAt) > DAEMON_PREFLIGHT_TTL_SECONDS) return null;
   if (!/^[A-Za-z0-9_-]{24,128}$/.test(nonce)) return null;
-  let publicJwk: JsonWebKey;
-  try { publicJwk = parsePublicJwk(input.publicKeyJson); } catch { return null; }
-  if (!(await safeEqual(keyId, await publicKeyId(publicJwk)))) return null;
+  if (!(await safeEqual(keyId, certificate.sessionKeyId))) return null;
   let transcript: string;
   try {
-    transcript = daemonPreflightTranscript({
-      workerOrigin: input.workerOrigin,
-      server: input.server,
-      version: input.version,
-      nonce,
-      issuedAt,
-    });
-  } catch {
-    return null;
-  }
-  try {
-    const key = await crypto.subtle.importKey("jwk", publicJwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
-    const valid = await crypto.subtle.verify(
-      { name: "ECDSA", hash: "SHA-256" },
-      key,
-      signature,
-      new TextEncoder().encode(transcript),
-    );
-    return valid ? { nonce, expiresAt: issuedAt + DAEMON_PREFLIGHT_TTL_SECONDS } : null;
+    transcript = daemonPreflightTranscript({ workerOrigin: input.workerOrigin, server: input.server, version: input.version, nonce, issuedAt });
   } catch {
     return null;
   }
+  if (!(await verifyP256Signature(certificate.sessionPublicJwk, transcript, signature))) return null;
+  return {
+    nonce,
+    expiresAt: issuedAt + DAEMON_PREFLIGHT_TTL_SECONDS,
+    sessionPublicKeyJson: certificate.sessionPublicKeyJson,
+    sessionKeyId: certificate.sessionKeyId,
+    certificateExpiresAt: certificate.expiresAt,
+  };
 }
 
-
 export async function consumeDaemonPreflightNonce(
   storage: DurableObjectStorage,
   authorization: DaemonPreflightAuthorization,
@@ -113,10 +129,12 @@ export async function verifyDaemonAuthentication(input: {
   server: string;
   version: string;
   instanceId: string;
+  certificateExpiresAt?: number;
   now?: number;
 }): Promise<boolean> {
   const now = Number.isSafeInteger(input.now) ? Number(input.now) : Math.floor(Date.now() / 1000);
   if (now < input.challenge.issuedAt - 5 || now > input.challenge.expiresAt) return false;
+  if (input.certificateExpiresAt !== undefined && (!Number.isSafeInteger(input.certificateExpiresAt) || now > input.certificateExpiresAt)) return false;
   if (!input.authentication || typeof input.authentication !== "object" || Array.isArray(input.authentication)) return false;
   const auth = input.authentication as Record<string, unknown>;
   if (auth.scheme !== DAEMON_AUTH_SCHEME) return false;
@@ -126,8 +144,7 @@ export async function verifyDaemonAuthentication(input: {
   if (!signature) return false;
   let publicJwk: JsonWebKey;
   try { publicJwk = parsePublicJwk(input.publicKeyJson); } catch { return false; }
-  const expectedKeyId = await publicKeyId(publicJwk);
-  if (!(await safeEqual(String(auth.key_id || ""), expectedKeyId))) return false;
+  if (!(await safeEqual(String(auth.key_id || ""), await publicKeyId(publicJwk)))) return false;
   let transcript: string;
   try {
     transcript = daemonAuthTranscript({
@@ -141,45 +158,7 @@ export async function verifyDaemonAuthentication(input: {
   } catch {
     return false;
   }
-  try {
-    const key = await crypto.subtle.importKey("jwk", publicJwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
-    return crypto.subtle.verify(
-      { name: "ECDSA", hash: "SHA-256" },
-      key,
-      signature,
-      new TextEncoder().encode(transcript),
-    );
-  } catch {
-    return false;
-  }
-}
-
-function parsePublicJwk(value: string): JsonWebKey {
-  const parsed = JSON.parse(value) as JsonWebKey;
-  if (!parsed || parsed.kty !== "EC" || parsed.crv !== "P-256") throw new Error("invalid device public key");
-  if (typeof parsed.x !== "string" || typeof parsed.y !== "string" || parsed.d !== undefined) throw new Error("invalid device public key");
-  return { kty: "EC", crv: "P-256", x: parsed.x, y: parsed.y, ext: true, key_ops: ["verify"] };
-}
-
-async function publicKeyId(jwk: JsonWebKey): Promise<string> {
-  const canonical = JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical));
-  return `device_${base64Url(new Uint8Array(digest)).slice(0, 32)}`;
-}
-
-function decodeBase64Url(value: string, expectedBytes: number): Uint8Array<ArrayBuffer> | null {
-  if (!/^[A-Za-z0-9_-]+$/.test(value)) return null;
-  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
-  const padding = "=".repeat((4 - (normalized.length % 4)) % 4);
-  try {
-    const binary = atob(normalized + padding);
-    if (binary.length !== expectedBytes) return null;
-    const bytes = new Uint8Array(expectedBytes);
-    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
-    return bytes;
-  } catch {
-    return null;
-  }
+  return verifyP256Signature(publicJwk, transcript, signature);
 }
 
 function base64Url(bytes: Uint8Array): string {
@@ -188,7 +167,6 @@ function base64Url(bytes: Uint8Array): string {
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 
-
 function positiveSafeInteger(value: unknown): number | undefined {
   const number = Number(value);
   return Number.isSafeInteger(number) && number > 0 ? number : undefined;

package/src/worker/daemon-sockets.ts

@@ -2,7 +2,6 @@ import { isLiveDaemonAttachment, withDaemonLastSeenAt, type DaemonRole } from ".
 import { sanitizeMetadataText } from "./http.ts";
 import { sanitizeDaemonPolicy, sanitizeDaemonTools, type DaemonPolicy } from "./policy.ts";
 import { sanitizeDaemonChallengeAttachment, type DaemonChallenge } from "./daemon-auth.ts";
-
 export interface DaemonAttachment {
   role: DaemonRole;
   connectedAt: string;
@@ -15,6 +14,9 @@ export interface DaemonAttachment {
   authIssuedAt?: number;
   authExpiresAt?: number;
   workerOrigin?: string;
+  authSessionPublicKeyJson?: string;
+  authSessionKeyId?: string;
+  authCertificateExpiresAt?: number;
 }
 
 interface WebSocketContext {
@@ -58,7 +60,12 @@ export class DaemonSocketRegistry {
     return this.context.getWebSockets().filter((socket) => this.attachment(socket)?.role !== "daemon" && socket.readyState === WebSocket.OPEN);
   }
 
-  beginCandidate(socket: WebSocket, challenge: DaemonChallenge, connectedAt = new Date().toISOString()): void {
+  beginCandidate(
+    socket: WebSocket,
+    challenge: DaemonChallenge,
+    preflight: { sessionPublicKeyJson: string; sessionKeyId: string; certificateExpiresAt: number },
+    connectedAt = new Date().toISOString(),
+  ): void {
     socket.serializeAttachment({
       role: "candidate",
       connectedAt,
@@ -66,6 +73,9 @@ export class DaemonSocketRegistry {
       authIssuedAt: challenge.issuedAt,
       authExpiresAt: challenge.expiresAt,
       workerOrigin: challenge.workerOrigin,
+      authSessionPublicKeyJson: preflight.sessionPublicKeyJson,
+      authSessionKeyId: preflight.sessionKeyId,
+      authCertificateExpiresAt: preflight.certificateExpiresAt,
     } satisfies DaemonAttachment);
   }
 

package/src/worker/device-session-verifier.ts

@@ -0,0 +1,129 @@
+import {
+  DEVICE_SESSION_CERTIFICATE_SCHEME,
+  DEVICE_SESSION_MAX_LIFETIME_SECONDS,
+  canonicalPublicJwk,
+  deviceSessionCertificateTranscript,
+} from "../shared/device-session-auth.mjs";
+import { safeEqual } from "./oauth-state.ts";
+
+const SESSION_CERTIFICATE_MAX_BYTES = 16 * 1024;
+
+export interface VerifiedDeviceSessionCertificate {
+  sessionPublicJwk: JsonWebKey;
+  sessionPublicKeyJson: string;
+  sessionKeyId: string;
+  rootKeyId: string;
+  issuedAt: number;
+  expiresAt: number;
+}
+
+export async function verifyDeviceSessionCertificate(input: {
+  encodedCertificate: string;
+  rootPublicKeyJson: string;
+  workerOrigin: string;
+  server: string;
+  version: string;
+  now: number;
+}): Promise<VerifiedDeviceSessionCertificate | null> {
+  const bytes = decodeBase64Url(input.encodedCertificate);
+  if (!bytes || bytes.byteLength > SESSION_CERTIFICATE_MAX_BYTES) return null;
+  let value: Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    value = parsed as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+  if (value.scheme !== DEVICE_SESSION_CERTIFICATE_SCHEME) return null;
+  const issuedAt = Number(value.issued_at);
+  const expiresAt = Number(value.expires_at);
+  const nonce = String(value.nonce || "");
+  const rootKeyId = String(value.root_key_id || "");
+  const signature = decodeBase64Url(String(value.signature || ""), 64);
+  if (!signature || !Number.isSafeInteger(issuedAt) || !Number.isSafeInteger(expiresAt)) return null;
+  if (issuedAt > input.now + 5 * 60 || expiresAt <= input.now) return null;
+  if (expiresAt <= issuedAt || expiresAt - issuedAt > DEVICE_SESSION_MAX_LIFETIME_SECONDS) return null;
+  if (!/^[A-Za-z0-9_-]{24,128}$/.test(nonce)) return null;
+  let rootPublicJwk: JsonWebKey;
+  let sessionPublicJwk: JsonWebKey;
+  try {
+    rootPublicJwk = parsePublicJwk(input.rootPublicKeyJson);
+    sessionPublicJwk = parsePublicJwk(JSON.stringify(value.public_jwk));
+  } catch {
+    return null;
+  }
+  const expectedRootKeyId = await publicKeyId(rootPublicJwk);
+  if (!(await safeEqual(rootKeyId, expectedRootKeyId))) return null;
+  let transcript: string;
+  try {
+    transcript = deviceSessionCertificateTranscript({
+      workerOrigin: input.workerOrigin,
+      server: input.server,
+      version: input.version,
+      rootKeyId,
+      publicJwk: sessionPublicJwk,
+      issuedAt,
+      expiresAt,
+      nonce,
+    });
+  } catch {
+    return null;
+  }
+  if (!(await verifyP256Signature(rootPublicJwk, transcript, signature))) return null;
+  return {
+    sessionPublicJwk,
+    sessionPublicKeyJson: JSON.stringify(canonicalPublicJwk(sessionPublicJwk)),
+    sessionKeyId: await publicKeyId(sessionPublicJwk),
+    rootKeyId,
+    issuedAt,
+    expiresAt,
+  };
+}
+
+export async function verifyP256Signature(publicJwk: JsonWebKey, transcript: string, signature: Uint8Array<ArrayBuffer>): Promise<boolean> {
+  try {
+    const key = await crypto.subtle.importKey("jwk", publicJwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    return crypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-256" },
+      key,
+      signature,
+      new TextEncoder().encode(transcript),
+    );
+  } catch {
+    return false;
+  }
+}
+
+export function parsePublicJwk(value: string): JsonWebKey {
+  const parsed = JSON.parse(value) as JsonWebKey;
+  const canonical = canonicalPublicJwk(parsed);
+  return { ...canonical, ext: true, key_ops: ["verify"] };
+}
+
+export async function publicKeyId(jwk: JsonWebKey): Promise<string> {
+  const canonical = JSON.stringify(canonicalPublicJwk(jwk));
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(canonical));
+  return `device_${base64Url(new Uint8Array(digest)).slice(0, 32)}`;
+}
+
+export function decodeBase64Url(value: string, expectedBytes?: number): Uint8Array<ArrayBuffer> | null {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) return null;
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = "=".repeat((4 - (normalized.length % 4)) % 4);
+  try {
+    const binary = atob(normalized + padding);
+    if (expectedBytes !== undefined && binary.length !== expectedBytes) return null;
+    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  } catch {
+    return null;
+  }
+}
+
+function base64Url(bytes: Uint8Array): string {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}

package/src/worker/dpop.ts

@@ -0,0 +1,151 @@
+import { consumeBoundedNonce } from "./nonce-store.ts";
+
+const DPOP_WINDOW_SECONDS = 5 * 60;
+const MAX_DPOP_JTIS = 4096;
+const JKT_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+
+export interface VerifiedDpopProof {
+  jkt: string;
+  jti: string;
+  issuedAt: number;
+  replayKey: string;
+  expiresAt: number;
+}
+
+export async function verifyDpopProof(input: {
+  request: Request;
+  expectedMethod?: string;
+  expectedUrl?: string;
+  accessToken?: string;
+  expectedJkt?: string;
+  now?: number;
+}): Promise<VerifiedDpopProof | null> {
+  const encoded = input.request.headers.get("DPoP") || "";
+  if (!encoded) return null;
+  const parts = encoded.split(".");
+  if (parts.length !== 3 || parts.some((part) => !/^[A-Za-z0-9_-]+$/.test(part))) return null;
+  const header = decodeJson(parts[0]);
+  const payload = decodeJson(parts[1]);
+  const signature = decodeBase64Url(parts[2], 64);
+  if (!header || !payload || !signature) return null;
+  if (header.typ !== "dpop+jwt" || header.alg !== "ES256" || !plainRecord(header.jwk)) return null;
+  if (header.crit !== undefined || header.b64 !== undefined) return null;
+  const publicJwk = publicP256Jwk(header.jwk);
+  if (!publicJwk) return null;
+  const now = Number.isSafeInteger(input.now) ? Number(input.now) : Math.floor(Date.now() / 1000);
+  const issuedAt = Number(payload.iat);
+  const jti = String(payload.jti || "");
+  if (!Number.isSafeInteger(issuedAt) || Math.abs(now - issuedAt) > DPOP_WINDOW_SECONDS) return null;
+  if (!/^[A-Za-z0-9._~-]{16,200}$/.test(jti)) return null;
+  const expectedMethod = String(input.expectedMethod || input.request.method).toUpperCase();
+  const expectedUrl = normalizedHtu(input.expectedUrl || input.request.url);
+  if (String(payload.htm || "").toUpperCase() !== expectedMethod || normalizedHtu(String(payload.htu || "")) !== expectedUrl) return null;
+  const jkt = await jwkThumbprint(publicJwk);
+  if (input.expectedJkt && (!JKT_PATTERN.test(input.expectedJkt) || input.expectedJkt !== jkt)) return null;
+  if (input.accessToken) {
+    const ath = String(payload.ath || "");
+    if (ath !== await sha256Base64Url(input.accessToken)) return null;
+  } else if (payload.ath !== undefined) {
+    return null;
+  }
+  try {
+    const key = await crypto.subtle.importKey("jwk", publicJwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]);
+    const verified = await crypto.subtle.verify(
+      { name: "ECDSA", hash: "SHA-256" },
+      key,
+      signature as unknown as BufferSource,
+      new TextEncoder().encode(`${parts[0]}.${parts[1]}`),
+    );
+    if (!verified) return null;
+  } catch {
+    return null;
+  }
+  const replayKey = await sha256Base64Url(`${jkt}\0${jti}`);
+  return {
+    jkt,
+    jti,
+    issuedAt,
+    replayKey,
+    expiresAt: Math.max(now + 1, issuedAt + DPOP_WINDOW_SECONDS),
+  };
+}
+
+export async function consumeDpopProof(
+  storage: DurableObjectStorage,
+  proof: VerifiedDpopProof,
+  now = Math.floor(Date.now() / 1000),
+): Promise<boolean> {
+  if (!proof || !JKT_PATTERN.test(proof.replayKey) || !Number.isSafeInteger(proof.expiresAt) || proof.expiresAt <= now) return false;
+  return consumeBoundedNonce(storage, {
+    key: "dpop-proof-jtis",
+    nonce: proof.replayKey,
+    expiresAt: proof.expiresAt,
+    now,
+    noncePattern: JKT_PATTERN,
+    maximum: MAX_DPOP_JTIS,
+  });
+}
+
+export async function jwkThumbprint(jwk: JsonWebKey): Promise<string> {
+  const publicJwk = publicP256Jwk(jwk);
+  if (!publicJwk) throw new Error("DPoP public key is invalid");
+  const canonical = JSON.stringify({ crv: publicJwk.crv, kty: publicJwk.kty, x: publicJwk.x, y: publicJwk.y });
+  return sha256Base64Url(canonical);
+}
+
+export function normalizedHtu(value: string): string {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))) {
+    throw new Error("DPoP target URI is invalid");
+  }
+  if (url.username || url.password || url.hash) throw new Error("DPoP target URI is invalid");
+  return `${url.origin}${url.pathname}`;
+}
+
+function publicP256Jwk(value: unknown): JsonWebKey | null {
+  if (!plainRecord(value) || value.kty !== "EC" || value.crv !== "P-256" || value.d !== undefined) return null;
+  if (typeof value.x !== "string" || typeof value.y !== "string") return null;
+  if (!/^[A-Za-z0-9_-]{42,44}$/.test(value.x) || !/^[A-Za-z0-9_-]{42,44}$/.test(value.y)) return null;
+  return { kty: "EC", crv: "P-256", x: value.x, y: value.y, ext: true, key_ops: ["verify"] };
+}
+
+function decodeJson(value: string): Record<string, unknown> | null {
+  const bytes = decodeBase64Url(value);
+  if (!bytes || bytes.byteLength > 16 * 1024) return null;
+  try {
+    const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    return plainRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function decodeBase64Url(value: string, expectedBytes?: number): Uint8Array | null {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) return null;
+  const normalized = value.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  try {
+    const binary = atob(padded);
+    if (expectedBytes !== undefined && binary.length !== expectedBytes) return null;
+    const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  } catch {
+    return null;
+  }
+}
+
+async function sha256Base64Url(value: string): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return base64Url(new Uint8Array(digest));
+}
+
+function base64Url(bytes: Uint8Array): string {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+
+function plainRecord(value: unknown): value is Record<string, any> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/src/worker/http.ts

@@ -101,11 +101,18 @@ export function baseUrl(request: Request): string {
   return new URL(request.url).origin;
 }
 
+export function oauthAccessToken(request: Request): { scheme: "bearer" | "dpop" | ""; token: string } {
+  const match = (request.headers.get("Authorization") ?? "").match(/^(Bearer|DPoP)\s+(.+)$/i);
+  if (!match) return { scheme: "", token: "" };
+  return { scheme: match[1].toLowerCase() as "bearer" | "dpop", token: match[2].trim() };
+}
+
 export function bearerToken(request: Request): string {
-  const match = (request.headers.get("Authorization") ?? "").match(/^Bearer\s+(.+)$/i);
-  return match?.[1]?.trim() ?? "";
+  const access = oauthAccessToken(request);
+  return access.scheme === "bearer" ? access.token : "";
 }
 
+
 export async function parseJsonRequest(request: Request, limit: number): Promise<unknown> {
   const text = await readBoundedText(request, limit);
   try {
@@ -133,31 +140,50 @@ export async function parseRequestBody(request: Request, limit: number): Promise
   return searchParamsObject(new URLSearchParams(text));
 }
 
-export async function readBoundedText(request: Request, limit: number): Promise<string> {
-  const length = Number(request.headers.get("content-length") ?? "0");
-  if (Number.isFinite(length) && length > limit) {
-    throw new HttpError(413, "request_body_too_large", `request body exceeds ${limit} bytes`);
-  }
-  if (!request.body) return "";
+export async function discardRequestBody(request: Pick<Request, "body" | "headers">, limit: number): Promise<{ bytes_read: number; exceeded: boolean }> {
+  const boundedLimit = normalizeBodyLimit(limit);
+  const declaredLength = Number(request.headers.get("content-length") ?? "0");
+  let exceeded = Number.isFinite(declaredLength) && declaredLength > boundedLimit;
+  let observed = 0;
+  if (!request.body) return { bytes_read: 0, exceeded };
   const reader = request.body.getReader();
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      observed = Math.min(boundedLimit + 1, observed + value.byteLength);
+      if (observed > boundedLimit) exceeded = true;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return { bytes_read: observed, exceeded };
+}
+
+export async function readBoundedText(request: Request, limit: number): Promise<string> {
+  const boundedLimit = normalizeBodyLimit(limit);
+  const declaredLength = Number(request.headers.get("content-length") ?? "0");
+  let exceeded = Number.isFinite(declaredLength) && declaredLength > boundedLimit;
+  const reader = request.body?.getReader();
+  if (!reader) return "";
   const chunks: Uint8Array[] = [];
-  let total = 0;
+  let observed = 0;
   try {
     for (;;) {
       const { done, value } = await reader.read();
       if (done) break;
       if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        await reader.cancel();
-        throw new HttpError(413, "request_body_too_large", `request body exceeds ${limit} bytes`);
-      }
-      chunks.push(value);
+      const nextObserved = Math.min(boundedLimit + 1, observed + value.byteLength);
+      if (!exceeded && observed + value.byteLength <= boundedLimit) chunks.push(value);
+      else exceeded = true;
+      observed = nextObserved;
     }
   } finally {
     reader.releaseLock();
   }
-  const combined = new Uint8Array(total);
+  if (exceeded) throw new HttpError(413, "request_body_too_large", `request body exceeds ${boundedLimit} bytes`);
+  const combined = new Uint8Array(observed);
   let offset = 0;
   for (const chunk of chunks) {
     combined.set(chunk, offset);
@@ -170,6 +196,11 @@ export async function readBoundedText(request: Request, limit: number): Promise<
   }
 }
 
+function normalizeBodyLimit(value: number): number {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : 0;
+}
+
 export function normalizeRedirectUri(value: string): string | null {
   try {
     const url = new URL(value);