Converted .hgignore to .gitignore

.gitignore

@@ -1,14 +1,12 @@
-syntax: regexp
-^asn\.1/.*\.(c|h)$
-^asn\.1/libasn1\.a$
-.*xcuserdata/
-^build/
-^local.conf
-^test_home/
-
-syntax: glob
 asn.1/Makefile.am.*
 asn.1/converter-example.mk
+asn.1/libasn1.a
+local.conf
+build/
+test_home/
+asn.1/*.c
+asn.1/*.h
+xcuserdata/
 *.orig
 *.old
 *.d

src/pEpEngine.c

@@ -1945,10 +1945,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_trustword), &_session->trustword, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_get_identity,
             (int)strlen(sql_get_identity), &_session->get_identity, NULL);
     assert(int_result == SQLITE_OK);
@@ -1970,11 +1966,7 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_get_identities_by_address), 
             &_session->get_identities_by_address, NULL);
     assert(int_result == SQLITE_OK);
-
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
+    
     int_result = sqlite3_prepare_v2(_session->db, sql_get_identities_by_userid,
             (int)strlen(sql_get_identities_by_userid), 
             &_session->get_identities_by_userid, NULL);
@@ -1997,10 +1989,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_get_user_default_key), &_session->get_user_default_key, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_get_all_keys_for_user,
             (int)strlen(sql_get_all_keys_for_user), &_session->get_all_keys_for_user, NULL);
     assert(int_result == SQLITE_OK);
@@ -2021,10 +2009,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_get_userid_alias_default), &_session->get_userid_alias_default, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_add_userid_alias,
             (int)strlen(sql_add_userid_alias), &_session->add_userid_alias, NULL);
     assert(int_result == SQLITE_OK);
@@ -2037,10 +2021,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_replace_userid), &_session->replace_userid, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_delete_key,
             (int)strlen(sql_delete_key), &_session->delete_key, NULL);
     assert(int_result == SQLITE_OK);
@@ -2053,10 +2033,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_replace_main_user_fpr), &_session->replace_main_user_fpr, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_replace_main_user_fpr_if_equal,
             (int)strlen(sql_replace_main_user_fpr_if_equal), &_session->replace_main_user_fpr_if_equal, NULL);
     assert(int_result == SQLITE_OK);
@@ -2069,10 +2045,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_get_main_user_fpr), &_session->get_main_user_fpr, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_refresh_userid_default_key,
             (int)strlen(sql_refresh_userid_default_key), &_session->refresh_userid_default_key, NULL);
     assert(int_result == SQLITE_OK);
@@ -2085,11 +2057,7 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_replace_identities_fpr), 
             &_session->replace_identities_fpr, NULL);
     assert(int_result == SQLITE_OK);
-
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
+    
     int_result = sqlite3_prepare_v2(_session->db, sql_remove_fpr_as_identity_default,
             (int)strlen(sql_remove_fpr_as_identity_default), 
             &_session->remove_fpr_as_identity_default, NULL);
@@ -2112,10 +2080,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_set_person), &_session->set_person, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_update_person,
             (int)strlen(sql_update_person), &_session->update_person, NULL);
     assert(int_result == SQLITE_OK);
@@ -2128,10 +2092,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_delete_person), &_session->delete_person, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_exists_person,
             (int)strlen(sql_exists_person), &_session->exists_person, NULL);
     assert(int_result == SQLITE_OK);
@@ -2152,10 +2112,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_is_pEp_user), &_session->is_pEp_user, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_add_into_social_graph,
             (int)strlen(sql_add_into_social_graph), &_session->add_into_social_graph, NULL);
     assert(int_result == SQLITE_OK);
@@ -2247,10 +2203,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_set_identity_entry), &_session->set_identity_entry, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_update_identity_entry,
             (int)strlen(sql_update_identity_entry), &_session->update_identity_entry, NULL);
     assert(int_result == SQLITE_OK);
@@ -2263,10 +2215,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_exists_identity_entry), &_session->exists_identity_entry, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_set_identity_flags,
             (int)strlen(sql_set_identity_flags), &_session->set_identity_flags,
             NULL);
@@ -2289,11 +2237,7 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_set_ident_enc_format), &_session->set_ident_enc_format,
             NULL);
     assert(int_result == SQLITE_OK);
-
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
+            
     int_result = sqlite3_prepare_v2(_session->db, sql_set_pEp_version,
             (int)strlen(sql_set_pEp_version), &_session->set_pEp_version,
             NULL);
@@ -2316,10 +2260,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_clear_trust_info), &_session->clear_trust_info, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_set_trust,
             (int)strlen(sql_set_trust), &_session->set_trust, NULL);
     assert(int_result == SQLITE_OK);
@@ -2332,10 +2272,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_update_trust), &_session->update_trust, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_update_trust_to_pEp,
             (int)strlen(sql_update_trust_to_pEp), &_session->update_trust_to_pEp, NULL);
     assert(int_result == SQLITE_OK);
@@ -2348,10 +2284,6 @@ DYNAMIC_API PEP_STATUS init(
                  (int)strlen(sql_exists_trust_entry), &_session->exists_trust_entry, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_update_trust_for_fpr,
             (int)strlen(sql_update_trust_for_fpr), &_session->update_trust_for_fpr, NULL);
     assert(int_result == SQLITE_OK);
@@ -2364,10 +2296,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_get_trust), &_session->get_trust, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_get_trust_by_userid,
             (int)strlen(sql_get_trust_by_userid), &_session->get_trust_by_userid, NULL);
     assert(int_result == SQLITE_OK);
@@ -2380,10 +2308,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_least_trust), &_session->least_trust, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_mark_as_compromised,
             (int)strlen(sql_mark_as_compromised), &_session->mark_compromised,
             NULL);
@@ -2397,10 +2321,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_crashdump), &_session->crashdump, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->system_db, sql_languagelist,
             (int)strlen(sql_languagelist), &_session->languagelist, NULL);
     assert(int_result == SQLITE_OK);
@@ -2449,11 +2369,7 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_blacklist_retrieve), &_session->blacklist_retrieve,
             NULL);
     assert(int_result == SQLITE_OK);
-
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
+    
     // Own keys
     
     int_result = sqlite3_prepare_v2(_session->db, sql_own_key_is_listed,
@@ -2487,11 +2403,7 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_own_keys_retrieve),
             &_session->own_keys_retrieve, NULL);
     assert(int_result == SQLITE_OK);
-
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
+ 
     // int_result = sqlite3_prepare_v2(_session->db, sql_set_own_key,
     //         (int)strlen(sql_set_own_key),
     //         &_session->set_own_key, NULL);
@@ -2540,10 +2452,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_get_replacement_fpr), &_session->get_replacement_fpr, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_add_mistrusted_key,
             (int)strlen(sql_add_mistrusted_key), &_session->add_mistrusted_key, NULL);
     assert(int_result == SQLITE_OK);
@@ -2556,10 +2464,6 @@ DYNAMIC_API PEP_STATUS init(
             (int)strlen(sql_delete_mistrusted_key), &_session->delete_mistrusted_key, NULL);
     assert(int_result == SQLITE_OK);
 
-    if (int_result != SQLITE_OK)
-        return PEP_UNKNOWN_DB_ERROR;
-
-
     int_result = sqlite3_prepare_v2(_session->db, sql_is_mistrusted_key,
             (int)strlen(sql_is_mistrusted_key), &_session->is_mistrusted_key, NULL);
     assert(int_result == SQLITE_OK);
@@ -5300,7 +5204,7 @@ DYNAMIC_API PEP_STATUS verify_text(
 DYNAMIC_API PEP_STATUS delete_keypair(PEP_SESSION session, const char *fpr)
 {
 
-    if (!(session && fpr))
+    if (!(session && fpr && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     return session->cryptotech[PEP_crypt_OpenPGP].delete_keypair(session, fpr);
@@ -5311,7 +5215,7 @@ DYNAMIC_API PEP_STATUS export_key(
     )
 {
 
-    if (!(session && fpr && key_data && size))
+    if (!(session && fpr && key_data && size && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
@@ -5322,7 +5226,7 @@ DYNAMIC_API PEP_STATUS export_secret_key(
         PEP_SESSION session, const char *fpr, char **key_data, size_t *size
     )
 {
-    if (!(session && fpr && key_data && size))
+    if (!(session && fpr && key_data && size && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     // don't accept key IDs but full fingerprints only
@@ -5338,7 +5242,7 @@ DYNAMIC_API PEP_STATUS export_secrect_key(
         PEP_SESSION session, const char *fpr, char **key_data, size_t *size
     )
 {
-    return export_secret_key(session, fpr, key_data, size);
+    return export_secret_key(session, fpr, key_data, size && check_fpr_format(fpr));
 }
 
 DYNAMIC_API PEP_STATUS find_keys(
@@ -5423,7 +5327,7 @@ DYNAMIC_API PEP_STATUS get_key_rating(
         PEP_comm_type *comm_type
     )
 {
-    if (!(session && fpr && comm_type))
+    if (!(session && fpr && comm_type && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     return session->cryptotech[PEP_crypt_OpenPGP].get_key_rating(session, fpr,
@@ -5480,7 +5384,7 @@ DYNAMIC_API PEP_STATUS renew_key(
         const timestamp *ts
     )
 {
-    if (!(session && fpr))
+    if (!(session && fpr && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     return session->cryptotech[PEP_crypt_OpenPGP].renew_key(session, fpr, ts);
@@ -5492,7 +5396,7 @@ DYNAMIC_API PEP_STATUS revoke_key(
         const char *reason
     )
 {
-    if (!(session && fpr))
+    if (!(session && fpr && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     // Check to see first if it is revoked
@@ -5515,7 +5419,7 @@ DYNAMIC_API PEP_STATUS key_expired(
         bool *expired
     )
 {
-    if (!(session && fpr && expired))
+    if (!(session && fpr && expired && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     return session->cryptotech[PEP_crypt_OpenPGP].key_expired(session, fpr,
@@ -5528,7 +5432,7 @@ DYNAMIC_API PEP_STATUS key_revoked(
        bool *revoked
    )
 {    
-    if (!(session && fpr && revoked))
+    if (!(session && fpr && revoked && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
     
     return session->cryptotech[PEP_crypt_OpenPGP].key_revoked(session, fpr,
@@ -5971,8 +5875,8 @@ DYNAMIC_API PEP_STATUS set_revoked(
     PEP_STATUS status = PEP_STATUS_OK;
         
     if (!(session &&
-          revoked_fpr && revoked_fpr[0] &&
-          replacement_fpr && replacement_fpr[0]
+          revoked_fpr && check_fpr_format(revoked_fpr) &&
+          replacement_fpr && check_fpr_format(replacement_fpr) 
          ))
         return PEP_ILLEGAL_VALUE;
     
@@ -6007,7 +5911,7 @@ DYNAMIC_API PEP_STATUS get_revoked(
 {
     PEP_STATUS status = PEP_STATUS_OK;
    
-    if (!(session && revoked_fpr && fpr && fpr[0]))
+    if (!(session && revoked_fpr && fpr && check_fpr_format(fpr)))
         return PEP_ILLEGAL_VALUE;
 
     *revoked_fpr = NULL;
@@ -6225,3 +6129,22 @@ PEP_STATUS set_all_userids_to_own(PEP_SESSION session, identity_list* id_list) {
     }
     return status;    
 }
+
+bool check_fpr_format(const char* fpr) {
+    if (EMPTYSTR(fpr))
+        return false;
+
+    int fpr_len = strlen(fpr);
+    if (fpr_len > 128 || fpr_len < 16)
+        return false;
+
+    const char* curr_fpr;
+
+    for (curr_fpr = fpr; curr_fpr && *curr_fpr != '\0'; curr_fpr++) {
+        char c = *curr_fpr;
+        if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f'))
+            continue;
+        return false;
+    }
+    return true;
+}

src/pEp_internal.h

@@ -374,15 +374,7 @@ typedef enum _normalize_hex_rest_t {
     reject_hex
 } normalize_hex_res_t;
 
-/**
- *  <!--       _normalize_hex()       -->
- *  
- *  @brief            TODO
- *  
- *  @param[in]  hex         char*
- *  
- */
-static inline normalize_hex_res_t _normalize_hex(char *hex) 
+static inline normalize_hex_res_t _normalize_hex(char* hex) 
 {
     if (*hex >= '0' && *hex <= '9')
         return accept_hex;
@@ -517,6 +509,16 @@ static inline int _same_fpr(
     return comparison == 0;
 }
 
+/**
+ *  <!--       check_fpr_format()       -->
+ *  
+ *  @brief     Check if fpr is hex and has between 16 and 128 characters inclusive            
+ *  
+ *  @param[in]  fpr       fingerprint to check 
+ *  
+ */
+bool check_fpr_format(const char* fpr); 
+
 // size is the length of the bytestr that's coming in. This is really only intended
 // for comparing two full strings. If charstr's length is different from bytestr_size,
 // we'll return a non-zero value.
@@ -743,14 +745,6 @@ static inline void _init_globals() {
 
 // spinlock implementation
 
-/**
- *  <!--       Sqlite3_step()       -->
- *  
- *  @brief            TODO
- *  
- *  @param[in]  stmt         sqlite3_stmt*
- *  
- */
 static inline int Sqlite3_step(sqlite3_stmt* stmt)
 {
     int rc;

test/src/KeyManipulationTest.cc

@@ -17,6 +17,24 @@ namespace {
         public:
             Engine* engine;
             PEP_SESSION session;
+            
+            const char* alice_fpr = "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97";
+            const char* alice_email = "pep.test.alice@pep-project.org";
+            const char* bob_fpr = "BFCDB7F301DEEEBBF947F29659BFF488C9C2EE39";
+            const char* mary_fpr= "599B3D67800DB37E2DCE05C07F59F03CD04A226E";
+            const char* erin_fpr = "1B0E197E8AE66277B8A024B9AEA69F509F8D7CBA";
+            const char* erin_email = "pep-test-erin@pep-project.org";
+            const char* bob_email = "pep.test.bob@pep-project.org";
+            const string alice_user_id = PEP_OWN_USERID;
+            const string bob_user_id = "BobId";
+            const string mary_user_id = "MaryId";
+
+            const char* nobodys_fpr = "11111133333333CFE4F86500A9411D4444445555"; 
+
+            // faulty fpr
+            const char* alice_too_long_fpr = "586500A9411D176FF00E974ABE3AAF59AC32CFE4F86500A9411D176FF00E974ABE3AAF59AC32CFE4F86500A9411D176FF00E974ABE3AAF59AC32CFE4F86500AA9";
+            const char* bob_too_short_fpr = "BFCDB7F301DEEEB";
+            const char* alice_not_hex_fpr = "6500A9411D176FF00E974ABE3AAF59ACXYZ";
 
         protected:
             // You can remove any or all of the following functions if its body
@@ -57,6 +75,36 @@ namespace {
                 // Engine is up. Keep on truckin'
             }
 
+            void import_test_keys() {
+                PEP_STATUS status = read_file_and_import_key(session,
+                            "test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
+                assert(status == PEP_KEY_IMPORTED);
+                status = set_up_ident_from_scratch(session,
+                            "test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc",
+                            "pep.test.alice@pep-project.org", alice_fpr,
+                            alice_user_id.c_str(), "Alice in Wonderland", NULL, true
+                        );
+                assert(status == PEP_STATUS_OK);
+
+                status = set_up_ident_from_scratch(session,
+                            "test_keys/pub/pep-test-bob-0xC9C2EE39_pub.asc",
+                            "pep.test.bob@pep-project.org", NULL, bob_user_id.c_str(), "Bob's Burgers",
+                            NULL, false
+                        );
+                assert(status == PEP_STATUS_OK);
+
+                status = read_file_and_import_key(session,
+                             "test_keys/priv/pep-test-mary-0x7F59F03CD04A226E_priv.asc");
+                assert(status == PEP_KEY_IMPORTED);
+
+                status = set_up_ident_from_scratch(session,
+                            "test_keys/pub/pep-test-mary-0x7F59F03CD04A226E_expired_pub.asc",
+                            "1960@example.org", NULL, mary_user_id.c_str(), "Mary Smith",
+                            NULL, false
+                        );
+                assert(status == PEP_STATUS_OK);
+            }
+
             void TearDown() override {
                 // Code here will be called immediately after each test (right
                 // before the destructor).
@@ -98,7 +146,877 @@ get_revoked()
 
 ***/
 
-TEST_F(KeyManipulationTest, check_key_manipulation) {
-    // 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 ;)
+// generate_keypair
+
+TEST_F(KeyManipulationTest, check_generate_keypair) {
+    stringlist_t* keylist = NULL;
+    pEp_identity* id = new_identity(
+        "leon.schumacher@digitalekho.com",
+        NULL,
+        "23",
+        "Leon Schumacher"
+    );
+
+    PEP_STATUS status = generate_keypair(session, id);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+
+    // Is it there?
+    status = find_keys(session, id->address, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_TRUE(keylist && keylist->value);
+    free_identity(id);
+    free_stringlist(keylist);
+}
+
+TEST_F(KeyManipulationTest, check_generate_keypair_no_session) {
+    pEp_identity* id = new_identity(
+        "leon.schumacher@digitalekho.com",
+        NULL,
+        "23",
+        "Leon Schumacher"
+    );
+
+    PEP_STATUS status = generate_keypair(NULL, id);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free_identity(id);
+}
+
+TEST_F(KeyManipulationTest, check_generate_keypair_no_identity) {
+    PEP_STATUS status = generate_keypair(session, NULL);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+}
+
+TEST_F(KeyManipulationTest, check_generate_keypair_has_fpr) {
+    stringlist_t* keylist = NULL;
+    pEp_identity* id = new_identity(
+        "leon.schumacher@digitalekho.com",
+        "8BD08954C74D830EEFFB5DEB2682A17F7C87F73D",
+        "23",
+        "Leon Schumacher"
+    );
+
+    PEP_STATUS status = generate_keypair(session, id);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free_identity(id);
+    free_stringlist(keylist);
+}
+TEST_F(KeyManipulationTest, check_generate_keypair_identity_without_user_id) {
+    stringlist_t* keylist = NULL;
+    pEp_identity* id = new_identity(
+        "leon.schumacher@digitalekho.com",
+        "",
+        "",
+        "Leon Schumacher"
+    );
+
+    PEP_STATUS status = generate_keypair(session, id);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+
+    // Is it there?
+    status = find_keys(session, id->address, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_TRUE(keylist && keylist->value);
+    free_identity(id);
+    free_stringlist(keylist);
+}
+
+TEST_F(KeyManipulationTest, check_generate_keypair_no_address) {
+    pEp_identity* id = new_identity(
+        NULL,
+        NULL,
+        "23",
+        "Leon Schumacher"
+    );
+
+    PEP_STATUS status = generate_keypair(session, id);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free_identity(id);
+}
+
+TEST_F(KeyManipulationTest, check_generate_keypair_seccond_key_for_same_adress) {
+    stringlist_t* keylist = NULL;
+    pEp_identity* id = new_identity(
+        "leon.schumacher@digitalekho.com",
+        NULL,
+        "23",
+        "Leon Schumacher"
+    );
+    pEp_identity* id2 = new_identity(
+        "leon.schumacher@digitalekho.com",
+        NULL,
+        "24",
+        "Leon Schumacher"
+    );
+
+    PEP_STATUS status = generate_keypair(session, id);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+
+    status = find_keys(session, id->address, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_TRUE(keylist && keylist->value);
+
+    free_stringlist(keylist);
+    keylist = NULL;
+
+    status = generate_keypair(session, id2);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    status = find_keys(session, id2->address, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    keylist = keylist->next;
+    ASSERT_TRUE(keylist && keylist->value);
+    free_stringlist(keylist);
+    free_identity(id);
+    free_identity(id2);
+}
+
+// delete_keypair()
+// only parameter testing as full test are done in in DeleteKeyTest.cc        
+
+TEST_F(KeyManipulationTest, check_delete_keypair) {
+    import_test_keys();
+    stringlist_t* keylist = NULL;
+
+    PEP_STATUS status = delete_keypair(session, alice_fpr);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    status = find_keys(session, alice_fpr, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_FALSE(keylist && keylist->value);
+    free_stringlist(keylist);
+}
+
+TEST_F(KeyManipulationTest, check_delete_keypair_no_session) {
+    PEP_STATUS status = delete_keypair(NULL, alice_fpr);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+}
+
+TEST_F(KeyManipulationTest, check_delete_keypair_no_fpr) {
+    PEP_STATUS status = delete_keypair(session, NULL);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+}
+
+TEST_F(KeyManipulationTest, check_delete_keypair_invalid_fpr_format) {
+    PEP_STATUS status = delete_keypair(session, alice_too_long_fpr);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    status = delete_keypair(session, bob_too_short_fpr);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    status = delete_keypair(session, alice_not_hex_fpr);
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+}
+
+TEST_F(KeyManipulationTest, check_delete_keypair_nonexistent_fpr) {
+    import_test_keys();
+    PEP_STATUS status = delete_keypair(session, nobodys_fpr);
+    ASSERT_EQ(status, PEP_KEY_NOT_FOUND);
+}
+
+TEST_F(KeyManipulationTest, check_delete_keypair_delete_twice) {
+    import_test_keys();
+    stringlist_t* keylist = NULL;
+
+    PEP_STATUS status = delete_keypair(session, alice_fpr);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    status = find_keys(session, alice_email, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_FALSE(keylist && keylist->value);
+    free_stringlist(keylist);
+
+    status = delete_keypair(session, alice_fpr);
+    ASSERT_EQ(status, PEP_KEY_NOT_FOUND);
+}
+
+// import_key()
+TEST_F(KeyManipulationTest, check_import_key_pub) {
+    string erin_pub = slurp("test_keys/pub/pep-test-erin-0x9F8D7CBA_pub.asc");
+    identity_list* idlist = NULL; 
+    PEP_STATUS status = import_key(session, erin_pub.c_str(), erin_pub.size(), &idlist);     
+    ASSERT_EQ(status, PEP_KEY_IMPORTED);
+
+    stringlist_t* keylist = NULL;
+    status = find_keys(session, erin_email, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_FALSE(idlist);
+    ASSERT_TRUE(keylist && keylist->value);
+    ASSERT_STREQ(keylist->value, erin_fpr);
+    free_stringlist(keylist);
+    free_identity_list(idlist);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_pub_no_idlist) {
+    string erin_pub = slurp("test_keys/pub/pep-test-erin-0x9F8D7CBA_pub.asc");
+    PEP_STATUS status = import_key(session, erin_pub.c_str(), erin_pub.size(), NULL);     
+    ASSERT_EQ(status, PEP_KEY_IMPORTED);
+
+    stringlist_t* keylist = NULL;
+    status = find_keys(session, erin_email, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_TRUE(keylist && keylist->value);
+    ASSERT_STREQ(keylist->value, erin_fpr);
+    free_stringlist(keylist);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_priv) {
+    string erin_priv = slurp("test_keys/priv/pep-test-erin-0x9F8D7CBA_priv.asc");
+    identity_list* idlist = NULL; 
+    PEP_STATUS status = import_key(session, erin_priv.c_str(), erin_priv.size(), &idlist);     
+    ASSERT_EQ(status, PEP_KEY_IMPORTED);
+
+    stringlist_t* keylist = NULL;
+    status = find_keys(session, erin_email, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_NE(idlist->ident, nullptr);
+    ASSERT_TRUE(keylist && keylist->value);
+    ASSERT_STREQ(keylist->value, erin_fpr);
+    free_stringlist(keylist);
+    free_identity_list(idlist);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_priv_no_idlist) {
+    string erin_priv = slurp("test_keys/priv/pep-test-erin-0x9F8D7CBA_priv.asc");
+    PEP_STATUS status = import_key(session, erin_priv.c_str(), erin_priv.size(), NULL);     
+    ASSERT_EQ(status, PEP_KEY_IMPORTED);
+
+    stringlist_t* keylist = NULL;
+    status = find_keys(session, erin_email, &keylist);
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    ASSERT_TRUE(keylist && keylist->value);
+    ASSERT_STREQ(keylist->value, erin_fpr);
+    free_stringlist(keylist);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_no_session) {
+    string erin_pub = slurp("test_keys/pub/pep-test-erin-0x9F8D7CBA_pub.asc");
+    identity_list* idlist = NULL; 
+    PEP_STATUS status = import_key(NULL, erin_pub.c_str(), erin_pub.size(), &idlist);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free_identity_list(idlist);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_no_key_data) {
+    string erin_pub = slurp("test_keys/pub/pep-test-erin-0x9F8D7CBA_pub.asc");
+    identity_list* idlist = NULL; 
+    PEP_STATUS status = import_key(session, NULL, erin_pub.size(), &idlist);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free_identity_list(idlist);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_no_size) {
+    string erin_pub = slurp("test_keys/pub/pep-test-erin-0x9F8D7CBA_pub.asc");
+    identity_list* idlist = NULL; 
+    PEP_STATUS status = import_key(session, erin_pub.c_str(), NULL, &idlist);     
+    ASSERT_EQ(status, PEP_NO_KEY_IMPORTED);
+}
+
+TEST_F(KeyManipulationTest, check_import_key_wrong_size) {
+    string erin_pub = slurp("test_keys/pub/pep-test-erin-0x9F8D7CBA_pub.asc");
+    identity_list* idlist = NULL; 
+    PEP_STATUS status = import_key(session, erin_pub.c_str(), erin_pub.size()+10, &idlist);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    status = import_key(session, erin_pub.c_str(), erin_pub.size()-10, &idlist);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free_identity_list(idlist);
+}
+
+
+// export_key()
+TEST_F(KeyManipulationTest, check_export_key) {
+    import_test_keys();
+    size_t keysize = 0;
+    char* keydata = NULL;
+
+    PEP_STATUS status = export_key(session, alice_fpr, &keydata, &keysize);     
+    ASSERT_EQ(status, PEP_STATUS_OK);
+    string alice_pub = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
+    ASSERT_TRUE(keydata && alice_pub.c_str()); 
+    ASSERT_EQ(strlen(keydata), keysize); 
+
+    free(keydata);
+}
+
+TEST_F(KeyManipulationTest, check_export_key_no_session) {
+    import_test_keys();
+    size_t keysize = 0;
+    char* keydata = NULL;
+
+    PEP_STATUS status = export_key(NULL, alice_fpr, &keydata, &keysize);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free(keydata);
+}
+
+TEST_F(KeyManipulationTest, check_export_key_no_fpr) {
+    import_test_keys();
+    size_t keysize = 0;
+    char* keydata = NULL;
+
+    PEP_STATUS status = export_key(session, NULL, &keydata, &keysize);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    free(keydata);
+}
+
+TEST_F(KeyManipulationTest, check_export_key_invalid_fpr_format) {
+    import_test_keys();
+    size_t keysize = 0;
+    char* keydata = NULL;
+
+    PEP_STATUS status = export_key(session, alice_too_long_fpr, &keydata, &keysize);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);
+    status = export_key(session, bob_too_short_fpr, &keydata, &keysize);     
+    ASSERT_EQ(status, PEP_ILLEGAL_VALUE);