Muldersoft/SlunkCrypt
Muldersoft/SlunkCrypt
1
0
Fork 0
Code Releases 5 Activity

Refactored key-derivation code into a separate file + some code clean-up.

Browse Source
This commit is contained in:
LoRd_MuldeR 2021-04-17 15:13:13 +02:00
parent 102233a237
commit a656e9de37
Signed by: mulder
GPG Key ID: 2B5913365F57E03F
7 changed files with 223 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
libslunkcrypt/libSlunkCrypt.vcxproj
View File

@ -44,11 +44,14 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="src\junk.c" /> <ClCompile Include="src\junk.c" />
<ClCompile Include="src\keygen.c" />
<ClCompile Include="src\slunkcrypt.c" /> <ClCompile Include="src\slunkcrypt.c" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="include\slunkcrypt.h" /> <ClInclude Include="include\slunkcrypt.h" />
<ClInclude Include="include\slunkcrypt.hpp" /> <ClInclude Include="include\slunkcrypt.hpp" />
<ClInclude Include="src\compiler.h" />
<ClInclude Include="src\keygen.h" />
<ClInclude Include="src\version.h" /> <ClInclude Include="src\version.h" />
</ItemGroup> </ItemGroup>
<PropertyGroup Label="Globals"> <PropertyGroup Label="Globals">

9
libslunkcrypt/libSlunkCrypt.vcxproj.filters
View File

@ -21,6 +21,9 @@
<ClCompile Include="src\junk.c"> <ClCompile Include="src\junk.c">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="src\keygen.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="include\slunkcrypt.h"> <ClInclude Include="include\slunkcrypt.h">
@ -32,5 +35,11 @@
<ClInclude Include="include\slunkcrypt.hpp"> <ClInclude Include="include\slunkcrypt.hpp">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="src\keygen.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="src\compiler.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>

26
libslunkcrypt/src/compiler.h Normal file
View File

@ -0,0 +1,26 @@
/******************************************************************************/
/* SlunkCrypt, by LoRd_MuldeR <MuldeR2@GMX.de> */
/* This work has been released under the CC0 1.0 Universal license! */
/******************************************************************************/
#ifndef INC_SLUNKCRYPT_COMPILER_H
#define INC_SLUNKCRYPT_COMPILER_H
/* Intel(R) oneAPI DPC++/C++ Compiler */
#if defined(__INTEL_LLVM_COMPILER) && (!defined(__GNUC__))
# define __GNUC__ 9
#endif
/* Compiler compatibility */
#if defined(_MSC_VER) && (!defined(__GNUC__))
# define INLINE __inline
# define UNUSED __pragma(warning(suppress: 4189))
#elif defined(__GNUC__)
# define INLINE __inline__
# define UNUSED __attribute__((unused))
#else
# define INLINE inline
# define UNUSED
#endif
#endif

107
libslunkcrypt/src/junk.c
View File

