Skip to content

Commit

Permalink
Update tests with not yet covered edge cases.
Browse files Browse the repository at this point in the history
  • Loading branch information
@ni4
ni4 committed May 1, 2024
1 parent 775ff07 commit d046e21
Show file tree
Hide file tree
Showing 5 changed files with 101 additions and 2 deletions.
33 changes: 33 additions & 0 deletions src/tests/ffi-enc.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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"));
Expand Down Expand Up @@ -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
Expand All @@ -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
Expand Down Expand Up @@ -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);
Expand Down Expand Up @@ -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;
Expand All @@ -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);
Expand Down Expand Up @@ -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"));
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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));
Expand Down
5 changes: 3 additions & 2 deletions src/tests/ffi-key-sig.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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 */
Expand Down Expand Up @@ -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));
Expand Down
19 changes: 19 additions & 0 deletions src/tests/ffi-key.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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);

Expand Down Expand Up @@ -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 */
Expand Down Expand Up @@ -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"));
Expand All @@ -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,
Expand Down Expand Up @@ -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 */
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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));
Expand Down
22 changes: 22 additions & 0 deletions src/tests/ffi.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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 */
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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
Expand Down Expand Up @@ -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));
Expand Down Expand Up @@ -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 */
Expand Down
24 changes: 24 additions & 0 deletions src/tests/pipe.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down Expand Up @@ -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));
}

0 comments on commit d046e21

Please sign in to comment.