NetworkManager/shared/nm-glib-aux/nm-hash-utils.c

/* SPDX-License-Identifier: LGPL-2.1+ */
/*
 * Copyright (C) 2017 Red Hat, Inc.
 */

#include "nm-default.h"

#include "nm-hash-utils.h"

#include <stdint.h>

#include "nm-shared-utils.h"
#include "nm-random-utils.h"

/*****************************************************************************/

#define HASH_KEY_SIZE       16u
#define HASH_KEY_SIZE_GUINT ((HASH_KEY_SIZE + sizeof(guint) - 1) / sizeof(guint))

G_STATIC_ASSERT(sizeof(guint) * HASH_KEY_SIZE_GUINT >= HASH_KEY_SIZE);

static const guint8 *volatile global_seed = NULL;

static const guint8 *
_get_hash_key_init(void)
{
    /* the returned hash is aligned to guin64, hence, it is safe
     * to use it as guint* or guint64* pointer. */
    static union {
        guint8  v8[HASH_KEY_SIZE];
        guint   _align_as_uint;
        guint32 _align_as_uint32;
        guint64 _align_as_uint64;
    } g_arr;
    const guint8 *g;

again:
    g = g_atomic_pointer_get(&global_seed);
    if (!G_UNLIKELY(g)) {
        static gsize g_lock;
        uint64_t     h;
        union {
            guint  vuint;
            guint8 v8[HASH_KEY_SIZE];
            guint8 _extra_entropy[3 * HASH_KEY_SIZE];
        } t_arr;

        nm_utils_random_bytes(&t_arr, sizeof(t_arr));

        /* We only initialize one random hash key. So we can spend some effort
         * of getting this right. For one, we collect more random bytes than
         * necessary.
         *
         * Then, the first guint of the seed should have all the entropy that we could
         * obtain in sizeof(t_arr). For that, siphash(t_arr) and xor the first guint
         * with hash.
         * The first guint is especially interesting for nm_hash_static() below that
         * doesn't use siphash itself. */
        h = c_siphash_hash(t_arr.v8, (const guint8 *) &t_arr, sizeof(t_arr));
        if (sizeof(h) > sizeof(guint))
            t_arr.vuint = t_arr.vuint ^ ((guint)(h & G_MAXUINT)) ^ ((guint)(h >> 32));
        else
            t_arr.vuint = t_arr.vuint ^ ((guint)(h & G_MAXUINT));

        if (!g_once_init_enter(&g_lock)) {
            /* lost a race. The random key is already initialized. */
            goto again;
        }

        memcpy(g_arr.v8, t_arr.v8, HASH_KEY_SIZE);
        g = g_arr.v8;
        g_atomic_pointer_set(&global_seed, g);
        g_once_init_leave(&g_lock, 1);
    }

    nm_assert(g == g_arr.v8);
    return g;
}

#define _get_hash_key()                          \
    ({                                           \
        const guint8 *_g;                        \
                                                 \
        _g = g_atomic_pointer_get(&global_seed); \
        if (G_UNLIKELY(!_g))                     \
            _g = _get_hash_key_init();           \
        _g;                                      \
    })

guint
nm_hash_static(guint static_seed)
{
    /* Note that we only xor the static_seed with the first guint of the key.
     *
     * We don't use siphash, which would mix the bits better with _get_hash_key().
     * Note that nm_hash_static() isn't used to hash the static_seed. Instead, it
     * is used to get a unique hash value in a static context. That means, every
     * caller is responsible to choose a static_seed that is sufficiently
     * distinct from all other callers. In other words, static_seed should be a
     * unique constant with good entropy.
     *
     * Note that _get_hash_key_init() already xored the first guint of the
     * key with the siphash of the entire static key. That means, even if
     * we got bad randomness for the first guint, the first guint is also
     * mixed with the randomness of the entire random key.
     *
     * Also, ensure that we don't return zero (like for nm_hash_complete()).
     */
    return ((*((const guint *) _get_hash_key())) ^ static_seed) ?: 3679500967u;
}

