wolfSSL/wolfssl
1
0
Fork 1
mirror of https://github.com/wolfSSL/wolfssl.git synced 2025-08-06 06:04:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

Fix RNG issue with Intel RDRAND and RDSEED accelerations not being used because HAVE_HASHDRBG was always being defined if !WOLFSSL_FORCE_RC4_DRBG. Added new --enable-intelrand option to indicate use of RDRAND preference for RNG source (if RDRAND not supported by CPU then HASHDRBG will be used). The --enable-intelasm option enables the RDSEED support for seeding HASHDRBG if CPU supports it. Allow use of seed as RNG source if --disable-hashdbrg (shows build warning). Cleanup to remove old ARC4 RNG support. Fixed random_test return code with !HAVE_HASHDRBG. Cleanup of ./configure --help alignment.

Browse Source
This commit is contained in:
David Garske
2017-03-17 13:29:03 -07:00
parent ccad9f5575
commit 5e3d8e705e
5 changed files with 428 additions and 480 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
configure.ac
View File

@@ -228,7 +228,7 @@ fi
AC_ARG_ENABLE([rng], AC_ARG_ENABLE([rng],
[AS_HELP_STRING([ --enable-rng Enable compiling and using RNG (default: enabled)])], [AS_HELP_STRING([--enable-rng Enable compiling and using RNG (default: enabled)])],
[ ENABLED_RNG=$enableval ], [ ENABLED_RNG=$enableval ],
[ ENABLED_RNG=yes ] [ ENABLED_RNG=yes ]
) )
@@ -612,7 +612,7 @@ fi
AM_CONDITIONAL([BUILD_ARMASM], [test "x$ENABLED_ARMASM" = "xyes"]) AM_CONDITIONAL([BUILD_ARMASM], [test "x$ENABLED_ARMASM" = "xyes"])
# AES-NI # INTEL AES-NI
AC_ARG_ENABLE([aesni], AC_ARG_ENABLE([aesni],
[AS_HELP_STRING([--enable-aesni],[Enable wolfSSL AES-NI support (default: disabled)])], [AS_HELP_STRING([--enable-aesni],[Enable wolfSSL AES-NI support (default: disabled)])],
[ ENABLED_AESNI=$enableval ], [ ENABLED_AESNI=$enableval ],
@@ -626,6 +626,7 @@ AC_ARG_ENABLE([intelasm],
[ ENABLED_INTELASM=no ] [ ENABLED_INTELASM=no ]
) )
if test "$ENABLED_AESNI" = "yes" || test "$ENABLED_INTELASM" = "yes" if test "$ENABLED_AESNI" = "yes" || test "$ENABLED_INTELASM" = "yes"
then then
AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_AESNI" AM_CFLAGS="$AM_CFLAGS -DWOLFSSL_AESNI"
@@ -643,10 +644,22 @@ fi
if test "$ENABLED_INTELASM" = "yes" if test "$ENABLED_INTELASM" = "yes"
then then
AM_CFLAGS="$AM_CFLAGS -DHAVE_INTEL_RDGEN -DUSE_INTEL_SPEEDUP" AM_CFLAGS="$AM_CFLAGS -DHAVE_INTEL_RDSEED -DUSE_INTEL_SPEEDUP"
ENABLED_AESNI=yes ENABLED_AESNI=yes
fi fi
# INTEL RDRAND
AC_ARG_ENABLE([intelrand],
[AS_HELP_STRING([--enable-intelrand],[Enable Intel rdrand as preferred RNG source (default: disabled)])],
[ ENABLED_INTELRDRAND=$enableval ],
[ ENABLED_INTELRDRAND=no ]
)
if test "$ENABLED_INTELRDRAND" = "yes"
then
AM_CFLAGS="$AM_CFLAGS -DHAVE_INTEL_RDRAND"
fi
AM_CONDITIONAL([BUILD_AESNI], [test "x$ENABLED_AESNI" = "xyes"]) AM_CONDITIONAL([BUILD_AESNI], [test "x$ENABLED_AESNI" = "xyes"])
@@ -1678,7 +1691,7 @@ then
AM_CFLAGS="$AM_CFLAGS -DHAVE_HASHDRBG" AM_CFLAGS="$AM_CFLAGS -DHAVE_HASHDRBG"
else else
# turn on Hash DRBG if FIPS is on or ARC4 is off # turn on Hash DRBG if FIPS is on or ARC4 is off
if test "x$ENABLED_FIPS" = "xyes" || test "x$ENABLED_ARC4" = "xno" if test "x$ENABLED_FIPS" = "xyes"
then then
AM_CFLAGS="$AM_CFLAGS -DHAVE_HASHDRBG" AM_CFLAGS="$AM_CFLAGS -DHAVE_HASHDRBG"
ENABLED_HASHDRBG=yes ENABLED_HASHDRBG=yes

593
wolfcrypt/src/random.c
View File

@@ -33,13 +33,6 @@
#include <wolfssl/wolfcrypt/random.h> #include <wolfssl/wolfcrypt/random.h>
#if defined(CUSTOM_RAND_GENERATE) && !defined(CUSTOM_RAND_TYPE)
/* To maintain compatibility the default return value from CUSTOM_RAND_GENERATE is byte */
#define CUSTOM_RAND_TYPE byte
#endif
#define RNG_HEALTH_TEST_CHECK_SIZE (SHA256_DIGEST_SIZE * 4)
#ifdef HAVE_FIPS #ifdef HAVE_FIPS
int wc_GenerateSeed(OS_Seed* os, byte* seed, word32 sz) int wc_GenerateSeed(OS_Seed* os, byte* seed, word32 sz)
@@ -64,14 +57,13 @@ int wc_RNG_GenerateByte(WC_RNG* rng, byte* b)
return RNG_GenerateByte(rng, b); return RNG_GenerateByte(rng, b);
} }
#if defined(HAVE_HASHDRBG) || defined(NO_RC4) #ifdef HAVE_HASHDRBG
int wc_FreeRng(WC_RNG* rng) int wc_FreeRng(WC_RNG* rng)
{ {
return FreeRng_fips(rng); return FreeRng_fips(rng);
} }
int wc_RNG_HealthTest(int reseed, int wc_RNG_HealthTest(int reseed,
const byte* entropyA, word32 entropyASz, const byte* entropyA, word32 entropyASz,
const byte* entropyB, word32 entropyBSz, const byte* entropyB, word32 entropyBSz,
@@ -80,11 +72,15 @@ int wc_RNG_GenerateByte(WC_RNG* rng, byte* b)
return RNG_HealthTest_fips(reseed, entropyA, entropyASz, return RNG_HealthTest_fips(reseed, entropyA, entropyASz,
entropyB, entropyBSz, output, outputSz); entropyB, entropyBSz, output, outputSz);
} }
#endif /* HAVE_HASHDRBG || NO_RC4 */ #endif /* HAVE_HASHDRBG */
#else /* else build without fips */ #else /* else build without fips */
#ifndef WC_NO_RNG /* if not FIPS and RNG is disabled then do not compile */ #ifndef WC_NO_RNG /* if not FIPS and RNG is disabled then do not compile */
#include <wolfssl/wolfcrypt/error-crypt.h> #include <wolfssl/wolfcrypt/error-crypt.h>
/* Allow custom RNG system */ /* Allow custom RNG system */
#ifdef CUSTOM_RAND_GENERATE_BLOCK #ifdef CUSTOM_RAND_GENERATE_BLOCK
@@ -122,36 +118,31 @@ int wc_FreeRng(WC_RNG* rng)
#else #else
/* Use HASHDRGB with SHA256 */ #include <wolfssl/wolfcrypt/sha256.h>
#if defined(HAVE_HASHDRBG) || defined(NO_RC4)
#include <wolfssl/wolfcrypt/sha256.h> #ifdef NO_INLINE
#ifdef NO_INLINE
#include <wolfssl/wolfcrypt/misc.h> #include <wolfssl/wolfcrypt/misc.h>
#else #else
#define WOLFSSL_MISC_INCLUDED #define WOLFSSL_MISC_INCLUDED
#include <wolfcrypt/src/misc.c> #include <wolfcrypt/src/misc.c>
#endif #endif
#endif /* HAVE_HASHDRBG || NO_RC4 */
#if defined(WOLFSSL_SGX) #if defined(WOLFSSL_SGX)
#include <sgx_trts.h> #include <sgx_trts.h>
#elif defined(USE_WINDOWS_API) #elif defined(USE_WINDOWS_API)
#ifndef _WIN32_WINNT #ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0400 #define _WIN32_WINNT 0x0400
#endif #endif
#include <windows.h> #include <windows.h>
#include <wincrypt.h> #include <wincrypt.h>
#else #elif defined(HAVE_WNR)
#ifdef HAVE_WNR
#include <wnr.h> #include <wnr.h>
#include <wolfssl/wolfcrypt/logging.h> #include <wolfssl/wolfcrypt/logging.h>
wolfSSL_Mutex wnr_mutex; /* global netRandom mutex */ wolfSSL_Mutex wnr_mutex; /* global netRandom mutex */
int wnr_timeout = 0; /* entropy timeout, mililseconds */ int wnr_timeout = 0; /* entropy timeout, mililseconds */
int wnr_mutex_init = 0; /* flag for mutex init */ int wnr_mutex_init = 0; /* flag for mutex init */
wnr_context* wnr_ctx; /* global netRandom context */ wnr_context* wnr_ctx; /* global netRandom context */
#elif !defined(NO_DEV_RANDOM) && !defined(CUSTOM_RAND_GENERATE) && \ #elif !defined(NO_DEV_RANDOM) && !defined(CUSTOM_RAND_GENERATE) && \
!defined(WOLFSSL_GENSEED_FORTEST) && !defined(WOLFSSL_MDK_ARM) && \ !defined(WOLFSSL_GENSEED_FORTEST) && !defined(WOLFSSL_MDK_ARM) && \
!defined(WOLFSSL_IAR_ARM) && !defined(WOLFSSL_ROWLEY_ARM) && \ !defined(WOLFSSL_IAR_ARM) && !defined(WOLFSSL_ROWLEY_ARM) && \
!defined(WOLFSSL_EMBOS) !defined(WOLFSSL_EMBOS)
@@ -159,34 +150,33 @@ int wc_FreeRng(WC_RNG* rng)
#ifndef EBSNET #ifndef EBSNET
#include <unistd.h> #include <unistd.h>
#endif #endif
#elif defined(FREESCALE_KSDK_2_0_TRNG) #elif defined(FREESCALE_KSDK_2_0_TRNG)
#include "fsl_trng.h" #include "fsl_trng.h"
#elif defined(FREESCALE_KSDK_2_0_RNGA) #elif defined(FREESCALE_KSDK_2_0_RNGA)
#include "fsl_rnga.h" #include "fsl_rnga.h"
#else #else
/* include headers that may be needed to get good seed */ /* include headers that may be needed to get good seed */
#endif
#endif /* USE_WINDOWS_API */
#ifdef HAVE_INTEL_RDGEN
static int wc_InitRng_IntelRD(void) ;
#if defined(HAVE_HASHDRBG) || defined(NO_RC4)
static int wc_GenerateSeed_IntelRD(OS_Seed* os, byte* output, word32 sz) ;
#else
static int wc_GenerateRand_IntelRD(OS_Seed* os, byte* output, word32 sz) ;
#endif
static word32 cpuid_check = 0 ;
static word32 cpuid_flags = 0 ;
#define CPUID_RDRAND 0x4
#define CPUID_RDSEED 0x8
#define IS_INTEL_RDRAND (cpuid_flags&CPUID_RDRAND)
#define IS_INTEL_RDSEED (cpuid_flags&CPUID_RDSEED)
#endif #endif
#if defined(HAVE_HASHDRBG) || defined(NO_RC4) #if defined(HAVE_INTEL_RDRAND) || defined(HAVE_INTEL_RDSEED)
static void wc_InitRng_IntelRD(void);
#ifdef HAVE_INTEL_RDSEED
static int wc_GenerateSeed_IntelRD(OS_Seed* os, byte* output, word32 sz);
#endif
#ifdef HAVE_INTEL_RDRAND
static int wc_GenerateRand_IntelRD(OS_Seed* os, byte* output, word32 sz);
#endif
static word32 cpuid_check = 0;
static word32 cpuid_flags = 0;
#define CPUID_RDRAND 0x4
#define CPUID_RDSEED 0x8
#define IS_INTEL_RDRAND (cpuid_flags & CPUID_RDRAND)
#define IS_INTEL_RDSEED (cpuid_flags & CPUID_RDSEED)
#endif
/* Start NIST DRBG code */ /* Start NIST DRBG code */
#ifdef HAVE_HASHDRBG
#define OUTPUT_BLOCK_LEN (SHA256_DIGEST_SIZE) #define OUTPUT_BLOCK_LEN (SHA256_DIGEST_SIZE)
#define MAX_REQUEST_LEN (0x10000) #define MAX_REQUEST_LEN (0x10000)
@@ -209,12 +199,13 @@ int wc_FreeRng(WC_RNG* rng)
#define DRBG_FAILED 2 #define DRBG_FAILED 2
#define DRBG_CONT_FAILED 3 #define DRBG_CONT_FAILED 3
#define RNG_HEALTH_TEST_CHECK_SIZE (SHA256_DIGEST_SIZE * 4)
/* Verify max gen block len */ /* Verify max gen block len */
#if RNG_MAX_BLOCK_LEN > MAX_REQUEST_LEN #if RNG_MAX_BLOCK_LEN > MAX_REQUEST_LEN
#error RNG_MAX_BLOCK_LEN is larger than NIST DBRG max request length #error RNG_MAX_BLOCK_LEN is larger than NIST DBRG max request length
#endif #endif
enum { enum {
drbgInitC = 0, drbgInitC = 0,
drbgReseed = 1, drbgReseed = 1,
@@ -295,7 +286,6 @@ static int Hash_df(DRBG* drbg, byte* out, word32 outSz, byte type,
return DRBG_SUCCESS; return DRBG_SUCCESS;
} }
/* Returns: DRBG_SUCCESS or DRBG_FAILURE */ /* Returns: DRBG_SUCCESS or DRBG_FAILURE */
static int Hash_DRBG_Reseed(DRBG* drbg, const byte* entropy, word32 entropySz) static int Hash_DRBG_Reseed(DRBG* drbg, const byte* entropy, word32 entropySz)
{ {
@@ -331,7 +321,6 @@ static INLINE void array_add_one(byte* data, word32 dataSz)
} }
} }
/* Returns: DRBG_SUCCESS or DRBG_FAILURE */ /* Returns: DRBG_SUCCESS or DRBG_FAILURE */
static int Hash_gen(DRBG* drbg, byte* out, word32 outSz, const byte* V) static int Hash_gen(DRBG* drbg, byte* out, word32 outSz, const byte* V)
{ {
@@ -393,7 +382,6 @@ static int Hash_gen(DRBG* drbg, byte* out, word32 outSz, const byte* V)
return DRBG_SUCCESS; return DRBG_SUCCESS;
} }
static INLINE void array_add(byte* d, word32 dLen, const byte* s, word32 sLen) static INLINE void array_add(byte* d, word32 dLen, const byte* s, word32 sLen)
{ {
word16 carry = 0; word16 carry = 0;
@@ -416,7 +404,6 @@ static INLINE void array_add(byte* d, word32 dLen, const byte* s, word32 sLen)
} }
} }
/* Returns: DRBG_SUCCESS, DRBG_NEED_RESEED, or DRBG_FAILURE */ /* Returns: DRBG_SUCCESS, DRBG_NEED_RESEED, or DRBG_FAILURE */
static int Hash_DRBG_Generate(DRBG* drbg, byte* out, word32 outSz) static int Hash_DRBG_Generate(DRBG* drbg, byte* out, word32 outSz)
{ {
@@ -455,7 +442,6 @@ static int Hash_DRBG_Generate(DRBG* drbg, byte* out, word32 outSz)
return ret; return ret;
} }
/* Returns: DRBG_SUCCESS or DRBG_FAILURE */ /* Returns: DRBG_SUCCESS or DRBG_FAILURE */
static int Hash_DRBG_Instantiate(DRBG* drbg, const byte* seed, word32 seedSz, static int Hash_DRBG_Instantiate(DRBG* drbg, const byte* seed, word32 seedSz,
const byte* nonce, word32 nonceSz) const byte* nonce, word32 nonceSz)
@@ -478,7 +464,6 @@ static int Hash_DRBG_Instantiate(DRBG* drbg, const byte* seed, word32 seedSz,
return ret; return ret;
} }
/* Returns: DRBG_SUCCESS or DRBG_FAILURE */ /* Returns: DRBG_SUCCESS or DRBG_FAILURE */
static int Hash_DRBG_Uninstantiate(DRBG* drbg) static int Hash_DRBG_Uninstantiate(DRBG* drbg)
{ {
@@ -493,22 +478,50 @@ static int Hash_DRBG_Uninstantiate(DRBG* drbg)
return (compareSum == 0) ? DRBG_SUCCESS : DRBG_FAILURE; return (compareSum == 0) ? DRBG_SUCCESS : DRBG_FAILURE;
} }
#endif /* HAVE_HASHDRBG */
/* End NIST DRBG Code */ /* End NIST DRBG Code */
/* Get seed and key cipher */
int wc_InitRng_ex(WC_RNG* rng, void* heap) int wc_InitRng_ex(WC_RNG* rng, void* heap)
{ {
int ret = BAD_FUNC_ARG; int ret = RNG_FAILURE_E;
if (rng == NULL)
return BAD_FUNC_ARG;
if (rng != NULL) {
#ifdef WOLFSSL_HEAP_TEST #ifdef WOLFSSL_HEAP_TEST
rng->heap = (void*)WOLFSSL_HEAP_TEST; rng->heap = (void*)WOLFSSL_HEAP_TEST;
(void)heap; (void)heap;
#else #else
rng->heap = heap; rng->heap = heap;
#endif #endif
#ifdef HAVE_HASHDRBG
/* init the DBRG to known values */
rng->drbg = NULL;
rng->status = DRBG_NOT_INIT;
#endif
#if defined(HAVE_INTEL_RDSEED) || defined(HAVE_INTEL_RDRAND)
/* init the intel RD seed and/or rand */
wc_InitRng_IntelRD();
#endif
/* configure async RNG source if available */
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_CAVIUM)
ret = wolfAsync_DevCtxInit(&rng->asyncDev, WOLFSSL_ASYNC_MARKER_RNG, INVALID_DEVID);
if (ret != 0)
return ret;
#endif
#ifdef HAVE_INTEL_RDRAND
/* if CPU supports RDRAND, use it directly and by-pass DRBG init */
if (IS_INTEL_RDRAND)
return 0;
#endif
#ifdef HAVE_HASHDRBG
if (wc_RNG_HealthTestLocal(0) == 0) { if (wc_RNG_HealthTestLocal(0) == 0) {
byte entropy[ENTROPY_NONCE_SZ]; byte entropy[ENTROPY_NONCE_SZ];
@@ -551,7 +564,7 @@ int wc_InitRng_ex(WC_RNG* rng, void* heap)
else { else {
rng->status = DRBG_FAILED; rng->status = DRBG_FAILED;
} }
} #endif /* HAVE_HASHDRBG */
return ret; return ret;
} }
@@ -567,14 +580,28 @@ int wc_RNG_GenerateBlock(WC_RNG* rng, byte* output, word32 sz)
{ {
int ret; int ret;
if (rng == NULL || output == NULL || sz > RNG_MAX_BLOCK_LEN) if (rng == NULL || output == NULL)
return BAD_FUNC_ARG;
#ifdef HAVE_INTEL_RDRAND
if (IS_INTEL_RDRAND)
return wc_GenerateRand_IntelRD(NULL, output, sz);
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_CAVIUM)
if (aes->asyncDev.marker == WOLFSSL_ASYNC_MARKER_RNG) {
return NitroxRngGenerateBlock(rng, output, sz);
}
#endif
#ifdef HAVE_HASHDRBG
if (sz > RNG_MAX_BLOCK_LEN)
return BAD_FUNC_ARG; return BAD_FUNC_ARG;
if (rng->status != DRBG_OK) if (rng->status != DRBG_OK)
return RNG_FAILURE_E; return RNG_FAILURE_E;
ret = Hash_DRBG_Generate(rng->drbg, output, sz); ret = Hash_DRBG_Generate(rng->drbg, output, sz);
if (ret == DRBG_NEED_RESEED) { if (ret == DRBG_NEED_RESEED) {
if (wc_RNG_HealthTestLocal(1) == 0) { if (wc_RNG_HealthTestLocal(1) == 0) {
byte entropy[ENTROPY_SZ]; byte entropy[ENTROPY_SZ];
@@ -607,8 +634,18 @@ int wc_RNG_GenerateBlock(WC_RNG* rng, byte* output, word32 sz)
ret = RNG_FAILURE_E; ret = RNG_FAILURE_E;
rng->status = DRBG_FAILED; rng->status = DRBG_FAILED;
} }
return ret; return ret;
#endif /* HAVE_HASHDRBG */
/* try using the generate seed direectly */
ret = wc_GenerateSeed(&rng->seed, output, sz);
if (ret == 0)
return 0;
/* if we get here then there is an RNG configuration error */
(void)ret;
(void)sz;
return RNG_FAILURE_E;
} }
@@ -620,13 +657,18 @@ int wc_RNG_GenerateByte(WC_RNG* rng, byte* b)
int wc_FreeRng(WC_RNG* rng) int wc_FreeRng(WC_RNG* rng)
{ {
int ret = BAD_FUNC_ARG; int ret = 0;
if (rng != NULL) { if (rng == NULL)
return BAD_FUNC_ARG;
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_CAVIUM)
wolfAsync_DevCtxFree(&rng->asyncDev);
#endif
#ifdef HAVE_HASHDRBG
if (rng->drbg != NULL) { if (rng->drbg != NULL) {
if (Hash_DRBG_Uninstantiate(rng->drbg) == DRBG_SUCCESS) if (Hash_DRBG_Uninstantiate(rng->drbg) != DRBG_SUCCESS)
ret = 0;
else
ret = RNG_FAILURE_E; ret = RNG_FAILURE_E;
XFREE(rng->drbg, rng->heap, DYNAMIC_TYPE_RNG); XFREE(rng->drbg, rng->heap, DYNAMIC_TYPE_RNG);
@@ -634,12 +676,12 @@ int wc_FreeRng(WC_RNG* rng)
} }
rng->status = DRBG_NOT_INIT; rng->status = DRBG_NOT_INIT;
} #endif /* HAVE_HASHDRBG */
return ret; return ret;
} }
#ifdef HAVE_HASHDRBG
int wc_RNG_HealthTest(int reseed, const byte* entropyA, word32 entropyASz, int wc_RNG_HealthTest(int reseed, const byte* entropyA, word32 entropyASz,
const byte* entropyB, word32 entropyBSz, const byte* entropyB, word32 entropyBSz,
byte* output, word32 outputSz) byte* output, word32 outputSz)
@@ -801,97 +843,7 @@ static int wc_RNG_HealthTestLocal(int reseed)
return ret; return ret;
} }
#endif /* HAVE_HASHDRBG */
#else /* HAVE_HASHDRBG || NO_RC4 */
/* Get seed and key cipher */
int wc_InitRng(WC_RNG* rng)
{
int ret;
#ifdef WOLFSSL_SMALL_STACK
byte* key;
byte* junk;
#else
byte key[32];
byte junk[256];
#endif
#ifdef HAVE_INTEL_RDGEN
wc_InitRng_IntelRD();
if(IS_INTEL_RDRAND) return 0;
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_CAVIUM)
ret = wolfAsync_DevCtxInit(&rng->asyncDev, WOLFSSL_ASYNC_MARKER_RNG, INVALID_DEVID);
if (ret != 0) return ret;
#endif
#ifdef WOLFSSL_SMALL_STACK
key = (byte*)XMALLOC(32, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (key == NULL)
return MEMORY_E;
junk = (byte*)XMALLOC(256, NULL, DYNAMIC_TYPE_TMP_BUFFER);
if (junk == NULL) {
XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER);
key = NULL;
return MEMORY_E;
}
#endif
ret = wc_GenerateSeed(&rng->seed, key, 32);
if (ret == 0) {
wc_Arc4SetKey(&rng->cipher, key, sizeof(key));
ret = wc_RNG_GenerateBlock(rng, junk, 256); /*rid initial state*/
}
#ifdef WOLFSSL_SMALL_STACK
XFREE(key, NULL, DYNAMIC_TYPE_TMP_BUFFER);
XFREE(junk, NULL, DYNAMIC_TYPE_TMP_BUFFER);
#endif
return ret;
}
/* place a generated block in output */
int wc_RNG_GenerateBlock(WC_RNG* rng, byte* output, word32 sz)
{
#ifdef HAVE_INTEL_RDGEN
if(IS_INTEL_RDRAND)
return wc_GenerateRand_IntelRD(NULL, output, sz) ;
#endif
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_CAVIUM)
if (aes->asyncDev.marker == WOLFSSL_ASYNC_MARKER_RNG) {
return NitroxRngGenerateBlock(rng, output, sz);
}
#endif
XMEMSET(output, 0, sz);
wc_Arc4Process(&rng->cipher, output, output, sz);
return 0;
}
int wc_RNG_GenerateByte(WC_RNG* rng, byte* b)
{
return wc_RNG_GenerateBlock(rng, b, 1);
}
int wc_FreeRng(WC_RNG* rng)
{
(void)rng;
#if defined(WOLFSSL_ASYNC_CRYPT) && defined(HAVE_CAVIUM)
wolfAsync_DevCtxFree(&rng->asyncDev);
#endif
return 0;
}
#endif /* HAVE_HASHDRBG || NO_RC4 */
#ifdef HAVE_WNR #ifdef HAVE_WNR
@@ -992,7 +944,7 @@ int wc_FreeNetRandom(void)
#endif /* HAVE_WNR */ #endif /* HAVE_WNR */
#if defined(HAVE_INTEL_RDGEN) #if defined(HAVE_INTEL_RDRAND) || defined(HAVE_INTEL_RDSEED)
#ifndef _MSC_VER #ifndef _MSC_VER
#define cpuid(reg, leaf, sub)\ #define cpuid(reg, leaf, sub)\
@@ -1016,36 +968,35 @@ int wc_FreeNetRandom(void)
#define EDX 3 #define EDX 3
static word32 cpuid_flag(word32 leaf, word32 sub, word32 num, word32 bit) { static word32 cpuid_flag(word32 leaf, word32 sub, word32 num, word32 bit) {
int got_intel_cpu=0; int got_intel_cpu = 0;
unsigned int reg[5]; unsigned int reg[5];
reg[4] = '\0' ; reg[4] = '\0';
cpuid(reg, 0, 0); cpuid(reg, 0, 0);
if(XMEMCMP((char *)&(reg[EBX]), "Genu", 4) == 0 && if (XMEMCMP((char *)&(reg[EBX]), "Genu", 4) == 0 &&
XMEMCMP((char *)&(reg[EDX]), "ineI", 4) == 0 && XMEMCMP((char *)&(reg[EDX]), "ineI", 4) == 0 &&
XMEMCMP((char *)&(reg[ECX]), "ntel", 4) == 0) { XMEMCMP((char *)&(reg[ECX]), "ntel", 4) == 0)
{
got_intel_cpu = 1; got_intel_cpu = 1;
} }
if (got_intel_cpu) { if (got_intel_cpu) {
cpuid(reg, leaf, sub); cpuid(reg, leaf, sub);
return((reg[num]>>bit)&0x1) ; return ((reg[num] >> bit) & 0x1);
} }
return 0 ; return 0;
} }
static int wc_InitRng_IntelRD() static void wc_InitRng_IntelRD(void) {
{ if (cpuid_check==0) {
if(cpuid_check==0) { if (cpuid_flag(1, 0, ECX, 30)) { cpuid_flags |= CPUID_RDRAND; }
if(cpuid_flag(1, 0, ECX, 30)){ cpuid_flags |= CPUID_RDRAND ;} if (cpuid_flag(7, 0, EBX, 18)) { cpuid_flags |= CPUID_RDSEED; }
if(cpuid_flag(7, 0, EBX, 18)){ cpuid_flags |= CPUID_RDSEED ;} cpuid_check = 1;
cpuid_check = 1 ;
} }
return 1 ;
} }
#define INTELRD_RETRY 32 #define INTELRD_RETRY 32
#if defined(HAVE_HASHDRBG) || defined(NO_RC4) #ifdef HAVE_INTEL_RDSEED
/* return 0 on success */ /* return 0 on success */
static INLINE int IntelRDseed64(word64* seed) static INLINE int IntelRDseed64(word64* seed)
@@ -1053,97 +1004,110 @@ static INLINE int IntelRDseed64(word64* seed)
unsigned char ok; unsigned char ok;
__asm__ volatile("rdseed %0; setc %1":"=r"(*seed), "=qm"(ok)); __asm__ volatile("rdseed %0; setc %1":"=r"(*seed), "=qm"(ok));
if(ok){ return (ok) ? 0 : -1;
return 0 ;
} else
return 1;
} }
/* return 0 on success */ /* return 0 on success */
static INLINE int IntelRDseed64_r(word64* rnd) static INLINE int IntelRDseed64_r(word64* rnd)
{ {
int i; int i;
for(i=0; i<INTELRD_RETRY;i++) { for (i = 0; i < INTELRD_RETRY; i++) {
if(IntelRDseed64(rnd) == 0) return 0 ; if (IntelRDseed64(rnd) == 0)
return 0;
} }
return 1 ; return -1;
} }
/* return 0 on success */ /* return 0 on success */
static int wc_GenerateSeed_IntelRD(OS_Seed* os, byte* output, word32 sz) static int wc_GenerateSeed_IntelRD(OS_Seed* os, byte* output, word32 sz)
{ {
(void) os ; int ret;
int ret ; word64 rndTmp;
word64 rndTmp ;
for( ; sz/8 > 0; sz-=8, output+=8) { (void)os;
if(IS_INTEL_RDSEED)ret = IntelRDseed64_r((word64*)output);
else return 1 ; if (!IS_INTEL_RDSEED)
if(ret) return -1;
return 1 ;
for (; (sz / sizeof(word64)) > 0; sz -= sizeof(word64),
output += sizeof(word64)) {
ret = IntelRDseed64_r((word64*)output);
if (ret != 0)
return ret;
} }
if(sz == 0)return 0 ; if (sz == 0)
return 0;
/* handle unaligned remainder */
ret = IntelRDseed64_r(&rndTmp);
if (ret != 0)
return ret;
XMEMCPY(output, &rndTmp, sz);
if(IS_INTEL_RDSEED)ret = IntelRDseed64_r(&rndTmp) ;
else return 1 ;
if(ret)
return 1 ;
XMEMCPY(output, &rndTmp, sz) ;
return 0; return 0;
} }
#else /* HAVE_HASHDRBG || NO_RC4 */ #endif /* HAVE_INTEL_RDSEED */
#ifdef HAVE_INTEL_RDRAND
/* return 0 on success */ /* return 0 on success */
static INLINE int IntelRDrand32(unsigned int *rnd) static INLINE int IntelRDrand32(unsigned int *rnd)
{ {
int rdrand; unsigned char ok ; unsigned char ok;
__asm__ volatile("rdrand %0; setc %1":"=r"(rdrand), "=qm"(ok));
if(ok){ __asm__ volatile("rdrand %0; setc %1":"=r"(*rnd), "=qm"(ok));
*rnd = rdrand;
return 0 ; return (ok) ? 0 : -1;
} else
return 1;
} }
/* return 0 on success */ /* return 0 on success */
static INLINE int IntelRDrand32_r(unsigned int *rnd) static INLINE int IntelRDrand32_r(unsigned int *rnd)
{ {
int i ; int i;
for(i=0; i<INTELRD_RETRY;i++) { for (i = 0; i < INTELRD_RETRY; i++) {
if(IntelRDrand32(rnd) == 0) return 0 ; if (IntelRDrand32(rnd) == 0)
return 0;
} }
return 1 ; return -1;
} }
/* return 0 on success */ /* return 0 on success */
static int wc_GenerateRand_IntelRD(OS_Seed* os, byte* output, word32 sz) static int wc_GenerateRand_IntelRD(OS_Seed* os, byte* output, word32 sz)
{ {
(void) os ; int ret;
int ret ;
unsigned int rndTmp; unsigned int rndTmp;
for( ; sz/4 > 0; sz-=4, output+=4) { (void)os;
if(IS_INTEL_RDRAND)ret = IntelRDrand32_r((word32 *)output);
else return 1 ; if (!IS_INTEL_RDRAND)
if(ret) return -1;
return 1 ;
} for (; (sz / sizeof(word32)) > 0; sz -= sizeof(word32),
if(sz == 0)return 0 ; output += sizeof(word32)) {
ret = IntelRDrand32_r((word32 *)output);
if (ret != 0)
return ret;
}
if (sz == 0)
return 0;
/* handle unaligned remainder */
ret = IntelRDrand32_r(&rndTmp);
if (ret != 0)
return ret;
XMEMCPY(output, &rndTmp, sz);
if(IS_INTEL_RDRAND)ret = IntelRDrand32_r(&rndTmp);
else return 1 ;
if(ret)
return 1 ;
XMEMCPY(output, &rndTmp, sz) ;
return 0; return 0;
} }
#endif /* defined(HAVE_HASHDRBG) || defined(NO_RC4) */
#endif /* HAVE_INTEL_RDGEN */ #endif /* HAVE_INTEL_RDRAND */
#endif /* HAVE_INTEL_RDRAND || HAVE_INTEL_RDSEED */
/* wc_GenerateSeed Implementations */ /* Begin wc_GenerateSeed Implementations */
#if defined(CUSTOM_RAND_GENERATE_SEED) #if defined(CUSTOM_RAND_GENERATE_SEED)
/* Implement your own random generation function /* Implement your own random generation function
@@ -1170,7 +1134,6 @@ static int wc_GenerateRand_IntelRD(OS_Seed* os, byte* output, word32 sz)
return CUSTOM_RAND_GENERATE_SEED_OS(os, output, sz); return CUSTOM_RAND_GENERATE_SEED_OS(os, output, sz);
} }
#elif defined(CUSTOM_RAND_GENERATE) #elif defined(CUSTOM_RAND_GENERATE)
/* Implement your own random generation function /* Implement your own random generation function
@@ -1267,49 +1230,50 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
#elif defined(MICROCHIP_PIC32) #elif defined(MICROCHIP_PIC32)
#ifdef MICROCHIP_MPLAB_HARMONY #ifdef MICROCHIP_MPLAB_HARMONY
#define PIC32_SEED_COUNT _CP0_GET_COUNT #define PIC32_SEED_COUNT _CP0_GET_COUNT
#else #else
#if !defined(WOLFSSL_MICROCHIP_PIC32MZ) #if !defined(WOLFSSL_MICROCHIP_PIC32MZ)
#include <peripheral/timer.h> #include <peripheral/timer.h>
#endif #endif
#define PIC32_SEED_COUNT ReadCoreTimer #define PIC32_SEED_COUNT ReadCoreTimer
#endif #endif
#ifdef WOLFSSL_MIC32MZ_RNG #ifdef WOLFSSL_MIC32MZ_RNG
#include "xc.h" #include "xc.h"
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz) int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{ {
int i ; int i;
byte rnd[8] ; byte rnd[8];
word32 *rnd32 = (word32 *)rnd ; word32 *rnd32 = (word32 *)rnd;
word32 size = sz ; word32 size = sz;
byte* op = output ; byte* op = output;
/* This part has to be replaced with better random seed */ /* This part has to be replaced with better random seed */
RNGNUMGEN1 = ReadCoreTimer(); RNGNUMGEN1 = ReadCoreTimer();
RNGPOLY1 = ReadCoreTimer(); RNGPOLY1 = ReadCoreTimer();
RNGPOLY2 = ReadCoreTimer(); RNGPOLY2 = ReadCoreTimer();
RNGNUMGEN2 = ReadCoreTimer(); RNGNUMGEN2 = ReadCoreTimer();
#ifdef DEBUG_WOLFSSL #ifdef DEBUG_WOLFSSL
printf("GenerateSeed::Seed=%08x, %08x\n", RNGNUMGEN1, RNGNUMGEN2) ; printf("GenerateSeed::Seed=%08x, %08x\n", RNGNUMGEN1, RNGNUMGEN2);
#endif #endif
RNGCONbits.PLEN = 0x40; RNGCONbits.PLEN = 0x40;
RNGCONbits.PRNGEN = 1; RNGCONbits.PRNGEN = 1;
for(i=0; i<5; i++) { /* wait for RNGNUMGEN ready */ for(i=0; i<5; i++) { /* wait for RNGNUMGEN ready */
volatile int x ; volatile int x;
x = RNGNUMGEN1 ; x = RNGNUMGEN1;
x = RNGNUMGEN2 ; x = RNGNUMGEN2;
} }
do { do {
rnd32[0] = RNGNUMGEN1; rnd32[0] = RNGNUMGEN1;
rnd32[1] = RNGNUMGEN2; rnd32[1] = RNGNUMGEN2;
for(i=0; i<8; i++, op++) { for(i=0; i<8; i++, op++) {
*op = rnd[i] ; *op = rnd[i];
size -- ; size --;
if(size==0)break ; if(size==0)break;
} }
} while(size) ; } while(size);
return 0; return 0;
} }
#else /* WOLFSSL_MIC32MZ_RNG */ #else /* WOLFSSL_MIC32MZ_RNG */
@@ -1451,46 +1415,15 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
} }
#else #else
#warning "write a real random seed!!!!, just for testing now" #define USE_TEST_GENSEED
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
int i;
for (i = 0; i < sz; i++ )
output[i] = i;
return 0;
}
#endif /* FREESCALE_K70_RNGA */ #endif /* FREESCALE_K70_RNGA */
#elif defined(WOLFSSL_SAFERTOS) || defined(WOLFSSL_LEANPSK) \
|| defined(WOLFSSL_IAR_ARM) || defined(WOLFSSL_MDK_ARM) \
|| defined(WOLFSSL_uITRON4) || defined(WOLFSSL_uTKERNEL2)\
|| defined(WOLFSSL_GENSEED_FORTEST)
#ifndef _MSC_VER
#warning "write a real random seed!!!!, just for testing now"
#else
#pragma message("Warning: write a real random seed!!!!, just for testing now")
#endif
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
word32 i;
for (i = 0; i < sz; i++ )
output[i] = i;
(void)os;
return 0;
}
#elif defined(STM32F2_RNG) || defined(STM32F4_RNG) #elif defined(STM32F2_RNG) || defined(STM32F4_RNG)
/* /*
* wc_Generate a RNG seed using the hardware random number generator * wc_Generate a RNG seed using the hardware random number generator
* on the STM32F2/F4. */ * on the STM32F2/F4. */
#ifdef WOLFSSL_STM32_CUBEMX #ifdef WOLFSSL_STM32_CUBEMX
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz) int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{ {
RNG_HandleTypeDef hrng; RNG_HandleTypeDef hrng;
@@ -1511,7 +1444,7 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
return 0; return 0;
} }
#else #else
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz) int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{ {
int i; int i;
@@ -1533,22 +1466,7 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
return 0; return 0;
} }
#endif /* WOLFSSL_STM32_CUBEMX */ #endif /* WOLFSSL_STM32_CUBEMX */
#elif defined(WOLFSSL_LPC43xx) || defined(WOLFSSL_STM32F2xx) || defined(MBED) \
|| defined(WOLFSSL_EMBOS)
#warning "write a real random seed!!!!, just for testing now"
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
int i;
for (i = 0; i < sz; i++ )
output[i] = i;
return 0;
}
#elif defined(WOLFSSL_TIRTOS) #elif defined(WOLFSSL_TIRTOS)
@@ -1693,58 +1611,66 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
return ret; return ret;
} }
#elif defined(NO_DEV_RANDOM)
#error "you need to write an os specific wc_GenerateSeed() here"
/*
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
return 0;
}
*/
#elif defined(IDIRECT_DEV_RANDOM) #elif defined(IDIRECT_DEV_RANDOM)
extern int getRandom( int sz, unsigned char *output ); extern int getRandom( int sz, unsigned char *output );
int GenerateSeed(OS_Seed* os, byte* output, word32 sz) int GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{ {
int num_bytes_returned = 0; int num_bytes_returned = 0;
num_bytes_returned = getRandom( (int) sz, (unsigned char *) output ); num_bytes_returned = getRandom( (int) sz, (unsigned char *) output );
return 0; return 0;
} }
#elif defined(WOLFSSL_SAFERTOS) || defined(WOLFSSL_LEANPSK) \
|| defined(WOLFSSL_IAR_ARM) || defined(WOLFSSL_MDK_ARM) \
|| defined(WOLFSSL_uITRON4) || defined(WOLFSSL_uTKERNEL2) \
|| defined(WOLFSSL_LPC43xx) || defined(WOLFSSL_STM32F2xx) \
|| defined(MBED) || defined(WOLFSSL_EMBOS) \
|| defined(WOLFSSL_GENSEED_FORTEST)
#else /* !USE_WINDOWS_API && !HAVE_RPT_SYS && !MICRIUM && !NO_DEV_RANDOM */ /* these platforms do not have a default random seed and
you need to implement your own wc_GenerateSeed */
/* may block */ #define USE_TEST_GENSEED
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{ #elif defined(NO_DEV_RANDOM)
#error "you need to write an os specific wc_GenerateSeed() here"
/*
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
return 0;
}
*/
#else
/* may block */
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
int ret = 0; int ret = 0;
#ifdef HAVE_INTEL_RDSEED
#if defined(HAVE_INTEL_RDGEN) && (defined(HAVE_HASHDRBG) || defined(NO_RC4)) if (IS_INTEL_RDSEED) {
wc_InitRng_IntelRD() ; /* set cpuid_flags if not yet */
if(IS_INTEL_RDSEED) {
ret = wc_GenerateSeed_IntelRD(NULL, output, sz); ret = wc_GenerateSeed_IntelRD(NULL, output, sz);
if (ret == 0) { if (ret == 0) {
/* success, we're done */ /* success, we're done */
return ret; return ret;
} }
#ifdef FORCE_FAILURE_RDSEED #ifdef FORCE_FAILURE_RDSEED
/* don't fallback to /dev/urandom */ /* don't fallback to /dev/urandom */
return ret; return ret;
#else #else
/* fallback to /dev/urandom attempt */ /* fallback to /dev/urandom attempt */
ret = 0; ret = 0;
#endif #endif
} }
#endif #endif /* HAVE_INTEL_RDSEED */
os->fd = open("/dev/urandom",O_RDONLY); os->fd = open("/dev/urandom",O_RDONLY);
if (os->fd == -1) { if (os->fd == -1) {
@@ -1765,21 +1691,42 @@ int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
output += len; output += len;
if (sz) { if (sz) {
#ifdef BLOCKING #ifdef BLOCKING
sleep(0); /* context switch */ sleep(0); /* context switch */
#else #else
ret = RAN_BLOCK_E; ret = RAN_BLOCK_E;
break; break;
#endif #endif
} }
} }
close(os->fd); close(os->fd);
return ret; return ret;
} }
#endif
#ifdef USE_TEST_GENSEED
#ifndef _MSC_VER
#warning "write a real random seed!!!!, just for testing now"
#else
#pragma message("Warning: write a real random seed!!!!, just for testing now")
#endif
int wc_GenerateSeed(OS_Seed* os, byte* output, word32 sz)
{
word32 i;
for (i = 0; i < sz; i++ )
output[i] = i;
(void)os;
return 0;
}
#endif
/* End wc_GenerateSeed */
#endif /* USE_WINDOWS_API */
#endif /* CUSTOM_RAND_GENERATE_BLOCK */ #endif /* CUSTOM_RAND_GENERATE_BLOCK */
#endif /* WC_NO_RNG */ #endif /* WC_NO_RNG */
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */

