#include "config.h"

#define LIBSSH_STATIC

#include "torture.h"

#include "torture_key.h"

#include "legacy.c"

#include "dh.c"

static int setup_rsa_key(void **state)

{

    int rc=0;

    enum ssh_keytypes_e type;

    char *b64_key, *p;

    ssh_key key;

    const char *q;

    b64_key = strdup(torture_get_testkey_pub(SSH_KEYTYPE_RSA));

    assert_non_null(b64_key);

    q = p = b64_key;

    while (p != NULL && *p != '\0' && *p != ' ') p++;

    if (p != NULL) {

        *p = '\0';

    }

    type = ssh_key_type_from_name(q);

    assert_true(type == SSH_KEYTYPE_RSA);

    q = ++p;

    while (p != NULL && *p != '\0' && *p != ' ') p++;

    if (p != NULL) {

        *p = '\0';

    }

    rc = ssh_pki_import_pubkey_base64(q, type, &key);

    assert_true(rc == 0);

    free(b64_key);

    *state = key;

    return 0;

}

static int teardown(void **state)

{

    SSH_KEY_FREE(*state);

    return 0;

}

static void torture_md5_hash(void **state)

{

    ssh_key pubkey = *state;

    char *hash = NULL;

    char *hexa = NULL;

    size_t hlen;

    int rc = 0;

    if (ssh_fips_mode()) {

        skip();

    }

    rc = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_MD5,

                                (unsigned char **)&hash, &hlen);

    if (ssh_fips_mode()) {

        /* When in FIPS mode, expect the call to fail */

        assert_int_equal(rc, SSH_ERROR);

    } else {

        assert_int_equal(rc, SSH_OK);

        hexa = ssh_get_hexa((unsigned char *)hash, hlen);

        SSH_STRING_FREE_CHAR(hash);

        assert_string_equal(hexa,

                            "50:15:a0:9b:92:bf:33:1c:01:c5:8c:fe:18:fa:ce:78");

        SSH_STRING_FREE_CHAR(hexa);

    }

}

static void torture_sha1_hash(void **state)

{

    ssh_key pubkey = *state;

    char *hash = NULL;

    char *sha1 = NULL;

    int rc = 0;

    size_t hlen;

    rc = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_SHA1,

                                (unsigned char **)&hash, &hlen);

    assert_true(rc == 0);

    sha1 = ssh_get_b64_unpadded((unsigned char *)hash, hlen);

    SSH_STRING_FREE_CHAR(hash);

    assert_string_equal(sha1, "6wP+houujQmxLBiFugTcoeoODCM");

    SSH_STRING_FREE_CHAR(sha1);

}

static void torture_sha256_hash(void **state)

{

    ssh_key pubkey = *state;

    char *hash = NULL;

    char *sha256 = NULL;

    int rc = 0;

    size_t hlen;

    rc = ssh_get_publickey_hash(pubkey, SSH_PUBLICKEY_HASH_SHA256,

                                (unsigned char **)&hash, &hlen);

    assert_true(rc == 0);

    sha256 = ssh_get_b64_unpadded((unsigned char *)hash, hlen);

    SSH_STRING_FREE_CHAR(hash);

    assert_string_equal(sha256, "jXstVLLe84fSDo1kEYGn6iumnPCSorhaiWxnJz8VTII");

    SSH_STRING_FREE_CHAR(sha256);

}

static void torture_sha256_fingerprint(void **state)

{

    ssh_key pubkey = *state;

    char *hash = NULL;

    char *sha256 = NULL;

    int rc = 0;

    size_t hlen;

    rc = ssh_get_publickey_hash(pubkey,

                                SSH_PUBLICKEY_HASH_SHA256,

                                (unsigned char **)&hash,

                                &hlen);

    assert_true(rc == 0);

    sha256 = ssh_get_fingerprint_hash(SSH_PUBLICKEY_HASH_SHA256,

                                      (unsigned char *)hash,

                                      hlen);

    SSH_STRING_FREE_CHAR(hash);

    assert_string_equal(sha256,

                        "SHA256:jXstVLLe84fSDo1kEYGn6iumnPCSorhaiWxnJz8VTII");

    SSH_STRING_FREE_CHAR(sha256);

}

int torture_run_tests(void) {

    int rc;

    struct CMUnitTest tests[] = {

        cmocka_unit_test_setup_teardown(torture_md5_hash,

                                        setup_rsa_key,

                                        teardown),

        cmocka_unit_test_setup_teardown(torture_sha1_hash,

                                        setup_rsa_key,

                                        teardown),

        cmocka_unit_test_setup_teardown(torture_sha256_hash,

                                        setup_rsa_key,

                                        teardown),

        cmocka_unit_test_setup_teardown(torture_sha256_fingerprint,

                                        setup_rsa_key,

                                        teardown),

    };

    torture_filter_tests(tests);

    rc = cmocka_run_group_tests(tests, NULL, NULL);

    return rc;

}