From b9ab3569ed3bff5895818251195f1214f428ca45 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Wed, 1 Mar 2023 11:18:57 +0000 Subject: [PATCH 1/5] #3448 Ignore signature for pubkey in protonmail --- extension/chrome/elements/attachment.ts | 3 +- .../compose-modules/compose-render-module.ts | 2 +- .../pgp-block-render-module.ts | 2 +- .../common/api/email-provider/gmail/gmail.ts | 2 +- extension/js/common/core/attachment.ts | 15 +- extension/js/common/core/common.ts | 5 + extension/js/common/core/mime.ts | 10 +- extension/js/common/core/msg-block-parser.ts | 2 +- .../webmail/gmail-element-replacer.ts | 2 +- .../message-export-1869220e0c8f16dd.json | 133 ++++++++++++++++++ test/source/mock/google/google-data.ts | 30 +++- test/source/tests/decrypt.ts | 85 +++++++++++ 12 files changed, 276 insertions(+), 15 deletions(-) create mode 100644 test/source/mock/google/exported-messages/message-export-1869220e0c8f16dd.json diff --git a/extension/chrome/elements/attachment.ts b/extension/chrome/elements/attachment.ts index aa4ffd53993..971b3df6c8c 100644 --- a/extension/chrome/elements/attachment.ts +++ b/extension/chrome/elements/attachment.ts @@ -238,7 +238,8 @@ export class AttachmentDownloadView extends View { }; private processAsPublicKeyAndHideAttachmentIfAppropriate = async () => { - if (this.attachment.msgId && this.attachment.id && this.attachment.treatAs() === 'publicKey') { + // todo: better rely on the preset this.treatAsValue + if (this.attachment.msgId && this.attachment.id && this.attachment.treatAs([]) === 'publicKey') { // this is encrypted public key - download && decrypt & parse & render const { data } = await this.gmail.attachmentGet(this.attachment.msgId, this.attachment.id); const decrRes = await MsgUtil.decryptMessage({ diff --git a/extension/chrome/elements/compose-modules/compose-render-module.ts b/extension/chrome/elements/compose-modules/compose-render-module.ts index 9fdec41e50f..3b826133da0 100644 --- a/extension/chrome/elements/compose-modules/compose-render-module.ts +++ b/extension/chrome/elements/compose-modules/compose-render-module.ts @@ -450,7 +450,7 @@ export class ComposeRenderModule extends ViewModule { private renderReplySuccessAttachments = (attachments: Attachment[], msgId: string, isEncrypted: boolean) => { const hideAttachmentTypes = this.view.sendBtnModule.popover.choices.richtext ? ['hidden', 'encryptedMsg', 'signature', 'publicKey'] : ['publicKey']; - const renderableAttachments = attachments.filter(attachment => !hideAttachmentTypes.includes(attachment.treatAs())); + const renderableAttachments = attachments.filter(attachment => !hideAttachmentTypes.includes(attachment.treatAs(attachments))); if (renderableAttachments.length) { this.view.S.cached('replied_attachments') .html( diff --git a/extension/chrome/elements/pgp_block_modules/pgp-block-render-module.ts b/extension/chrome/elements/pgp_block_modules/pgp-block-render-module.ts index e7f20d03419..8d7b00fd589 100644 --- a/extension/chrome/elements/pgp_block_modules/pgp-block-render-module.ts +++ b/extension/chrome/elements/pgp_block_modules/pgp-block-render-module.ts @@ -293,7 +293,7 @@ export class PgpBlockViewRenderModule { decryptedContent = this.getEncryptedSubjectText(decoded.subject, isHtml) + decryptedContent; // render encrypted subject in message } for (const attachment of decoded.attachments) { - if (attachment.treatAs() !== 'publicKey') { + if (attachment.treatAs(decoded.attachments) !== 'publicKey') { renderableAttachments.push(attachment); } else { publicKeys.push(attachment.getData().toUtfStr()); diff --git a/extension/js/common/api/email-provider/gmail/gmail.ts b/extension/js/common/api/email-provider/gmail/gmail.ts index 8d4d8a5d5eb..75cad4a34a0 100644 --- a/extension/js/common/api/email-provider/gmail/gmail.ts +++ b/extension/js/common/api/email-provider/gmail/gmail.ts @@ -325,7 +325,7 @@ export class Gmail extends EmailProviderApi implements EmailProviderInterface { return { armored: fromHtmlBody, subject, isPwdMsg }; } for (const attachment of attachments) { - if (attachment.treatAs(!!textBody) === 'encryptedMsg') { + if (attachment.treatAs(attachments, !!textBody) === 'encryptedMsg') { await this.fetchAttachments([attachment], progressCb); const armoredMsg = PgpArmor.clip(attachment.getData().toUtfStr()); if (!armoredMsg) { diff --git a/extension/js/common/core/attachment.ts b/extension/js/common/core/attachment.ts index 929ff529c39..10aa499bbd1 100644 --- a/extension/js/common/core/attachment.ts +++ b/extension/js/common/core/attachment.ts @@ -122,13 +122,24 @@ export class Attachment { throw new Error('Attachment has no data set'); }; - public treatAs = (isBodyEmpty = false): Attachment$treatAs => { + public treatAs = (attachments: Attachment[], isBodyEmpty = false): Attachment$treatAs => { if (this.treatAsValue) { // pre-set return this.treatAsValue; } else if (['PGPexch.htm.pgp', 'PGPMIME version identification', 'Version.txt', 'PGPMIME Versions Identification'].includes(this.name)) { return 'hidden'; // PGPexch.htm.pgp is html alternative of textual body content produced by PGP Desktop and GPG4o - } else if (this.name === 'signature.asc' || this.type === 'application/pgp-signature') { + } else if (this.name === 'signature.asc') { + return 'signature'; + } else if (this.type === 'application/pgp-signature') { + // this may be a signature for an attachment following these patterns: + // sample.name.sig for sample.name.pgp #3448 + // or sample.name.sig for sample.name + if (attachments.length > 1) { + const nameWithoutExtension = Str.getFilenameWithoutExtension(this.name); + if (attachments.some(a => a !== this && (a.name === nameWithoutExtension || Str.getFilenameWithoutExtension(a.name) === nameWithoutExtension))) { + return 'hidden'; + } + } return 'signature'; } else if (!this.name && !this.type.startsWith('image/')) { // this.name may be '' or undefined - catch either diff --git a/extension/js/common/core/common.ts b/extension/js/common/core/common.ts index ebb5a73698d..52e36574b66 100644 --- a/extension/js/common/core/common.ts +++ b/extension/js/common/core/common.ts @@ -196,6 +196,11 @@ export class Str { return rtlCount > lrtCount; }; + // the regex has the most votes https://stackoverflow.com/a/4250408 + public static getFilenameWithoutExtension = (filename: string): string => { + return filename.replace(/\.[^/.]+$/, ''); + }; + private static formatEmailWithOptionalNameEx = ({ email, name }: EmailParts, forceBrackets?: boolean): string => { if (name) { return `${Str.rmSpecialCharsKeepUtf(name, 'ALLOW-SOME')} <${email}>`; diff --git a/extension/js/common/core/mime.ts b/extension/js/common/core/mime.ts index 781df972f4b..c2736bf1cab 100644 --- a/extension/js/common/core/mime.ts +++ b/extension/js/common/core/mime.ts @@ -75,7 +75,7 @@ export class Mime { } for (const file of decoded.attachments) { const isBodyEmpty = decoded.text === '' || decoded.text === '\n'; - const treatAs = file.treatAs(isBodyEmpty); + const treatAs = file.treatAs(decoded.attachments, isBodyEmpty); if (treatAs === 'encryptedMsg') { const armored = PgpArmor.clip(file.getData().toUtfStr()); if (armored) { @@ -258,9 +258,9 @@ export class Mime { contentNode = Mime.newContentNode(MimeBuilder, Object.keys(body)[0], body[Object.keys(body)[0] as 'text/plain' | 'text/html'] || ''); } else { contentNode = new MimeBuilder('multipart/alternative'); - for (const type of Object.keys(body)) { + for (const [type, content] of Object.entries(body)) { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - contentNode.appendChild(Mime.newContentNode(MimeBuilder, type, body[type]!.toString())); // already present, that's why part of for loop + contentNode.appendChild(Mime.newContentNode(MimeBuilder, type, content!.toString())); // already present, that's why part of for loop } } rootNode.appendChild(contentNode); @@ -306,9 +306,9 @@ export class Mime { rootNode.addHeader(key, headers[key]); } const bodyNodes = new MimeBuilder('multipart/alternative'); - for (const type of Object.keys(body)) { + for (const [type, content] of Object.entries(body)) { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - bodyNodes.appendChild(Mime.newContentNode(MimeBuilder, type, body[type]!.toString())); + bodyNodes.appendChild(Mime.newContentNode(MimeBuilder, type, content!.toString())); } const signedContentNode = new MimeBuilder('multipart/mixed'); signedContentNode.appendChild(bodyNodes); diff --git a/extension/js/common/core/msg-block-parser.ts b/extension/js/common/core/msg-block-parser.ts index 87b788636b3..b1bc7be7d22 100644 --- a/extension/js/common/core/msg-block-parser.ts +++ b/extension/js/common/core/msg-block-parser.ts @@ -82,7 +82,7 @@ export class MsgBlockParser { blocks.push(MsgBlock.fromContent('decryptedHtml', Str.escapeTextAsRenderableHtml(Buf.with(decryptedContent).toUtfStr()))); // escaped mime text as html } for (const attachment of decoded.attachments) { - if (attachment.treatAs() === 'publicKey') { + if (attachment.treatAs(decoded.attachments) === 'publicKey') { await MsgBlockParser.pushArmoredPubkeysToBlocks([attachment.getData().toUtfStr()], blocks); } else { blocks.push( diff --git a/extension/js/content_scripts/webmail/gmail-element-replacer.ts b/extension/js/content_scripts/webmail/gmail-element-replacer.ts index 76a5ad7012e..8e45220a430 100644 --- a/extension/js/content_scripts/webmail/gmail-element-replacer.ts +++ b/extension/js/content_scripts/webmail/gmail-element-replacer.ts @@ -432,7 +432,7 @@ export class GmailElementReplacer implements WebmailElementReplacer { attachmentsContainerInner.parent().find(this.sel.numberOfAttachments).hide(); let nRenderedAttachments = attachmentMetas.length; for (const a of attachmentMetas) { - const treatAs = a.treatAs(isBodyEmpty); + const treatAs = a.treatAs(attachmentMetas, isBodyEmpty); // todo - [same name + not processed].first() ... What if attachment metas are out of order compared to how gmail shows it? And have the same name? const attachmentSel = this.filterAttachments( attachmentsContainerInner.children().not('.attachment_processed'), diff --git a/test/source/mock/google/exported-messages/message-export-1869220e0c8f16dd.json b/test/source/mock/google/exported-messages/message-export-1869220e0c8f16dd.json new file mode 100644 index 00000000000..49b1818e8f9 --- /dev/null +++ b/test/source/mock/google/exported-messages/message-export-1869220e0c8f16dd.json @@ -0,0 +1,133 @@ +{ + "acctEmail": "ci.tests.gmail@flowcrypt.test", + "full": { + "id": "1869220e0c8f16dd", + "threadId": "1869220e0c8f16dd", + "labelIds": ["IMPORTANT", "CATEGORY_PERSONAL", "INBOX"], + "snippet": "-----BEGIN PGP MESSAGE----- Version: ProtonMail wV4DeWfgCtVtdnoSAQdAPNQhPJG8if4F6R6Dneng7TfppSVPQYHsKYCqoKKD 9W8wDO6xf08jS+Sn7QJcs/N/5so8bfppkTmx9xgEly5JIhwyrcIGp7R/ClN6 0hW9YzzB0sHjAeNkIAPLOMRhW+", + "payload": { + "partId": "", + "mimeType": "multipart/mixed", + "filename": "", + "headers": [ + { + "name": "Date", + "value": "Mon, 27 Feb 2023 09:07:46 +0000" + }, + { + "name": "To", + "value": "ci.tests.gmail@flowcrypt.dev" + }, + { + "name": "From", + "value": "schlemazle@proton.me" + }, + { + "name": "Subject", + "value": "Inline signed and encrypted" + }, + { + "name": "MIME-Version", + "value": "1.0" + }, + { + "name": "Content-Type", + "value": "multipart/mixed; boundary=\"b1_APtjrArD3xyvepenMGInm3lxJB3YfIvNBM8MvjwSkc0\"" + } + ], + "body": { + "size": 0 + }, + "parts": [ + { + "partId": "0", + "mimeType": "text/plain", + "filename": "", + "headers": [ + { + "name": "Content-Type", + "value": "text/plain; charset=utf-8" + }, + { + "name": "Content-Transfer-Encoding", + "value": "base64" + } + ], + "body": { + "size": 1154, + "data": "LS0tLS1CRUdJTiBQR1AgTUVTU0FHRS0tLS0tDQpWZXJzaW9uOiBQcm90b25NYWlsDQoNCndWNERlV2ZnQ3RWdGRub1NBUWRBUE5RaFBKRzhpZjRGNlI2RG5lbmc3VGZwcFNWUFFZSHNLWUNxb0tLRA0KOVc4d0RPNnhmMDhqUytTbjdRSmNzL04vNXNvOGJmcHBrVG14OXhnRWx5NUpJaHd5cmNJR3A3Ui9DbE42DQowaFc5WXp6QjBzSGpBZU5rSUFQTE9NUmhXK0F2WW41aEx3UXphZWNBK0pmbXZIY0pzWlZESlNVbGxTNUUNCk9ENnBUdUtHb0tVUEF1RGdpbkF5cXVvRlI4WlFOSVFwUUk5ZUt5U2JXMXpWemNMWmVsMS9XeEZ4VWdXZQ0KTndFMHhRUWl2Kys4Z0FWcUQ1UkJEZDZGdjY5RlpCMVBNbHc1QmpDaTdpQnp3VXZzZ3UwVW1nZFErZ1ozDQplSTZXMkxSTVZYUUNEd0t3OTcxZDBMMWpxNmZEYmtLTklYVHVRbEY4b2xXeVRmd20zK3BYdmdidVFCdEkNCmhkaW9ndWEwcElEQkdQbDlScmdENFNUcjJnTUJFMk8yWWVJZG5NQVVWZE5ZelVSOUFxYkpnQm5NdTU2Lw0KOHJkcS9oTFpRWEpyL3hzdTVEeUgxbkd1Z1JLU0Y2dDVkSlpZSkQvN1hNNENKWkJ6OHZrWENjcTdtTmdSDQp3MWsrMGZZVUJjeXNxWFFNdTNOWlo5OVU0NHQxY25WcW9KNnowblFHSmJLZGhIditFQTMxU1VpV3lJQnANCmxWOUVnTmViM0s4TG9KUE9icGdqVWswTjJuS0JhRXl4UDhRZ2FDQ1psajV6ZDVYbEtFRE5IdUMzR2kyUw0KbkQvYmt4Y2ZsTkhsWkR2MGIxWEdNcUlCZExEalVXTUV2ZXdzR3VwdFRBQ25IazR4SDB6MWVRckNNT3pPDQphbHkrYWY4anRFMVo4NDBMbzJRb1U3M2VEUjdaVCtlV2hOQ1hYVDNSZ2w2VmVSRWRteVp2VG1FTXVPMkINCmluTG91MU1JeWxoc1lPZC9vVzcwUW9OcUtMU3EzRG9nOElNM2pqaGpNN0s0ZEZBVFF0cnVaWC9BVXFRSg0KNG00VDZRclBEL21lOFR5SzBRV1Y0UzREZGJhVVVxUVViUndKa2hIN0d6VGxmSDVHNnQycnFmaWRyczhjDQp4bkVtSXZvVUc3Wkp0UEFtWW9USlRDZ24zOHc2SWMxVElMTWZKRFlQMWZkYjI5S25lZXpOSHI1QkwzR08NCndmbTZ1aTM3VGZTNmMvaFI2WDEvalB6dDQ0R09Yb3l0N0RnaFgvVXFYcTJ0cDJjcjFBTUhRWlEwSXFxTA0KdUpEakVhWHZpOHFzZStvRGdTWityaDRQNEsrL01vS1phdUZwOUtrYjZjd0VEU2JvUkxZSFFOYkdOL25xDQpQZkJYN0hDN1N6dXoNCj1WUGd5DQotLS0tLUVORCBQR1AgTUVTU0FHRS0tLS0tDQo=" + } + }, + { + "partId": "1", + "mimeType": "application/octet-stream", + "filename": "publickey - schlemazle@proton.me - 0xA5140005.asc.pgp", + "headers": [ + { + "name": "Content-Type", + "value": "application/octet-stream; name=\"publickey - schlemazle@proton.me - 0xA5140005.asc.pgp\"" + }, + { + "name": "Content-Transfer-Encoding", + "value": "base64" + }, + { + "name": "Content-Disposition", + "value": "attachment; filename=\"publickey - schlemazle@proton.me - 0xA5140005.asc.pgp\"" + } + ], + "body": { + "attachmentId": "ANGjdJ9pRNT3HoxqlbhmP4GxrLjMYvpaEX6PFy-MY0IdV0Naq9mneeDsesG3uIOQAx4_DIWU86VHmFdB1eST67tBgRBcQIjfunLDrcSkijWQmcJXrZ225LRBCvmNq3vQwRoDqen4PVYfFdlasrHLwZ4oh5Cj4wpRZd5ItJl6BuUdvVPmNunbd5cGObdjpQEtSDQnWdpJjbK7XhUOrCisxjakoT2F0onnYZkf7jIvdVP_wN0L4QogsBYahSyq07mkAeZR2NgQowa2O4-_xXakzO1FbkN1-xVQwX31Td3-8I7bv5snlLtV8QwgK3-hk403lJ4nTTUJ9UqxVc5no65r7SnBDwD_xZhO7oClVCK371VLpQsy0bhMZVWgcbya2VfwvIQlFl6_6OOusQRU0vnE", + "size": 3291 + } + }, + { + "partId": "2", + "mimeType": "application/pgp-signature", + "filename": "publickey - schlemazle@proton.me - 0xA5140005.asc.sig", + "headers": [ + { + "name": "Content-Type", + "value": "application/pgp-signature; name=\"publickey - schlemazle@proton.me - 0xA5140005.asc.sig\"" + }, + { + "name": "Content-Transfer-Encoding", + "value": "base64" + }, + { + "name": "Content-Disposition", + "value": "attachment; filename=\"publickey - schlemazle@proton.me - 0xA5140005.asc.sig\"" + } + ], + "body": { + "attachmentId": "ANGjdJ8ObnISqVY0JigN1hg_P91vvKZXr6dr80PrwuuPtOhSvx4PPXRgV6T5hKGO7_3lfwh_pQKTWpUmFwUMhetsesG_kflx2i3WrkK1xkoEFSawR42PrXO_B4wXBamt3mSbT4G7ZZPTE98Ge2GUValy4y04aJEKUgRCcuWGs_t5vmoAaYSuG5WYSWUaFdECRudxUY8PdChMETMLMbb4QcAupoB0T3H4qVMoNGre8AMWfE1iz9jXxSIcd6EBuLQmzSw2ab1r_16JLtJeiTSSIyjo-vv1szsBAdhliKiff1CdMo4cH4G5P89Z9pIqhkuBISwHTGDzmdiWGFLfiFoLry4VLQjT0wgDph9XFig8kpn2-4dvz6aUlkuuglc528ZtzwmLFGhnaJTTn0aa-uMF", + "size": 566 + } + } + ] + }, + "sizeEstimate": 11617, + "historyId": "2491472", + "internalDate": "1677488866000" + }, + "attachments": { + "ANGjdJ9pRNT3HoxqlbhmP4GxrLjMYvpaEX6PFy-MY0IdV0Naq9mneeDsesG3uIOQAx4_DIWU86VHmFdB1eST67tBgRBcQIjfunLDrcSkijWQmcJXrZ225LRBCvmNq3vQwRoDqen4PVYfFdlasrHLwZ4oh5Cj4wpRZd5ItJl6BuUdvVPmNunbd5cGObdjpQEtSDQnWdpJjbK7XhUOrCisxjakoT2F0onnYZkf7jIvdVP_wN0L4QogsBYahSyq07mkAeZR2NgQowa2O4-_xXakzO1FbkN1-xVQwX31Td3-8I7bv5snlLtV8QwgK3-hk403lJ4nTTUJ9UqxVc5no65r7SnBDwD_xZhO7oClVCK371VLpQsy0bhMZVWgcbya2VfwvIQlFl6_6OOusQRU0vnE": { + "data": "wV4DeWfgCtVtdnoSAQdA4kGwTDSb1fd4v2M6YCRcuX2KHNvHdZI5ued1okohXwUw5FaloTIHJIiOx7FE8-JM8hai6KscbNMLfYWGCP2H9xv-CYS9J4nvZ1OuwJWDVbQJ0su4AajhNdmX8to5tBecKw-vxSsfASKChm4mpzULjxqRb--t5aQXwENDS-5YteWwXreKGyMSWfW4V5CIR3NxruzzzFnuNyjxkPw_-DZW0rZx8225IdA5lGF6PeYh74Xdrl8Aq9C2IxpgxPTWtaAxpHJ69VfMCm2tTKOOfU4j4G_14nl9kGxMiUJuL-NQ6c9Yj3kVlTdc7Q5Cxas7szh4D4uYzsoIHioWUsbwpJgZIursqskj0O-Q2oE45ySo-VT0Eq82t2bcEZo7oH3Clb5-EdZHPWMZHGcJoiRJyGcU76qYjC8zWrsqSotZtPlRTteujIk_d82172tkd1s7gjKWHZ_cb4Pm1tET3akPXWrbcnt1Q0hyK33tjZ9i8peKdAdOcy3A8VS5EBKbP62074Lnc-jXTuRjiwMi7iBv6sVxII5wbE-58Pbt0Jg3WnnINdWPiakNcYIrW94KLjwgWUmzkGQNBV6ISKm2qKdR7KpkDBN3v5NRCFPmimvqgT1dfAcol7oVHVNIAO4iyTuiX7oyN7-GyGkmvMovLDGzn_rD2r88jfFKEBXsYe5GOUCH4wIzS0G5SzKWBTA5PrQm2KicRkdIceYFk9dh7EErvF201MuKc--Sok1cN_CE8PSSSC14y25TqOq0GwvehPrnmkyi8rVwKazwLhBqoSaxes78Me99I_aU7HvY2HZA1_xSVdFsGRvjKN1Q9N-wWgbnE4RDXcVq6l5WW61kRLyAHFk_9_b6NSjq6618dMrIM2pilu3LBB0Jk2Sic7rMRvfW9bFk4nkClIr6hdudBJPBh_dQUKhJny8gCmjbybLQ_4hw3Iv0bhw00De4uvEJAgKyOX5uBkc3bE78qBa1RHxjGxcNi8Fb5jgow4rzLQn9xErvtESMwH3pmCwfEW2tFnyYtFgk6lkdp6uQR7T9lLwaj_R8FSN9fFN1N3oY1YjpzV2CFM7iifMCLbotts8mrJzJcXgE3_iUQLVKgUllAF0ey5DDPwjxcbOMcm_9qAFqfbbkb5c9x7BFFdYJeJ8zAyQoJOVZxBD_rKWtS1izfuy5fhicokRpMIq6P0NPTcD6Q1PWG93852iTlZYE_TOqp_G8Tc9HpQE5cRQChMVzV_4pHeqqhWn8-09IvGvfrq5Ew_zuqFXUGyjQszBHyPCwXBHJ8dMifkZZlyyG2Gius9IRM8Snu0XU6hfE3WvRu4KZDvNYs3J57RCtUGVI9hKI1yjgJWpjCC4S851JgJZUFZVySiT7u4dcJE6Cr66zcM2NVDF_1jCQsMTjVrMxVHLu2ddCn3QS1DTZcA8nqCYcafVPwklopnM_mJN5L3z-uTQIlfc9DnB0zTeBU-j7jGumAtoMfNkvsd24_3H5-0d8evzbmhRqCmIouxgfSYyqESRw29D6BFdW1L-a9AjMFONeChtKNoPA-fJAUBV8TneVapkiam4jPfzUyNt592D8RIv2byZj1b2fVsmroeyPTabwpHdzNdLV99WMCcBiSiFnYa_jH_499zzy4Qur2FICzVVOZoksJ2GdiY_QfSbtk2C9_UK0SRgV3ymqoGknPk6QRQizH5Bo1iqDpelY64J3XoHulr8BPx89hDpMusS9IJeqNx1WacdPgaJWoMY1ghFHMZBWRNWxM1DhswjBZjLwP0h-Fuf8nolURv_oQAAjaBX2s1nUKAUdeGhsVgn0LcNjJtNiNo-UUOlcrKwBo3TEKwKDHyEtw_81zvtdseyyJgmDo5K_UcirmcsLiOzYOOsLzl6d9LQ_pXIxkv5NUtUUlqL2I7kw4UNUCT56Ms1Cd25KDy8cVb7hFHQxJvkxvYYhoxurFDfPplI3sK1IVNasSsJZtf-qaGI6_gewTWdRG6SoVm9Y8wt71Tm_83dIRHWDdXHF_75q4bekbQ94o6m7KTYtNN0ULnPZLk1NNy971Sbgf1A28-vPHRXdgG-q8zT7soT6pO-LWEaZCHBsvQy3u30eTWG9weJauwt4LEPNSH2-uEZdD5nteLNUujR9zhQp0v6do5h69-RIlUKcQGWnh_rIs8QMLNxq164ZqBC3h30a-gVjhxUVyrz6-ETR2jdt4eIEZ9p-TqkmY-usqlvbIKaHEavOy3KpR3cFUO2hOHA5-oaqGWLUJRStKKSbcu1cKDAVLiSakS1egAtAsbzcLunEKpP69-EpyXexlnx0mPfzz1xFt2hy5kY_FQXjSvJsxUlsCqUy6QtTaz9rKx0Uli9RRfsZzYhKQRjcViHRVPuna-8FlIrN-J5qZtaG8HEboFNkOpmWVF0XnH-ZKlppA5hI_hDr7aO0FFJ7qOSXLcB6TrlMIMyoMhONqfnEfkyIe8J6Ri71Yt2qc7KjpMj5rjrVkN-TUWYOn65YFT_e4Fz5qVjsNh-WrjcE5qdrvZZOimcj_FmQmWMVgW39rcscgHZRS5Ehp4ak0gAqYhyhoV-_T3ADwSVoc5K3OxJ6dLT9WHI6L9tZ60XdFIyhWnr4-BS3rP9nSUNuPkVcx2QfslHSESX-GBs0sQh5Yk_pxq2zgW83ZQjRjgvp0x4DBkp8p2SnOSdE9eHa2LZr1nZiVpLMI3ALDxhXd9SVUOVxcAS7A_y97OMHY9AA4Fk7zDxQAUyARUPGgmUcCLrEGSyyGZzTIJz-mcd2ZK2ReYcos-nHxPO-EFVddVP1qkXmMHRytBnjWjngKZPFgCY3a2U64PicJxymjq_e-jVh7uMoKjcpVQxCxZNwdwHzNf37NXERbeQkV5hPPc-IH3YFGlxowXPLTZCx6tCXHrd9uvjGTgr9yrTi65I9cIfvYHW31yKtor62IqgYWvrrckoiFGNgu1L99-auDzJwxZSSksBZnGCT7VYfhmgiGX61j1x3CBiHq1v53YtMX9nx-YXkFXHjcJ_rZhJOyf4waKOnqSmyWLYUjbQAezuZOvULbwPZoHNWK36fZWezoEXP8Pz2GwahZ2UdPZHtChQBwMYEHv1lnl4EJmyhul9G6KW4W7gforI4yVHv8zzy4X0dGb0-mwYgUvS8BuPyiaa3kPh4MTR_mBGuBiXDmQeu7lNz4eLhXy2o-zDeJytSmtkBM-D_XbzlEUeWMouxpmQN56cysJSTcenLPWwpYQQoOwQ_ZfuqUSo4d9adFPTKSCiSNLITBV_5kSc2Go6TkVZ3_AbNniwcjs8wxjpx2b7Q-GLLqSMDTFyN_Y76yBB00sX9x0q7wW6akZ8fTTSEKaxCyLVch1x1UUD4LZMwUWQcWQzaMU5bAXJnZsnXNPZJsZ6Xzf2V5g28n3TS2G_VCysWVNn93VzcOY2bVoJUwPJIiT_H0NfC5HId4QsSeOKg317DzOYrHTJs8cyMO0E1yM-9XhAfzhlUFwi_6YMP1UuV7kCkI1rZ2AMR3I_6_QAT9YP0rnRlAyvLjRpnEVtDTLuKDWhJYY8ACnh2_jTanrU0L_ShI2pbkc6L84wjHZPzCUsE05x5j9gExDiwGVqOZ5FkIuY5jimXUTtyCW7YKruFtkTwHyxlAHFY4gek_F_lqcm1vcmhi3L2rQb6pHIwwkRpSoMSEBiRsRbjrkvwFJnnKNF4VbbnQQWeVLHVRR3vVc6uWaLULcaUXSpRvIL4S9IUGe2lVOveQeBDF4exW27BiUXSFByxHvFFH8Z3tgTgte4Wi0XPi2ZJ4flUBlSnJZrdg3F9Y92_Hg2HzBmOPZlWTXTFZR54cOIjNjF-hEr8zulha1wFsPz1ygOBmp6ENWxxhBNo1K-Cp2O6Ik72HLHLAj6L8T6heuX6Tmr2mgQl87EgpGGEV1EObbItEh_xCCkAjoDaJPgfDOFNcIhgI608FoWJX98dAx4gRLoxXhtYH_8rV1o5L8ech75UnhIounm_KPa55KjijCIV4q-5dozVrs9y9x4p2tB0tdK-Hl8RJlgpoX3HHfZe23KmrNgAvhMOh25_pE_Wc4AD0CxBn4vVlJCYIM5wKDtlEr3YhhLzCtYo4bIJV-3J-FexP2Ti8z2Wez252NnivdX56ohhOlJbKdJFt0BPs0_XfOKk69vZ4xLF_tJUNkv3vz_R8TDCNaiVvvRckVqdTN8Cemqn-5YhBvdN8V1SslX-tpu2G950HAJ3WAI_J4B72M9-4maAYC1xcRvlv-VZOr30GDf_o7Zd-kmziw-nXMI3DJSUhXHQAeZyjvbQD5PSMtD8J6hNSS9zsSQdXorohWaJVSZMZqAfH4FWW1tMDKdbax8Z-3jsBJwNT21tocRkTj7d5ImOCmu9NzoXqL3t1P6Z9B94", + "size": 3291 + }, + "ANGjdJ8ObnISqVY0JigN1hg_P91vvKZXr6dr80PrwuuPtOhSvx4PPXRgV6T5hKGO7_3lfwh_pQKTWpUmFwUMhetsesG_kflx2i3WrkK1xkoEFSawR42PrXO_B4wXBamt3mSbT4G7ZZPTE98Ge2GUValy4y04aJEKUgRCcuWGs_t5vmoAaYSuG5WYSWUaFdECRudxUY8PdChMETMLMbb4QcAupoB0T3H4qVMoNGre8AMWfE1iz9jXxSIcd6EBuLQmzSw2ab1r_16JLtJeiTSSIyjo-vv1szsBAdhliKiff1CdMo4cH4G5P89Z9pIqhkuBISwHTGDzmdiWGFLfiFoLry4VLQjT0wgDph9XFig8kpn2-4dvz6aUlkuuglc528ZtzwmLFGhnaJTTn0aa-uMF": { + "data": "wsFzBAABCAAnBQJj_HLECRBhbVlrwgZdSBYhBKUUAAVXUrRPueoIlWFtWWvCBl1IAABeiw__ZzonIepMwDlEYE4Lk0pUzt4JVHDFVWq4OwyGg-jSDK1EV0C5qAS-UXHXc10wKhuj43VE7loAbCTbrVxP06j7pnzvSm3cMs9UStgqAYf9D6dQFULlz4KSwJ0MvIThP-3FkfNUUe8aziOIue_meA_ajC98f4rKbIC48Ee5T66krSOh6gGBXRMhsWojJSHEUPI1yGD7NDBr3xKtdvyCufRoIWMXOfED3nSQMZJjJFhJlCxI_3TtmSumVRhaxU8WjV3ceCOcovHhI2YZ2KAL3oOAgcn-AQ79NkWeCWHnqOUJZk1ZCIi5exSr9Jv1NP6tb2nzLwPNDwf4OScLXX3KBZTlr2uqStWPQ1Gjj5ovP-gPzoUchATXM89bGYZVSnJdmTL3gYPmnuXC6GEr5EJK5k0Kc3bVN__ysdx0aHEImY-0LyoVTI_24ULOQm_oUX_Ltty6CgIj40BM2vr8zvJ2oIeYEZwGbszcQip0njJ9ucGDchUjppEBjd7KglYkA30e-UyLfeBggEwGVtELRxDwIZ6G953LQAu_fRezkQ_IlbDjD0mavZv7tvZunV_RGelCmBRj6MH4qjBOReIRuWBlRwoaoP0ugb_Ma6oMOzZiw5bAqRzlcHG95fQNtDWFG50XSK70S_-Fqk7q9RaK3PKJ0Bc5QRMdr1xrpLP5ju0V2saUuOk", + "size": 566 + } + }, + "raw": { + "id": "1869220e0c8f16dd", + "threadId": "1869220e0c8f16dd", + "labelIds": ["IMPORTANT", "CATEGORY_PERSONAL", "INBOX"], + "snippet": "-----BEGIN PGP MESSAGE----- Version: ProtonMail wV4DeWfgCtVtdnoSAQdAPNQhPJG8if4F6R6Dneng7TfppSVPQYHsKYCqoKKD 9W8wDO6xf08jS+Sn7QJcs/N/5so8bfppkTmx9xgEly5JIhwyrcIGp7R/ClN6 0hW9YzzB0sHjAeNkIAPLOMRhW+", + "sizeEstimate": 11617, + "raw": "Delivered-To: ci.tests.gmail@flowcrypt.dev
Received: by 2002:a17:907:785:b0:84c:e73c:ee76 with SMTP id xd5csp2902076ejb;
        Mon, 27 Feb 2023 01:07:54 -0800 (PST)
