hashstate.c

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#include "internal.h"
#include <string.h>

int noise_hashstate_new_by_id(NoiseHashState **state, int id)
{
    /* The "state" argument must be non-NULL */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;

    /* Create the HashState object for the "id" */
    *state = 0;
    switch (id) {
    case NOISE_HASH_BLAKE2s:
        *state = noise_blake2s_new();
        break;

    case NOISE_HASH_BLAKE2b:
        *state = noise_blake2b_new();
        break;

    case NOISE_HASH_SHA256:
        *state = noise_sha256_new();
        break;

    case NOISE_HASH_SHA512:
        *state = noise_sha512_new();
        break;

    default:
        return NOISE_ERROR_UNKNOWN_ID;
    }

    /* Bail out if insufficient memory */
    if (!(*state))
        return NOISE_ERROR_NO_MEMORY;

    /* Ready to go */
    return NOISE_ERROR_NONE;
}

int noise_hashstate_new_by_name(NoiseHashState **state, const char *name)
{
    int id;

    /* The "state" and "name" arguments must be non-NULL */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;
    *state = 0;
    if (!name)
        return NOISE_ERROR_INVALID_PARAM;

    /* Map the name and create the corresponding object */
    id = noise_name_to_id(NOISE_HASH_CATEGORY, name, strlen(name));
    if (id)
        return noise_hashstate_new_by_id(state, id);

    /* We don't know what this is */
    return NOISE_ERROR_UNKNOWN_NAME;
}

int noise_hashstate_free(NoiseHashState *state)
{
    /* Bail out if no hash state */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;

    /* Call the backend-specific destroy function if necessary */
    if (state->destroy)
        (*(state->destroy))(state);

    /* Clean and free the memory */
    noise_free(state, state->size);
    return NOISE_ERROR_NONE;
}

int noise_hashstate_get_hash_id(const NoiseHashState *state)
{
    return state ? state->hash_id : NOISE_HASH_NONE;
}

size_t noise_hashstate_get_hash_length(const NoiseHashState *state)
{
    return state ? state->hash_len : 0;
}

size_t noise_hashstate_get_block_length(const NoiseHashState *state)
{
    return state ? state->block_len : 0;
}

int noise_hashstate_reset(NoiseHashState *state)
{
    /* Validate the parameter */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;

    /* Reset the hash state */
    (*(state->reset))(state);
    return NOISE_ERROR_NONE;
}

int noise_hashstate_update
    (NoiseHashState *state, const uint8_t *data, size_t data_len)
{
    /* Validate the parameters */
    if (!state || !data)
        return NOISE_ERROR_INVALID_PARAM;

    /* Update the hash state */
    (*(state->update))(state, data, data_len);
    return NOISE_ERROR_NONE;
}

