#include <stdlib.h>

#include <popt.h>

#include <check.h>

#include "util/util.h"

#include "tests/common.h"

#include "util/crypto/sss_crypto.h"

#include "util/crypto/nss/nss_util.h"

static TALLOC_CTX *test_ctx = NULL;

#ifdef HAVE_NSS

START_TEST(test_nss_init)

{

int ret;

ret = nspr_nss_init();

fail_if(ret != EOK);

ret = nspr_nss_cleanup();

fail_if(ret != EOK);

}

#endif

START_TEST(test_encrypt_decrypt)

{

const char *password[] = { "test123", /* general */

"12345678901234567", /* just above blocksize */

"", /* empty */

NULL}; /* sentinel */

int i;

char *obfpwd = NULL;

char *ctpwd = NULL;

int ret;

int expected;

#ifdef HAVE_NSS

expected = EOK;

#elif HAVE_LIBCRYPTO

expected = ENOSYS;

#else

#error Unknown crypto back end

#endif

test_ctx = talloc_new(NULL);

fail_if(test_ctx == NULL);

check_leaks_push(test_ctx);

for (i=0; password[i]; i++) {

ret = sss_password_encrypt(test_ctx, password[i], strlen(password[i])+1,

AES_256, &obfpwd);

fail_if(ret != expected);

ret = sss_password_decrypt(test_ctx, obfpwd, &ctpwd);

fail_if(ret != expected);

fail_if(ctpwd && strcmp(password[i], ctpwd) != 0);

talloc_free(obfpwd);

talloc_free(ctpwd);

}

check_leaks_pop(test_ctx);

talloc_free(test_ctx);

}

START_TEST(test_hmac_sha1)

{

const char *message = "test message";

const char *keys[] = {

"short",

"proper6789012345678901234567890123456789012345678901234567890123",

"longlonglonglonglonglonglonglonglonglonglonglonglonglonglonglonglong",

NULL };

const char *results[] = {

"\x2b\x27\x53\x07\x17\xd8\xc0\x8f\x97\x27\xdd\xb3\xec\x41\xd8\xa3\x94\x97\xaa\x35",

"\x37\xe7\x0a\x6f\x71\x0b\xa9\x93\x81\x53\x8f\x5c\x06\x83\x44\x2f\xc9\x41\xe3\xed",

"\xbd\x99\xa7\x7f\xfc\x5e\xde\x04\x32\x7f\x7b\x71\x4d\xc0\x3f\x51\x2d\x25\x01\x28",

NULL };

unsigned char out[SSS_SHA1_LENGTH];

int ret, expected;

int i;

#ifdef HAVE_NSS

expected = EOK;

#elif HAVE_LIBCRYPTO

expected = ENOSYS;

#else

#error Unknown crypto back end

#endif

for (i = 0; keys[i]; i++) {

ret = sss_hmac_sha1((const unsigned char *)keys[i], strlen(keys[i]),

(const unsigned char *)message, strlen(message),

out);

fail_if(ret != expected);

fail_if(ret == EOK && memcmp(out, results[i], SSS_SHA1_LENGTH) != 0);

}

}

Suite *crypto_suite(void)

{

Suite *s = suite_create("sss_crypto");

TCase *tc = tcase_create("sss crypto tests");

tcase_add_checked_fixture(tc, leak_check_setup, leak_check_teardown);

/* Do some testing */

#ifdef HAVE_NSS

tcase_add_test(tc, test_nss_init);

#endif

tcase_add_test(tc, test_encrypt_decrypt);

tcase_add_test(tc, test_hmac_sha1);

/* Add all test cases to the test suite */

suite_add_tcase(s, tc);

return s;

}

int main(int argc, const char *argv[])

{

int opt;

poptContext pc;

int number_failed;

int debug = 0;

struct poptOption long_options[] = {

POPT_AUTOHELP

{ "debug-level", 'd', POPT_ARG_INT, &debug, 0, "Set debug level", NULL },

POPT_TABLEEND

};

/* Set debug level to invalid value so we can deside if -d 0 was used. */

debug_level = SSSDBG_INVALID;

pc = poptGetContext(argv[0], argc, argv, long_options, 0);

while((opt = poptGetNextOpt(pc)) != -1) {

switch(opt) {

default:

fprintf(stderr, "\nInvalid option %s: %s\n\n",

poptBadOption(pc, 0), poptStrerror(opt));

poptPrintUsage(pc, stderr, 0);

return 1;

}

}

poptFreeContext(pc);

CONVERT_AND_SET_DEBUG_LEVEL(debug_level);

tests_set_cwd();

Suite *s = crypto_suite();

SRunner *sr = srunner_create(s);

srunner_run_all(sr, CK_ENV);

number_failed = srunner_ntests_failed(sr);

srunner_free(sr);

return (number_failed == 0 ? EXIT_SUCCESS : EXIT_FAILURE);

}