pEp.foundation
/
pEpEngine
15
2
Fork 17
Code Issues 21 Pull Requests 1 Projects 2 Releases 52 Wiki Activity

ENGINE-423: normal tests pass. Now to test reencrypt functionality.

Browse Source
doc_update_sequoia
Krista Bennett 5 years ago
parent 0fd0e38b76
commit d2a39c12d9
17 changed files with 150 additions and 24 deletions
Show Stats Download Patch File Download Diff File

5
src/keymanagement.h
Unescape Escape View File

@ -363,6 +363,11 @@ PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen,
PEP_STATUS add_mistrusted_key(PEP_SESSION session, const char* fpr);
PEP_STATUS delete_mistrusted_key(PEP_SESSION session, const char* fpr);
PEP_STATUS is_mistrusted_key(PEP_SESSION session, const char* fpr, bool* mistrusted);
PEP_STATUS get_user_default_key(PEP_SESSION session, const char* user_id,
char** default_key);
// Only call on retrieval of previously stored identity!
// Also, we presume that if the stored_identity was sent in

76
src/message.c
Unescape Escape View File

@ -201,6 +201,81 @@ enomem:
return NULL;
}
DYNAMIC_API void message_transfer(message* dst, message *src)
{
assert(dst);
assert(src);
dst->dir = src->dir;
dst->rawmsg_ref = src->rawmsg_ref;
dst->rawmsg_size = src->rawmsg_size;
dst->refering_msg_ref = src->refering_msg_ref;
dst->enc_format = src->enc_format;
/* Strings */
free(dst->id);
free(dst->shortmsg);
free(dst->longmsg);
free(dst->longmsg_formatted);
free(dst->comments);
dst->id = src->id;
dst->shortmsg = src->shortmsg;
dst->longmsg = src->longmsg;
dst->longmsg_formatted = src->longmsg_formatted;
dst->comments = src->comments;
src->id = src->shortmsg = src->longmsg = src->longmsg_formatted = NULL;
src->comments = NULL;
/* bloblists */
free_bloblist(dst->attachments);
dst->attachments = src->attachments;
src->attachments = NULL;
/* timestamps */
free_timestamp(dst->sent);
free_timestamp(dst->recv);
dst->sent = src->sent;
dst->recv = src->recv;
src->sent = src->recv = NULL;
/* identities */
free_identity(dst->from);
free_identity(dst->recv_by);
dst->from = src->from;
dst->recv_by = src->recv_by;
src->from = src->recv_by = NULL;
/* identity lists */
free_identity_list(dst->to);
free_identity_list(dst->cc);
free_identity_list(dst->bcc);
free_identity_list(dst->reply_to);
dst->to = src->to;
dst->cc = src->cc;
dst->bcc = src->bcc;
dst->reply_to = src->reply_to;
src->to = src->cc = src->bcc = src->reply_to = NULL;
/* stringlists */
free_stringlist(dst->references);
free_stringlist(dst->keywords);
free_stringlist(dst->in_reply_to);
dst->references = src->references;
dst->keywords = src->keywords;
dst->in_reply_to = src->in_reply_to;
src->references = src->keywords = src->in_reply_to = NULL;
/* message ref list */
free_message_ref_list(dst->refered_by);
dst->refered_by = src->refered_by;
src->refered_by = NULL;
/* stringpair lists */
free_stringpair_list(dst->opt_fields);
dst->opt_fields = src->opt_fields;
src->opt_fields = NULL;
}
DYNAMIC_API message_ref_list *new_message_ref_list(message *msg)
{
message_ref_list *msg_list = calloc(1, sizeof(message_ref_list));
@ -266,4 +341,3 @@ DYNAMIC_API message_ref_list *message_ref_list_add(message_ref_list *msg_list, m
return message_ref_list_add(msg_list->next, msg);
}
}

14
src/message.h
Unescape Escape View File

@ -114,6 +114,20 @@ DYNAMIC_API void free_message(message *msg);
DYNAMIC_API message * message_dup(const message *msg);
// message_transfer - assign ownership of all fields of the src message to
// the dst message object passed in. Free respective memory
// in the dst message, and reinitialise and pointers in
// the src message to NULL so that it can be freed properly
// by its owner.
// parameters:
// dst (inout) message to clobber and reassign values to
// src (inout) message whose values will be transfered to dst
// NOTA BENE:
// not owned pointees (msg->rawmsg_ref and msg->refering_msg_ref) are shared!
// these are simply transferred.
DYNAMIC_API void message_transfer(message* dst, message *src);
// new_message_ref_list() - allocate new message reference list
//
// parameters:

