encrypt + encode encrypted/plain emails

[tomholub]

part of #1051

Right now we use node for initial structure and then we tag on files in Kotlin. Can do all in Kotlin.

Current implementation is at https://github.com/FlowCrypt/flowcrypt-mobile-core/blob/master/source/mobile-interface/endpoints.ts

Here:

 public composeEmail = async (uncheckedReq: any): Promise<Buffers> => {
 const req = ValidateInput.composeEmail(uncheckedReq);
 const mimeHeaders: RichHeaders = { to: req.to, from: req.from, subject: req.subject, cc: req.cc, bcc: req.bcc };
 if (req.replyToMimeMsg) {
 const previousMsg = await Mime.decode(Buf.fromUtfStr((req.replyToMimeMsg.substr(0, 10000).split('\n\n')[0] || '') + `\n\nno content`));
 const replyHeaders = Mime.replyHeaders(previousMsg);
 mimeHeaders['in-reply-to'] = replyHeaders['in-reply-to'];
 mimeHeaders['references'] = replyHeaders['references'];
 }
 if (req.format === 'plain') {
 const atts = (req.atts || []).map(({ name, type, base64 }) => new Att({ name, type, data: Buf.fromBase64Str(base64) }));
 return fmtRes({}, Buf.fromUtfStr(await Mime.encode({ 'text/plain': req.text }, mimeHeaders, atts)));
 } else if (req.format === 'encrypt-inline') {
 const encryptedAtts: Att[] = [];
 for (const att of req.atts || []) {
 const encryptedAtt = await PgpMsg.encrypt({ pubkeys: req.pubKeys, data: Buf.fromBase64Str(att.base64), filename: att.name, armor: false }) as OpenPGP.EncryptBinaryResult;
 encryptedAtts.push(new Att({ name: att.name, type: 'application/pgp-encrypted', data: encryptedAtt.message.packets.write() }))
 }
 const encrypted = await PgpMsg.encrypt({ pubkeys: req.pubKeys, data: Buf.fromUtfStr(req.text), armor: true }) as OpenPGP.EncryptArmorResult;
 return fmtRes({}, Buf.fromUtfStr(await Mime.encode({ 'text/plain': encrypted.data }, mimeHeaders, encryptedAtts)));
 } else {
 throw new Error(`Unknown format: ${req.format}`);
 }
 }

Tests at https://github.com/FlowCrypt/flowcrypt-mobile-core/blob/master/source/test.ts

ava.default('composeEmail format:plain -> parseDecryptMsg', async t => {
 const content = 'hello\nwrld';
 const { keys } = getKeypairs('rsa1');
 const req = { format: 'plain', text: content, to: ['some@to.com'], cc: ['some@cc.com'], bcc: [], from: 'some@from.com', subject: 'a subj' };
 const { data: plainMimeMsg, json: composeEmailJson } = await request('composeEmail', req, []);
 expectEmptyJson(composeEmailJson);
 const plainMimeStr = plainMimeMsg.toString();
 expect(plainMimeStr).contains('To: some@to.com');
 expect(plainMimeStr).contains('From: some@from.com');
 expect(plainMimeStr).contains('Subject: a subj');
 expect(plainMimeStr).contains('Cc: some@cc.com');
 expect(plainMimeStr).contains('Date: ');
 expect(plainMimeStr).contains('MIME-Version: 1.0');
 const { data: blocks, json: parseJson } = await request('parseDecryptMsg', { keys, isEmail: true }, plainMimeMsg);
 expect(parseJson).to.deep.equal({ text: content, replyType: 'plain', subject: 'a subj' });
 expectData(blocks, 'msgBlocks', [{ rendered: true, frameColor: 'plain', htmlContent: content.replace(/\n/g, '<br />') }]);
 t.pass();
});

