util.c

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Southern Storm Software, Pty Ltd.
 * Copyright (C) 2016 Topology LP.
 *
 * 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"
#if USE_LIBSODIUM
#include <sodium.h>
typedef crypto_hash_sha256_state sha256_context_t;
#define sha256_reset(ctx) crypto_hash_sha256_init(ctx)
#define sha256_update(ctx, pub, pub_len) crypto_hash_sha256_update(ctx, pub, pub_len)
#define sha256_finish(ctx, hash) crypto_hash_sha256_final(ctx, hash)
#else
#include "crypto/sha2/sha256.h"
#endif
#if USE_OPENSSL
#include <openssl/err.h>
#include <openssl/evp.h>
#endif
#include <stdlib.h>
#if HAVE_PTHREAD
#include <pthread.h>
static pthread_once_t noise_is_initialized = PTHREAD_ONCE_INIT;
#endif

void noise_init_helper(void)
{
#if USE_LIBSODIUM
    if (sodium_init() < 0)
        return;
#endif
#if USE_OPENSSL
    OpenSSL_add_all_algorithms();
    ERR_load_crypto_strings();
#endif
}

int noise_init(void)
{
#if HAVE_PTHREAD
    if (pthread_once(&noise_is_initialized, noise_init_helper) != 0)
        return NOISE_ERROR_SYSTEM;
#else
    noise_init_helper();
#endif

    return NOISE_ERROR_NONE;
}

void *noise_new_object(size_t size)
{
    void *ptr = calloc(1, size);
    if (!ptr || size < sizeof(size_t))
        return ptr;
    *((size_t *)ptr) = size;
    return ptr;
}

void noise_free(void *ptr, size_t size)
{
    if (ptr) {
        noise_clean(ptr, size);
        free(ptr);
    }
}

void noise_clean(void *data, size_t size)
{
    volatile uint8_t *d = (volatile uint8_t *)data;
    while (size > 0) {
        *d++ = 0;
        --size;
    }
}

int noise_is_equal(const void *s1, const void *s2, size_t size)
{
    const uint8_t *str1 = (const unsigned char *)s1;
    const uint8_t *str2 = (const unsigned char *)s2;
    uint8_t temp = 0;
    while (size > 0) {
        temp |= *str1 ^ *str2;
        ++str1;
        ++str2;
        --size;
    }
    return (0x0100 - (int)temp) >> 8;
}

int noise_is_zero(const void *data, size_t size)
{
    const uint8_t *d = (const uint8_t *)data;
    uint8_t temp = 0;
    while (size > 0) {
        temp |= *d++;
        --size;
    }
    return (0x0100 - (int)temp) >> 8;
}

int noise_format_fingerprint
    (int fingerprint_type, char *buffer, size_t len,
     const uint8_t *public_key, size_t public_key_len)
{
    static char const hexchars[] = "0123456789abcdef";
    sha256_context_t sha256;
    uint8_t hash[32];
    size_t f_len;
    size_t posn;

    /* 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 (!public_key)
        return NOISE_ERROR_INVALID_PARAM;

    /* Validate the fingerprint type and get the desired length */
    if (fingerprint_type == NOISE_FINGERPRINT_BASIC)
        f_len = 16;
    else if (fingerprint_type == NOISE_FINGERPRINT_FULL)
        f_len = 32;
    else
        return NOISE_ERROR_INVALID_PARAM;

    /* Check the length of the buffer */
    if ((f_len * 3) > len)
        return NOISE_ERROR_INVALID_LENGTH;

    /* Hash the public key with SHA256 */
    sha256_reset(&sha256);
    sha256_update(&sha256, public_key, public_key_len);
    sha256_finish(&sha256, hash);
    noise_clean(&sha256, sizeof(sha256));

    /* Format the fingerprint in hexadecimal within the buffer */
    for (posn = 0; posn < f_len; ++posn) {
        uint8_t byte = hash[posn];
        buffer[posn * 3] = hexchars[(byte >> 4) & 0x0F];
        buffer[posn * 3 + 1] = hexchars[byte & 0x0F];
        buffer[posn * 3 + 2] = ':';
    }
    buffer[f_len * 3 - 1] = '\0';
    noise_clean(hash, sizeof(hash));
    return NOISE_ERROR_NONE;
}