@rapidmx/web-client 0.35.0 → 0.36.0

package/lib/crypto/keySession.ts

@@ -22,6 +22,7 @@
  * module today.
  */
 import { type KeyVault, type PublicKey, type WrappedPrivateKey, findActivePublicKey, getKeyVault } from "./keyvaultApi.js";
+import type { ApiClient } from "../util/api.js";
 import { fromBase64 } from "./encoding.js";
 import { importPrivateKeyPkcs8 } from "./keys.js";
 import { KeysLockedError, buildAad, openWithKey } from "./masterKey.js";
@@ -34,6 +35,7 @@ import { RECOVERY_KDF_LABEL, deriveFromRecoveryCode } from "./recoveryCode.js";
 export const MASTER_KEY_AAD_PURPOSE = "master-key";
 export const SIGNING_PRIVATE_KEY_AAD_PURPOSE = "sign-private-key";
 export const ENCRYPTION_PRIVATE_KEY_AAD_PURPOSE = "encrypt-private-key";
+export const ZERO_ACCESS_PRIVATE_KEY_AAD_PURPOSE = "zero-access-private-key";
 
 export { KeysLockedError };
 
@@ -73,6 +75,17 @@ export interface UnlockedKeys {
      * that). A compromised key is kept because reading one's own mail encrypted to it is still needed. Absent when there
      * are none. */
     retainedEncryptionKeys?: RetainedEncryptionKey[];
+    /** The mailbox's zero-access private keys (restapi `specs/search.md` §3) - the keys the server encrypts mail at rest,
+     * index entries and sealed summaries to - the active one first, then retained ones newest first, at most
+     * `MAX_RETAINED_ENCRYPTION_KEYS + 1`. Decryption only. Absent when the mailbox has none (or none opened). */
+    zeroAccessKeys?: RetainedEncryptionKey[];
+    /** A shared mailbox opened through this user's member key wraps (`sharedMailboxKeys.ts`), not with its own master key: it holds
+     * only `zeroAccessKeys`, and `masterKey` is a per-key secret derived from its zero-access private key (what the local search
+     * index's key is derived from), never a key that opens the mailbox's vault. */
+    shared?: boolean;
+    /** A shared session only: the user's own mailboxes whose zero-access keys opened its member key wraps. Locking any of them locks it too -
+     * it was opened with their keys, so it doesn't outlive them. */
+    openedWith?: string[];
 }
 
 const sessions = new Map<string, UnlockedKeys>();
@@ -146,6 +159,52 @@ export function subscribeKeySession(listener: KeySessionListener): () => void {
     };
 }
 