X-Google-Smtp-Source: AK7set+CTAAC1FC4yY5ufrhJqbE1svs8l+f77bJx1yKLqWojzp5aHjetKD/1eDFtji9YhgYP4L2B
X-Received: by 2002:a05:600c:1d9e:b0:3dc:4042:5c21 with SMTP id p30-20020a05600c1d9e00b003dc40425c21mr18911530wms.6.1677488873820;
        Mon, 27 Feb 2023 01:07:53 -0800 (PST)
ARC-Seal: i=1; a=rsa-sha256; t=1677488873; cv=none;
        d=google.com; s=arc-20160816;
        b=jvQFaQZAbZQgYC3XiQXmIJmUHAktmk+dHy5vBbVHIX/V+GX+Y1fFK4CiNXjJXw7S8o
         UHnHfrLAamQVnXGICWTLZAcxaCx7wbWlZAcorJyAUf2HkNhgPTGRyJhlnZ3M9IufLJel
         /xgmql83OW++ciC82+O+wDDcQK/DlEVz6Ke0TmAp8xB+D4NTaJk8F8uFBYqG0DyIwkBC
         BzHUM73PcBcjjdFc7QOzFwTvhfZv+zJabJ76D5rthvOAh0s4Hmvx7iMralX9SEol9Owh
         iHsQWXBC4t0HO6nwKM8w1qY1XBBtKzoFqDsmFmbKmPgCBMo+j/PXdoTOIE0Eibo+51Wn
         a3qw==
ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816;
        h=mime-version:feedback-id:message-id:subject:from:to:dkim-signature
         :date;
        bh=nm+qsa0EnkQPf5RjXZDKyUrBrR59MkDtaniMHvmE2s0=;
        b=J95QTSvkq6mN1JLD5hPpmsfBCBVxcrDC2y8uXivqTBPsPemJRddlNdPx07QyprTza6
         6ndY+OzWWP3Siq7cu+BeUoe8ih2iLQZxQ4b25TJggbsTyVaQRbcc60VodMGRdh22thFt
         xV0XnnakW0dfkITPIFZtZ1xUeNnxTz6zC8etk9O4zT6MvgxajBX0YGaHSMT64KMD7Vyw
         PqAnzJGc56nVzZqyWf0IEW6sz04aVzSvQqon36nktAqAy29ep8jSx8vFqrIYyBCr2O6f
         +tZMwXIsEbaovP8rw4uxRjxAtPrIX96+FlYoYiw61asIIwMJzOMJoOkPihMVp3XM12rE
         LzMQ==
