lib/libssh
1
0
Fork 0
mirror of https://git.libssh.org/projects/libssh.git synced 2025-04-24 23:07:01 +03:00
Code

tests: Migrated torture_keyfiles to cmockery.

Browse Source
This commit is contained in:
Andreas Schneider 2010-12-28 14:37:45 +01:00
parent fa17f33d2b
commit 2bc03d22a1
2 changed files with 118 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/unittests/CMakeLists.txt
View File

@ -3,7 +3,7 @@ project(unittests C)
add_cmockery_test(torture_buffer torture_buffer.c ${TORTURE_LIBRARY}) add_cmockery_test(torture_buffer torture_buffer.c ${TORTURE_LIBRARY})
add_cmockery_test(torture_callbacks torture_callbacks.c ${TORTURE_LIBRARY}) add_cmockery_test(torture_callbacks torture_callbacks.c ${TORTURE_LIBRARY})
add_cmockery_test(torture_init torture_init.c ${TORTURE_LIBRARY}) add_cmockery_test(torture_init torture_init.c ${TORTURE_LIBRARY})
#add_check_test(torture_keyfiles torture_keyfiles.c ${TORTURE_LIBRARY}) add_cmockery_test(torture_keyfiles torture_keyfiles.c ${TORTURE_LIBRARY})
#add_check_test(torture_knownhosts torture_knownhosts.c ${TORTURE_LIBRARY}) #add_check_test(torture_knownhosts torture_knownhosts.c ${TORTURE_LIBRARY})
#add_check_test(torture_list torture_list.c ${TORTURE_LIBRARY}) #add_check_test(torture_list torture_list.c ${TORTURE_LIBRARY})
#add_check_test(torture_misc torture_misc.c ${TORTURE_LIBRARY}) #add_check_test(torture_misc torture_misc.c ${TORTURE_LIBRARY})

225
tests/unittests/torture_keyfiles.c
View File