void
nm_hash_siphash42_init(CSipHash *h, guint static_seed)
{
    const guint8 *g;
    union {
        guint64 _align_as_uint64;
        guint   arr[HASH_KEY_SIZE_GUINT];
    } seed;

    nm_assert(h);

    g = _get_hash_key();
    memcpy(&seed, g, HASH_KEY_SIZE);
    seed.arr[0] ^= static_seed;
    c_siphash_init(h, (const guint8 *) &seed);
}

guint
nm_hash_str(const char *str)
{
    NMHashState h;

    if (!str)
        return nm_hash_static(1867854211u);
    nm_hash_init(&h, 1867854211u);
    nm_hash_update_str(&h, str);
    return nm_hash_complete(&h);
}

guint
nm_str_hash(gconstpointer str)
{
    return nm_hash_str(str);
}

guint
nm_hash_ptr(gconstpointer ptr)
{
    NMHashState h;

    if (!ptr)
        return nm_hash_static(2907677551u);
    nm_hash_init(&h, 2907677551u);
    nm_hash_update(&h, &ptr, sizeof(ptr));
    return nm_hash_complete(&h);
}

guint
nm_direct_hash(gconstpointer ptr)
{
    return nm_hash_ptr(ptr);
}

/*****************************************************************************/

guint
nm_pstr_hash(gconstpointer p)
{
    const char *const *s = p;

    if (!s)
        return nm_hash_static(101061439u);
    return nm_hash_str(*s);
}

gboolean
nm_pstr_equal(gconstpointer a, gconstpointer b)
{
    const char *const *s1 = a;
    const char *const *s2 = b;

    return (s1 == s2) || (s1 && s2 && nm_streq0(*s1, *s2));
}

guint
nm_pint_hash(gconstpointer p)
{
    const int *s = p;

    if (!s)
        return nm_hash_static(298377461u);
    return nm_hash_val(1208815757u, *s);
}

gboolean
nm_pint_equals(gconstpointer a, gconstpointer b)
{
    const int *s1 = a;
    const int *s2 = a;

    return s1 == s2 || (s1 && s2 && *s1 == *s2);
}

guint
nm_pdirect_hash(gconstpointer p)
{
    const void *const *s = p;

    if (!s)
        return nm_hash_static(1852748873u);
    return nm_direct_hash(*s);
}

gboolean
nm_pdirect_equal(gconstpointer a, gconstpointer b)
{
    const void *const *s1 = a;
    const void *const *s2 = b;

    return (s1 == s2) || (s1 && s2 && *s1 == *s2);
}

guint
nm_ppdirect_hash(gconstpointer p)
{
    const void *const *const *s = p;

    if (!s)
        return nm_hash_static(396534869u);
    if (!*s)
        return nm_hash_static(1476102263u);
    return nm_direct_hash(**s);
}

gboolean
nm_ppdirect_equal(gconstpointer a, gconstpointer b)
{
    const void *const *const *s1 = a;
    const void *const *const *s2 = b;

    if (s1 == s2)
        return TRUE;
    if (!s1 || !s2)
        return FALSE;

    if (*s1 == *s2)
        return TRUE;
    if (!*s1 || !*s2)
        return FALSE;

    return **s1 == **s2;
}

/*****************************************************************************/

guint
nm_gbytes_hash(gconstpointer p)
{
    GBytes *      ptr = (GBytes *) p;
    gconstpointer arr;
    gsize         len;

    arr = g_bytes_get_data(ptr, &len);
    return nm_hash_mem(792701303u, arr, len);
}

guint
nm_pgbytes_hash(gconstpointer p)
{
    GBytes *const *ptr = p;
    gconstpointer  arr;
    gsize          len;

    arr = g_bytes_get_data(*ptr, &len);
    return nm_hash_mem(1470631313u, arr, len);
}

gboolean
nm_pgbytes_equal(gconstpointer a, gconstpointer b)
{
    GBytes *const *ptr_a = a;
    GBytes *const *ptr_b = b;

    return g_bytes_equal(*ptr_a, *ptr_b);
}