ARC-Authentication-Results: i=1; mx.google.com;
       dkim=pass header.i=@proton.me header.s=protonmail header.b=PV7hBJYk;
       spf=pass (google.com: domain of schlemazle@proton.me designates 185.70.43.19 as permitted sender) smtp.mailfrom=schlemazle@proton.me;
       dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=proton.me
Return-Path: <schlemazle@proton.me>
Received: from mail-4319.protonmail.ch (mail-4319.protonmail.ch. [185.70.43.19])
        by mx.google.com with ESMTPS id e20-20020a05600c13d400b003dc3f19804dsi5387209wmg.200.2023.02.27.01.07.53
        for <ci.tests.gmail@flowcrypt.dev>
        (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);
        Mon, 27 Feb 2023 01:07:53 -0800 (PST)
Received-SPF: pass (google.com: domain of schlemazle@proton.me designates 185.70.43.19 as permitted sender) client-ip=185.70.43.19;
Authentication-Results: mx.google.com;
       dkim=pass header.i=@proton.me header.s=protonmail header.b=PV7hBJYk;
       spf=pass (google.com: domain of schlemazle@proton.me designates 185.70.43.19 as permitted sender) smtp.mailfrom=schlemazle@proton.me;
       dmarc=pass (p=QUARANTINE sp=QUARANTINE dis=NONE) header.from=proton.me
