From 23aa58e442c59f624af9d04f00cd271fb4bd73a3 Mon Sep 17 00:00:00 2001 From: milo Date: Thu, 17 Mar 2011 11:39:11 +0100 Subject: [PATCH] Added some tortures for pki --- tests/unittests/CMakeLists.txt | 1 + tests/unittests/torture_pki.c | 345 +++++++++++++++++++++++++++++++++ 2 files changed, 346 insertions(+) create mode 100644 tests/unittests/torture_pki.c diff --git a/tests/unittests/CMakeLists.txt b/tests/unittests/CMakeLists.txt index 55144042..91e1c41e 100644 --- a/tests/unittests/CMakeLists.txt +++ b/tests/unittests/CMakeLists.txt @@ -10,6 +10,7 @@ add_cmockery_test(torture_isipaddr torture_isipaddr.c ${TORTURE_LIBRARY}) if (UNIX AND NOT WIN32) # requires ssh-keygen add_cmockery_test(torture_keyfiles torture_keyfiles.c ${TORTURE_LIBRARY}) + add_cmockery_test(torture_pki torture_pki.c ${TORTURE_LIBRARY}) # requires pthread add_cmockery_test(torture_rand torture_rand.c ${TORTURE_LIBRARY}) endif (UNIX AND NOT WIN32) diff --git a/tests/unittests/torture_pki.c b/tests/unittests/torture_pki.c new file mode 100644 index 00000000..f0dbd20c --- /dev/null +++ b/tests/unittests/torture_pki.c @@ -0,0 +1,345 @@ +#define LIBSSH_STATIC + +#include "torture.h" +#include "pki.c" +#include +#include + +#define LIBSSH_RSA_TESTKEY "libssh_testkey.id_rsa" +#define LIBSSH_DSA_TESTKEY "libssh_testkey.id_dsa" +#define LIBSSH_PASSPHRASE "libssh-rocks" + +static void setup_rsa_key(void **state) { + ssh_session session; + int rc; + + unlink(LIBSSH_RSA_TESTKEY); + unlink(LIBSSH_RSA_TESTKEY ".pub"); + + rc = system("ssh-keygen -t rsa -q -N \"\" -f " LIBSSH_RSA_TESTKEY); + assert_true(rc == 0); + + session = ssh_new(); + *state = session; +} + +static void setup_dsa_key(void **state) { + ssh_session session; + int rc; + + unlink(LIBSSH_DSA_TESTKEY); + unlink(LIBSSH_DSA_TESTKEY ".pub"); + + rc = system("ssh-keygen -t dsa -q -N \"\" -f " LIBSSH_DSA_TESTKEY); + assert_true(rc == 0); + + session = ssh_new(); + *state = session; +} + +static void setup_both_keys(void **state) { + setup_rsa_key(state); + ssh_free(*state); + setup_dsa_key(state); +} + +static void setup_both_keys_passphrase(void **state) { + ssh_session session; + int rc; + + rc = system("ssh-keygen -t rsa -q -N " LIBSSH_PASSPHRASE " -f " LIBSSH_RSA_TESTKEY); + assert_true(rc == 0); + + rc = system("ssh-keygen -t dsa -q -N " LIBSSH_PASSPHRASE " -f " LIBSSH_DSA_TESTKEY); + assert_true(rc == 0); + + session = ssh_new(); + *state = session; +} + +static void teardown(void **state) { + unlink(LIBSSH_DSA_TESTKEY); + unlink(LIBSSH_DSA_TESTKEY ".pub"); + + unlink(LIBSSH_RSA_TESTKEY); + unlink(LIBSSH_RSA_TESTKEY ".pub"); + + ssh_free(*state); +} + +static char *read_file(const char *filename) { + char *key; + int fd; + int size; + struct stat buf; + + assert_true(filename != NULL); + assert_true(*filename != '\0'); + + stat(filename, &buf); + + key = malloc(buf.st_size + 1); + assert_true(key != NULL); + + fd = open(filename, O_RDONLY); + assert_true(fd >= 0); + + size = read(fd, key, buf.st_size); + assert_true(size == buf.st_size); + + close(fd); + + key[size] = '\0'; + return key; +} + +static void torture_pki_import_privkey_base64_RSA(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + const char *passphrase = LIBSSH_PASSPHRASE; + + key_str = read_file(LIBSSH_RSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + /* + int ssh_pki_import_privkey_base64(ssh_key key, ssh_session session, + const char *b64_key, const char *passphrase) + */ + rc = ssh_pki_import_privkey_base64(key, session, key_str, passphrase); + assert_true(rc == 0); + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_import_privkey_base64_NULL_key(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + const char *passphrase = LIBSSH_PASSPHRASE; + + key_str = read_file(LIBSSH_RSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + + /* test if it returns -1 if key is NULL */ + rc = ssh_pki_import_privkey_base64(NULL, session, key_str, passphrase); + assert_true(rc == -1); + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_import_privkey_base64_NULL_session(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + const char *passphrase = LIBSSH_PASSPHRASE; + + key_str = read_file(LIBSSH_RSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + + /* test if it returns -1 if session is NULL */ + (void)session; + rc = ssh_pki_import_privkey_base64(key, NULL, key_str, passphrase); + assert_true(rc == -1); + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_import_privkey_base64_NULL_str(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + const char *passphrase = LIBSSH_PASSPHRASE; + + key_str = read_file(LIBSSH_RSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + + /* test if it returns -1 if key_str is NULL */ + rc = ssh_pki_import_privkey_base64(key, session, NULL, passphrase); + assert_true(rc == -1); + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_import_privkey_base64_DSA(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + const char *passphrase = LIBSSH_PASSPHRASE; + + key_str = read_file(LIBSSH_DSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + /* + int ssh_pki_import_privkey_base64(ssh_key key, ssh_session session, + const char *b64_key, const char *passphrase) + */ + rc = ssh_pki_import_privkey_base64(key, session, key_str, passphrase); + assert_true(rc == 0); + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_import_privkey_base64_passphrase(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + const char *passphrase = LIBSSH_PASSPHRASE; + + key_str = read_file(LIBSSH_RSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + + rc = ssh_pki_import_privkey_base64(key, session, key_str, passphrase); + assert_true(rc == 0); + + /* test if it returns -1 if passphrase is wrong */ + rc = ssh_pki_import_privkey_base64(key, session, key_str, "wrong passphrase !!"); + assert_true(rc == -1); + +#ifndef HAVE_LIBCRYPTO + /* test if it returns -1 if passphrase is NULL */ + /* libcrypto asks for a passphrase, so skip this test */ + rc = ssh_pki_import_privkey_base64(key, session, key_str, NULL); + assert_true(rc == -1); +#endif + + free(key_str); + + /* same for DSA */ + key_str = read_file(LIBSSH_DSA_TESTKEY); + assert_true(key_str != NULL); + + rc = ssh_pki_import_privkey_base64(key, session, key_str, passphrase); + assert_true(rc == 0); + + /* test if it returns -1 if passphrase is wrong */ + rc = ssh_pki_import_privkey_base64(key, session, key_str, "wrong passphrase !!"); + assert_true(rc == -1); + +#ifndef HAVE_LIBCRYPTO + /* test if it returns -1 if passphrase is NULL */ + /* libcrypto asks for a passphrase, so skip this test */ + rc = ssh_pki_import_privkey_base64(key, session, key_str, NULL); + assert_true(rc == -1); +#endif + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_pki_publickey_from_privatekey_RSA(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + ssh_key pubkey; + const char *passphrase = NULL; + + key_str = read_file(LIBSSH_RSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + + rc = ssh_pki_import_privkey_base64(key, session, key_str, passphrase); + assert_true(rc == 0); + + pubkey = ssh_pki_publickey_from_privatekey(key); + assert_true(pubkey != NULL); + + free(key_str); + ssh_key_free(key); +} + +static void torture_pki_pki_publickey_from_privatekey_DSA(void **state) { + ssh_session session = *state; + int rc; + char *key_str; + ssh_key key; + ssh_key pubkey; + const char *passphrase = NULL; + + key_str = read_file(LIBSSH_DSA_TESTKEY); + assert_true(key_str != NULL); + + key = ssh_key_new(); + assert_true(key != NULL); + + rc = ssh_pki_import_privkey_base64(key, session, key_str, passphrase); + assert_true(rc == 0); + + pubkey = ssh_pki_publickey_from_privatekey(key); + assert_true(pubkey != NULL); + + free(key_str); + ssh_key_free(key); +} + +int torture_run_tests(void) { + int rc; + const UnitTest tests[] = { + /* ssh_pki_import_privkey_base64 */ + unit_test_setup_teardown(torture_pki_import_privkey_base64_NULL_key, + setup_rsa_key, + teardown), + unit_test_setup_teardown(torture_pki_import_privkey_base64_NULL_session, + setup_rsa_key, + teardown), + unit_test_setup_teardown(torture_pki_import_privkey_base64_NULL_str, + setup_rsa_key, + teardown), + unit_test_setup_teardown(torture_pki_import_privkey_base64_RSA, + setup_rsa_key, + teardown), + unit_test_setup_teardown(torture_pki_import_privkey_base64_DSA, + setup_dsa_key, + teardown), + unit_test_setup_teardown(torture_pki_import_privkey_base64_passphrase, + setup_both_keys_passphrase, + teardown), + /* ssh_pki_publickey_from_privatekey */ + unit_test_setup_teardown(torture_pki_pki_publickey_from_privatekey_RSA, + setup_rsa_key, + teardown), + unit_test_setup_teardown(torture_pki_pki_publickey_from_privatekey_DSA, + setup_dsa_key, + teardown), + + + + }; + + (void)setup_both_keys; + + ssh_init(); + rc=run_tests(tests); + ssh_finalize(); + return rc; +}