hash_test.c

Go to the documentation of this file.

/**
 * \file    heivs/hash_test.c
 * \see     heivs/hash.h
 *
 * This file has been split out of hash.c for size optimization reasons, the
 * linker has no reason to include it if it unused.
 */

#include "heivs/hash_test.h"
#include "heivs/hash.h"
#include <stdint.h>
#include <string.h>

static uint8_t to_bin(char c)
{
    if (c >= '0' && c <= '9')
    {
        return c-'0';
    }

    if (c >= 'A' && c <= 'F')
    {
        return c-'A'+10;
    }

    if (c >= 'a' && c <= 'f')
    {
        return c-'a'+10;
    }

    return 0;
}

status_e hash_compare_ascii(const struct heivs_hash_t *hash, const void *state, const char *str)
{
    uint8_t orig[strlen(str)/2];
    size_t str_len = strlen(str);
    size_t i;

    if (str_len%2)
    {
        return ERROR_BAD_PARAM;
    }

    if (str_len/2 != hash->hash_size)
    {
        return ERROR_BAD_PARAM;
    }

    for (i = 0 ; i < ARRAY_SIZE(orig); i++)
    {
        orig[i]  = to_bin(str[2*i+0]) << 4;
        orig[i] |= to_bin(str[2*i+1]) << 0;
    }

    if (memcmp(state, orig, sizeof(orig)))
    {
        return ERROR_FAILED;
    }

    return NO_ERROR;
}

status_e hash_test(struct heivs_hash_t *hash, const void *data, size_t size, const char *reference)
{
    status_e status;
    hash_declare_state(hash, state);

    status = hash_init(hash, &state, sizeof(state));
    if (status != NO_ERROR)
    {
        return status;
    }

    status = hash_run(hash, &state, data, size);
    if (status != NO_ERROR)
    {
        return status;
    }

    status = hash_finish(hash, state);
    if (status != NO_ERROR)
    {
        return status;
    }

    status = hash_compare_ascii(hash, state, reference);
    if (status != NO_ERROR)
    {
        return status;
    }

    return NO_ERROR;
}

status_e hash_test_zeroes(struct heivs_hash_t *hash, size_t size, const char *reference)
{
    uint32_t data[512/sizeof(uint32_t)];
    status_e status;
    hash_declare_state(hash, state);

    memset(data, 0x0, sizeof(data));

    status = hash_init(hash, &state, sizeof(state));
    if (status != NO_ERROR)
    {
        return status;
    }

    while (size)
    {
        uint32_t block_size = min(size, sizeof(data));
        status = hash_run(hash, &state, data, block_size);
        if (status != NO_ERROR)
        {
            return status;
        }

        size -= block_size;
    }

    status = hash_finish(hash, state);
    if (status != NO_ERROR)
    {
        return status;
    }

    status = hash_compare_ascii(hash, state, reference);
    if (status != NO_ERROR)
    {
        return status;
    }

    return NO_ERROR;
}