// SPDX-License-Identifier: LGPL-2.1+

/*

 * Copyright (C) 2018 Red Hat, Inc.

 * Copyright (C) 2015 - 2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.

 */

#include "nm-default.h"

#include "nm-secret-utils.h"

#include <malloc.h>

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

void

nm_explicit_bzero (void *s, gsize n)

{

	/* gracefully handle n == 0. This is important, callers rely on it. */

	if (G_UNLIKELY (n == 0))

		return;

	nm_assert (s);

#if defined (HAVE_DECL_EXPLICIT_BZERO) && HAVE_DECL_EXPLICIT_BZERO

	explicit_bzero (s, n);

#else

	{

		volatile guint8 *p = s;

		memset (s, '\0', n);

		while (n-- > 0)

			*(p++) = '\0';

	}

#endif

}

void

nm_free_secret (char *secret)

{

	gsize len;

	if (!secret)

		return;

#if GLIB_CHECK_VERSION(2,44,0)

	/* Here we mix malloc() and g_malloc() API. Usually we avoid this,

	 * however since glib 2.44.0 we are in fact guaranteed that g_malloc()/g_free()

	 * just wraps malloc()/free(), so this is actually fine.

	 *

	 * See https://gitlab.gnome.org/GNOME/glib/commit/3be6ed60aa58095691bd697344765e715a327fc1

	 */

	len = malloc_usable_size (secret);

#else

	len = strlen (secret);

#endif

	nm_explicit_bzero (secret, len);

	g_free (secret);

}

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

char *

nm_secret_strchomp (char *secret)

{

	gsize len;

	g_return_val_if_fail (secret, NULL);

	/* it's actually identical to g_strchomp(). However,

	 * the glib function does not document, that it clears the

	 * memory. For @secret, we don't only want to truncate trailing

	 * spaces, we want to overwrite them with NUL. */

	len = strlen (secret);

	while (len--) {

		if (g_ascii_isspace ((guchar) secret[len]))

			secret[len] = '\0';

		else

			break;

	}

	return secret;

}

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

GBytes *

nm_secret_copy_to_gbytes (gconstpointer mem, gsize mem_len)

{

	NMSecretBuf *b;

	if (mem_len == 0)

		return g_bytes_new_static ("", 0);

	nm_assert (mem);

	/* NUL terminate the buffer.

	 *

	 * The entire buffer is already malloc'ed and likely has some room for padding.

	 * Thus, in many situations, this additional byte will cause no overhead in

	 * practice.

	 *

	 * Even if it causes an overhead, do it just for safety. Yes, the returned

	 * bytes is not a NUL terminated string and no user must rely on this. Do

	 * not treat binary data as NUL terminated strings, unless you know what

	 * you are doing. Anyway, defensive FTW.

	 */

	b = nm_secret_buf_new (mem_len + 1);

	memcpy (b->bin, mem, mem_len);

	b->bin[mem_len] = 0;

	return nm_secret_buf_to_gbytes_take (b, mem_len);

}

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

NMSecretBuf *

nm_secret_buf_new (gsize len)

{

	NMSecretBuf *secret;

	nm_assert (len > 0);

	secret = g_malloc (sizeof (NMSecretBuf) + len);

	*((gsize *) &(secret->len)) = len;

	return secret;

}

static void

_secret_buf_free (gpointer user_data)

{

	NMSecretBuf *secret = user_data;

	nm_assert (secret);

	nm_assert (secret->len > 0);

	nm_explicit_bzero (secret->bin, secret->len);

	g_free (user_data);

}

GBytes *

nm_secret_buf_to_gbytes_take (NMSecretBuf *secret, gssize actual_len)

{

	nm_assert (secret);

	nm_assert (secret->len > 0);

	nm_assert (actual_len == -1 || (actual_len >= 0 && actual_len <= secret->len));

	return g_bytes_new_with_free_func (secret->bin,

	                                   actual_len >= 0 ? (gsize) actual_len : secret->len,

	                                   _secret_buf_free,

	                                   secret);

}

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

/**

 * nm_utils_memeqzero_secret:

 * @data: the data pointer to check (may be %NULL if @length is zero).

 * @length: the number of bytes to check.

 *

 * Checks that all bytes are zero. This always takes the same amount

 * of time to prevent timing attacks.

 *

 * Returns: whether all bytes are zero.

 */

gboolean

nm_utils_memeqzero_secret (gconstpointer data, gsize length)

{

	const guint8 *const key = data;

	volatile guint8 acc = 0;

	gsize i;

	for (i = 0; i < length; i++) {

		acc |= key[i];

		asm volatile("" : "=r"(acc) : "0"(acc));

	}

	return 1 & ((acc - 1) >> 8);

}