hash_stm32_md5.c

/**
 * \file    heivs/hash_md5.c
 * \see     heivs/hash.h
 *
 * Reference code from RFC1321
 */

#include "heivs/hash_stm32_md5.h"
#include <stdint.h>
#include <string.h>
#include <stm32/stm32f4xx_hash.h>
#include <stm32/stm32f4xx_rcc.h>
#include <heivs/time.h>

struct md5_state_t
{
    uint32_t bytes_left;
    uint8_t buffer[3];
};

static status_e init(struct heivs_hash_t *hash, void *_state, size_t state_size)
{
    struct md5_state_t *state = (struct md5_state_t *)_state;
    HASH_InitTypeDef MD5_HASH_InitStructure;

    (void)hash;
    (void)state_size;
    memset(state, 0x0, sizeof(*state));

    RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_HASH, ENABLE);

    /**
     * Check if the HASH device is functional.
     *
     * This device is not part of the whole family
     */
    HASH->DIN = 0xdeadbeaf;
    if (HASH->DIN != 0xdeadbeaf)
    {
        return ERROR_HW_FAILED;
    }

    /* HASH peripheral initialization */
    HASH_DeInit();

    /* HASH Configuration */
    MD5_HASH_InitStructure.HASH_AlgoSelection = HASH_AlgoSelection_MD5;
    MD5_HASH_InitStructure.HASH_AlgoMode = HASH_AlgoMode_HASH;
    MD5_HASH_InitStructure.HASH_DataType = HASH_DataType_8b;
    HASH_Init(&MD5_HASH_InitStructure);

    return NO_ERROR;
}

static status_e run(struct heivs_hash_t *hash, void *_state, const void *_data, size_t size)
{
    struct md5_state_t *state = (struct md5_state_t *)_state;
    uint32_t i;
    uint8_t *inputaddr  = (uint8_t *)_data;

    (void)hash;
    if (state->bytes_left)
    {
        /* FIXME : manage the case where data is not input in words... */
        return ERROR_NOT_YET_IMPLEMENTED;
    }

    /* Write the Input block in the IN FIFO */
    for( i = 0; i < size/4; i++)
    {
        HASH_DataIn(*(uint32_t*)inputaddr);
        inputaddr+=4;
    }

    state->bytes_left = size % 4;
    memcpy(state->buffer, inputaddr, state->bytes_left);

    return NO_ERROR;
}

static status_e finish(struct heivs_hash_t *hash, void *_state)
{
    status_e status = NO_ERROR;
    struct md5_state_t *state = (struct md5_state_t *)_state;
    uint32_t nbvalidbitsdata;
    timeout_t timeout;
    HASH_MsgDigest MD5_MessageDigest;
    uint32_t outputaddr = (uint32_t)_state;

    (void)hash;
    /* Number of valid bits in last word of the Input data */
    nbvalidbitsdata = 8 * (state->bytes_left % 4);

    if (state->bytes_left)
    {
        uint32_t *data = (uint32_t *)state->buffer;
        HASH_DataIn(*data);
    }

    /* Configure the number of valid bits in last word of the data */
    HASH_SetLastWordValidBitsNbr(nbvalidbitsdata);

    /* Start the HASH processor */
    HASH_StartDigest();

    timeout = time_set_timeout_ms(10);
    while (HASH_GetFlagStatus(HASH_FLAG_BUSY) != RESET)
    {
        if (time_elapsed(timeout))
        {
            status = ERROR_TIMEOUT;
            goto end;
        }
    }

    memset(state, 0x0, sizeof(*state));

    /* Read the message digest */
    HASH_GetDigest(&MD5_MessageDigest);
    *(uint32_t*)(outputaddr)  = __REV(MD5_MessageDigest.Data[0]);
    outputaddr+=4;
    *(uint32_t*)(outputaddr)  = __REV(MD5_MessageDigest.Data[1]);
    outputaddr+=4;
    *(uint32_t*)(outputaddr)  = __REV(MD5_MessageDigest.Data[2]);
    outputaddr+=4;
    *(uint32_t*)(outputaddr)  = __REV(MD5_MessageDigest.Data[3]);

end:
    RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_HASH, DISABLE);

    return status;
}


struct heivs_hash_t hash_stm32_md5 =
{
        .name           = "hash_stm32_md5",
        .init           = init,
        .run            = run,
        .finish         = finish,

        .state_size     = 128/8,
        .hash_size      = 128/8,
};