SlunkCrypt/libslunkcrypt/src/internal.c

/******************************************************************************/
/* SlunkCrypt, by LoRd_MuldeR <MuldeR2@GMX.de>                                */
/* This work has been released under the CC0 1.0 Universal license!           */
/******************************************************************************/

#include <slunkcrypt.h>

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN 1
#include <Windows.h>
typedef BOOLEAN(WINAPI *genrandom_t)(void*, ULONG);
static volatile LONG g_random_init = 0L;
static HMODULE g_advapi32 = NULL;
static genrandom_t g_genrandom = NULL;
#else
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#if (defined(__GLIBC__) && __GLIBC_PREREQ(2,25)) || (defined(__FreeBSD__) && (__FreeBSD__ >= 12))
#include <sys/random.h>
#else
static const char *const DEV_RANDOM[] = { "/dev/urandom", "/dev/arandom", "/dev/random", NULL };
#endif
#endif

#ifdef _WIN32
static genrandom_t init_genrandom()
{
	LONG state;
	while ((state = InterlockedCompareExchange(&g_random_init, -1L, 0L)) != 0L)
	{
		if (state > 0L)
		{
			return g_genrandom;
		}
		Sleep(0U);
	}
	if (g_advapi32 || (g_advapi32 = LoadLibrary(L"advapi32.dll")))
	{
		if ((g_genrandom = (genrandom_t)GetProcAddress(g_advapi32, "SystemFunction036")))
		{
			InterlockedExchange(&g_random_init, 1L);
			return g_genrandom;
		}
	}
	InterlockedExchange(&g_random_init, 0L);
	return NULL;
}
#endif

int slunkcrypt_random_bytes(uint8_t* const buffer, const size_t length)
{
#ifdef _WIN32
	if ((length <= ((size_t)ULONG_MAX)))
	{
		const genrandom_t genrandom = init_genrandom();
		if (genrandom)
		{
			return genrandom(buffer, (ULONG)length) ? 0 : (-1);
		}
	}
	return -1;
#else
#if (defined(__GLIBC__) && __GLIBC_PREREQ(2,25)) || (defined(__FreeBSD__) && (__FreeBSD__ >= 12))
	if (getrandom(buffer, length, 0U) >= length)
	{
		return 0;
	}
	return -1;
#else
	int result = -1;
	for (size_t i = 0U; DEV_RANDOM[i] && (result != 0); ++i)
	{
		const int fd = open(DEV_RANDOM[i], O_RDONLY);
		if (fd >= 0)
		{
			if (read(fd, buffer, length) >= length)
			{
				result = 0;
			}
			close(fd);
		}
	}
	return result;
#endif
#endif
}

void slunkcrypt_bzero(void* const ptr, const size_t length)
{
	if ((ptr) && (length > 0U))
	{
#if defined(_WIN32) && defined(SecureZeroMemory)
		SecureZeroMemory(ptr, length);
#else
#if (defined(__GLIBC__) && __GLIBC_PREREQ(2,25)) || (defined(__FreeBSD__) && (__FreeBSD__ >= 11))
		explicit_bzero(ptr, length);
#else
		volatile uint8_t *buffer = (volatile uint8_t*)ptr;
		for (size_t i = 0U; i < length; ++i)
		{
			buffer[i] = 0U;
		}
#endif
#endif
	}
}