int noise_hashstate_finalize
    (NoiseHashState *state, uint8_t *hash, size_t hash_len)
{
    /* Validate the parameters */
    if (!state || !hash)
        return NOISE_ERROR_INVALID_PARAM;
    if (hash_len != state->hash_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Finalize the hash state */
    (*(state->finalize))(state, hash);
    return NOISE_ERROR_NONE;
}

int noise_hashstate_hash_one
    (NoiseHashState *state, const uint8_t *data, size_t data_len,
     uint8_t *hash, size_t hash_len)
{
    /* Validate the parameters */
    if (!state || !data || !hash)
        return NOISE_ERROR_INVALID_PARAM;
    if (hash_len != state->hash_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Hash the data */
    (*(state->reset))(state);
    (*(state->update))(state, data, data_len);
    (*(state->finalize))(state, hash);
    return NOISE_ERROR_NONE;
}

int noise_hashstate_hash_two
    (NoiseHashState *state, const uint8_t *data1, size_t data1_len,
     const uint8_t *data2, size_t data2_len, uint8_t *hash, size_t hash_len)
{
    /* Validate the parameters */
    if (!state || !data1 || !data2 || !hash)
        return NOISE_ERROR_INVALID_PARAM;
    if (hash_len != state->hash_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Hash the data */
    (*(state->reset))(state);
    (*(state->update))(state, data1, data1_len);
    (*(state->update))(state, data2, data2_len);
    (*(state->finalize))(state, hash);
    return NOISE_ERROR_NONE;
}

#define HMAC_IPAD   0x36    
#define HMAC_OPAD   0x5C    
static void noise_hashstate_xor_key(uint8_t *key, size_t key_len, uint8_t value)
{
    while (key_len > 0) {
        *key++ ^= value;
        --key_len;
    }
}

static void noise_hashstate_hmac
    (NoiseHashState *state, const uint8_t *key, size_t key_len,
     const uint8_t *data1, size_t data1_len,
     const uint8_t *data2, size_t data2_len, uint8_t *hash)
{
    size_t hash_len = state->hash_len;
    size_t block_len = state->block_len;
    uint8_t *key_block;

    /* Allocate temporary stack space for the key block */
    key_block = alloca(block_len);

    /* Format the key for the inner hashing context */
    if (key_len <= block_len) {
        memcpy(key_block, key, key_len);
        memset(key_block + key_len, 0, block_len - key_len);
    } else {
        (*(state->reset))(state);
        (*(state->update))(state, key, key_len);
        (*(state->finalize))(state, key_block);
        memset(key_block + hash_len, 0, block_len - hash_len);
    }
    noise_hashstate_xor_key(key_block, block_len, HMAC_IPAD);

    /* Calculate the inner hash */
    (*(state->reset))(state);
    (*(state->update))(state, key_block, block_len);
    (*(state->update))(state, data1, data1_len);
    if (data2)
        (*(state->update))(state, data2, data2_len);
    (*(state->finalize))(state, hash);

    /* Format the key for the outer hashing context */
    noise_hashstate_xor_key(key_block, block_len, HMAC_IPAD ^ HMAC_OPAD);

    /* Calculate the outer hash */
    (*(state->reset))(state);
    (*(state->update))(state, key_block, block_len);
    (*(state->update))(state, hash, hash_len);
    (*(state->finalize))(state, hash);

    /* Clean up and exit */
    noise_clean(key_block, state->block_len);
}

int noise_hashstate_hkdf
    (NoiseHashState *state, const uint8_t *key, size_t key_len,
     const uint8_t *data, size_t data_len,
     uint8_t *output1, size_t output1_len,
     uint8_t *output2, size_t output2_len)
{
    size_t hash_len;
    uint8_t *temp_key;
    uint8_t *temp_hash;

    /* Validate the parameters */
    if (!state || !key || !data || !output1 || !output2)
        return NOISE_ERROR_INVALID_PARAM;
    hash_len = state->hash_len;
    if (output1_len > hash_len || output2_len > hash_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Allocate local stack space for the temporary hash values */
    temp_key = alloca(hash_len);
    temp_hash = alloca(hash_len + 1);

    /* Generate the temporary hashing key */
    noise_hashstate_hmac(state, key, key_len, data, data_len, 0, 0, temp_key);

    /* Generate the first output */
    temp_hash[0] = 0x01;
    noise_hashstate_hmac
        (state, temp_key, hash_len, temp_hash, 1, 0, 0, temp_hash);
    memcpy(output1, temp_hash, output1_len);

    /* Generate the second output */
    temp_hash[hash_len] = 0x02;
    noise_hashstate_hmac
        (state, temp_key, hash_len, temp_hash, hash_len + 1, 0, 0, temp_hash);
    memcpy(output2, temp_hash, output2_len);

    /* Clean up and exit */
    noise_clean(temp_key, hash_len);
    noise_clean(temp_hash, hash_len + 1);
    return NOISE_ERROR_NONE;
}

int noise_hashstate_pbkdf2
    (NoiseHashState *state, const uint8_t *passphrase, size_t passphrase_len,
     const uint8_t *salt, size_t salt_len, size_t iterations,
     uint8_t *output, size_t output_len)
{
    size_t hash_len;
    uint64_t max_size;
    uint8_t T[NOISE_MAX_HASHLEN];
    uint8_t U[NOISE_MAX_HASHLEN];
    uint8_t ibuf[4];
    size_t i, index, index2;

    /* Validate the parameters */
    if (!state || !passphrase || !salt || !output)
        return NOISE_ERROR_INVALID_PARAM;
    hash_len = state->hash_len;
    max_size = ((uint64_t)0xFFFFFFFFU) * hash_len;
    if (output_len > max_size)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Generate the required output blocks */
    i = 1;
    while (output_len > 0) {
        /* Generate the next block of output */
        ibuf[0] = (uint8_t)(i >> 24);
        ibuf[1] = (uint8_t)(i >> 16);
        ibuf[2] = (uint8_t)(i >> 8);
        ibuf[3] = (uint8_t)i;
        ++i;
        noise_hashstate_hmac
            (state, passphrase, passphrase_len, salt, salt_len,
             ibuf, sizeof(ibuf), T);
        memcpy(U, T, hash_len);
        for (index = 1; index < iterations; ++index) {
            noise_hashstate_hmac
                (state, passphrase, passphrase_len, U, hash_len, 0, 0, U);
            for (index2 = 0; index2 < hash_len; ++index2)
                T[index2] ^= U[index2];
        }

        /* Copy the generated data into the output buffer */
        if (output_len >= hash_len) {
            memcpy(output, T, hash_len);
            output += hash_len;
            output_len -= hash_len;
        } else {
            memcpy(output, T, output_len);
            output_len = 0;
        }
    }

    /* Clean up and exit */
    noise_clean(T, sizeof(T));
    noise_clean(U, sizeof(U));
    return NOISE_ERROR_NONE;
}

int noise_hashstate_get_max_hash_length(void)
{
    return NOISE_MAX_HASHLEN;
}

int noise_hashstate_get_max_block_length(void)
{
    return 128;
}