@ -11,14 +11,18 @@
#endif #endif
/* Internal */ /* Internal */
#include "../include/slunkcrypt.h" #include "slunkcrypt.h"
#include "compiler.h"
/* CRT */ /* CRT */
#include <string.h> #include <string.h>
#include <fcntl.h> #include <fcntl.h>
#include <limits.h> #include <limits.h>
/* Platform compatibility */ // ==========================================================================
// Platform compatibility
// ==========================================================================
#ifdef _WIN32 #ifdef _WIN32
# include <Windows.h> # include <Windows.h>
#else #else
@ -26,11 +30,30 @@
# include <pthread.h> # include <pthread.h>
#endif #endif
/* Compiler compatibility */ /* detect destructor support */
#undef ATTRIB_DESTRUCTOR
#if defined(__GNUC__) || defined(__clang__) #if defined(__GNUC__) || defined(__clang__)
# define HAVE_DESTRUCTOR 1 # define ATTRIB_DESTRUCTOR __attribute__((destructor))
#else #endif
# define HAVE_DESTRUCTOR 0
/* detect getrandom() support */
#undef SYS_GETRANDOM
#if defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 25)
# define SYS_GETRANDOM 1
# include <sys/random.h>
#elif defined(__FreeBSD__) && (__FreeBSD__ >= 12)
# define SYS_GETRANDOM 1
# include <sys/random.h>
#endif
/* detect explicit_bzero() support */
#undef EXPLICIT_BZERO
#if defined(_WIN32) && defined(SecureZeroMemory)
# define EXPLICIT_BZERO SecureZeroMemory
#elif defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 25)
# define EXPLICIT_BZERO explicit_bzero
#elif defined(__FreeBSD__) && (__FreeBSD__ >= 11)
# define EXPLICIT_BZERO explicit_bzero
#endif #endif
// ========================================================================== // ==========================================================================
@ -68,28 +91,13 @@ static void win32_call_once(CALL_ONCE_TYPE *const control, void (*init_routine)(
// Random bytes // Random bytes
// ========================================================================== // ==========================================================================
#ifdef _WIN32
# define HAVE_GETRANDOM 0
#else
# if defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 25)
# define HAVE_GETRANDOM 1
# elif defined(__FreeBSD__) && (__FreeBSD__ >= 12)
# define HAVE_GETRANDOM 1
# else
# define HAVE_GETRANDOM 0
# endif
#endif
#if HAVE_GETRANDOM
# include <sys/random.h>
#endif
/* Global state */ /* Global state */
static CALL_ONCE_TYPE s_random_is_initialized = CALL_ONCE_INIT; static CALL_ONCE_TYPE s_random_is_initialized = CALL_ONCE_INIT;
#if defined(_WIN32) #if defined(_WIN32)
typedef BOOLEAN(WINAPI *rtl_genrandom_t)(void *buffer, ULONG buff_size); typedef BOOLEAN(WINAPI *rtlgenrandom_t)(void *buffer, ULONG buff_size);
static HMODULE s_dll_advapi32 = NULL; static HMODULE s_advapi32 = NULL;
static rtl_genrandom_t s_rtl_genrandom = NULL; static rtlgenrandom_t s_rtlgenrandom = NULL;
#elif !HAVE_GETRANDOM #elif !defined(SYS_GETRANDOM)
static const char *const DEV_RANDOM[] = { "/dev/urandom", "/dev/arandom", "/dev/random", NULL }; static const char *const DEV_RANDOM[] = { "/dev/urandom", "/dev/arandom", "/dev/random", NULL };
static int s_random_fd = -1; static int s_random_fd = -1;
#endif #endif
@ -98,13 +106,13 @@ static int s_random_fd = -1;
static void exit_random_source(void) static void exit_random_source(void)
{ {
#if defined(_WIN32) #if defined(_WIN32)
s_rtl_genrandom = NULL; s_rtlgenrandom = NULL;
if (s_dll_advapi32) if (s_advapi32)
{ {
FreeLibrary(s_dll_advapi32); FreeLibrary(s_advapi32);
s_dll_advapi32 = NULL; s_advapi32 = NULL;
} }
#elif !HAVE_GETRANDOM #elif !defined(SYS_GETRANDOM)
if (s_random_fd >= 0) if (s_random_fd >= 0)
{ {
close(s_random_fd); close(s_random_fd);
@ -117,11 +125,11 @@ static void exit_random_source(void)
static void init_random_source(void) static void init_random_source(void)
{ {
#if defined(_WIN32) #if defined(_WIN32)
if ((s_dll_advapi32 = LoadLibraryW(L"advapi32.dll"))) if ((s_advapi32 = LoadLibraryW(L"advapi32.dll")))
{ {
s_rtl_genrandom = (rtl_genrandom_t)GetProcAddress(s_dll_advapi32, "SystemFunction036"); s_rtlgenrandom = (rtlgenrandom_t) GetProcAddress(s_advapi32, "SystemFunction036");
} }
#elif !HAVE_GETRANDOM #elif !defined(SYS_GETRANDOM)
for (size_t i = 0U; DEV_RANDOM[i]; ++i) for (size_t i = 0U; DEV_RANDOM[i]; ++i)
{ {
if ((s_random_fd = open(DEV_RANDOM[i], O_RDONLY)) >= 0) if ((s_random_fd = open(DEV_RANDOM[i], O_RDONLY)) >= 0)
@ -130,7 +138,7 @@ static void init_random_source(void)
} }
} }
#endif #endif
#if !HAVE_DESTRUCTOR #if !defined(ATTRIB_DESTRUCTOR)
atexit(exit_random_source); atexit(exit_random_source);
#endif #endif
} }
@ -140,12 +148,12 @@ size_t slunkcrypt_random_bytes(uint8_t* const buffer, const size_t length)
{ {
CALL_ONCE(&s_random_is_initialized, init_random_source); CALL_ONCE(&s_random_is_initialized, init_random_source);
#if defined(_WIN32) #if defined(_WIN32)
if (s_rtl_genrandom) if (s_rtlgenrandom)
{ {
const ULONG buff_size = (ULONG)length; const ULONG buff_size = (ULONG)length;
return s_rtl_genrandom(buffer, buff_size) ? buff_size : 0U; return s_rtlgenrandom(buffer, buff_size) ? buff_size : 0U;
} }
#elif HAVE_GETRANDOM #elif defined(SYS_GETRANDOM)
const ssize_t result = getrandom(buffer, length, 0U); const ssize_t result = getrandom(buffer, length, 0U);
return (result < 0) ? 0U : ((size_t)result); return (result < 0) ? 0U : ((size_t)result);
#else #else
@ -162,29 +170,12 @@ size_t slunkcrypt_random_bytes(uint8_t* const buffer, const size_t length)
// Zero memory // Zero memory
// ========================================================================== // ==========================================================================
#ifdef _WIN32
# ifdef SecureZeroMemory
# define HAVE_EXPLICIT_BZERO 1
# define explicit_bzero SecureZeroMemory
# else
# define HAVE_EXPLICIT_BZERO 0
# endif
#else
# if defined(__GLIBC__) && (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 25)
# define HAVE_EXPLICIT_BZERO 1
# elif defined(__FreeBSD__) && (__FreeBSD__ >= 11)
# define HAVE_EXPLICIT_BZERO 1
# else
# define HAVE_EXPLICIT_BZERO 0
# endif
#endif
void slunkcrypt_bzero(void* const buffer, const size_t length) void slunkcrypt_bzero(void* const buffer, const size_t length)
{ {
if ((buffer) && (length > 0U)) if ((buffer) && (length > 0U))
{ {
#if HAVE_EXPLICIT_BZERO #if defined(EXPLICIT_BZERO)
explicit_bzero(buffer, length); EXPLICIT_BZERO(buffer, length);
#else #else
volatile uint8_t* ptr = (volatile uint8_t*) buffer; volatile uint8_t* ptr = (volatile uint8_t*) buffer;
for (size_t i = 0U; i < length; ++i) for (size_t i = 0U; i < length; ++i)
@ -199,8 +190,8 @@ void slunkcrypt_bzero(void* const buffer, const size_t length)
// Destructor // Destructor
// ========================================================================== // ==========================================================================
#if HAVE_DESTRUCTOR #if defined(ATTRIB_DESTRUCTOR)
__attribute__((destructor)) void slunkcrypt_destructor() ATTRIB_DESTRUCTOR void slunkcrypt_destructor()
{ {
exit_random_source(); exit_random_source();
} }

101
libslunkcrypt/src/keygen.c Normal file
View File

@ -0,0 +1,101 @@
/******************************************************************************/
/* SlunkCrypt, by LoRd_MuldeR <MuldeR2@GMX.de> */
/* This work has been released under the CC0 1.0 Universal license! */
/******************************************************************************/
/* Internal */
#include "keygen.h"
#include "compiler.h"
/* CRT */
#include <limits.h>
/* Type */
typedef struct
{
uint64_t hi, lo;
}
uint128_t;
// ==========================================================================
// 128-Bit math support
// ==========================================================================
#define READ_U128(X) ((((__uint128_t)(X).hi) << 64U) | ((__uint128_t)(X).lo))
static INLINE void multiply_u128(uint128_t *const out, const uint128_t lhs, const uint128_t rhs)
{
#if defined(__GNUC__) && defined(__SIZEOF_INT128__)
const __uint128_t tmp = READ_U128(lhs) * READ_U128(rhs);
out->hi = (uint64_t)(tmp >> 64U);
out->lo = (uint64_t)(tmp & 0xFFFFFFFFFFFFFFFF);
#else
const uint64_t lolo = (lhs.lo & 0xFFFFFFFF) * (rhs.lo & 0xFFFFFFFF);
const uint64_t hilo = (lhs.lo >> 32U) * (rhs.lo & 0xFFFFFFFF);
const uint64_t lohi = (lhs.lo & 0xFFFFFFFF) * (rhs.lo >> 32U);
const uint64_t hihi = (lhs.lo >> 32U) * (rhs.lo >> 32U);
const uint64_t crss = (lolo >> 32U) + (hilo & 0xFFFFFFFF) + lohi;
out->hi = (hilo >> 32U) + (crss >> 32) + hihi;
out->lo = (crss << 32U) | (lolo & 0xFFFFFFFF);
out->hi += (lhs.hi * rhs.lo) + (lhs.lo * rhs.hi); /* 128x128=128 */
#endif
}
// ==========================================================================
// Hash function
// ==========================================================================
static const uint128_t HASH_OFFSETBASE_128 = { 0x6C62272E07BB0142, 0x62B821756295C58D };
static const uint128_t HASH_MAGICPRIME_128 = { 0x0000000001000000, 0x000000000000013B };
static INLINE void hash_update_u64(uint128_t* const hash, uint64_t value)
{
size_t i;
for (i = 0U; i < sizeof(uint64_t); ++i, value >>= CHAR_BIT)
{
hash->lo ^= (uint8_t)(value & 0xFF);
multiply_u128(hash, *hash, HASH_MAGICPRIME_128);
}
}
static INLINE void hash_update_str(uint128_t *const hash, const uint8_t *const data, const size_t data_len)
{
size_t i;
for (i = 0U; i < data_len; ++i)
{
hash->lo ^= data[i];
multiply_u128(hash, *hash, HASH_MAGICPRIME_128);
}
}
static INLINE uint128_t hash_code(const uint128_t *const seed, const uint8_t *const data, const size_t data_len)
{
uint128_t hash = HASH_OFFSETBASE_128;
hash_update_u64(&hash, seed->lo);
hash_update_u64(&hash, seed->hi);
hash_update_str(&hash, data, data_len);
return hash;
}
// ==========================================================================
// Key derivation
// ==========================================================================
static INLINE uint64_t keygen_loop(uint64_t seed, const uint64_t i, const uint8_t *const passwd, const size_t passwd_len)
{
uint128_t hash = { seed, i };
size_t u;
for (u = 0U, seed = 0U; u < 99971U; ++u)
{
hash = hash_code(&hash, passwd, passwd_len);
seed ^= hash.hi ^ hash.lo;
}
return seed;
}
void slunkcrypt_keygen(keydata_t *const key, const uint64_t salt, const uint16_t pepper, const uint8_t *const passwd, const size_t passwd_len)
{
key->a = keygen_loop(salt, 0x162603FA1CDA99D3 + (uint64_t)pepper, passwd, passwd_len);
key->b = keygen_loop(salt, 0xBFDEC4A6C1A46E09 + (uint64_t)pepper, passwd, passwd_len);
key->c = keygen_loop(salt, 0x6BA17D11624973EE + (uint64_t)pepper, passwd, passwd_len);
}

20
libslunkcrypt/src/keygen.h Normal file
View File

@ -0,0 +1,20 @@
/******************************************************************************/
/* SlunkCrypt, by LoRd_MuldeR <MuldeR2@GMX.de> */
/* This work has been released under the CC0 1.0 Universal license! */
/******************************************************************************/
#ifndef INC_SLUNKCRYPT_KEYGEN_H
#define INC_SLUNKCRYPT_KEYGEN_H
#include <stdlib.h>
#include <stdint.h>
typedef struct
{
uint64_t a, b, c;
}
keydata_t;
void slunkcrypt_keygen(keydata_t *const key, const uint64_t salt, const uint16_t pepper, const uint8_t* const passwd, const size_t passwd_len);
#endif

141
libslunkcrypt/src/slunkcrypt.c
View File

@ -4,32 +4,16 @@
/******************************************************************************/ /******************************************************************************/
/* Internal */ /* Internal */
#include "../include/slunkcrypt.h" #include "slunkcrypt.h"
#include "compiler.h"
#include "keygen.h"
#include "version.h" #include "version.h"
/* CRT */ /* CRT */
#include <string.h> #include <string.h>
#include <limits.h> #include <limits.h>
#include <assert.h>
/* Intel(R) oneAPI DPC++/C++ Compiler */ /* Version */
#if defined(__INTEL_LLVM_COMPILER) && (!defined(__GNUC__))
# define __GNUC__ 9
#endif
/* Compiler compatibility */
#if defined(_MSC_VER) && (!defined(__GNUC__))
# define INLINE __inline
# define UNUSED __pragma(warning(suppress: 4189))
#elif defined(__GNUC__)
# define INLINE __inline__
# define UNUSED __attribute__((unused))
#else
# define INLINE inline
# define UNUSED
#endif
/* Version info */
const uint16_t SLUNKCRYPT_VERSION_MAJOR = LIB_VERSION_MAJOR; const uint16_t SLUNKCRYPT_VERSION_MAJOR = LIB_VERSION_MAJOR;
const uint16_t SLUNKCRYPT_VERSION_MINOR = LIB_VERSION_MINOR; const uint16_t SLUNKCRYPT_VERSION_MINOR = LIB_VERSION_MINOR;
const uint16_t SLUNKCRYPT_VERSION_PATCH = LIB_VERSION_PATCH; const uint16_t SLUNKCRYPT_VERSION_PATCH = LIB_VERSION_PATCH;
@ -42,12 +26,6 @@ const char *const SLUNKCRYPT_BUILD = __DATE__ ", " __TIME__;
// Data structures // Data structures
// ========================================================================== // ==========================================================================
typedef struct
{
uint64_t hi, lo;
}
uint128_t;
typedef struct typedef struct
{ {
uint32_t x, y, z, w, v, d; uint32_t x, y, z, w, v, d;
@ -92,108 +70,19 @@ static INLINE uint32_t upper_u64(const uint64_t value)
return (uint32_t)(value >> 32U); return (uint32_t)(value >> 32U);
} }
static INLINE uint8_t byte_u64(const uint64_t value, const size_t off)
{
assert(off < sizeof(uint64_t));
return (uint8_t)((value >> (CHAR_BIT * off)) & 0xFF);
}
// ==========================================================================
// 128-Bit math support
// ==========================================================================
#define READ_U128(X) ((((__uint128_t)(X).hi) << 64U) | ((__uint128_t)(X).lo))
static INLINE void multiply_u128(uint128_t *const out, const uint128_t lhs, const uint128_t rhs)
{
#if defined(__GNUC__) && defined(__SIZEOF_INT128__)
const __uint128_t tmp = READ_U128(lhs) * READ_U128(rhs);
out->hi = (uint64_t)(tmp >> 64U);
out->lo = (uint64_t)(tmp & 0xFFFFFFFFFFFFFFFF);
#else
const uint64_t lolo = (lhs.lo & 0xFFFFFFFF) * (rhs.lo & 0xFFFFFFFF);
const uint64_t hilo = (lhs.lo >> 32U) * (rhs.lo & 0xFFFFFFFF);
const uint64_t lohi = (lhs.lo & 0xFFFFFFFF) * (rhs.lo >> 32U);
const uint64_t hihi = (lhs.lo >> 32U) * (rhs.lo >> 32U);
const uint64_t crss = (lolo >> 32U) + (hilo & 0xFFFFFFFF) + lohi;
out->hi = (hilo >> 32U) + (crss >> 32) + hihi;
out->lo = (crss << 32U) | (lolo & 0xFFFFFFFF);
out->hi += (lhs.hi * rhs.lo) + (lhs.lo * rhs.hi); /* 128x128=128 */
#endif
}
// ==========================================================================
// Hash function
// ==========================================================================
static const uint128_t HASH_OFFSETBASE_128 = { 0x6C62272E07BB0142, 0x62B821756295C58D };
static const uint128_t HASH_MAGICPRIME_128 = { 0x0000000001000000, 0x000000000000013B };
static INLINE void hash_update_str(uint128_t *const hash, const uint8_t *const data, const size_t data_len)
{
size_t i;
for (i = 0U; i < data_len; ++i)
{
hash->lo ^= data[i];
multiply_u128(hash, *hash, HASH_MAGICPRIME_128);
}
}
static INLINE void hash_update_u64(uint128_t *const hash, const uint64_t value)
{
size_t i;
for (i = 0U; i < sizeof(uint64_t); ++i)
{
hash->lo ^= byte_u64(value, i);
multiply_u128(hash, *hash, HASH_MAGICPRIME_128);
}
}
static INLINE uint128_t hash_code(const uint128_t *const salt, const uint8_t *const data, const size_t data_len)
{
uint128_t hash = HASH_OFFSETBASE_128;
hash_update_u64(&hash, salt->lo);
hash_update_u64(&hash, salt->hi);
hash_update_str(&hash, data, data_len);
return hash;
}
// ==========================================================================
// Key derivation
// ==========================================================================
static INLINE uint64_t keygen_loop(uint64_t salt, const uint64_t pepper, const uint8_t *const passwd, const size_t passwd_len)
{
uint128_t hash = { salt, pepper };
size_t u;
for (u = 0U, salt = 0U; u < 99971U; ++u)
{
hash = hash_code(&hash, passwd, passwd_len);
salt ^= hash.hi ^ hash.lo;
}
return salt;
}
static INLINE void generate_key(uint64_t *const key, const uint64_t salt, const uint16_t pepper, const uint8_t *const passwd, const size_t passwd_len)
{
key[0U] = keygen_loop(salt, 0x162603FA1CDA99D3 + (uint64_t)pepper, passwd, passwd_len);
key[1U] = keygen_loop(salt, 0xBFDEC4A6C1A46E09 + (uint64_t)pepper, passwd, passwd_len);
key[2U] = keygen_loop(salt, 0x6BA17D11624973EE + (uint64_t)pepper, passwd, passwd_len);
}
// ========================================================================== // ==========================================================================
// Deterministic random bit generator // Deterministic random bit generator
// ========================================================================== // ==========================================================================
static INLINE void random_init(rand_state_t *const state, const uint64_t *const key) static INLINE void random_init(rand_state_t *const state, const keydata_t *const key)
{ {
slunkcrypt_bzero(state, sizeof(rand_state_t)); slunkcrypt_bzero(state, sizeof(rand_state_t));
state->x = lower_u64(key[0U]); state->x = lower_u64(key->a);
state->y = upper_u64(key[0U]); state->y = upper_u64(key->a);
state->z = lower_u64(key[1U]); state->z = lower_u64(key->b);
state->w = upper_u64(key[1U]); state->w = upper_u64(key->b);
state->v = lower_u64(key[2U]); state->v = lower_u64(key->c);
state->d = upper_u64(key[2U]); state->d = upper_u64(key->c);
} }
static INLINE uint32_t random_next(rand_state_t *const state) static INLINE uint32_t random_next(rand_state_t *const state)
@ -210,12 +99,12 @@ static INLINE uint32_t random_next(rand_state_t *const state)
static INLINE void random_seed(rand_state_t *const state, uint64_t salt, const uint16_t pepper, const uint8_t *const passwd, const size_t passwd_len) static INLINE void random_seed(rand_state_t *const state, uint64_t salt, const uint16_t pepper, const uint8_t *const passwd, const size_t passwd_len)
{ {
size_t i; size_t i;
uint64_t key[3U]; keydata_t key;
do do
{ {
generate_key(key, salt++, pepper, passwd, passwd_len); slunkcrypt_keygen(&key, salt++, pepper, passwd, passwd_len);
random_init(state, key); random_init(state, &key);
slunkcrypt_bzero(&key, 3U * sizeof(uint64_t)); slunkcrypt_bzero(&key, sizeof(keydata_t));
} }
while (!(state->x || state->y || state->z || state->w || state->v)); while (!(state->x || state->y || state->z || state->w || state->v));
for (i = 0U; i < 97U; ++i) for (i = 0U; i < 97U; ++i)