+/**
+ * Makes a zero-access key this device has just enrolled (`zeroAccessKey.ts`'s `provisionZeroAccessKey()`) the active one
+ * of `unlocked` - the session object the key's private half was sealed under - so zero-access mail encrypted to it reads
+ * without another unlock. Does nothing when `unlocked` is no longer this mailbox's session (it was locked or replaced
+ * meanwhile; the next unlock opens the key from the vault anyway).
+ */
+export function addZeroAccessKey(mailboxUid: string, unlocked: UnlockedKeys, key: RetainedEncryptionKey): void {
+    if (unlocked.destroyed || sessions.get(mailboxUid) !== unlocked) {
+        return;
+    }
+    unlocked.zeroAccessKeys = [key, ...(unlocked.zeroAccessKeys ?? []).filter((k) => k.fingerprint !== key.fingerprint)];
+}
+
+/**
+ * Stores the keys of a shared mailbox opened through member key wraps (`sharedMailboxKeys.ts`'s `unlockSharedMailbox()`) as that mailbox's
+ * session, exactly as an unlock would - tracked for `destroyUnlockedKeys()`, and notified - unless the mailbox was locked since `generation`
+ * was taken (`sharedUnlockGeneration()`), when they are destroyed instead and `KeysLockedError` is thrown.
+ */
+export function installSharedSession(mailboxUid: string, unlocked: UnlockedKeys, generation: string): void {
+    if (lockGeneration(mailboxUid) !== generation) {
+        destroyObject(unlocked);
+        throw new KeysLockedError();
+    }
+    unlocked.shared = true;
+    sessions.set(mailboxUid, unlocked);
+    const objects = issued.get(mailboxUid) ?? new Set<WeakHandle<UnlockedKeys>>();
+    objects.add(weakHandle(unlocked));
+    issued.set(mailboxUid, objects);
+    notify({ mailboxUid, state: "unlocked" });
+}
+
+/** The lock generation to pass `installSharedSession()`, taken before a shared unlock starts its requests. */
+export function sharedUnlockGeneration(mailboxUid: string): string {
+    return lockGeneration(mailboxUid);
+}
+
+/** Every mailbox unlocked this session with its own keys (not a shared one opened through member key wraps). */
+export function personallyUnlockedKeys(): UnlockedKeys[] {
+    return personalSessions().map((session) => session.unlocked);
+}
+
+/** `personallyUnlockedKeys()` with each mailbox's uid. */
+export function personalSessions(): { mailboxUid: string; unlocked: UnlockedKeys }[] {
+    return [...sessions].filter(([, unlocked]) => !unlocked.shared).map(([mailboxUid, unlocked]) => ({ mailboxUid, unlocked }));
+}
+
 /** Reads back a mailbox's already-unlocked keys this session, or `undefined` if it hasn't been
  * unlocked yet (or was destroyed). Never triggers an unlock itself. */
 export function getUnlockedKeys(mailboxUid: string): UnlockedKeys | undefined {
@@ -189,6 +248,14 @@ export function destroyUnlockedKeys(mailboxUid?: string): void {
         sessions.delete(uid);
         notify({ mailboxUid: uid, state: "locked" });
     }
+    // The shared mailboxes opened with this mailbox's keys go with it.
+    if (mailboxUid) {
+        for (const [uid, unlocked] of [...sessions]) {
+            if (unlocked.shared && unlocked.openedWith?.includes(mailboxUid)) {
+                destroyUnlockedKeys(uid);
+            }
+        }
+    }
 }
 
 function destroyObject(unlocked: UnlockedKeys): void {
@@ -201,6 +268,10 @@ function destroyObject(unlocked: UnlockedKeys): void {
         unlocked.retainedEncryptionKeys.length = 0;
         delete unlocked.retainedEncryptionKeys;
     }
+    if (unlocked.zeroAccessKeys) {
+        unlocked.zeroAccessKeys.length = 0;
+        delete unlocked.zeroAccessKeys;
+    }
 }
 
 /** Finds the wrapped private key whose fingerprint matches a given published public key. */
@@ -297,6 +368,35 @@ async function openRetainedEncryptionKeys(
     }
 }
 
