@rapidmx/web-client 0.36.0 → 0.37.0

package/apps/shared/components/layout/SharedMailboxKeyManager.tsx

@@ -7,6 +7,7 @@ import { getUnlockedKeys, personallyUnlockedKeys, subscribeKeySession } from "..
 import type { Mailbox } from "../../../../lib/mail/mailApi.js";
 import type { ApiClient } from "../../../../lib/util/api.js";
 import { useApiClient } from "../../../../lib/util/apiClientContext.js";
+import { notify } from "../../notifications/store.js";
 
 /** How often the shared mailboxes are looked after again while some own mailbox stays unlocked. */
 export const SHARED_MAILBOX_CHECK_INTERVAL_MS = 5 * 60 * 1000;
@@ -19,6 +20,14 @@ const loadSharedKeys = () =>
         throw err;
     }));
 
+/** The refused rotations already shown, per mailbox (the reason): each is shown once a session, not on every pass that retries it. */
+const shownRefusals = new Map<string, string>();
+
+/** Forgets which refused rotations were shown (tests). */
+export function resetSharedMailboxKeyManager(): void {
+    shownRefusals.clear();
+}
+
 export interface SharedMailboxKeyManagerProps {
     /** Every mailbox the user can open. */
     mailboxes: Mailbox[];
@@ -29,7 +38,7 @@ export interface SharedMailboxKeyManagerProps {
  * Looks after the zero-access keys of the user's shared mailboxes (`lib/crypto/sharedMailboxKeys.ts`) whenever a mailbox of their own is
  * unlocked, and every `SHARED_MAILBOX_CHECK_INTERVAL_MS` after that: opens each mailbox shared with them through their member key wraps (no
  * password), and - for a mailbox they own or manage - provisions, rotates and shares its key with members still waiting. Best effort and
- * silent: a pass that fails is tried again on the next. Renders nothing; mounted by `MailShell`.
+ * silent (a pass that fails is tried again on the next), except for a rotation the server refuses, shown once as a warning. Renders nothing; mounted by `MailShell`.
  */
 export default function SharedMailboxKeyManager({ mailboxes, userUid }: SharedMailboxKeyManagerProps) {
     const client = useApiClient();
@@ -75,17 +84,39 @@ async function look(
     mailbox: Mailbox,
     me: string | undefined,
     client: ApiClient | undefined,
-    unlockSharedMailbox: (uid: string, client?: ApiClient) => Promise<string>,
-    maintainSharedMailbox: (uid: string, address: string, client?: ApiClient) => Promise<unknown>,
+    unlockSharedMailbox: (uid: string, client?: ApiClient, refresh?: boolean) => Promise<string>,
+    maintainSharedMailbox: (
+        uid: string,
+        address: string,
+        client?: ApiClient,
+    ) => Promise<{ provisioned: boolean; rotated: boolean; rotationRefused?: string }>,
 ): Promise<void> {
     const owned = !!mailbox.ownerUserUid && mailbox.ownerUserUid === me;
-    if (!owned && !getUnlockedKeys(mailbox.uid)) {
-        await unlockSharedMailbox(mailbox.uid, client);
+    if (!owned) {
+        // Opened, or - once open - opened again when a rotation left it without the active key.
+        await unlockSharedMailbox(mailbox.uid, client, true);
     }
     const unlocked = getUnlockedKeys(mailbox.uid);
     // An owner looks after their mailbox with its own keys; a member, with full access, whether or not it is open yet (a mailbox
     // without an owner may have no key to open).
     if (owned ? unlocked && !unlocked.shared : true) {
-        await maintainSharedMailbox(mailbox.uid, mailbox.primarySmtpAddress, client);
+        const done = await maintainSharedMailbox(mailbox.uid, mailbox.primarySmtpAddress, client);
+        // The server kept the current key (its vault can't take the new key's member wraps): say so once, members keep reading.
+        if (done.rotationRefused && shownRefusals.get(mailbox.uid) !== done.rotationRefused) {
+            shownRefusals.set(mailbox.uid, done.rotationRefused);
+            notify({
+                kind: "warning",
+                title: `${mailbox.displayName || mailbox.primarySmtpAddress}: the zero-access key wasn't replaced`,
+                message: "A member has left, but the server refused a new key for this shared mailbox. The current key stays active.",
+                details: done.rotationRefused,
+                dedupeKey: `shared-rotation-refused:${mailbox.uid}`,
+            });
+        } else if (!done.rotationRefused) {
+            shownRefusals.delete(mailbox.uid);
+        }
+        // A key this member just made (a mailbox without an owner) goes into their session now, not on the next pass.
+        if (!owned && (done.provisioned || done.rotated)) {
+            await unlockSharedMailbox(mailbox.uid, client, true);
+        }
     }
 }

package/apps/shared/components/mail/InviteCard.tsx

@@ -15,6 +15,7 @@ import {
     respondToMessageInvite,
 } from "../../../../lib/calendar/inviteApi.js";
 import { guestPermissionsOf } from "../../../../lib/calendar/calendarApi.js";
+import { openSealedEvent } from "../../calendar/sealedEvents.js";
 import { formatMailAddress } from "../../../../lib/mail/mailAddress.js";
 import { useApiClient } from "../../../../lib/util/apiClientContext.js";
 import Button from "../../../../lib/components/buttons/Button.js";
@@ -334,7 +335,7 @@ export default function InviteCard({ messageUid, headingLevel = 2 }: InviteCardP
                             aria-busy={pending === "acceptProposal" || undefined}
                             loading={pending === "acceptProposal"}
                             disabled={busy}
-                            onClick={() => void run("acceptProposal", "Couldn't accept the proposed time", () => acceptProposal(messageUid, client))}
+                            onClick={() => void run("acceptProposal", "Couldn't accept the proposed time", () => acceptProposal(messageUid, client, invite.calendarEventUid, openSealedEvent))}
                         >
                             Accept proposal
                         </Button>
@@ -387,6 +388,15 @@ export default function InviteCard({ messageUid, headingLevel = 2 }: InviteCardP
                             description: invite.description,
                             descriptionHtml: invite.descriptionHtml,
                             guestAddresses: invite.attendees.map((attendee) => attendee.address),
+                            // The invitation's own content: what a protected copy of the event is named by.
+                            invitationContent: invite.summary
+                                ? {
+                                      title: invite.summary,
+                                      location: invite.location ?? undefined,
+                                      description: invite.description ?? undefined,
+                                      descriptionHtml: invite.descriptionHtml ?? undefined,
+                                  }
+                                : undefined,
                         }}
                         canChange={!!invite.canRequestChange}
                         canInvite={!!invite.canRequestInvite}

package/apps/shared/components/mail/MessageDetailPane.tsx

@@ -50,11 +50,11 @@ import { isCalendarAttachment } from "./invite/inviteFormat.js";
 import { useMessageInvite } from "./invite/inviteStore.js";
 import { rememberSealedInvite } from "../../../../lib/calendar/sealedInvites.js";
 import { getUnlockedKeys, subscribeKeySession } from "../../../../lib/crypto/keySession.js";
-import type { MessageSecurityResult, SignatureFailureReason } from "../../../../lib/crypto/messageSecurity.js";
+import type { MessageSecurityResult, SignatureFailureReason, SignerPinsInput } from "../../../../lib/crypto/messageSecurity.js";
 import { extractAddresses, type MimeAttachment } from "../../../../lib/crypto/mime.js";
 import { SignerKeyConflictError, signingKeyFingerprints, trustSigner } from "../../../../lib/crypto/keyvaultApi.js";
 import { isLikelyMailingList } from "../../../../lib/crypto/composeSecurity.js";
-import { SenderKeyState, clearPinnedSignerCache, getPinnedSignerFingerprints, getSignerKeyState } from "./pinnedSigners.js";
+import { SenderKeyState, clearPinnedSignerCache, getPinnedSigners, getSignerKeyState } from "./pinnedSigners.js";
 import { currentVerificationSeal, getVaultGeneration, sendVerificationSeal } from "./verificationSeals.js";
 import { getMyMailboxAccess } from "../../../../lib/mail/mailboxAccessApi.js";
 import { useApiClient } from "../../../../lib/util/apiClientContext.js";
@@ -612,9 +612,9 @@ function MessageDetailContent({
         // mailbox's own signing keys when it sent the message itself. A failed lookup means no pins, which can only
         // ever make a signature "signer not verified", never verified.
         const senderAddress = message.from.address;
-        const pinsPromise = getPinnedSignerFingerprints(message.mailboxUid, senderAddress, client).then(
-            (fingerprints) => ({ loaded: true, fingerprints }),
-            () => ({ loaded: false, fingerprints: [] as string[] }),
+        const pinsPromise = getPinnedSigners(message.mailboxUid, senderAddress, client).then(
+            (signers) => ({ loaded: true, ...signers }),
+            () => ({ loaded: false, fingerprints: [] as string[], openPgpKeys: [] as string[] }),
         );
         // Verification seals (see `verificationSeals.ts`) need unlocked keys and the vault's current master key
         // generation; without either the message is evaluated exactly as before, with no seal. The sender's key records
@@ -640,7 +640,9 @@ function MessageDetailContent({
                 const ownPins = signingKeyFingerprints(ownKeys);
                 const [contactPins, sealContext] = await Promise.all([pinsPromise, sealContextPromise]);
                 const pins = [...new Set([...contactPins.fingerprints, ...ownPins])];
-                const pinned = pins.length > 0 ? pins : undefined;
+                // An OpenPGP signature is checked against the sender's pinned OpenPGP certificates themselves (it names only a key ID).
+                const pinned: SignerPinsInput =
+                    contactPins.openPgpKeys.length > 0 ? { fingerprints: pins, openPgpKeys: contactPins.openPgpKeys } : pins.length > 0 ? pins : undefined;
                 // The raw content is a byte string - only ever handed to evaluateMessageSecurity(), never shown. Keys
                 // are read after the pin lookup's await, so a lock that happened meanwhile is honored.
                 const unlocked = getUnlockedKeys(message.mailboxUid);
@@ -677,7 +679,7 @@ function MessageDetailContent({
                     const viaAlias = await messageSecurity.evaluateMessageSecurity(rawMime, unlocked, pinned, alias);
                     result = { ...result, notAddressedToReader: viaAlias.notAddressedToReader };
                 }
-                const unpinned = contactPins.loaded && pins.length === 0;
+                const unpinned = contactPins.loaded && pins.length === 0 && contactPins.openPgpKeys.length === 0;
                 const keyChanged = signerKeyChanged(result);
                 const [keyState, access] = await Promise.all([
                     keyChanged || (unpinned && UNVERIFIED_SIGNER_STATES.has(result.state)) ? loadKeyState() : undefined,
@@ -783,11 +785,11 @@ function MessageDetailContent({
     // Only ever invoked from the "Trust this signer" dialog, which only opens for an unverified-signer result carrying
     // `signerCertificate`. The pin goes on the contact in the mailbox the message belongs to; the evaluation is then
     // re-run against a fresh pinned-signer lookup, so the badge turns verified.
-    async function handleTrustSigner(address: string, certificate: string) {
+    async function handleTrustSigner(address: string, certificate: string, type?: "openpgp") {
         setTrusting(true);
         setTrustError(null);
         try {
-            await trustSigner(message.mailboxUid, { address, certificate }, client);
+            await trustSigner(message.mailboxUid, { address, certificate, ...(type ? { type } : {}) }, client);
             clearPinnedSignerCache();
             setTrustConfirmOpen(false);
             setUnlockRefresh((n) => n + 1);
@@ -1112,7 +1114,10 @@ function MessageDetailContent({
             ? security.signerCertificate
             : undefined;
     const keyChanged = security && signerKeyChanged(security) ? security : undefined;
-    const pinnedSignerKey = senderKeyState?.pinned[0];
+    // An OpenPGP signer's key is pinned as the contact's OpenPGP certificate, not a signing certificate.
+    const openPgpSigner = keyChanged?.signerKeyType === "openpgp";
+    const pinnedSignerKey = openPgpSigner ? senderKeyState?.openPgp?.[0] : senderKeyState?.pinned[0];
+    const pinnedSignerSince = openPgpSigner ? senderKeyState?.openPgpPinnedSince : senderKeyState?.pinnedSince;
     const recordedConflict =
         keyChanged && sameFingerprint(senderKeyState?.conflict?.observedKey.fingerprint, keyChanged.signerFingerprint)
             ? senderKeyState!.conflict
@@ -1148,7 +1153,7 @@ function MessageDetailContent({
     // Registered while rendering, not in an effect: the invitation lookup below must find it the moment it is enabled. Writing the same
     // file for the same message again is a no-op.
     if (sealedCalendar !== undefined) {
-        rememberSealedInvite(message.uid, sealedCalendar);
+        rememberSealedInvite(message.uid, sealedCalendar, message.mailboxUid);
     }
     const mayHoldInvite =
         !message.encrypted &&
@@ -1349,6 +1354,11 @@ function MessageDetailContent({
                         )}
                         {security && <SecurityIndicator security={security} zeroAccess={!!message.zeroAccess} />}
                     </div>
+                    {security?.signerKeyUnknown && (
+                        <p role="status" className="mt-2 text-sm text-text-muted">
+                            Signed with an OpenPGP key RapidMX doesn&rsquo;t have for this sender yet, so the signature couldn&rsquo;t be checked.
+                        </p>
+                    )}
                     {senderNameCheck.misleading && (
                         <p role="status" className="mt-2 py-2 px-3 rounded-sm text-sm bg-warning/15 text-text">
                             The sender&rsquo;s name &ldquo;{senderName}&rdquo; looks like an email address, but this message was
@@ -1577,9 +1587,10 @@ function MessageDetailContent({
                         <KeyChangeReview
                             mailboxUid={message.mailboxUid}
                             address={senderAddress}
-                            useType="sign"
+                            useType={openPgpSigner ? "encrypt" : "sign"}
+                            {...(openPgpSigner ? { keyType: "openpgp" as const } : {})}
                             ownerName="the sender"
-                            current={pinnedSignerKey && { fingerprint: pinnedSignerKey.fingerprint, since: senderKeyState.pinnedSince! }}
+                            current={pinnedSignerKey && { fingerprint: pinnedSignerKey.fingerprint, since: pinnedSignerSince! }}
                             proposed={{
                                 fingerprint: keyChanged.signerFingerprint!,
                                 emails: keyChanged.signerEmails,
@@ -1879,7 +1890,7 @@ function MessageDetailContent({
                             className="!w-auto"
                             loading={trusting}
                             disabled={trusting}
-                            onClick={() => handleTrustSigner(senderAddress, trustableCertificate!)}
+                            onClick={() => handleTrustSigner(senderAddress, trustableCertificate!, security?.signerKeyType)}
                         >
                             Trust
                         </Button>

package/apps/shared/components/mail/compose/ComposeWindow.tsx

@@ -48,7 +48,7 @@ import { notify } from "../../../notifications/store.js";
 import { isFileDrag, isInlineImage } from "./dropFiles.js";
 import { evaluateEncryptionRequirement } from "./encryptionRequirement.js";
 import { decideSend, SendBlock } from "../../../mail/outbox/sendDecision.js";
-import { SendRequest, sendDecisionInput, startSend } from "../../../mail/outbox/sendJob.js";
+import { SendRequest, sendDecisionInput, senderCanUseOpenPgp, startSend } from "../../../mail/outbox/sendJob.js";
 import { useCompose, type ComposeSession } from "./ComposeContext.js";
 import { ariaKeyShortcuts, withHint } from "../../../keyboard/format.js";
 import { SHORTCUTS, ShortcutDef } from "../../../keyboard/keymap.js";
@@ -492,7 +492,14 @@ export default function ComposeWindow({
                         return;
                     }
                     lookupFailuresRef.current.delete(key);
-                    const status = resolveRecipientEncryption(mailbox.primarySmtpAddress, ownPrefersMutual, encryptionPolicy, recipient.address, result.lookup);
+                    const status = resolveRecipientEncryption(
+                        mailbox.primarySmtpAddress,
+                        ownPrefersMutual,
+                        encryptionPolicy,
+                        recipient.address,
+                        result.lookup,
+                        senderCanUseOpenPgp(getUnlockedKeys(mailbox.uid)),
+                    );
                     setRecipientStatuses((prev) => ({ ...prev, [key]: status }));
                 });
         }

package/apps/shared/components/mail/compose/RecipientInput.tsx

@@ -5,6 +5,7 @@
 import React, { ChangeEvent, KeyboardEvent, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { createPortal } from "react-dom";
 import { HiOutlineXMark } from "react-icons/hi2";
+import { fetchSuggestionsWithProtectedContacts } from "./protectedContactSuggestions.js";
 import {
     fetchRecipientSuggestions,
     RECIPIENT_SUGGESTION_MIN_QUERY_LENGTH,
@@ -111,7 +112,7 @@ export default function RecipientInput({
     onBlur,
     onCommit,
     mailboxUid,
-    fetchSuggestions = fetchRecipientSuggestions,
+    fetchSuggestions = fetchSuggestionsWithProtectedContacts,
     debounceMs = RECIPIENT_SUGGESTION_DEBOUNCE_MS,
     disabled,
     autoFocus,

package/apps/shared/components/mail/compose/protectedContactSuggestions.ts

@@ -0,0 +1,121 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Recipient suggestions that include contacts zero-access encryption protects. Their names are sealed (restapi `specs/search.md` §3 *What
+ * It Covers*), so the server's contact search finds them only by address; this matches their opened names on the device and puts them
+ * first. Names are opened only - never the rest of a contact - and kept for ten minutes, and only while the mailbox is unlocked: its lock
+ * (and signing out) forgets them, as does a search that finds it locked. Reading them never holds up the server's suggestions: what isn't read by the time those arrive (plus
+ * `PROTECTED_NAMES_WAIT_MS`) is left to the next keystroke.
+ */
+import { type Contact, listContacts, PINNED_FINGERPRINT_PAGE_SIZE } from "../../../../../lib/contacts/contactsApi.js";
+import { getUnlockedKeys, subscribeKeySession } from "../../../../../lib/crypto/keySession.js";
+import {
+    type ContactSuggestionOptions,
+    fetchRecipientSuggestions,
+    mergeRecipientSuggestions,
+    RECIPIENT_SUGGESTION_DEFAULT_LIMIT,
+    type RecipientSuggestion,
+} from "../../../../../lib/mail/directoryApi.js";
+import { listFolders } from "../../../../../lib/mail/mailApi.js";
+import type { ApiClient } from "../../../../../lib/util/api.js";
+import { isProtectedRecord, openSealedRecords } from "../../../../../lib/zeroAccess/sealedRecords.js";
+import { onSigningOut } from "./composeFlushRegistry.js";
+
+/** How long a mailbox's protected contact names are kept: reading them is a crawl of the whole address book. */
+export const PROTECTED_NAMES_TTL_MS = 10 * 60_000;
+
+/** How long suggestions wait, once the server's have arrived, for the protected contacts still being read. */
+export const PROTECTED_NAMES_WAIT_MS = 250;
+
+/** At most this many contacts are read per contacts folder. */
+const MAX_PAGES = 20;
+
+const cache = new Map<string, { loadedAt: number; contacts: Promise<Contact[]> }>();
+
+/** Forgets every mailbox's names (signing out, or the test seam). */
+export function clearProtectedContactNames(): void {
+    cache.clear();
+}
+
+onSigningOut(clearProtectedContactNames);
+
+let watchingKeys = false;
+
+/** A mailbox's names go the moment it locks, so nothing opened outlives its key session. Subscribed with the first crawl, not on import. */
+function forgetOnLock(): void {
+    if (watchingKeys) {
+        return;
+    }
+    watchingKeys = true;
+    subscribeKeySession(({ mailboxUid, state }) => {
+        if (state === "locked") {
+            cache.delete(mailboxUid);
+        }
+    });
+}
+
+/** `mailboxUid`'s protected contacts with their names opened. */
+async function loadProtectedContacts(mailboxUid: string, client: ApiClient | undefined): Promise<Contact[]> {
+    const found: Contact[] = [];
+    // The folders side by side, each one's pages in turn.
+    await Promise.all(
+        (await listFolders(mailboxUid, client))
+            .filter((f) => f.type === "contacts")
+            .map(async (folder) => {
+                for (let page = 0; page < MAX_PAGES; page++) {
+                    const batch = await listContacts(folder.uid, { limit: PINNED_FINGERPRINT_PAGE_SIZE, page }, client);
+                    found.push(...batch.filter((contact) => isProtectedRecord(contact)));
+                    if (batch.length < PINNED_FINGERPRINT_PAGE_SIZE) {
+                        break;
+                    }
+                }
+            }),
+    );
+    return openSealedRecords(found, ["displayName"]);
+}
+
+function protectedContacts(mailboxUid: string, client: ApiClient | undefined): Promise<Contact[]> {
+    let entry = cache.get(mailboxUid);
+    if (!entry || Date.now() - entry.loadedAt > PROTECTED_NAMES_TTL_MS) {
+        forgetOnLock();
+        const created = { loadedAt: Date.now(), contacts: loadProtectedContacts(mailboxUid, client) };
+        created.contacts.catch(() => cache.delete(mailboxUid));
+        cache.set(mailboxUid, created);
+        entry = created;
+    }
+    return entry.contacts;
+}
+
+/** Every address of the protected contacts of `mailboxUid` whose opened name contains `query` (case-insensitively). */
+export async function searchProtectedContactNames(mailboxUid: string, query: string, client?: ApiClient): Promise<RecipientSuggestion[]> {
+    const wanted = query.trim().toLowerCase();
+    if (wanted.length < 2) {
+        return [];
+    }
+    if (!getUnlockedKeys(mailboxUid)?.zeroAccessKeys?.length) {
+        // Locked: nothing opened is kept, and nothing could be opened now.
+        cache.delete(mailboxUid);
+        return [];
+    }
+    return (await protectedContacts(mailboxUid, client))
+        .filter((contact) => contact.displayName.toLowerCase().includes(wanted))
+        .flatMap((contact) => contact.emails.map((email) => ({ displayName: contact.displayName, address: email.address, kind: "contact" as const })));
+}
+
+/** `fetchRecipientSuggestions()` with the composing mailbox's protected contacts matched by name on the device, first - those read by the
+ * time the server's suggestions are in (plus `PROTECTED_NAMES_WAIT_MS`): a first search of a large address book shows the server's alone
+ * rather than waiting for the crawl, which goes on for the next keystroke. A failure to read them only leaves them out. */
+export async function fetchSuggestionsWithProtectedContacts(
+    query: string,
+    options: ContactSuggestionOptions = {},
+    client?: ApiClient,
+): Promise<RecipientSuggestion[]> {
+    const local: Promise<RecipientSuggestion[]> = options.mailboxUid ? searchProtectedContactNames(options.mailboxUid, query, client).catch(() => []) : Promise.resolve([]);
+    const server = await fetchRecipientSuggestions(query, options, client);
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const ready = await Promise.race([local, new Promise<RecipientSuggestion[]>((resolve) => (timer = setTimeout(() => resolve([]), PROTECTED_NAMES_WAIT_MS)))]);
+    clearTimeout(timer);
+    return mergeRecipientSuggestions(ready, server, options.limit ?? RECIPIENT_SUGGESTION_DEFAULT_LIMIT);
+}

package/apps/shared/components/mail/invite/inviteStore.ts

@@ -4,7 +4,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 import { useCallback, useEffect, useReducer } from "react";
 import { MessageInvite, getMessageInvite } from "../../../../../lib/calendar/inviteApi.js";
-import { clearSealedInvites, sealedInviteCalendar } from "../../../../../lib/calendar/sealedInvites.js";
+import { clearSealedInvites, onSealedInvitesForgotten, sealedInviteCalendar } from "../../../../../lib/calendar/sealedInvites.js";
 import { onSigningOut } from "../compose/composeFlushRegistry.js";
 import { ApiClient } from "../../../../../lib/util/api.js";
 import { useApiClient } from "../../../../../lib/util/apiClientContext.js";
@@ -126,3 +126,13 @@ export function useMessageInvite(uid: string, enabled = true): { invite: Message
 }
 
 onSigningOut(clearSealedInvites);
+onSigningOut(clearInviteCache);
+// What the server read from a zero-access message's decrypted calendar file (its summary, description) goes with the file when the mailbox
+// locks: mounted cards, chips and popovers draw nothing until it is read again.
+onSealedInvitesForgotten((uids) => {
+    for (const uid of uids) {
+        if (entries.delete(uid)) {
+            notify(uid);
+        }
+    }
+});

package/apps/shared/components/mail/pinnedSigners.ts

@@ -28,6 +28,7 @@ import {
     PINNED_FINGERPRINT_PAGE_SIZE,
     SignerKeyState,
     listContacts,
+    pinnedOpenPgpKeysFor,
     pinnedSigningFingerprintsFor,
     signerKeyStateFor,
 } from "../../../../lib/contacts/contactsApi.js";
@@ -35,6 +36,7 @@ import { keyPinnedSince } from "../contacts/contactKeys.js";
 import { listFolders } from "../../../../lib/mail/mailApi.js";
 import { subscribeKeySession } from "../../../../lib/crypto/keySession.js";
 import type { ApiClient } from "../../../../lib/util/api.js";
+import type { SignerPins } from "../../../../lib/crypto/messageSecurity.js";
 
 /** How long one mailbox's loaded contact list is reused before it is fetched again. */
 export const CONTACTS_CACHE_TTL_MS = 60_000;
@@ -120,12 +122,21 @@ export async function getPinnedSignerFingerprints(mailboxUid: string, address: s
     return pinnedSigningFingerprintsFor(await cachedMailboxContacts(mailboxUid, client), address);
 }
 
+/** The sender `address`'s pinned signing fingerprints and pinned OpenPGP certificates from `mailboxUid`'s contacts - what
+ * `evaluateMessageSecurity()` takes as `SignerPins`. Rejects if they can't be loaded. */
+export async function getPinnedSigners(mailboxUid: string, address: string, client?: ApiClient): Promise<SignerPins> {
+    const contacts = await cachedMailboxContacts(mailboxUid, client);
+    return { fingerprints: pinnedSigningFingerprintsFor(contacts, address), openPgpKeys: pinnedOpenPgpKeysFor(contacts, address) };
+}
+
 /** A sender's signing-key state (`signerKeyStateFor()`) plus what a key-changed notice needs to show and link. */
 export interface SenderKeyState extends SignerKeyState {
     /** The contact holding the first pinned signing key, else the one holding the conflict, else the first match. */
     contactUid?: string;
     /** When the first pinned signing key started being trusted - see `keyPinnedSince()`. */
     pinnedSince?: number;
+    /** When the first pinned OpenPGP certificate (`openPgp[0]`) started being trusted. */
+    openPgpPinnedSince?: number;
 }
 
 /** The sender `address`'s signing-key state from `mailboxUid`'s (cached) contacts, for a "signing key changed" comparison
@@ -142,9 +153,12 @@ export async function getSignerKeyState(mailboxUid: string, address: string, cli
         holder ??
         matching.find((candidate) => (candidate.keyConflicts ?? []).some((conflict) => conflict.useType === "sign")) ??
         matching[0];
+    const openPgpKey = state.openPgp?.[0];
+    const openPgpHolder = openPgpKey && matching.find((candidate) => (candidate.keys ?? []).includes(openPgpKey));
     return {
         ...state,
         ...(contact ? { contactUid: contact.uid } : {}),
         ...(holder ? { pinnedSince: keyPinnedSince(holder, pinned) } : {}),
+        ...(openPgpHolder ? { openPgpPinnedSince: keyPinnedSince(openPgpHolder, openPgpKey) } : {}),
     };
 }

package/apps/shared/components/mail/reading/conversationPrint.ts

@@ -39,13 +39,13 @@ export async function olderConversationMessages(message: Message, client?: ApiCl
 }
 
 /**
- * One earlier message of a conversation as it prints: the body the reading pane would show. An encrypted one is decrypted here when this device has
- * its mailbox's keys unlocked; when it can't be, it prints a line saying so rather than the ciphertext. `client` is the explicit `ApiClient` every
+ * One earlier message of a conversation as it prints: the body the reading pane would show. An encrypted one - end to end, or sealed to its mailbox's
+ * zero-access key, whose subject and body the server doesn't hold readable - is decrypted here when this device has its mailbox's keys unlocked; when it can't be, it prints a line saying so rather than the ciphertext. `client` is the explicit `ApiClient` every
  * request goes through when given (see `useApiClient()`); without one they are the cookie requests they always were.
  */
 export async function printableOlderMessage(message: Message, client?: ApiClient): Promise<PrintableMessage> {
     const attachments = await listAttachments(message.folderUid, message.uid, client).catch(() => []);
-    if (message.encrypted) {
+    if (message.encrypted || message.zeroAccess) {
         const unlocked = getUnlockedKeys(message.mailboxUid);
         if (unlocked) {
             const { evaluateMessageSecurity } = await import("../../../../../lib/crypto/messageSecurity.js");

package/apps/shared/components/settings/KeyExportSetting.tsx

@@ -20,6 +20,9 @@ export interface KeyExportSettingProps {
 
 const INPUT_CLASS = "w-full text-sm border border-border rounded-sm py-1.5 px-2 bg-surface";
 
+/** How long the file's object URL is kept, since some browsers (WebKit, older Firefox) still read it after the click returns. */
+const DOWNLOAD_URL_LIFETIME_MS = 60_000;
+
 /** Hands `bytes` to the browser as a file download. */
 function saveFile(bytes: Uint8Array, filename: string): void {
     const url = URL.createObjectURL(new Blob([bytes as BlobPart], { type: "application/x-pkcs12" }));
@@ -29,7 +32,7 @@ function saveFile(bytes: Uint8Array, filename: string): void {
     document.body.appendChild(link);
     link.click();
     link.remove();
-    URL.revokeObjectURL(url);
+    setTimeout(() => URL.revokeObjectURL(url), DOWNLOAD_URL_LIFETIME_MS);
 }
 
 /**