lib/libssh
1
0
Fork 0
mirror of https://git.libssh.org/projects/libssh.git synced 2025-07-29 13:01:13 +03:00
Code Activity

tests: replace assert_true

Browse Source 
Mechanical edit in vim:

%s/assert_true(rc == 0)/assert_return_code(rc, errno)/g
%s/assert_true(rc == SSH_OK)/assert_return_code(rc, errno)/g
%s/assert_true(rc == \(-*\d*\))/assert_int_equal(rc, \1)/g
%s/assert_true(rc == \(.*\))/assert_int_equal(rc, \1)/g
%s/assert_true(type == \(.*\))/assert_int_equal(type, \1)/g

Signed-off-by: Jakub Jelen <jjelen@redhat.com>
Reviewed-by: Sahana Prasad <sahana@redhat.com>
This commit is contained in:
Jakub Jelen
2023-09-22 23:26:18 +02:00
committed by Sahana Prasad
parent 2c026e4314
commit dd11d469dc
2 changed files with 126 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
tests/unittests/torture_pki_ecdsa.c
View File

@ -231,11 +231,11 @@ static void torture_pki_ecdsa_import_privkey_base64(void **state)
assert_non_null(key_str);
rc = ssh_pki_import_privkey_base64(key_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(key);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
free(key_str);
SSH_KEY_FREE(key);
@ -261,11 +261,11 @@ static void torture_pki_ecdsa_import_privkey_base64_comment(void **state)
assert_int_equal(rc, file_str_len - 1);
rc = ssh_pki_import_privkey_base64(file_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(key);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
free(key_str);
free(file_str);
@ -292,11 +292,11 @@ static void torture_pki_ecdsa_import_privkey_base64_whitespace(void **state)
assert_int_equal(rc, file_str_len - 1);
rc = ssh_pki_import_privkey_base64(file_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(key);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
free(key_str);
free(file_str);
@ -318,11 +318,11 @@ static void torture_pki_ecdsa_publickey_from_privatekey(void **state)
assert_non_null(key_str);
rc = ssh_pki_import_privkey_base64(key_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey);
free(key_str);
@ -338,14 +338,14 @@ static void torture_pki_ecdsa_import_cert_file(void **state)
struct pki_st *test_state = *((struct pki_st **)state);
rc = ssh_pki_import_cert_file(LIBSSH_ECDSA_TESTKEY "-cert.pub", &cert);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(cert);
type = ssh_key_type(cert);
assert_true(type == test_state->type+3);
assert_int_equal(type, test_state->type+3);
rc = ssh_key_is_public(cert);
assert_true(rc == 1);
assert_int_equal(rc, 1);
SSH_KEY_FREE(cert);
}
@ -369,7 +369,7 @@ static void torture_pki_ecdsa_publickey_base64(void **state)
}
type = ssh_key_type_from_name(q);
assert_true(type == test_state->type);
assert_int_equal(type, test_state->type);
q = ++p;
while (p != NULL && *p != '\0' && *p != ' ') p++;
@ -378,11 +378,11 @@ static void torture_pki_ecdsa_publickey_base64(void **state)
}
rc = ssh_pki_import_pubkey_base64(q, type, &key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(key);
rc = ssh_pki_export_pubkey_base64(key, &b64_key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(b64_key);
assert_string_equal(q, b64_key);
@ -406,7 +406,7 @@ static void torture_pki_ecdsa_generate_pubkey_from_privkey(void **state)
rc = torture_read_one_line(LIBSSH_ECDSA_TESTKEY ".pub",
pubkey_original,
sizeof(pubkey_original));
assert_true(rc == 0);
assert_int_equal(rc, 0);
/* remove the public key, generate it from the private key and write it. */
unlink(LIBSSH_ECDSA_TESTKEY ".pub");
@ -416,20 +416,20 @@ static void torture_pki_ecdsa_generate_pubkey_from_privkey(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(privkey);
rc = ssh_pki_export_privkey_to_pubkey(privkey, &pubkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey);
rc = ssh_pki_export_pubkey_file(pubkey, LIBSSH_ECDSA_TESTKEY ".pub");
assert_true(rc == 0);
assert_int_equal(rc, 0);
rc = torture_read_one_line(LIBSSH_ECDSA_TESTKEY ".pub",
pubkey_generated,
sizeof(pubkey_generated));
assert_true(rc == 0);
assert_int_equal(rc, 0);
len = torture_pubkey_len(pubkey_original);
assert_int_equal(len, torture_pubkey_len(pubkey_generated));
assert_memory_equal(pubkey_original, pubkey_generated, len);
@ -451,11 +451,11 @@ static void torture_pki_ecdsa_duplicate_key(void **state)
(void) state;
rc = ssh_pki_import_pubkey_file(LIBSSH_ECDSA_TESTKEY ".pub", &pubkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(pubkey);
rc = ssh_pki_export_pubkey_base64(pubkey, &b64_key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(b64_key);
rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY,
@ -463,27 +463,27 @@ static void torture_pki_ecdsa_duplicate_key(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(privkey);
privkey_dup = ssh_key_dup(privkey);
assert_non_null(privkey_dup);
rc = ssh_pki_export_privkey_to_pubkey(privkey, &pubkey_dup);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey_dup);
rc = ssh_pki_export_pubkey_base64(pubkey_dup, &b64_key_gen);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(b64_key_gen);
assert_string_equal(b64_key, b64_key_gen);
rc = ssh_key_cmp(privkey, privkey_dup, SSH_KEY_CMP_PRIVATE);
assert_true(rc == 0);
assert_int_equal(rc, 0);
rc = ssh_key_cmp(pubkey, pubkey_dup, SSH_KEY_CMP_PUBLIC);
assert_true(rc == 0);
assert_int_equal(rc, 0);
SSH_KEY_FREE(pubkey);
SSH_KEY_FREE(pubkey_dup);
@ -540,7 +540,7 @@ static void torture_pki_generate_key_ecdsa(void **state)
(void) state;
rc = ssh_pki_generate(SSH_KEYTYPE_ECDSA_P256, 0, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -548,9 +548,9 @@ static void torture_pki_generate_key_ecdsa(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA256);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_ECDSA_P256);
assert_int_equal(type, SSH_KEYTYPE_ECDSA_P256);
type_char = ssh_key_type_to_char(type);
assert_string_equal(type_char, "ecdsa-sha2-nistp256");
etype_char = ssh_pki_key_ecdsa_name(key);
@ -562,7 +562,7 @@ static void torture_pki_generate_key_ecdsa(void **state)
/* deprecated */
rc = ssh_pki_generate(SSH_KEYTYPE_ECDSA, 256, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -570,9 +570,9 @@ static void torture_pki_generate_key_ecdsa(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA256);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_ECDSA_P256);
assert_int_equal(type, SSH_KEYTYPE_ECDSA_P256);
type_char = ssh_key_type_to_char(type);
assert_string_equal(type_char, "ecdsa-sha2-nistp256");
etype_char = ssh_pki_key_ecdsa_name(key);
@ -583,7 +583,7 @@ static void torture_pki_generate_key_ecdsa(void **state)
SSH_KEY_FREE(pubkey);
rc = ssh_pki_generate(SSH_KEYTYPE_ECDSA_P384, 0, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -591,9 +591,9 @@ static void torture_pki_generate_key_ecdsa(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA384);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_ECDSA_P384);
assert_int_equal(type, SSH_KEYTYPE_ECDSA_P384);
type_char = ssh_key_type_to_char(type);
assert_string_equal(type_char, "ecdsa-sha2-nistp384");
etype_char = ssh_pki_key_ecdsa_name(key);
@ -605,7 +605,7 @@ static void torture_pki_generate_key_ecdsa(void **state)
/* deprecated */
rc = ssh_pki_generate(SSH_KEYTYPE_ECDSA, 384, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -613,9 +613,9 @@ static void torture_pki_generate_key_ecdsa(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA384);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_ECDSA_P384);
assert_int_equal(type, SSH_KEYTYPE_ECDSA_P384);
type_char = ssh_key_type_to_char(type);
assert_string_equal(type_char, "ecdsa-sha2-nistp384");
etype_char = ssh_pki_key_ecdsa_name(key);
@ -626,7 +626,7 @@ static void torture_pki_generate_key_ecdsa(void **state)
SSH_KEY_FREE(pubkey);
rc = ssh_pki_generate(SSH_KEYTYPE_ECDSA_P521, 0, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -634,9 +634,9 @@ static void torture_pki_generate_key_ecdsa(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA512);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_ECDSA_P521);
assert_int_equal(type, SSH_KEYTYPE_ECDSA_P521);
type_char = ssh_key_type_to_char(type);
assert_string_equal(type_char, "ecdsa-sha2-nistp521");
etype_char =ssh_pki_key_ecdsa_name(key);
@ -648,7 +648,7 @@ static void torture_pki_generate_key_ecdsa(void **state)
/* deprecated */
rc = ssh_pki_generate(SSH_KEYTYPE_ECDSA, 521, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -656,9 +656,9 @@ static void torture_pki_generate_key_ecdsa(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA512);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_ECDSA_P521);
assert_int_equal(type, SSH_KEYTYPE_ECDSA_P521);
type_char = ssh_key_type_to_char(type);
assert_string_equal(type_char, "ecdsa-sha2-nistp521");
etype_char = ssh_pki_key_ecdsa_name(key);
@ -685,11 +685,11 @@ static void torture_pki_ecdsa_cert_verify(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(privkey);
rc = ssh_pki_import_cert_file(LIBSSH_ECDSA_TESTKEY "-cert.pub", &cert);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(cert);
/* Get the hash type to be used in the signature based on the key type */
@ -698,7 +698,7 @@ static void torture_pki_ecdsa_cert_verify(void **state)
sign = pki_do_sign(privkey, INPUT, sizeof(INPUT), hash_type);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, cert, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
ssh_signature_free(sign);
SSH_KEY_FREE(privkey);
SSH_KEY_FREE(cert);
@ -837,7 +837,7 @@ static void torture_pki_ecdsa_write_privkey(void **state)
NULL,
NULL,
&origkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(origkey);
unlink(LIBSSH_ECDSA_TESTKEY);
@ -847,18 +847,18 @@ static void torture_pki_ecdsa_write_privkey(void **state)
NULL,
NULL,
LIBSSH_ECDSA_TESTKEY);
assert_true(rc == 0);
assert_int_equal(rc, 0);
rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY,
NULL,
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(privkey);
rc = ssh_key_cmp(origkey, privkey, SSH_KEY_CMP_PRIVATE);
assert_true(rc == 0);
assert_int_equal(rc, 0);
SSH_KEY_FREE(origkey);
SSH_KEY_FREE(privkey);
@ -869,7 +869,7 @@ static void torture_pki_ecdsa_write_privkey(void **state)
NULL,
NULL,
&origkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(origkey);
unlink(LIBSSH_ECDSA_TESTKEY_PASSPHRASE);
@ -878,7 +878,7 @@ static void torture_pki_ecdsa_write_privkey(void **state)
NULL,
NULL,
LIBSSH_ECDSA_TESTKEY_PASSPHRASE);
assert_true(rc == 0);
assert_int_equal(rc, 0);
/* Test with invalid passphrase */
rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY_PASSPHRASE,
@ -886,7 +886,7 @@ static void torture_pki_ecdsa_write_privkey(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
assert_null(privkey);
rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY_PASSPHRASE,
@ -894,11 +894,11 @@ static void torture_pki_ecdsa_write_privkey(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(privkey);
rc = ssh_key_cmp(origkey, privkey, SSH_KEY_CMP_PRIVATE);
assert_true(rc == 0);
assert_int_equal(rc, 0);
SSH_KEY_FREE(origkey);
SSH_KEY_FREE(privkey);
@ -914,10 +914,10 @@ static void torture_pki_ecdsa_name(void **state, const char *expected_name)
(void) state; /* unused */
rc = ssh_pki_import_privkey_file(LIBSSH_ECDSA_TESTKEY, NULL, NULL, NULL, &key);
assert_true(rc == 0);
assert_int_equal(rc, 0);
assert_non_null(key);
etype_char =ssh_pki_key_ecdsa_name(key);
etype_char = ssh_pki_key_ecdsa_name(key);
assert_string_equal(etype_char, expected_name);
SSH_KEY_FREE(key);

136
tests/unittests/torture_pki_rsa.c
View File

@ -164,7 +164,7 @@ static void torture_pki_rsa_import_privkey_base64_NULL_key(void **state)
NULL,
NULL,
NULL);
assert_true(rc == -1);
assert_int_equal(rc, -1);
}
@ -178,7 +178,7 @@ static void torture_pki_rsa_import_privkey_base64_NULL_str(void **state)
/* test if it returns -1 if key_str is NULL */
rc = ssh_pki_import_privkey_base64(NULL, passphrase, NULL, NULL, &key);
assert_true(rc == -1);
assert_int_equal(rc, -1);
SSH_KEY_FREE(key);
}
@ -197,17 +197,17 @@ static void torture_pki_rsa_import_privkey_base64(void **state)
assert_non_null(key_str);
rc = ssh_pki_import_privkey_base64(key_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(key);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_RSA);
assert_int_equal(type, SSH_KEYTYPE_RSA);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
rc = ssh_key_is_public(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
free(key_str);
SSH_KEY_FREE(key);
@ -234,17 +234,17 @@ static void torture_pki_rsa_import_privkey_base64_comment(void **state)
assert_int_equal(rc, file_str_len - 1);
rc = ssh_pki_import_privkey_base64(file_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(key);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_RSA);
assert_int_equal(type, SSH_KEYTYPE_RSA);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
rc = ssh_key_is_public(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
free(key_str);
free(file_str);
@ -272,17 +272,17 @@ static void torture_pki_rsa_import_privkey_base64_whitespace(void **state)
assert_int_equal(rc, file_str_len - 1);
rc = ssh_pki_import_privkey_base64(file_str, passphrase, NULL, NULL, &key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(key);
type = ssh_key_type(key);
assert_true(type == SSH_KEYTYPE_RSA);
assert_int_equal(type, SSH_KEYTYPE_RSA);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
rc = ssh_key_is_public(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
free(key_str);
free(file_str);
@ -303,14 +303,14 @@ static void torture_pki_rsa_publickey_from_privatekey(void **state)
NULL,
NULL,
&key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey);
SSH_KEY_FREE(key);
@ -333,11 +333,11 @@ static void torture_pki_rsa_copy_cert_to_privkey(void **state)
(void) state; /* unused */
rc = ssh_pki_import_cert_file(LIBSSH_RSA_TESTKEY "-cert.pub", &cert);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(cert);
rc = ssh_pki_import_pubkey_file(LIBSSH_RSA_TESTKEY ".pub", &pubkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey);
rc = ssh_pki_import_privkey_base64(torture_get_testkey(SSH_KEYTYPE_RSA, 0),
@ -345,32 +345,32 @@ static void torture_pki_rsa_copy_cert_to_privkey(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(privkey);
/* Basic sanity. */
rc = ssh_pki_copy_cert_to_privkey(NULL, privkey);
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
rc = ssh_pki_copy_cert_to_privkey(pubkey, NULL);
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
/* A public key doesn't have a cert, copy should fail. */
assert_null(pubkey->cert);
rc = ssh_pki_copy_cert_to_privkey(pubkey, privkey);
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
/* Copying the cert to non-cert keys should work fine. */
rc = ssh_pki_copy_cert_to_privkey(cert, pubkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey->cert);
rc = ssh_pki_copy_cert_to_privkey(cert, privkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(privkey->cert);
/* The private key's cert is already set, another copy should fail. */
rc = ssh_pki_copy_cert_to_privkey(cert, privkey);
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
SSH_KEY_FREE(cert);
SSH_KEY_FREE(privkey);
@ -385,14 +385,14 @@ static void torture_pki_rsa_import_cert_file(void **state) {
(void) state; /* unused */
rc = ssh_pki_import_cert_file(LIBSSH_RSA_TESTKEY "-cert.pub", &cert);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(cert);
type = ssh_key_type(cert);
assert_true(type == SSH_KEYTYPE_RSA_CERT01);
assert_int_equal(type, SSH_KEYTYPE_RSA_CERT01);
rc = ssh_key_is_public(cert);
assert_true(rc == 1);
assert_int_equal(rc, 1);
SSH_KEY_FREE(cert);
}
@ -417,7 +417,7 @@ static void torture_pki_rsa_publickey_base64(void **state)
}
type = ssh_key_type_from_name(q);
assert_true(type == SSH_KEYTYPE_RSA);
assert_int_equal(type, SSH_KEYTYPE_RSA);
q = ++p;
while (p != NULL && *p != '\0' && *p != ' ') p++;
@ -426,11 +426,11 @@ static void torture_pki_rsa_publickey_base64(void **state)
}
rc = ssh_pki_import_pubkey_base64(q, type, &key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_pubkey_base64(key, &b64_key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(b64_key);
assert_string_equal(q, b64_key);
@ -457,20 +457,20 @@ static void torture_pki_rsa_generate_pubkey_from_privkey(void **state) {
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(privkey);
rc = ssh_pki_export_privkey_to_pubkey(privkey, &pubkey);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey);
rc = ssh_pki_export_pubkey_file(pubkey, LIBSSH_RSA_TESTKEY ".pub");
assert_true(rc == 0);
assert_return_code(rc, errno);
rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub",
pubkey_generated,
sizeof(pubkey_generated));
assert_true(rc == 0);
assert_return_code(rc, errno);
len = torture_pubkey_len(torture_get_testkey_pub(SSH_KEYTYPE_RSA));
assert_memory_equal(torture_get_testkey_pub(SSH_KEYTYPE_RSA),
@ -494,11 +494,11 @@ static void torture_pki_rsa_duplicate_key(void **state)
(void) state;
rc = ssh_pki_import_pubkey_file(LIBSSH_RSA_TESTKEY ".pub", &pubkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(pubkey);
rc = ssh_pki_export_pubkey_base64(pubkey, &b64_key);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(b64_key);
rc = ssh_pki_import_privkey_file(LIBSSH_RSA_TESTKEY,
@ -506,27 +506,27 @@ static void torture_pki_rsa_duplicate_key(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(privkey);
privkey_dup = ssh_key_dup(privkey);
assert_non_null(privkey_dup);
rc = ssh_pki_export_privkey_to_pubkey(privkey, &pubkey_dup);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(pubkey_dup);
rc = ssh_pki_export_pubkey_base64(pubkey_dup, &b64_key_gen);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(b64_key_gen);
assert_string_equal(b64_key, b64_key_gen);
rc = ssh_key_cmp(privkey, privkey_dup, SSH_KEY_CMP_PRIVATE);
assert_true(rc == 0);
assert_return_code(rc, errno);
rc = ssh_key_cmp(pubkey, pubkey_dup, SSH_KEY_CMP_PUBLIC);
assert_true(rc == 0);
assert_return_code(rc, errno);
SSH_KEY_FREE(pubkey);
SSH_KEY_FREE(pubkey_dup);
@ -550,7 +550,7 @@ static void torture_pki_rsa_generate_key(void **state)
if (!ssh_fips_mode()) {
rc = ssh_pki_generate(SSH_KEYTYPE_RSA, 1024, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -558,7 +558,7 @@ static void torture_pki_rsa_generate_key(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA256);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
ssh_signature_free(sign);
SSH_KEY_FREE(key);
SSH_KEY_FREE(pubkey);
@ -567,7 +567,7 @@ static void torture_pki_rsa_generate_key(void **state)
}
rc = ssh_pki_generate(SSH_KEYTYPE_RSA, 2048, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -575,7 +575,7 @@ static void torture_pki_rsa_generate_key(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA256);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
ssh_signature_free(sign);
SSH_KEY_FREE(key);
SSH_KEY_FREE(pubkey);
@ -583,7 +583,7 @@ static void torture_pki_rsa_generate_key(void **state)
pubkey = NULL;
rc = ssh_pki_generate(SSH_KEYTYPE_RSA, 4096, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -591,7 +591,7 @@ static void torture_pki_rsa_generate_key(void **state)
sign = pki_do_sign(key, INPUT, sizeof(INPUT), SSH_DIGEST_SHA256);
assert_non_null(sign);
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
ssh_signature_free(sign);
SSH_KEY_FREE(key);
SSH_KEY_FREE(pubkey);
@ -613,11 +613,11 @@ static void torture_pki_rsa_sha2(void **state)
/* Setup */
rc = ssh_pki_import_privkey_file(LIBSSH_RSA_TESTKEY, NULL, NULL, NULL, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_import_cert_file(LIBSSH_RSA_TESTKEY "-cert.pub", &cert);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(cert);
/* Get the public key to verify signature */
@ -680,7 +680,7 @@ static void torture_pki_rsa_key_size(void **state)
(void) state;
rc = ssh_pki_generate(SSH_KEYTYPE_RSA, 2048, &key);
assert_true(rc == SSH_OK);
assert_return_code(rc, errno);
assert_non_null(key);
rc = ssh_pki_export_privkey_to_pubkey(key, &pubkey);
assert_int_equal(rc, SSH_OK);
@ -696,7 +696,7 @@ static void torture_pki_rsa_key_size(void **state)
/* the verification should fail now */
rc = ssh_pki_signature_verify(session, sign, pubkey, INPUT, sizeof(INPUT));
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
ssh_signature_free(sign);
SSH_KEY_FREE(key);
@ -821,7 +821,7 @@ static void torture_pki_rsa_write_privkey(void **state)
NULL,
NULL,
&origkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(origkey);
unlink(LIBSSH_RSA_TESTKEY);
@ -831,18 +831,18 @@ static void torture_pki_rsa_write_privkey(void **state)
NULL,
NULL,
LIBSSH_RSA_TESTKEY);
assert_true(rc == 0);
assert_return_code(rc, errno);
rc = ssh_pki_import_privkey_file(LIBSSH_RSA_TESTKEY,
NULL,
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(privkey);
rc = ssh_key_cmp(origkey, privkey, SSH_KEY_CMP_PRIVATE);
assert_true(rc == 0);
assert_return_code(rc, errno);
SSH_KEY_FREE(origkey);
SSH_KEY_FREE(privkey);
@ -853,7 +853,7 @@ static void torture_pki_rsa_write_privkey(void **state)
NULL,
NULL,
&origkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(origkey);
unlink(LIBSSH_RSA_TESTKEY_PASSPHRASE);
@ -862,7 +862,7 @@ static void torture_pki_rsa_write_privkey(void **state)
NULL,
NULL,
LIBSSH_RSA_TESTKEY_PASSPHRASE);
assert_true(rc == 0);
assert_return_code(rc, errno);
/* Test with invalid passphrase */
rc = ssh_pki_import_privkey_file(LIBSSH_RSA_TESTKEY_PASSPHRASE,
@ -870,7 +870,7 @@ static void torture_pki_rsa_write_privkey(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == SSH_ERROR);
assert_int_equal(rc, SSH_ERROR);
assert_null(privkey);
rc = ssh_pki_import_privkey_file(LIBSSH_RSA_TESTKEY_PASSPHRASE,
@ -878,11 +878,11 @@ static void torture_pki_rsa_write_privkey(void **state)
NULL,
NULL,
&privkey);
assert_true(rc == 0);
assert_return_code(rc, errno);
assert_non_null(privkey);
rc = ssh_key_cmp(origkey, privkey, SSH_KEY_CMP_PRIVATE);
assert_true(rc == 0);
assert_return_code(rc, errno);
SSH_KEY_FREE(origkey);
SSH_KEY_FREE(privkey);
@ -907,7 +907,7 @@ static void torture_pki_rsa_import_privkey_base64_passphrase(void **state)
assert_non_null(key);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
SSH_KEY_FREE(key);
@ -917,7 +917,7 @@ static void torture_pki_rsa_import_privkey_base64_passphrase(void **state)
NULL,
NULL,
&key);
assert_true(rc == -1);
assert_int_equal(rc, -1);
SSH_KEY_FREE(key);
#ifndef HAVE_LIBCRYPTO
@ -928,7 +928,7 @@ static void torture_pki_rsa_import_privkey_base64_passphrase(void **state)
NULL,
NULL,
&key);
assert_true(rc == -1);
assert_int_equal(rc, -1);
SSH_KEY_FREE(key);
#endif
}
@ -955,7 +955,7 @@ torture_pki_rsa_import_openssh_privkey_base64_passphrase(void **state)
assert_non_null(key);
rc = ssh_key_is_private(key);
assert_true(rc == 1);
assert_int_equal(rc, 1);
SSH_KEY_FREE(key);
@ -965,7 +965,7 @@ torture_pki_rsa_import_openssh_privkey_base64_passphrase(void **state)
NULL,
NULL,
&key);
assert_true(rc == -1);
assert_int_equal(rc, -1);
SSH_KEY_FREE(key);
/* test if it returns -1 if passphrase is NULL */
@ -975,7 +975,7 @@ torture_pki_rsa_import_openssh_privkey_base64_passphrase(void **state)
NULL,
NULL,
&key);
assert_true(rc == -1);
assert_int_equal(rc, -1);
SSH_KEY_FREE(key);
}