+/**
+ * Opens the mailbox's zero-access private keys into `unlocked.zeroAccessKeys`: the vault's `zeroAccessKeys` that have a
+ * wrapped private key, the unrevoked one with the latest `notBefore` first, then the rest newest first, at most
+ * `MAX_RETAINED_ENCRYPTION_KEYS + 1`. A key that won't open is listed in `unopenableKeys` and skipped - zero-access mail
+ * encrypted to it doesn't decrypt on this device, but nothing else about the unlock depends on it.
+ */
+async function openZeroAccessKeys(mailboxUid: string, vault: KeyVault, unlocked: UnlockedKeys, unopenableKeys: string[]): Promise<void> {
+    const ordered = [...(vault.zeroAccessKeys ?? [])].sort(
+        (a, b) => Number(!!a.revokedAt) - Number(!!b.revokedAt) || b.notBefore - a.notBefore,
+    );
+    const aad = buildAad(mailboxUid, ZERO_ACCESS_PRIVATE_KEY_AAD_PURPOSE);
+    let opened = 0;
+    for (const publicKey of ordered) {
+        const wrapped = findWrappedPrivateKey(vault, publicKey.fingerprint);
+        if (!wrapped || wrapped.useType !== "zero-access") {
+            continue;
+        }
+        try {
+            const privateKey = await openPrivateKey(unlocked.masterKey, wrapped, aad, { name: "ECDH", namedCurve: "P-256" }, ["deriveBits"], false);
+            (unlocked.zeroAccessKeys ??= []).push({ fingerprint: publicKey.fingerprint, certDer: fromBase64(publicKey.publicKey), privateKey });
+        } catch {
+            unopenableKeys.push(publicKey.fingerprint);
+        }
+        if (++opened === MAX_RETAINED_ENCRYPTION_KEYS + 1) {
+            break;
+        }
+    }
+}
+
 /**
  * Unlocks a mailbox's key vault with its password unlock method: fetches the vault, derives the
  * wrapping key from `password` using the *exact* KDF parameters that wrap was created with, unwraps
@@ -315,7 +415,21 @@ async function openRetainedEncryptionKeys(
  */
 export async function unlockWithPassword(mailboxUid: string, mailboxKeys: PublicKey[], password: string): Promise<UnlockResult> {
     const generation = lockGeneration(mailboxUid);
-    const vault = await getKeyVault(mailboxUid);
+    const { vault, masterKey } = await openMasterKeyWithPassword(mailboxUid, password);
+    return openSession(mailboxUid, mailboxKeys, vault, masterKey, generation);
+}
+
+/**
+ * Fetches `mailboxUid`'s vault and opens its master key with the password wrap, touching no session - for an operation that
+ * must re-prove the password even while the mailbox is unlocked (`keyExport.ts`). Rejects exactly as `unlockWithPassword()`
+ * does on a missing wrap, an unknown KDF or a wrong password. The caller owns the returned master key and must zero it.
+ */
+export async function openMasterKeyWithPassword(
+    mailboxUid: string,
+    password: string,
+    client?: ApiClient,
+): Promise<{ vault: KeyVault; masterKey: Uint8Array }> {
+    const vault = await getKeyVault(mailboxUid, client);
     const passwordWrap = vault.masterKeyWraps.find((w) => w.method === "password");
     if (!passwordWrap) {
         throw new Error("This mailbox has no password unlock method enrolled.");
@@ -332,8 +446,7 @@ export async function unlockWithPassword(mailboxUid: string, mailboxKeys: Public
         { ciphertext: passwordWrap.ciphertext, nonce: passwordWrap.nonce },
         buildAad(mailboxUid, MASTER_KEY_AAD_PURPOSE),
     );
-
-    return openSession(mailboxUid, mailboxKeys, vault, masterKey, generation);
+    return { vault, masterKey };
 }
 
 /** What `unlockWithRecoveryCode()` resolves with. */
@@ -453,6 +566,7 @@ async function openSession(
         }
 
         await openRetainedEncryptionKeys(mailboxUid, mailboxKeys, vault, unlocked, encryptionPublicKey?.fingerprint, unopenableKeys);
+        await openZeroAccessKeys(mailboxUid, vault, unlocked, unopenableKeys);
         if (lockGeneration(mailboxUid) !== generation) {
             // Locked (e.g. logout) while this unlock was awaiting - never restore keys after that.
             throw new KeysLockedError();

package/lib/crypto/keyvaultApi.ts

@@ -47,7 +47,18 @@ export interface WrappedPrivateKey {
     /** AEAD algorithm identifier (e.g. `AES-256-GCM`). */
     algorithm: string;
     fingerprint: string;
-    useType: "sign" | "encrypt";
+    useType: KeyUseType;
+}
+
+/** What a mailbox's own key is used for. `sign`/`encrypt` keys are published (`Mailbox.keys`); `zero-access` keys never are.
+ * Mirrors `@rapidmx/restapi`'s `KeyUseType`. */
+export type KeyUseType = "sign" | "encrypt" | "zero-access";
+
+/** A mailbox's zero-access key (restapi `specs/search.md` §3): the certificate the server encrypts mail at rest to on
+ * arrival. Same shape as `PublicKey`, but never published - only the vault's reader gets it (`KeyVault.zeroAccessKeys`).
+ * Mirrors `@rapidmx/restapi`'s `ZeroAccessKey`. */
+export interface ZeroAccessKey extends Omit<PublicKey, "useType" | "issuerCertificate"> {
+    useType: "zero-access";
 }
 
 /** One wrapped copy of the mailbox master key (MK), per unlock method. Mirrors `@rapidmx/restapi`'s
@@ -114,6 +125,9 @@ export interface KeyVault {
      * (`enrollKey()`, `startSignEnrollment()`, `addMasterKeyWrap()`, `rekey()`), so restapi refuses it with `409` if
      * another device rotated the master key meanwhile. Absent from servers that don't track it yet. */
     masterKeyGeneration?: number;
+    /** The mailbox's zero-access certificates, newest last - returned with the vault because they are never published and
+     * an unlock needs them to decrypt zero-access mail. Absent from servers without zero-access encryption. */
+    zeroAccessKeys?: ZeroAccessKey[];
 }
 
 /** The optional optimistic check restapi applies to vault writes carrying key material sealed under the master key. */
@@ -179,8 +193,8 @@ export function signingKeyFingerprints(keys: PublicKey[] | undefined, previousKe
 }
 
 export interface EnrollKeyInput extends ExpectedMasterKeyGeneration {
-    useType: "sign" | "encrypt";
-    /** PEM-encoded PKCS#10 CSR — required (and only meaningful) for `useType: "encrypt"`; the server
+    useType: KeyUseType;
+    /** PEM-encoded PKCS#10 CSR — required (and only meaningful) for `useType: "encrypt"` and `"zero-access"`; the server
      * calls its own internal CA against this CSR. */
     csr?: string;
     /** An already-issued PEM certificate — required (and only meaningful) for `useType: "sign"`. */
@@ -508,6 +522,110 @@ export function removeMasterKeyWrap(mailboxUid: string, method: string, methodId
     });
 }
 
