refactor: update encryption handling and address management in email components

- Enhanced the encryption logic to include recipient addresses for better key management.
- Updated the versioning of encryption blocks from v1 to v2 across various components and tests.
- Implemented checks to prevent sending encrypted emails with Bcc recipients, ensuring compliance with encryption protocols.
- Adjusted related tests to reflect changes in encryption handling and recipient address management.

Author: jzunigax2

src/components/compose-message/hooks/useComposeSend.test.ts

@@ -35,11 +35,11 @@ const recipient = (email: string): Recipient => ({ id: email, email });
 const show = vi.mocked(notificationsService.show);
 
 const mockEncryptionBlock = {
-  version: 'v1',
+  version: 'v2',
   encryptedText: 'ct',
-  encryptedPreview: 'cp',
   wrappedKeys: [],
-  attachmentWrappedKeys: [],
+  encryptedPreview: 'cp',
+  previewWrappedKeys: [],
 };
 
 const renderSend = (overrides: Partial<Parameters<typeof useComposeSend>[0]> = {}) => {
@@ -175,11 +175,31 @@ describe('useComposeSend', () => {
       expect.any(Uint8Array),
     );
     expect(mocks.sendEmail).toHaveBeenCalledWith(
-      expect.objectContaining({ encryption: expect.objectContaining({ version: 'v1' }), deliveryMode: 'INTERNXT' }),
+      expect.objectContaining({ encryption: expect.objectContaining({ version: 'v2' }), deliveryMode: 'INTERNXT' }),
     );
     expect(onSent).toHaveBeenCalled();
   });
 
