// 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);
}