Committing to merge

src/message_api.c

@@ -5331,47 +5331,57 @@ static PEP_STATUS _decrypt_message(
                                                         &_changed_keys,
                                                         &imported_sender_key_fpr);
 
-                if (src->from && !is_me(session, src->from)) {
-                    if (status == PEP_STATUS_OK && !has_inner) {
-                        // If we're claiming to have a pEp version 2.2 or greater, we only take it
-                        // if it had the right name during the import and if it was the ONLY key on the message?
-                        //
-                        // FIXME: From SENDER >= 2.2, we should be VERY careful here -- check back on this one
-                        //
-                        const char* sender_key = NULL;
-                        if ((major_ver == 2 && minor_ver > 1) || major_ver > 2) {
-                            if (imported_sender_key_fpr)
-                                sender_key = imported_sender_key_fpr;
+                if (src->from) {
+                    if (!is_me(session, src->from)) {
+
+                        /* if decrypted, but not verified... */
+                        if (status == PEP_STATUS_OK && decrypt_status == PEP_DECRYPTED) {
+                            if (src->from)
+                                status = verify_decrypted(session,
+                                                          src, msg,
+                                                          ptext, psize,
+                                                          &_keylist,
+                                                          &decrypt_status,
+                                                          crypto);
                         }
-                        else if (header_key_imported && _imported_key_list)
-                            sender_key = _imported_key_list->value;
-                        else if (*start && !((*start)->next))
-                            sender_key = (*start)->value; // signer if sent from < 2.1
 
+                        if (status == PEP_STATUS_OK && !has_inner) {
+                            // If we're claiming to have a pEp version 2.2 or greater, we only take it
+                            // if it had the right name during the import and if it was the ONLY key on the message?
+                            //
+                            // FIXME: From SENDER >= 2.2, we should be VERY careful here -- check back on this one
+                            //
+                            const char *sender_key = NULL;
+                            // FIXME: No, not possible. Has to come from INNER message.
+                            if ((major_ver == 2 && minor_ver > 1) || major_ver > 2) {
+                                if (imported_sender_key_fpr)
+                                    sender_key = imported_sender_key_fpr;
+                            }
+                            else if (header_key_imported && _imported_key_list) {
+                                sender_key = _imported_key_list->value;
+                            }
+                            else if (*start && !((*start)->next)) {
+                                if (decrypt_status == PEP_DECRYPTED_AND_VERIFIED) {
+                                    if (_keylist && !EMPTYSTR(_keylist->value) && *start && !EMPTYSTR((*start)->value)) {
+                                        sender_key = (*start)->value; // signer if sent from < 2.1
+                                    }
+                                }
+                            }
 
-                        status = _check_and_set_default_key(session, src->from, sender_key);
-                        free(imported_sender_key_fpr);
-                        imported_sender_key_fpr = NULL;
 
-                        if (status == PEP_OUT_OF_MEMORY)
-                            goto enomem;    
-                    }    
-                } // else, it needs to get set from INNER keys.
+                            status = _check_and_set_default_key(session, src->from, sender_key);
+                            free(imported_sender_key_fpr);
+                            imported_sender_key_fpr = NULL;
+
+                            if (status == PEP_OUT_OF_MEMORY)
+                                goto enomem;
+                        } // else, it needs to get set from INNER keys.
+                    }
+                }
 
                 if (status != PEP_STATUS_OK)
                     goto pEp_error;            
 
-                /* if decrypted, but not verified... */
-                if (decrypt_status == PEP_DECRYPTED) {
-                    
-                    if (src->from)                                                                 
-                        status = verify_decrypted(session,
-                                                  src, msg,
-                                                  ptext, psize,
-                                                  &_keylist,
-                                                  &decrypt_status,
-                                                  crypto);
-                }
                 break;
 
             case PEP_enc_inline:

test/src/DefaultFromEmailTest.cc

@@ -858,10 +858,10 @@ TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_bob) {
 // B. Test failures
 
 // Failure case 1) No key attached
-TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_carol_no_key) {
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_bob_no_pep_no_key) {
 }
 
-TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_john_no_key) {
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_sylvia_no_pep_no_key) {
 }
 
 TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_sylvia_no_key) {
@@ -944,10 +944,84 @@ TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_bob_no_key) {
 
 // A. Test successful cases
 
-TEST_F(DefaultFromEmailTest, check_encrypted_key_import_carol) {
+// Bob is a known OpenPGP partner - we use the "wrong filename" version because OpenPGP doesn't use our conventions
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_no_pep) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0_wrong_key_filename_no_pEp.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_OpenPGP_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
 }
 
-TEST_F(DefaultFromEmailTest, check_encrypted_key_import_john) {
+// Sylvia is an unknown OpenPGP partner
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_no_pep) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0_wrong_key_filename_no_pEp.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_OpenPGP_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
 }
 
 TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_2) {
@@ -1184,6 +1258,7 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_0) {
     free_identity(recip);
 }
 
+// We use the "wrong" filename version on purpose to ensure we aren't relying on 2.2 changes
 TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_1_0) {
     pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
     const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
@@ -1198,7 +1273,7 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_1_0) {
     ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
 
     // Ok, we now have a blank slate. Run the import mail fun.
-    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0.eml";
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0_wrong_key_filename_ModifiedVersion.eml";
     message* infile = NULL;
     status = vanilla_read_file_and_decrypt(session, &infile, filename);
     ASSERT_OK;
@@ -1219,6 +1294,7 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_1_0) {
     free_identity(recip);
 }
 
+// We use the "wrong" filename version on purpose to ensure we aren't relying on 2.2 changes
 TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0) {
     pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
     const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
@@ -1241,7 +1317,7 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0) {
     ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
 
     // Ok, we now the desired state. Run the import mail fun.
-    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0.eml";
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0_wrong_key_filename_ModifiedVersion.eml";
     message* infile = NULL;
     status = vanilla_read_file_and_decrypt(session, &infile, filename);
     ASSERT_OK;
@@ -1262,14 +1338,88 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0) {
     free_identity(recip);
 }
 
-
 // B. Test failures
 
 // Failure case 1) No key attached
-TEST_F(DefaultFromEmailTest, check_encrypted_key_import_carol_no_key) {
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_no_pep_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0_NoKey_no_pEp.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
 }
 
-TEST_F(DefaultFromEmailTest, check_encrypted_key_import_john_no_key) {
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_no_pep_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey_no_pEp.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
 }
 
 TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_2_no_key) {
@@ -1593,10 +1743,51 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0_no_key) {
 }
 
 // Failure case 2) Wrong key attached
-TEST_F(DefaultFromEmailTest, check_encrypted_key_import_carol_wrong_sender_key_attached) {
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_no_pep_wrong_sender_key_attached) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0_wrong_sender_key_attached_no_pEp.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
 }
 
-TEST_F(DefaultFromEmailTest, check_encrypted_key_import_john_wrong_sender_key_attached) {
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_no_pep_wrong_sender_key_attached) {
 }
 
 TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_2_wrong_sender_key_attached) {
@@ -2088,4 +2279,334 @@ TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_0_wrong_keyfilenam
     free_identity(recip);
 }
 
