p≡p engine
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

511 lines
21 KiB

// This file is under GNU General Public License 3.0
// see LICENSE.txt
#include "TestConstants.h"
#include <stdlib.h>
#include <string>
#include <cstring>
#include "pEpEngine.h"
#include "pEp_internal.h"
#include "TestUtilities.h"
#include "Engine.h"
#include <gtest/gtest.h>
namespace {
//The fixture for UserIdCollisionTest
class UserIdCollisionTest : public ::testing::Test {
public:
Engine* engine;
PEP_SESSION session;
// own user
pEp_identity* user_alice;
// real ID, only minimal info w/ username
pEp_identity* real_alex;
// tofu ID, only minimal info w/ username
pEp_identity* tofu_alex;
// real ID, only minimal info w/o username
pEp_identity* real_alex_0;
// tofu ID, only minimal info w/o username
pEp_identity* tofu_alex_0;
// real ID, only minimal info w/o username
pEp_identity* real_alex_1;
// tofu ID, only minimal info w/o username
pEp_identity* tofu_alex_1;
// real ID, various kinds of info
pEp_identity* real_alex_2;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_2;
// real ID, various kinds of info
pEp_identity* real_alex_3;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_3;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_4;
// real ID, various kinds of info
pEp_identity* real_alex_4;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_5;
// real ID, various kinds of info
pEp_identity* real_alex_5;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_6a;
// real ID, various kinds of info
pEp_identity* real_alex_6a;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_6b;
// real ID, various kinds of info
pEp_identity* real_alex_6b;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_6c;
// real ID, various kinds of info
pEp_identity* real_alex_6c;
// tofu ID, various kinds of info
pEp_identity* tofu_alex_6d;
// real ID, various kinds of info
pEp_identity* real_alex_6d;
const char* const alice_keyfile = "test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc";
const char* const alice_keyid = "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97";
const char* const alice_email = "pep.test.alice@pep-project.org";
const char* const alex_keyfile = "test_keys/pub/pep.test.alexander-0x26B54E4E_pub.asc";
const char* const alex_keyid = "3AD9F60FAEB22675DB873A1362D6981326B54E4E";
const char* const alex_email = "pep.test.alexander@peptest.ch";
const char* const alex0_keyfile = "test_keys/pub/pep.test.alexander0-0x3B7302DB_pub.asc";
const char* const alex0_keyid = "F4598A17D4690EB3B5B0F6A344F04E963B7302DB";
const char* const alex0_email = "pep.test.alexander0@darthmama.org";
const char* const alex1_keyfile = "test_keys/pub/pep.test.alexander1-0x541260F6_pub.asc";
const char* const alex1_keyid = "59AF4C51492283522F6904531C09730A541260F6";
const char* const alex1_email = "pep.test.alexander1@darthmama.org";
const char* const alex2_keyfile = "test_keys/pub/pep.test.alexander2-0xA6512F30_pub.asc";
const char* const alex2_keyid = "46A994F19077C05610870273C4B8AB0BA6512F30";
const char* const alex2_email = "pep.test.alexander2@darthmama.org";
const char* const alex3_keyfile = "test_keys/pub/pep.test.alexander3-0x724B3975_pub.asc";
const char* const alex3_keyid = "5F7076BBD92E14EA49F0DF7C2CE49419724B3975";
const char* const alex3_email = "pep.test.alexander3@darthmama.org";
const char* const alex4_keyfile = "test_keys/pub/pep.test.alexander4-0x844B9DCF_pub.asc";
const char* const alex4_keyid = "E95FFF95B8E2FDD4A12C3374395F1485844B9DCF";
const char* const alex4_email = "pep.test.alexander4@darthmama.org";
const char* const alex5_keyfile = "test_keys/pub/pep.test.alexander5-0x0773CD29_pub.asc";
const char* const alex5_keyid = "58BCC2BF2AE1E3C4FBEAB89AD7838ACA0773CD29";
const char* const alex5_email = "pep.test.alexander5@darthmama.org";
const char* const alex6a_keyfile = "test_keys/pub/pep.test.alexander6-0xBDA17020_pub.asc";
const char* const alex6a_keyid = "B4CE2F6947B6947C500F0687AEFDE530BDA17020";
const char* const alex6_email = "pep.test.alexander6@darthmama.org";
const char* const alex6b_keyfile = "test_keys/pub/pep.test.alexander6-0x503B14D8_pub.asc";
const char* const alex6b_keyid = "2E21325D202A44BFD9C607FCF095B202503B14D8";
const char* const alex6c_keyfile = "test_keys/pub/pep.test.alexander6-0xA216E95A_pub.asc";
const char* const alex6c_keyid = "3C1E713D8519D7F907E3142D179EAA24A216E95A";
const char* const alex6d_keyfile = "test_keys/pub/pep.test.alexander6-0x0019697D_pub.asc";
const char* const alex6d_keyid = "74D79B4496E289BD8A71B70BA8E2C4530019697D";
protected:
// You can remove any or all of the following functions if its body
// is empty.
UserIdCollisionTest() {
// 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;
}
~UserIdCollisionTest() 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_NOTNULL(engine);
// Ok, let's initialize test directories etc.
engine->prep(NULL, NULL, NULL, init_files);
// Ok, try to start this bugger.
engine->start();
ASSERT_NOTNULL(engine->session);
session = engine->session;
// Engine is up. Keep on truckin'
user_alice = new_identity(alice_email, alice_keyid, PEP_OWN_USERID, "Alice from Mel's Diner");
slurp_and_import_key(session, alice_keyfile);
real_alex = new_identity(alex_email, alex_keyid, "AlexID", "Alexander the Mediocre");
tofu_alex = new_identity(alex_email, alex_keyid, NULL, NULL);
real_alex_0 = new_identity(alex_email, alex_keyid, "Alex0", "Alexander the Mediocre");
tofu_alex_0 = new_identity(alex_email, alex_keyid, NULL, NULL);
real_alex_1 = new_identity(alex1_email, alex_keyid, "Alex1", NULL);
tofu_alex_1 = new_identity(alex1_email, alex1_keyid, NULL, NULL);
real_alex_2 = new_identity(alex2_email, alex1_keyid, "Alex2", NULL);
tofu_alex_2 = new_identity(alex2_email, alex2_keyid, NULL, NULL);
real_alex_3 = new_identity(alex3_email, alex2_keyid, "Alex3", NULL);
tofu_alex_3 = new_identity(alex3_email, alex3_keyid, NULL, NULL);
real_alex_4 = new_identity(alex4_email, alex3_keyid, "Alex4", NULL);
tofu_alex_4 = new_identity(alex4_email, alex4_keyid, NULL, NULL);
real_alex_5 = new_identity(alex5_email, alex4_keyid, "Alex5", NULL);
tofu_alex_5 = new_identity(alex5_email, alex5_keyid, NULL, NULL);
real_alex_6a = new_identity(alex6_email, alex5_keyid, "Alex6", NULL);
tofu_alex_6a = new_identity(alex6_email, alex6a_keyid, NULL, NULL);
real_alex_6b = new_identity(alex6_email, alex6a_keyid, "Alex6", NULL);
tofu_alex_6b = new_identity(alex6_email, alex6b_keyid, NULL, NULL);
real_alex_6c = new_identity(alex6_email, alex6b_keyid, "Alex6", NULL);
tofu_alex_6c = new_identity(alex6_email, alex6c_keyid, NULL, NULL);
real_alex_6d = new_identity(alex6_email, alex6c_keyid, "Alex6", NULL);
tofu_alex_6d = new_identity(alex6_email, alex6d_keyid, NULL, NULL);
}
void TearDown() override {
// Code here will be called immediately after each test (right
// before the destructor).
free_identity(real_alex);
free_identity(real_alex_0);
free_identity(real_alex_1);
free_identity(real_alex_2);
free_identity(real_alex_3);
free_identity(real_alex_4);
free_identity(real_alex_5);
free_identity(real_alex_6a);
free_identity(real_alex_6b);
free_identity(real_alex_6c);
free_identity(real_alex_6d);
free_identity(tofu_alex);
free_identity(tofu_alex_0);
free_identity(tofu_alex_1);
free_identity(tofu_alex_2);
free_identity(tofu_alex_3);
free_identity(tofu_alex_4);
free_identity(tofu_alex_5);
free_identity(tofu_alex_6a);
free_identity(tofu_alex_6b);
free_identity(tofu_alex_6c);
free_identity(tofu_alex_6d);
engine->shut_down();
delete engine;
engine = NULL;
session = NULL;
}
private:
const char* test_suite_name;
const char* test_name;
string test_path;
// Objects declared here can be used by all tests in the UserIdCollisionTest suite.
};
} // namespace
//
// Create TOFU identity, set its FPR in the DB, test real id collision
//
TEST_F(UserIdCollisionTest, simple_tofu_collision) {
slurp_and_import_key(session,alex_keyfile);
tofu_alex->username = strdup("Alexander the Mediocre");
PEP_STATUS status = update_identity(session, tofu_alex);
ASSERT_OK;
string tofu_id = string("TOFU_") + alex_email;
ASSERT_STREQ(tofu_alex->user_id, tofu_id.c_str());
ASSERT_NULL(tofu_alex->fpr);
status = set_fpr_preserve_ident(session, tofu_alex, alex_keyid, false);
ASSERT_OK;
status = update_identity(session, tofu_alex);
ASSERT_OK;
ASSERT_STREQ(tofu_alex->fpr, alex_keyid);
status = update_identity(session, real_alex);
ASSERT_OK;
ASSERT_STREQ(real_alex->fpr, alex_keyid);
bool tofu_still_exists = false;
status = exists_person(session, tofu_alex, &tofu_still_exists);
ASSERT_OK;
ASSERT_FALSE(tofu_still_exists);
}
//
// Create TOFU identity, set its FPR in the DB, test real id collision
// with different usernames. Real ID shouldn't pick up the TOFU information
// OR its key, since key election has been removed.
//
// This should no longer fail, because we don't use username matches to determine
// what happens in update_identity. So we SHOULD replace the user_id and consolidate
// identities.
//
TEST_F(UserIdCollisionTest, simple_tofu_collision_different_usernames) {
slurp_and_import_key(session,alex_keyfile);
tofu_alex->username = strdup("Alexander Hamilton");
PEP_STATUS status = update_identity(session, tofu_alex);
ASSERT_OK;
string tofu_id = string("TOFU_") + alex_email;
ASSERT_STREQ(tofu_alex->user_id, tofu_id.c_str());
ASSERT_NULL(tofu_alex->fpr);
status = set_fpr_preserve_ident(session, tofu_alex, alex_keyid, false);
ASSERT_OK;
status = update_identity(session, tofu_alex);
ASSERT_OK;
ASSERT_STREQ(tofu_alex->fpr, alex_keyid);
status = update_identity(session, real_alex);
ASSERT_OK;
ASSERT_NOTNULL(real_alex->fpr);
ASSERT_STREQ(real_alex->fpr, alex_keyid);
bool tofu_still_exists = false;
status = exists_person(session, tofu_alex, &tofu_still_exists);
ASSERT_OK;
ASSERT_FALSE(tofu_still_exists);
}
//
// Create TOFU identity, set its FPR in the DB, test second same tofu id collision
// with same usernames. Mostly, this test appears to check if things don't blow up
// when you don't update the TOFU id?
//
TEST_F(UserIdCollisionTest, tofu_two_tofus_no_collision) {
slurp_and_import_key(session,alex6a_keyfile);
tofu_alex_6a->username = strdup("Alexander Hamilton");
tofu_alex_6b->username = strdup("Alexander Hamilton");
tofu_alex_6a->lang[0] = 'j';
tofu_alex_6a->lang[1] = 'p';
PEP_STATUS status = update_identity(session, tofu_alex_6a);
ASSERT_OK;
string tofu_id = string("TOFU_") + alex6_email;
ASSERT_STREQ(tofu_alex_6a->user_id, tofu_id.c_str());
ASSERT_NULL(tofu_alex_6a->fpr);
status = set_fpr_preserve_ident(session, tofu_alex_6a, alex6a_keyid, false);
ASSERT_OK;
status = update_identity(session, tofu_alex_6a);
ASSERT_OK;
ASSERT_STREQ(tofu_alex_6a->fpr, alex6a_keyid);
// Ok, we call with the same explicit TOFU id (?)
tofu_alex_6b->user_id = strdup(tofu_id.c_str());
status = update_identity(session, tofu_alex_6b);
ASSERT_OK;
ASSERT_STREQ(tofu_alex_6b->fpr, alex6a_keyid);
bool tofu_still_exists = false;
status = exists_person(session, tofu_alex_6a, &tofu_still_exists);
ASSERT_OK;
ASSERT_TRUE(tofu_still_exists);
ASSERT_EQ(tofu_alex_6b->lang[0] , 'j');
ASSERT_EQ(tofu_alex_6b->lang[1] , 'p');
}
TEST_F(UserIdCollisionTest, tofu_collision_same_tofus_diff_usernames) {
slurp_and_import_key(session,alex6a_keyfile);
tofu_alex_6a->username = strdup("Alexander Hamilton");
tofu_alex_6b->username = strdup("Alexander the Not-Cool-At-All");
tofu_alex_6a->lang[0] = 'j';
tofu_alex_6a->lang[1] = 'p';
PEP_STATUS status = update_identity(session, tofu_alex_6a);
ASSERT_OK;
string tofu_id = string("TOFU_") + alex6_email;
ASSERT_STREQ(tofu_alex_6a->user_id, tofu_id.c_str());
ASSERT_NULL(tofu_alex_6a->fpr);
status = set_fpr_preserve_ident(session, tofu_alex_6a, alex6a_keyid, false);
ASSERT_OK;
status = update_identity(session, tofu_alex_6a);
ASSERT_OK;
ASSERT_STREQ(tofu_alex_6a->fpr, alex6a_keyid);
// FIXME: This is such a weird thing... check this
//
// Ok, NOW we put in an explicit TOFU
tofu_alex_6b->user_id = strdup(tofu_id.c_str());
status = update_identity(session, tofu_alex_6b);
ASSERT_OK;
ASSERT_STREQ(tofu_alex_6b->fpr, alex6a_keyid);
bool tofu_still_exists = false;
status = exists_person(session, tofu_alex_6a, &tofu_still_exists);
ASSERT_OK;
// SHOULD still exist, because we don't replace when usernames differ
ASSERT_TRUE(tofu_still_exists);
ASSERT_EQ(tofu_alex_6b->lang[0] , 'j');
ASSERT_EQ(tofu_alex_6b->lang[1] , 'p');
ASSERT_STREQ(tofu_alex_6b->username, "Alexander the Not-Cool-At-All");
}
TEST_F(UserIdCollisionTest, real_followed_by_explicit_tofu) {
slurp_and_import_key(session,alex_keyfile);
real_alex->username = strdup("Alexander the Mediocre");
PEP_STATUS status = update_identity(session, real_alex);
ASSERT_OK;
ASSERT_NULL(real_alex->fpr);
status = set_fpr_preserve_ident(session, real_alex, alex_keyid, false);
ASSERT_OK;
status = update_identity(session, real_alex);
ASSERT_OK;
ASSERT_STREQ(real_alex->fpr, alex_keyid);
string tofu_id = string("TOFU_") + alex_email;
tofu_alex->username = strdup(real_alex->username);
tofu_alex->user_id = strdup(tofu_id.c_str());
status = update_identity(session, tofu_alex);
ASSERT_OK;
ASSERT_STREQ(tofu_alex->user_id, "AlexID");
bool tofu_still_exists = false;
free(tofu_alex->user_id);
tofu_alex->user_id = strdup(tofu_id.c_str());
status = exists_person(session, tofu_alex, &tofu_still_exists);
ASSERT_OK;
ASSERT_FALSE(tofu_still_exists);
}
TEST_F(UserIdCollisionTest, merge_records_normal) {
// Tofu 6a has lots of stuff.
slurp_and_import_key(session,alex6a_keyfile);
tofu_alex_6a->username = strdup("Alexander Hamilton");
tofu_alex_6a->lang[0] = 'e';
tofu_alex_6a->lang[1] = 's';
PEP_STATUS status = update_identity(session, tofu_alex_6a);
slurp_and_import_key(session,alex6c_keyfile);
free(tofu_alex_6a->fpr);
tofu_alex_6a->fpr = strdup(alex6c_keyid);
tofu_alex_6a->comm_type = PEP_ct_OpenPGP;
status = set_identity(session, tofu_alex_6a);
slurp_and_import_key(session,alex6d_keyfile);
free(tofu_alex_6a->fpr);
tofu_alex_6a->fpr = strdup(alex6d_keyid);
tofu_alex_6a->comm_type = PEP_ct_pEp_unconfirmed; // ???
status = set_identity(session, tofu_alex_6a);
real_alex_6a->username = strdup(tofu_alex_6a->username);
status = update_identity(session, real_alex_6a);
ASSERT_OK;
ASSERT_EQ(real_alex_6a->lang[0] , 'e');
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp_unconfirmed);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6c_keyid);
status = get_trust(session, real_alex_6a);
ASSERT_OK;
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_OpenPGP);
}
TEST_F(UserIdCollisionTest, merge_records_set) {
// Tofu 6a has lots of stuff.
slurp_and_import_key(session,alex6a_keyfile);
tofu_alex_6a->username = strdup("Alexander Hamilton");
tofu_alex_6a->lang[0] = 'e';
tofu_alex_6a->lang[1] = 's';
PEP_STATUS status = update_identity(session, tofu_alex_6a);
slurp_and_import_key(session,alex6b_keyfile);
slurp_and_import_key(session,alex6c_keyfile);
free(tofu_alex_6a->fpr);
tofu_alex_6a->fpr = strdup(alex6c_keyid);
tofu_alex_6a->comm_type = PEP_ct_pEp_unconfirmed;
status = set_identity(session, tofu_alex_6a);
status = set_as_pEp_user(session, tofu_alex_6a);
slurp_and_import_key(session,alex6d_keyfile);
free(tofu_alex_6a->fpr);
tofu_alex_6a->fpr = strdup(alex6d_keyid);
tofu_alex_6a->comm_type = PEP_ct_OpenPGP;
status = set_identity(session, tofu_alex_6a);
real_alex_6a->username = strdup(tofu_alex_6a->username);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6d_keyid);
status = set_person(session, real_alex_6a, true); // NOT identit
ASSERT_OK;
status = update_identity(session, real_alex_6a);
ASSERT_OK;
ASSERT_EQ(real_alex_6a->lang[0] , 'e');
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp);
bool pEp_peep = false;
status = is_pEp_user(session, real_alex_6a, &pEp_peep);
ASSERT_TRUE(pEp_peep);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6c_keyid);
status = get_trust(session, real_alex_6a);
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp_unconfirmed);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6d_keyid);
status = get_trust(session, real_alex_6a);
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp);
}
TEST_F(UserIdCollisionTest, merge_records_set_2) {
// Tofu 6a has lots of stuff.
slurp_and_import_key(session,alex6a_keyfile);
tofu_alex_6a->username = strdup("Alexander Hamilton");
tofu_alex_6a->lang[0] = 'e';
tofu_alex_6a->lang[1] = 's';
PEP_STATUS status = update_identity(session, tofu_alex_6a);
slurp_and_import_key(session,alex6b_keyfile);
slurp_and_import_key(session,alex6c_keyfile);
free(tofu_alex_6a->fpr);
tofu_alex_6a->fpr = strdup(alex6c_keyid);
tofu_alex_6a->comm_type = PEP_ct_OpenPGP_unconfirmed;
status = set_identity(session, tofu_alex_6a);
slurp_and_import_key(session,alex6d_keyfile);
free(tofu_alex_6a->fpr);
tofu_alex_6a->fpr = strdup(alex6d_keyid);
tofu_alex_6a->comm_type = PEP_ct_OpenPGP;
status = set_identity(session, tofu_alex_6a);
real_alex_6a->username = strdup(tofu_alex_6a->username);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6d_keyid);
status = set_person(session, real_alex_6a, true); // NOT identity
ASSERT_OK;
status = set_as_pEp_user(session, real_alex_6a);
ASSERT_OK;
status = update_identity(session, real_alex_6a);
ASSERT_OK;
ASSERT_EQ(real_alex_6a->lang[0] , 'e');
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp);
bool pEp_peep = false;
status = is_pEp_user(session, real_alex_6a, &pEp_peep);
ASSERT_TRUE(pEp_peep);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6c_keyid);
status = get_trust(session, real_alex_6a);
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp_unconfirmed);
free(real_alex_6a->fpr);
real_alex_6a->fpr = strdup(alex6d_keyid);
status = get_trust(session, real_alex_6a);
ASSERT_EQ(real_alex_6a->comm_type , PEP_ct_pEp);
}