+/** One member's copy of a shared mailbox's zero-access private key: base64 CMS of its PKCS#8, to the member's own zero-access certificate. */
+export interface MemberKeyWrap {
+    memberUserUid: string;
+    recipientFingerprint: string;
+    zeroAccessKeyFingerprint: string;
+    cms: string;
+    createdAt?: number;
+}
+
+/** One member in `SharedKeyStatus`. */
+export interface SharedKeyMember {
+    userUid: string;
+    full: boolean;
+    /** Their own zero-access certificate - absent until they first sign in and get one. */
+    certificate?: ZeroAccessKey;
+    /** The mailbox's zero-access keys they hold a wrap of. */
+    wrapped: string[];
+}
+
+/** Where a shared mailbox's zero-access key stands with its members - restapi `GET /mail/mailboxes/:id/keyvault/members`. */
+export interface SharedKeyStatus {
+    ownerless: boolean;
+    /** The caller: the mailbox's owner, one of its members, or neither (an administrator acting through a role). */
+    role?: "owner" | "member" | "other";
+    activeKeyFingerprint?: string;
+    zeroAccessKeys: ZeroAccessKey[];
+    members: SharedKeyMember[];
+    /** Members with a certificate but no wrap of the active key. */
+    pending: string[];
+    /** Users holding wraps who are no longer members. */
+    departed: string[];
+    /** A departed user holds the active key: a new key must be provisioned. */
+    rotationPending: boolean;
+    /** The caller may change the wraps. */
+    manager: boolean;
+    /** A mailbox without an owner assigned to an escrow scope: that scope. */
+    escrowScopeId?: string;
+    /** Its zero-access keys (fingerprints) with no escrow copy for `escrowScopeId` yet. Absent from servers that predate it. */
+    escrowPending?: string[];
+}
+
+/** An escrow copy of a mailbox-without-an-owner's zero-access private key, as `putZeroAccessEscrowWraps()` sends it: CMS of its PKCS#8 to
+ * the escrow scope's certificate (`getEscrowInfo()`). */
+export interface ZeroAccessEscrowWrapInput {
+    escrowScopeId: string;
+    zeroAccessKeyFingerprint: string;
+    /** Base64 DER CMS `EnvelopedData`. */
+    cms: string;
+}
+
+const vaultPath = (mailboxUid: string): string => `/mail/mailboxes/${encodeURIComponent(mailboxUid)}/keyvault`;
+
+export function getSharedKeyStatus(mailboxUid: string, client?: ApiClient): Promise<SharedKeyStatus> {
+    return withClient(client, `${vaultPath(mailboxUid)}/members`);
+}
+
+/** The caller's own member key wraps of `mailboxUid` (`[]` for its owner and for a member still waiting). */
+export function getMyMemberKeyWraps(mailboxUid: string, client?: ApiClient): Promise<MemberKeyWrap[]> {
+    return withClient(client, `${vaultPath(mailboxUid)}/member-wraps`);
+}
+
+export function putMemberKeyWraps(mailboxUid: string, wraps: MemberKeyWrap[], client?: ApiClient): Promise<SharedKeyStatus> {
+    return withClient(client, `${vaultPath(mailboxUid)}/member-wraps`, { method: "PUT", body: JSON.stringify({ wraps }) });
+}
+
+/** Removes every wrap of a user who is no longer a member - the last step of a rotation. */
+export function removeMemberKeyWraps(mailboxUid: string, memberUserUid: string, client?: ApiClient): Promise<SharedKeyStatus> {
+    return withClient(client, `${vaultPath(mailboxUid)}/member-wraps/${encodeURIComponent(memberUserUid)}`, { method: "DELETE" });
+}
+
+/** Provisions (or rotates) a mailbox-without-an-owner's zero-access key with its member wraps, in one write - and, for a mailbox assigned to
+ * an escrow scope, its escrow copy (required then). */
+export function enrollSharedZeroAccessKey(
+    mailboxUid: string,
+    input: {
+        csr: string;
+        wraps: Omit<MemberKeyWrap, "zeroAccessKeyFingerprint">[];
+        escrowWrap?: Omit<ZeroAccessEscrowWrapInput, "zeroAccessKeyFingerprint">;
+    },
+    client?: ApiClient,
+): Promise<SharedKeyStatus> {
+    return withClient(client, `${vaultPath(mailboxUid)}/shared-zero-access-key`, { method: "POST", body: JSON.stringify(input) });
+}
+
+/** Adds the escrow copies of a mailbox-without-an-owner's zero-access keys its escrow scope is missing (`SharedKeyStatus.escrowPending`). */
+export function putZeroAccessEscrowWraps(mailboxUid: string, wraps: ZeroAccessEscrowWrapInput[], client?: ApiClient): Promise<SharedKeyStatus> {
+    return withClient(client, `${vaultPath(mailboxUid)}/escrow-wraps`, { method: "PUT", body: JSON.stringify({ wraps }) });
+}
+
+/** One key a "Export keys for Outlook/phone" file held, as `recordKeyExport()` reports it. */
+export interface ExportedKeyRecord {
+    kind: "zero-access" | "encrypt" | "sign";
+    fingerprint: string;
+}
+
+/** Records with restapi that the owner exported these private keys (`key_vault.export` in the audit log). `keyExport.ts`
+ * calls it before handing over the file, so an export the server refuses to record isn't handed over. Owner-only. */
+export async function recordKeyExport(mailboxUid: string, keys: ExportedKeyRecord[], client?: ApiClient): Promise<void> {
+    await withClient(client, `/mail/mailboxes/${encodeURIComponent(mailboxUid)}/keyvault/exports`, {
+        method: "POST",
+        body: JSON.stringify({ keys }),
+    });
+}
+
 export interface RekeyInput extends ExpectedMasterKeyGeneration {
     wrappedKeys: WrappedPrivateKey[];
     /** Every wrap of the new master key. For a mailbox assigned an escrow scope, this must include a fresh escrow wrap
@@ -657,6 +775,10 @@ export interface EncryptionPolicy {
     encryptSameOrg: PolicyState;
     encryptFederated: PolicyState;
     encryptExternal: PolicyState;
+    /** "Allow zero-access encryption": whether mailboxes may store mail encrypted at rest. Always present from a server that
+     * supports zero-access encryption (its stored value or the server default); absent from one that doesn't, which a
+     * caller treats as not allowed. */
+    allowZeroAccess?: boolean;
 }
 
 /** The system-wide encryption policy (readable by any authenticated user, used to decide what encryption

package/lib/crypto/messageSecurity.ts

@@ -37,9 +37,23 @@
  * `untrusted_signer`. Previously pinned keys count as pins (see `signingKeyFingerprints()`), so mail signed before an
  * accepted or automatic rotation still verifies.
  */