-// Note: 1.0 only looks at the number of keys attached, so there's no concept of "wrong sender key"
+// Note: 1.0 only looks at the number of keys attached, so there's no concept of "wrong sender key"
+
+// C. Cases which may fail or succeed based on source
+// Two keys attached
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_carol_two_keys) {
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_john_two_keys) {
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_2_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_2_TwoKeys.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_2_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_2_TwoKeys.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_1_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_1_TwoKeys.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_OK;
+    ASSERT_EQ(rating, PEP_rating_reliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_1_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_1_TwoKeys.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_OK;
+    ASSERT_EQ(rating, PEP_rating_reliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_0_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_0_TwoKeys.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_OK;
+    ASSERT_EQ(rating, PEP_rating_reliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_0_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_0_TwoKeys.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_OK;
+    ASSERT_EQ(rating, PEP_rating_reliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_1_0_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0_TwoKeys.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_OK;
+    ASSERT_EQ(rating, PEP_rating_reliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0_two_keys) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0_TwoKeys.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_OK;
+    ASSERT_EQ(rating, PEP_rating_reliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}

test/src/TestUtilities.cc

@@ -36,7 +36,7 @@ const TestUtilsPreset::IdentityInfo TestUtilsPreset::presets[]     = {
                 TestUtilsPreset::IdentityInfo("Alice Spivak Hyatt", "ALICE", "pep.test.alice@pep-project.org", "pep-test-alice-0x6FF00E97", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97"),
                 TestUtilsPreset::IdentityInfo("Apple of my Computer", "APPLE", "pep.test.apple@pep-project.org", "pep-test-apple-0x1CCBC7D7", "3D8D9423D03DDF61B60161150313D94A1CCBC7D7"),
                 TestUtilsPreset::IdentityInfo("Bob Dog", "BOB", "pep.test.bob@pep-project.org", "pep-test-bob-0xC9C2EE39", "BFCDB7F301DEEEBBF947F29659BFF488C9C2EE39"),
-                TestUtilsPreset::IdentityInfo("Bob Dog", "BOB", "pep.test.bob@pep-project.org", "pep-test-bob-0xC9C2EE39", "BFCDB7F301DEEEBBF947F29659BFF488C9C2EE39"),
+                TestUtilsPreset::IdentityInfo("Bob Dog", "BOB", "pep.test.bob@pep-project.org", "pep-test-bob-0x9667F61D", "C47ADE6207C7C3098C6E83D9FF3D3F669667F61D"),
                 TestUtilsPreset::IdentityInfo("Carol Burnett", "CAROL", "pep-test-carol@pep-project.org", "pep-test-carol-0x42A85A42", "8DD4F5827B45839E9ACCA94687BDDFFB42A85A42"),
                 TestUtilsPreset::IdentityInfo("The Hoff", "DAVE", "pep-test-dave@pep-project.org", "pep-test-dave-0xBB5BCCF6", "E8AC9779A2D13A15D8D55C84B049F489BB5BCCF6"),
                 TestUtilsPreset::IdentityInfo("Erin Ireland", "ERIN", "pep-test-erin@pep-project.org", "pep-test-erin-0x9F8D7CBA", "1B0E197E8AE66277B8A024B9AEA69F509F8D7CBA"),
@@ -60,7 +60,7 @@ const TestUtilsPreset::IdentityInfo TestUtilsPreset::presets[]     = {
                 TestUtilsPreset::IdentityInfo("Inquisitor Claire Trevelyan", "INQUISITOR", "inquisitor@darthmama.org", "inquisitor-0xA4728718_renewed", "8E8D2381AE066ABE1FEE509821BA977CA4728718"),
                 TestUtilsPreset::IdentityInfo("Bernd das Brot", "BERNDI", "bernd.das.brot@darthmama.org", "bernd.das.brot-0xCAFAA422", "F8CE0F7E24EB190A2FCBFD38D4B088A7CAFAA422"),
                 TestUtilsPreset::IdentityInfo("Sylvia Plath", "SYLVIA", "sylvia@darthmama.org", "sylvia-0x585A6780", "0C0F053EED87058C7330A11F10B89D31585A6780"),
-                TestUtilsPreset::IdentityInfo("Sylvia Plath", "SYLVIA", "sylvia@darthmama.org", "sylvia-0x585A6780", "0C0F053EED87058C7330A11F10B89D31585A6780")
+                TestUtilsPreset::IdentityInfo("Sylvia Plath", "SYLVIA", "sylvia@darthmama.org", "sylvia-0x2E5A78A9", "3FB4EB6F00E96E163FB05C0374B8F0832E5A78A9")
     };
 
 

test/test_keys/priv/pep-test-bob-0x9667F61D_priv.asc

@@ -0,0 +1,106 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+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+=4VrA
+-----END PGP PRIVATE KEY BLOCK-----

test/test_keys/priv/sylvia-0x2E5A78A9_priv.asc

@@ -0,0 +1,106 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+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+=ITgs
+-----END PGP PRIVATE KEY BLOCK-----

test/test_keys/pub/pep-test-bob-0x9667F61D_pub.asc

@@ -0,0 +1,52 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=6fS5
+-----END PGP PUBLIC KEY BLOCK-----

test/test_keys/pub/sylvia-0x2E5A78A9_pub.asc

@@ -0,0 +1,52 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=qBJO
+-----END PGP PUBLIC KEY BLOCK-----

test/test_mails/CanonicalFrom2.2BobToAliceUnencrypted_TwoKeys.eml

@@ -3,9 +3,9 @@ To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
 Subject: This is a canonical mail from someone to Alice
 X-pEp-Version: 2.2
 MIME-Version: 1.0
-Content-Type: multipart/mixed; boundary="bf72b1411447b7342963e5aa0382c5"
+Content-Type: multipart/mixed; boundary="6feaabad2c151875184cee7e2320e4c6"
 
---bf72b1411447b7342963e5aa0382c5
+--6feaabad2c151875184cee7e2320e4c6
 Content-Type: text/plain
 Content-Transfer-Encoding: 7bit
 
@@ -13,45 +13,69 @@ Fa una canzona senza note nere
 Se mai bramasti la mia grazia havere
 Falla d'un tuono ch'invita al dormire,
 Dolcemente, dolcemente facendo la finire.
---bf72b1411447b7342963e5aa0382c5
+--6feaabad2c151875184cee7e2320e4c6
 Content-Type: application/pgp-keys
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="pEpKey.asc"
 
-LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgp4c0JOQkZWNFBsOEJDQUN1dWtR
-THdzSGZ0SDVqa1ZzU0w3Q09GaGFtTnNFRThsWjhNRzFmMVJ4NXp0UHVaVG5hCllYeVdPRGdwajJC
-eHowVGNQK1ExN0diTEtzZTdUV0QxazlpMVJ6TFd6OFpTQ0xZcTJUdGpMV1BsZVZ1R0dXZXEKWTN0
-VFdIQy9uRmJpdm9sTlBBMG1MMjAzOFRHZEJvbFBhWmlQWjRQOHd1UVZZTmZEcWk0dXRjZXpHRE5T
-OE9IaApFUGhmeUtLb1NNNzlITG9VUGM2eHNmaW14UE1yeWxJL2k4YkZ2ZkRZejV2bXlkZWZ2QXhO
-aHFqTEgzR21oajFwCm5JbnNyYUVpeWg3WTJ6QXhDZnI2aEQ5bmt5N1dpeEJpbktGRmhRcGNVdTFv
-K0llNlVHd0xWYlR5Uk1PY1Jzb2IKeWFocUEvbTJIZkRSajFZK244SEhxc1FrQjJCdG1NWVhsYTNq
-QUJFQkFBSE5RWEJGY0NCVVpYTjBJRUp2WWlBbwpkR1Z6ZENCclpYa3NJR1J2YmlkMElIVnpaU2tn
-UEhCbGNDNTBaWE4wTG1KdllrQndaWEF0Y0hKdmFtVmpkQzV2CmNtYyt3c0NQQkJNQkFnQWlCUUpW
-ZUQ1ZkFoc0RCZ3NKQ0FjREFnWVZDQUlKQ2dzRUZnSURBUUllQVFJWGdBQWgKQ1JCWnYvU0l5Y0x1
-T1JZaEJML050L01CM3U2NytVZnlsbG0vOUlqSnd1NDVwSGtJQUtQY1RyS1EycU1aTGsvTwpDRmg4
-c215anFQM25oRE12QTZqTlBOVC9mOGRZZmlVTGNtWit2U2tZam5VcG5wZDYrdW5jMzFMRkdxdTRr
-SVZHCjNBMTRmZTZNaUFPSDlRY0pRU3cvLzUzdmhJNTZjZ0ZnWlFvVFU0bWFIejh0QjJRMUp6b2sx
-M01tTU5aMHA2SHAKd0F3VzlhTzc4MnEyWCtYUVVheWxCVDEyWUl5M09RcUNiQ2dwbGJucG9SVm5h
-VlBHbzBTalZwRDZVdXMyNTRHcgpUOURtUUJVVE5RYnRSK2JYM0JlTlo2Y1F4NTRTVmZkUUFhNTBz
-bTV5VEh1NFB4Yi9JSENxdEVCdG9KSjVsL3BGClVFdlAzcDZTTmF0Vjh5ZWFPUSs1QTgrM2x5ejN4
-SEZCT25HVHR2ckV0cFpmS2FFRHB4aFQ0VUJiZ09sdU44bU0KeFlnVU53ck93RTBFVlhnK1h3RUlB
-TXBEWkpYcUNOSGszcjNGVjJJSnA1K1BDaHV0ZEhXZUs0RWNFMU5jd25BKwpUYkcvNTd0OWpieEVy
-VUhNNE5nTE1HR21XMjlHZ0p3bUwxTHRHckxQeldkdkdmRC9WTm9xMmZwME1PRms5VWVNCjNlOXF3
-TzU0enJGTVI4U0tFMXpRN0IvakRQMUlHTzZ0NTFSV1IxUEZUc1hGS0JVL1hSMDdHRjIyU05hTVpi
-VU0KWHBhVmdEd0VBZ1IxdW1pRjRrZlBjMFdTRTlEd09YT2pzaWg3YTN1K3RQTzF3RmZYV2paNzRV
-ODZyVkthRVN2dgp6QnRFNERJSlVCY3I3eW9PSGpNT3J5SUF4a3I4cWRtdWJxay9UVDZJRkZ4djRs
-Q0NmY2FmNkZUU1dBVGRnSDJRCkVrdDVab2ZFUTgyZWMwMjliOEV5WG5keTEvd2luNm5Pa0RVcjlM
-YmNwVHNBRVFFQUFjTEFkZ1FZQVFJQUNRVUMKVlhnK1h3SWJEQUFoQ1JCWnYvU0l5Y0x1T1JZaEJM
-L050L01CM3U2NytVZnlsbG0vOUlqSnd1NDVhbThILzNUKwpMRncwWWtlYmxUSWVWb1RwOVV2REp4
-MllTMWdFT255UGZ5c1lJQWo0WUdPc3dJTE16ekxyY3diRUpWZUQra0Y5CjlIZmZTRENhOHhtR01Z
-emUyZW54ZTdyUGJ0ZE4vaGs4eGtCKy8rT3lSdEhrazBtaWtMNmhHamRmdWpQemdXU24KTURWdXNS
-MnZwWVNFdVp5Umxkem5zdjBSVU1MbkFibzBHN2Nvd3pkMmhySWNLczRTVnhRWlJkMGFoY3k4YmdD
-WgpuamxYbldpcjNUNDBZWUJic1laSW5GSVZhZHU2bDBBcVE2WkZKSS9ZVysrY2doT3FRTTZLVHVy
-T3VjaDdKeGNuCm9jSU1qSzM2VXo1VHpQT2dkU3grQ0JNRW1qcXhDVW5SNTV4US9KNTBpSTBjbjYy
-dDNiQ1AwVlRabUYvQkpEQmkKQXM2RWVKVm5HQlVvU1VET2tFST0KPXhyM3kKLS0tLS1FTkQgUEdQ
-IFBVQkxJQyBLRVkgQkxPQ0stLS0tLQo=
+LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgp4c0ZOQkdDK05KVUJFQUN0bml4
+cU1GOGFGMktlSWNFaU05SXQ3Q0lRQnozWDNlNVNKL0pmaU1vd0RWOUpiQzE1CjZQMzJGU25TVmRX
+bEZ2Q1J4Y2tqV2dkS1JaYkxUR25tU2RoRFViTWoraU11Z0UvSmNKb2FmL01pcFAvZTdqMmYKd1Zj
+NlNsOWpCNzlGZWRqRm1DVG52bjdJM2JpL2svNWFhbWpIN3hTditIWXR4b0hpa3V4ajFZOS9xaCtC
+T3o1VgpzcDJOY0N3WENYTGFsNWsrUzFxeFBIZkgyYVQ4eWd1bStDK2dhY2QydTlkN0NjTzdIM2p4
+VC9uQ0VBT1c2bUljCnROK294N1JGbVROdDhlM3ZEcklRM1hhU2lSRGNTeG9mRTFiRjZQdXMycTht
+ZFdUTVMxbXNCRjFYdDJjVHJETUkKczFUUUdxeEhYUElMUkZOTlNMRmczSWw0L1c1b05rbWR6N3V6
+OGZmSExNMVJUeFRmNXNaalZwWDRSQnBHcHp3ZwpKNXpuNGJRMVMrMGpVblRkYk4zcXNDdTV4VDZV
+d3lxbFdCY2JEaWZCbjEzZkpXb1BaN0Q3ckJXSW94bnFxdVNKCk1QdE5iOWZLclppd0U1MlExeWdK
+Q2trYzUzTGwzcWJzMCtSMUdLdURPa01YbG9OVTVSMWcyUW41RzVob0JmSVoKYndxajBxOHJlemp3
+OVlPMW9sSjBKYUVqYzQ2dzRoV1poU0RTQnZoY1NUTXJYTEJqMzNPVnNwZ2UrT0RnUVRnVwpldXBI
+U04va1hhV2g4YnRtQWtJNkZja2l5YXUvK1ljbjRIVFAxUzZQdUJDY1NsRXl0UEUyeDBscEx5MWdh
+cjNaCjdac2wxM0ZOZWJueTFoL2dTU2hPVEFlb3hDbVJGMHhFSlJkclczNVFqajNUSkdzNFIzYXdK
+STBGU3dBUkFRQUIKelVwQ2IySWdSRzluSUNoVFpXTnZibVJoY25rZ2EyVjVJR1p2Y2lCQ2IySWda
+bTl5SUhSbGMzUnBibWNwSUR4dwpaWEF1ZEdWemRDNWliMkpBY0dWd0xYQnliMnBsWTNRdWIzSm5Q
+c0xCamdRVEFRZ0FPQlloQk1SNjNtSUh4OE1KCmpHNkQyZjg5UDJhV1ovWWRCUUpndmpTVkFoc0RC
+UXNKQ0FjQ0JoVUtDUWdMQWdRV0FnTUJBaDRCQWhlQUFBb0oKRVA4OVAyYVdaL1lkQzZvUCt3VEtq
+SldWVHNXZEZZQ25LZ2VIaGQ2QWIrS0txbGhacDZSZllRRGNnZVpnWFdPZwpyQkhXRGVZTFc2Wjgx
+Y3hDM1pNQkZlWml6SjdrTFVaQldQWXhXQm5JUUhCWUpsNllpRTdJblNNMXN5Z1Yvc1g2CmpYbjdR
+VEk5clphQkNDeXRKRHdmc3p5cS9QaUd3YnBZNzFyb2p0THVob2Qrc0M0S3RGRGpPLzJYMHZ6Yyt4
+bVYKZ3oxKzFqM1ZqY2U4UXhkNi9WRC9XWEZRY0tLRjZaRkJYR0RaOFp1bEJaKzlpWGcvS015WXJU
+dnBwK3RwaGlXaApvK21EcStYUTRobGZZd1ljMXpybS9PUW5TUTZhVnBLMzRtMHQ1TWROaVJqemhp
+Q1U0K3ZDeXZNSCtRUjF3eWJmCmZmdVI2YXNzZE1kTE9lUzBnNmVaODlJZHZ6bU1CNkYzV3lpUFp2
+WHFIQ3BOODg1a0pqb1lNRmoyMzl2NUJubmoKTHdYbXBzdmk0SWNIOUVPaXI4blI1bXZHM1hJQUt4
+TjRDemNpSmFYeGlXaWlYaVJnc1R4YXdsWFN5NTVZUk4yVAp6TDFpOFJPaTl5K1hkS25QY1VvN0ZD
+azlsdWgrTGVtMDI2dVdheXh4RHR6M1pEZ3NqeThMODYwVzR5Q2MvV3lMClRyVldBWGhQc3BJL2hv
+ZVZpSjVtNW1xeUN5OTRVTjc3WTZmYmdSK1BQSHFlOGgvZHdRZS9Tem1vNHVUUWpGS1gKWmFBMmdU
+b2tRM1NTS1Q1bytSQkZGcUF6UjZFUkkvWm0rbTlnSVFRQm4rTXJzNjNLa3pWSFREL05rVzhUYnpB
+TApjT3YzNEFBaWthZ2l3anJTY2Fab2l1Qi84ZkpMQ1YyVU13K2dReDZwSmpTV3Zpbm8vdUNLOEFx
+WXZ0TkN6c0ZOCkJHQytOSlVCRUFDbTJjZSt6cUNQaWlFN1Y5TGlCTXBERlllMkRTRzVhcnpXM1VQ
+ZHQvTEpMYkt4ZkJNT3hiamUKNGdmQUdDT2l1N1pGamgrN0NEenJXeTVYcmJMdnNsaXNCRmV6NGtQ
+eFNFYnRTakUwQXZHVDNmK1NrMjNYalVpdwp5MHhDRzFoZStnaXdJSDl0S1F2bkFSeXhEMGdKSkQ1
+SlRZVkZqdnY3R0d2OHRpY0VhSEdiM0lJUWpGUVBoSDdmClIzQkhySlppV0R2K1JrZW1vazNkU3Vp
+ejc3c2MvdWNyVUdTRTBGRkNpMy9nblMwMno3YzlPNUw2R3hMM1dxNWoKTHVIRy9obHJMU1Vhc3RV
+bUZsVVM1S2VNa3hWMXQ0OFo2VWZVYk1SVVFEQ2EzVmJRTUVabGdTUzFCcHpNZ0VkagpQQWJxbWE5
+UlBLSFRsSjNwLytCcnRWUzEzbmY2Zm5DcDgwUWNiRUlhN2hJMzIyNnBQL001T1lWSE1FZUZJcVlq
+CmtoVG9GamI2c1VJWG5MRFRBbGZWYTk3TVpHYVdQUVpmaVAwWHkzYXlBM3hxS0Y4NWlEY3d6SkJQ
+THMyRjE5QXgKY2lNUE9DcDR3ZFR2b3haVm02VElrZ2RoVS8yQ2h3SVVtUUhvczEzOUNzWnllbXds
+Ym8xN3lkekFuSHErM0xuTApoSXh3a0lyWlVoQlVSMVRidnFUakFmUjdTSFIxenZkSFNZa1NIQ0tu
+N2VlNm1ibHNYRmROS0NJRllFS3JYNTV5CmhZNE9BMkMycVpKREZuQmx1Wm1LSW1IZkFOZCtKQVlp
+b0lYSjh2WTBwWWZOdFlwMlpEdjRLOFJmQ2xyYzIzc1QKYWw4V0FBbTdsYnlOcFlLSG95dldjTWhE
+SWZaL1NEeXZzUGFLcXR0M2NWZER5WFlGak9rWk1RQVJBUUFCd3NGMgpCQmdCQ0FBZ0ZpRUV4SHJl
+WWdmSHd3bU1ib1BaL3owL1pwWm45aDBGQW1DK05KVUNHd3dBQ2drUS96MC9acFpuCjloM0M2aEFB
+bjdRRTlQUDVNekZsS2VLYWwyQUFSd1N0STloUExiMWs5QkJCeit0MW9WOTNNbWY0QTM3UnR0bWsK
+NENDeTFXRlNEQlJGbkdPeWlmcXFuZjRvZFdoNUdVdXVPb0ZPTk1ncmFUbi9CS1l6b3VIRzB6TXhk
+MUhTZ1dxMQpSKzRmWE44bXA1TVRNc3dPeGRFNWhjVnJjelpPMGVvUDJrWk1jeTk3bXNvOFBVUmVz
+UjcvUTh1WmI4ZXp2TjYwCjZyN0hFakFZdS9xU2E4dWNtdFNNdEM5Qlp6QjEwWHc1Nlh1UW4vVXBQ
+b2dMdGpUWUhNUSt5L1I5RkY4ampubjEKY05tNzV3d0pTeDNmemFTRjdvVFZDRFdPQnlmODlNcGly
+U1htanJrZEE1U0hEcEhJcjNQa09LbFRkM0hLYjN5UQoybzVjcjdwSzI5ZXNkNHhTQjFiK1k5RGpD
+WHlNY0Q2bG8xZFFLZlc4NFdKKytMNlhlbHF1ZGVrN3pFUUdUdWttCnFvVTE5dUxkTElJVklpWG1Q
+UFVmMnVWY2doTy82ZDlzZ3B3ZG5iSXB0NTZ6TDYrcDZIRndlTmJ5T0ZxR0RjTHkKR0g2UWdxR3l3
+bWtucmxHVWdPN3RzNCtlSGRhbmw3dGtLVlNwdEdoRXBSL2JuWjFmRE5RWkFpZFpJRmY0cVZXdApr
+SmN0ZmNhVzNhZDI2QVZXclMrVDdSZVhnT0drN0RCdXVxMkZWcDRWL2pLaytqNUs4UkpWdHFuRWZL
+aGZFQVFvCkMzdXJaMmtxTjhFbFNUVG05ME5JOWVjMThKd2wrV0Q0MnplRUJCaGE2b1hPWmt6dm05
+VEZCaStMemZmamQrR1oKaDNOYlhUZzIwMlRNTnM4K1BEekJyYjJxcHJWTDZSNmFHM3RvNFMxZ0Nj
+YkVlcjRlUTJrPQo9UkMwagotLS0tLUVORCBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCg==
 
---bf72b1411447b7342963e5aa0382c5
+--6feaabad2c151875184cee7e2320e4c6
 Content-Type: application/pgp-keys
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename="sender_key.asc"
@@ -89,4 +113,4 @@ T3VjaDdKeGNuCm9jSU1qSzM2VXo1VHpQT2dkU3grQ0JNRW1qcXhDVW5SNTV4US9KNTBpSTBjbjYy
 dDNiQ1AwVlRabUYvQkpEQmkKQXM2RWVKVm5HQlVvU1VET2tFST0KPXhyM3kKLS0tLS1FTkQgUEdQ
 IFBVQkxJQyBLRVkgQkxPQ0stLS0tLQo=
 
---bf72b1411447b7342963e5aa0382c5--
+--6feaabad2c151875184cee7e2320e4c6--

test/test_mails/CanonicalFrom2.2BobToAlice_1_0_ModifiedVersion.eml

@@ -0,0 +1,108 @@
+From: Bob Dog <pep.test.bob@pep-project.org>
+To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
+Subject: =?utf-8?Q?p=E2=89=A1p?=
+X-pEp-Version: 1.0
+MIME-Version: 1.0
+Content-Type: multipart/encrypted; boundary="7fdcc2331befd79f41a7c4c96b68079a"; 
+ protocol="application/pgp-encrypted"
+
+--7fdcc2331befd79f41a7c4c96b68079a
+Content-Type: application/pgp-encrypted
+
+Version: 1
+--7fdcc2331befd79f41a7c4c96b68079a
+Content-Type: application/octet-stream
+Content-Transfer-Encoding: 7bit
+Content-Disposition: inline; filename="msg.asc"
+
+-----BEGIN PGP MESSAGE-----
+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+=jmBT
+-----END PGP MESSAGE-----
+
+--7fdcc2331befd79f41a7c4c96b68079a--

test/test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey_ModifiedVersion.eml

@@ -0,0 +1,50 @@
+From: Bob Dog <pep.test.bob@pep-project.org>
+To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
+Subject: =?utf-8?Q?p=E2=89=A1p?=
+X-pEp-Version: 1.0
+MIME-Version: 1.0
+Content-Type: multipart/encrypted; boundary="32fff902684a481a579478fe749abb43"; 
+ protocol="application/pgp-encrypted"
+
+--32fff902684a481a579478fe749abb43
+Content-Type: application/pgp-encrypted
+
+Version: 1
+--32fff902684a481a579478fe749abb43
+Content-Type: application/octet-stream
+Content-Transfer-Encoding: 7bit
+Content-Disposition: inline; filename="msg.asc"
+
+-----BEGIN PGP MESSAGE-----
+
+wcBMA4rbkTfsG51OAQf9EI1NVefF1eD2GMmYDl448IuMevBqp+0Z8MFTWoLdH6Zi
+tMJb4WcJpBsUg6pcI/lkrheYT9006OuPYGwA9xSSfc7MGB1MN8M6zaJP2rObxFne
+2X+ShiG/y/yibzMpsOjVg2b+xj1zsszEJ+JMKgcIHays+PXQap1CtX4V/z1L1ZUw
+4Ryfjnhd157M7B5cGmaH0hvrfnoKg/f5rW4rxPNSMMnBWVmTRau0gcDpLeDKLKE7
+GN8ET9CIYThKDGMpzVVQ0PmNj41/IdC6o5QNFYVA4YL0sasujHKS5tdJoV3m8sjO
+dVnYe67hfb0FauZWXLnNquaVGpsRvj8ri8UfYlZkPcHATANaAgXZcwg/TQEIAIzq
+JTN/30ezqTkjtwqxpSprUMTry5o9U5ZllhLJyGCzSrx/Xpa4oa9XrL1t0Oj076Nv
+KPMgZyS8THa6LEQoCYC5PcMCdjrGieLufTZUvcPMLOXV6g6LhwTRgR6AI6IWIpKy
+xrv/5Y2b87foV8GxneJLBc49V/vH1J83QENOfyvJNMLvefOQLZzykZGcRG2otDSm
+PPVIVpwEH9Zm+kfkH/rIvQYGZxuV1nAY6DbrW9aoOV/PeUlR3pWaVSGPM5q5s19h
+cDATSvARtisPffQwFOheJhbO6raiyZLPp/zs3kZeR92LLx78GfPg2glejpYkbJDK
+vYcx9luo3yB4R+8w0PHSwiEBaFc7QD6CUYbIZRTPR4yuHzDTcH/xpLEU/l+J+1nY
+jQnS9TYhFThhSPJDpmzr9dKYZxqwHBFjRAOk7k0ZTP/f6EvjioipK5X/yx8EIb3j
+WaP2oUCW2P/Tvgb9rElrTJ+7xtx0zJ/sSdMonwjLwlcmYlqHRG34F7SLk+5Pnqis
+5ZV9MnxwImAmENGSsBi0kT911nnBNLzfdIsug3OKjfnm/5rdyRxmLrAYcsomdvAe
+y3Pp17prLs+7g4l3QdFllLL/k5PU0ytsKsPEf4M6g5Yu609DGuQru3Y8D87TaoT7
+DxotkhX6rxkUZGzT8wr/96XLbEZx1mdiuoTmRl7npjA2JdgOKeVp6JY7b0dXTD6+
+znHD9sxjsyYJjLW10ogVvybHjEOaswyipKiBhkBNOl7COJv/Dl3U4ZaaloNbAAOS
+E1TjPKjrslyI3Vo+XrqTA25ULogEK1lhVxWKUgIo0j4xcriXQakj4ZkJnEVUVHwn
+vSN39ObZ8ij19x+o3kSjL6ef8DWzJZzLYlMkblB6VIO3/7sxovINdIpdEA8tcZN2
+YngsIAFVPGJyZ2RQ3pG+KHNP5GGC05qDAUc0Yetd9sfyY0lWBKHfdJqKW+jzdm+n
+TIxcPAKdi39uQ9E+c3qwHr4dUJIO5gTSUyt4twF5ZwxV+Db/Gyvvp2Qawf1yDEcf
+Ucg5cESy5aJaZmllHlSzZc0NT4aSZ1nff93DxT6nMc2+VYBBPgVH1YmI8iOXpueZ
+zYEpVAyMywAUGho41k3+s+lvv1j/5R68IvBBvhvqIl6PA7MFlQac4JgoYfsOkcLA
+l3XEjGC4wI4fkMGxQ05oqhknTaQ1JeUmLjveiGIaK9ytbtQF8Nas1c5P7saYR/D6
+3ZgsqWwOMZWoMlH88d+AhhXS4/1RbnOu2jGm2aIitPioTB8Oy3UzlqojfPrlkBNy
+RfEvlOFQo/0Xv1en3EjRDvCINSkYI2yvVehZmSQClbd0Dw==
+=n4ly
+-----END PGP MESSAGE-----
+
+--32fff902684a481a579478fe749abb43--

test/test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey_no_pEp.eml

@@ -0,0 +1,49 @@
+From: Bob Dog <pep.test.bob@pep-project.org>
+To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
+Subject: Not pEp
+MIME-Version: 1.0
+Content-Type: multipart/encrypted; boundary="32fff902684a481a579478fe749abb43"; 
+ protocol="application/pgp-encrypted"
+
+--32fff902684a481a579478fe749abb43
+Content-Type: application/pgp-encrypted
+
+Version: 1
+--32fff902684a481a579478fe749abb43
+Content-Type: application/octet-stream
+Content-Transfer-Encoding: 7bit
+Content-Disposition: inline; filename="msg.asc"
+
+-----BEGIN PGP MESSAGE-----
+
+wcBMA4rbkTfsG51OAQf9EI1NVefF1eD2GMmYDl448IuMevBqp+0Z8MFTWoLdH6Zi
+tMJb4WcJpBsUg6pcI/lkrheYT9006OuPYGwA9xSSfc7MGB1MN8M6zaJP2rObxFne
+2X+ShiG/y/yibzMpsOjVg2b+xj1zsszEJ+JMKgcIHays+PXQap1CtX4V/z1L1ZUw
+4Ryfjnhd157M7B5cGmaH0hvrfnoKg/f5rW4rxPNSMMnBWVmTRau0gcDpLeDKLKE7
+GN8ET9CIYThKDGMpzVVQ0PmNj41/IdC6o5QNFYVA4YL0sasujHKS5tdJoV3m8sjO
+dVnYe67hfb0FauZWXLnNquaVGpsRvj8ri8UfYlZkPcHATANaAgXZcwg/TQEIAIzq
+JTN/30ezqTkjtwqxpSprUMTry5o9U5ZllhLJyGCzSrx/Xpa4oa9XrL1t0Oj076Nv
+KPMgZyS8THa6LEQoCYC5PcMCdjrGieLufTZUvcPMLOXV6g6LhwTRgR6AI6IWIpKy
+xrv/5Y2b87foV8GxneJLBc49V/vH1J83QENOfyvJNMLvefOQLZzykZGcRG2otDSm
+PPVIVpwEH9Zm+kfkH/rIvQYGZxuV1nAY6DbrW9aoOV/PeUlR3pWaVSGPM5q5s19h
+cDATSvARtisPffQwFOheJhbO6raiyZLPp/zs3kZeR92LLx78GfPg2glejpYkbJDK
+vYcx9luo3yB4R+8w0PHSwiEBaFc7QD6CUYbIZRTPR4yuHzDTcH/xpLEU/l+J+1nY
+jQnS9TYhFThhSPJDpmzr9dKYZxqwHBFjRAOk7k0ZTP/f6EvjioipK5X/yx8EIb3j
+WaP2oUCW2P/Tvgb9rElrTJ+7xtx0zJ/sSdMonwjLwlcmYlqHRG34F7SLk+5Pnqis
+5ZV9MnxwImAmENGSsBi0kT911nnBNLzfdIsug3OKjfnm/5rdyRxmLrAYcsomdvAe
+y3Pp17prLs+7g4l3QdFllLL/k5PU0ytsKsPEf4M6g5Yu609DGuQru3Y8D87TaoT7
+DxotkhX6rxkUZGzT8wr/96XLbEZx1mdiuoTmRl7npjA2JdgOKeVp6JY7b0dXTD6+
+znHD9sxjsyYJjLW10ogVvybHjEOaswyipKiBhkBNOl7COJv/Dl3U4ZaaloNbAAOS
+E1TjPKjrslyI3Vo+XrqTA25ULogEK1lhVxWKUgIo0j4xcriXQakj4ZkJnEVUVHwn
+vSN39ObZ8ij19x+o3kSjL6ef8DWzJZzLYlMkblB6VIO3/7sxovINdIpdEA8tcZN2
+YngsIAFVPGJyZ2RQ3pG+KHNP5GGC05qDAUc0Yetd9sfyY0lWBKHfdJqKW+jzdm+n
+TIxcPAKdi39uQ9E+c3qwHr4dUJIO5gTSUyt4twF5ZwxV+Db/Gyvvp2Qawf1yDEcf
+Ucg5cESy5aJaZmllHlSzZc0NT4aSZ1nff93DxT6nMc2+VYBBPgVH1YmI8iOXpueZ
+zYEpVAyMywAUGho41k3+s+lvv1j/5R68IvBBvhvqIl6PA7MFlQac4JgoYfsOkcLA
+l3XEjGC4wI4fkMGxQ05oqhknTaQ1JeUmLjveiGIaK9ytbtQF8Nas1c5P7saYR/D6
+3ZgsqWwOMZWoMlH88d+AhhXS4/1RbnOu2jGm2aIitPioTB8Oy3UzlqojfPrlkBNy
+RfEvlOFQo/0Xv1en3EjRDvCINSkYI2yvVehZmSQClbd0Dw==
+=n4ly
+-----END PGP MESSAGE-----
+
+--32fff902684a481a579478fe749abb43--

test/test_mails/CanonicalFrom2.2BobToAlice_1_0_TwoKeys.eml

@@ -3,161 +3,200 @@ To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
 Subject: =?utf-8?Q?p=E2=89=A1p?=
 X-pEp-Version: 2.2
 MIME-Version: 1.0
-Content-Type: multipart/encrypted; boundary="2df6d64846b7d4474a2ac31539ee015c"; 
+Content-Type: multipart/encrypted; boundary="21d16ce04e65e34b57f06df123987fba"; 
  protocol="application/pgp-encrypted"
 
---2df6d64846b7d4474a2ac31539ee015c
+--21d16ce04e65e34b57f06df123987fba
 Content-Type: application/pgp-encrypted
 
 Version: 1
---2df6d64846b7d4474a2ac31539ee015c
+--21d16ce04e65e34b57f06df123987fba
 Content-Type: application/octet-stream
 Content-Transfer-Encoding: 7bit
 Content-Disposition: inline; filename="msg.asc"
 
 -----BEGIN PGP MESSAGE-----
 
-wcBMA4rbkTfsG51OAQf+N0rc1BbyX/p4cFEN3i4st12GMdfyNCAYO+iz0T1AnoZ6
-0UO8TDPYF8LfcuywNjy5BbPtgNEQYVb6/01aaS77XPwASqbvY2tYL3bNyGHek0Ye
-pR16hpOBFNsujI8k2ZrypFZOGM6bmFd+8mkT1DQQzJnsBFUgYJqgqKxGEw+7MAgi
-KdneDQ2bkX7qYbMqa2HxNQ+nHcf0l7X73cJVofg4TmtEPKcsd6frUZo8c2ykWs1m
-I11mFb7Mv5b/sYaQfiSAmu2fek81LHCcBwRXoZAGLQXBgtHoWApNW2b83awW8xLA
-Sypjkj32EFFZULc0cV5bQgU5xbGSiOVzedW8FkLDIcHATANaAgXZcwg/TQEIAMjv
-g9Q6Via/oGHOEEXmLUDFoCwJLNXulfOtgb8sOYSdh8Sby1YqcBMNUizUcUmI7Tuk
-K7xEgy35FFJaIvcIcSEgaf61zwQroDKA57G7+fDN2PZ14FT7NWqiZNVQApbsE3BE
-SVR5yiaecl02cyrfHKCDwq8Cf7cUYeGcDOUFl3fSH8BL9BWl88tXh8x+bxhZ4usw
-CmpOYxLwHsDmEgFKhC/qYk3daQLvR1c8ZaDGoWcsqOxg2GyXint+Nom40y0jNWgk
-alBBMyrnQfm0b3qArjT9EeSi+plgxKwmCQSK0fEdLjABkmeIVAtw3Ah30j0xX9/W
-j/+Fb7AmgV7UnkeTv3TS1zUB9+T0mjnPjYvkDBev/TX33duIJdxNeHPeezb5dQRl
-7hGRNnbauSyZeQNhuRcSAhZm41W1HgeO+eFKbdtuaHhczdjFHsbtXacLjeHg+aRL
-QFHHrcmlYcFS4CoV6zYu7hKsWzT7QeyJk4Wlkpi/wVskQmvlsmjjmEOjbR+i0SpV
-fZvW84EZ80+PeJm1Z265tAzxUL1GZefnMJH96gIJSu9EPnWReTqu7QFCJLHFVru+
-SKyfMBhEvRS6YXp3+4CE2QNof6V79Z1a36QD7obO1FYOR0XaEzNHja3GC3jA3cs5
-80Eo3vzPhkMvwQ8vxDdS0Z6D4SStcASXneVZQY7AEXqbCatV1D+0AAHeyA3kKtN3
-ZkgPyaHPlKINWJ/z8J4PQfvfSKRtQb8DhICm/yMLe0wMgdxwtIOkWgqadx0BhNzn
-B3JPr9oBMdbSARDztKHiLj/LdpeKzmAjEeXzUlVXesIG/8m2YXwWTKDyCkwe84tY
-fqLPHXxhG8Iaig9rAR74Z0P1r5/JUHw/z15rF7IX5UGuS7U8MOStypzDyTtT3ZYs
-Q4T7pe5PB6LHyp4bJRLKX9T7M9AuL5Nh1HJ0/mJCszWBzJqAFfmMwGbz38WXTfWl
-Y/JS6TOy23X3glNnopPl1NitaHjFU3LYkRKLn8QbsVne8lXiSAbd476raeqEuJU/
-Gf92b2pvyOo+s4UwsbV/aG8shzgWWaT0qrv0SkeQiqziEHhzQDcW3DCyprSlMJEF
-AS4O6JautMDIfyZilprmDvsJZUpGH2RbPn+XBa+u698FWfroxCwzaLyGXlKEyQPD
-NteOCKvz2X32Djvsgf/gjLjmMr1apLJV7EuDtLvAC+egtENv4DCqsTduwwoMzWEm
-PXBbPRe73PSyhvmPMlmA/efgjDZUBegE+WSvtHKE5ojc7tj1BEKbAKE5XJ5+XIIi
-6OFBX1yUadVUKoMFbgkE2urbx+bkyEx4uq7dxDimcvE/2038LllokbLDJi8/2guA
-u33h9vG+8r2Brt032sKb9K1fO90yNJ0RoceSaAWVSo2O5fp46nTqMHKkKvL5/7wy
-uxCmk52IhEDnlvuqsLakX2HaVxAsg/EXmeKdUcd4xKswXArDvTGhyQ89El8QMjJ/
-E6e6TKf1oCrgp9Fupc/B+W29SnzurY+Sg3R+thC6aclvoeWYELtxL3TL2nMWUhH2
-0iSmp6nuex9+VksqxbQg6pSRH/RRTXG66xvKJgvu+udPbifbb/BwumuZM6u+1vMe
-0Ey6WUT1lDhgtArZRKdml+8dvuFKqah/DRfExwSrvBaP8lUoIazNddt5qYLQa+UO
-rLoIylH9iHQiAqTuSslzcDHgkJA4ctk6gCPcWlSNhKjVWqNzhiYIOqJ2wDMuTArp
-Xkp/0j1wB8snIHjs5ktQtYl28Brqr+sG+yHOgoROl+q/eTsbFsXl9nXrM+CIQyp4
-r+AFh2vjj6b7RH0lg/EuOxqbFulLTuUeDX6Bj2FIlqT1xQhU9xLlGnzqxbS/enmE
-wLzLcxQHvNMX4UgO2Tcy999UmgX8xw9PyDQ6zmo1QKuLErPCk4vqzNQ2kL9Q0c4f
-q3Lnngjsunz7dQB+VZMd2+ugIq/9OssR2jn7vHzuaOSZTd8/gh+7JlIlWdW/Lcvu
-+gInl464W4yLy5KJpcDSKfvBQ0klovdhj8K+h6iEJAgfQibDI/QKoxZfJvonV40o
-Yw68iI9uOR+TBeRdlktKDlUD/trehA9AFSB6kg3RVaJFoLEuDjWu1SL5DAJ5pOq/
-IJDuJS9EecVCRHyvQwdJdD3CBLVBJIM//9DVKcQXVhbrBgKZOiSJm4EOtCM/GQas
-BB3MR1hTXrZYE4c7Xn8AhG7XjfCGWipU5++LHUjKsHPxbxZphYIz8x+hFK0siT8k
-4dJZ7oxLK0a2u1ASeuttS66MKK+VyMo5pTIl+7G7ib+mX+Rp1nNg1sWvtrHkt7kh
-E52PoUnHbmE/iOpbDFI+TRuSYTbGHWRRCCurdP9EHsRiXXatVaOXW13BstxbXOVk
-ImVkMmOv4x7HfjTIFvHAcUokpFeMLgXAgMYvI6/FnfKbnzxlclW6oBm7GcEiFCST
-Zsk3pT1d1zmX4xP53EEX+xdMujE8eUIk38ENO3I57LncvFbysSnX4aRmlUmrVIq1
-Sci0ma+GdmYCcHPEMTyWpi61ZWZK39iqtY2FVY+JzTroOQ8cEC9Cv8pRwtb04Xnb
-LigMJwYk+GGK65QvTK6BIgMYO+8C091xZ05L5od8pasFMhxDydmgq840xadJw3ag
-/hoDxMicWbH77JZPsvuLPV0a0UQhh4+YZJAeoEmL/bhQDhigAAzZ+cxDXQ6pywyk
-ZKErGpITY0wJWZiAC5k8A3HYnqzqGjugPxw3JLlR+6lLavvWNuEnj8ZHQUkDO8Nu
-g9dz8tomwcIvXJ+SIrUTmuKdiBq5xVgRgpGYAzfhl+N8SngCLfiNu+fVfRzoYeUe
-9GvGNKdky1bu6NwpD5lgF2Ld9xDi9ZnpP9rAAvPFhoT6jwGzxh6+J/ukbedI5sth
-yGsRWrmD2jIeYO1OM8xVoESY71tbFWgaxp66uAmCzla0s+JvZ5vKjkTIZid1iFj9
-EMV+fhnrXucBRdlrONNv3fDMdX0TxieOOqzbofBqi8N60dUfniQz489EpAGEd+cb
-NI2u66b8Kx4dw3rxvLV21bnPMc6C7zfVEHudgZd95qBuwcwmufM+662dxQJ265hH
-WsBF/i2KK8wRY9vtYof1TGbB0y0hV5GDl8a15OM2OO0AgJVaNZgEnHWVKWNVneJB
-cIAsikPMwsnSWwcDe9u7NXQEiyPBZ5ibBznoDYcVt/I32Ww7QDNZmAcww+AkSjWQ
-ucwvFqHpJqWgpuf2kFq+Qj6kVqXGKMFP1aql1KlWVAzjLBvF0UrMu8InwwAHGRA1
-cUS4Y8UzcLj8rZS2Rs5/KZX+FtL1A2sJVjFztAGFcsOzj1D2Sl21M7R+cYUXsIBE
-NwX/7Ce1XuThc/Y7nFh3+kzVV3Z06y9Q2Jawz8NymOyMI5Ex28VltTaDvj1ozpQ+
-Xe0nDKLQOgcsAP/mlGPjEAlobyfvnRr9dGKhEmCcG+7TByhZM+kMfPoA7C2GnQ4B
-b2EmXQpb+KZCIDn/ReI6ADHAQkpK5atCazP0/saM95ZIiA0eVPe+BIzyTWfT3bE/
-uZ6Iol1Xj6SAglue28/w9SfTmgQeRFcax8IER6OQFaB9uvgOPDptL+KQ86WdnNra
-gx2VdwBW6s5/TcpN+niXiObwgq5/9EMHiDhqOOqfMlhLetxEjzAQ1pfp+QZOBLlo
-63WHEkkQejOvz9O8YcTG/WkuRiueyh7G+zPeF9sauthe1dFvnY+QCZnVTQcq1h/L
-27z9054d6g0IJ/C13OrJJ286N69p11XECDjeaA981OkIHqcBblSApamPW38eRRxx
-04a4jTWaFSjegOMME/RApVcA8NBrAZKhC143Emgn9TH0bNgnMKKWC5ifedKDZPgv
-sAiXZJti1p99DkbbWIAEiC+8iztrncqlWZVYhUbZJnniD3g3EIKnBapl3zdWhFAN
-GrY4BPDwTml54MjvCeaF9MxyafKDllAyIPZfuPv8EtkuwyN7SGiA7qThc5Ij+u0y
-Sr9IPo8rJX1BPt7FP8XX+kdVcuPkABaK2YDiL/bKnFKl8AuYJJsuMGflgjl8Bi2s
-Px4z6Yp+RBytWszDDwixPJBrY+3njCu4XvGtrlrUvc0UKQWsGMvXboXrWdRNCYOY
-ySGUxBaQwFvd744vltX3o639jeNZuNXCyZ5jnPnovznSMnPZIIR3lNqU3of/iKOn
-jkkMYDcBdAj+PFd14vWLFjDC3+GFn9LKb9hY+d8WAei/E7WMH9P1aQPXvo8BkYQm
-9XBybgRCJByPI2Oq5YqFUFXlt6K986sIQ5NYl2l6dk4Yrbp/V1zQdDnDWKQRzEpz
-3h8YRcCDZSHYF8XBmfgscc6fdSrlbECGekAascRQTYsjwDNaFRHltmcagFjBorse
-85Sg//J6UC7kxCfRP/X0bpJv1tpqTPYQ8EDROlt1YnjgQg6IPG1r/ATliI4xrXdL
-pflSCr0RsLWAMDoo3352Ox108nho0tOD39cg4P+OSm7GQLTnI0es+iZIAzw05Tj+
-pMDOg5XKUqI+tBZORCb0AXZKQtjlY3JL3QKHNwA/2ytpT9YFLMH77jQX+pi1Ahzf
-tUzU4TM5M3oWz4lC/1TwMuYw5GNzi2lyHW5hw+1noxACXUTHBHDdUZYmUNpeB5Us
-3J23/OyXUOgrFYVRlaVAZEeDDUsGoY7I34C2bi9av7/a8zVB0RrLCW/+ByeM8iCQ
-aOR56J9fkzdtgV7jGXU0NBSTxHaihMj1PGaIxKcWXkJmgcLX2EuEWOo78KywKvN/
-JMlLC1so6dQBFw+26fiXfmIWeGZyOHiZhv3RSyUWQUEIT4/LuUsVSgXgHlWEetmh
-OcmuHqdkbANa/IYPcGa551z60McamILo0d46Adi7bIqrFMDVuvKzVzCqQuOb/2Te
-1lOjzWrWAf4C5qphopllVnSYZR/f5wCoYqbAd7HU7MLFC0903GTr7GKpSLspwLaq
-40w2fe9pemEsd4fjuXYFUFbkurOIDQy12WlGXxt3vvJhvlWb4hqF4+ltD8omH3Lk
-IbIMXn27zfW1w1u+j+Mim8rC+dueeArkva7PnwsnZik9qDUzhSQrru7DWiTxagn1
-6cTJla3NxsxXzp02lw7C6I6AsTkKLQaaO0d5Sj0LJYe2Fvp9D3om26RzsDL890ha
-2HHtiL1nZxQRLAKgzaqR9yujLBjqJQH1a8S3c1q3P/f1Wewuvt/YStJR709z7PYm
-JWgYLbu3FU2uR4pHhucaw07JxMQElpH6M2DX1qkLobuftWV0L0Wl1A9NDS48aq+i
-C5qW6YgrQIAg3iCmDRbcGjbBZ8MRKFsnXUnjLSTH4B85T7NK7i34LooPWKUO5Y2T
-Egw5nybgoFpdaH9PFgtFeItxqMZboEsm/7kYkZwz/YB8mdI5JEv6PjfdWXfP+caj
-aiclN69Y89c7O0iZYeWeXLhyGMeh0HD9h+2nXGtb+Y03cxloIcaMPe46uP1T6DsV
-u3mlj5XUKWtpZMeYib7qDujQ7LoqPLy7tZBdSqeHgebJnXw6KJNoZK8l6ImJWAGx
-9FAzJl8rIBBi8vGJeHtWuExk1HNHu7p9WnajaB7aG/fYDERoN1A4U0pus6WFZo67
-KC6XjDPjqGlBlDQXlQeHnypRdk3x+n6fTOSTIYchikLCFVq6JoMuoUB5s78JjMVe
-lAPLRksoIU6doPfOOibOzEtVjeIkqkdYcfUbCBdgL6WyOuxbI7GiiffDW4I1d4H+
-JPWmyP69eeUq2m2N2nZFPZPnNOjhoG8Fx7vZKl1NPxUfmHRVYb/Hl9dAaD/HmPyD
-E2eN+pNhRhr6H5/dlL6aOrMwsY3fEPUz/txhFoiv98Zj4J30adIXcjVY0ETbrAeE
-6d0lYNkfevYfgD0RYSfiVlH7LV4enIB4d2HwtmD+evzBV8uHD75H3IxhulRc8fkg
-seM+rt5CbrGr8ik/3YbkWH4CyhG5+Qm90loIHBMEXZUvvZTOrac1Ia30/TXpOHHj
-Y/B/05y58lB6sH+94hVJccpyzDBHB5z/96PLUseuPjLNAxhH7ACWWCZJx79T0s5G
-F8mXB5edJkINR/H6hlruCCHZP5ItU9YkloGAKlar97YzEll1+EqHODJwyM99nfJQ
-7PT0QzWqlhvnp+7DrOk4rUIyal0TpkcgADpWfb9f7atCYorXo1aYTtcnTZqhe2ct
-JTCx/AVXFYqC1LvNqmmrIvgp3+UUbn5Au0xSFNjJps7hGhTxuIRFgKqOAzyjxZT8
-Osdlv4xQIFPZdjvXBrBz3hiKTrRuyXqG8fZV4axi1YVK3BG8pB8DUKKXwEMKeGe7
-Okx6tj96trzW5/9IXKPeOBTETHczWNI74n3YIfY8/btSmQJFM3j+xvj5RceZh5Ic
-YrFeqj/yXFtz3bLZq2TJd8ff8cK55lTg4W+47MZbndtCQDxXXJF5/XN8K20gUfcy
-9L6M7pHxEmqWGJx6QwSMF+aOoUuA3YWKnhQpzxtOstRfqxRCfVQXK2O2rriEds+H
-tF8aKX+iI34VCKUKW/3LiW/U406tc0z5PZPKd++1W9sWrK8eaXma7rnpzQ0vUvVP
-lVTP5lMyWkC/doiH2HapA1YlQAGHUHbpTq7NmFVUd9oBrRPIPVkBytAKCfPJHzR+
-0590LZ93iZyepvi/9UbFuKrteJxi8hNArMRHkRdJlNVIJb046JZbtGAsioSjFUvQ
-ebFPDh9f5Z48O54A0NXyo7koLSfzWg2IBwSLg57eYr9bH7mRmfFurTBJZNdyMD/X
-eFo6Vk53Du6Ag5cDh+yB4mefJPOITm33UmaMNlEywCcv5TOq7nGuE5iljZOHB9VX
-cYT5c5oTGNV6AnykQW5OsZ40ynoDlZvfCJ5qq+hwgnolUB1TeUMBuYlafDzjiEnb
-FvfW6xwbuOC08LhYS4NHKa0ZbtWPZP1f5V2fszzrKl+m8JsST4f2mldMLWZxiHin
-W1kFsVpqY83LEQ4FErmfs5vqHdy4lHW2kR1b9krPubsSe8EC7f9QHPmt+9z+kxCd
-dkZOMzWmLY9xIp8eL3lDHnUt7dlus5BPrxnxlJCW5dkCAmk1rnZXRfEEPj2AkEve
-djPYNO0a0c6ChyGh5YPiMjhsr0DrsaZ3xU3SF4nusoqeVYsYcFRQtJpnDPi9xDJY
-OTbXwvTFLKyipm66w5F0JtNmKlnMCoNm+29X2ZDbBm9+vgmN4VfRAE8wKKHokQXX
-1uisGNn2EhGnr5qw8MUHuNvscajcifQlkTiZhXJF1j7EgZ7WzL3OhUziIiwzkj4l
-xOwPZwl7Go6du2Ds8q5RyFb6OJ0/LAMqjyVq3GNGSDI/FQUKc0DHJtSedmW5VTAr
-s2PsOF5c79CaQOXpVP+dIheAC3Wtz25oWXPWHwFOCJ9xWpi0AClRp+5WCSAZWUc0
-7RQKoxcstDgzDPeT45nBgm3VOe2qqMjSmqgtf0A9Ej8iqoQPjRiRS/gJ9r6S+799
-xjAB2bb0Sj3AJ2JPNSgF0/vkHKa58fxZnjFRSxTYkuMjbfrQTBDw+MadGsLW+O3e
-dkMvAr6/RVklCsGRnpWyU9xE/1S6bt39acKGJUNHy3EkiU/VNOq9GLBk4A4bTdGt
-Av9+ODMzO+ewCDco9mKN8bTGG7KzrKpIk5I3nmxKqp3Io3jZfHXV5EfSz/HGDxRv
-l/fkmP4LL0pbAD2U4IlKoGzeL4jfFwz1H2zzdA9DuNwkQBsjRcnJFf1p+ooFihIu
-jZ5VE1yOVVUDH5I59RQ1rWRVXTnXjVFeMvZ1f/9r8KGV0eJ9tIdgLHQkUKGQ8Jnh
-vq8rOI5UjUyGH7sbA5byYmq1b+IdJ1ST2yy/rrOR+JakEM7XaTuYlKulJeqpM6eU