import_key 2.1 changes - API change without substance XD (headers and calls)

import_key_2.1
parent 0cd1f862b6
commit d77dbdd10c

@ -65,7 +65,8 @@ typedef PEP_STATUS (*get_key_rating_t)(
);
typedef PEP_STATUS (*import_key_t)(PEP_SESSION session, const char *key_data,
size_t size, identity_list **private_keys);
size_t size, identity_list **private_keys, stringlist_t** imported_keys,
uint64_t* changed_key_index);
typedef PEP_STATUS (*recv_key_t)(PEP_SESSION session, const char *pattern);
@ -133,4 +134,3 @@ typedef uint64_t cryptotech_mask;
PEP_STATUS init_cryptotech(PEP_SESSION session, bool in_first);
void release_cryptotech(PEP_SESSION session, bool out_last);

@ -1575,8 +1575,13 @@ bool import_attached_keys(
continue;
}
}
// FIXME: free these guys if we choke, yeah?
identity_list *local_private_idents = NULL;
PEP_STATUS import_status = import_key(session, blob_value, blob_size, &local_private_idents);
stringlist_t* imported_keylist = NULL;
uint64_t changed_keys = 0;
PEP_STATUS import_status = import_key(session, blob_value, blob_size, &local_private_idents,
&imported_keylist, &changed_keys);
bloblist_t* to_delete = NULL;
switch (import_status) {
case PEP_NO_KEY_IMPORTED:
@ -3408,7 +3413,10 @@ static bool import_header_keys(PEP_SESSION session, message* src) {
bloblist_t* the_key = base64_str_to_binary_blob(start_key, length);
if (!the_key)
return false;
PEP_STATUS status = import_key(session, the_key->value, the_key->size, NULL);
stringlist_t* imported_keys = NULL;
uint64_t changed_keys = 0;
PEP_STATUS status = import_key(session, the_key->value, the_key->size, NULL,
&imported_keys, &changed_keys);
free_bloblist(the_key);
if (status == PEP_STATUS_OK || status == PEP_KEY_IMPORTED)
return true;

@ -4853,7 +4853,9 @@ DYNAMIC_API PEP_STATUS import_key(
PEP_SESSION session,
const char *key_data,
size_t size,
identity_list **private_keys
identity_list **private_keys,
stringlist_t** imported_keys,
uint64_t* changed_key_index
)
{
assert(session);
@ -4863,7 +4865,7 @@ DYNAMIC_API PEP_STATUS import_key(
return PEP_ILLEGAL_VALUE;
return session->cryptotech[PEP_crypt_OpenPGP].import_key(session, key_data,
size, private_keys);
size, private_keys, imported_keys, changed_key_index);
}
DYNAMIC_API PEP_STATUS recv_key(PEP_SESSION session, const char *pattern)

@ -895,10 +895,17 @@ DYNAMIC_API PEP_STATUS delete_keypair(PEP_SESSION session, const char *fpr);
// import_key() - import key from data
//
// parameters:
// session (in) session handle
// key_data (in) key data, i.e. ASCII armored OpenPGP key
// size (in) amount of data to handle
// private_keys (out) list of private keys that have been imported
// session (in) session handle
// key_data (in) key data, i.e. ASCII armored OpenPGP key
// size (in) amount of data to handle
// private_keys (out) list of identities containing the
// private keys that have been imported
// imported_keys (out) list of actual keys imported
// changed_key_index (out) bitvector - corresponds to the first 64 keys
// imported. If nth bit is set, import changed a
// key corresponding to the nth element in
// imported keys (i.e. key was in DB and was
// changed by import)
//
// return value:
// PEP_STATUS_OK = 0 key was successfully imported
@ -913,7 +920,9 @@ DYNAMIC_API PEP_STATUS import_key(
PEP_SESSION session,
const char *key_data,
size_t size,
identity_list **private_keys
identity_list **private_keys,
stringlist_t** imported_keys,
uint64_t* changed_key_index
);

@ -1,305 +0,0 @@
// This file is under GNU General Public License 3.0
// see LICENSE.txt
#pragma once
#include "pEpEngine.h"
// pgp_init() - initialize PGP backend
//
// parameters:
// session (in) session handle
// in_first (in) true if this is the first session
//
// return value:
// PEP_STATUS_OK if PGP backend was successfully initialized
// or any other value on error
PEP_STATUS pgp_init(PEP_SESSION session, bool in_first);
// pgp_release() - release PGP backend
//
// paramters:
// session (in) session handle
// out_last (in) true if this is the last session to release
void pgp_release(PEP_SESSION session, bool out_last);
// pgp_decrypt_and_verify() - decrypt and verify ciphertext
//
// parameters:
// session (in) session handle
// ctext (in) bytes with ciphertext
// csize (in) size of ciphertext in bytes
// dsigtext (in) pointer to bytes with detached signature
// or NULL if no detached signature
// dsigsize (in) size of detached signature in bytes
// ptext (out) bytes with ciphertext
// psize (out) size of ciphertext in bytes
// keylist (out) list of keys being used; first is the key being
// used for signing
// filename (out) PGP filename, when rendered (Optional, only necessary for some PGP implementations (e.g. Symantec),
// *** Mostly internal ***
// return value:
// PEP_DECRYPTED_AND_VERIFIED data could be decryped and verified
// PEP_DECRYPT_SIGNATURE_DOES_NOT_MATCH
// a signature does not match
// PEP_DECRYPTED data could be decrypted but not verified
// PEP_VERIFIED_AND_TRUSTED data was unencrypted but perfectly signed
// PEP_VERIFIED data was unencrypted, signature matches
// PEP_DECRYPT_NO_KEY data could not be decrypted because a
// key is missing
// PEP_DECRYPT_WRONG_FORMAT data format not readable
// PEP_ILLEGAL_VALUE parameters wrong
// PEP_OUT_OF_MEMORY out of memory error
// PEP_UNKOWN_ERROR internal error
PEP_STATUS pgp_decrypt_and_verify(
PEP_SESSION session,
const char *ctext,
size_t csize,
const char *dsigtext,
size_t dsigsize,
char **ptext,
size_t *psize,
stringlist_t **keylist,
char** filename_ptr
);
// pgp_encrypt_and_sign() - encrypt plaintext and sign
//
// parameters:
// session (in) session handle
// keylist (in) first key to sign and encrypt, all other keys to
// encrypt
// ptext (in) bytes with plaintext
// psize (in) size of plaintext in bytes
// ctext (out) bytes with ciphertext, ASCII armored
// csize (out) size of ciphertext in bytes
//
// return value:
// PEP_STATUS_OK successful
// PEP_KEY_NOT_FOUND key not in keyring
// PEP_KEY_HAS_AMBIG_NAME multiple keys match data in keylist
// PEP_GET_KEY_FAILED access to keyring failed
// PEP_ILLEGAL_VALUE parameters wrong
// PEP_OUT_OF_MEMORY out of memory error
// PEP_UNKOWN_ERROR internal error
PEP_STATUS pgp_encrypt_and_sign(
PEP_SESSION session,
const stringlist_t *keylist,
const char *ptext,
size_t psize,
char **ctext,
size_t *csize
);
PEP_STATUS pgp_sign_only(
PEP_SESSION session, const char* fpr, const char *ptext,
size_t psize, char **stext, size_t *ssize
);
// pgp_encrypt_only() - encrypt plaintext
//
// parameters:
// session (in) session handle
// keylist (in) keys to encrypt plaintext
// ptext (in) bytes with plaintext
// psize (in) size of plaintext in bytes
// ctext (out) bytes with ciphertext, ASCII armored
// csize (out) size of ciphertext in bytes
//
// return value:
// PEP_STATUS_OK successful
// PEP_KEY_NOT_FOUND key not in keyring
// PEP_KEY_HAS_AMBIG_NAME multiple keys match data in keylist
// PEP_GET_KEY_FAILED access to keyring failed
// PEP_ILLEGAL_VALUE parameters wrong
// PEP_OUT_OF_MEMORY out of memory error
// PEP_UNKNOWN_ERROR internal error
PEP_STATUS pgp_encrypt_only(
PEP_SESSION session,
const stringlist_t *keylist,
const char *ptext,
size_t psize,
char **ctext,
size_t *csize
);
// pgp_verify_text() - verify signed data
//
// parameters:
// session (in) session handle
// keylist (in) keys to encrypt plaintext
// text (in) data to verify, may include signature
// size (in) size of data to verify in bytes
// signature (in) detached signature data or NULL
// sig_size (in) size of detached signature in bytes
// keylist (out) list of keys being used for signing
//
// return value:
// PEP_VERIFIED_AND_TRUSTED data was unencrypted but perfectly signed
// this is depending on PGP trust concept
// PEP_VERIFIED data was unencrypted, signature matches
// PEP_DECRYPT_NO_KEY data could not be verified because a
// key is missing
// PEP_DECRYPT_WRONG_FORMAT data format not readable
// PEP_ILLEGAL_VALUE parameters wrong
// PEP_OUT_OF_MEMORY out of memory error
// PEP_UNKOWN_ERROR internal error
PEP_STATUS pgp_verify_text(
PEP_SESSION session,
const char *text,
size_t size,
const char *signature,
size_t sig_size,
stringlist_t **keylist
);
// pgp_delete_keypair() - delete key or keypair
//
// parameters:
// session (in) session handle
// fpr (in) fingerprint of key or keypair to delete
PEP_STATUS pgp_delete_keypair(PEP_SESSION session, const char *fpr);
// pgp_export_keydata() - export public key data ASCII armored
//
// parameters:
// session (in) session handle
// fpr (in) fingerprint of public key to export
// key_data (out) ascii armored key data
// size (out) size of ascii armored key data
// secret (in) additionally export private key data
PEP_STATUS pgp_export_keydata(
PEP_SESSION session,
const char *fpr,
char **key_data,
size_t *size,
bool secret
);
// pgp_find_keys() - find keys where fprs are matching a pattern
//
// parameters:
// session (in) session handle
// pattern (in) UTF-8 string with pattern
// keylist (out) list of fprs matching
PEP_STATUS pgp_find_keys(
PEP_SESSION session,
const char *pattern,
stringlist_t **keylist
);
PEP_STATUS pgp_list_keyinfo(
PEP_SESSION session,
const char* pattern,
stringpair_list_t** keyinfo_list
);
PEP_STATUS pgp_generate_keypair(
PEP_SESSION session,
pEp_identity *identity
);
PEP_STATUS pgp_get_key_rating(
PEP_SESSION session,
const char *fpr,
PEP_comm_type *comm_type
);
PEP_STATUS pgp_import_keydata(
PEP_SESSION session,
const char *key_data,
size_t size,
identity_list **private_idents
);
PEP_STATUS pgp_import_private_keydata(
PEP_SESSION session,
const char *key_data,
size_t size,
identity_list **private_idents
);
PEP_STATUS pgp_recv_key(PEP_SESSION session, const char *pattern);
PEP_STATUS pgp_send_key(PEP_SESSION session, const char *pattern);
PEP_STATUS pgp_renew_key(
PEP_SESSION session,
const char *fpr,
const timestamp *ts
);
PEP_STATUS pgp_revoke_key(
PEP_SESSION session,
const char *fpr,
const char *reason
);
PEP_STATUS pgp_key_expired(
PEP_SESSION session,
const char *fpr,
const time_t when,
bool *expired
);
PEP_STATUS pgp_key_revoked(
PEP_SESSION session,
const char *fpr,
bool *revoked
);
PEP_STATUS pgp_key_created(
PEP_SESSION session,
const char *fpr,
time_t *created
);
PEP_STATUS pgp_contains_priv_key(
PEP_SESSION session,
const char *fpr,
bool *has_private
);
PEP_STATUS pgp_find_private_keys(
PEP_SESSION session,
const char *pattern,
stringlist_t **keylist
);
PEP_STATUS pgp_binary(const char **path);
// Returns first failure status, if there were any. Keys may have been
// imported into DB regardless of status.
PEP_STATUS pgp_import_ultimately_trusted_keypairs(PEP_SESSION session);
/* Really only internal. */
PEP_STATUS pgp_replace_only_uid(
PEP_SESSION session,
const char* fpr,
const char* realname,
const char* email
);
PEP_STATUS pgp_config_cipher_suite(PEP_SESSION session,
PEP_CIPHER_SUITE suite);
#define PGP_BINARY_PATH pgp_binary

@ -2253,7 +2253,9 @@ static unsigned int count_keydata_parts(const char* key_data, size_t size) {
}
PEP_STATUS _pgp_import_keydata(PEP_SESSION session, const char *key_data,
size_t size, identity_list **private_idents)
size_t size, identity_list **private_idents,
stringlist_t** imported_keys,
uint64_t* changed_key_index)
{
PEP_STATUS status = PEP_NO_KEY_IMPORTED;
pgp_error_t err;
@ -2385,7 +2387,9 @@ PEP_STATUS _pgp_import_keydata(PEP_SESSION session, const char *key_data,
}
PEP_STATUS pgp_import_keydata(PEP_SESSION session, const char *key_data,
size_t size, identity_list **private_idents)
size_t size, identity_list **private_idents,
stringlist_t** imported_keys,
uint64_t* changed_key_index)
{
const char* pgp_begin = "-----BEGIN PGP";
@ -2404,7 +2408,8 @@ PEP_STATUS pgp_import_keydata(PEP_SESSION session, const char *key_data,
unsigned int keycount = count_keydata_parts(key_data, size);
if (keycount < 2)
return(_pgp_import_keydata(session, key_data, size, private_idents));
return(_pgp_import_keydata(session, key_data, size, private_idents,
imported_keys, changed_key_index));
unsigned int i;
const char* curr_begin;
@ -2428,7 +2433,12 @@ PEP_STATUS pgp_import_keydata(PEP_SESSION session, const char *key_data,
else
curr_size = (key_data + size) - curr_begin;
PEP_STATUS curr_status = _pgp_import_keydata(session, curr_begin, curr_size, private_idents);
PEP_STATUS curr_status = _pgp_import_keydata(session,
curr_begin,
curr_size,
private_idents,
imported_keys,
changed_key_index);
if (private_idents && *private_idents) {
if (!collected_idents)
collected_idents = *private_idents;

@ -62,7 +62,9 @@ PEP_STATUS pgp_get_key_rating(
);
PEP_STATUS pgp_import_keydata(PEP_SESSION session, const char *key_data,
size_t size, identity_list **private_idents);
size_t size, identity_list **private_idents,
stringlist_t** imported_keys,
uint64_t* changed_key_index);
PEP_STATUS pgp_import_private_keydata(PEP_SESSION session, const char *key_data,
size_t size, identity_list **private_idents);

@ -99,9 +99,9 @@ TEST_F(AppleMailTest, check_apple_mail_text_signed_encrypted) {
const string keytextkey2 = slurp("test_keys/priv/pep-test-recip-0x08DB0AEE_priv.asc");
const string keytextkey3 = slurp("test_keys/pub/pep-test-recip-0x08DB0AEE_pub.asc");
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL);
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL, NULL, NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL, NULL, NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL, NULL, NULL);
const string mailtext = slurp(mailfile);
pEp_identity * me = new_identity("pep.test.recip@kgrothoff.org", "93D19F24AD6F4C4BA9134AAF84D9217908DB0AEE", PEP_OWN_USERID, "pEp Test Recipient");
@ -157,9 +157,9 @@ TEST_F(AppleMailTest, check_apple_mail_html_signed_encrypted) {
const string keytextkey2 = slurp("test_keys/priv/pep-test-recip-0x08DB0AEE_priv.asc");
const string keytextkey3 = slurp("test_keys/pub/pep-test-recip-0x08DB0AEE_pub.asc");
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL);
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL, NULL, NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL, NULL, NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL, NULL, NULL);
pEp_identity * me = new_identity("pep.test.recip@kgrothoff.org", "93D19F24AD6F4C4BA9134AAF84D9217908DB0AEE", PEP_OWN_USERID, "pEp Test Recipient");
me->me = true;

@ -65,18 +65,18 @@ namespace {
// Engine is up. Keep on truckin'
string keystr = slurp("test_keys/priv/bcc_test_dude_0-0x1CCCFC41_priv.asc");
PEP_STATUS status = import_key(session, keystr.c_str(), keystr.size(), NULL);
PEP_STATUS status = import_key(session, keystr.c_str(), keystr.size(), NULL, NULL, NULL);
ASSERT_TRUE(status == PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity * me = new_identity("bcc_test_dude_0@darthmama.cool", "0AE9AA3E320595CF93296BDFA155AC491CCCFC41", PEP_OWN_USERID, "BCC Test Sender");
status = set_own_key(session, me, "0AE9AA3E320595CF93296BDFA155AC491CCCFC41");
keystr = slurp("test_keys/pub/bcc_test_dude_0-0x1CCCFC41_pub.asc");
status = import_key(session, keystr.c_str(), keystr.size(), NULL);
status = import_key(session, keystr.c_str(), keystr.size(), NULL, NULL, NULL);
ASSERT_TRUE(status == PEP_TEST_KEY_IMPORT_SUCCESS);
keystr = slurp("test_keys/pub/bcc_test_dude_1-0xDAC746BE_pub.asc");
status = import_key(session, keystr.c_str(), keystr.size(), NULL);
status = import_key(session, keystr.c_str(), keystr.size(), NULL, NULL, NULL);
ASSERT_TRUE(status == PEP_TEST_KEY_IMPORT_SUCCESS);
keystr = slurp("test_keys/pub/bcc_test_dude_2-0x53CECCF7_pub.asc");
status = import_key(session, keystr.c_str(), keystr.size(), NULL);
status = import_key(session, keystr.c_str(), keystr.size(), NULL, NULL, NULL);
ASSERT_TRUE(status == PEP_TEST_KEY_IMPORT_SUCCESS);
}

@ -100,7 +100,7 @@ TEST_F(BlacklistAcceptNewKeyTest, check_blacklist_accept_new_key) {
const string keytext = slurp("test_keys/pub/blacklisted_pub.asc");
/* import it into pep */
PEP_STATUS status7 = import_key(session, keytext.c_str(), keytext.length(), NULL);
PEP_STATUS status7 = import_key(session, keytext.c_str(), keytext.length(), NULL, NULL, NULL);
const char* bl_fpr_1 = "279765A2FEB5B7C731B861D93E4CEFD9F7AF4684";
bool is_blacklisted = false;

@ -152,7 +152,7 @@ TEST_F(BlacklistTest, check_blacklist) {
/* FIXME: put in automated test stuff (N.B. only gdb mem examination to this point to get
* fix in */
/* import it into pep */
PEP_STATUS status7 = import_key(session, keytext.c_str(), keytext.length(), NULL);
PEP_STATUS status7 = import_key(session, keytext.c_str(), keytext.length(), NULL, NULL, NULL);
const char* bl_fpr_1 = "279765A2FEB5B7C731B861D93E4CEFD9F7AF4684";
const char* bl_fpr_2 = "634FAC4417E9B2A5DC2BD4AAC4AEEBBE7E62701B";
@ -229,7 +229,7 @@ TEST_F(BlacklistTest, check_blacklist) {
free_message(msg23);
const string keytext2 = slurp("test_keys/pub/blacklisted_pub2.asc");
PEP_STATUS status14 = import_key(session, keytext2.c_str(), keytext2.length(), NULL);
PEP_STATUS status14 = import_key(session, keytext2.c_str(), keytext2.length(), NULL, NULL, NULL);
pEp_identity* blacklisted_identity2 = new_identity("blacklistedkeys@kgrothoff.org",
bl_fpr_2,

@ -98,7 +98,7 @@ TEST_F(CaseAndDotAddressTest, check_case_and_dot_address) {
const char* alice_email_dotless = "peptestalice@pep-project.org";
const char* alice_email_case_and_dot = "PE.p.teS.t.ALICE@pep-project.OrG";
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity * alice_id = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", user_id, "Alice Test");

@ -92,9 +92,9 @@ TEST_F(DecorateTest, check_decorate) {
const string alice_pub_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
const string alice_priv_key = slurp("test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc");
const string bob_pub_key = slurp("test_keys/pub/pep-test-bob-0xC9C2EE39_pub.asc");
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
PEP_STATUS statusbob = import_key(session, bob_pub_key.c_str(), bob_pub_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL, NULL, NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL, NULL, NULL);
PEP_STATUS statusbob = import_key(session, bob_pub_key.c_str(), bob_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statuspriv , PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statusbob , PEP_TEST_KEY_IMPORT_SUCCESS);

@ -108,11 +108,11 @@ TEST_F(DecryptAttachPrivateKeyTrustedTest, check_decrypt_attach_private_key_trus
//
// 13A9F97964A2B52520CAA40E51BCA783C065A213
input_key = slurp("test_keys/pub/priv-key-import-test-main_0-0xC065A213_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
input_key = slurp("test_keys/priv/priv-key-import-test-main_0-0xC065A213_priv.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
// ensure there's no private key - doesn't work in automated tests, sadly. Uncommon when running script manually.
@ -121,7 +121,7 @@ TEST_F(DecryptAttachPrivateKeyTrustedTest, check_decrypt_attach_private_key_trus
// key with same address and user_id
// 8AB616A3BD51DEF714B5E688EFFB540C3276D2E5
input_key = slurp("test_keys/pub/priv-key-import-test-main_0-0x3276D2E5_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);

@ -106,11 +106,11 @@ TEST_F(DecryptAttachPrivateKeyUntrustedTest, check_decrypt_attach_private_key_un
//
// 13A9F97964A2B52520CAA40E51BCA783C065A213
input_key = slurp("test_keys/pub/priv-key-import-test-main_0-0xC065A213_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
input_key = slurp("test_keys/priv/priv-key-import-test-main_0-0xC065A213_priv.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
// ensure there's no private key - doesn't work in automated tests, sadly. Uncommon when running script manually.
@ -126,7 +126,7 @@ TEST_F(DecryptAttachPrivateKeyUntrustedTest, check_decrypt_attach_private_key_un
// key with same address and user_id
// 8AB616A3BD51DEF714B5E688EFFB540C3276D2E5
input_key = slurp("test_keys/pub/priv-key-import-test-main_0-0x3276D2E5_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);

@ -118,35 +118,35 @@ TEST_F(EncryptAttachPrivateKeyTest, check_encrypt_attach_private_key) {
// key for main own user
// 8AB616A3BD51DEF714B5E688EFFB540C3276D2E5
input_key = slurp("test_keys/pub/priv-key-import-test-main_0-0x3276D2E5_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
input_key = slurp("test_keys/priv/priv-key-import-test-main_0-0x3276D2E5_priv.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
// key with same address and user_id (initially untrusted, then trusted)
// 359DD8AC87D1F5E4304D08338D7185F180C8CD87
input_key = slurp("test_keys/pub/priv-key-import-test-main_1-0x80C8CD87_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
// key with same address and to have different (non-aliased) user_id (initially untrusted, then trusted)
// B044B83639E292283A3F6E14C2E64B520B74809C
input_key = slurp("test_keys/pub/priv-key-import-test-main_2-0x0B74809C_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
// key with different address to have same user_id (initially untrusted, then trusted)
// C52911EBA0D34B0F549594A15A7A363BD11252C9
input_key = slurp("test_keys/pub/priv-key-import-test-other_0-0xD11252C9_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
// key with different address to have different user_id (initially untrusted, then trusted)
// 567212EFB8A3A76B1D32B9565F45BEA9C785F20A
input_key = slurp("test_keys/pub/priv-key-import-test-other_1-0xC785F20A_pub.asc");
status = import_key(session, input_key.c_str(), input_key.length(), NULL);
status = import_key(session, input_key.c_str(), input_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
output_stream << "Done!" << endl << endl;

@ -98,14 +98,14 @@ TEST_F(EncryptForIdentityTest, check_encrypt_for_identity) {
const string gabrielle_pub_key = slurp("test_keys/pub/pep-test-gabrielle-0xE203586C_pub.asc");
const string bella_pub_key = slurp("test_keys/pub/pep.test.bella-0xAF516AAE_pub.asc");
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL, NULL, NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub, PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statuspriv, PEP_TEST_KEY_IMPORT_SUCCESS);
statuspub = import_key(session, gabrielle_pub_key.c_str(), gabrielle_pub_key.length(), NULL);
statuspub = import_key(session, gabrielle_pub_key.c_str(), gabrielle_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub, PEP_TEST_KEY_IMPORT_SUCCESS);
statuspub = import_key(session, bella_pub_key.c_str(), bella_pub_key.length(), NULL);
statuspub = import_key(session, bella_pub_key.c_str(), bella_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub, PEP_TEST_KEY_IMPORT_SUCCESS);
const char* alice_fpr = "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97";

@ -71,7 +71,7 @@ namespace {
// Engine is up. Keep on truckin'
string recip_key = slurp("test_keys/pub/pep-test-bob-0xC9C2EE39_pub.asc");
PEP_STATUS status = import_key(session, recip_key.c_str(), recip_key.size(), NULL);
PEP_STATUS status = import_key(session, recip_key.c_str(), recip_key.size(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
}

@ -88,9 +88,9 @@ TEST_F(Engine463Test, check_engine_463_no_own_key) {
const string claudio_keys = slurp("test_keys/priv/notfound-alt-pub_and_private.asc");
const string fake_schleuder_key = slurp("test_keys/pub/fake-schleuder.asc");
PEP_STATUS status = import_key(session, claudio_keys.c_str(), claudio_keys.length(), NULL);
PEP_STATUS status = import_key(session, claudio_keys.c_str(), claudio_keys.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, fake_schleuder_key.c_str(), fake_schleuder_key.length(), NULL);
status = import_key(session, fake_schleuder_key.c_str(), fake_schleuder_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
// Ok, bring in message, decrypt, and see what happens.
@ -111,9 +111,9 @@ TEST_F(Engine463Test, check_engine_463_own_key) {
const string claudio_keys = slurp("test_keys/priv/notfound-alt-pub_and_private.asc");
const string fake_schleuder_key = slurp("test_keys/pub/fake-schleuder.asc");
PEP_STATUS status = import_key(session, claudio_keys.c_str(), claudio_keys.length(), NULL);
PEP_STATUS status = import_key(session, claudio_keys.c_str(), claudio_keys.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, fake_schleuder_key.c_str(), fake_schleuder_key.length(), NULL);
status = import_key(session, fake_schleuder_key.c_str(), fake_schleuder_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* own_ident = new_identity("claudio+engine-463@pep.foundation", "A039BC60E43E0DFDDC9DE8663B48C38325210C88", PEP_OWN_USERID, "Not Actually Claudio");

@ -81,6 +81,6 @@ TEST_F(Engine715Test, check_engine_715) {
// This is just a dummy test case. The convention is check_whatever_you_are_checking
// so for multiple test cases in a suite, be more explicit ;)
string keyfile = slurp("test_keys/t001.asc");
PEP_STATUS status = import_key(session, keyfile.c_str(), keyfile.size(), NULL);
PEP_STATUS status = import_key(session, keyfile.c_str(), keyfile.size(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_KEY_IMPORTED);
}

@ -102,8 +102,8 @@ TEST_F(ExternalRevokeTest, check_external_revoke) {
ASSERT_NE(fenris_pub_key.length() , 0);
ASSERT_NE(fenris_priv_key.length() , 0);
PEP_STATUS statuspub = import_key(session, fenris_pub_key.c_str(), fenris_pub_key.length(), NULL);
PEP_STATUS statuspriv = import_key(session, fenris_priv_key.c_str(), fenris_priv_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, fenris_pub_key.c_str(), fenris_pub_key.length(), NULL, NULL, NULL);
PEP_STATUS statuspriv = import_key(session, fenris_priv_key.c_str(), fenris_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statuspriv , PEP_TEST_KEY_IMPORT_SUCCESS);

@ -2577,7 +2577,7 @@ TEST_F(KeyResetMessageTest, check_reset_own_with_revocations) {
// Reimport
curr_key = revocations;
for (i = 0; i < 4; curr_key = curr_key->next, i++) {
status = import_key(session, curr_key->value, strlen(curr_key->value), NULL);
status = import_key($1, $2, $3, $4, NULL, NULL);
ASSERT_EQ(status, PEP_KEY_IMPORTED);
}
ASSERT_EQ(i, 4);
@ -2585,7 +2585,7 @@ TEST_F(KeyResetMessageTest, check_reset_own_with_revocations) {
curr_key = keys;
for (i = 0; i < 4; curr_key = curr_key->next, i++) {
status = import_key(session, curr_key->value, strlen(curr_key->value), NULL);
status = import_key($1, $2, $3, $4, NULL, NULL);
ASSERT_EQ(status, PEP_KEY_IMPORTED);
}
ASSERT_EQ(i, 4);

@ -93,7 +93,7 @@ TEST_F(KeyringImportTest, check_import1) {
#ifdef USE_SEQUOIA
const string pub_key = slurp("test_keys/pub/pep-test-keyring.asc");
PEP_STATUS statuspub = import_key(session, pub_key.c_str(), pub_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, pub_key.c_str(), pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
struct entry {
@ -145,7 +145,7 @@ TEST_F(KeyringImportTest, check_import2) {
#ifdef USE_SEQUOIA
const string pub_key = slurp("test_keys/pub/pep-test-android-keyring.pgp");
PEP_STATUS statuspub = import_key(session, pub_key.c_str(), pub_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, pub_key.c_str(), pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
struct entry {

@ -103,7 +103,7 @@ TEST_F(LeastColorGroupTest, check_least_color_group) {
for (auto name : keynames) {
output_stream << "\t read keyfile \"" << name << "\"..." << std::endl;
const string keytextkey = slurp(name);
PEP_STATUS statuskey = import_key(session, keytextkey.c_str(), keytextkey.length(), NULL);
PEP_STATUS statuskey = import_key(session, keytextkey.c_str(), keytextkey.length(), NULL, NULL, NULL);
ASSERT_EQ(statuskey , PEP_TEST_KEY_IMPORT_SUCCESS);
}

@ -98,10 +98,10 @@ TEST_F(LeastCommonDenomColorTest, check_least_common_denom_color) {
const string keytextkey3 = slurp("test_keys/pub/pep.never.me.test-0x79C11D1D_pub.asc");
const string keytextkey4 = slurp("test_keys/priv/pep.never.me.test-0x79C11D1D_priv.asc");
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL);
PEP_STATUS statuskey4 = import_key(session, keytextkey4.c_str(), keytextkey4.length(), NULL);
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL, NULL, NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL, NULL, NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL, NULL, NULL);
PEP_STATUS statuskey4 = import_key(session, keytextkey4.c_str(), keytextkey4.length(), NULL, NULL, NULL);
pEp_identity * sender = new_identity("pep.never.me.test@kgrothoff.org", NULL, "TOFU_pep.never.me.test@kgrothoff.org", "pEp Never Me Test");
sender->me = false;

@ -96,7 +96,7 @@ TEST_F(LookupTest, check_lookup) {
const char* username = "SuperDuperHans";
const string pub_key = slurp("test_keys/pub/hans@xn--bcher-kva.tld_-0x08AD6E9400D38894_pub.asc");
PEP_STATUS statuspub = import_key(session, pub_key.c_str(), pub_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, pub_key.c_str(), pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* hans = new_identity(expected_address, NULL, userid, username);

@ -94,11 +94,11 @@ TEST_F(MessageApiTest, check_message_api) {
const string alice_priv_key = slurp("test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc");
const string bob_pub_key = slurp("test_keys/pub/pep-test-bob-0xC9C2EE39_pub.asc");
PEP_STATUS status0 = import_key(session, alice_pub_key.c_str(), alice_pub_key.size(), NULL);
PEP_STATUS status0 = import_key(session, alice_pub_key.c_str(), alice_pub_key.size(), NULL, NULL, NULL);
ASSERT_EQ(status0 , PEP_TEST_KEY_IMPORT_SUCCESS);
status0 = import_key(session, alice_priv_key.c_str(), alice_priv_key.size(), NULL);
status0 = import_key(session, alice_priv_key.c_str(), alice_priv_key.size(), NULL, NULL, NULL);
ASSERT_EQ(status0 , PEP_TEST_KEY_IMPORT_SUCCESS);
status0 = import_key(session, bob_pub_key.c_str(), bob_pub_key.size(), NULL);
status0 = import_key(session, bob_pub_key.c_str(), bob_pub_key.size(), NULL, NULL, NULL);
ASSERT_EQ(status0 , PEP_TEST_KEY_IMPORT_SUCCESS);
// message_api test code

@ -42,16 +42,16 @@ namespace {
void import_alice_pub() {
const string alice_pub_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
PEP_STATUS status = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
PEP_STATUS status = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL, NULL, NULL);
assert(status == PEP_TEST_KEY_IMPORT_SUCCESS);
}
void import_bob_pair_and_set_own() {
const string bob_pub_key = slurp("test_keys/pub/pep-test-bob-0xC9C2EE39_pub.asc");
const string bob_priv_key = slurp("test_keys/priv/pep-test-bob-0xC9C2EE39_priv.asc");
PEP_STATUS status = import_key(session, bob_pub_key.c_str(), bob_pub_key.length(), NULL);
PEP_STATUS status = import_key(session, bob_pub_key.c_str(), bob_pub_key.length(), NULL, NULL, NULL);
assert(status == PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, bob_priv_key.c_str(), bob_priv_key.length(), NULL);
status = import_key(session, bob_priv_key.c_str(), bob_priv_key.length(), NULL, NULL, NULL);
assert(status == PEP_TEST_KEY_IMPORT_SUCCESS);
}

@ -100,12 +100,12 @@ TEST_F(MessageTwoPointOhTest, check_message_two_point_oh) {
const string carol_pub_key = slurp("test_keys/pub/pep-test-carol-0x42A85A42_pub.asc");
const string carol_priv_key = slurp("test_keys/priv/pep-test-carol-0x42A85A42_priv.asc");
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL, NULL, NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statuspriv , PEP_TEST_KEY_IMPORT_SUCCESS);
statuspub = import_key(session, carol_pub_key.c_str(), carol_pub_key.length(), NULL);
statuspriv = import_key(session, carol_priv_key.c_str(), carol_priv_key.length(), NULL);
statuspub = import_key(session, carol_pub_key.c_str(), carol_pub_key.length(), NULL, NULL, NULL);
statuspriv = import_key(session, carol_priv_key.c_str(), carol_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statuspriv , PEP_TEST_KEY_IMPORT_SUCCESS);

@ -95,9 +95,9 @@ TEST_F(PepSubjectReceivedTest, check_pep_subject_received) {
const string keytextkey1 = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
const string keytextkey2 = slurp("test_keys/priv/pep-test-recip-0x08DB0AEE_priv.asc");
const string keytextkey3 = slurp("test_keys/pub/pep-test-recip-0x08DB0AEE_pub.asc");
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL);
PEP_STATUS statuskey1 = import_key(session, keytextkey1.c_str(), keytextkey1.length(), NULL, NULL, NULL);
PEP_STATUS statuskey2 = import_key(session, keytextkey2.c_str(), keytextkey2.length(), NULL, NULL, NULL);
PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL, NULL, NULL);
pEp_identity * me = new_identity("pep.test.recip@kgrothoff.org", "93D19F24AD6F4C4BA9134AAF84D9217908DB0AEE", PEP_OWN_USERID, "pEp Test Recipient");
me->me = true;

@ -99,35 +99,35 @@ namespace {
const string own_recip_priv_key = slurp("test_keys/priv/reencrypt_recip_0-0xB1A2BE89_priv.asc");
const string own_recip_2_pub_key = slurp("test_keys/pub/reencrypt_recip_numero_deux_test_0-0xD6E75FFF_pub.asc");
const string own_recip_2_priv_key = slurp("test_keys/priv/reencrypt_recip_numero_deux_test_0-0xD6E75FFF_priv.asc");
status = import_key(session, own_recip_pub_key.c_str(), own_recip_pub_key.length(), NULL);
status = import_key(session, own_recip_pub_key.c_str(), own_recip_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, own_recip_priv_key.c_str(), own_recip_priv_key.length(), NULL);
status = import_key(session, own_recip_priv_key.c_str(), own_recip_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, own_recip_2_pub_key.c_str(), own_recip_2_pub_key.length(), NULL);
status = import_key(session, own_recip_2_pub_key.c_str(), own_recip_2_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, own_recip_2_priv_key.c_str(), own_recip_2_priv_key.length(), NULL);
status = import_key(session, own_recip_2_priv_key.c_str(), own_recip_2_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
// Import sender key
const string sender_pub_key = slurp("test_keys/pub/reencrypt_sender_0-0x3B508C8E_pub.asc");
status = import_key(session, sender_pub_key.c_str(), sender_pub_key.length(), NULL);
status = import_key(session, sender_pub_key.c_str(), sender_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
// Import other recips
const string recip_0_pub_key = slurp("test_keys/pub/reencrypt_other_recip_0-0x1F4A5986_pub.asc");
status = import_key(session, recip_0_pub_key.c_str(), recip_0_pub_key.length(), NULL);
status = import_key(session, recip_0_pub_key.c_str(), recip_0_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
// we're leaving recip_1 out for the Hell of it - D3886D0DF75113BE2799C9374D6B99FE0F8273D8
const string recip_2_pub_key = slurp("test_keys/pub/reencrypt_other_recip_2-0x1EDBE691_pub.asc");
status = import_key(session, recip_2_pub_key.c_str(), recip_2_pub_key.length(), NULL);
status = import_key(session, recip_2_pub_key.c_str(), recip_2_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
// Import extra keys
const string pub_extra_key_0 = slurp("test_keys/pub/reencrypt_extra_keys_0-0x828AA789_pub.asc");
const string pub_extra_key_1 = slurp("test_keys/pub/reencrypt_extra_keys_1-0x8B026AEC_pub.asc");
status = import_key(session, pub_extra_key_0.c_str(), pub_extra_key_0.length(), NULL);
status = import_key(session, pub_extra_key_0.c_str(), pub_extra_key_0.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
status = import_key(session, pub_extra_key_1.c_str(), pub_extra_key_1.length(), NULL);
status = import_key(session, pub_extra_key_1.c_str(), pub_extra_key_1.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
output_stream << "Keys imported." << endl;

@ -93,7 +93,7 @@ TEST_F(RevocationTest, check_revocation) {
// Read the key.
const string key = slurp("test_keys/priv/pep-test-linda-0xDCD555B6055ADE22_priv.asc");
PEP_STATUS status = import_key(session, key.c_str(), key.length(), NULL);
PEP_STATUS status = import_key(session, key.c_str(), key.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* pre = new_identity("linda@example.org", NULL, NULL, NULL);
@ -104,7 +104,7 @@ TEST_F(RevocationTest, check_revocation) {
// Read in the revocation certificate.
const string rev = slurp("test_keys/priv/pep-test-linda-0xDCD555B6055ADE22.rev");
status = import_key(session, rev.c_str(), rev.length(), NULL);
status = import_key(session, rev.c_str(), rev.length(), NULL, NULL, NULL);
ASSERT_EQ(status , PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* post = new_identity("linda@example.org", NULL, NULL, NULL);

@ -70,7 +70,7 @@ namespace {
// Engine is up. Keep on truckin'
string recip_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
PEP_STATUS status = import_key(session, recip_key.c_str(), recip_key.size(), NULL);
PEP_STATUS status = import_key(session, recip_key.c_str(), recip_key.size(), NULL, NULL, NULL);
ASSERT_EQ(status, PEP_TEST_KEY_IMPORT_SUCCESS);
}

@ -258,7 +258,7 @@ TEST_F(UpdateIdAndMyselfTest, check_update_identity_and_myself) {
// 1. create original identity
const string alex_pub_key = slurp("test_keys/pub/pep.test.alexander-0x26B54E4E_pub.asc");
PEP_STATUS statuspub = import_key(session, alex_pub_key.c_str(), alex_pub_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, alex_pub_key.c_str(), alex_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub, PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* alex = new_identity(alex_address, alex_fpr, alex_userid, alex_username);
@ -451,7 +451,7 @@ TEST_F(UpdateIdAndMyselfTest, check_update_identity_and_myself) {
const char* bella_username = "Annabella the Great";
const string bella_pub_key = slurp("test_keys/pub/pep.test.bella-0xAF516AAE_pub.asc");
statuspub = import_key(session, bella_pub_key.c_str(), bella_pub_key.length(), NULL);
statuspub = import_key(session, bella_pub_key.c_str(), bella_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub, PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* bella = new_identity(bella_address, bella_fpr, bella_userid, bella_username);
@ -500,7 +500,7 @@ TEST_F(UpdateIdAndMyselfTest, check_update_identity_and_myself) {
const char* bernd_username = "Bernd das Brot der Ultimative Testkandidat";
const string bernd_pub_key = slurp("test_keys/pub/bernd.das.brot-0xCAFAA422_pub.asc");
statuspub = import_key(session, bernd_pub_key.c_str(), bernd_pub_key.length(), NULL);
statuspub = import_key(session, bernd_pub_key.c_str(), bernd_pub_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub, PEP_TEST_KEY_IMPORT_SUCCESS);
pEp_identity* bernd = new_identity(bernd_address, bernd_fpr, bernd_userid, bernd_username);

@ -94,8 +94,8 @@ TEST_F(UserIDAliasTest, check_userid_aliases) {
const string alice_pub_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
const string alice_priv_key = slurp("test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc");
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL, NULL, NULL);
PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL, NULL, NULL);
ASSERT_EQ(statuspub , PEP_TEST_KEY_IMPORT_SUCCESS);
ASSERT_EQ(statuspriv , PEP_TEST_KEY_IMPORT_SUCCESS);

@ -72,7 +72,7 @@ PEP_STATUS read_file_and_import_key(PEP_SESSION session, const char* fname) {
const std::string key = slurp(fname);
PEP_STATUS status = (key.empty() ? PEP_KEY_NOT_FOUND : PEP_STATUS_OK);
if (status == PEP_STATUS_OK)
status = import_key(session, key.c_str(), key.size(), NULL);
status = import_key(session, key.c_str(), key.size(), NULL, NULL, NULL);
return status;
}
@ -450,7 +450,7 @@ std::string tl_ident_flags_String(identity_flags_t fl) {
}
bool slurp_and_import_key(PEP_SESSION session, const char* key_filename) {
std::string keyfile = slurp(key_filename);
if (import_key(session, keyfile.c_str(), keyfile.size(), NULL) != PEP_TEST_KEY_IMPORT_SUCCESS)
if (import_key(session, keyfile.c_str(), keyfile.size(), NULL, NULL, NULL) != PEP_TEST_KEY_IMPORT_SUCCESS)
return false;
return true;
}

Loading…
Cancel
Save