ava.default('composeEmail format:plain (reply)', async t => {
 const replyToMimeMsg = `Content-Type: multipart/mixed;
 boundary="----sinikael-?=_1-15535259519270.930031460416217"
To: some@to.com
From: some@from.com
Subject: Re: original
Date: Mon, 25 Mar 2019 14:59:11 +0000
Message-Id: <originalmsg@from.com>
MIME-Version: 1.0
------sinikael-?=_1-15535259519270.930031460416217
Content-Type: text/plain
Content-Transfer-Encoding: quoted-printable
orig message
------sinikael-?=_1-15535259519270.930031460416217--`
 const req = { format: 'plain', text: 'replying', to: ['some@to.com'], cc: [], bcc: [], from: 'some@from.com', subject: 'Re: original', replyToMimeMsg };
 const { data: mimeMsgReply, json } = await request('composeEmail', req, []);
 expectEmptyJson(json);
 const mimeMsgReplyStr = mimeMsgReply.toString();
 expect(mimeMsgReplyStr).contains('In-Reply-To: <originalmsg@from.com>');
 expect(mimeMsgReplyStr).contains('References: <originalmsg@from.com>');
 t.pass();
});

ava.default('composeEmail format:encrypt-inline -> parseDecryptMsg', async t => {
 const content = 'hello\nwrld';
 const { pubKeys, keys } = getKeypairs('rsa1');
 const req = { pubKeys, format: 'encrypt-inline', text: content, to: ['encrypted@to.com'], cc: [], bcc: [], from: 'encr@from.com', subject: 'encr subj' };
 const { data: encryptedMimeMsg, json: encryptJson } = await request('composeEmail', req, []);
 expectEmptyJson(encryptJson);
 const encryptedMimeStr = encryptedMimeMsg.toString();
 expect(encryptedMimeStr).contains('To: encrypted@to.com');
 expect(encryptedMimeStr).contains('MIME-Version: 1.0');
 expectData(encryptedMimeMsg, 'armoredMsg'); // armored msg block should be contained in the mime message
 const { data: blocks, json: decryptJson } = await request('parseDecryptMsg', { keys, isEmail: true }, encryptedMimeMsg);
 expect(decryptJson).deep.equal({ text: content, replyType: 'encrypted', subject: 'encr subj' });
 expectData(blocks, 'msgBlocks', [{ rendered: true, frameColor: 'green', htmlContent: content.replace(/\n/g, '<br />') }]);
 t.pass();
});

[DenBond7]

@tomholub Please clarify some moments. Below you can see how NodeJs makes a simple MIME message and how JavaMail does it

1. Does it matter the order of headers? I've sorted headers for better comparison but they don't look as I've displayed

Return-Path: <usertest@gmail.com>
Received: from localhost ([1.1.1.1])
 by smtp.gmail.com with ESMTPSA id 13
 for <user@gmail.com>
 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128);
 Thu, 25 Mar 2021 07:19:29 -0700 (PDT)
Content-Type: multipart/mixed; boundary="----sinikael-?=_1-16166819659690.8102595683743179"
To: user@gmail.com
From: usertest@gmail.com
Subject: NodeJs
Date: Thu, 25 Mar 2021 14:19:25 +0000
Message-Id: <1616681965973-cbae0d37-b57d0555-aebdf58d@gmail.com>
MIME-Version: 1.0
User-Agent: FlowCrypt_Android_1.1.3

------sinikael-?=_1-16166819659690.8102595683743179
Content-Type: text/plain
Content-Transfer-Encoding: quoted-printable

Hello
------sinikael-?=_1-16166819659690.8102595683743179--

Return-Path: <usertest@gmail.com>
Received: from localhost ([1.1.1.1])
 by smtp.gmail.com with ESMTPSA id 12
 for <user@gmail.com>
 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128);
 Thu, 25 Mar 2021 07:20:28 -0700 (PDT)
Date: Thu, 25 Mar 2021 16:20:24 +0200 (GMT+02:00)
From: usertest@gmail.com
To: user@gmail.com
Message-ID: <180413985.1.1616682024190@localhost>
Subject: Java
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="----=_Part_0_162249864.1616682024146"
User-Agent: FlowCrypt_Android_1.1.5_dev_115__2021_03_25

------=_Part_0_162249864.1616682024146
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit

Hello
------=_Part_0_162249864.1616682024146--

2. JavaMail adds Date differently. As you can see we have here timezone. But in the code below I see you change such behavior for NodeJs
   
3. JavaMail adds Message-ID differently. It uses localhost. But in the code below I see you change such behavior for NodeJs
   

Just want to clarify, maybe I've missed something due to NodeJs

[tomholub]

1. order of headers should not matter. The encoding difference should be ok.
2. date is fine as long as sending/receiving clients understand it readily
3. this is hard to say - the behavior you see is from a library. It seems like they did it deliberately. If it's easy to do something similar, I would follow it on Android too. But that can be a followup issue.