Browse Source

ENGINE-633: some testing stuff. urgh.

doxygen_doc
parent
commit
b14fe44726
7 changed files with 1564 additions and 0 deletions
  1. +1
    -0
      src/pEp_internal.h
  2. +731
    -0
      test/src/DefaultFromEmailTest.cc
  3. +10
    -0
      test/src/test_util.cc
  4. +2
    -0
      test/src/test_util.h
  5. +58
    -0
      test/test_keys/priv/big_clumsy_cat_0xC6406F81_priv.asc
  6. +30
    -0
      test/test_keys/pub/big_clumsy_cat_0xC6406F81_pub.asc
  7. +732
    -0
      test/test_mails/unencrypted_OpenPGP_with_key_attached.eml

+ 1
- 0
src/pEp_internal.h View File

@ -61,6 +61,7 @@
#define VER_1_0 "1.0"
#define VER_2_0 "2.0"
#define VER_2_1 "2.1"
#define VER_2_2 "2.2"
#include "platform.h"


+ 731
- 0
test/src/DefaultFromEmailTest.cc View File

@ -0,0 +1,731 @@
#include <stdlib.h>
#include <string>
#include <cstring>
#include "pEpEngine.h"
#include "test_util.h"
#include "TestConstants.h"
#include "Engine.h"
#include <gtest/gtest.h>
#define DEFAULT_FROM_TEST_GEN 1
namespace {
//The fixture for DefaultFromEmailTest
class DefaultFromEmailTest : public ::testing::Test {
public:
Engine* engine;
PEP_SESSION session;
protected:
// You can remove any or all of the following functions if its body
// is empty.
DefaultFromEmailTest() {
// You can do set-up work for each test here.
test_suite_name = ::testing::UnitTest::GetInstance()->current_test_info()->GTEST_SUITE_SYM();
test_name = ::testing::UnitTest::GetInstance()->current_test_info()->name();
test_path = get_main_test_home_dir() + "/" + test_suite_name + "/" + test_name;
}
~DefaultFromEmailTest() override {
// You can do clean-up work that doesn't throw exceptions here.
}
// If the constructor and destructor are not enough for setting up
// and cleaning up each test, you can define the following methods:
void SetUp() override {
// Code here will be called immediately after the constructor (right
// before each test).
// Leave this empty if there are no files to copy to the home directory path
std::vector<std::pair<std::string, std::string>> init_files = std::vector<std::pair<std::string, std::string>>();
// Get a new test Engine.
engine = new Engine(test_path);
ASSERT_NE(engine, nullptr);
// Ok, let's initialize test directories etc.
engine->prep(NULL, NULL, NULL, init_files);
// Ok, try to start this bugger.
engine->start();
ASSERT_NE(engine->session, nullptr);
session = engine->session;
// Engine is up. Keep on truckin'
}
void TearDown() override {
// Code here will be called immediately after each test (right
// before the destructor).
engine->shut_down();
delete engine;
engine = NULL;
session = NULL;
}
const char* john_fpr = "AA2E4BEB93E5FE33DEFD8BE1135CD6D170DCF575";
const char* inq_fpr = "8E8D2381AE066ABE1FEE509821BA977CA4728718";
string mail_prefix = "test_mails/default_keys_test_ver_";
string mail_suffix = string(".eml");
string OpenPGP_file = mail_prefix + "OpenPGP" + mail_suffix;
string v1_0_file = mail_prefix + "1.0" + mail_suffix;
string v2_0_file = mail_prefix + "2.0" + mail_suffix;
string v2_1_file = mail_prefix + "2.1" + mail_suffix;
string v2_2_file = mail_prefix + "2.2" + mail_suffix;
string v10_111_file = mail_prefix + "10.111" + mail_suffix;
void create_base_test_msg(message** msg, unsigned int to_major, unsigned int to_minor, bool is_pEp) {
pEp_identity* from = NULL;
PEP_STATUS status = set_up_preset(session, JOHN, true, true, true, true, true, &from);
ASSERT_OK;
pEp_identity* to = NULL;
status = set_up_preset(session, INQUISITOR, true, is_pEp, false, false, false, &to);
ASSERT_OK;
to->major_ver = to_major;
to->minor_ver = to_minor;
status = set_identity(session, to);
ASSERT_OK;
status = update_identity(session, to);
ASSERT_EQ(to->major_ver, to_major);
ASSERT_EQ(to->minor_ver, to_minor);
message* retval = new_message(PEP_dir_outgoing);
const char* shortmsg = "Exciting subject!";
const char* longmsg = "¡Feliz Navidad!\n\n¡Feliz Navidad!\n\n¡Feliz Navidad, prospero año y felicidad!";
retval->from = from;
retval->to = new_identity_list(to);
retval->shortmsg = strdup(shortmsg);
retval->longmsg = strdup(longmsg);
*msg = retval;
}
private:
const char* test_suite_name;
const char* test_name;
string test_path;
// Objects declared here can be used by all tests in the DefaultFromEmailTest suite.
};
} // namespace
// Should be rerun to generate additional test mails every time the message version changes IMHO
// Add in more version strings I guess. So inelegant, but... sigh. Who has time? Not me.
// You can step through this and force some other paths to generate other paths and create emails
// which will be otherwise difficult to get, but that shouldn't be necessary beyond the first time
// this is written in 2.2, I suspect, so others should ignore this blathery part.
//
TEST_F(DefaultFromEmailTest, check_encrypt_to_OpenPGP_simple_key) {
PEP_STATUS status = PEP_STATUS_OK;
message* unenc_msg = NULL;
message* enc_msg = NULL;
create_base_test_msg(&unenc_msg, 0, 0, false);
status = encrypt_message(session, unenc_msg, NULL, &enc_msg, PEP_enc_PEP, 0);
ASSERT_OK;
ASSERT_NE(enc_msg, nullptr);
// N.B. Actual check happens on decrypt later. But we can check that the encryption path doesn't fail, anyway.
if (DEFAULT_FROM_TEST_GEN) {
char* enc_text = NULL;
status = mime_encode_message(enc_msg, false, &enc_text, false);
ASSERT_OK;
ASSERT_NOTNULL(enc_text);
dump_out(OpenPGP_file.c_str(), enc_text);
free(enc_text);
}
free_message(unenc_msg);
free_message(enc_msg);
}
TEST_F(DefaultFromEmailTest, check_encrypt_to_pEp_1_0_simple_key) {
PEP_STATUS status = PEP_STATUS_OK;
message* unenc_msg = NULL;
message* enc_msg = NULL;
create_base_test_msg(&unenc_msg, 1, 0, false);
status = encrypt_message(session, unenc_msg, NULL, &enc_msg, PEP_enc_PEP, 0);
ASSERT_OK;
ASSERT_NE(enc_msg, nullptr);
// N.B. Actual check happens on decrypt later. But we can check that the encryption path doesn't fail, anyway.
if (DEFAULT_FROM_TEST_GEN) {
char* enc_text = NULL;
status = mime_encode_message(enc_msg, false, &enc_text, false);
ASSERT_OK;
ASSERT_NOTNULL(enc_text);
dump_out(v1_0_file.c_str(), enc_text);
free(enc_text);
}
free_message(unenc_msg);
free_message(enc_msg);
}
TEST_F(DefaultFromEmailTest, check_encrypt_to_pEp_2_0_simple_key) {
PEP_STATUS status = PEP_STATUS_OK;
message* unenc_msg = NULL;
message* enc_msg = NULL;
create_base_test_msg(&unenc_msg, 2, 0, false);
status = encrypt_message(session, unenc_msg, NULL, &enc_msg, PEP_enc_PEP, 0);
ASSERT_OK;
ASSERT_NE(enc_msg, nullptr);
// N.B. Actual check happens on decrypt later. But we can check that the encryption path doesn't fail, anyway.
if (DEFAULT_FROM_TEST_GEN) {
char* enc_text = NULL;
status = mime_encode_message(enc_msg, false, &enc_text, false);
ASSERT_OK;
ASSERT_NOTNULL(enc_text);
dump_out(v2_0_file.c_str(), enc_text);
free(enc_text);
}
free_message(unenc_msg);
free_message(enc_msg);
}
TEST_F(DefaultFromEmailTest, check_encrypt_to_pEp_2_1_simple_key) {
PEP_STATUS status = PEP_STATUS_OK;
message* unenc_msg = NULL;
message* enc_msg = NULL;
create_base_test_msg(&unenc_msg, 2, 1, false);
status = encrypt_message(session, unenc_msg, NULL, &enc_msg, PEP_enc_PEP, 0);
ASSERT_OK;
ASSERT_NE(enc_msg, nullptr);
// N.B. Actual check happens on decrypt later. But we can check that the encryption path doesn't fail, anyway.
if (DEFAULT_FROM_TEST_GEN) {
char* enc_text = NULL;
status = mime_encode_message(enc_msg, false, &enc_text, false);
ASSERT_OK;
ASSERT_NOTNULL(enc_text);
dump_out(v2_1_file.c_str(), enc_text);
free(enc_text);
}
free_message(unenc_msg);
free_message(enc_msg);
}
TEST_F(DefaultFromEmailTest, check_encrypt_to_pEp_2_2_simple_key) {
PEP_STATUS status = PEP_STATUS_OK;
message* unenc_msg = NULL;
message* enc_msg = NULL;
create_base_test_msg(&unenc_msg, 2, 2, false);
status = encrypt_message(session, unenc_msg, NULL, &enc_msg, PEP_enc_PEP, 0);
ASSERT_OK;
ASSERT_NE(enc_msg, nullptr);
// N.B. Actual check happens on decrypt later. But we can check that the encryption path doesn't fail, anyway.
if (DEFAULT_FROM_TEST_GEN) {
char* enc_text = NULL;
status = mime_encode_message(enc_msg, false, &enc_text, false);
ASSERT_OK;
ASSERT_NOTNULL(enc_text);
dump_out(v2_2_file.c_str(), enc_text);
free(enc_text);
}
free_message(unenc_msg);
free_message(enc_msg);
}
TEST_F(DefaultFromEmailTest, check_encrypt_to_pEp_10_111_simple_key) {
PEP_STATUS status = PEP_STATUS_OK;
message* unenc_msg = NULL;
message* enc_msg = NULL;
create_base_test_msg(&unenc_msg, 10, 111, false);
status = encrypt_message(session, unenc_msg, NULL, &enc_msg, PEP_enc_PEP, 0);
ASSERT_OK;
ASSERT_NE(enc_msg, nullptr);
// N.B. Actual check happens on decrypt later. But we can check that the encryption path doesn't fail, anyway.
if (DEFAULT_FROM_TEST_GEN) {
char* enc_text = NULL;
status = mime_encode_message(enc_msg, false, &enc_text, false);
ASSERT_OK;
ASSERT_NOTNULL(enc_text);
dump_out(v10_111_file.c_str(), enc_text);
free(enc_text);
}
free_message(unenc_msg);
free_message(enc_msg);
}
TEST_F(DefaultFromEmailTest, check_unencrypted_OpenPGP_from_TB_import_bare_default) {
PEP_STATUS status = PEP_STATUS_OK;
pEp_identity* ramoth = new_identity("ramoth_cat@darthmama.org", NULL, PEP_OWN_USERID, "Ramoth T. Cat, Spy Queen of Orlais");
status = myself(session, ramoth);
ASSERT_OK;
// FIXME: change this message to an non-expiring key, btw.
// Import the message which contains a single key. Be sure we get this key back.
string email = slurp("test_mails/unencrypted_OpenPGP_with_key_attached.eml");
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
const char* sender_key_fpr = "62D4932086185C15917B72D30571AFBCA5493553";
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_EQ(status, PEP_UNENCRYPTED);
ASSERT_NULL(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, enc_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* bcc = idents->ident;
ASSERT_NOTNULL(bcc);
ASSERT_NOTNULL(bcc->fpr);
ASSERT_STREQ(sender_key_fpr, bcc->fpr);
// Now make sure update identity returns the same
status = update_identity(session, bcc);
ASSERT_NOTNULL(bcc->fpr);
ASSERT_STREQ(sender_key_fpr, bcc->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_unencrypted_OpenPGP_import_default_alternate_available) {
// PEP_STATUS status = PEP_STATUS_OK;
// const char* sender_key_fpr = "62D4932086185C15917B72D30571AFBCA5493553";
// pEp_identity* ramoth = new_identity("ramoth_cat@darthmama.org", NULL, PEP_OWN_USERID, "Ramoth T. Cat, Spy Queen of Orlais");
// status = myself(session, ramoth);
// ASSERT_OK;
// // FIXME: change this message to an non-expiring key, btw.
// // Import the message which contains a single key. Be sure we get this key back.
// string email = slurp("test_mails/unencrypted_OpenPGP_with_key_attached.eml");
// ASSERT_TRUE(slurp_and_import_key(session, "test_keys/pub/big_clumsy_cat_0xC6406F81_pub.asc"));
// pEp_identity* bcc = NULL;
// // We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// // otherwise, we're also testing the parser driver.
// message* enc_msg = NULL;
// status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
// ASSERT_OK;
// ASSERT_NOTNULL(enc_msg);
// message* dec_msg = NULL;
// stringlist_t* keylist = NULL;
// PEP_rating rating;
// PEP_decrypt_flags_t flags = 0;
// status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
// ASSERT_EQ(status, PEP_UNENCRYPTED);
// ASSERT_NULL(dec_msg);
// identity_list* idents = NULL;
// status = get_identities_by_address(session, enc_msg->from->address, &idents);
// ASSERT_OK;
// ASSERT_NOTNULL(idents);
// ASSERT_NULL(idents->next);
// bcc = idents->ident;
// ASSERT_NOTNULL(bcc);
// ASSERT_NOTNULL(bcc->fpr);
// ASSERT_STREQ(sender_key_fpr, bcc->fpr);
// // Now make sure update identity returns the same
// status = update_identity(session, bcc);
// ASSERT_NOTNULL(bcc->fpr);
// ASSERT_STREQ(sender_key_fpr, bcc->fpr);
// // FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_OpenPGP_import_bare_default) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v1_import_bare_default) {
PEP_STATUS status = PEP_STATUS_OK;
pEp_identity* ramoth = new_identity("ramoth_cat@darthmama.org", NULL, PEP_OWN_USERID, "Ramoth T. Cat, Spy Queen of Orlais");
status = myself(session, ramoth);
ASSERT_OK;
// FIXME: change this message to an non-expiring key, btw.
// Import the message which contains a single key. Be sure we get this key back.
string email = slurp("test_mails/unencrypted_OpenPGP_with_key_attached.eml");
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
const char* sender_key_fpr = "62D4932086185C15917B72D30571AFBCA5493553";
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_EQ(status, PEP_UNENCRYPTED);
ASSERT_NULL(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, enc_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* bcc = idents->ident;
ASSERT_NOTNULL(bcc);
ASSERT_NOTNULL(bcc->fpr);
ASSERT_STREQ(sender_key_fpr, bcc->fpr);
// Now make sure update identity returns the same
status = update_identity(session, bcc);
ASSERT_NOTNULL(bcc->fpr);
ASSERT_STREQ(sender_key_fpr, bcc->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v1_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_0_import_bare_default) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_0_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_1_import_bare_default) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_1_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_2_import_bare_default) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_2_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_OpenPGP_import_bare_default) {
string email = slurp(OpenPGP_file);
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
PEP_STATUS status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
pEp_identity* me = NULL;
status = set_up_preset(session, INQUISITOR, true, true, true, true, true, &me);
ASSERT_OK;
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_OK;
ASSERT_NOTNULL(dec_msg);
print_mail(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, dec_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* john = idents->ident;
ASSERT_NOTNULL(john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// Now make sure update identity returns the same
status = update_identity(session, john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_OpenPGP_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v1_import_bare_default) {
string email = slurp(v1_0_file);
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
PEP_STATUS status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
pEp_identity* me = NULL;
status = set_up_preset(session, INQUISITOR, true, true, true, true, true, &me);
ASSERT_OK;
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_OK;
ASSERT_NOTNULL(dec_msg);
print_mail(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, dec_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* john = idents->ident;
ASSERT_NOTNULL(john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// Now make sure update identity returns the same
status = update_identity(session, john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_pEp_v1_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_0_import_bare_default) {
string email = slurp(v2_0_file);
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
PEP_STATUS status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
pEp_identity* me = NULL;
status = set_up_preset(session, INQUISITOR, true, true, true, true, true, &me);
ASSERT_OK;
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_OK;
ASSERT_NOTNULL(dec_msg);
print_mail(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, dec_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* john = idents->ident;
ASSERT_NOTNULL(john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// Now make sure update identity returns the same
status = update_identity(session, john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_0_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_1_import_bare_default) {
string email = slurp(v2_1_file);
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
PEP_STATUS status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
pEp_identity* me = NULL;
status = set_up_preset(session, INQUISITOR, true, true, true, true, true, &me);
ASSERT_OK;
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_OK;
ASSERT_NOTNULL(dec_msg);
print_mail(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, dec_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* john = idents->ident;
ASSERT_NOTNULL(john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// Now make sure update identity returns the same
status = update_identity(session, john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_1_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_2_import_bare_default) {
string email = slurp(v2_0_file);
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
PEP_STATUS status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
pEp_identity* me = NULL;
status = set_up_preset(session, INQUISITOR, true, true, true, true, true, &me);
ASSERT_OK;
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_OK;
ASSERT_NOTNULL(dec_msg);
print_mail(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, dec_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* john = idents->ident;
ASSERT_NOTNULL(john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// Now make sure update identity returns the same
status = update_identity(session, john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// FIXME: free stuff
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_2_import_default_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v10_111_import_bare_default) {
string email = slurp(v10_111_file);
// We shouldn't rely on MIME_encrypt/decrypt (and should fix other tests) -
// otherwise, we're also testing the parser driver.
message* enc_msg = NULL;
PEP_STATUS status = mime_decode_message(email.c_str(), email.size(), &enc_msg, NULL);
ASSERT_OK;
ASSERT_NOTNULL(enc_msg);
pEp_identity* me = NULL;
status = set_up_preset(session, INQUISITOR, true, true, true, true, true, &me);
ASSERT_OK;
message* dec_msg = NULL;
stringlist_t* keylist = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags = 0;
status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
ASSERT_OK;
ASSERT_NOTNULL(dec_msg);
print_mail(dec_msg);
identity_list* idents = NULL;
status = get_identities_by_address(session, dec_msg->from->address, &idents);
ASSERT_OK;
ASSERT_NOTNULL(idents);
ASSERT_NULL(idents->next);
pEp_identity* john = idents->ident;
ASSERT_NOTNULL(john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// Now make sure update identity returns the same
status = update_identity(session, john);
ASSERT_NOTNULL(john->fpr);
ASSERT_STREQ(john_fpr, john->fpr);
// FIXME: free stuff
}
/////////////////////////////////////////////////////
// The following require key election removal to function correctly
/////////////////////////////////////////////////////
TEST_F(DefaultFromEmailTest, check_unencrypted_OpenPGP_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v1_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_1_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_unencrypted_pEp_v2_2_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_OpenPGP_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v1_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_1_import_two_alternate_available) {
}
TEST_F(DefaultFromEmailTest, check_pEp_v2_2_import_two_alternate_available) {
}

+ 10
- 0
test/src/test_util.cc View File

@ -21,6 +21,8 @@
#include <stdlib.h>
#include <unistd.h>
#include <ftw.h>
#include <fstream>
#include <iostream>
using namespace std;
@ -1021,3 +1023,11 @@ int NullBuffer::overflow(int c) {
#ifndef DEBUG_OUTPUT
std::ostream output_stream(new NullBuffer());
#endif
void print_mail(message* msg) {
char* outmsg = NULL;
mime_encode_message(msg, false, &outmsg, false);
// output_stream << outmsg << endl;
cout << outmsg << endl;
free(outmsg);
}

+ 2
- 0
test/src/test_util.h View File

@ -133,6 +133,8 @@ class NullBuffer : public std::streambuf {
PEP_STATUS config_valid_passphrase(PEP_SESSION session, const char* fpr, std::vector<std::string> passphrases);
void print_mail(message* msg);
#ifndef ENIGMAIL_MAY_USE_THIS
// MIME_decrypt_message() - decrypt a MIME message, with MIME output


+ 58
- 0
test/test_keys/priv/big_clumsy_cat_0xC6406F81_priv.asc View File

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

+ 30
- 0
test/test_keys/pub/big_clumsy_cat_0xC6406F81_pub.asc View File

@ -0,0 +1,30 @@
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQENBF86Ti0BCACzYuZMijtDKU23ayc5xF+vRMyAPjoefmK78NX6buG01bM/E8gu
quOVNTL2cR2J/l9SbgwQXPxo7UvNiktOaU60jF5N8SZ8Ust4bj7RhMaBZynzeaIp
FV/rgzK5ZqLqPX49fvoKER1lQglwtzr3LO4lxbgNFmaql2dQaCl/XVPWMZAn8EpD
hEw7IDBtX6GKCHatN/ldLwOkBPQkiiVeQ6A7FJadFadZd+KOdNgETyzbl6WTADxu
ctsBR9V+ZUdgaOmJ/nx8XQK1RO6B22AMxitxsES8ZWXjWWo8cjMNPrSXcrYYKYVR
xvmoLtCIC+mqA95p2Hl/JOo3NImQE1j1LLz5ABEBAAG0LUJpZyBDbHVtc3kgQ2F0
IDxiaWdfY2x1bXN5X2NhdEBkYXJ0aG1hbWEub3JnPokBTgQTAQgAOAIbAwULCQgH
AgYVCgkICwIEFgIDAQIeAQIXgBYhBIkEe/53mZn3fPvtsoRZOtrGQG+BBQJfOk5r
AAoJEIRZOtrGQG+BrpEH/1lwFYn8i1xKl7WWIRHI91rXV4tjll8QIaEkRpNhKItW
h5gY8JgyBMwz7cQ4LGryaAp3Cm/okNlpdwt0UDYGkl/8q3Q8V4Pfn9f1xBK1avAR
KOc6sBOu5jLRdPULf/xuhpqP2IVbqLvm5fmIGTCgNTRHU9sBu68GuY5v2Nc9e0dG
9cdwAm+MyyBRLqtKiBFByvYEcxhVzWeRhhJJYgGsdyeQyB9iteOLxXeLkZB9XwOV
5BLxFdrcU0vmvDlFzO/3cjMg5BXO84uFWd+xMuy05o8mJhSj6CJyNfU3ecOcXCrR
dprrP0bnDbijJjH1EVUDg3WIBfx4GU9oOaBmvMRLE6W5AQ0EXzpOLQEIAMhtD8Hs
QPwgAN2DFwyFDBWlMMIvk8tHGwN0ttXja6CkCcYHBhEiOB4e//ruv2UGjfbkvKeT
5dF9GZxAjC/b9dNCeVPRWxiRDjQlfslSekUxNOATAGt/x1O4fgwsnsyqIYrbwuWq
5G9O0hmnXlempTDimBP2/XGZ4rxl3d2maug+s1DQl/niUcKkrOmhELYl0ll8HrD+
bjxNdgZNOg2fPo0+1Tb4TgYNIvMpkWj4TNYHBHQI7teXD8btX5lH5T3sE+61GdEa
fx1EdhEpJctB0ELUz3aboQVOJuykzdMD+8tTzMkzNz3STUze5Prx2sB1kOgrHrhw
Zg4yDwlkM4saXPsAEQEAAYkBPAQYAQgAJhYhBIkEe/53mZn3fPvtsoRZOtrGQG+B
BQJfOk4tAhsMBQkDwmcAAAoJEIRZOtrGQG+B/cMH+wTrp9D82aK82hzv9uFtFcDL
rE733twcTXgqRPSzalxHoHQVoLZxNpvH6azK2DWN+qViD5WJmaQdssD/4gEtqdZQ
i7FCJDf3ceGISiTdGZMomOFGIM8XL4VvnGzQZsufKy28ROdduly0k9T0IOH3FhCg
ICwKo79XWGHXQXS8PakOazSMIbewZLnULqwXUR3h8EipbBmNuEcVuVZEcQ/1/RjE
L5uVkMb8ulYJF5ZZqWvI7LYbRZ0dCsevRQLxHzbGcERNXVkHqvpipevCL68d8Iaq
OpUlxLGFpmVC5bICOfKwpv9Cyi/uERyo5Cb8/SJGwJn9//cp5ii3vlovAdEmHlw=
=2rEk
-----END PGP PUBLIC KEY BLOCK-----

+ 732
- 0
test/test_mails/unencrypted_OpenPGP_with_key_attached.eml View File

@ -0,0 +1,732 @@
X-Envelope-From: <SRS0=nwscbP=BY=darthmama.org=big_clumsy_cat@srs.smtpin.rzone.de>
X-Envelope-To: <krista@darthmama.org>
X-Delivery-Time: 1597406019
X-UID: 17690
Return-Path: <SRS0=nwscbP=BY=darthmama.org=big_clumsy_cat@srs.smtpin.rzone.de>
Authentication-Results: strato.com; dmarc=none header.from=darthmama.org
Authentication-Results: strato.com; arc=none
Authentication-Results: strato.com; dkim=pass header.d=darthmama.org
Authentication-Results: strato.com; dkim-adsp=pass header.from="big_clumsy_cat@darthmama.org"
Authentication-Results: strato.com; spf=pass smtp.mailfrom="SRS0=nwscbP=BY=darthmama.org=big_clumsy_cat@srs.smtpin.rzone.de"
X-RZG-Expurgate: clean/normal
X-RZG-Expurgate-ID: 149500::1597406019-000035D7-8E034EDF/0/0
X-RZG-CLASS-ID: mi00
Received-SPF: pass
(strato.com: domain _spf.strato.com designates 85.215.255.5 as permitted sender)
mechanism=ip4;
client-ip=85.215.255.5;
helo="mi4-p00-ob.smtp.rzone.de";
envelope-from="SRS0=nwscbP=BY=darthmama.org=big_clumsy_cat@srs.smtpin.rzone.de";
receiver=smtpin.rzone.de;
identity=mailfrom;
Received: from mi4-p00-ob.smtp.rzone.de ([85.215.255.5])
by smtpin.rzone.de (RZmta 46.10.5 OK)
with ESMTPS id s03316w7EBrdnww
(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256 bits))
(Client CN "*.smtp.rzone.de", Issuer "TeleSec ServerPass Class 2 CA" (verified OK (+EmiG)))
(Client hostname verified OK)
for <krista@darthmama.org>;
Fri, 14 Aug 2020 13:53:39 +0200 (CEST)
X-RZG-FWD-BY: ramoth_cat@darthmama.org
Received: from mailin.rzone.de ([unix socket])
by mailin.rzone.de (RZmta 46.10.5) with LMTPA;
Fri, 14 Aug 2020 13:53:36 +0200 (CEST)
Authentication-Results: strato.com; dmarc=none header.from=darthmama.org
Authentication-Results: strato.com; arc=none
Authentication-Results: strato.com; dkim=pass header.d=darthmama.org
Authentication-Results: strato.com; dkim-adsp=pass header.from="big_clumsy_cat@darthmama.org"
Authentication-Results: strato.com; spf=none smtp.mailfrom="big_clumsy_cat@darthmama.org"
X-RZG-Expurgate: clean/normal
X-RZG-Expurgate-ID: 149500::1597406016-00004BAD-5F1D1FAD/0/0
X-RZG-CLASS-ID: mi00
Received-SPF: none
client-ip=85.215.255.22;
helo="mo4-p00-ob.smtp.rzone.de";
envelope-from="big_clumsy_cat@darthmama.org";
receiver=smtpin.rzone.de;
identity=mailfrom;
Received: from mo4-p00-ob.smtp.rzone.de ([85.215.255.22])
by smtpin.rzone.de (RZmta 46.10.5 OK)
with ESMTPS id e028e4w7EBranEJ
(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256 bits))
(Client CN "*.smtp.rzone.de", Issuer "TeleSec ServerPass Class 2 CA" (verified OK (+EmiG)))
(Client hostname verified OK)
for <ramoth_cat@darthmama.org>;
Fri, 14 Aug 2020 13:53:36 +0200 (CEST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; t=1597406016;
s=strato-dkim-0002; d=darthmama.org;
h=Date:Message-ID:Subject:From:To:X-RZG-CLASS-ID:X-RZG-AUTH:From:
Subject:Sender;
bh=y2SxjMop565Qma25QJWUizg5kJjgyTgu0mN7JqpwNxw=;
b=Y+NunxItrC3Kb/C0KlMroezIn9L7BOAcRJjCXKFNDBvgCzpXJs+DEFhjtj8grEO7Px
PM0J960SiezdRKm9Z3i1StO9EGK22ZxrgfMWfs8T9vtgvBh+Zo7TZoKo91Ro5OUSbAk9
CY6eQZ3T9YvD3xmAfM8UyX/z09hYB+3Aucuwk7MfRnVR1V2sc+RqNMr0epfyfrkIoy5T
miAHX1unrYdn9U9aayA62ei9JTA7Nkw2NGdqEuqXTqtHRVpfIFiSuNhTvdgIxTSdFNNJ
uMy2H7TQgb08g+3g+LOnz7lemISKEaX+Fdz36IUT8EDdBEZTgTP5EgS4VylwERBgp1Mo
HL9w==
X-RZG-AUTH: ":J34NZlSpW/vPDlKSRxUBevLT/2WDdlCqkty/deruLplgoO4nY+csF8wOXLDBWKUEIjwKiw=="
X-RZG-CLASS-ID: mo00
Received: from rylen.home
by smtp.strato.de (RZmta 46.10.5 DYNA|AUTH)
with ESMTPSA id D09f3cw7EBrawNS
(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256 bits))
(Client did not present a certificate)
for <ramoth_cat@darthmama.org>;
Fri, 14 Aug 2020 13:53:36 +0200 (CEST)
To: Ramoth Cat <ramoth_cat@darthmama.org>
From: Big Clumsy Cat <big_clumsy_cat@darthmama.org>
Subject: Hi kitten!
Message-ID: <a3dc9e2d-fd67-9650-4979-6dc6e35de80e@darthmama.org>
Date: Fri, 14 Aug 2020 13:53:35 +0200
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:68.0)
Gecko/20100101 Thunderbird/68.11.0
MIME-Version: 1.0
Content-Type: multipart/mixed;
boundary="------------1F0E65787DE23831537A2135"
Content-Language: en-GB
This is a multi-part message in MIME format.
--------------1F0E65787DE23831537A2135
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 7bit
Dear Ramoth,
You are the best cat. Don't tell your brothers. My key is attached so we
can secretly talk about how cool you are.
Love,
Big Clumsy Cat
--------------1F0E65787DE23831537A2135
Content-Type: application/pgp-keys;
name="0x0571AFBCA5493553.asc"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="0x0571AFBCA5493553.asc"
-----BEGIN PGP PUBLIC KEY BLOCK-----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=apZU
-----END PGP PUBLIC KEY BLOCK-----
--------------1F0E65787DE23831537A2135--

Loading…
Cancel
Save