10
wolfcrypt/test/test.c
View File

@@ -5047,7 +5047,7 @@ exit:
return ret; return ret;
} }
#if (defined(HAVE_HASHDRBG) || defined(NO_RC4)) && !defined(CUSTOM_RAND_GENERATE_BLOCK) #if defined(HAVE_HASHDRBG) && !defined(CUSTOM_RAND_GENERATE_BLOCK)
int random_test(void) int random_test(void)
{ {
@@ -5126,17 +5126,15 @@ int random_test(void)
return 0; return 0;
} }
#else /* (HAVE_HASHDRBG || NO_RC4) && !CUSTOM_RAND_GENERATE_BLOCK */ #else
int random_test(void) int random_test(void)
{ {
/* Basic RNG generate block test */ /* Basic RNG generate block test */
random_rng_test(); return random_rng_test();
return 0;
} }
#endif /* (HAVE_HASHDRBG || NO_RC4) && !CUSTOM_RAND_GENERATE_BLOCK */ #endif /* HAVE_HASHDRBG && !CUSTOM_RAND_GENERATE_BLOCK */
#endif /* WC_NO_RNG */ #endif /* WC_NO_RNG */

70
wolfssl/wolfcrypt/random.h
View File

@@ -36,43 +36,59 @@
#endif #endif
/* Maximum generate block length */ /* Maximum generate block length */
#define RNG_MAX_BLOCK_LEN (0x10000) #ifndef RNG_MAX_BLOCK_LEN
#define RNG_MAX_BLOCK_LEN (0x10000)
#endif
#if defined(CUSTOM_RAND_GENERATE) && !defined(CUSTOM_RAND_TYPE)
/* To maintain compatibility the default is byte */
#define CUSTOM_RAND_TYPE byte
#endif
#ifndef HAVE_FIPS /* avoid redefining structs and macros */ #ifndef HAVE_FIPS /* avoid redefining structs and macros */
#if defined(WOLFSSL_FORCE_RC4_DRBG) && defined(NO_RC4)
#error Cannot have WOLFSSL_FORCE_RC4_DRBG and NO_RC4 defined.
#endif /* WOLFSSL_FORCE_RC4_DRBG && NO_RC4 */
/* RNG supports the following sources (in order): /* RNG supports the following sources (in order):
* 1. CUSTOM_RAND_GENERATE_BLOCK: Defines name of function as RNG source and * 1. CUSTOM_RAND_GENERATE_BLOCK: Defines name of function as RNG source and
* bypasses the P-RNG. * bypasses the options below.
* 2. HAVE_HASHDRBG && !NO_SHA256 (SHA256 enabled): Uses SHA256 based P-RNG * 2. HAVE_INTEL_RDRAND: Uses the Intel RDRAND if supported by CPU.
* 3. HAVE_HASHDRBG (requires SHA256 enabled): Uses SHA256 based P-RNG
* seeded via wc_GenerateSeed. This is the default source. * seeded via wc_GenerateSeed. This is the default source.
* 3. !NO_RC4 (RC4 enabled): Uses RC4 * 4. Fallback to using wc_GenerateSeed directly.
*/ */
/* Seed source can be overriden by defining one of these:
CUSTOM_RAND_GENERATE_SEED
CUSTOM_RAND_GENERATE_SEED_OS
CUSTOM_RAND_GENERATE */
#if defined(CUSTOM_RAND_GENERATE_BLOCK) #if defined(CUSTOM_RAND_GENERATE_BLOCK)
/* To use define the following: /* To use define the following:
* #define CUSTOM_RAND_GENERATE_BLOCK myRngFunc * #define CUSTOM_RAND_GENERATE_BLOCK myRngFunc
* extern int myRngFunc(byte* output, word32 sz); * extern int myRngFunc(byte* output, word32 sz);
*/ */
#elif (defined(HAVE_HASHDRBG) || defined(NO_RC4)) #elif defined(HAVE_HASHDRBG)
#ifdef NO_SHA256 #ifdef NO_SHA256
#error "Hash DRBG requires SHA-256." #error "Hash DRBG requires SHA-256."
#endif /* NO_SHA256 */ #endif /* NO_SHA256 */
#include <wolfssl/wolfcrypt/sha256.h> #include <wolfssl/wolfcrypt/sha256.h>
#elif defined(HAVE_INTEL_RDRAND)
#elif defined(HAVE_WNR)
#else #else
#include <wolfssl/wolfcrypt/arc4.h> #warning No RNG source defined. Using wc_GenerateSeed directly
#endif #endif
#ifdef HAVE_WNR #ifdef HAVE_WNR
#include <wnr.h> #include <wnr.h>
#endif #endif
#ifdef WOLFSSL_ASYNC_CRYPT
#include <wolfssl/wolfcrypt/async.h>
#endif
#if defined(USE_WINDOWS_API) #if defined(USE_WINDOWS_API)
#if defined(_WIN64) #if defined(_WIN64)
typedef unsigned __int64 ProviderHandle; typedef unsigned __int64 ProviderHandle;
@@ -98,46 +114,26 @@ typedef struct OS_Seed {
#define WC_RNG_TYPE_DEFINED #define WC_RNG_TYPE_DEFINED
#endif #endif
#if (defined(HAVE_HASHDRBG) || defined(NO_RC4)) && !defined(CUSTOM_RAND_GENERATE_BLOCK) #ifndef CUSTOM_RAND_GENERATE_BLOCK
#define DRBG_SEED_LEN (440/8) #define DRBG_SEED_LEN (440/8)
struct DRBG; /* Private DRBG state */ struct DRBG; /* Private DRBG state */
/* Hash-based Deterministic Random Bit Generator */ /* Hash-based Deterministic Random Bit Generator */
struct WC_RNG { struct WC_RNG {
#ifdef HAVE_HASHDRBG
struct DRBG* drbg; struct DRBG* drbg;
byte status;
#endif
OS_Seed seed; OS_Seed seed;
void* heap; void* heap;
byte status;
};
#else /* (HAVE_HASHDRBG || NO_RC4) && !CUSTOM_RAND_GENERATE_BLOCK */
#ifdef WOLFSSL_ASYNC_CRYPT
#include <wolfssl/wolfcrypt/async.h>
#endif
/* secure Random Number Generator */
struct WC_RNG {
OS_Seed seed;
#ifndef NO_RC4
Arc4 cipher;
#endif
#ifdef WOLFSSL_ASYNC_CRYPT #ifdef WOLFSSL_ASYNC_CRYPT
AsyncCryptDev asyncDev; AsyncCryptDev asyncDev;
#endif #endif
}; };
#endif /* !CUSTOM_RAND_GENERATE_BLOCK */
#endif /* (HAVE_HASHDRBG || NO_RC4) && !CUSTOM_RAND_GENERATE_BLOCK */
#endif /* HAVE_FIPS */ #endif /* HAVE_FIPS */
/* NO_OLD_RNGNAME removes RNG struct name to prevent possible type conflicts, /* NO_OLD_RNGNAME removes RNG struct name to prevent possible type conflicts,

6
wolfssl/wolfcrypt/settings.h
View File

@@ -1405,12 +1405,6 @@ extern void uITRON4_free(void *p) ;
#define WOLFSSL_MIN_AUTH_TAG_SZ 12 #define WOLFSSL_MIN_AUTH_TAG_SZ 12
#endif #endif
/* If not forcing ARC4 as the DRBG or using custom RNG block gen, enable Hash_DRBG */
#undef HAVE_HASHDRBG
#if !defined(WOLFSSL_FORCE_RC4_DRBG) && !defined(CUSTOM_RAND_GENERATE_BLOCK)
#define HAVE_HASHDRBG
#endif
/* sniffer requires: /* sniffer requires:
* static RSA cipher suites * static RSA cipher suites