Date: Mon, 27 Feb 2023 09:07:46 +0000
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=proton.me;
	s=protonmail; t=1677488873; x=1677748073;
	bh=nm+qsa0EnkQPf5RjXZDKyUrBrR59MkDtaniMHvmE2s0=;
	h=Date:To:From:Subject:Message-ID:Feedback-ID:From:To:Cc:Date:
	 Subject:Reply-To:Feedback-ID:Message-ID:BIMI-Selector;
	b=PV7hBJYklHjR66awaJ8D2hPlKSVhAKsrNy7SwGt1TBFLpzLQz/X6u4CkGu8q01kpb
	 m2bQbcCapT+3M3C65QOGsI47eWhaO3odpV2Ec2KHoWGFJTePyPWkaG4YJGxKar3i+N
	 QkXjt61KJC1UP5gQDY96yo6l87mIaOKcUhIKuvr2C2mIJ7zRPswZffrH+TamriWGkg
	 0cFlj9F3KJf42zC7raWUfItggJ6w7cR2oID/GLDWi98n0mm3JMRgpN/5J0Mf5/HykD
	 uPrJzIvhA7NWs+4J1Tx5THV3dvLIyAD9hgfS4lhmSMGHbUSyZK2CfhBQqK8eWwqOFB
	 xiBnHVWJaONug==
To: "ci.tests.gmail@flowcrypt.dev" <ci.tests.gmail@flowcrypt.dev>
From: schlemazle <schlemazle@proton.me>
Subject: Inline signed and encrypted
Message-ID: <9Ej_cH67RvffrOL9kJsqtkyaLPmZpL2SRin7vdEr3_oJcMwTA2hBBFHmswiegJJVk7e33KyXbAU-syOFzkQHZeKFm0NkPSTN0XsBR4rMGEs=@proton.me>
Feedback-ID: 68049325:user:proton
MIME-Version: 1.0
Content-Type: multipart/mixed;
 boundary="b1_APtjrArD3xyvepenMGInm3lxJB3YfIvNBM8MvjwSkc0"

This is a multi-part message in MIME format.

--b1_APtjrArD3xyvepenMGInm3lxJB3YfIvNBM8MvjwSkc0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: base64

LS0tLS1CRUdJTiBQR1AgTUVTU0FHRS0tLS0tDQpWZXJzaW9uOiBQcm90b25NYWlsDQoNCndWNERl
V2ZnQ3RWdGRub1NBUWRBUE5RaFBKRzhpZjRGNlI2RG5lbmc3VGZwcFNWUFFZSHNLWUNxb0tLRA0K
OVc4d0RPNnhmMDhqUytTbjdRSmNzL04vNXNvOGJmcHBrVG14OXhnRWx5NUpJaHd5cmNJR3A3Ui9D
bE42DQowaFc5WXp6QjBzSGpBZU5rSUFQTE9NUmhXK0F2WW41aEx3UXphZWNBK0pmbXZIY0pzWlZE
SlNVbGxTNUUNCk9ENnBUdUtHb0tVUEF1RGdpbkF5cXVvRlI4WlFOSVFwUUk5ZUt5U2JXMXpWemNM
WmVsMS9XeEZ4VWdXZQ0KTndFMHhRUWl2Kys4Z0FWcUQ1UkJEZDZGdjY5RlpCMVBNbHc1QmpDaTdp
Qnp3VXZzZ3UwVW1nZFErZ1ozDQplSTZXMkxSTVZYUUNEd0t3OTcxZDBMMWpxNmZEYmtLTklYVHVR
bEY4b2xXeVRmd20zK3BYdmdidVFCdEkNCmhkaW9ndWEwcElEQkdQbDlScmdENFNUcjJnTUJFMk8y
WWVJZG5NQVVWZE5ZelVSOUFxYkpnQm5NdTU2Lw0KOHJkcS9oTFpRWEpyL3hzdTVEeUgxbkd1Z1JL
U0Y2dDVkSlpZSkQvN1hNNENKWkJ6OHZrWENjcTdtTmdSDQp3MWsrMGZZVUJjeXNxWFFNdTNOWlo5
OVU0NHQxY25WcW9KNnowblFHSmJLZGhIditFQTMxU1VpV3lJQnANCmxWOUVnTmViM0s4TG9KUE9i
cGdqVWswTjJuS0JhRXl4UDhRZ2FDQ1psajV6ZDVYbEtFRE5IdUMzR2kyUw0KbkQvYmt4Y2ZsTkhs
WkR2MGIxWEdNcUlCZExEalVXTUV2ZXdzR3VwdFRBQ25IazR4SDB6MWVRckNNT3pPDQphbHkrYWY4
anRFMVo4NDBMbzJRb1U3M2VEUjdaVCtlV2hOQ1hYVDNSZ2w2VmVSRWRteVp2VG1FTXVPMkINCmlu
TG91MU1JeWxoc1lPZC9vVzcwUW9OcUtMU3EzRG9nOElNM2pqaGpNN0s0ZEZBVFF0cnVaWC9BVXFR
Sg0KNG00VDZRclBEL21lOFR5SzBRV1Y0UzREZGJhVVVxUVViUndKa2hIN0d6VGxmSDVHNnQycnFm
aWRyczhjDQp4bkVtSXZvVUc3Wkp0UEFtWW9USlRDZ24zOHc2SWMxVElMTWZKRFlQMWZkYjI5S25l
ZXpOSHI1QkwzR08NCndmbTZ1aTM3VGZTNmMvaFI2WDEvalB6dDQ0R09Yb3l0N0RnaFgvVXFYcTJ0
cDJjcjFBTUhRWlEwSXFxTA0KdUpEakVhWHZpOHFzZStvRGdTWityaDRQNEsrL01vS1phdUZwOUtr
YjZjd0VEU2JvUkxZSFFOYkdOL25xDQpQZkJYN0hDN1N6dXoNCj1WUGd5DQotLS0tLUVORCBQR1Ag
TUVTU0FHRS0tLS0tDQo=

--b1_APtjrArD3xyvepenMGInm3lxJB3YfIvNBM8MvjwSkc0
Content-Type: application/octet-stream; name="publickey - schlemazle@proton.me - 0xA5140005.asc.pgp"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="publickey - schlemazle@proton.me - 0xA5140005.asc.pgp"
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--b1_APtjrArD3xyvepenMGInm3lxJB3YfIvNBM8MvjwSkc0
Content-Type: application/pgp-signature; name="publickey - schlemazle@proton.me - 0xA5140005.asc.sig"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="publickey - schlemazle@proton.me - 0xA5140005.asc.sig"

wsFzBAABCAAnBQJj/HLECRBhbVlrwgZdSBYhBKUUAAVXUrRPueoIlWFtWWvCBl1IAABeiw//Zzon
IepMwDlEYE4Lk0pUzt4JVHDFVWq4OwyGg+jSDK1EV0C5qAS+UXHXc10wKhuj43VE7loAbCTbrVxP
06j7pnzvSm3cMs9UStgqAYf9D6dQFULlz4KSwJ0MvIThP+3FkfNUUe8aziOIue/meA/ajC98f4rK
bIC48Ee5T66krSOh6gGBXRMhsWojJSHEUPI1yGD7NDBr3xKtdvyCufRoIWMXOfED3nSQMZJjJFhJ
lCxI/3TtmSumVRhaxU8WjV3ceCOcovHhI2YZ2KAL3oOAgcn+AQ79NkWeCWHnqOUJZk1ZCIi5exSr
9Jv1NP6tb2nzLwPNDwf4OScLXX3KBZTlr2uqStWPQ1Gjj5ovP+gPzoUchATXM89bGYZVSnJdmTL3
gYPmnuXC6GEr5EJK5k0Kc3bVN//ysdx0aHEImY+0LyoVTI/24ULOQm/oUX/Ltty6CgIj40BM2vr8
zvJ2oIeYEZwGbszcQip0njJ9ucGDchUjppEBjd7KglYkA30e+UyLfeBggEwGVtELRxDwIZ6G953L
QAu/fRezkQ/IlbDjD0mavZv7tvZunV/RGelCmBRj6MH4qjBOReIRuWBlRwoaoP0ugb/Ma6oMOzZi
w5bAqRzlcHG95fQNtDWFG50XSK70S/+Fqk7q9RaK3PKJ0Bc5QRMdr1xrpLP5ju0V2saUuOk=

--b1_APtjrArD3xyvepenMGInm3lxJB3YfIvNBM8MvjwSkc0--