-import { DisplayBody, MimeAttachment, MimeHeaderField, decodeHeaderText, extractAddresses, parseMimeEntity, parseParameterizedHeader, plainTextToHtml } from "./mime.js";
-import { toBase64 } from "./encoding.js";
-import { computeCertFingerprint, extractCertificateEmails } from "./smime.js";
+import {
+    DisplayBody,
+    MimeAttachment,
+    MimeHeaderField,
+    bytesToBinaryString,
+    decodeBase64Text,
+    decodeHeaderText,
+    extractAddresses,
+    extractAttachments,
+    extractCalendarText,
+    extractDisplayBody,
+    parseMimeEntity,
+    parseParameterizedHeader,
+    plainTextToHtml,
+} from "./mime.js";
+import { fromBase64, toBase64 } from "./encoding.js";
+import { type DecryptionKey, computeCertFingerprint, decryptEnvelopedDataWithKeys, extractCertificateEmails } from "./smime.js";
 import { ComparableOuterHeaders, ProtectedHeaders, parseEncryptedMessageWithKeys, parseSignedOnlyMessage } from "./smimeMessage.js";
 import { type PublicKey, isTrustedForVerification } from "./keyvaultApi.js";
 import { KeysLockedError } from "./masterKey.js";
@@ -67,6 +81,7 @@ export type MessageSecurityState =
     | "encrypted_unverified_signer"
     | "signature_failed"
     | "verified_at_first_open"
