dhstate.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_dhstate_new_by_id(NoiseDHState **state, int id)
{
    /* The "state" argument must be non-NULL */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;

    /* Create the DHState object for the "id" */
    *state = 0;
    switch (id) {
    case NOISE_DH_CURVE25519:
        *state = noise_curve25519_new();
        break;

    case NOISE_DH_CURVE448:
        *state = noise_curve448_new();
        break;

    case NOISE_DH_NEWHOPE:
        *state = noise_newhope_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_dhstate_new_by_name(NoiseDHState **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_DH_CATEGORY, name, strlen(name));
    if (id)
        return noise_dhstate_new_by_id(state, id);

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

int noise_dhstate_free(NoiseDHState *state)
{
    /* Bail out if no DH 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_dhstate_get_dh_id(const NoiseDHState *state)
{
    return state ? state->dh_id : NOISE_DH_NONE;
}

size_t noise_dhstate_get_public_key_length(const NoiseDHState *state)
{
    return state ? state->public_key_len : 0;
}

size_t noise_dhstate_get_private_key_length(const NoiseDHState *state)
{
    return state ? state->private_key_len : 0;
}

size_t noise_dhstate_get_shared_key_length(const NoiseDHState *state)
{
    return state ? state->shared_key_len : 0;
}

int noise_dhstate_is_ephemeral_only(const NoiseDHState *state)
{
    return state ? state->ephemeral_only : 0;
}

int noise_dhstate_has_keypair(const NoiseDHState *state)
{
    if (state)
        return state->key_type == NOISE_KEY_TYPE_KEYPAIR;
    else
        return 0;
}

int noise_dhstate_has_public_key(const NoiseDHState *state)
{
    if (state)
        return state->key_type != NOISE_KEY_TYPE_NO_KEY;
    else
        return 0;
}

int noise_dhstate_generate_keypair(NoiseDHState *state)
{
    int err;

    /* Validate the parameter */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;

    /* Generate the new keypair */
    err = (*(state->generate_keypair))(state, 0);
    if (err == NOISE_ERROR_NONE)
        state->key_type = NOISE_KEY_TYPE_KEYPAIR;
    return err;
}

int noise_dhstate_generate_dependent_keypair
    (NoiseDHState *state, const NoiseDHState *other)
{
    int err;

    /* Validate the parameters */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;
    if (other && state->dh_id != other->dh_id)
        return NOISE_ERROR_INVALID_PARAM;

    /* Generate the new keypair */
    err = (*(state->generate_keypair))(state, other);
    if (err == NOISE_ERROR_NONE)
        state->key_type = NOISE_KEY_TYPE_KEYPAIR;
    return err;
}

int noise_dhstate_set_keypair
    (NoiseDHState *state, const uint8_t *private_key, size_t private_key_len,
     const uint8_t *public_key, size_t public_key_len)
{
    int err;

    /* Validate the parameters */
    if (!state || !private_key || !public_key)
        return NOISE_ERROR_INVALID_PARAM;
    if (private_key_len != state->private_key_len)
        return NOISE_ERROR_INVALID_LENGTH;
    if (public_key_len != state->public_key_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Set the keypair */
    err = (*(state->set_keypair))(state, private_key, public_key);
    if (err != NOISE_ERROR_NONE) {
        noise_dhstate_clear_key(state);
        return err;
    }
    state->key_type = NOISE_KEY_TYPE_KEYPAIR;
    return NOISE_ERROR_NONE;
}

int noise_dhstate_set_keypair_private
    (NoiseDHState *state, const uint8_t *private_key, size_t private_key_len)
{
    int err;

    /* Validate the parameters */
    if (!state || !private_key)
        return NOISE_ERROR_INVALID_PARAM;
    if (private_key_len != state->private_key_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Set the private key and derive the public key from the private key */
    err = (*(state->set_keypair_private))(state, private_key);
    if (err != NOISE_ERROR_NONE) {
        noise_dhstate_clear_key(state);
        return err;
    }
    state->key_type = NOISE_KEY_TYPE_KEYPAIR;
    return NOISE_ERROR_NONE;
}

int noise_dhstate_get_keypair
    (const NoiseDHState *state, uint8_t *private_key, size_t private_key_len,
     uint8_t *public_key, size_t public_key_len)
{
    /* Validate the parameters */
    if (!state || !private_key || !public_key)
        return NOISE_ERROR_INVALID_PARAM;
    if (private_key_len != state->private_key_len)
        return NOISE_ERROR_INVALID_LENGTH;
    if (public_key_len != state->public_key_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Is this actually a keypair? */
    if (state->key_type != NOISE_KEY_TYPE_KEYPAIR) {
        memset(private_key, 0, private_key_len);
        memset(public_key, 0, public_key_len);
        return NOISE_ERROR_INVALID_STATE;
    }

    /* Copy the keypair out */
    memcpy(private_key, state->private_key, private_key_len);
    memcpy(public_key, state->public_key, public_key_len);
    return NOISE_ERROR_NONE;
}

int noise_dhstate_set_public_key
    (NoiseDHState *state, const uint8_t *public_key, size_t public_key_len)
{
    int is_null, err;

    /* Validate the parameters */
    if (!state || !public_key)
        return NOISE_ERROR_INVALID_PARAM;
    if (public_key_len != state->public_key_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Validate the public key with the back end and then ignore the
       result if the public key is the special null value */
    is_null = state->nulls_allowed & noise_is_zero(public_key, public_key_len);
    err = (*(state->validate_public_key))(state, public_key);
    err &= (is_null - 1);
    if (err != NOISE_ERROR_NONE)
        return err;

    /* Copy the public key into place and clear the private key */
    memset(state->private_key, 0, state->private_key_len);
    memcpy(state->public_key, public_key, public_key_len);
    state->key_type = NOISE_KEY_TYPE_PUBLIC;
    return NOISE_ERROR_NONE;
}

int noise_dhstate_get_public_key
    (const NoiseDHState *state, uint8_t *public_key, size_t public_key_len)
{
    /* Validate the parameters */
    if (!state || !public_key)
        return NOISE_ERROR_INVALID_PARAM;
    if (public_key_len != state->public_key_len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Copy the public key out */
    memcpy(public_key, state->public_key, public_key_len);
    return NOISE_ERROR_NONE;
}

int noise_dhstate_set_null_public_key(NoiseDHState *state)
{
    /* Validate the parameter */
    if (!state || !state->nulls_allowed)
        return NOISE_ERROR_INVALID_PARAM;

    /* Clear the key to all-zeroes */
    memset(state->public_key, 0, state->public_key_len);
    memset(state->private_key, 0, state->private_key_len);

    /* We have a public key but no private key */
    state->key_type = NOISE_KEY_TYPE_PUBLIC;
    return NOISE_ERROR_NONE;
}

int noise_dhstate_is_null_public_key(const NoiseDHState *state)
{
    if (state && state->key_type != NOISE_KEY_TYPE_NO_KEY) {
        return state->nulls_allowed &&
               noise_is_zero(state->public_key, state->public_key_len);
    } else {
        return 0;
    }
}

int noise_dhstate_clear_key(NoiseDHState *state)
{
    /* Validate the parameter */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;

    /* Clear the key to all-zeroes */
    memset(state->public_key, 0, state->public_key_len);
    memset(state->private_key, 0, state->private_key_len);

    /* There is no key in the object now */
    state->key_type = NOISE_KEY_TYPE_NO_KEY;
    return NOISE_ERROR_NONE;
}

static void noise_cmove_zero(uint8_t *data, size_t len, int condition)
{
    /* Turn the condition into an all-zeroes or all-ones mask.
       If the condition is set, then we want all-zeroes in the mask.
       If the condition is not set, then we want all-ones in the mask. */
    uint8_t mask = ~((uint8_t)(-condition));

    /* AND the contents of the data buffer with the mask */
    while (len > 0) {
        *data++ &= mask;
        --len;
    }
}

int noise_dhstate_calculate
    (const NoiseDHState *private_key_state,
     const NoiseDHState *public_key_state,
     uint8_t *shared_key, size_t shared_key_len)
{
    int is_null, err;

    /* Validate the parameters */
    if (!private_key_state || !public_key_state || !shared_key)
        return NOISE_ERROR_INVALID_PARAM;
    if (private_key_state->dh_id != public_key_state->dh_id)
        return NOISE_ERROR_INVALID_PARAM;
    if (shared_key_len != private_key_state->shared_key_len)
        return NOISE_ERROR_INVALID_LENGTH;
    if (private_key_state->key_type != NOISE_KEY_TYPE_KEYPAIR)
        return NOISE_ERROR_INVALID_PRIVATE_KEY;

    /* If the public key is null, then the output must be null too.
       We check for null now, but still perform the normal evaluation.
       At the end we will null out the result in constant time */
    is_null = public_key_state->nulls_allowed & noise_is_zero
        (public_key_state->public_key, public_key_state->public_key_len);

    /* Perform the calculation */
    err = (*(private_key_state->calculate))
        (private_key_state, public_key_state, shared_key);

    /* If the public key was null, then we need to set the shared key
       to null and replace any error we got from the back end with "none" */
    noise_cmove_zero(shared_key, shared_key_len, is_null);
    err &= (is_null - 1);
    return err;
}

int noise_dhstate_copy(NoiseDHState *state, const NoiseDHState *from)
{
    int err;

    /* Validate the parameters */
    if (!state || !from)
        return NOISE_ERROR_INVALID_PARAM;
    if (state->dh_id != from->dh_id)
        return NOISE_ERROR_NOT_APPLICABLE;
    if (state == from)
        return NOISE_ERROR_NONE;

    /* Copy the key information across */
    err = (*(state->copy))(state, from, 0);
    if (err != NOISE_ERROR_NONE)
        return err;
    state->key_type = from->key_type;
    return err;
}

int noise_dhstate_format_fingerprint
    (const NoiseDHState *state, int fingerprint_type, char *buffer, size_t len)
{
    /* Validate the parameters */
    if (!buffer)
        return NOISE_ERROR_INVALID_PARAM;
    if (!len)
        return NOISE_ERROR_INVALID_LENGTH;
    *buffer = '\0'; /* In case we bail out with an error later */
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;
    if (state->key_type == NOISE_KEY_TYPE_NO_KEY)
        return NOISE_ERROR_INVALID_STATE;

    /* Format the fingerprint */
    return noise_format_fingerprint
        (fingerprint_type, buffer, len,
         state->public_key, state->public_key_len);
}

int noise_dhstate_get_role(const NoiseDHState *state)
{
    return state ? state->role : 0;
}

int noise_dhstate_set_role(NoiseDHState *state, int role)
{
    if (!state)
        return NOISE_ERROR_INVALID_PARAM;
    if (role != NOISE_ROLE_INITIATOR && role != NOISE_ROLE_RESPONDER && role)
        return NOISE_ERROR_INVALID_PARAM;
    state->role = role;
    if (state->change_role)
        (*(state->change_role))(state);
    return NOISE_ERROR_NONE;
}