pEp.foundation
/
pEpEngine
16
2
Fork 17
Code Issues 19 Pull Requests 2 Releases 46 Wiki Activity

ENGINE-289: intermittent commit - almost compiling cleanly (yes, it's that far away from tested. It's complicated.

Browse Source
doc_update_sequoia
Krista Bennett 5 years ago
parent 9c615b23f1
commit df59d0eaf8
4 changed files with 131 additions and 74 deletions
Show Stats Download Patch File Download Diff File

107
src/keymanagement.c
Unescape View File

@ -32,13 +32,15 @@ static bool key_matches_address(PEP_SESSION session, const char* address,
PEP_STATUS status = find_keys(session, address, &keylist);
if (status == PEP_STATUS_OK && keylist) {
stringlist_t* curr = keylist;
if (curr->value) {
if (strcasecmp(curr->value, fpr)) {
retval = true;
break;
while (curr) {
if (curr->value) {
if (strcasecmp(curr->value, fpr)) {
retval = true;
break;
}
}
curr = curr->next;
}
curr = curr->next;
}
free_stringlist(keylist);
@ -99,7 +101,8 @@ PEP_STATUS elect_pubkey(
return PEP_STATUS_OK;
}
static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {
static PEP_STATUS validate_fpr(PEP_SESSION session,
pEp_identity* ident) {
if (!session || !ident || !ident->fpr)
return PEP_ILLEGAL_VALUE;
@ -109,9 +112,11 @@ static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {
PEP_STATUS status = get_trust(session, ident);
if (status != PEP_STATUS_OK)
return ADD_TO_LOG(status);
PEP_comm_type ct = ident->comm_type;
bool revoked, expired;
bool blacklisted;
bool blacklisted = false;
status = key_revoked(session, fpr, &revoked);
@ -129,16 +134,15 @@ static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {
if (status != PEP_STATUS_OK)
return ADD_TO_LOG(status);
status = blacklist_is_listed(session,
stored_identity->fpr,
&blacklisted);
if (status != PEP_STATUS_OK)
return ADD_TO_LOG(status);
if ((ct | PEP_ct_confirmed) == PEP_ct_OpenPGP) {
status = blacklist_is_listed(session,
fpr,
&blacklisted);
if (status != PEP_STATUS_OK)
return ADD_TO_LOG(status);
}
char* retval = fpr;
// FIXME: bits for pEp FIXME: blacklisted?
if (ident->me && (ct == PEP_ct_pEp) && !revoked && expired) {
// extend key
timestamp *ts = new_timestamp(time(NULL) + KEY_EXPIRE_DELTA);
@ -148,7 +152,7 @@ static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {
if (status == PEP_STATUS_OK) {
// if key is valid (second check because pEp key might be extended above)
// Return fpr
status = key_expired(session, fpr, &expired);
status = key_expired(session, fpr, time(NULL), &expired);
if (status != PEP_STATUS_OK)
return ADD_TO_LOG(status);
// communicate key(?)
@ -156,30 +160,29 @@ static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {
}
if (revoked)
ct = PEP_ct_revoked;
ct = PEP_ct_key_revoked;
else if (expired)
ct = PEP_ct_expired;
else if (blacklisted &&
((ct | PEP_ct_confirmed) == PEP_ct_OpenPGP_confirmed)) {
ident->ct = ct = PEP_ct_key_not_found;
ct = PEP_ct_key_expired;
else if (blacklisted) {
ident->comm_type = ct = PEP_ct_key_not_found;
free(ident->fpr);
ident->fpr = strdup("");
}
status = PEP_KEY_UNSUITABLE;
}
switch (ct) {
case PEP_ct_key_expired:
case PEP_ct_key_revoked
case PEP_ct_key_revoked:
case PEP_ct_key_b0rken:
// delete key from being default key for all users/identities
status = remove_fpr_as_default(session, fpr);
status = update_trust_for_fpr(session,
fpr,
ct);
free(ident->fpr);
ident->fpr = strdup("");
ident->comm_type = PEP_ct_key_not_found;
status = PEP_KEY_UNSUITABLE;
status = update_trust_for_fpr(session,
stored_identity->fpr,
ct);
default:
break;
}
@ -191,8 +194,8 @@ static PEP_STATUS validate_fpr(PEP_SESSION session, pEp_identity* ident) {
// Also, we presume that if the stored_identity was sent in
// without an fpr, there wasn't one in the trust DB for this
// identity.
PEP_STATUS get_valid_pubkey(PEP_STATUS session,
  PEP_STATUS stored_identity,
PEP_STATUS get_valid_pubkey(PEP_SESSION session,
pEp_identity* stored_identity,
bool* is_identity_default,
bool* is_user_default,
bool* is_address_default) {
@ -227,14 +230,14 @@ PEP_STATUS get_valid_pubkey(PEP_STATUS session,
const int result = sqlite3_step(session->get_user_default_key);
const char* user_fpr = NULL;
if (result == SQLITE_ROW) {
user_fpr =
(const char *) sqlite3_column_text(session->get_user_default_key, 0);
user_fpr =
(char *) sqlite3_column_text(session->get_user_default_key, 0);
}
sqlite3_reset(session->get_user_default_key);
if (user_fpr) {
// There exists a default key for user, so validate
stored_identity->fpr = user_fpr;
stored_identity->fpr = strdup(user_fpr);
status = validate_fpr(session, stored_identity);
if (status == PEP_STATUS_OK && stored_identity->fpr) {
*is_user_default = true;
@ -269,7 +272,9 @@ static PEP_STATUS prepare_updated_identity(PEP_SESSION session,
if (!session || !input_id || !stored_ident)
return PEP_ILLEGAL_VALUE;
PEP_STATUS status;
bool is_identity_default, is_user_default, is_address_default;
status = get_valid_pubkey(session, stored_ident,
&is_identity_default,
@ -284,10 +289,10 @@ static PEP_STATUS prepare_updated_identity(PEP_SESSION session,
if (input_id->fpr &&
strcasecmp(stored_ident->fpr, input_id->fpr) != 0) {
free(input_id->fpr);
strdup(input_id->fpr, stored_ident->fpr);
// We have to call this because we didn't get it during
// get identity above
// Copy in the result from get_valid_pubkey
input_id->fpr = strdup(stored_ident->fpr);
status = get_trust(session, stored_ident);
input_id->comm_type = stored_ident->comm_type;
}
@ -316,7 +321,7 @@ static PEP_STATUS prepare_updated_identity(PEP_SESSION session,
// if we got an fpr which is default for either user
// or identity AND is valid for this address, set in DB
// as default
status = set_identity(input_id);
status = set_identity(session, input_id);
}
else {
// Store without default fpr/ct, but return the fpr and ct
@ -325,7 +330,7 @@ static PEP_STATUS prepare_updated_identity(PEP_SESSION session,
PEP_comm_type save_ct = input_id->comm_type;
input_id->fpr = NULL;
input_id->comm_type = PEP_ct_unknown;
status = set_identity(input_id);
status = set_identity(session, input_id);
input_id->fpr = save_fpr;
input_id->comm_type = save_ct;
}
@ -340,8 +345,6 @@ DYNAMIC_API PEP_STATUS update_identity(
PEP_SESSION session, pEp_identity * identity
)
{
pEp_identity *stored_identity = NULL;
pEp_identity *temp_id = NULL;
PEP_STATUS status;
assert(session);
@ -366,9 +369,6 @@ DYNAMIC_API PEP_STATUS update_identity(
// We have, at least, an address.
// Retrieve stored identity information!
pEp_identity* stored_ident = NULL;
char* identity_default_fpr = NULL;
char* user_default_fpr = NULL;
char* passed_in_fpr = identity->fpr;
if (identity->user_id) {
// (we're gonna update the trust/fpr anyway, so we user the no-fpr-from-trust-db variant)
@ -402,7 +402,9 @@ DYNAMIC_API PEP_STATUS update_identity(
// Ok, we have a temp ID. We have to replace this
// with the real ID.
status = replace_userid(this_uid, identity->user_id);
status = replace_userid(session,
this_uid,
identity->user_id);
if (status != PEP_STATUS_OK) {
free_identity_list(id_list);
return status;
@ -443,7 +445,7 @@ DYNAMIC_API PEP_STATUS update_identity(
// if we only have user_id and address and identity not available
// * return error status (identity not found)
if (!identity->username)
status PEP_CANNOT_FIND_IDENTITY;
status = PEP_CANNOT_FIND_IDENTITY;
// Otherwise, if we had user_id, address, and username:
// * create identity with user_id, address, username
@ -540,9 +542,9 @@ DYNAMIC_API PEP_STATUS update_identity(
// * If exactly one found
// * elect valid key for identity (see below)
// * Return this identity
stored_ident = id_curr->ident;
stored_ident = id_list->ident;
if (this_id)
if (stored_ident)
status = prepare_updated_identity(session, identity,
stored_ident, false);
else
@ -551,7 +553,14 @@ DYNAMIC_API PEP_STATUS update_identity(
else // too little info
status = PEP_CANNOT_FIND_IDENTITY;
}
// FIXME: This is legacy. I presume it's a notification for the caller...
// Revisit once I can talk to Volker
if (identity->comm_type != PEP_ct_compromized &&
identity->comm_type < PEP_ct_strong_but_unconfirmed)
if (session->examine_identity)
session->examine_identity(identity, session->examine_management);
return ADD_TO_LOG(status);
}

83
src/pEpEngine.c
Unescape View File

@ -76,7 +76,7 @@ static const char *sql_get_identity_without_trust_check =
" and identity.user_id = ?2;";
static const char *sql_get_identities_by_address =
"select main_key_id, username, comm_type, lang,"
"select user_id, main_key_id, username, comm_type, lang,"
" identity.flags, is_own"
" from identity"
" where (case when (address = ?1) then (1)"
@ -89,6 +89,10 @@ static const char *sql_replace_identities_fpr =
"update identity"
" set main_key_id = ?1 "
" where main_key_id = ?2 ;";
static const char *sql_remove_fpr_as_default =
"update person set main_key_id = NULL where main_key_id = ?1 ;"
"update identity set main_key_id = NULL where main_key_id = ?1 ;";
// Set person, but if already exist, only update.
// if main_key_id already set, don't touch.
@ -690,6 +694,7 @@ DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
// person->id replacements (for temp ids like "TOFU_")
// so here we go...
int_result = sqlite3_exec(
_session->db,
"PRAGMA foreign_keys=off;\n"
"BEGIN TRANSACTION;\n"
"ALTER TABLE identity RENAME TO _identity_old;\n"
@ -790,6 +795,11 @@ DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
(int)strlen(sql_replace_identities_fpr),
&_session->replace_identities_fpr, NULL);
assert(int_result == SQLITE_OK);
int_result = sqlite3_prepare_v2(_session->db, sql_remove_fpr_as_default,
(int)strlen(sql_remove_fpr_as_default),
&_session->remove_fpr_as_default, NULL);
assert(int_result == SQLITE_OK);
int_result = sqlite3_prepare_v2(_session->db, sql_set_person,
(int)strlen(sql_set_person), &_session->set_person, NULL);
@ -1041,6 +1051,8 @@ DYNAMIC_API void release(PEP_SESSION session)
sqlite3_finalize(session->get_own_userid);
if (session->replace_identities_fpr)
sqlite3_finalize(session->replace_identities_fpr);
if (session->remove_fpr_as_default)
sqlite3_finalize(session->remove_fpr_as_default);
if (session->set_person)
sqlite3_finalize(session->set_person);
if (session->set_device_group)
@ -1559,38 +1571,39 @@ PEP_STATUS get_identities_by_address(
*id_list = NULL;
identity_list* ident_list = NULL;
sqlite3_reset(sql->get_identities_by_address);
sqlite3_bind_text(sql->get_identities_by_address, 1, address, -1, SQLITE_STATIC);
sqlite3_reset(session->get_identities_by_address);
sqlite3_bind_text(session->get_identities_by_address, 1, address, -1, SQLITE_STATIC);
int result;
while ((result = sqlite3_step(sql->get_identities_by_address)) == SQLITE_ROW) {
while ((result = sqlite3_step(session->get_identities_by_address)) == SQLITE_ROW) {
//"select user_id, main_key_id, username, comm_type, lang,"
//" identity.flags, is_own"
ident = new_identity(
address,
(const char *) sqlite3_column_text(sql->get_identities_by_address, 0),
user_id,
(const char *) sqlite3_column_text(sql->get_identities_by_address, 1)
(const char *) sqlite3_column_text(session->get_identities_by_address, 1),
(const char *) sqlite3_column_text(session->get_identities_by_address, 0),
(const char *) sqlite3_column_text(session->get_identities_by_address, 2)
);
assert(_identity);
assert(ident);
if (ident == NULL)
return PEP_OUT_OF_MEMORY;
ident->comm_type = (PEP_comm_type)
sqlite3_column_int(sql->get_identities_by_address, 2);
sqlite3_column_int(session->get_identities_by_address, 3);
const char* const _lang = (const char *)
sqlite3_column_text(sql->get_identities_by_address, 3);
sqlite3_column_text(session->get_identities_by_address, 4);
if (_lang && _lang[0]) {
assert(_lang[0] >= 'a' && _lang[0] <= 'z');
assert(_lang[1] >= 'a' && _lang[1] <= 'z');
assert(_lang[2] == 0);
_identity->lang[0] = _lang[0];
_identity->lang[1] = _lang[1];
_identity->lang[2] = 0;
ident->lang[0] = _lang[0];
ident->lang[1] = _lang[1];
ident->lang[2] = 0;
}
ident->flags = (unsigned int)
sqlite3_column_int(sql->get_identities_by_address, 4);
sqlite3_column_int(session->get_identities_by_address, 5);
ident->me = (unsigned int)
sqlite3_column_int(sql->get_identities_by_address, 5);
sqlite3_column_int(session->get_identities_by_address, 6);
if (ident_list)
identity_list_add(ident_list, ident);
@ -1598,7 +1611,7 @@ PEP_STATUS get_identities_by_address(
ident_list = new_identity_list(ident);
}
sqlite3_reset(sql->get_identities_by_address);
sqlite3_reset(session->get_identities_by_address);
*id_list = ident_list;
@ -1719,6 +1732,28 @@ DYNAMIC_API PEP_STATUS set_identity(
return PEP_COMMIT_FAILED;
}
PEP_STATUS remove_fpr_as_default(PEP_SESSION session,
const char* fpr)
{
assert(fpr);
if (!session || !fpr)
return PEP_ILLEGAL_VALUE;
sqlite3_reset(session->remove_fpr_as_default);
sqlite3_bind_text(session->remove_fpr_as_default, 1, fpr, -1,
SQLITE_STATIC);
int result = sqlite3_step(session->remove_fpr_as_default);
sqlite3_reset(session->remove_fpr_as_default);
if (result != SQLITE_DONE)
return PEP_CANNOT_SET_IDENTITY; // misleading - could also be person
return PEP_STATUS_OK;
}
PEP_STATUS replace_identities_fpr(PEP_SESSION session,
const char* old_fpr,
const char* new_fpr)
@ -1874,8 +1909,10 @@ DYNAMIC_API PEP_STATUS set_identity_flags(
sqlite3_bind_text(session->set_identity_flags, 2, identity->address, -1,
SQLITE_STATIC);
sqlite3_bind_text(session->set_identity_flags, 3, identity->user_id, -1,
result = sqlite3_step(session->set_identity_flags);
SQLITE_STATIC);
SQLITE_STATIC);
result = sqlite3_step(session->set_identity_flags);
sqlite3_reset(session->set_identity_flags);
if (result != SQLITE_DONE)
return PEP_CANNOT_SET_IDENTITY;
@ -1929,12 +1966,12 @@ PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
int result;
sqlite3_reset(session->replace_userid);
sqlite3_bind_text(session->replace_userid, 1, new_id, -1,
sqlite3_bind_text(session->replace_userid, 1, new_uid, -1,
SQLITE_STATIC);
sqlite3_bind_text(session->replace_userid, 2, old_id, -1,
sqlite3_bind_text(session->replace_userid, 2, old_uid, -1,
SQLITE_STATIC);
result = sqlite3_step(session->replace);
sqlite3_reset(session->replace);
result = sqlite3_step(session->replace_userid);
sqlite3_reset(session->replace_userid);
if (result != SQLITE_DONE)
return PEP_CANNOT_SET_PERSON; // May need clearer retval

14
src/pEpEngine.h
Unescape View File

@ -1153,15 +1153,25 @@ DYNAMIC_API PEP_STATUS reset_peptest_hack(PEP_SESSION session);
// This is used internally when there is a temporary identity to be retrieved
// that may not yet have an FPR attached. See get_identity() for functionality,
// params and caveats.
PEP_STATUS get_identity_without_fpr(
PEP_STATUS get_identity_without_trust_check(
PEP_SESSION session,
const char *address,
const char *user_id,
pEp_identity **identity
);
PEP_STATUS get_identities_by_address(
PEP_SESSION session,
const char *address,
identity_list** id_list
);
PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
const char* new_uid);
PEP_STATUS remove_fpr_as_default(PEP_SESSION session,
const char* fpr);
#ifdef __cplusplus
}

1
src/pEp_internal.h
Unescape View File

@ -127,6 +127,7 @@ struct _pEpSession {
sqlite3_stmt *get_identity_without_trust_check;
sqlite3_stmt *get_identities_by_address;
sqlite3_stmt *replace_identities_fpr;
sqlite3_stmt *remove_fpr_as_default;
sqlite3_stmt *set_person;
sqlite3_stmt *set_device_group;
sqlite3_stmt *get_device_group;

Write Preview
Loading…
Cancel
Save