fedipod-server 0.12.1 → 0.13.1

package/web/app/keys-browser.mjs

@@ -4,6 +4,11 @@
 // this returns the same, RSA only. FEP-8b32 Ed25519 proofs are optional — the
 // deliverer treats a null edPrivate as "no proof", and an unproved activity
 // still federates — so the browser MVP omits them.
+//
+// The private key is imported NON-extractable, and the copy this browser keeps
+// in IndexedDB is that CryptoKey, not the PEM: it can sign and cannot be read
+// out, so a script that reaches this origin's storage gets nothing it can carry
+// away. The PEM record exists only in memory, between unwrap and import.
 import { kvGet, kvPut } from './idb-kv.mjs';
 import * as podState from '../../lib/pod/state.mjs';
 import { isKeyEnvelope, KeyPasswordNeeded } from './keystore.mjs';
@@ -13,10 +18,26 @@ const pemToDer = (pem) => Uint8Array.from(
 
 export async function importSigningKey(keysRecord) {
   const rsaPrivate = await crypto.subtle.importKey('pkcs8', pemToDer(keysRecord.rsa.privatePem),
-    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, true, ['sign']);
+    { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, false, ['sign']);
   return { rsaPrivate, rsaPublicPem: keysRecord.rsa.publicPem, edPrivate: null, edPublicMultibase: null };
 }
 
+/** What the cache holds: the non-extractable key and the public half. */
+const fromCache = (c) => ({ rsaPrivate: c.rsaPrivate, rsaPublicPem: c.rsaPublicPem, edPrivate: null, edPublicMultibase: null });
+const isOpenedKey = (c) => c?.rsaPrivate?.type === 'private' && typeof c.rsaPublicPem === 'string';
+
+/**
+ * Keep this browser's opened copy: import the record and store the CryptoKey.
+ * Best effort on the store — a browser that refuses IndexedDB (private mode)
+ * asks for the password on the way back in. Returns the imported keys.
+ */
+export async function cacheOpenedKeys(actorUrl, keysRecord) {
+  const keys = await importSigningKey(keysRecord);
+  await kvPut(keyCacheKey(actorUrl), { rsaPrivate: keys.rsaPrivate, rsaPublicPem: keys.rsaPublicPem })
+    .catch(() => {});
+  return keys;
+}
+
 // Where this browser keeps its own opened copy of the signing key. The pod's
 // copy is wrapped under the account password; this one is not, because it never
 // leaves the origin — the same protection the OIDC session in the next IDB row
@@ -34,13 +55,15 @@ export const keyCacheKey = (actorUrl) => `signing-keys:${actorUrl}`;
 // needs the password and so has to go back to the page.
 export async function loadKeysFromPod(remote, urls) {
   const cached = await kvGet(keyCacheKey(urls.actor)).catch(() => null);
-  if (cached?.rsa) return importSigningKey(cached);
+  if (isOpenedKey(cached)) return fromCache(cached);
+  // A copy stored as PEM by an earlier build: import it and store the key form
+  // in its place, so the PEM is gone from storage after one boot.
+  if (cached?.rsa?.privatePem) return cacheOpenedKeys(urls.actor, cached);
 
   const doc = await podState.readWrappedKeys(remote, urls);
   if (isKeyEnvelope(doc)) throw new KeyPasswordNeeded();
   if (!doc || !doc.rsa) throw new Error('no signing key on the pod — sign up did not finish');
   // A pre-wrapping install. Cache it so the next boot is one read, and leave
   // the pod's copy alone: re-wrapping it would need the password we do not have.
-  await kvPut(keyCacheKey(urls.actor), doc).catch(() => {});
-  return importSigningKey(doc);
+  return cacheOpenedKeys(urls.actor, doc);
 }

package/web/app/signup.mjs

@@ -14,8 +14,7 @@ import { createAccountWithPod, mintCredential, makeDpopSession, revokeCredential
 import { generateKeys, wrapKeys } from './keystore.mjs';
 import { BrowserRemotePod } from './pod-remote.mjs';
 import * as podState from '../../lib/pod/state.mjs';
-import { kvPut } from './idb-kv.mjs';
-import { keyCacheKey } from './keys-browser.mjs';
+import { cacheOpenedKeys } from './keys-browser.mjs';
 
 // The container everything the agent publishes hangs under. New pods made here
 // use `fedipod/`; the agent's own default stays `activitypods-js/` for installs
@@ -167,7 +166,7 @@ export async function signUp(answers, { onStep = () => {}, frontOrigin = null }
     // This browser's own opened copy, so the boot after the login redirect
     // needs no password. Best effort: a browser that refuses IndexedDB (private
     // mode) simply asks for the password on the way back in.
-    await kvPut(keyCacheKey(actorUrl), keys).catch(() => {});
+    await cacheOpenedKeys(actorUrl, keys);
     prog.keys = keys; prog.keysStored = true;
     keysStep.ok();
   } else {

package/web/app/site/boot.js

@@ -33231,6 +33231,26 @@ async function kvPut(key, val) {
 }
 
 // web/app/keys-browser.mjs
+var pemToDer = (pem) => Uint8Array.from(
+  atob(pem.replace(/-----[^-]+-----/g, "").replace(/\s+/g, "")),
+  (c) => c.charCodeAt(0)
+);
+async function importSigningKey(keysRecord) {
+  const rsaPrivate = await crypto.subtle.importKey(
+    "pkcs8",
+    pemToDer(keysRecord.rsa.privatePem),
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return { rsaPrivate, rsaPublicPem: keysRecord.rsa.publicPem, edPrivate: null, edPublicMultibase: null };
+}
+async function cacheOpenedKeys(actorUrl, keysRecord) {
+  const keys = await importSigningKey(keysRecord);
+  await kvPut(keyCacheKey(actorUrl), { rsaPrivate: keys.rsaPrivate, rsaPublicPem: keys.rsaPublicPem }).catch(() => {
+  });
+  return keys;
+}
 var keyCacheKey = (actorUrl) => `signing-keys:${actorUrl}`;
 
 // web/app/signup.mjs
@@ -33321,8 +33341,7 @@ async function signUp(answers, { onStep = () => {
     } catch (e) {
       throw new Error(`could not store the signing key on the pod (${e.message}). The credential is for ${credential.webId} \u2014 that WebID must own ${pod} and its ${AP_ROOT} must be writable by it.`);
     }
-    await kvPut(keyCacheKey(actorUrl), keys).catch(() => {
-    });
+    await cacheOpenedKeys(actorUrl, keys);
     prog.keys = keys;
     prog.keysStored = true;
     keysStep.ok();
@@ -33668,7 +33687,7 @@ window.fedipodUnlock = async (password) => {
   if (!isKeyEnvelope(doc)) throw new Error("this account's key is not locked \u2014 nothing to unlock");
   const rec = await unwrapKeys(doc, password);
   const actorUrl = `${cfg.remotePod}${cfg.root || AP_ROOT}ap/actor`;
-  await kvPut(keyCacheKey(actorUrl), rec);
+  await cacheOpenedKeys(actorUrl, rec);
   await bootWorker();
 };
 window.fedipodSignup = async ({ onStep, ...answers }) => {