mirror of
https://github.com/ProtonMail/proton-bridge.git
synced 2025-12-16 07:06:45 +00:00
152046bf97
* [x] move package creation logic to `pmapi.SendMessageReq`
* [ ] write test of package creation logic
* [x] internal
* [x] plain
* [x] external encrypted
* [ ] signature ???
* [x] attachments
808 lines
27 KiB
Go
808 lines
27 KiB
Go
// Copyright (c) 2020 Proton Technologies AG
|
|
//
|
|
// This file is part of ProtonMail Bridge.
|
|
//
|
|
// ProtonMail Bridge is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// ProtonMail Bridge is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with ProtonMail Bridge. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
package pmapi
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"testing"
|
|
|
|
"github.com/ProtonMail/gopenpgp/v2/crypto"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type recipient struct {
|
|
email string
|
|
sendScheme int
|
|
pubkey *crypto.KeyRing
|
|
signature int
|
|
contentType string
|
|
doEncrypt bool
|
|
wantError error
|
|
}
|
|
|
|
type testData struct {
|
|
recipients []recipient
|
|
wantPackages []*MessagePackage
|
|
|
|
attKeys map[string]*crypto.SessionKey
|
|
mimeBody, plainBody, richBody string
|
|
}
|
|
|
|
func (td *testData) prepareAndCheck(t *testing.T) {
|
|
r := require.New(t)
|
|
|
|
shouldBeEmpty := func(want string) require.ValueAssertionFunc {
|
|
if len(want) == 0 {
|
|
return require.Empty
|
|
}
|
|
return require.NotEmpty
|
|
}
|
|
|
|
have := NewSendMessageReq(testPrivateKeyRing, td.mimeBody, td.plainBody, td.richBody, td.attKeys)
|
|
for _, rec := range td.recipients {
|
|
err := have.AddRecipient(rec.email, rec.sendScheme, rec.pubkey, rec.signature, rec.contentType, rec.doEncrypt)
|
|
|
|
if rec.wantError == nil {
|
|
r.NoError(err, "email %s", rec.email)
|
|
} else {
|
|
r.EqualError(err, rec.wantError.Error(), "email %s", rec.email)
|
|
}
|
|
}
|
|
have.PreparePackages()
|
|
|
|
r.Equal(len(td.wantPackages), len(have.Packages))
|
|
|
|
for i, wantPackage := range td.wantPackages {
|
|
havePackage := have.Packages[i]
|
|
|
|
r.Equal(len(havePackage.Addresses), len(wantPackage.Addresses))
|
|
for email, wantAddress := range wantPackage.Addresses {
|
|
haveAddress, ok := havePackage.Addresses[email]
|
|
r.True(ok, "pkg %d email %s", i, email)
|
|
|
|
r.Equal(wantAddress.Type, haveAddress.Type, "pkg %d email %s", i, email)
|
|
shouldBeEmpty(wantAddress.BodyKeyPacket)(t, haveAddress.BodyKeyPacket, "pkg %d email %s", i, email)
|
|
r.Equal(wantAddress.Signature, haveAddress.Signature, "pkg %d email %s", i, email)
|
|
|
|
if len(td.attKeys) == 0 {
|
|
r.Len(haveAddress.AttachmentKeyPackets, 0)
|
|
} else {
|
|
r.Equal(
|
|
len(wantAddress.AttachmentKeyPackets),
|
|
len(haveAddress.AttachmentKeyPackets),
|
|
"pkg %d email %s", i, email,
|
|
)
|
|
for attID, wantAttKey := range wantAddress.AttachmentKeyPackets {
|
|
haveAttKey, ok := haveAddress.AttachmentKeyPackets[attID]
|
|
r.True(ok, "pkg %d email %s att %s", i, email, attID)
|
|
shouldBeEmpty(wantAttKey)(t, haveAttKey, "pkg %d email %s att %s", i, email, attID)
|
|
}
|
|
}
|
|
}
|
|
|
|
r.Equal(wantPackage.Type, havePackage.Type, "pkg %d", i)
|
|
r.Equal(wantPackage.MIMEType, havePackage.MIMEType, "pkg %d", i)
|
|
|
|
shouldBeEmpty(wantPackage.Body)(t, havePackage.Body, "pkg %d", i)
|
|
|
|
wantBodyKey := wantPackage.BodyKey
|
|
haveBodyKey := havePackage.BodyKey
|
|
|
|
shouldBeEmpty(wantBodyKey.Algorithm)(t, haveBodyKey.Algorithm, "pkg %d", i)
|
|
shouldBeEmpty(wantBodyKey.Key)(t, haveBodyKey.Key, "pkg %d", i)
|
|
|
|
if len(td.attKeys) == 0 {
|
|
r.Len(havePackage.AttachmentKeys, 0)
|
|
} else {
|
|
r.Equal(
|
|
len(wantPackage.AttachmentKeys),
|
|
len(havePackage.AttachmentKeys),
|
|
"pkg %d", i,
|
|
)
|
|
for attID, wantAttKey := range wantPackage.AttachmentKeys {
|
|
haveAttKey, ok := havePackage.AttachmentKeys[attID]
|
|
r.True(ok, "pkg %d att %s", i, attID)
|
|
shouldBeEmpty(wantAttKey.Key)(t, haveAttKey.Key, "pkg %d att %s", i, attID)
|
|
shouldBeEmpty(wantAttKey.Algorithm)(t, haveAttKey.Algorithm, "pkg %d att %s", i, attID)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSendReq(t *testing.T) {
|
|
attKeyB64 := "EvjO/2RIJNn6HdoU6ACqFdZglzJhpjQ/PpjsvL3mB5Q="
|
|
token, err := base64.StdEncoding.DecodeString(attKeyB64)
|
|
require.NoError(t, err)
|
|
|
|
attKey := crypto.NewSessionKeyFromToken(token, "aes256")
|
|
attKeyPackets := map[string]string{"attID": "not-empty"}
|
|
attAlgoKeys := map[string]AlgoKey{"attID": {"not-empty", "not-empty"}}
|
|
|
|
// NOTE naming
|
|
// Single: there should be one packet
|
|
// Multiple: there should be more than one packet
|
|
// Internal: there should be internal package
|
|
// Clear: there should be non-encrypted package
|
|
// Encrypted: there should be encrypted package
|
|
// NotAllowed: combination of inputs which are not allowed
|
|
tests := map[string]testData{
|
|
"SingleInternalHTML": {
|
|
recipients: []recipient{
|
|
{"html@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"html@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: InternalPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"SingleInternalPlain": {
|
|
recipients: []recipient{
|
|
{"plain@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"plain@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: InternalPackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"InternalNotAllowed": {
|
|
recipients: []recipient{
|
|
{"multipart@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, errMultipartInNonMIME},
|
|
{"noencrypt@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, false, errInternalMustEncrypt},
|
|
{"no-pubkey@pm.me", InternalPackage, nil, SignatureDetached, ContentTypeHTML, true, errMisingPubkey},
|
|
{"nosigning@pm.me", InternalPackage, testPublicKeyRing, SignatureNone, ContentTypeHTML, true, errEncryptMustSign},
|
|
},
|
|
},
|
|
"MultipleInternal": {
|
|
recipients: []recipient{
|
|
{"internal1@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
{"internal2@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
{"internal3@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
{"internal4@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"internal1@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"internal3@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: InternalPackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"internal2@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"internal4@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: InternalPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
|
|
"SingleClearHTML": {
|
|
recipients: []recipient{
|
|
{"html@email.com", ClearPackage, nil, SignatureNone, ContentTypeHTML, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"html@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
"SingleClearPlain": {
|
|
recipients: []recipient{
|
|
{"plain@email.com", ClearPackage, nil, SignatureNone, ContentTypePlainText, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"plain@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearPackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
"SingleClearMIME": {
|
|
recipients: []recipient{
|
|
{"mime@email.com", ClearMIMEPackage, nil, SignatureNone, ContentTypeMultipartMixed, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"mime@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
},
|
|
},
|
|
},
|
|
"SingleClearSign": {
|
|
recipients: []recipient{
|
|
{"signed@email.com", ClearMIMEPackage, nil, SignatureDetached, ContentTypeMultipartMixed, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"signed@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
},
|
|
},
|
|
Type: ClearMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
},
|
|
},
|
|
},
|
|
"ClearNotAllowed": {
|
|
recipients: []recipient{
|
|
{"plain@email.com", ClearPackage, nil, SignatureDetached, ContentTypePlainText, false, errSignMustBeMultipart},
|
|
{"html-1@email.com", ClearPackage, nil, SignatureDetached, ContentTypeHTML, false, errSignMustBeMultipart},
|
|
{"plain@email.com", ClearMIMEPackage, nil, SignatureDetached, ContentTypePlainText, false, errMIMEMustBeMultipart},
|
|
{"html-@email.com", ClearMIMEPackage, nil, SignatureDetached, ContentTypeHTML, false, errMIMEMustBeMultipart},
|
|
},
|
|
},
|
|
"MultipleClear": {
|
|
recipients: []recipient{
|
|
{"html@email.com", ClearPackage, nil, SignatureNone, ContentTypeHTML, false, nil},
|
|
{"sign@email.com", ClearMIMEPackage, nil, SignatureDetached, ContentTypeMultipartMixed, false, nil},
|
|
{"mime@email.com", ClearMIMEPackage, nil, SignatureNone, ContentTypeMultipartMixed, false, nil},
|
|
{"plain@email.com", ClearPackage, nil, SignatureNone, ContentTypePlainText, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{ // TODO can this two be combined
|
|
"sign@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
},
|
|
"mime@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"plain@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearPackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"html@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
|
|
"SingleEncryptedMIME": {
|
|
recipients: []recipient{
|
|
{"mime@gpg.com", PGPMIMEPackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"mime@gpg.com": {
|
|
Type: PGPMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
},
|
|
},
|
|
Type: PGPMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"SingleEncryptedInlinePlain": {
|
|
recipients: []recipient{
|
|
{"inline-plain@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-plain@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"SingleEncryptedInlineHTML": {
|
|
recipients: []recipient{
|
|
{"inline-html@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-html@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"EncryptedNotAllowed": {
|
|
recipients: []recipient{
|
|
{"inline-mixed@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, errMultipartInNonMIME},
|
|
{"inline-clear@gpg.com", PGPInlinePackage, nil, SignatureDetached, ContentTypePlainText, false, errInlinelMustEncrypt},
|
|
{"mime-plain@gpg.com", PGPMIMEPackage, nil, SignatureDetached, ContentTypePlainText, true, errMIMEMustBeMultipart},
|
|
{"mime-html@gpg.com", PGPMIMEPackage, nil, SignatureDetached, ContentTypeHTML, true, errMIMEMustBeMultipart},
|
|
{"no-pubkey@gpg.com", PGPMIMEPackage, nil, SignatureDetached, ContentTypeMultipartMixed, true, errMisingPubkey},
|
|
{"not-signed@gpg.com", PGPMIMEPackage, testPublicKeyRing, SignatureNone, ContentTypeMultipartMixed, true, errEncryptMustSign},
|
|
},
|
|
},
|
|
"MultipleEncrypted": {
|
|
recipients: []recipient{
|
|
{"mime@gpg.com", PGPMIMEPackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, nil},
|
|
{"inline-plain@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
{"inline-html@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"mime@gpg.com": {
|
|
Type: PGPMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
},
|
|
},
|
|
Type: PGPMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-plain@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-html@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
|
|
"SingleInternalEncryptedHTML": {
|
|
recipients: []recipient{
|
|
{"inline-html@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
{"internal@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-html@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"internal@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage | InternalPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"SingleInternalEncryptedPlain": {
|
|
recipients: []recipient{
|
|
{"inline-plain@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
{"internal@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-plain@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"internal@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage | InternalPackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
},
|
|
},
|
|
},
|
|
"SingleInternalClearHTML": {
|
|
recipients: []recipient{
|
|
{"internal@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
{"html@email.com", ClearPackage, nil, SignatureNone, ContentTypeHTML, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"internal@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"html@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: InternalPackage | ClearPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
"SingleInternalClearPlain": {
|
|
recipients: []recipient{
|
|
{"internal@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
{"html@email.com", ClearPackage, nil, SignatureNone, ContentTypeHTML, false, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"internal@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"html@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: InternalPackage | ClearPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
"SingleClearEncryptedHTML": {
|
|
recipients: []recipient{
|
|
{"html@email.com", ClearPackage, nil, SignatureNone, ContentTypeHTML, false, nil},
|
|
{"inline-html@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"inline-html@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"html@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage | ClearPackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
"SingleClearEncryptedPlain": {
|
|
recipients: []recipient{
|
|
{"plain@email.com", ClearPackage, nil, SignatureNone, ContentTypePlainText, false, nil},
|
|
{"inline-plain@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"plain@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
"inline-plain@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: PGPInlinePackage | ClearPackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
"SingleClearEncryptedMIME": {
|
|
recipients: []recipient{
|
|
{"signed@email.com", ClearMIMEPackage, nil, SignatureDetached, ContentTypeMultipartMixed, false, nil},
|
|
{"mime@gpg.com", PGPMIMEPackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"mime@gpg.com": {
|
|
Type: PGPMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
},
|
|
"signed@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
},
|
|
},
|
|
Type: ClearMIMEPackage | PGPMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
},
|
|
},
|
|
},
|
|
"SingleClearEncryptedMIMENoSign": {
|
|
recipients: []recipient{
|
|
{"mime@email.com", ClearMIMEPackage, nil, SignatureNone, ContentTypeMultipartMixed, false, nil},
|
|
{"mime@gpg.com", PGPMIMEPackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"mime@gpg.com": {
|
|
Type: PGPMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
},
|
|
"mime@email.com": { // can this be combined ?
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
},
|
|
Type: ClearMIMEPackage | PGPMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
},
|
|
},
|
|
},
|
|
"MultipleCombo": {
|
|
recipients: []recipient{
|
|
{"mime@email.com", ClearMIMEPackage, nil, SignatureNone, ContentTypeMultipartMixed, false, nil},
|
|
{"signed@email.com", ClearMIMEPackage, nil, SignatureDetached, ContentTypeMultipartMixed, false, nil},
|
|
{"mime@gpg.com", PGPMIMEPackage, testPublicKeyRing, SignatureDetached, ContentTypeMultipartMixed, true, nil},
|
|
|
|
{"plain@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
{"plain@email.com", ClearPackage, nil, SignatureNone, ContentTypePlainText, false, nil},
|
|
{"inline-plain@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypePlainText, true, nil},
|
|
|
|
{"html@pm.me", InternalPackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
{"html@email.com", ClearPackage, nil, SignatureNone, ContentTypeHTML, false, nil},
|
|
{"inline-html@gpg.com", PGPInlinePackage, testPublicKeyRing, SignatureDetached, ContentTypeHTML, true, nil},
|
|
},
|
|
wantPackages: []*MessagePackage{
|
|
{
|
|
Addresses: map[string]*MessageAddress{ // TODO can this three be combined
|
|
"mime@gpg.com": {
|
|
Type: PGPMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
},
|
|
"mime@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
"signed@email.com": {
|
|
Type: ClearMIMEPackage,
|
|
Signature: SignatureDetached,
|
|
},
|
|
},
|
|
Type: ClearMIMEPackage | PGPMIMEPackage,
|
|
MIMEType: ContentTypeMultipartMixed,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"plain@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"plain@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
"inline-plain@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: InternalPackage | ClearPackage | PGPInlinePackage,
|
|
MIMEType: ContentTypePlainText,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
{
|
|
Addresses: map[string]*MessageAddress{
|
|
"html@pm.me": {
|
|
Type: InternalPackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "not-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
"html@email.com": {
|
|
Type: ClearPackage,
|
|
Signature: SignatureNone,
|
|
},
|
|
"inline-html@gpg.com": {
|
|
Type: PGPInlinePackage,
|
|
Signature: SignatureDetached,
|
|
BodyKeyPacket: "non-empty",
|
|
AttachmentKeyPackets: attKeyPackets,
|
|
},
|
|
},
|
|
Type: InternalPackage | ClearPackage | PGPInlinePackage,
|
|
MIMEType: ContentTypeHTML,
|
|
Body: "non-empty",
|
|
BodyKey: AlgoKey{"non-empty", "non-empty"},
|
|
AttachmentKeys: attAlgoKeys,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for name, test := range tests {
|
|
test.mimeBody = "Mime body"
|
|
test.plainBody = "Plain body"
|
|
test.richBody = "HTML body"
|
|
t.Run("NoAtt"+name, test.prepareAndCheck)
|
|
test.attKeys = map[string]*crypto.SessionKey{"attID": attKey}
|
|
t.Run("Att"+name, test.prepareAndCheck)
|
|
}
|
|
}
|