diff --git a/extension/chrome/elements/backup.htm b/extension/chrome/elements/backup.htm index afe1ae92349..6040b2ccdf5 100644 --- a/extension/chrome/elements/backup.htm +++ b/extension/chrome/elements/backup.htm @@ -13,7 +13,9 @@
- This backup is protected by your passphrase. Please make sure to note your passphrase down or you may lose access to your encrypted emails! + + This backup is protected by your passphrase. Please make sure to note your passphrase down or you may lose access to your encrypted emails! +
diff --git a/extension/chrome/elements/backup.ts b/extension/chrome/elements/backup.ts index ad1e38bd7fe..231db348e80 100644 --- a/extension/chrome/elements/backup.ts +++ b/extension/chrome/elements/backup.ts @@ -19,15 +19,17 @@ View.run( private readonly parentTabId: string; private readonly frameId: string; private readonly armoredPrvBackup: string; + private readonly fromEmail: string; private storedPrvWithMatchingLongid: KeyInfoWithIdentity | undefined; public constructor() { super(); - const uncheckedUrlParams = Url.parse(['acctEmail', 'armoredPrvBackup', 'parentTabId', 'frameId']); + const uncheckedUrlParams = Url.parse(['acctEmail', 'armoredPrvBackup', 'parentTabId', 'frameId', 'fromEmail']); this.acctEmail = Assert.urlParamRequire.string(uncheckedUrlParams, 'acctEmail'); this.parentTabId = Assert.urlParamRequire.string(uncheckedUrlParams, 'parentTabId'); this.frameId = Assert.urlParamRequire.string(uncheckedUrlParams, 'frameId'); this.armoredPrvBackup = Assert.urlParamRequire.string(uncheckedUrlParams, 'armoredPrvBackup'); + this.fromEmail = Assert.urlParamRequire.string(uncheckedUrlParams, 'fromEmail'); } public render = async () => { @@ -53,12 +55,20 @@ View.run( `This private key with fingerprint ${Xss.escape(Str.spaced(fingerprint))} has already been imported.` ); } else { + const notUserOwnedPrvKey = this.fromEmail !== this.acctEmail; + const recommendation = notUserOwnedPrvKey ? '' : 'We recommend importing all backups to ensure you can read all incoming encrypted emails.'; + if (notUserOwnedPrvKey) { + $('.backup_message_text').text( + 'This message contains a private key received from ' + + this.fromEmail + + '. Import only if you intentionally sent this to yourself or received it from your administrator.' + ); + } $('.line .private_key_status') - .html( - `The private key ${Xss.escape(Str.spaced(fingerprint))} has not been imported yet. \n` + - `We recommend importing all backups to ensure you can read all incoming encrypted emails.` - ) - .after('
'); // xss-direct + .html(`The private key ${Xss.escape(Str.spaced(fingerprint))} has not been imported yet. \n` + recommendation) // xss-safe-value + .after( + `
` + ); // xss-direct } this.sendResizeMsg(); }; diff --git a/extension/js/common/message-renderer.ts b/extension/js/common/message-renderer.ts index 67422c6dc62..46928530710 100644 --- a/extension/js/common/message-renderer.ts +++ b/extension/js/common/message-renderer.ts @@ -282,7 +282,7 @@ export class MessageRenderer { renderedXssSafe += frameXssSafe; // xss-safe-value blocksInFrames[frameId] = block; } else { - renderedXssSafe += XssSafeFactory.renderableMsgBlock(this.factory, block, isOutgoing); // xss-safe-factory + renderedXssSafe += XssSafeFactory.renderableMsgBlock(this.factory, block, isOutgoing, senderEmail); // xss-safe-factory } } return { renderedXssSafe, isOutgoing, blocksInFrames }; // xss-safe-value @@ -385,13 +385,17 @@ export class MessageRenderer { return 'replaced'; // native should be hidden, custom should appear instead } else if (treatAs === 'encryptedMsg') { this.setMsgBodyAndStartProcessing( - loaderContext, treatAs, messageInfo.printMailInfo, messageInfo.from?.email, - renderModule => this.processEncryptedMsgAttachment(a, renderModule, messageInfo.from?.email, messageInfo.isPwdMsgBasedOnMsgSnippet, messageInfo.plainSubject), + loaderContext, + treatAs, + messageInfo.printMailInfo, + messageInfo.from?.email, + renderModule => + this.processEncryptedMsgAttachment(a, renderModule, messageInfo.from?.email, messageInfo.isPwdMsgBasedOnMsgSnippet, messageInfo.plainSubject), 'append' ); return 'hidden'; // native attachment should be hidden, the "attachment" goes to the message container } else if (treatAs === 'privateKey') { - return await this.renderBackupFromFile(a, loaderContext, attachmentSel); + return await this.renderBackupFromFile(a, loaderContext, attachmentSel, messageInfo.from?.email); } else { // standard file loaderContext.renderPlainAttachment(a, attachmentSel); @@ -869,11 +873,12 @@ export class MessageRenderer { private renderBackupFromFile = async ( attachment: Attachment, loaderContext: LoaderContextInterface, - attachmentSel: JQuery | undefined + attachmentSel: JQuery | undefined, + fromEmail?: string ): Promise<'shown' | 'hidden'> => { try { await this.gmail.fetchAttachmentsMissingData([attachment]); - loaderContext.setMsgBody_DANGEROUSLY(this.factory.embeddedBackup(attachment.getData().toUtfStr()), 'append'); // xss-safe-factory + loaderContext.setMsgBody_DANGEROUSLY(this.factory.embeddedBackup(attachment.getData().toUtfStr(), fromEmail), 'append'); // xss-safe-factory return 'hidden'; } catch { loaderContext.renderPlainAttachment(attachment, attachmentSel, 'Please reload page'); // todo: unit-test diff --git a/extension/js/common/xss-safe-factory.ts b/extension/js/common/xss-safe-factory.ts index 48df1d6b07c..7fee04eccc5 100644 --- a/extension/js/common/xss-safe-factory.ts +++ b/extension/js/common/xss-safe-factory.ts @@ -60,7 +60,7 @@ export class XssSafeFactory { * * When edited, REQUEST A SECOND SET OF EYES TO REVIEW CHANGES */ - public static renderableMsgBlock = (factory: XssSafeFactory, block: MsgBlock, isOutgoing?: boolean) => { + public static renderableMsgBlock = (factory: XssSafeFactory, block: MsgBlock, isOutgoing?: boolean, senderEmail?: string) => { if (block.type === 'plainText') { return XssSafeFactory.renderPlainContent(block.content); } else if (block.type === 'plainHtml') { @@ -68,7 +68,7 @@ export class XssSafeFactory { } else if (block.type === 'publicKey') { return factory.embeddedPubkey(PgpArmor.normalize(Str.with(block.content), 'publicKey'), isOutgoing); } else if (block.type === 'privateKey') { - return factory.embeddedBackup(PgpArmor.normalize(Str.with(block.content), 'privateKey')); + return factory.embeddedBackup(PgpArmor.normalize(Str.with(block.content), 'privateKey'), senderEmail); } else if (block.type === 'certificate') { return factory.embeddedPubkey(Str.with(block.content), isOutgoing); } else if (['encryptedAttachment', 'plainAttachment'].includes(block.type)) { @@ -163,8 +163,8 @@ export class XssSafeFactory { }); }; - public srcBackupIframe = (armoredPrvBackup: string) => { - return this.frameSrc(this.extUrl('chrome/elements/backup.htm'), { frameId: this.newId(), armoredPrvBackup }); + public srcBackupIframe = (armoredPrvBackup: string, fromEmail?: string) => { + return this.frameSrc(this.extUrl('chrome/elements/backup.htm'), { frameId: this.newId(), armoredPrvBackup, fromEmail }); }; public srcReplyMsgIframe = (convoParams: FactoryReplyParams, skipClickPrompt: boolean, ignoreDraft: boolean) => { @@ -229,8 +229,8 @@ export class XssSafeFactory { return this.iframe(this.srcPgpPubkeyIframe(armoredPubkey, isOutgoing), ['pgp_block', 'publicKey']); }; - public embeddedBackup = (armoredPrvBackup: string) => { - return this.iframe(this.srcBackupIframe(armoredPrvBackup), ['backup_block']); + public embeddedBackup = (armoredPrvBackup: string, fromEmail?: string) => { + return this.iframe(this.srcBackupIframe(armoredPrvBackup, fromEmail), ['backup_block']); }; public embeddedReply = (convoParams: FactoryReplyParams, skipClickPrompt: boolean, ignoreDraft = false) => { diff --git a/test/source/mock/google/exported-messages/message-export-19d4781fca9d303d.json b/test/source/mock/google/exported-messages/message-export-19d4781fca9d303d.json new file mode 100644 index 00000000000..1d1d6a4b284 --- /dev/null +++ b/test/source/mock/google/exported-messages/message-export-19d4781fca9d303d.json @@ -0,0 +1,167 @@ +{ + "acctEmail": "flowcrypt.compatibility@gmail.com", + "full": { + "id": "19d4781fca9d303d", + "threadId": "19d4781fca9d303d", + "labelIds": [ + "IMPORTANT", + "CATEGORY_PERSONAL", + "Label_15", + "INBOX" + ], + "snippet": "This email contains private backup that doesn't owned by flowcrypt.compatibility", + "payload": { + "partId": "", + "mimeType": "multipart/mixed", + "filename": "", + "headers": [ + { + "name": "X-Gm-Message-State", + "value": "AOJu0YxShBlKdFwhibsyRCr3kBtQ8t+hhKWdf1oszQSVAaVyHBpzihEf t/FP6mdFz1Md2scCvhr6t6x7ckkes0hs4qrMyhHI8CgkhTnezfxxThAY/wAKJsNxe2h/2JFfzqJ xqoZOihesQGsS9TneKJWVtHkUbvpleBSbyAN7xifNCvIMjFb0v83y" + }, + { + "name": "X-Gm-Gg", + "value": "ATEYQzyI0AGWRTQqTz3S10kl0hjwn+BLZl7FpO2d0384u3XeizyT1A2umb+SnK6ZCQc M5XT6lkfaA3Y7MCUgE+BlTQHQOqtUJtRDOEH/XOHlWm/Fj+c+XXEDp2Z6PyPCYiVn6j762vxiku 8L2ExzFt870O/U1GpZYeTb30wF0gJ209bno/lXwFvum5qpkTG2GO0s8sBXSyWl3X4BXJKMimLMX oL3stReGgbUaZpAlpkXwvrwkzX4gHCXD1/e5qp8n/zHL9SEJe3X2vlGrCQ0lmj+udaX4W88rdHt yuYnREWU9jpWBpPOjhi41rvE/sz5FeG0+uXR7iGJ83HzSnWqNcmsmCoZZ5GHkqdWNlm/95xJCmx bAdvjaZyP5o1yu0fsdXVaKEFfY+7LRgfIlRDPnhxdk+RcJin7uAdk14Bx0PHu/fAwwr6Wme+7QX SArl16uA==" + }, + { + "name": "MIME-Version", + "value": "1.0" + }, + { + "name": "From", + "value": "sender@domain.com" + }, + { + "name": "Date", + "value": "Wed, 1 Apr 2026 13:25:57 +0800" + }, + { + "name": "X-Gm-Features", + "value": "AQROBzCt50DWyWY_lNV5OV4sq2EBd1Pgz1Y8CGQA1m7Bm0Inrav2_RJifRKURJE" + }, + { + "name": "Subject", + "value": "Test email with backup for flowcrypt-browser #6199" + }, + { + "name": "To", + "value": "flowcrypt.compatibility@gmail.com" + }, + { + "name": "Content-Type", + "value": "multipart/mixed; boundary=\"000000000000b58afc064e5f5349\"" + } + ], + "body": { + "size": 0 + }, + "parts": [ + { + "partId": "0", + "mimeType": "multipart/alternative", + "filename": "", + "headers": [ + { + "name": "Content-Type", + "value": "multipart/alternative; boundary=\"000000000000b58afb064e5f5347\"" + } + ], + "body": { + "size": 0 + }, + "parts": [ + { + "partId": "0.0", + "mimeType": "text/plain", + "filename": "", + "headers": [ + { + "name": "Content-Type", + "value": "text/plain; charset=\"UTF-8\"" + } + ], + "body": { + "size": 83, + "data": "VGhpcyBlbWFpbCBjb250YWlucyBwcml2YXRlIGJhY2t1cCB0aGF0IGRvZXNuJ3Qgb3duZWQgYnkNCmZsb3djcnlwdC5jb21wYXRpYmlsaXR5DQo=" + } + }, + { + "partId": "0.1", + "mimeType": "text/html", + "filename": "", + "headers": [ + { + "name": "Content-Type", + "value": "text/html; charset=\"UTF-8\"" + }, + { + "name": "Content-Transfer-Encoding", + "value": "quoted-printable" + } + ], + "body": { + "size": 109, + "data": "PGRpdiBkaXI9Imx0ciI-VGhpcyBlbWFpbCBjb250YWlucyBwcml2YXRlIGJhY2t1cCB0aGF0IGRvZXNuJiMzOTt0IG93bmVkIGJ5IGZsb3djcnlwdC5jb21wYXRpYmlsaXR5wqA8L2Rpdj4NCg==" + } + } + ] + }, + { + "partId": "1", + "mimeType": "application/pgp-keys", + "filename": "flowcrypt-backup-martroblesitgmailcom-67BEE1A01FB71D36804276A08CDBB8C8059A2AF5.asc", + "headers": [ + { + "name": "Content-Type", + "value": "application/pgp-keys; name=\"flowcrypt-backup-martroblesitgmailcom-67BEE1A01FB71D36804276A08CDBB8C8059A2AF5.asc\"" + }, + { + "name": "Content-Disposition", + "value": "attachment; filename=\"flowcrypt-backup-martroblesitgmailcom-67BEE1A01FB71D36804276A08CDBB8C8059A2AF5.asc\"" + }, + { + "name": "Content-Transfer-Encoding", + "value": "base64" + }, + { + "name": "Content-ID", + "value": "" + }, + { + "name": "X-Attachment-Id", + "value": "f_mnflrk420" + } + ], + "body": { + "attachmentId": "ANGjdJ8qorwt8gGgIajqLmoLIG1JJAtpMxxjvsfFl4OGLMbssnnNvxppj_Le7M3ltEPi3FuiM7u3GVHdP-0h55sgIE607SLr_YpxqLPa6anfXU8GiYDVm_9Y2SspJDU9qZrAR8PaZRC23KJkvl-WZdGx4lBjzJCxYokS6JqloMWuS-0RSjLBbWy8oAcxfIQ3OQJsWYbxaUQVKpgtjIAESoIUvICraxysPe66JzT-J_dtmdPIp8lBIcsttLw8QCr_vLC-8YibCkRnOY7Au9Aus0pK4n945g_CZ4wIwZZkLHXVA3PxaDR0OwA6fKpih5CeMF8QVFXyUG4CWXxZr473CHiLyLZ4Hs7G8bQ_FyYmiQFJMmzKarMlMWkTNIIeUbNqLu6z4jKA9GTUTANtP_hu", + "size": 5184 + } + } + ] + }, + "sizeEstimate": 14754, + "historyId": "1494870", + "internalDate": "1775021157000" + }, + "attachments": { + "ANGjdJ8qorwt8gGgIajqLmoLIG1JJAtpMxxjvsfFl4OGLMbssnnNvxppj_Le7M3ltEPi3FuiM7u3GVHdP-0h55sgIE607SLr_YpxqLPa6anfXU8GiYDVm_9Y2SspJDU9qZrAR8PaZRC23KJkvl-WZdGx4lBjzJCxYokS6JqloMWuS-0RSjLBbWy8oAcxfIQ3OQJsWYbxaUQVKpgtjIAESoIUvICraxysPe66JzT-J_dtmdPIp8lBIcsttLw8QCr_vLC-8YibCkRnOY7Au9Aus0pK4n945g_CZ4wIwZZkLHXVA3PxaDR0OwA6fKpih5CeMF8QVFXyUG4CWXxZr473CHiLyLZ4Hs7G8bQ_FyYmiQFJMmzKarMlMWkTNIIeUbNqLu6z4jKA9GTUTANtP_hu": { + "data": "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", + "size": 5184 + } + }, + "raw": { + "id": "19d4781fca9d303d", + "threadId": "19d4781fca9d303d", + "labelIds": [ + "IMPORTANT", + "CATEGORY_PERSONAL", + "Label_15", + "INBOX" + ], + "snippet": "This email contains private backup that doesn't owned by flowcrypt.compatibility", + "sizeEstimate": 14754, + "raw": "Delivered-To: flowcrypt.compatibility@gmail.com
Received: by 2002:ac8:4455:0:b0:50b:38a5:87ca with SMTP id m21csp2611033qtn;
        Tue, 31 Mar 2026 22:26:34 -0700 (PDT)
X-Received: by 2002:a05:6808:5291:b0:45e:f888:695e with SMTP id 5614622812f47-46ae01b9890mr1069555b6e.11.1775021194407;
        Tue, 31 Mar 2026 22:26:34 -0700 (PDT)
ARC-Seal: i=2; a=rsa-sha256; t=1775021194; cv=pass;
        d=google.com; s=arc-20240605;
        b=N6epJq/BrO+dud0CX31fpjtJl1KBBevSPI4jQmuyXdCCC1ZLv9HpB0Afgw2DUPuVR8
         BWX0K21PNNM1lPExlnjIrlMAiUwEQdO40NwQd+3Yi9a0ZX4m0sFBwUuc5AcWFjYGEPXv
         +G4w5/JZNXqkuAtl72oyp1n6pG0+kf2+CstA6xCMTq4W5qnH4LwjRu+OHYqSOx728v43
         hFrW6GrfySNTlRQ7DgLY6xbG0O3Cv5i2/1QZEz64EPgMfgTHsb80drhoIiscu1hm5L4M
         puXpQx0vXuX9Hk89qwlPJ9zKHgARm7291glGu1W7I4usVy6miIv1Ugfb9QaYADK7vDee
         vBtg==
ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605;
        h=to:subject:message-id:date:from:mime-version:dkim-signature;
        bh=3CJpvAOLv//zkQGQsJpRrvoHA4BE1ASujUkQ7aYTRKw=;
        fh=Gc7KPxFW2JqEPl+qfxGvKsx5Usr1IrZhNziNchCyS+I=;
        b=krW3ej/6oER8OYdi+V7m/zIBiREWgs9fJ1Vz7PtfylSlrYa9KfJcURch/Vlb2HZJhK
         bwnEJqjjbSFF712sw0bxpjft1zU0iZxbsns1IR8vuLSrRiHKxvRclKGvwt9zJ9wILjBL
         gLmcxeOYeVasoVobrNr49ZtRjXm44YeZZbRricksJ/9cK+TirVNVrN9R5GoIJt9moSIN
         ZEsOZJSqvoIEsE4ojxlh3fUIXy08T8aqReG4aLHt/bf72De8I+66/6H4NWUhgu/QnuJT
         k2fqRfvfssRXSy4fmsKq13zCizjbdOq105FiCUmxn0XsR1pBepqDMfgH2XcA7MC1u8VT
         gzRw==;
        dara=google.com
ARC-Authentication-Results: i=2; mx.google.com;
       dkim=pass header.i=@flowcrypt.com header.s=google header.b=JfAoNrSP;
       arc=pass (i=1);
       spf=pass (google.com: domain of mart@flowcrypt.com designates 209.85.220.41 as permitted sender) smtp.mailfrom=mart@flowcrypt.com;
       dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=flowcrypt.com;
       dara=pass header.i=@gmail.com
Return-Path: <mart@flowcrypt.com>
Received: from mail-sor-f41.google.com (mail-sor-f41.google.com. [209.85.220.41])
        by mx.google.com with SMTPS id 5614622812f47-46ad6e6e715sor1055905b6e.0.2026.03.31.22.26.33
        for <flowcrypt.compatibility@gmail.com>
        (Google Transport Security);
        Tue, 31 Mar 2026 22:26:34 -0700 (PDT)
Received-SPF: pass (google.com: domain of mart@flowcrypt.com designates 209.85.220.41 as permitted sender) client-ip=209.85.220.41;
Authentication-Results: mx.google.com;
       dkim=pass header.i=@flowcrypt.com header.s=google header.b=JfAoNrSP;
       arc=pass (i=1);
       spf=pass (google.com: domain of mart@flowcrypt.com designates 209.85.220.41 as permitted sender) smtp.mailfrom=mart@flowcrypt.com;
       dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=flowcrypt.com;
       dara=pass header.i=@gmail.com
ARC-Seal: i=1; a=rsa-sha256; t=1775021193; cv=none;
        d=google.com; s=arc-20240605;
        b=T4q52VHhq5olVj6HsiowKRXe4SXSdHn34FBzZl8KWmW13TeDXqnvJtdxfNQl8TMqIA
         T0gBaDDPcxfCibsX/Kxh3WWVR1h+IggpqdDPuvk4h4Wvk9yy/ArpHWXD7U4XTAZ+zQzc
         z1ui7lYvdq3MIMxG2L04WbvqzNhmK8IWRbBxCFbAjVHL/igcBpcSeNT4zKkxpdJOoO8h
         c5pcUbETl3b1bogSd8emo7T7semCYIl8K8EUeMzpSiRmU8qTtDD7EyShB7AG1n4fvRxi
         nBJTWqgOIGfBrDXVd1jOaw0LC+JKr1AKfvVO3LqkE9Hzx7MqZRJjySUSyd8XIMxvVZ+c
         DIag==
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605;
        h=to:subject:message-id:date:from:mime-version:dkim-signature;
        bh=3CJpvAOLv//zkQGQsJpRrvoHA4BE1ASujUkQ7aYTRKw=;
        fh=Gc7KPxFW2JqEPl+qfxGvKsx5Usr1IrZhNziNchCyS+I=;
        b=MmNZUm93d3PKpF8fgFOrVV0TPqcQIv7Qqn6Ln+v7Vh5KHz5pDmyPAFnvbBTE4vS5vU
         pdh0JG+le64fSEiblgVGWUYxu8dRKech2rthJFgYJqN9buhRFrSQ4YszJ/h9s0Kgek8f
         bieCW+Poe27gxHVAZq4VKNzNiqUfitmj0kih5kjJEET68KxqVR0+HtOEIwms6ixKXqYV
         vMvjdxv31s0LX20SA+r1xbWc5ge+pBx+oI3QBwCbWkK/iN7/p/kNibomduH/3N4tRvtq
         BWXP2E10vUzFPhb4XV/u2kTiCEHiB2sZcvSQlhRmYTe5SRAiOVMDe3tBXqEhZR/uQyJa
         EwIQ==;
        dara=google.com
ARC-Authentication-Results: i=1; mx.google.com; arc=none
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=flowcrypt.com; s=google; t=1775021193; x=1775625993; dara=google.com;
        h=to:subject:message-id:date:from:mime-version:from:to:cc:subject
         :date:message-id:reply-to;
        bh=3CJpvAOLv//zkQGQsJpRrvoHA4BE1ASujUkQ7aYTRKw=;
        b=JfAoNrSPo8Y1QPwk5zdkBif+2cJ5HMi5ufKaEqkXU3OtYpQj2Vncpp1qfNHq+Yhr49
         eTpm/3HKAMr948fh3yBur4fPQ/FTqGkSrvy+OsBFlanLvnebwfsLwXCOmZqv7YLOiJQP
         eSQGSXvZ7g1qVr7mL3foWvpTmKi9GpncwsArQ=
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20251104; t=1775021193; x=1775625993;
        h=to:subject:message-id:date:from:mime-version:x-gm-gg
         :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to;
        bh=3CJpvAOLv//zkQGQsJpRrvoHA4BE1ASujUkQ7aYTRKw=;
        b=R6+5VRs6kyoYKiLfRxSfUFVQ2cD8uq09r3tEN1hctH0PSSs6ibNGzoMFqMkLGZU3hX
         PVQzsZo4kbFt4x9z4V36kaIag88rZvIC+cS2atg5Mt3/QZ2iRBm/HBd1rjUZF0zYYOqy
         ox9jBUncXYt1NbazYjUioxVoL2SPqPFliySHfQiyG7YHxeGn6J99NT77xIla+BDQcz40
         qQfj5SDa0176TQUxPcvRVq4RPnwKQZBBj9OjKV/gDjh6U2B6B4gOBpBLzwp+6tBosrbt
         s0L/A96w88uffMpeDFfRMsmrhpCPfVcxa4ZeHiXbiAa/nuTq7gOwSeN+FuVLgNDpUcBA
         f/1A==
X-Gm-Message-State: AOJu0YxShBlKdFwhibsyRCr3kBtQ8t+hhKWdf1oszQSVAaVyHBpzihEf
	t/FP6mdFz1Md2scCvhr6t6x7ckkes0hs4qrMyhHI8CgkhTnezfxxThAY/wAKJsNxe2h/2JFfzqJ
	xqoZOihesQGsS9TneKJWVtHkUbvpleBSbyAN7xifNCvIMjFb0v83y
X-Gm-Gg: ATEYQzyI0AGWRTQqTz3S10kl0hjwn+BLZl7FpO2d0384u3XeizyT1A2umb+SnK6ZCQc
	M5XT6lkfaA3Y7MCUgE+BlTQHQOqtUJtRDOEH/XOHlWm/Fj+c+XXEDp2Z6PyPCYiVn6j762vxiku
	8L2ExzFt870O/U1GpZYeTb30wF0gJ209bno/lXwFvum5qpkTG2GO0s8sBXSyWl3X4BXJKMimLMX
	oL3stReGgbUaZpAlpkXwvrwkzX4gHCXD1/e5qp8n/zHL9SEJe3X2vlGrCQ0lmj+udaX4W88rdHt
	yuYnREWU9jpWBpPOjhi41rvE/sz5FeG0+uXR7iGJ83HzSnWqNcmsmCoZZ5GHkqdWNlm/95xJCmx
	bAdvjaZyP5o1yu0fsdXVaKEFfY+7LRgfIlRDPnhxdk+RcJin7uAdk14Bx0PHu/fAwwr6Wme+7QX
	SArl16uA==
X-Received: by 2002:a05:6820:4df0:b0:67e:101d:1054 with SMTP id
 006d021491bc7-67fab975474mr1047904eaf.11.1775021193494; Tue, 31 Mar 2026
 22:26:33 -0700 (PDT)
MIME-Version: 1.0
From: Mart at FlowCrypt <mart@flowcrypt.com>
Date: Wed, 1 Apr 2026 13:25:57 +0800
X-Gm-Features: AQROBzCt50DWyWY_lNV5OV4sq2EBd1Pgz1Y8CGQA1m7Bm0Inrav2_RJifRKURJE
Message-ID: <CAMvd857nVQ=vdzHZsM_iKaGsHjqR6kxGmKqAT985f4OAhetkuA@mail.gmail.com>
Subject: Test email with backup for flowcrypt-browser #6199
To: FlowCrypt Compatibility <flowcrypt.compatibility@gmail.com>
Content-Type: multipart/mixed; boundary="000000000000b58afc064e5f5349"

--000000000000b58afc064e5f5349
Content-Type: multipart/alternative; boundary="000000000000b58afb064e5f5347"

--000000000000b58afb064e5f5347
Content-Type: text/plain; charset="UTF-8"

This email contains private backup that doesn't owned by
flowcrypt.compatibility

--000000000000b58afb064e5f5347
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">This email contains private backup that doesn&#39;t owned =
by flowcrypt.compatibility=C2=A0</div>

--000000000000b58afb064e5f5347--
--000000000000b58afc064e5f5349
Content-Type: application/pgp-keys; 
	name="flowcrypt-backup-martroblesitgmailcom-67BEE1A01FB71D36804276A08CDBB8C8059A2AF5.asc"
Content-Disposition: attachment; 
	filename="flowcrypt-backup-martroblesitgmailcom-67BEE1A01FB71D36804276A08CDBB8C8059A2AF5.asc"
Content-Transfer-Encoding: base64
Content-ID: <f_mnflrk420>
X-Attachment-Id: f_mnflrk420
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--000000000000b58afc064e5f5349--
", + "historyId": "1494870", + "internalDate": "1775021157000" + } +} \ No newline at end of file diff --git a/test/source/tests/decrypt.ts b/test/source/tests/decrypt.ts index 4053b42248d..92722f154c4 100644 --- a/test/source/tests/decrypt.ts +++ b/test/source/tests/decrypt.ts @@ -118,6 +118,33 @@ export const defineDecryptTests = (testVariant: TestVariant, testWithBrowser: Te }) ); + test( + `decrypt - backup key received from a different sender shows warning message`, + testWithBrowser(async (t, browser) => { + const threadId = '19d4781fca9d303d'; + const { acctEmail, authHdr } = await BrowserRecipe.setupCommonAcctWithAttester(t, browser, 'compatibility'); + const inboxPage = await browser.newExtensionPage(t, `chrome/settings/inbox/inbox.htm?acctEmail=${acctEmail}&threadId=${threadId}`); + await inboxPage.waitForSelTestState('ready'); + await inboxPage.waitAll('iframe'); + const backupFrame = await inboxPage.getFrame(['backup.htm']); + await backupFrame.waitForContent( + '@backup-message-text', + 'This message contains a private key received from sender@domain.com. Import only if you intentionally sent this to yourself or received it from your administrator.' + ); + await inboxPage.close(); + const gmailPage = await browser.newPage(t, `${t.context.urls?.mockGmailUrl()}/${threadId}`, undefined, authHdr); + await gmailPage.waitAll('iframe'); + const backupFrameFromGmailPage = await gmailPage.getFrame(['backup.htm']); + await backupFrameFromGmailPage.waitForContent( + '@backup-message-text', + 'This message contains a private key received from sender@domain.com. Import only if you intentionally sent this to yourself or received it from your administrator.' + ); + const importButton = await backupFrameFromGmailPage.waitAny('#action_import_key'); + expect(await importButton.evaluate((el: Element) => el.textContent?.trim())).to.equal('Import Private Key'); + await gmailPage.close(); + }) + ); + test( `decrypt - show remote images`, testWithBrowser(async (t, browser) => {