+    | "protected_at_rest"
     | "unprotected";
 
 /** Why a message is `"signature_failed"`. `invalid_signature`: the CMS signature itself is malformed or
@@ -113,6 +128,13 @@ export interface MessageSecurityResult {
      * since-rotated key, non-AEAD content encryption, or corrupt/foreign data) - the caller should keep
      * showing whatever `GET /:id/content` already produced alongside this explanation. */
     decryptError?: string;
+    /** Set when the stored message was sealed at rest by the server (restapi `specs/search.md` §3) and opened here with the mailbox's
+     * zero-access key. `state` then describes the original message inside: `protected_at_rest` when it arrived unprotected, or its own
+     * signed/encrypted state otherwise. */
+    zeroAccess?: boolean;
+    /** With `zeroAccess`: the original's calendar file (`extractCalendarText()`), which the server can't read from the sealed copy - the
+     * client sends it with the invitation endpoints. Absent when the message carries none. */
+    calendar?: string;
     /** See `ParsedEncryptedMessage.headerTamperDetected`'s own doc comment - a deliberately separate,
      * orthogonal signal from `state`, since RFC 9788's `HP-Outer` is written on every encrypted message
      * regardless of whether it's also signed. `undefined` for anything that isn't an encrypted message
@@ -347,6 +369,61 @@ export interface MessageSecurityKeys {
     encryptionCertDer?: Uint8Array;
     retainedEncryptionKeys?: { certDer: Uint8Array; privateKey: CryptoKey }[];
     signingFingerprint?: string;
+    /** The mailbox's zero-access keys (`keySession.ts`'s `UnlockedKeys.zeroAccessKeys`) - what opens a message the server sealed at
+     * rest on arrival. */
+    zeroAccessKeys?: { certDer: Uint8Array; privateKey: CryptoKey }[];
+}
+
+/**
+ * The subject and preview of a zero-access message (`Message.zeroAccess.sealedSummary`, base64 CMS of JSON `{ subject, preview }`),
+ * decrypted with the mailbox's zero-access keys - a few hundred bytes, so a message list shows real subjects without downloading
+ * each message. `undefined` when no key opens it or it isn't a summary.
+ */
+export async function openZeroAccessSummary(
+    sealedSummary: string,
+    keys: DecryptionKey[] | undefined,
+): Promise<{ subject: string; preview: string } | undefined> {
+    if (!keys?.length) {
+        return undefined;
+    }
+    try {
+        const json: unknown = JSON.parse(new TextDecoder().decode(await decryptEnvelopedDataWithKeys(fromBase64(sealedSummary), keys)));
+        const { subject, preview } = (json ?? {}) as Record<string, unknown>;
+        return typeof subject === "string" && typeof preview === "string" ? { subject, preview } : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+/**
+ * The original MIME (as a binary string) of a stored message the server sealed at rest, opened with `unlocked.zeroAccessKeys` -
+ * `undefined` when it isn't a sealed message or no key opens it. For what needs the original itself, e.g. reporting it to the spam
+ * filter (`reportMessage()`'s `rawMessage`).
+ */
+export async function openZeroAccessMessage(rawMime: string, unlocked: MessageSecurityKeys | undefined): Promise<string | undefined> {
+    const { headers, body } = parseMimeEntity(rawMime);
+    const rawContentType = headers["content-type"];
+    if (!unlocked?.zeroAccessKeys?.length || !rawContentType || !isEncryptedContentType(parseParameterizedHeader(rawContentType))) {
+        return undefined;
+    }
+    return openZeroAccess(body, unlocked.zeroAccessKeys);
+}
+
+/**
+ * The original MIME of a message the server sealed at rest (restapi `specs/search.md` §3) - the stored S/MIME `enveloped-data`
+ * message's content, decrypted with one of `keys` - or `undefined` when none of them opens it. Only the server ever encrypts to a
+ * zero-access key (it is never published), so a message that opens with one was sealed at rest, never sent end-to-end.
+ */
+async function openZeroAccess(body: string, keys: DecryptionKey[]): Promise<string | undefined> {
+    const der = decodeBase64Text(body);
+    if (!der) {
+        return undefined;
+    }
+    try {
+        return bytesToBinaryString(await decryptEnvelopedDataWithKeys(der, keys));
+    } catch {
+        return undefined;
+    }
 }
 
 /** `evaluateMessageSecurity()`'s result plus what the seal-aware wrapper needs: which kind of protected message it was,
@@ -362,6 +439,7 @@ async function evaluateLive(
     unlocked: MessageSecurityKeys | undefined,
     pinnedSignerFingerprints: string | string[] | undefined,
     readerAddress: string | undefined,
+    sealedAtRest = false,
 ): Promise<LiveEvaluation> {
     const { headers, body, fields } = parseMimeEntity(rawMime);
     const rawContentType = headers["content-type"];
@@ -452,6 +530,35 @@ async function evaluateLive(
         };
     }
 
+    // A message the server sealed at rest: evaluate the original it holds - which may itself be signed or end-to-end encrypted -
+    // and report one that was unprotected when it arrived as `protected_at_rest`, with its content.
+    if (isEncryptedContentType(contentType) && !sealedAtRest && unlocked?.zeroAccessKeys?.length) {
+        const original = await openZeroAccess(body, unlocked.zeroAccessKeys);
+        if (original !== undefined) {
+            const inner = await evaluateLive(original, unlocked, pinnedSignerFingerprints, readerAddress, true);
+            const entity = parseMimeEntity(original);
+            const subject = entity.headers["subject"];
+            const calendarText = extractCalendarText(entity);
+            const calendar = calendarText !== undefined ? { calendar: calendarText } : {};
+            if (inner.result.state !== "unprotected") {
+                // The stored message's own Subject is the placeholder: the original's stands in when the inner result has none.
+                const fallbackSubject = inner.result.subject === undefined && subject !== undefined ? { subject: decodeHeaderText(subject) } : {};
+                return { ...inner, result: { ...inner.result, ...fallbackSubject, ...calendar, zeroAccess: true } };
+            }
+            return {
+                result: {
+                    state: "protected_at_rest",
+                    zeroAccess: true,
+                    ...calendar,
+                    ...renderDisplayBody(extractDisplayBody(entity)),
+                    ...(subject !== undefined ? { subject: decodeHeaderText(subject) } : {}),
+                    attachments: extractAttachments(entity),
+                },
+                kind: "other",
+            };
+        }
+    }
+
     if (isEncryptedContentType(contentType)) {
         // The active key first, then the retained older ones (see `keySession.ts`'s `retainedEncryptionKeys`), so mail
         // encrypted to a key since replaced still opens. Only ever used to decrypt here - never to encrypt or sign.

package/lib/crypto/mime.ts

@@ -541,6 +541,32 @@ export function extractAttachments(entity: MimeEntity, depth = 0): MimeAttachmen
     ];
 }
 
+/**
+ * The text of the first calendar file in `entity` (descending into multipart children, bounded depth): a `text/calendar` or
+ * `application/ics` leaf, whether a body alternative (as Outlook sends an invitation) or an attached `.ics`. `undefined` when there is none.
+ */
+export function extractCalendarText(entity: MimeEntity, depth = 0): string | undefined {
+    const contentType = parseParameterizedHeader(entity.headers["content-type"] ?? "text/plain");
+    if (contentType.value.startsWith("multipart/")) {
+        const boundary = contentType.params["boundary"];
+        if (!boundary || depth >= MAX_MULTIPART_DEPTH) {
+            return undefined;
+        }
+        for (const part of splitMultipart(entity.body, boundary)) {
+            const found = extractCalendarText(parseMimeEntity(part), depth + 1);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+        return undefined;
+    }
+    if (contentType.value !== "text/calendar" && contentType.value !== "application/ics") {
+        return undefined;
+    }
+    const bytes = decodeBodyBytes(entity);
+    return bytes ? new TextDecoder().decode(bytes) : undefined;
+}
+
 /** HTML-escapes plain text and wraps it in a whitespace-preserving `<pre>`, so a `text/plain` body can be
  * rendered through the same HTML path without ever being interpreted as markup. */
 export function plainTextToHtml(text: string): string {