", + "historyId": "2491472", + "internalDate": "1677488866000" + } +} diff --git a/test/source/mock/google/google-data.ts b/test/source/mock/google/google-data.ts index 9f93a85039d..706f5045f14 100644 --- a/test/source/mock/google/google-data.ts +++ b/test/source/mock/google/google-data.ts @@ -6,6 +6,7 @@ import { readdir, readFile } from 'fs'; import { Util } from '../../util/index'; import { ParseMsgResult } from '../../util/parse'; import { Buf } from '../../core/buf'; +import { Xss } from '../../platform/xss'; type GmailMsg$header = { name: string; value: string }; type GmailMsg$payload$body = { attachmentId?: string; size: number; data?: string }; @@ -217,18 +218,43 @@ export class GoogleData { public static getMockGmailPage = async (acct: string, msgId?: string) => { let msgBlock = ''; + let attachmentsBlock = ''; if (msgId) { /* eslint-disable @typescript-eslint/no-non-null-assertion */ const payload = (await GoogleData.withInitializedData(acct)).getMessage(msgId)!.payload!; const fromHeader = payload.headers!.find(header => header.name === 'From')!; const fromAddress = fromHeader.value!; - const htmlPart = payload.parts!.find(part => part.mimeType === 'text/html')!; - const htmlData = Buf.fromBase64Str(htmlPart.body!.data!).toUtfStr(); + let htmlData: string; + const htmlPart = payload.parts!.find(part => part.mimeType === 'text/html'); + if (htmlPart) { + htmlData = Buf.fromBase64Str(htmlPart.body!.data!).toUtfStr(); + } else { + const textPart = payload.parts!.find(part => part.mimeType === 'text/plain')!; + const textData = Buf.fromBase64Str(textPart.body!.data!).toUtfStr(); + htmlData = Xss.escape(textData); + } + const otherParts = payload.parts!.filter(part => !['text/plain', 'text/html'].includes(part.mimeType!)); + if (otherParts.length) { + attachmentsBlock = + `
${otherParts.length} Attachments
+
` + + otherParts + .map( + part => ` +
+ ${Xss.escape(part.filename!)} +
+ ` + ) + .join('') + + '
'; + } /* eslint-enable @typescript-eslint/no-non-null-assertion */ msgBlock = `
Mock Sender
${htmlData}
+ ${attachmentsBlock}
`; diff --git a/test/source/tests/decrypt.ts b/test/source/tests/decrypt.ts index af50d6fc59f..a7b829715bd 100644 --- a/test/source/tests/decrypt.ts +++ b/test/source/tests/decrypt.ts @@ -892,6 +892,91 @@ XZ8r4OC6sguP/yozWlkG+7dDxsgKQVBENeG6Lw== }) ); + test( + 'decrypt - protonmail - PGP/inline signed and encrypted message with pubkey - pubkey signature is ignored', + testWithBrowser('ci.tests.gmail', async (t, browser) => { + const acctEmail = 'ci.tests.gmail@flowcrypt.test'; + const dbPage = await browser.newExtensionPage(t, 'chrome/dev/ci_unit_test.htm'); // todo: url? + // add the pubkey of the sender + await dbPage.page.evaluate( + async (pubkey: string) => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const key = await (window as any).KeyUtil.parse(pubkey); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + await (window as any).ContactStore.update(undefined, 'schlemazle@proton.me', { pubkey: key }); + }, + `-----BEGIN PGP PUBLIC KEY BLOCK----- + +xsFNBGP8b1IBEACvY95nEYEFC9JEeP475BY4FHDZK8HLNSMbxskQdcRauwyu +4JrVnXou/8QftKZz3ayUFlK0mRy5aGg+D1mcN2EDufwA7fuOowGZMr9WqxOl +mR+mX/B7yc8FfMLsHZ8k9T3Fw+s/Pm4ttGAhuAIJd0Lyo6YLgZTah/HM+S28 +PQHEpfOAgmbNvb7WaLQwh0oTMGMLosXHCh8NOvSW9TS4zB+bMhEnfF53+XM5 +RUZsDQSs8p59itcn7kU3L45CK8Vjg6S49miGpZ6xPDJ+fKN/ZhLzTkT5aHVv +OjUJLCCXpYnG8uqU/1xXLdANM1FNKHTk4EuuGiHFA6XYeiPVwx/dNw+IvePR +cbgtkGoMfdet4ywfUfrFydFUuXHf59XJoaS0tk3nU/gRC0fRgeSwdQamZ1is +xAsyprt9pPSHmVVCyFEOyBND/8lilB8ZL5/1blOBgrZGj1zMRnUJHDjs6TkP +hAqw9dL6j+4pN2o3gjUFcbPBx9LfbfWbrqaZMWwkDb/ysA4pSCeLBnGYIw78 +hDLcijCe+RJLlu2snHfRqcCI2wab+MMUHC11xTp5lzA4u0eoqufp+LOudDXz +zawsdjz+ojRxf0YiEd4jYVkI9/qP4WVkO3QmJPNWrDw3XDjSSvwpz5elrE0l +24pOH1pGLN/6CDZp0h1wNtLhEAX0aIf/kcypjwARAQABzStzY2hsZW1hemxl +QHByb3Rvbi5tZSA8c2NobGVtYXpsZUBwcm90b24ubWU+wsGKBBABCAA+BQJj +/G9SBAsJBwgJEGFtWWvCBl1IAxUICgQWAAIBAhkBAhsDAh4BFiEEpRQABVdS +tE+56giVYW1Za8IGXUgAAJsVEACCwO90h/jfWK0KJ203z9fRnDT+iX1ahTEn +IvzsGUXwo5opTK8k8fz/wZDNl9itrd9c65fWOkeiVYM0jDINxeEvhTwJwTqY +yic+yfnnH9EMIBlUCd36dh+xIK2GwdmtdqYBDwyKzOqWGRQb3zE9I6aHajI7 +yzaJyxEBLv2mrNId2Vtrz12JbJJv4RO4Dv3sZPJoJfbkuV5xg6uEUtIk9aAM +iDdNUhkw3JvPq/cKnh6AAHPBSxxV8dRXOTgIgf5ncoXNodyGtbpPzis7Hxz+ +5KwoyfkDzQYtAKVpXRlyh+F06C5jUCUvmoFxZoH40OfSBpHKcu4EKqIBh28b +oI0ofxQCIWvMiYkcfYeKjnwg25MdpYvatxS4NQVegzq0DhiVEisO0cKtKawn +VGPXTUsevGswICsJBS9DRv3FMkGJIDqR1S/E2GWZa3+U6A4TwPrcmzfXvzqQ ++vxPdq03fMExIHeYlcnexypFUN9K/LtLgXEG34/LXXI9gNBjyfYUwjLZAueh +YqsMqM05waJ3ZlgbZEsePK0LMfRO9g6lq7LsFtB0q28u5IwK6M7Fnox5bzQr +hIDXAFpU4rw7GWWKF71Ujw9r6P8rY0RcRaW2RGlY8+tQvxnSHcK/Ki6ozlWQ +Cv5blHur/EmTO9neO84dHspC8d5Ggwv8qDFR5deohm/TLlkh3c7BTQRj/G9S +ARAAv8AZdsZwWtxE7+NMX+CAurhFwvIxeDOjrXe5LeBhzIEUVXkTNIpf/udq +BfH34LcemmoB6pPnpaxS0Grg/a8FLk7TRU2WkucrnbT8nuv9GihJCyucC9Co +5ZoVmNwIFrxaSkC5oQvsQoytUyk5TJ95egTs7qcsICouCpcIJfM+seNtpc26 +XDWVrf+L3FWGK47LBExHhUrIbgEiUjLfHwCGZEQsctfTIs4W2PJhfF/egiPE +DDLhfWgDQAplZrr6vZlCwPmGy5JYjYMq4u363+9eU/p3jBaK0kJg3O1KvDxn +om/p4ouA64UbkB65gBW58XCECWGJi+AsKU4nmBTXu6DuFZUSedLl7LEmmFvc +AHd5Pp9WFvn7UKae7qZRdLT8QDlRutn1IiVQLnlocI3dHS1Aw0uzbc8+kdE8 +SNbDBZYkLb7eb+aLsQtSegCu21+yIfMOBcBSoQa9uB3L9ZC1xvooGzWKWcCP +jEykQc3akqACHGAsXXSOWvlfzx4dr9oDQASoqdQdZb3j3vDNqYYK00AJyQ9R +czic4tqDngUX8inTSAswkeQ/N/ZITI2Y3lwD0KF/vYTOSl7SK0wVLHZy54NX +ViZcuRJwYzqPoBpfj2ILGTa5o/WnTzWAQl+HHlD0xXhsLC0EeyiKMkBi0X/0 +MoHrdEvwvjSVIH7mGo+1hC2PipEAEQEAAcLBdgQYAQgAKgUCY/xvUgkQYW1Z +a8IGXUgCGwwWIQSlFAAFV1K0T7nqCJVhbVlrwgZdSAAAlfAP/1MszOKhkoqQ +K6JQHKyfBxXk+MKhp1TTAwtz+1X1OAOkrm/0Qi9S8kJU1LLQUXQWCNAsYM7H +84lLfu9XTuHm39/QhupULjt1SAzc9Hfri00iSfWBB7diJX6UMjRMOAuNpiJ+ +/nKO8m7QJp61tvWdxYJUAXoJ0niZsnXk2KkJJHtceqVFGIuVjyFZVzZ3Z2I1 +QVOA8rxMZ9bSpnlzJFbHiyFmmAxLjn0Usr/wDKOPOubaVgt3+VVon6i4MWPn +CgJ+KyuXI8Om99vRI3/d/fH0ZrBeK1Vyc8v2TTXtZHtOwpqczDn0JD4t+V/t +v512cMeXGHjX1f0bNDkeRJ7czyX92FbyLhePuCg3oxEvB7yknSOzO0B/gmGa +rCBs3MltkE3fS9p8haasjBX1QLdkQAC4vT31BIrhyFFbQxnBeFGw/PK0Roga +3gUH4WRkY24xdJ5ZOktj7F6y5mhxv69xbaJet4WB/6MGm36Zc9M0T0tcJlrG +XTXFEw/PwRB1QJluM/KxliL2WcHSpr1rgRDGBmGCOGYYrPkjiHuBo3JqsVm0 +WNA5sNQKxg7PO+78WdK9nDCl8ZVimWLowZR776EhQ8nCqn8ckik9Y+AlJLQY +mZj/np4NhifobIjw4MGcf8h2YOq6fWhhyZQKk1IOxVv0wZnqyjcHp3/HqlEq +dUDdlDNGYaMN +=efCn +-----END PGP PUBLIC KEY BLOCK----- +` + ); + const accessToken = await BrowserRecipe.getGoogleAccessToken(dbPage, acctEmail); + await dbPage.close(); + const extraAuthHeaders = { Authorization: `Bearer ${accessToken}` }; // eslint-disable-line @typescript-eslint/naming-convention + const gmailPage = await browser.newPage(t, `${t.urls?.mockGmailUrl()}/1869220e0c8f16dd`, undefined, extraAuthHeaders); + await gmailPage.waitAll('iframe'); + const pgpBlock = await gmailPage.getFrame(['pgp_block.htm']); + await BrowserRecipe.pgpBlockCheck(t, pgpBlock, { + content: ['Sent with Proton Mail secure email.'], + encryption: 'encrypted', + signature: 'signed', + }); + await gmailPage.close(); + }) + ); + test( 'signature - cleartext signed messages from HTML are re-fetched when needed', testWithBrowser('ci.tests.gmail', async (t, browser) => { From cf3c5fd4e3fddfb774e0e7699ad0059df54f6f1c Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Fri, 3 Mar 2023 10:01:01 +0000 Subject: [PATCH 2/5] Added test for inbox-active-thread --- test/source/browser/browser-handle.ts | 4 +- test/source/browser/test-urls.ts | 5 +- test/source/tests/decrypt.ts | 91 ++++++++------------------- test/source/tests/tooling/consts.ts | 56 +++++++++++++++++ 4 files changed, 88 insertions(+), 68 deletions(-) diff --git a/test/source/browser/browser-handle.ts b/test/source/browser/browser-handle.ts index 86c84d6dcd2..39f93398f96 100644 --- a/test/source/browser/browser-handle.ts +++ b/test/source/browser/browser-handle.ts @@ -49,8 +49,8 @@ export class BrowserHandle { return this.newPage(t, t.urls?.extension(url)); }; - public newExtensionInboxPage = async (t: AvaContext, acctEmail: string): Promise => { - return this.newPage(t, t.urls?.extensionInbox(acctEmail)); + public newExtensionInboxPage = async (t: AvaContext, acctEmail: string, threadId?: string): Promise => { + return this.newPage(t, t.urls?.extensionInbox(acctEmail, threadId)); }; public newExtensionSettingsPage = async (t: AvaContext, acctEmail?: string | undefined): Promise => { diff --git a/test/source/browser/test-urls.ts b/test/source/browser/test-urls.ts index ff16e851031..14e235cee5a 100644 --- a/test/source/browser/test-urls.ts +++ b/test/source/browser/test-urls.ts @@ -21,8 +21,9 @@ export class TestUrls { return this.extension(`chrome/settings/index.htm?account_email=${acctEmail || ''}`); }; - public extensionInbox = (acctEmail: string) => { - return this.extension(`chrome/settings/inbox/inbox.htm?acctEmail=${acctEmail}`); + public extensionInbox = (acctEmail: string, threadId?: string) => { + const url = this.extension(`chrome/settings/inbox/inbox.htm?acctEmail=${acctEmail}`); + return threadId ? url + `&threadId=${threadId}` : url; }; public mockGmailUrl = () => `https://gmail.localhost:${this.port}/gmail`; diff --git a/test/source/tests/decrypt.ts b/test/source/tests/decrypt.ts index a7b829715bd..9b38626e779 100644 --- a/test/source/tests/decrypt.ts +++ b/test/source/tests/decrypt.ts @@ -898,70 +898,12 @@ XZ8r4OC6sguP/yozWlkG+7dDxsgKQVBENeG6Lw== const acctEmail = 'ci.tests.gmail@flowcrypt.test'; const dbPage = await browser.newExtensionPage(t, 'chrome/dev/ci_unit_test.htm'); // todo: url? // add the pubkey of the sender - await dbPage.page.evaluate( - async (pubkey: string) => { - // eslint-disable-next-line @typescript-eslint/no-explicit-any - const key = await (window as any).KeyUtil.parse(pubkey); - // eslint-disable-next-line @typescript-eslint/no-explicit-any - await (window as any).ContactStore.update(undefined, 'schlemazle@proton.me', { pubkey: key }); - }, - `-----BEGIN PGP PUBLIC KEY BLOCK----- - -xsFNBGP8b1IBEACvY95nEYEFC9JEeP475BY4FHDZK8HLNSMbxskQdcRauwyu -4JrVnXou/8QftKZz3ayUFlK0mRy5aGg+D1mcN2EDufwA7fuOowGZMr9WqxOl -mR+mX/B7yc8FfMLsHZ8k9T3Fw+s/Pm4ttGAhuAIJd0Lyo6YLgZTah/HM+S28 -PQHEpfOAgmbNvb7WaLQwh0oTMGMLosXHCh8NOvSW9TS4zB+bMhEnfF53+XM5 -RUZsDQSs8p59itcn7kU3L45CK8Vjg6S49miGpZ6xPDJ+fKN/ZhLzTkT5aHVv -OjUJLCCXpYnG8uqU/1xXLdANM1FNKHTk4EuuGiHFA6XYeiPVwx/dNw+IvePR -cbgtkGoMfdet4ywfUfrFydFUuXHf59XJoaS0tk3nU/gRC0fRgeSwdQamZ1is -xAsyprt9pPSHmVVCyFEOyBND/8lilB8ZL5/1blOBgrZGj1zMRnUJHDjs6TkP -hAqw9dL6j+4pN2o3gjUFcbPBx9LfbfWbrqaZMWwkDb/ysA4pSCeLBnGYIw78 -hDLcijCe+RJLlu2snHfRqcCI2wab+MMUHC11xTp5lzA4u0eoqufp+LOudDXz -zawsdjz+ojRxf0YiEd4jYVkI9/qP4WVkO3QmJPNWrDw3XDjSSvwpz5elrE0l -24pOH1pGLN/6CDZp0h1wNtLhEAX0aIf/kcypjwARAQABzStzY2hsZW1hemxl -QHByb3Rvbi5tZSA8c2NobGVtYXpsZUBwcm90b24ubWU+wsGKBBABCAA+BQJj -/G9SBAsJBwgJEGFtWWvCBl1IAxUICgQWAAIBAhkBAhsDAh4BFiEEpRQABVdS -tE+56giVYW1Za8IGXUgAAJsVEACCwO90h/jfWK0KJ203z9fRnDT+iX1ahTEn -IvzsGUXwo5opTK8k8fz/wZDNl9itrd9c65fWOkeiVYM0jDINxeEvhTwJwTqY -yic+yfnnH9EMIBlUCd36dh+xIK2GwdmtdqYBDwyKzOqWGRQb3zE9I6aHajI7 -yzaJyxEBLv2mrNId2Vtrz12JbJJv4RO4Dv3sZPJoJfbkuV5xg6uEUtIk9aAM -iDdNUhkw3JvPq/cKnh6AAHPBSxxV8dRXOTgIgf5ncoXNodyGtbpPzis7Hxz+ -5KwoyfkDzQYtAKVpXRlyh+F06C5jUCUvmoFxZoH40OfSBpHKcu4EKqIBh28b -oI0ofxQCIWvMiYkcfYeKjnwg25MdpYvatxS4NQVegzq0DhiVEisO0cKtKawn -VGPXTUsevGswICsJBS9DRv3FMkGJIDqR1S/E2GWZa3+U6A4TwPrcmzfXvzqQ -+vxPdq03fMExIHeYlcnexypFUN9K/LtLgXEG34/LXXI9gNBjyfYUwjLZAueh -YqsMqM05waJ3ZlgbZEsePK0LMfRO9g6lq7LsFtB0q28u5IwK6M7Fnox5bzQr -hIDXAFpU4rw7GWWKF71Ujw9r6P8rY0RcRaW2RGlY8+tQvxnSHcK/Ki6ozlWQ -Cv5blHur/EmTO9neO84dHspC8d5Ggwv8qDFR5deohm/TLlkh3c7BTQRj/G9S -ARAAv8AZdsZwWtxE7+NMX+CAurhFwvIxeDOjrXe5LeBhzIEUVXkTNIpf/udq -BfH34LcemmoB6pPnpaxS0Grg/a8FLk7TRU2WkucrnbT8nuv9GihJCyucC9Co -5ZoVmNwIFrxaSkC5oQvsQoytUyk5TJ95egTs7qcsICouCpcIJfM+seNtpc26 -XDWVrf+L3FWGK47LBExHhUrIbgEiUjLfHwCGZEQsctfTIs4W2PJhfF/egiPE -DDLhfWgDQAplZrr6vZlCwPmGy5JYjYMq4u363+9eU/p3jBaK0kJg3O1KvDxn -om/p4ouA64UbkB65gBW58XCECWGJi+AsKU4nmBTXu6DuFZUSedLl7LEmmFvc -AHd5Pp9WFvn7UKae7qZRdLT8QDlRutn1IiVQLnlocI3dHS1Aw0uzbc8+kdE8 -SNbDBZYkLb7eb+aLsQtSegCu21+yIfMOBcBSoQa9uB3L9ZC1xvooGzWKWcCP -jEykQc3akqACHGAsXXSOWvlfzx4dr9oDQASoqdQdZb3j3vDNqYYK00AJyQ9R -czic4tqDngUX8inTSAswkeQ/N/ZITI2Y3lwD0KF/vYTOSl7SK0wVLHZy54NX -ViZcuRJwYzqPoBpfj2ILGTa5o/WnTzWAQl+HHlD0xXhsLC0EeyiKMkBi0X/0 -MoHrdEvwvjSVIH7mGo+1hC2PipEAEQEAAcLBdgQYAQgAKgUCY/xvUgkQYW1Z -a8IGXUgCGwwWIQSlFAAFV1K0T7nqCJVhbVlrwgZdSAAAlfAP/1MszOKhkoqQ -K6JQHKyfBxXk+MKhp1TTAwtz+1X1OAOkrm/0Qi9S8kJU1LLQUXQWCNAsYM7H -84lLfu9XTuHm39/QhupULjt1SAzc9Hfri00iSfWBB7diJX6UMjRMOAuNpiJ+ -/nKO8m7QJp61tvWdxYJUAXoJ0niZsnXk2KkJJHtceqVFGIuVjyFZVzZ3Z2I1 -QVOA8rxMZ9bSpnlzJFbHiyFmmAxLjn0Usr/wDKOPOubaVgt3+VVon6i4MWPn -CgJ+KyuXI8Om99vRI3/d/fH0ZrBeK1Vyc8v2TTXtZHtOwpqczDn0JD4t+V/t -v512cMeXGHjX1f0bNDkeRJ7czyX92FbyLhePuCg3oxEvB7yknSOzO0B/gmGa -rCBs3MltkE3fS9p8haasjBX1QLdkQAC4vT31BIrhyFFbQxnBeFGw/PK0Roga -3gUH4WRkY24xdJ5ZOktj7F6y5mhxv69xbaJet4WB/6MGm36Zc9M0T0tcJlrG -XTXFEw/PwRB1QJluM/KxliL2WcHSpr1rgRDGBmGCOGYYrPkjiHuBo3JqsVm0 -WNA5sNQKxg7PO+78WdK9nDCl8ZVimWLowZR776EhQ8nCqn8ckik9Y+AlJLQY -mZj/np4NhifobIjw4MGcf8h2YOq6fWhhyZQKk1IOxVv0wZnqyjcHp3/HqlEq -dUDdlDNGYaMN -=efCn ------END PGP PUBLIC KEY BLOCK----- -` - ); + await dbPage.page.evaluate(async (pubkey: string) => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const key = await (window as any).KeyUtil.parse(pubkey); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + await (window as any).ContactStore.update(undefined, 'schlemazle@proton.me', { pubkey: key }); + }, testConstants.protonPubkey); const accessToken = await BrowserRecipe.getGoogleAccessToken(dbPage, acctEmail); await dbPage.close(); const extraAuthHeaders = { Authorization: `Bearer ${accessToken}` }; // eslint-disable-line @typescript-eslint/naming-convention @@ -977,6 +919,27 @@ dUDdlDNGYaMN }) ); + test( + 'decrypt - protonmail - PGP/inline signed and encrypted message with pubkey - pubkey signature is ignored - inbox', + testWithBrowser('ci.tests.gmail', async (t, browser) => { + const acctEmail = 'ci.tests.gmail@flowcrypt.test'; + const threadId = '1869220e0c8f16dd'; + const inboxPage = await browser.newExtensionInboxPage(t, acctEmail, threadId); + await inboxPage.waitAll('iframe'); + expect((await inboxPage.getFramesUrls(['pgp_block.htm'])).length).to.equal(1); + expect((await inboxPage.getFramesUrls(['pgp_pubkey.htm'])).length).to.equal(1); + expect((await inboxPage.getFramesUrls(['attachment.htm'])).length).to.equal(0); // invisible + const pgpBlock = await inboxPage.getFrame(['pgp_block.htm']); + await BrowserRecipe.pgpBlockCheck(t, pgpBlock, { + content: ['Sent with Proton Mail secure email.'], + encryption: 'encrypted', + signature: 'could not verify signature: missing pubkey 616D596BC2065D48', + }); + await inboxPage.close(); + t.pass(); + }) + ); + test( 'signature - cleartext signed messages from HTML are re-fetched when needed', testWithBrowser('ci.tests.gmail', async (t, browser) => { diff --git a/test/source/tests/tooling/consts.ts b/test/source/tests/tooling/consts.ts index 10f1bfb6a32..0a2a17710f9 100644 --- a/test/source/tests/tooling/consts.ts +++ b/test/source/tests/tooling/consts.ts @@ -61,6 +61,62 @@ EexnUn1E1mOjFwiYOZavCLvJRtazGCreO0FkWtrrtoa+5F2fbKUIVNGg44fG 7aGdFze6mNyI/fMU =D34s -----END PGP PUBLIC KEY BLOCK-----`, + protonPubkey: `-----BEGIN PGP PUBLIC KEY BLOCK----- + +xsFNBGP8b1IBEACvY95nEYEFC9JEeP475BY4FHDZK8HLNSMbxskQdcRauwyu +4JrVnXou/8QftKZz3ayUFlK0mRy5aGg+D1mcN2EDufwA7fuOowGZMr9WqxOl +mR+mX/B7yc8FfMLsHZ8k9T3Fw+s/Pm4ttGAhuAIJd0Lyo6YLgZTah/HM+S28 +PQHEpfOAgmbNvb7WaLQwh0oTMGMLosXHCh8NOvSW9TS4zB+bMhEnfF53+XM5 +RUZsDQSs8p59itcn7kU3L45CK8Vjg6S49miGpZ6xPDJ+fKN/ZhLzTkT5aHVv +OjUJLCCXpYnG8uqU/1xXLdANM1FNKHTk4EuuGiHFA6XYeiPVwx/dNw+IvePR +cbgtkGoMfdet4ywfUfrFydFUuXHf59XJoaS0tk3nU/gRC0fRgeSwdQamZ1is +xAsyprt9pPSHmVVCyFEOyBND/8lilB8ZL5/1blOBgrZGj1zMRnUJHDjs6TkP +hAqw9dL6j+4pN2o3gjUFcbPBx9LfbfWbrqaZMWwkDb/ysA4pSCeLBnGYIw78 +hDLcijCe+RJLlu2snHfRqcCI2wab+MMUHC11xTp5lzA4u0eoqufp+LOudDXz +zawsdjz+ojRxf0YiEd4jYVkI9/qP4WVkO3QmJPNWrDw3XDjSSvwpz5elrE0l +24pOH1pGLN/6CDZp0h1wNtLhEAX0aIf/kcypjwARAQABzStzY2hsZW1hemxl +QHByb3Rvbi5tZSA8c2NobGVtYXpsZUBwcm90b24ubWU+wsGKBBABCAA+BQJj +/G9SBAsJBwgJEGFtWWvCBl1IAxUICgQWAAIBAhkBAhsDAh4BFiEEpRQABVdS +tE+56giVYW1Za8IGXUgAAJsVEACCwO90h/jfWK0KJ203z9fRnDT+iX1ahTEn +IvzsGUXwo5opTK8k8fz/wZDNl9itrd9c65fWOkeiVYM0jDINxeEvhTwJwTqY +yic+yfnnH9EMIBlUCd36dh+xIK2GwdmtdqYBDwyKzOqWGRQb3zE9I6aHajI7 +yzaJyxEBLv2mrNId2Vtrz12JbJJv4RO4Dv3sZPJoJfbkuV5xg6uEUtIk9aAM +iDdNUhkw3JvPq/cKnh6AAHPBSxxV8dRXOTgIgf5ncoXNodyGtbpPzis7Hxz+ +5KwoyfkDzQYtAKVpXRlyh+F06C5jUCUvmoFxZoH40OfSBpHKcu4EKqIBh28b +oI0ofxQCIWvMiYkcfYeKjnwg25MdpYvatxS4NQVegzq0DhiVEisO0cKtKawn +VGPXTUsevGswICsJBS9DRv3FMkGJIDqR1S/E2GWZa3+U6A4TwPrcmzfXvzqQ ++vxPdq03fMExIHeYlcnexypFUN9K/LtLgXEG34/LXXI9gNBjyfYUwjLZAueh +YqsMqM05waJ3ZlgbZEsePK0LMfRO9g6lq7LsFtB0q28u5IwK6M7Fnox5bzQr +hIDXAFpU4rw7GWWKF71Ujw9r6P8rY0RcRaW2RGlY8+tQvxnSHcK/Ki6ozlWQ +Cv5blHur/EmTO9neO84dHspC8d5Ggwv8qDFR5deohm/TLlkh3c7BTQRj/G9S +ARAAv8AZdsZwWtxE7+NMX+CAurhFwvIxeDOjrXe5LeBhzIEUVXkTNIpf/udq +BfH34LcemmoB6pPnpaxS0Grg/a8FLk7TRU2WkucrnbT8nuv9GihJCyucC9Co +5ZoVmNwIFrxaSkC5oQvsQoytUyk5TJ95egTs7qcsICouCpcIJfM+seNtpc26 +XDWVrf+L3FWGK47LBExHhUrIbgEiUjLfHwCGZEQsctfTIs4W2PJhfF/egiPE +DDLhfWgDQAplZrr6vZlCwPmGy5JYjYMq4u363+9eU/p3jBaK0kJg3O1KvDxn +om/p4ouA64UbkB65gBW58XCECWGJi+AsKU4nmBTXu6DuFZUSedLl7LEmmFvc +AHd5Pp9WFvn7UKae7qZRdLT8QDlRutn1IiVQLnlocI3dHS1Aw0uzbc8+kdE8 +SNbDBZYkLb7eb+aLsQtSegCu21+yIfMOBcBSoQa9uB3L9ZC1xvooGzWKWcCP +jEykQc3akqACHGAsXXSOWvlfzx4dr9oDQASoqdQdZb3j3vDNqYYK00AJyQ9R +czic4tqDngUX8inTSAswkeQ/N/ZITI2Y3lwD0KF/vYTOSl7SK0wVLHZy54NX +ViZcuRJwYzqPoBpfj2ILGTa5o/WnTzWAQl+HHlD0xXhsLC0EeyiKMkBi0X/0 +MoHrdEvwvjSVIH7mGo+1hC2PipEAEQEAAcLBdgQYAQgAKgUCY/xvUgkQYW1Z +a8IGXUgCGwwWIQSlFAAFV1K0T7nqCJVhbVlrwgZdSAAAlfAP/1MszOKhkoqQ +K6JQHKyfBxXk+MKhp1TTAwtz+1X1OAOkrm/0Qi9S8kJU1LLQUXQWCNAsYM7H +84lLfu9XTuHm39/QhupULjt1SAzc9Hfri00iSfWBB7diJX6UMjRMOAuNpiJ+ +/nKO8m7QJp61tvWdxYJUAXoJ0niZsnXk2KkJJHtceqVFGIuVjyFZVzZ3Z2I1 +QVOA8rxMZ9bSpnlzJFbHiyFmmAxLjn0Usr/wDKOPOubaVgt3+VVon6i4MWPn +CgJ+KyuXI8Om99vRI3/d/fH0ZrBeK1Vyc8v2TTXtZHtOwpqczDn0JD4t+V/t +v512cMeXGHjX1f0bNDkeRJ7czyX92FbyLhePuCg3oxEvB7yknSOzO0B/gmGa +rCBs3MltkE3fS9p8haasjBX1QLdkQAC4vT31BIrhyFFbQxnBeFGw/PK0Roga +3gUH4WRkY24xdJ5ZOktj7F6y5mhxv69xbaJet4WB/6MGm36Zc9M0T0tcJlrG +XTXFEw/PwRB1QJluM/KxliL2WcHSpr1rgRDGBmGCOGYYrPkjiHuBo3JqsVm0 +WNA5sNQKxg7PO+78WdK9nDCl8ZVimWLowZR776EhQ8nCqn8ckik9Y+AlJLQY +mZj/np4NhifobIjw4MGcf8h2YOq6fWhhyZQKk1IOxVv0wZnqyjcHp3/HqlEq +dUDdlDNGYaMN +=efCn +-----END PGP PUBLIC KEY BLOCK----- +`, expiredPub: `-----BEGIN PGP PUBLIC KEY BLOCK----- mQGNBF04cLABDADGVUmV8RtjsCIrmg97eO9vmxfc6FeH1cIguCXoFpQxCSk0/Hv8 From f7e2e5e1decca743f20a2d5a593153de574f3dce Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Fri, 3 Mar 2023 12:13:54 +0000 Subject: [PATCH 3/5] refactor signature detection --- extension/chrome/elements/attachment.ts | 15 ++++++----- .../pgp-block-attachmens-module.ts | 5 ++-- .../pgp-block-decrypt-module.ts | 20 +++++++------- extension/js/common/core/attachment.ts | 26 +++++++++---------- extension/js/common/core/common.ts | 3 +++ extension/js/common/core/mime.ts | 19 +++++++------- 6 files changed, 46 insertions(+), 42 deletions(-) diff --git a/extension/chrome/elements/attachment.ts b/extension/chrome/elements/attachment.ts index 971b3df6c8c..8ba53e5eedc 100644 --- a/extension/chrome/elements/attachment.ts +++ b/extension/chrome/elements/attachment.ts @@ -4,7 +4,7 @@ import { Bm, BrowserMsg } from '../../js/common/browser/browser-msg.js'; import { DecryptErrTypes, MsgUtil } from '../../js/common/core/crypto/pgp/msg-util.js'; -import { PromiseCancellation, Url } from '../../js/common/core/common.js'; +import { PromiseCancellation, Str, Url } from '../../js/common/core/common.js'; import { Api } from '../../js/common/api/shared/api.js'; import { ApiErr } from '../../js/common/api/shared/api-error.js'; import { Assert } from '../../js/common/assert.js'; @@ -66,7 +66,7 @@ export class AttachmentDownloadView extends View { this.acctEmail = Assert.urlParamRequire.string(uncheckedUrlParams, 'acctEmail'); this.parentTabId = Assert.urlParamRequire.string(uncheckedUrlParams, 'parentTabId'); this.frameId = Assert.urlParamRequire.string(uncheckedUrlParams, 'frameId'); - this.origNameBasedOnFilename = uncheckedUrlParams.name ? String(uncheckedUrlParams.name).replace(/\.(pgp|gpg)$/gi, '') : 'noname'; + this.origNameBasedOnFilename = uncheckedUrlParams.name ? Str.stripPgpOrGpgExtensionIfPresent(String(uncheckedUrlParams.name)) : 'noname'; this.isEncrypted = uncheckedUrlParams.isEncrypted === true; this.errorDetailsOpened = uncheckedUrlParams.errorDetailsOpened === true; this.size = uncheckedUrlParams.size ? parseInt(String(uncheckedUrlParams.size)) : undefined; @@ -238,17 +238,18 @@ export class AttachmentDownloadView extends View { }; private processAsPublicKeyAndHideAttachmentIfAppropriate = async () => { - // todo: better rely on the preset this.treatAsValue - if (this.attachment.msgId && this.attachment.id && this.attachment.treatAs([]) === 'publicKey') { + // todo: we should call this detection in the main `core/Attachment.treatAs` (e.g. in the context of GmailElementReplacer and InboxActiveThreadModule) + // should be possible after #4906 is done + if (((this.attachment.msgId && this.attachment.id) || this.attachment.url) && this.attachment.isPublicKey()) { // this is encrypted public key - download && decrypt & parse & render - const { data } = await this.gmail.attachmentGet(this.attachment.msgId, this.attachment.id); + await this.downloadDataIfNeeded(); const decrRes = await MsgUtil.decryptMessage({ kisWithPp: await KeyStore.getAllWithOptionalPassPhrase(this.acctEmail), - encryptedData: data, + encryptedData: this.attachment.getData(), verificationPubs: [], // no need to worry about the public key signature, as public key exchange is inherently unsafe }); if (decrRes.success && decrRes.content) { - const openpgpType = await MsgUtil.type({ data: decrRes.content }); + const openpgpType = MsgUtil.type({ data: decrRes.content }); if (openpgpType && openpgpType.type === 'publicKey' && openpgpType.armored) { // 'openpgpType.armored': could potentially process unarmored pubkey files, maybe later BrowserMsg.send.renderPublicKeys(this.parentTabId, { diff --git a/extension/chrome/elements/pgp_block_modules/pgp-block-attachmens-module.ts b/extension/chrome/elements/pgp_block_modules/pgp-block-attachmens-module.ts index e0b0b37a173..b8340bd3d39 100644 --- a/extension/chrome/elements/pgp_block_modules/pgp-block-attachmens-module.ts +++ b/extension/chrome/elements/pgp_block_modules/pgp-block-attachmens-module.ts @@ -11,6 +11,7 @@ import { Ui } from '../../../js/common/browser/ui.js'; import { Xss } from '../../../js/common/platform/xss.js'; import { KeyStore } from '../../../js/common/platform/store/key-store.js'; import { XssSafeFactory } from '../../../js/common/xss-safe-factory.js'; +import { Str } from '../../../js/common/core/common.js'; declare const filesize: { filesize: Function }; // eslint-disable-line @typescript-eslint/ban-types @@ -23,7 +24,7 @@ export class PgpBlockViewAttachmentsModule { Xss.sanitizeAppend('#pgp_block', '
'); this.includedAttachments = attachments; for (const i of attachments.keys()) { - const name = (attachments[i].name ? attachments[i].name : 'noname').replace(/\.(pgp|gpg)$/, ''); + const name = attachments[i].name ? Str.stripPgpOrGpgExtensionIfPresent(attachments[i].name) : 'noname'; const nameVisible = name.length > 100 ? name.slice(0, 100) + '…' : name; const size = filesize.filesize(attachments[i].length); const htmlContent = `${Xss.escape(nameVisible)}   ${size}`; @@ -90,7 +91,7 @@ export class PgpBlockViewAttachmentsModule { }); if (decrypted.success) { const attachment = new Attachment({ - name: encrypted.name.replace(/\.(pgp|gpg)$/, ''), + name: Str.stripPgpOrGpgExtensionIfPresent(encrypted.name), type: encrypted.type, data: decrypted.content, }); diff --git a/extension/chrome/elements/pgp_block_modules/pgp-block-decrypt-module.ts b/extension/chrome/elements/pgp_block_modules/pgp-block-decrypt-module.ts index 70239851ec5..6c60dae59e7 100644 --- a/extension/chrome/elements/pgp_block_modules/pgp-block-decrypt-module.ts +++ b/extension/chrome/elements/pgp_block_modules/pgp-block-decrypt-module.ts @@ -30,16 +30,18 @@ export class PgpBlockViewDecryptModule { // eslint-disable-next-line @typescript-eslint/no-non-null-assertion const mimeMsg = Buf.fromBase64UrlStr(raw!); // used 'raw' above const parsed = await Mime.decode(mimeMsg); - if (parsed && typeof parsed.rawSignedContent === 'string' && parsed.signature) { - this.view.signature.parsedSignature = parsed.signature; - await this.decryptAndRender(Buf.fromUtfStr(parsed.rawSignedContent), verificationPubs); - } else { - await this.view.errorModule.renderErr( - 'Error: could not properly parse signed message', - parsed.rawSignedContent || parsed.text || parsed.html || mimeMsg.toUtfStr(), - 'parse error' - ); + if (parsed && typeof parsed.rawSignedContent === 'string') { + const signatureAttachment = parsed.attachments.find(a => a.treatAs(parsed.attachments) === 'signature'); // todo: more than one signature candidate? + if (signatureAttachment) { + this.view.signature.parsedSignature = signatureAttachment.getData().toUtfStr(); + return await this.decryptAndRender(Buf.fromUtfStr(parsed.rawSignedContent), verificationPubs); + } } + await this.view.errorModule.renderErr( + 'Error: could not properly parse signed message', + parsed.rawSignedContent || parsed.text || parsed.html || mimeMsg.toUtfStr(), + 'parse error' + ); } else if (this.view.encryptedMsgUrlParam && !forcePullMsgFromApi) { // ascii armored message supplied this.view.renderModule.renderText(this.view.signature ? 'Verifying...' : 'Decrypting...'); diff --git a/extension/js/common/core/attachment.ts b/extension/js/common/core/attachment.ts index 10aa499bbd1..7f3d37ca96d 100644 --- a/extension/js/common/core/attachment.ts +++ b/extension/js/common/core/attachment.ts @@ -101,6 +101,15 @@ export class Attachment { return `f_${Str.sloppyRandom(30)}@flowcrypt`; }; + public isPublicKey = (): boolean => { + return ( + this.type === 'application/pgp-keys' || + /^(0|0x)?[A-F0-9]{8}([A-F0-9]{8})?.*\.asc$/g.test(this.name) || // name starts with a key id + (this.name.toLowerCase().includes('public') && /[A-F0-9]{8}.*\.asc$/g.test(this.name)) || // name contains the word "public", any key id and ends with .asc + (/\.asc$/.test(this.name) && this.hasData() && Buf.with(this.getData().subarray(0, 100)).toUtfStr().includes('-----BEGIN PGP PUBLIC KEY BLOCK-----')) + ); + }; + public hasData = () => { return this.bytes instanceof Uint8Array; }; @@ -154,22 +163,11 @@ export class Attachment { } else if (this.name.match(/(\.pgp$)|(\.gpg$)|(\.[a-zA-Z0-9]{3,4}\.asc$)/g)) { // ends with one of .gpg, .pgp, .???.asc, .????.asc return 'encryptedFile'; + // todo: after #4906 is done we should "decrypt" the encryptedFile here to see if it's a binary 'publicKey' (as in message 1869220e0c8f16dd) + } else if (this.isPublicKey()) { + return 'publicKey'; } else if (this.name.match(/(cryptup|flowcrypt)-backup-[a-z0-9]+\.(key|asc)$/g)) { return 'privateKey'; - } else if (this.type === 'application/pgp-keys') { - return 'publicKey'; - } else if (this.name.match(/^(0|0x)?[A-F0-9]{8}([A-F0-9]{8})?.*\.asc$/g)) { - // name starts with a key id - return 'publicKey'; - } else if (this.name.toLowerCase().includes('public') && this.name.match(/[A-F0-9]{8}.*\.asc$/g)) { - // name contains the word "public", any key id and ends with .asc - return 'publicKey'; - } else if ( - this.name.match(/\.asc$/) && - this.hasData() && - Buf.with(this.getData().subarray(0, 100)).toUtfStr().includes('-----BEGIN PGP PUBLIC KEY BLOCK-----') - ) { - return 'publicKey'; } else if (this.name.match(/\.asc$/) && this.length < 100000 && !this.inline) { return 'encryptedMsg'; } else { diff --git a/extension/js/common/core/common.ts b/extension/js/common/core/common.ts index 52e36574b66..e73a34d960f 100644 --- a/extension/js/common/core/common.ts +++ b/extension/js/common/core/common.ts @@ -201,6 +201,9 @@ export class Str { return filename.replace(/\.[^/.]+$/, ''); }; + public static stripPgpOrGpgExtensionIfPresent = (filename: string) => { + return filename.replace(/\.(pgp|gpg)$/i, ''); + }; private static formatEmailWithOptionalNameEx = ({ email, name }: EmailParts, forceBrackets?: boolean): string => { if (name) { return `${Str.rmSpecialCharsKeepUtf(name, 'ALLOW-SOME')} <${email}>`; diff --git a/extension/js/common/core/mime.ts b/extension/js/common/core/mime.ts index c2736bf1cab..40be1fe4bf4 100644 --- a/extension/js/common/core/mime.ts +++ b/extension/js/common/core/mime.ts @@ -25,7 +25,6 @@ type MimeContentHeader = string | AddressHeader[]; export type MimeContent = { headers: Dict; attachments: Attachment[]; - signature?: string; rawSignedContent?: string; subject?: string; html?: string; @@ -73,6 +72,7 @@ export class Mime { } else if (decoded.html) { blocks.push(MsgBlock.fromContent('plainHtml', decoded.html)); } + const signatureAttachments: Attachment[] = []; for (const file of decoded.attachments) { const isBodyEmpty = decoded.text === '' || decoded.text === '\n'; const treatAs = file.treatAs(decoded.attachments, isBodyEmpty); @@ -82,7 +82,7 @@ export class Mime { blocks.push(MsgBlock.fromContent('encryptedMsg', armored)); } } else if (treatAs === 'signature') { - decoded.signature = decoded.signature || file.getData().toUtfStr(); + signatureAttachments.push(file); } else if (treatAs === 'publicKey') { blocks.push(...MsgBlockParser.detectBlocks(file.getData().toUtfStr()).blocks); } else if (treatAs === 'privateKey') { @@ -109,19 +109,21 @@ export class Mime { ); } } - if (decoded.signature) { + if (signatureAttachments.length) { + // todo: if multiple signatures, figure out which fits what + const signature = signatureAttachments[0].getData().toUtfStr(); for (const block of blocks) { if (block.type === 'plainText') { block.type = 'signedText'; - block.signature = decoded.signature; + block.signature = signature; } else if (block.type === 'plainHtml') { block.type = 'signedHtml'; - block.signature = decoded.signature; + block.signature = signature; } } if (!blocks.find(block => ['plainText', 'plainHtml', 'signedMsg', 'signedHtml', 'signedText'].includes(block.type))) { // signed an empty message - blocks.push(new MsgBlock('signedMsg', '', true, decoded.signature)); + blocks.push(new MsgBlock('signedMsg', '', true, signature)); } } return { @@ -182,7 +184,6 @@ export class Mime { subject: undefined, text: undefined, html: undefined, - signature: undefined, from: undefined, to: [], cc: [], @@ -210,9 +211,7 @@ export class Mime { } for (const node of Object.values(leafNodes)) { const nodeType = Mime.getNodeType(node); - if (nodeType === 'application/pgp-signature') { - mimeContent.signature = node.rawContent; - } else if (nodeType === 'text/html' && !Mime.getNodeFilename(node)) { + if (nodeType === 'text/html' && !Mime.getNodeFilename(node)) { // html content may be broken up into smaller pieces by attachments in between // AppleMail does this with inline attachments mimeContent.html = (mimeContent.html || '') + Mime.getNodeContentAsUtfStr(node); From 54cd0730e245e910e69d22b2e211f637ad14664c Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Fri, 3 Mar 2023 12:39:46 +0000 Subject: [PATCH 4/5] fix treatAsValue --- extension/js/common/core/attachment.ts | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/extension/js/common/core/attachment.ts b/extension/js/common/core/attachment.ts index 7f3d37ca96d..8de49af3dee 100644 --- a/extension/js/common/core/attachment.ts +++ b/extension/js/common/core/attachment.ts @@ -41,7 +41,7 @@ export class Attachment { public contentTransferEncoding?: ContentTransferEncoding; private bytes: Uint8Array | undefined; - private treatAsValue: Attachment$treatAs | undefined; + private treatAsValue: Attachment$treatAs | undefined; // this field is to disable on-the-fly detection by this.treatAs() public constructor({ data, type, name, length, url, inline, id, msgId, treatAs, cid, contentDescription, contentTransferEncoding }: AttachmentMeta) { if (typeof data === 'undefined' && typeof url === 'undefined' && typeof id === 'undefined') { @@ -102,6 +102,9 @@ export class Attachment { }; public isPublicKey = (): boolean => { + if (this.treatAsValue) { + return this.treatAsValue === 'publicKey'; + } return ( this.type === 'application/pgp-keys' || /^(0|0x)?[A-F0-9]{8}([A-F0-9]{8})?.*\.asc$/g.test(this.name) || // name starts with a key id From c3088864ed4575a1bd4b97eb687b5e407b975305 Mon Sep 17 00:00:00 2001 From: Roman Shevchenko Date: Fri, 3 Mar 2023 12:56:22 +0000 Subject: [PATCH 5/5] test with known pubkey --- test/source/tests/decrypt.ts | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-) diff --git a/test/source/tests/decrypt.ts b/test/source/tests/decrypt.ts index 9b38626e779..d24af61cb2a 100644 --- a/test/source/tests/decrypt.ts +++ b/test/source/tests/decrypt.ts @@ -924,18 +924,36 @@ XZ8r4OC6sguP/yozWlkG+7dDxsgKQVBENeG6Lw== testWithBrowser('ci.tests.gmail', async (t, browser) => { const acctEmail = 'ci.tests.gmail@flowcrypt.test'; const threadId = '1869220e0c8f16dd'; - const inboxPage = await browser.newExtensionInboxPage(t, acctEmail, threadId); + let inboxPage = await browser.newExtensionInboxPage(t, acctEmail, threadId); await inboxPage.waitAll('iframe'); expect((await inboxPage.getFramesUrls(['pgp_block.htm'])).length).to.equal(1); expect((await inboxPage.getFramesUrls(['pgp_pubkey.htm'])).length).to.equal(1); expect((await inboxPage.getFramesUrls(['attachment.htm'])).length).to.equal(0); // invisible - const pgpBlock = await inboxPage.getFrame(['pgp_block.htm']); - await BrowserRecipe.pgpBlockCheck(t, pgpBlock, { + await BrowserRecipe.pgpBlockCheck(t, await inboxPage.getFrame(['pgp_block.htm']), { content: ['Sent with Proton Mail secure email.'], encryption: 'encrypted', signature: 'could not verify signature: missing pubkey 616D596BC2065D48', }); await inboxPage.close(); + const dbPage = await browser.newExtensionPage(t, 'chrome/dev/ci_unit_test.htm'); + // add the pubkey of the sender + await dbPage.page.evaluate(async (pubkey: string) => { + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const key = await (window as any).KeyUtil.parse(pubkey); + // eslint-disable-next-line @typescript-eslint/no-explicit-any + await (window as any).ContactStore.update(undefined, 'schlemazle@proton.me', { pubkey: key }); + }, testConstants.protonPubkey); + await dbPage.close(); + inboxPage = await browser.newExtensionInboxPage(t, acctEmail, threadId); + await inboxPage.waitAll('iframe'); + expect((await inboxPage.getFramesUrls(['pgp_block.htm'])).length).to.equal(1); + expect((await inboxPage.getFramesUrls(['pgp_pubkey.htm'])).length).to.equal(1); + expect((await inboxPage.getFramesUrls(['attachment.htm'])).length).to.equal(0); // invisible + await BrowserRecipe.pgpBlockCheck(t, await inboxPage.getFrame(['pgp_block.htm']), { + content: ['Sent with Proton Mail secure email.'], + encryption: 'encrypted', + signature: 'signed', + }); t.pass(); }) );