diff --git a/src/tests/ffi-enc.cpp b/src/tests/ffi-enc.cpp index 5e027743be..0ee1b28517 100644 --- a/src/tests/ffi-enc.cpp +++ b/src/tests/ffi-enc.cpp @@ -151,10 +151,15 @@ TEST_F(rnp_tests, test_ffi_encrypt_pass) str_to_file("plaintext", plaintext); // create input+output w/ bad paths (should fail) input = NULL; + assert_rnp_failure(rnp_input_from_stdin(NULL)); + assert_rnp_failure(rnp_input_from_path(NULL, "noexist")); + assert_rnp_failure(rnp_input_from_path(&input, NULL)); assert_rnp_failure(rnp_input_from_path(&input, "noexist")); assert_null(input); assert_rnp_failure(rnp_output_to_path(&output, "")); assert_null(output); + assert_rnp_failure(rnp_output_to_path(NULL, "path")); + assert_rnp_failure(rnp_output_to_path(&output, NULL)); // create input+output assert_rnp_success(rnp_input_from_path(&input, "plaintext")); @@ -202,6 +207,7 @@ TEST_F(rnp_tests, test_ffi_encrypt_pass) assert_rnp_success(rnp_op_encrypt_set_cipher(op, "AES256")); } // execute the operation + assert_rnp_failure(rnp_op_encrypt_execute(NULL)); assert_rnp_success(rnp_op_encrypt_execute(op)); // make sure the output file was created @@ -222,6 +228,7 @@ TEST_F(rnp_tests, test_ffi_encrypt_pass) assert_non_null(input); assert_rnp_success(rnp_output_to_path(&output, "decrypted")); assert_non_null(output); + assert_rnp_failure(rnp_ffi_set_pass_provider(NULL, NULL, NULL)); assert_rnp_success(rnp_ffi_set_pass_provider(ffi, NULL, NULL)); assert_rnp_failure(rnp_decrypt(ffi, input, output)); // cleanup @@ -251,6 +258,9 @@ TEST_F(rnp_tests, test_ffi_encrypt_pass) assert_non_null(output); assert_rnp_success( rnp_ffi_set_pass_provider(ffi, ffi_string_password_provider, (void *) "pass1")); + assert_rnp_failure(rnp_decrypt(NULL, input, output)); + assert_rnp_failure(rnp_decrypt(ffi, NULL, output)); + assert_rnp_failure(rnp_decrypt(ffi, input, NULL)); assert_rnp_success(rnp_decrypt(ffi, input, output)); // cleanup rnp_input_destroy(input); @@ -368,6 +378,10 @@ TEST_F(rnp_tests, test_ffi_encrypt_set_cipher) /* create input + output */ rnp_input_t input = NULL; const char *plaintext = "Data encrypted with password using different CEK/KEK."; + assert_rnp_failure( + rnp_input_from_memory(NULL, (const uint8_t *) plaintext, strlen(plaintext), false)); + assert_rnp_failure(rnp_input_from_memory(&input, NULL, strlen(plaintext), false)); + assert_rnp_failure(rnp_input_from_memory(&input, (const uint8_t *) plaintext, 0, false)); assert_rnp_success( rnp_input_from_memory(&input, (const uint8_t *) plaintext, strlen(plaintext), false)); rnp_output_t output = NULL; @@ -393,6 +407,10 @@ TEST_F(rnp_tests, test_ffi_encrypt_set_cipher) rnp_ffi_set_pass_provider(ffi, ffi_string_password_provider, (void *) "password1")); rnp_op_verify_t verify; assert_rnp_success(rnp_op_verify_create(&verify, ffi, input, output)); + assert_rnp_failure(rnp_op_verify_set_flags(NULL, RNP_VERIFY_ALLOW_HIDDEN_RECIPIENT)); + assert_rnp_failure(rnp_op_verify_set_flags(verify, 0x77)); + assert_rnp_success(rnp_op_verify_set_flags(verify, RNP_VERIFY_ALLOW_HIDDEN_RECIPIENT)); + assert_rnp_success(rnp_op_verify_set_flags(verify, 0)); assert_rnp_success(rnp_op_verify_execute(verify)); rnp_input_destroy(input); rnp_output_destroy(output); @@ -1115,7 +1133,9 @@ TEST_F(rnp_tests, test_ffi_encrypt_and_sign) // add second signature with different hash/issued/expiration assert_rnp_success(rnp_locate_key(ffi, "userid", "key1-uid2", &key)); assert_rnp_success(rnp_op_encrypt_add_signature(op, key, &signsig)); + assert_rnp_failure(rnp_op_sign_signature_set_creation_time(NULL, issued2)); assert_rnp_success(rnp_op_sign_signature_set_creation_time(signsig, issued2)); + assert_rnp_failure(rnp_op_sign_signature_set_expiration_time(NULL, expires2)); assert_rnp_success(rnp_op_sign_signature_set_expiration_time(signsig, expires2)); assert_rnp_failure(rnp_op_sign_signature_set_hash(signsig, NULL)); assert_rnp_failure(rnp_op_sign_signature_set_hash(NULL, "SHA512")); @@ -1229,16 +1249,28 @@ TEST_F(rnp_tests, test_ffi_encrypt_and_sign) assert_rnp_success(rnp_op_verify_get_signature_count(verify, &sig_count)); assert_int_equal(sig_count, 2); + assert_rnp_failure(rnp_op_verify_get_signature_at(NULL, 0, &sig)); + assert_rnp_failure(rnp_op_verify_get_signature_at(verify, 0, NULL)); + assert_rnp_failure(rnp_op_verify_get_signature_at(verify, 10, &sig)); // signature 1 assert_rnp_success(rnp_op_verify_get_signature_at(verify, 0, &sig)); + assert_rnp_failure(rnp_op_verify_signature_get_status(NULL)); assert_rnp_success(rnp_op_verify_signature_get_status(sig)); assert_rnp_success(rnp_op_verify_signature_get_times(sig, &sig_create, &sig_expires)); assert_int_equal(sig_create, issued); assert_int_equal(sig_expires, expires); + assert_rnp_failure(rnp_op_verify_signature_get_hash(NULL, &hname)); + assert_rnp_failure(rnp_op_verify_signature_get_hash(sig, NULL)); assert_rnp_success(rnp_op_verify_signature_get_hash(sig, &hname)); assert_string_equal(hname, "SHA256"); rnp_buffer_destroy(hname); hname = NULL; + key = NULL; + assert_rnp_failure(rnp_op_verify_signature_get_key(NULL, &key)); + assert_rnp_failure(rnp_op_verify_signature_get_key(sig, NULL)); + assert_rnp_success(rnp_op_verify_signature_get_key(sig, &key)); + assert_non_null(key); + rnp_key_handle_destroy(key); // signature 2 assert_rnp_success(rnp_op_verify_get_signature_at(verify, 1, &sig)); assert_rnp_success(rnp_op_verify_signature_get_status(sig)); @@ -1298,6 +1330,7 @@ TEST_F(rnp_tests, test_ffi_encrypt_pk_subkey_selection) assert_rnp_success( rnp_input_from_memory(&input, (uint8_t *) plaintext, strlen(plaintext), false)); + assert_rnp_failure(rnp_output_to_memory(NULL, 0)); assert_rnp_success(rnp_output_to_memory(&output, 0)); /* create encrypt operation, add recipient and execute */ assert_rnp_success(rnp_op_encrypt_create(&op, ffi, input, output)); diff --git a/src/tests/ffi-key-sig.cpp b/src/tests/ffi-key-sig.cpp index a97d2fd125..83af5f5139 100644 --- a/src/tests/ffi-key-sig.cpp +++ b/src/tests/ffi-key-sig.cpp @@ -303,8 +303,6 @@ TEST_F(rnp_tests, test_ffi_import_signatures) assert_false(revoked); /* some import edge cases */ assert_rnp_failure(rnp_import_signatures(ffi, NULL, 0, &results)); - assert_rnp_failure(rnp_import_signatures(NULL, input, 0, &results)); - assert_rnp_failure(rnp_import_signatures(ffi, input, 0x18, &results)); /* import revocation signature */ json_object *jso = NULL; json_object *jsosigs = NULL; @@ -342,6 +340,8 @@ TEST_F(rnp_tests, test_ffi_import_signatures) assert_int_equal(till, 1578663151); /* check import with NULL results param */ assert_rnp_success(rnp_input_from_path(&input, "data/test_key_validity/alice-rev.pgp")); + assert_rnp_failure(rnp_import_signatures(NULL, input, 0, &results)); + assert_rnp_failure(rnp_import_signatures(ffi, input, 0x18, &results)); assert_rnp_success(rnp_import_signatures(ffi, input, 0, NULL)); assert_rnp_success(rnp_input_destroy(input)); /* import signature again, making sure it is not duplicated */ @@ -1355,6 +1355,7 @@ TEST_F(rnp_tests, test_ffi_remove_signatures) assert_rnp_failure(rnp_key_remove_signatures(NULL, RNP_KEY_SIGNATURE_INVALID, NULL, NULL)); assert_rnp_failure(rnp_key_remove_signatures(NULL, 0, NULL, NULL)); assert_rnp_failure(rnp_key_remove_signatures(key, 0, NULL, ffi)); + assert_rnp_failure(rnp_key_remove_signatures(key, 0x77, NULL, ffi)); /* remove unknown signatures */ assert_rnp_success( rnp_key_remove_signatures(key, RNP_KEY_SIGNATURE_UNKNOWN_KEY, NULL, NULL)); diff --git a/src/tests/ffi-key.cpp b/src/tests/ffi-key.cpp index fe4dfdcf64..d79be0dd59 100644 --- a/src/tests/ffi-key.cpp +++ b/src/tests/ffi-key.cpp @@ -113,8 +113,12 @@ TEST_F(rnp_tests, test_ffi_keygen_json_pair) json_object_put(parsed_results); // check the key counts + assert_rnp_failure(rnp_get_public_key_count(NULL, &count)); + assert_rnp_failure(rnp_get_public_key_count(ffi, NULL)); assert_rnp_success(rnp_get_public_key_count(ffi, &count)); assert_int_equal(2, count); + assert_rnp_failure(rnp_get_secret_key_count(NULL, &count)); + assert_rnp_failure(rnp_get_secret_key_count(ffi, NULL)); assert_rnp_success(rnp_get_secret_key_count(ffi, &count)); assert_int_equal(2, count); @@ -435,6 +439,7 @@ TEST_F(rnp_tests, test_ffi_key_generate_misc) { rnp_ffi_t ffi = NULL; assert_rnp_success(rnp_ffi_create(&ffi, "GPG", "GPG")); + assert_rnp_failure(rnp_ffi_set_key_provider(NULL, unused_getkeycb, NULL)); assert_rnp_success(rnp_ffi_set_key_provider(ffi, unused_getkeycb, NULL)); /* make sure we do not leak key handle and do not access NULL */ @@ -567,6 +572,10 @@ TEST_F(rnp_tests, test_ffi_key_generate_misc) assert_rnp_success(rnp_key_get_keyid(primary, &keyid)); rnp_op_generate_t subop = NULL; + assert_rnp_failure(rnp_op_generate_subkey_create(NULL, ffi, primary, "ECDSA")); + assert_rnp_failure(rnp_op_generate_subkey_create(&subop, NULL, primary, "ECDSA")); + assert_rnp_failure(rnp_op_generate_subkey_create(&subop, ffi, NULL, "ECDSA")); + assert_rnp_failure(rnp_op_generate_subkey_create(&subop, ffi, primary, NULL)); assert_rnp_success(rnp_op_generate_subkey_create(&subop, ffi, primary, "ECDSA")); assert_rnp_success(rnp_op_generate_set_curve(subop, "NIST P-256")); assert_rnp_success(rnp_op_generate_add_usage(subop, "sign")); @@ -580,6 +589,13 @@ TEST_F(rnp_tests, test_ffi_key_generate_misc) rnp_output_t output = NULL; rnp_output_to_memory(&output, 0); + assert_rnp_failure(rnp_key_export(NULL, output, RNP_KEY_EXPORT_PUBLIC)); + assert_rnp_failure(rnp_key_export(primary, NULL, RNP_KEY_EXPORT_PUBLIC)); + assert_rnp_failure(rnp_key_export(primary, output, 0)); + assert_rnp_failure( + rnp_key_export(primary, output, RNP_KEY_EXPORT_PUBLIC | RNP_KEY_EXPORT_SECRET)); + assert_rnp_failure(rnp_key_export(primary, output, 0x77)); + assert_rnp_success( rnp_key_export(primary, output, @@ -1187,6 +1203,7 @@ TEST_F(rnp_tests, test_ffi_key_generate_ex) /* Generate RSA key with misc options set */ rnp_op_generate_t keygen = NULL; assert_rnp_success(rnp_op_generate_create(&keygen, ffi, "RSA")); + assert_rnp_failure(rnp_op_generate_set_bits(NULL, 1024)); assert_rnp_success(rnp_op_generate_set_bits(keygen, 1024)); assert_rnp_failure(rnp_op_generate_set_dsa_qbits(keygen, 256)); /* key usage */ @@ -4116,6 +4133,7 @@ TEST_F(rnp_tests, test_ffi_key_export_autocrypt) /* remove first subkey and export again */ assert_rnp_success(rnp_locate_key(ffi, "keyid", "1ed63ee56fadc34d", &sub)); + assert_rnp_failure(rnp_key_remove(sub, 0x333)); assert_rnp_success(rnp_key_remove(sub, RNP_KEY_REMOVE_PUBLIC)); rnp_key_handle_destroy(sub); assert_rnp_success(rnp_output_to_memory(&output, 0)); @@ -4468,6 +4486,7 @@ TEST_F(rnp_tests, test_ffi_sha1_self_signatures) assert_rnp_success(rnp_unload_keys(ffi, RNP_KEY_UNLOAD_PUBLIC)); /* Check the key which has SHA1 self signature, made after the cut-off date */ + assert_rnp_failure(rnp_set_timestamp(NULL, SHA1_KEY_FROM + 10)); assert_rnp_success(rnp_set_timestamp(ffi, SHA1_KEY_FROM + 10)); assert_true(import_pub_keys(ffi, "data/test_forged_keys/eddsa-2024-pub.pgp")); assert_rnp_success(rnp_locate_key(ffi, "keyid", "980e3741f632212c", &key)); diff --git a/src/tests/ffi.cpp b/src/tests/ffi.cpp index ad7155cce3..d84cad8f5d 100644 --- a/src/tests/ffi.cpp +++ b/src/tests/ffi.cpp @@ -420,6 +420,7 @@ TEST_F(rnp_tests, test_ffi_save_keys) assert_rnp_failure(rnp_save_keys(ffi, "GPG", NULL, RNP_LOAD_SAVE_PUBLIC_KEYS)); assert_rnp_failure(rnp_save_keys(ffi, "WRONG", output, RNP_LOAD_SAVE_PUBLIC_KEYS)); assert_rnp_failure(rnp_save_keys(ffi, "GPG", output, 0)); + assert_rnp_failure(rnp_save_keys(ffi, "GPG", output, 0x77)); assert_rnp_success(rnp_save_keys(ffi, "GPG", output, RNP_LOAD_SAVE_PUBLIC_KEYS)); assert_rnp_success(rnp_output_destroy(output)); output = NULL; @@ -820,9 +821,12 @@ test_ffi_setup_signatures(rnp_ffi_t *ffi, rnp_op_sign_t *op) const uint32_t issued2 = 1516211900; // Unix epoch, nowish const uint32_t expires2 = 2000000000; // expires later + assert_rnp_failure(rnp_op_sign_set_armor(NULL, true)); assert_rnp_success(rnp_op_sign_set_armor(*op, true)); assert_rnp_success(rnp_op_sign_set_hash(*op, "SHA256")); + assert_rnp_failure(rnp_op_sign_set_creation_time(NULL, issued)); assert_rnp_success(rnp_op_sign_set_creation_time(*op, issued)); + assert_rnp_failure(rnp_op_sign_set_expiration_time(NULL, expires)); assert_rnp_success(rnp_op_sign_set_expiration_time(*op, expires)); // set pass provider @@ -895,10 +899,15 @@ TEST_F(rnp_tests, test_ffi_signatures_memory) // init input test_ffi_init_sign_memory_input(&input, &output); // create signature operation + assert_rnp_failure(rnp_op_sign_create(NULL, ffi, input, output)); + assert_rnp_failure(rnp_op_sign_create(&op, NULL, input, output)); + assert_rnp_failure(rnp_op_sign_create(&op, ffi, NULL, output)); + assert_rnp_failure(rnp_op_sign_create(&op, ffi, input, NULL)); assert_rnp_success(rnp_op_sign_create(&op, ffi, input, output)); // setup signature(s) test_ffi_setup_signatures(&ffi, &op); // execute the operation + assert_rnp_failure(rnp_op_sign_execute(NULL)); assert_rnp_success(rnp_op_sign_execute(op)); // make sure the output file was created assert_rnp_failure(rnp_output_memory_get_buf(NULL, &signed_buf, &signed_len, true)); @@ -1118,6 +1127,8 @@ TEST_F(rnp_tests, test_ffi_signatures_dump) assert_rnp_success(rnp_op_verify_get_signature_at(verify, 0, &sig)); assert_rnp_success(rnp_op_verify_signature_get_status(sig)); rnp_signature_handle_t sighandle = NULL; + assert_rnp_failure(rnp_op_verify_signature_get_handle(NULL, &sighandle)); + assert_rnp_failure(rnp_op_verify_signature_get_handle(sig, NULL)); assert_rnp_success(rnp_op_verify_signature_get_handle(sig, &sighandle)); assert_non_null(sighandle); /* check signature type */ @@ -1627,6 +1638,7 @@ TEST_F(rnp_tests, test_ffi_signatures_detached_memory_g10) assert_non_null(opsign); // add the signer + assert_rnp_failure(rnp_op_sign_add_signature(NULL, key, NULL)); assert_rnp_success(rnp_op_sign_add_signature(opsign, key, NULL)); // execute the signing operation assert_rnp_success(rnp_op_sign_execute(opsign)); @@ -2773,6 +2785,8 @@ TEST_F(rnp_tests, test_ffi_file_output) assert_true(sz != file_size(KEY_OUT_PATH)); sz = file_size(KEY_OUT_PATH); // test output to file - will fail without overwrite + assert_rnp_failure(rnp_output_to_file(NULL, KEY_OUT_PATH, RNP_OUTPUT_FILE_OVERWRITE)); + assert_rnp_failure(rnp_output_to_file(&output, NULL, RNP_OUTPUT_FILE_OVERWRITE)); assert_rnp_failure(rnp_output_to_file(&output, KEY_OUT_PATH, 0)); // fail with wrong flags assert_rnp_failure(rnp_output_to_file(&output, KEY_OUT_PATH, 0x100)); @@ -3407,9 +3421,11 @@ TEST_F(rnp_tests, test_ffi_literal_filename) // setup signature(s) test_ffi_setup_signatures(&ffi, &op); // setup filename and modification time + assert_rnp_failure(rnp_op_sign_set_file_name(NULL, "checkleak.dat")); assert_rnp_success(rnp_op_sign_set_file_name(op, "checkleak.dat")); assert_rnp_success(rnp_op_sign_set_file_name(op, NULL)); assert_rnp_success(rnp_op_sign_set_file_name(op, "testfile.dat")); + assert_rnp_failure(rnp_op_sign_set_file_mtime(NULL, 12345678)); assert_rnp_success(rnp_op_sign_set_file_mtime(op, 12345678)); // execute the operation assert_rnp_success(rnp_op_sign_execute(op)); @@ -3461,6 +3477,7 @@ TEST_F(rnp_tests, test_ffi_op_set_hash) test_ffi_setup_signatures(&ffi, &op); // make sure it doesn't fail on NULL hash value assert_rnp_failure(rnp_op_sign_set_hash(op, NULL)); + assert_rnp_failure(rnp_op_sign_set_hash(NULL, "SHA256")); assert_rnp_failure(rnp_op_sign_set_hash(op, "Unknown")); assert_rnp_success(rnp_op_sign_set_hash(op, "SHA256")); // execute the operation with wrong password @@ -5557,6 +5574,8 @@ TEST_F(rnp_tests, test_ffi_exception) throw std::bad_alloc(); return true; }; + assert_rnp_failure(rnp_input_from_callback(NULL, reader, NULL, NULL)); + assert_rnp_failure(rnp_input_from_callback(&input, NULL, NULL, NULL)); assert_rnp_success(rnp_input_from_callback(&input, reader, NULL, NULL)); assert_rnp_success(rnp_output_to_memory(&output, 0)); assert_int_equal(RNP_ERROR_OUT_OF_MEMORY, rnp_output_pipe(input, output)); @@ -6021,6 +6040,9 @@ TEST_F(rnp_tests, test_result_to_string) result_string = rnp_result_to_string(RNP_SUCCESS); assert_string_equal(result_string, "Success"); + result_string = rnp_result_to_string(1); + assert_string_equal(result_string, "Unsupported error code"); + /* Cover all defined error code ranges, * check that each defined * code has corresponding unique string */ diff --git a/src/tests/pipe.cpp b/src/tests/pipe.cpp index 6f680872b8..72bf5cdbf9 100644 --- a/src/tests/pipe.cpp +++ b/src/tests/pipe.cpp @@ -50,6 +50,12 @@ error_writer(void *app_ctx, const void *buf, size_t len) return false; } +static bool +ignoring_writer(void *app_ctx, const void *buf, size_t len) +{ + return true; +} + TEST_F(rnp_tests, test_pipe) { uint8_t * buf = NULL; @@ -103,3 +109,21 @@ TEST_F(rnp_tests, test_pipe_dest_error) assert_rnp_success(rnp_input_destroy(input)); assert_rnp_success(rnp_output_destroy(output)); } + +TEST_F(rnp_tests, test_output_write) +{ + rnp_output_t output = NULL; + const std::string msg("this is a test"); + + assert_rnp_failure(rnp_output_to_callback(NULL, ignoring_writer, NULL, NULL)); + assert_rnp_failure(rnp_output_to_callback(&output, NULL, NULL, NULL)); + assert_rnp_success(rnp_output_to_callback(&output, ignoring_writer, NULL, NULL)); + size_t written = 100; + assert_rnp_failure(rnp_output_write(NULL, msg.c_str(), msg.size(), &written)); + assert_rnp_failure(rnp_output_write(output, NULL, 10, &written)); + assert_rnp_success(rnp_output_write(output, NULL, 0, &written)); + assert_int_equal(written, 0); + assert_rnp_success(rnp_output_write(output, msg.c_str(), msg.size(), NULL)); + assert_rnp_failure(rnp_output_finish(NULL)); + assert_rnp_success(rnp_output_destroy(output)); +}