@abraca/dabra 1.8.2 → 2.0.0

package/src/DocKeyManager.ts

@@ -45,16 +45,64 @@ export class DocKeyManager {
 		}
 
 		const envelope = await client.getMyKeyEnvelope(docId);
-		if (!envelope) return null;
+		if (envelope) {
+			const x25519PrivKey = await keystore.getX25519PrivateKey();
+			try {
+				const wrapped = fromBase64(envelope.encrypted_key);
+				const docKey = await this._unwrapKey(wrapped, x25519PrivKey, docId);
+				this.cache.set(docId, { key: docKey, epoch: envelope.key_epoch, fetchedAt: Date.now() });
+				return docKey;
+			} finally {
+				x25519PrivKey.fill(0);
+			}
+		}
 
-		const x25519PrivKey = await keystore.getX25519PrivateKey();
+		// Inheritance fallback. The doc has no envelope of our own — but it
+		// might inherit its encryption mode from an ancestor (e.g. a child
+		// page under an E2E space). The ancestor IS provisioned for us
+		// (otherwise we couldn't open the parent either). Resolve the
+		// encryption-source via /docs/:id/encryption.inherited_from, fetch
+		// OUR envelope on that source, unwrap with the source's salt,
+		// re-wrap for the current docId with its own salt, upload the new
+		// envelope so subsequent calls hit the direct-envelope path.
 		try {
-			const wrapped = fromBase64(envelope.encrypted_key);
-			const docKey = await this._unwrapKey(wrapped, x25519PrivKey, docId);
-			this.cache.set(docId, { key: docKey, epoch: envelope.key_epoch, fetchedAt: Date.now() });
-			return docKey;
-		} finally {
-			x25519PrivKey.fill(0);
+			const enc = await client.getDocEncryption(docId);
+			if (enc.effective_mode !== "e2e" || !enc.inherited_from || enc.inherited_from === docId) {
+				return null;
+			}
+			const sourceEnv = await client.getMyKeyEnvelope(enc.inherited_from);
+			if (!sourceEnv) return null;
+			const x25519PrivKey = await keystore.getX25519PrivateKey();
+			try {
+				const wrappedSrc = fromBase64(sourceEnv.encrypted_key);
+				const docKey = await this._unwrapKey(wrappedSrc, x25519PrivKey, enc.inherited_from);
+				this.cache.set(docId, { key: docKey, epoch: sourceEnv.key_epoch, fetchedAt: Date.now() });
+				// Re-wrap for the current doc + upload so future opens take
+				// the direct path. Best-effort — caller already has the key.
+				const me = await client.getMe();
+				if (me.publicKey) {
+					const myKeys = await client.listUserKeys(me.id);
+					const primaryKey = myKeys[0];
+					if (primaryKey?.x25519Key) {
+						const x25519Pub = fromBase64(primaryKey.x25519Key.replace(/-/g, "+").replace(/_/g, "/"));
+						const rewrapped = await this.wrapKeyForRecipient(docKey, x25519Pub, docId);
+						const b64 = (() => {
+							let s = "";
+							for (let i = 0; i < rewrapped.length; i++) s += String.fromCharCode(rewrapped[i]!);
+							return btoa(s);
+						})();
+						await client.uploadKeyEnvelopes(docId, {
+							key_epoch: sourceEnv.key_epoch,
+							envelopes: [{ recipient_key_id: primaryKey.id, encrypted_key: b64 }],
+						}).catch(() => null);
+					}
+				}
+				return docKey;
+			} finally {
+				x25519PrivKey.fill(0);
+			}
+		} catch {
+			return null;
 		}
 	}
 
@@ -73,11 +121,11 @@ export class DocKeyManager {
 
 		const salt = new TextEncoder().encode(docId);
 		const keyBytes = hkdf(sha256, sharedSecret, salt, HKDF_INFO, 32);
-		const wrapKey = await crypto.subtle.importKey("raw", keyBytes, { name: "AES-GCM" }, false, ["encrypt"]);
+		const wrapKey = await crypto.subtle.importKey("raw", keyBytes as BufferSource, { name: "AES-GCM" }, false, ["encrypt"]);
 
 		const rawDocKey = await crypto.subtle.exportKey("raw", docKey);
 		const nonce = crypto.getRandomValues(new Uint8Array(12));
-		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce }, wrapKey, rawDocKey));
+		const ciphertext = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv: nonce as BufferSource }, wrapKey, rawDocKey));
 
 		const result = new Uint8Array(32 + 12 + ciphertext.length);
 		result.set(ephemeralPub, 0);
@@ -94,8 +142,8 @@ export class DocKeyManager {
 		const sharedSecret = x25519.getSharedSecret(recipientX25519PrivKey, ephemeralPub);
 		const salt = new TextEncoder().encode(docId);
 		const keyBytes = hkdf(sha256, sharedSecret, salt, HKDF_INFO, 32);
-		const wrapKey = await crypto.subtle.importKey("raw", keyBytes, { name: "AES-GCM" }, false, ["decrypt"]);
-		const rawDocKey = await crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce }, wrapKey, ciphertext);
+		const wrapKey = await crypto.subtle.importKey("raw", keyBytes as BufferSource, { name: "AES-GCM" }, false, ["decrypt"]);
+		const rawDocKey = await crypto.subtle.decrypt({ name: "AES-GCM", iv: nonce as BufferSource }, wrapKey, ciphertext as BufferSource);
 		return crypto.subtle.importKey("raw", rawDocKey, { name: "AES-GCM" }, true, ["encrypt", "decrypt"]);
 	}