+  test('When all recipients are Internxt and one is Bcc, then the send is blocked', async () => {
+    const buildSpy = vi.spyOn(MailEncryptionService.instance, 'buildEncryptionBlock');
+
+    const { result, onSent } = renderSend({
+      toRecipients: [recipient('bob@inxt.me')],
+      bccRecipients: [recipient('carol@inxt.me')],
+    });
+
+    expect(result.current.encryptionState).toBe('internxt');
+
+    await act(async () => {
+      await result.current.send();
+    });
+
+    expect(show).toHaveBeenCalledWith(expect.objectContaining({ text: 'errors.mail.bccNotSupportedEncrypted' }));
+    expect(buildSpy).not.toHaveBeenCalled();
+    expect(mocks.sendEmail).not.toHaveBeenCalled();
+    expect(onSent).not.toHaveBeenCalled();
+  });
+
   describe('external recipients', () => {
     let getVariable: ReturnType<typeof vi.spyOn>;
 
@@ -226,7 +246,7 @@ describe('useComposeSend', () => {
         expect.any(Uint8Array),
       );
       expect(mocks.sendEmail).toHaveBeenCalledWith(
-        expect.objectContaining({ deliveryMode: 'EXTERNAL', encryption: expect.objectContaining({ version: 'v1' }) }),
+        expect.objectContaining({ deliveryMode: 'EXTERNAL', encryption: expect.objectContaining({ version: 'v2' }) }),
       );
       expect(onSent).toHaveBeenCalled();
     });

src/components/compose-message/hooks/useComposeSend.ts

@@ -96,7 +96,8 @@ export const useComposeSend = ({
 
     if (pendingInherited.length > 0) {
       const senderKeysForAttachments = MailKeysService.instance.getCurrentKeys();
-      if (!senderKeysForAttachments) {
+      const senderAddress = MailKeysService.instance.getCurrentAddress();
+      if (!senderKeysForAttachments || !senderAddress) {
         notificationsService.show({
           text: translate('errors.mail.forwardAttachmentFailed'),
           type: ToastType.Error,
@@ -110,6 +111,7 @@ export const useComposeSend = ({
           const originalSessionKey = await MailEncryptionService.instance.decryptAttachmentsSessionKey(
             item.originalEnvelope,
             senderKeysForAttachments,
+            senderAddress,
           );
 
           const { blob } = await NetworkService.instance.download({
@@ -167,6 +169,12 @@ export const useComposeSend = ({
       return;
     }
 
+    // TODO: remove this once per-recipient delivery is implemented
+    if (encryptionState === 'internxt' && bccRecipients.length > 0) {
+      notificationsService.show({ text: translate('errors.mail.bccNotSupportedEncrypted'), type: ToastType.Warning });
+      return;
+    }
+
     if (!senderKeys?.address || !senderKeys.publicKey) {
       notificationsService.show({ text: translate('errors.mail.keyLookupFailed'), type: ToastType.Error });
       return;

src/components/compose-message/hooks/useDraftMessage.test.ts

@@ -25,11 +25,11 @@ const editor = { getHTML: () => '<p>hi</p>', getText: () => 'hi', on: vi.fn(), o
 const recipient = (email: string): Recipient => ({ id: email, email });
 
 const mockEncryptionBlock = {
-  version: 'v1',
+  version: 'v2',
   encryptedText: 'ct',
-  encryptedPreview: 'cp',
   wrappedKeys: [],
-  attachmentWrappedKeys: [],
+  encryptedPreview: 'cp',
+  previewWrappedKeys: [],
 };
 
 const renderDraft = (overrides: Partial<Parameters<typeof useDraftMessage>[0]> = {}) => {
@@ -84,7 +84,7 @@ describe('Draft Message', () => {
       expect.objectContaining({
         subject: 'A subject',
         to: [{ email: 'bob@inxt.me' }],
-        encryption: expect.objectContaining({ version: 'v1' }),
+        encryption: expect.objectContaining({ version: 'v2' }),
       }),
     );
   });

src/components/compose-message/index.tsx

@@ -128,9 +128,10 @@ export const ComposeMessageDialog = () => {
     const envelope = composeDialogData?.mode === 'draft' ? composeDialogData.draft.encryption : undefined;
     if (!envelope) return;
     const keys = MailKeysService.instance.getCurrentKeys();
-    if (!keys) return;
+    const address = MailKeysService.instance.getCurrentAddress();
+    if (!keys || !address) return;
     MailEncryptionService.instance
-      .decryptAttachmentsSessionKey(envelope as EncryptionBlock, keys)
+      .decryptAttachmentsSessionKey(envelope as EncryptionBlock, keys, address)
       .then((key) => {
         setAttachmentsSessionKey(key);
         sessionKeyHydratedRef.current = true;

src/hooks/mail/useAttachmentsSessionKey.test.tsx

@@ -9,16 +9,17 @@ import { MailKeysService } from '@/services/mail-keys';
 const KEY = new Uint8Array([1, 2, 3, 4]);
 const KEYPAIR = { secretKey: new Uint8Array(32), publicKey: new Uint8Array(32) } as unknown as HybridKeyPair;
 const ENVELOPE = {
-  version: 'v1',
+  version: 'v2',
   encryptedText: 'ct',
-  encryptedPreview: 'cp',
   wrappedKeys: [],
-  attachmentWrappedKeys: [],
+  encryptedPreview: 'cp',
+  previewWrappedKeys: [],
 } as unknown as EncryptionBlock;
 
 const setKeys = (keys: HybridKeyPair | null) => {
   const spy = vi.spyOn(MailKeysService.instance, 'getCurrentKeys');
   spy.mockReturnValue(keys);
+  vi.spyOn(MailKeysService.instance, 'getCurrentAddress').mockReturnValue(keys ? 'me@inxt.me' : null);
   return spy;
 };
 

src/hooks/mail/useAttachmentsSessionKey.ts

@@ -16,15 +16,16 @@ export const useAttachmentsSessionKey = (
   envelope: EncryptionBlock | null,
 ): Uint8Array | null => {
   const keypair = MailKeysService.instance.getCurrentKeys();
+  const address = MailKeysService.instance.getCurrentAddress();
   const [cache, setCache] = useState<Record<string, CachedKey>>({});
 
   useEffect(() => {
-    if (!mailId || !envelope || !keypair) return;
+    if (!mailId || !envelope || !keypair || !address) return;
     if (cache[mailId]) return;
 
     let cancelled = false;
     MailEncryptionService.instance
-      .decryptAttachmentsSessionKey(envelope, keypair)
+      .decryptAttachmentsSessionKey(envelope, keypair, address)
       .then((key) => {
         if (!cancelled) setCache((prev) => ({ ...prev, [mailId]: { ok: true, key } }));
       })
@@ -36,7 +37,7 @@ export const useAttachmentsSessionKey = (
     return () => {
       cancelled = true;
     };
-  }, [mailId, envelope, keypair, cache]);
+  }, [mailId, envelope, keypair, address, cache]);
 
   if (!mailId) return null;
   const entry = cache[mailId];

src/hooks/mail/useDecryptedPreviews.test.tsx

@@ -15,6 +15,7 @@ const plainSummary = (id: string): Summary => ({ id }) as unknown as Summary;
 
 const setKeys = (keys: HybridKeyPair | null) => {
   vi.spyOn(MailKeysService.instance, 'getCurrentKeys').mockReturnValue(keys);
+  vi.spyOn(MailKeysService.instance, 'getCurrentAddress').mockReturnValue(keys ? 'me@inxt.me' : null);
 };
 
 const spyOnPreviewDecrypt = () => vi.spyOn(MailEncryptionService.instance, 'decryptSummaryPreview');

src/hooks/mail/useDecryptedPreviews.ts

@@ -6,11 +6,19 @@ import { MailKeysService } from '@/services/mail-keys';
 
 type Summary = EmailListResponse['emails'][number];
 
-const decryptPendingPreviews = async (pending: Summary[], keypair: HybridKeyPair): Promise<Record<string, string>> => {
+const decryptPendingPreviews = async (
+  pending: Summary[],
+  keypair: HybridKeyPair,
+  address: string,
+): Promise<Record<string, string>> => {
   const resolved: Record<string, string> = {};
   for (const summary of pending) {
     try {
-      resolved[summary.id] = await MailEncryptionService.instance.decryptSummaryPreview(summary.encryption!, keypair);
+      resolved[summary.id] = await MailEncryptionService.instance.decryptSummaryPreview(
+        summary.encryption!,
+        keypair,
+        address,
+      );
     } catch (error) {
       console.error('Failed to decrypt mail preview', { mailId: summary.id, error });
     }
@@ -21,27 +29,28 @@ const decryptPendingPreviews = async (pending: Summary[], keypair: HybridKeyPair
 /**
  * Decrypts the preview snippet for the encrypted rows on a list page. The
  * backend projects an `encryption` block ({ encryptedPreview, wrappedKeys })
- * onto each encrypted summary the caller can read; we trial-decrypt it with the
- * caller's keypair, exactly as the full body is decrypted.
+ * onto each encrypted summary the caller can read; the caller's wrapped key is
+ * found by its address label, exactly as the full body is decrypted.
  *
  * Returns a map of `emailId -> decrypted preview`. Rows are decrypted at most
  * once (tracked in `attempted`), so re-renders and pagination don't re-run the
  * crypto, and a row that fails simply stays absent
  */
 export const useDecryptedPreviews = (summaries: Summary[] | undefined): Record<string, string> => {
   const senderKeys = MailKeysService.instance.getCurrentKeys();
+  const senderAddress = MailKeysService.instance.getCurrentAddress();
   const [previews, setPreviews] = useState<Record<string, string>>({});
   const attempted = useRef<Set<string>>(new Set());
 
   useEffect(() => {
-    if (!senderKeys || !summaries?.length) return;
+    if (!senderKeys || !senderAddress || !summaries?.length) return;
 
     const pending = summaries.filter((s) => s.encryption && !attempted.current.has(s.id));
     if (pending.length === 0) return;
     pending.forEach((s) => attempted.current.add(s.id));
 
     let cancelled = false;
-    decryptPendingPreviews(pending, senderKeys).then((resolved) => {
+    decryptPendingPreviews(pending, senderKeys, senderAddress).then((resolved) => {
       if (!cancelled && Object.keys(resolved).length) {
         setPreviews((prev) => ({ ...prev, ...resolved }));
       }
@@ -50,7 +59,7 @@ export const useDecryptedPreviews = (summaries: Summary[] | undefined): Record<s
     return () => {
       cancelled = true;
     };
-  }, [summaries, senderKeys]);
+  }, [summaries, senderKeys, senderAddress]);
 
   return previews;
 };

src/i18n/locales/en.json

@@ -170,6 +170,7 @@
       "forwardAttachmentFailed": "Could not prepare an attachment for forwarding. Please try again.",
       "internxtKeyMissing": "Could not find encryption keys for an Internxt recipient. Please try again later.",
       "encryptionUnavailable": "Encryption isn't ready yet. Please try again in a moment.",
+      "bccNotSupportedEncrypted": "Bcc isn't available for encrypted emails yet. Move the recipient to To or Cc.",
       "draftSaveFailed": "Could not save the draft. Your changes are still here.",
       "draftDiscardFailed": "Could not delete the draft. Please try again.",
       "draftOpenFailed": "Could not open the draft. Please try again."

src/i18n/locales/es.json

@@ -172,6 +172,7 @@
       "forwardAttachmentFailed": "No se pudo preparar un adjunto para reenviar. Inténtalo de nuevo.",
       "internxtKeyMissing": "No se encontraron claves de cifrado para un destinatario de Internxt. Inténtalo de nuevo más tarde.",
       "encryptionUnavailable": "El cifrado aún no está listo. Inténtalo de nuevo en un momento.",
+      "bccNotSupportedEncrypted": "Cco aún no está disponible para correos cifrados. Mueve el destinatario a Para o Cc.",
       "draftSaveFailed": "No se pudo guardar el borrador. Tus cambios siguen aquí.",
       "draftDiscardFailed": "No se pudo eliminar el borrador. Inténtalo de nuevo.",
       "draftOpenFailed": "No se pudo abrir el borrador. Inténtalo de nuevo."