@ -6,15 +6,9 @@
#define LIBSSH_RSA_TESTKEY "libssh_testkey.id_rsa" #define LIBSSH_RSA_TESTKEY "libssh_testkey.id_rsa"
#define LIBSSH_DSA_TESTKEY "libssh_testkey.id_dsa" #define LIBSSH_DSA_TESTKEY "libssh_testkey.id_dsa"
#define LIBSSH_PASSPHRASE "libssh-rocks" #define LIBSSH_PASSPHRASE "libssh-rocks"
ssh_session session;
#if 0 static void setup_rsa_key(void **state) {
static void setup(void) { ssh_session session;
session = ssh_new();
}
#endif
static void setup_rsa_key(void) {
int rc; int rc;
unlink(LIBSSH_RSA_TESTKEY); unlink(LIBSSH_RSA_TESTKEY);
@ -23,46 +17,55 @@ static void setup_rsa_key(void) {
rc = system("ssh-keygen -t rsa -q -N \"\" -f " LIBSSH_RSA_TESTKEY); rc = system("ssh-keygen -t rsa -q -N \"\" -f " LIBSSH_RSA_TESTKEY);
session = ssh_new(); session = ssh_new();
*state = session;
} }
static void setup_dsa_key(void) { static void setup_dsa_key(void **state) {
ssh_session session;
int rc;
unlink(LIBSSH_DSA_TESTKEY); unlink(LIBSSH_DSA_TESTKEY);
unlink(LIBSSH_DSA_TESTKEY ".pub"); unlink(LIBSSH_DSA_TESTKEY ".pub");
system("ssh-keygen -t dsa -q -N \"\" -f " LIBSSH_DSA_TESTKEY); rc = system("ssh-keygen -t dsa -q -N \"\" -f " LIBSSH_DSA_TESTKEY);
session = ssh_new(); session = ssh_new();
*state = session;
} }
static void setup_both_keys(void) { static void setup_both_keys(void **state) {
setup_rsa_key(); setup_rsa_key(state);
ssh_free(session); ssh_free(*state);
setup_dsa_key(); setup_dsa_key(state);
} }
static void setup_both_keys_passphrase(void) { static void setup_both_keys_passphrase(void **state) {
system("ssh-keygen -t rsa -N " LIBSSH_PASSPHRASE " -f " LIBSSH_RSA_TESTKEY); ssh_session session;
system("ssh-keygen -t dsa -N " LIBSSH_PASSPHRASE " -f " LIBSSH_DSA_TESTKEY);
session = ssh_new(); system("ssh-keygen -t rsa -N " LIBSSH_PASSPHRASE " -f " LIBSSH_RSA_TESTKEY);
system("ssh-keygen -t dsa -N " LIBSSH_PASSPHRASE " -f " LIBSSH_DSA_TESTKEY);
session = ssh_new();
*state = session;
} }
static void teardown(void) { static void teardown(void **state) {
unlink(LIBSSH_DSA_TESTKEY); unlink(LIBSSH_DSA_TESTKEY);
unlink(LIBSSH_DSA_TESTKEY ".pub"); unlink(LIBSSH_DSA_TESTKEY ".pub");
unlink(LIBSSH_RSA_TESTKEY); unlink(LIBSSH_RSA_TESTKEY);
unlink(LIBSSH_RSA_TESTKEY ".pub"); unlink(LIBSSH_RSA_TESTKEY ".pub");
ssh_free(session); ssh_free(*state);
} }
START_TEST (torture_pubkey_from_file) static void torture_pubkey_from_file(void **state) {
{ ssh_session session = *state;
ssh_string pubkey; ssh_string pubkey;
int type, rc; int type, rc;
rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type); rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type);
ck_assert_msg(rc == 0,ssh_get_error(session)); assert_true(rc == 0);
ssh_string_free(pubkey); ssh_string_free(pubkey);
@ -70,15 +73,14 @@ START_TEST (torture_pubkey_from_file)
unlink(LIBSSH_RSA_TESTKEY ".pub"); unlink(LIBSSH_RSA_TESTKEY ".pub");
rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type); rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type);
ck_assert_msg(rc == 1,ssh_get_error(session)); assert_true(rc == 1);
/* test if it returns -1 if privkey doesn't exist */ /* test if it returns -1 if privkey doesn't exist */
unlink(LIBSSH_RSA_TESTKEY); unlink(LIBSSH_RSA_TESTKEY);
rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type); rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey, &type);
ck_assert_msg(rc == -1,ssh_get_error(session)); assert_true(rc == -1);
} }
END_TEST
static int torture_read_one_line(const char *filename, char *buffer, size_t len) { static int torture_read_one_line(const char *filename, char *buffer, size_t len) {
FILE *fp; FILE *fp;
@ -100,8 +102,8 @@ static int torture_read_one_line(const char *filename, char *buffer, size_t len)
return 0; return 0;
} }
START_TEST (torture_pubkey_generate_from_privkey) static void torture_pubkey_generate_from_privkey(void **state) {
{ ssh_session session = *state;
ssh_private_key privkey = NULL; ssh_private_key privkey = NULL;
ssh_public_key pubkey = NULL; ssh_public_key pubkey = NULL;
ssh_string pubkey_orig = NULL; ssh_string pubkey_orig = NULL;
@ -115,126 +117,133 @@ START_TEST (torture_pubkey_generate_from_privkey)
/* read the publickey */ /* read the publickey */
rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey_orig, rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey_orig,
&type_orig); &type_orig);
ck_assert_msg(rc == 0,ssh_get_error(session)); assert_true(rc == 0);
ck_assert(pubkey_orig != NULL); assert_true(pubkey_orig != NULL);
rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_orig, rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_orig,
sizeof(pubkey_line_orig)); sizeof(pubkey_line_orig));
ck_assert(rc == 0); assert_true(rc == 0);
/* remove the public key, generate it from the private key and write it. */ /* remove the public key, generate it from the private key and write it. */
unlink(LIBSSH_RSA_TESTKEY ".pub"); unlink(LIBSSH_RSA_TESTKEY ".pub");
privkey = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL); privkey = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL);
ck_assert_msg(privkey != NULL,ssh_get_error(session)); assert_true(privkey != NULL);
pubkey = publickey_from_privatekey(privkey); pubkey = publickey_from_privatekey(privkey);
type_new = privkey->type; type_new = privkey->type;
privatekey_free(privkey); privatekey_free(privkey);
ck_assert_msg(pubkey != NULL,ssh_get_error(session)); assert_true(pubkey != NULL);
pubkey_new = publickey_to_string(pubkey); pubkey_new = publickey_to_string(pubkey);
publickey_free(pubkey); publickey_free(pubkey);
ck_assert_msg(pubkey_new != NULL,ssh_get_error(session)); assert_true(pubkey_new != NULL);
ck_assert(ssh_string_len(pubkey_orig) == ssh_string_len(pubkey_new)); assert_true(ssh_string_len(pubkey_orig) == ssh_string_len(pubkey_new));
ck_assert(memcmp(ssh_string_data(pubkey_orig), ssh_string_data(pubkey_new), assert_memory_equal(ssh_string_data(pubkey_orig),
ssh_string_len(pubkey_orig)) == 0); ssh_string_data(pubkey_new),
ssh_string_len(pubkey_orig));
rc = ssh_publickey_to_file(session, LIBSSH_RSA_TESTKEY ".pub", pubkey_new, type_new); rc = ssh_publickey_to_file(session, LIBSSH_RSA_TESTKEY ".pub", pubkey_new, type_new);
ck_assert_msg(rc == 0,ssh_get_error(session)); assert_true(rc == 0);
rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_new, rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_new,
sizeof(pubkey_line_new)); sizeof(pubkey_line_new));
ck_assert_str_eq(pubkey_line_orig, pubkey_line_new); assert_string_equal(pubkey_line_orig, pubkey_line_new);
ssh_string_free(pubkey_orig); ssh_string_free(pubkey_orig);
ssh_string_free(pubkey_new); ssh_string_free(pubkey_new);
} }
END_TEST
/** /**
* @brief tests the privatekey_from_file function without passphrase * @brief tests the privatekey_from_file function without passphrase
*/ */
START_TEST(torture_privatekey_from_file){ static void torture_privatekey_from_file(void **state) {
ssh_private_key key=NULL; ssh_session session = *state;
key=privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, NULL); ssh_private_key key = NULL;
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
key=privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, NULL);
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
/* test the automatic type discovery */
key=privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL);
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
key=privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, NULL);
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, NULL);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, NULL);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
/* Test the automatic type discovery */
key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, NULL);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
} }
END_TEST
/** /**
* @brief tests the privatekey_from_file function with passphrase * @brief tests the privatekey_from_file function with passphrase
*/ */
START_TEST(torture_privatekey_from_file_passphrase){ static void torture_privatekey_from_file_passphrase(void **state) {
ssh_private_key key=NULL; ssh_session session = *state;
key=privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, LIBSSH_PASSPHRASE); ssh_private_key key = NULL;
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
key=privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, LIBSSH_PASSPHRASE);
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
/* test the automatic type discovery */
key=privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
key=privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
ck_assert_msg(key != NULL,ssh_get_error(session));
if(key != NULL){
privatekey_free(key);
key=NULL;
}
} key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, LIBSSH_PASSPHRASE);
END_TEST assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
Suite *torture_make_suite(void) { key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, LIBSSH_PASSPHRASE);
Suite *s = suite_create("libssh_keyfiles"); assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
torture_create_case_fixture(s, "torture_pubkey_from_file", /* Test the automatic type discovery */
torture_pubkey_from_file, setup_rsa_key, teardown); key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
torture_create_case_fixture(s, "torture_pubkey_generate_from_privkey", assert_true(key != NULL);
torture_pubkey_generate_from_privkey, setup_rsa_key, teardown); if (key != NULL) {
torture_create_case_fixture(s, "torture_privkey_from_file", privatekey_free(key);
torture_privatekey_from_file, setup_both_keys, teardown); key = NULL;
torture_create_case_fixture(s, "torture_privkey_from_file_passphrase", }
torture_privatekey_from_file_passphrase, setup_both_keys_passphrase, teardown);
return s; key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
} }
int torture_run_tests(void) {
const UnitTest tests[] = {
unit_test_setup_teardown(torture_pubkey_from_file,
setup_rsa_key,
teardown),
unit_test_setup_teardown(torture_pubkey_generate_from_privkey,
setup_rsa_key, teardown),
unit_test_setup_teardown(torture_privatekey_from_file,
setup_both_keys,
teardown),
unit_test_setup_teardown(torture_privatekey_from_file_passphrase,
setup_both_keys_passphrase, teardown),
};
return run_tests(tests);
}