42
src/message_api.c
Unescape Escape View File

@ -2041,7 +2041,7 @@ DYNAMIC_API PEP_STATUS encrypt_message_for_self(
if (status != PEP_STATUS_OK)
goto pep_error;
}
else if (!target_fpr)
else if (!target_id->fpr)
return PEP_ILLEGAL_VALUE;
*dst = NULL;
@ -2892,7 +2892,7 @@ static bool reject_fpr(PEP_SESSION session, const char* fpr) {
PEP_STATUS status = key_revoked(session, fpr, &reject);
if (!reject) {
status = key_expired(session, fpr, &reject);
status = key_expired(session, fpr, time(NULL), &reject);
if (reject) {
timestamp *ts = new_timestamp(time(NULL) + KEY_EXPIRE_DELTA);
status = renew_key(session, fpr, ts);
@ -2910,12 +2910,11 @@ static char* seek_good_trusted_private_fpr(PEP_SESSION session, char* own_id,
return NULL;
stringlist_t* kl_curr = keylist;
char* retval = NULL;
while (kl_curr) {
char* fpr = kl_curr->value;
if (is_own_trusted_private_fpr(fpr)) {
if (!reject_fpr(fpr))
if (is_trusted_own_priv_fpr(session, own_id, fpr)) {
if (!reject_fpr(session, fpr))
return strdup(fpr);
}
@ -2925,12 +2924,12 @@ static char* seek_good_trusted_private_fpr(PEP_SESSION session, char* own_id,
char* target_own_fpr = NULL;
// Last shot...
status = get_user_default_key(session, own_id,
&target_own_fpr);
PEP_STATUS status = get_user_default_key(session, own_id,
&target_own_fpr);
if (status == PEP_STATUS_OK && !EMPTYSTR(target_own_fpr)) {
if (is_own_trusted_private_fpr(target_own_fpr)) {
if (!reject_fpr(target_own_fpr))
if (is_trusted_own_priv_fpr(session, own_id, target_own_fpr)) {
if (!reject_fpr(session, target_own_fpr))
return target_own_fpr;
}
}
@ -2976,7 +2975,7 @@ DYNAMIC_API PEP_STATUS _decrypt_message(
bool is_pep_msg = is_a_pEpmessage(src);
// Grab input flags
bool reencrypt = (*flags & PEP_decrypt_flag_untrusted_server > 0);
bool reencrypt = ((*flags & PEP_decrypt_flag_untrusted_server) > 0);
// We own this pointer, and we take control of *keylist if reencrypting.
stringlist_t* extra = NULL;
@ -3326,6 +3325,7 @@ DYNAMIC_API PEP_STATUS _decrypt_message(
*dst = msg;
*keylist = _keylist;
message* reencrypt_msg;
if (reencrypt) {
if (decrypt_status == PEP_DECRYPTED || decrypt_status == PEP_DECRYPTED_AND_VERIFIED) {
@ -3337,28 +3337,30 @@ DYNAMIC_API PEP_STATUS _decrypt_message(
own_id,
_keylist);
if (target_own_fpr) {
pEp_identity* target_id = new_identity(NULL, own_id,
target_own_fpr, NULL);
pEp_identity* target_id = new_identity(NULL, target_own_fpr,
own_id, NULL);
if (target_id) {
*dst = NULL;
reencrypt_status = encrypt_message_for_self(session, target_id, msg,
extra, dst, PEP_enc_PGP_MIME,
extra, &reencrypt_msg, PEP_enc_PGP_MIME,
0);
if (reencrypt_status != PEP_STATUS_OK)
reencrypt_status = PEP_CANNOT_REENCRYPT;
free_identity(target_id);
}
free(target_own_fpr);
}
free(own_id);
}
}
free_stringlist(extra); // This was an input variable for us. Keylist is overwritten above.
if (reencrypt_status == PEP_CANNOT_REENCRYPT)
decrypt_status = reencrypt_status;
else {
// Copy msg into src
free_stringlist(extra); // This was an input variable for us. Keylist is overwritten above.
if (reencrypt_status != PEP_CANNOT_REENCRYPT && reencrypt_msg) {
message_transfer(src, reencrypt_msg);
free_message(reencrypt_msg);
}
else
decrypt_status = PEP_CANNOT_REENCRYPT;
}
}

1
src/pEpEngine.h
Unescape Escape View File

@ -72,6 +72,7 @@ typedef enum {
PEP_DECRYPT_SIGNATURE_DOES_NOT_MATCH = 0x0406,
PEP_VERIFY_NO_KEY = 0x0407,
PEP_VERIFIED_AND_TRUSTED = 0x0408,
PEP_CANNOT_REENCRYPT = 0x0409,
PEP_CANNOT_DECRYPT_UNKNOWN = 0x04ff,
PEP_TRUSTWORD_NOT_FOUND = 0x0501,

3
test/apple_mail_test.cc
Unescape Escape View File

@ -50,7 +50,7 @@ int main(int argc, char** argv) {
message* final_ptr = nullptr;
stringlist_t* keylist = nullptr;
PEP_rating rating;
PEP_decrypt_flags_t flags;
PEP_decrypt_flags_t flags = 0;
status = mime_decode_message(mailtext.c_str(), mailtext.length(), &msg_ptr);
assert(status == PEP_STATUS_OK);
@ -80,6 +80,7 @@ int main(int argc, char** argv) {
final_ptr = nullptr;
keylist = nullptr;
rating = PEP_rating_unreliable;
flags = 0;
const char* mailfile2 = "test_mails/apple_mail_TC_html_signed_encrypted.eml";
const string mailtext2 = slurp(mailfile2);

2
test/blacklist_accept_new_key_test.cc
Unescape Escape View File

@ -76,7 +76,7 @@ int main() {
message* dest_msg = nullptr;
stringlist_t* keylist = nullptr;
PEP_rating rating;
PEP_decrypt_flags_t flags;
PEP_decrypt_flags_t flags = 0;
status = mime_decode_message(mailtext.c_str(), mailtext.length(), &msg_ptr);
assert(status == PEP_STATUS_OK);

4
test/decrypt_attach_private_key_trusted_test.cc
Unescape Escape View File

@ -102,7 +102,7 @@ int main() {
char* decrypted_text = NULL;
stringlist_t* keylist_used = NULL;
PEP_rating rating;
PEP_decrypt_flags_t flags;
PEP_decrypt_flags_t flags = 0;
cout << "Trusting personal key for " << same_addr_same_uid->user_id << " and " << same_addr_same_uid->fpr << endl;
status = trust_personal_key(session, same_addr_same_uid);
@ -116,6 +116,7 @@ int main() {
assert(same_addr_same_uid->comm_type == PEP_ct_pEp);
flags = 0;
status = MIME_decrypt_message(session, encoded_text.c_str(),
encoded_text.size(), &decrypted_text,
&keylist_used, &rating, &flags);
@ -123,6 +124,7 @@ int main() {
status = get_trust(session, same_addr_same_uid);
assert(same_addr_same_uid->comm_type == PEP_ct_pEp);
flags = 0;
status = MIME_decrypt_message(session, encoded_text.c_str(),
encoded_text.size(), &decrypted_text,
&keylist_used, &rating, &flags);

1
test/decrypt_attach_private_key_untrusted_test.cc
Unescape Escape View File

@ -103,6 +103,7 @@ int main() {
assert((same_addr_same_uid->comm_type & PEP_ct_confirmed) != PEP_ct_confirmed);
flags = 0;
status = MIME_decrypt_message(session, encoded_text.c_str(),
encoded_text.size(), &decrypted_text,
&keylist_used, &rating, &flags);

3
test/encrypt_for_identity_test.cc
Unescape Escape View File

@ -107,6 +107,7 @@ int main() {
PEP_rating rating;
PEP_decrypt_flags_t flags;
flags = 0;
status = decrypt_message(session, encrypted_msg, &decrypted_msg, &keylist_used, &rating, &flags);
assert(decrypted_msg);
assert(keylist_used);
@ -152,6 +153,7 @@ int main() {
assert(encrypted_msg);
cout << "message encrypted.\n";
flags = 0;
status = decrypt_message(session, encrypted_msg, &decrypted_msg, &keylist_used, &rating, &flags);
assert(decrypted_msg);
assert(keylist_used);
@ -246,6 +248,7 @@ int main() {
PEP_decrypt_flags_t mimeflags;
PEP_rating mimerating;
mimeflags = 0;
status = MIME_decrypt_message(session,
encrypted_mimetext,
strlen(encrypted_mimetext),

2
test/external_revoke_test.cc
Unescape Escape View File

@ -125,6 +125,7 @@ int main() {
cout << "1b. Decrypt message that was encrypted for trusted partner." << endl;
cout << "---------------------------------------------------------" << endl << endl;
flags = 0;
cout << "Decrypting message." << endl;
status = decrypt_message(session, encrypted_outgoing_msg, &outgoing_msg, &keylist, &rating, &flags);
cout << "Decrypted message with status " << tl_status_string(status) << endl;
@ -260,6 +261,7 @@ int main() {
cout << "---------------------------------------------------------" << endl << endl;
flags = 0;
status = decrypt_message(session, encrypted_outgoing_msg, &decrypted_msg, &keylist, &rating, &flags);
cout << "Decryption returns with status " << tl_status_string(status) << endl;
assert(status == PEP_STATUS_OK);

1
test/lars_test_do_not_run_outside_of_test_environment.cc
Unescape Escape View File

@ -142,6 +142,7 @@ void test_MIME_decrypt_message()
PEP_rating rating;
PEP_decrypt_flags_t dec_flags;
dec_flags = 0;
PEP_STATUS status2 = MIME_decrypt_message(session, mimetext.c_str(), mimetext.length(),
&plaintext, &keys_used, &rating, &dec_flags);

1
test/least_color_group_test.cc
Unescape Escape View File

@ -68,6 +68,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;

2
test/least_common_denom_color_test.cc
Unescape Escape View File

@ -66,6 +66,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
assert(status == PEP_STATUS_OK);
assert(dest_msg);
@ -113,6 +114,7 @@ int main(int argc, char** argv) {
status = mime_decode_message(mailtext.c_str(), mailtext.length(), &msg_ptr);
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
cout << "shortmsg: " << dest_msg->shortmsg << endl << endl;

1
test/message_2.0_test.cc
Unescape Escape View File

@ -134,6 +134,7 @@ int main() {
//
stringpair_t* autoconsume = new_stringpair("pEp-auto-consume", "yes");
stringpair_list_add(encrypted_msg->opt_fields, autoconsume);
flags = 0;
status = decrypt_message(session, encrypted_msg, &decrypted_msg, &keylist_used, &rating, &flags);
assert(decrypted_msg);
assert(keylist_used);

3
test/message_api_test.cc
Unescape Escape View File

@ -93,6 +93,7 @@ int main() {
PEP_rating rating;
PEP_decrypt_flags_t flags;
flags = 0;
PEP_STATUS status4 = decrypt_message(session, enc_msg2, &msg4, &keylist4, &rating, &flags);
assert(status4 == PEP_STATUS_OK);
assert(msg4);
@ -136,6 +137,7 @@ int main() {
stringlist_t *keylist5 = nullptr;
PEP_rating rating2;
PEP_decrypt_flags_t flags2;
flags2 = 0;
PEP_STATUS status6 = decrypt_message(session, msg5, &msg6, &keylist5, &rating2, &flags2);
assert(status6 == PEP_DECRYPT_NO_KEY);
assert(msg6 == NULL);
@ -177,6 +179,7 @@ int main() {
PEP_decrypt_flags_t dec_flags;
stringlist_t* keys_used;
dec_flags = 0;
PEP_STATUS status8 = MIME_decrypt_message(session, text5.c_str(), text5.length(), &dec_msg, &keys_used, &rating, &dec_flags);
assert(status8 == PEP_STATUS_OK);

13
test/pEp_subject_received_test.cc
Unescape Escape View File

@ -61,6 +61,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -93,6 +94,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -125,6 +127,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -157,6 +160,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -190,6 +194,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -222,6 +227,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -255,6 +261,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -287,6 +294,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -319,6 +327,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -351,6 +360,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -384,6 +394,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -417,6 +428,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;
@ -449,6 +461,7 @@ int main(int argc, char** argv) {
assert(status == PEP_STATUS_OK);
assert(msg_ptr);
final_ptr = msg_ptr;
flags = 0;
status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
final_ptr = dest_msg ? dest_msg : msg_ptr;

Write Preview
Loading…
Cancel
Save