~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/socialweb-computer-console

console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork

0
0
main
167 lines · 6.8 KB Raw History
// Copyright 2026 The KCP Authors.
// SPDX-License-Identifier: Apache-2.0

// OAuth token refresh worker: kcp's Go runtime (socialweb oauthclient's
// TokenRefresher seam, socialweb docs/ARCHITECTURE.md section 7) hands each
// refresh of the page's public atproto client here, so a busy Go runtime can
// never delay the token response and lose a rotated, single-use refresh
// token. The worker signs the DPoP proofs with a non-extractable WebCrypto
// key, stores every rotated set in IndexedDB before answering, and answers a
// stored newer set instead of POSTing a refresh token that is already spent.
// It never logs or stores the private key.
//
// Message in:  {id, request: TokenRefreshRequest JSON text} (+ a reply port)
// Message out: {id, response: TokenRefreshResponse or {error, error_description, status} JSON text}

const DB = "kcp-oauth-refresh";
const STORE = "sets";

/** base64url without padding. */
export function b64url(bytes) {
  let s = "";
  for (const b of new Uint8Array(bytes)) s += String.fromCharCode(b);
  return btoa(s).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
}

const text = (s) => new TextEncoder().encode(s);

/** The htu of a DPoP proof: the endpoint without query or fragment. */
export function htu(endpoint) {
  const u = new URL(endpoint);
  return `${u.origin}${u.pathname}`;
}

/** A DPoP proof JWT for POST endpoint, signed with key (ES256, raw r||s). */
export async function dpopProof({ key, jwk, endpoint, nonce, now = Date.now() }) {
  const iat = Math.floor(now / 1000);
  const header = { typ: "dpop+jwt", alg: "ES256", jwk: { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y } };
  const claims = { jti: b64url(crypto.getRandomValues(new Uint8Array(16))), htm: "POST", htu: htu(endpoint), iat, exp: iat + 30 };
  if (nonce) claims.nonce = nonce;
  const input = `${b64url(text(JSON.stringify(header)))}.${b64url(text(JSON.stringify(claims)))}`;
  const sig = await crypto.subtle.sign({ name: "ECDSA", hash: "SHA-256" }, key, text(input));
  return `${input}.${b64url(sig)}`;
}

// Keys imported once per session; non-extractable, so the private JWK is
// only ever held as the request text Go sent.
const keys = new Map();
async function signingKey(sessionID, jwk) {
  const id = `${sessionID}:${jwk.x}:${jwk.y}`;
  if (!keys.has(id)) {
    keys.set(id, crypto.subtle.importKey("jwk", { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y, d: jwk.d },
      { name: "ECDSA", namedCurve: "P-256" }, false, ["sign"]));
  }
  return await keys.get(id);
}

function openDB() {
  return new Promise((resolve, reject) => {
    const req = indexedDB.open(DB, 1);
    req.onupgradeneeded = () => req.result.createObjectStore(STORE);
    req.onsuccess = () => resolve(req.result);
    req.onerror = () => reject(req.error);
  });
}

/** IndexedDB, or an in-memory map when it is unavailable (the set is still answered). */
export function tokenStore(db = openDB().catch(() => null)) {
  const memory = new Map();
  const tx = async (mode, fn) => {
    const d = await db;
    if (!d) return fn(null);
    return await new Promise((resolve, reject) => {
      const t = d.transaction(STORE, mode);
      const out = fn(t.objectStore(STORE));
      t.oncomplete = () => resolve(out?.result ?? out);
      t.onerror = () => reject(t.error);
    });
  };
  return {
    async get(id) {
      try {
        const got = await tx("readonly", (s) => s ? s.get(id) : null);
        return got ?? memory.get(id) ?? null;
      } catch {
        return memory.get(id) ?? null;
      }
    },
    async put(id, set) {
      memory.set(id, set);
      await tx("readwrite", (s) => s?.put(set, id));
    },
  };
}

const fail = (error, description = "", status = 0) => ({ error, error_description: description, status });

/**
 * refresher(request) -> response object. fetchFn, store and clientID are
 * injected for tests. Single-flight per did+session_id.
 */
export function refresher({ fetchFn = fetch, store = tokenStore(), clientID = `${self.location.origin}/oauth-client-metadata.json` } = {}) {
  const flights = new Map();
  async function once(req) {
    const id = `${req.did}|${req.session_id}`;
    // A stored set newer than the token Go holds: answer it, never POST a
    // spent refresh token.
    const stored = await store.get(id);
    if (stored && stored.previous_refresh_token === req.refresh_token && stored.refresh_token !== req.refresh_token) {
      return stored.response;
    }
    const key = await signingKey(req.session_id, req.dpop_jwk);
    let nonce = req.dpop_nonce ?? "";
    for (let attempt = 0; attempt < 2; attempt++) {
      let res;
      try {
        res = await fetchFn(req.token_endpoint, {
          method: "POST",
          headers: {
            "content-type": "application/x-www-form-urlencoded",
            dpop: await dpopProof({ key, jwk: req.dpop_jwk, endpoint: req.token_endpoint, nonce }),
          },
          body: new URLSearchParams({ grant_type: "refresh_token", refresh_token: req.refresh_token, client_id: req.client_id }),
        });
      } catch (err) {
        return fail("network", String(err?.message ?? err));
      }
      nonce = res.headers.get("dpop-nonce") ?? nonce;
      const body = await res.json().catch(() => ({}));
      if (res.ok) {
        const now = Math.floor(Date.now() / 1000);
        const response = {
          access_token: body.access_token, refresh_token: body.refresh_token, token_type: body.token_type,
          scope: body.scope, sub: body.sub, expires_in: body.expires_in,
          expires_at: body.expires_in ? now + body.expires_in : undefined, dpop_nonce: nonce || undefined,
        };
        // Persist before answering; a failed write still answers the set.
        await store.put(id, { previous_refresh_token: req.refresh_token, refresh_token: body.refresh_token, response })
          .catch(() => {});
        return response;
      }
      if (attempt === 0 && body.error === "use_dpop_nonce" && (res.status === 400 || res.status === 401)) continue;
      return fail(body.error ?? "http_error", body.error_description ?? "", res.status);
    }
    return fail("use_dpop_nonce", "the authorization server kept asking for a new DPoP nonce");
  }
  return (req) => {
    if (req.client_id !== clientID) return Promise.resolve(fail("pass_through"));
    const id = `${req.did}|${req.session_id}`;
    if (!flights.has(id)) flights.set(id, once(req).finally(() => flights.delete(id)));
    return flights.get(id);
  };
}

if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
  const refresh = refresher();
  self.onmessage = async (event) => {
    const { id, request } = event.data ?? {};
    const reply = event.ports[0] ?? self;
    let response;
    try {
      response = await refresh(JSON.parse(request));
    } catch (err) {
      response = fail("worker", String(err?.message ?? err));
    }
    reply.postMessage({ id, response: JSON.stringify(response) });
  };
}