11 #if CRYPTOPP_MSC_VERSION 12 # pragma warning(disable: 4100) 41 #define NASM_RDRAND_ASM_AVAILABLE 1 42 #define NASM_RDSEED_ASM_AVAILABLE 1 52 #ifndef CRYPTOPP_CPUID_AVAILABLE 53 # if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 54 # define CRYPTOPP_CPUID_AVAILABLE 58 #if defined(CRYPTOPP_CPUID_AVAILABLE) && !defined(CRYPTOPP_BOOL_RDRAND_ASM) 59 # define CRYPTOPP_BOOL_RDRAND_ASM 1 61 # define CRYPTOPP_BOOL_RDRAND_ASM 0 63 #if defined(CRYPTOPP_CPUID_AVAILABLE) && !defined(CRYPTOPP_BOOL_RDSEED_ASM) 64 # define CRYPTOPP_BOOL_RDSEED_ASM 1 66 # define CRYPTOPP_BOOL_RDSEED_ASM 0 69 #if defined(CRYPTOPP_CPUID_AVAILABLE) 70 # define MSC_INTRIN_COMPILER ((CRYPTOPP_MSC_VERSION >= 1700) || (CRYPTOPP_CLANG_VERSION >= 30200) || (_INTEL_COMPILER >= 1210)) 71 # define GCC_INTRIN_COMPILER ((CRYPTOPP_GCC_VERSION >= 40600) || (CRYPTOPP_CLANG_VERSION >= 30200) || (_INTEL_COMPILER >= 1210)) 73 # define MSC_INTRIN_COMPILER 0 74 # define GCC_INTRIN_COMPILER 0 80 #if defined(CRYPTOPP_CPUID_AVAILABLE) && (CRYPTOPP_MSC_VERSION >= 1200) 81 # if CRYPTOPP_BOOL_RDRAND_ASM 82 # define MASM_RDRAND_ASM_AVAILABLE 1 83 # elif MSC_INTRIN_COMPILER 84 # define ALL_RDRAND_INTRIN_AVAILABLE 1 86 # if CRYPTOPP_BOOL_RDSEED_ASM 87 # define MASM_RDSEED_ASM_AVAILABLE 1 88 # elif MSC_INTRIN_COMPILER 89 # define ALL_RDSEED_INTRIN_AVAILABLE 1 91 #elif defined(CRYPTOPP_CPUID_AVAILABLE) && (CRYPTOPP_GCC_VERSION >= 30200) 92 # if GCC_INTRIN_COMPILER && defined(__RDRND__) 93 # define ALL_RDRAND_INTRIN_AVAILABLE 1 94 # elif CRYPTOPP_BOOL_RDRAND_ASM 95 # define GCC_RDRAND_ASM_AVAILABLE 1 97 # if GCC_INTRIN_COMPILER && defined(__RDSEED__) 98 # define ALL_RDSEED_INTRIN_AVAILABLE 1 99 # elif CRYPTOPP_BOOL_RDSEED_ASM 100 # define GCC_RDSEED_ASM_AVAILABLE 1 106 # if MASM_RDRAND_ASM_AVAILABLE 107 # pragma message ("MASM_RDRAND_ASM_AVAILABLE is 1") 108 # elif NASM_RDRAND_ASM_AVAILABLE 109 # pragma message ("NASM_RDRAND_ASM_AVAILABLE is 1") 110 # elif GCC_RDRAND_ASM_AVAILABLE 111 # pragma message ("GCC_RDRAND_ASM_AVAILABLE is 1") 112 # elif ALL_RDRAND_INTRIN_AVAILABLE 113 # pragma message ("ALL_RDRAND_INTRIN_AVAILABLE is 1") 115 # pragma message ("RDRAND is not available") 117 # if MASM_RDSEED_ASM_AVAILABLE 118 # pragma message ("MASM_RDSEED_ASM_AVAILABLE is 1") 119 # elif NASM_RDSEED_ASM_AVAILABLE 120 # pragma message ("NASM_RDSEED_ASM_AVAILABLE is 1") 121 # elif GCC_RDSEED_ASM_AVAILABLE 122 # pragma message ("GCC_RDSEED_ASM_AVAILABLE is 1") 123 # elif ALL_RDSEED_INTRIN_AVAILABLE 124 # pragma message ("ALL_RDSEED_INTRIN_AVAILABLE is 1") 126 # pragma message ("RDSEED is not available") 133 #if (ALL_RDRAND_INTRIN_AVAILABLE || ALL_RDSEED_INTRIN_AVAILABLE) 134 # include <immintrin.h> 135 # if defined(__has_include) 136 # if __has_include(<x86intrin.h>) 137 # include <x86intrin.h> 142 #if MASM_RDRAND_ASM_AVAILABLE 144 extern "C" int CRYPTOPP_FASTCALL MASM_RRA_GenerateBlock(byte*,
size_t,
unsigned int);
147 extern "C" int MASM_RRA_GenerateBlock(byte*,
size_t,
unsigned int);
152 #if MASM_RDSEED_ASM_AVAILABLE 154 extern "C" int CRYPTOPP_FASTCALL MASM_RSA_GenerateBlock(byte*,
size_t,
unsigned int);
157 extern "C" int MASM_RSA_GenerateBlock(byte*,
size_t,
unsigned int);
162 #if NASM_RDRAND_ASM_AVAILABLE 163 extern "C" int NASM_RRA_GenerateBlock(byte*,
size_t,
unsigned int);
166 #if NASM_RDSEED_ASM_AVAILABLE 167 extern "C" int NASM_RSA_GenerateBlock(byte*,
size_t,
unsigned int);
175 #if ALL_RDRAND_INTRIN_AVAILABLE 176 static int ALL_RRI_GenerateBlock(byte *output,
size_t size,
unsigned int safety)
178 assert((output && size) || !(output || size));
179 #if CRYPTOPP_BOOL_X64 || CRYTPOPP_BOOL_X32 185 while (size >=
sizeof(val))
187 #if CRYPTOPP_BOOL_X64 || CRYTPOPP_BOOL_X32 188 if (_rdrand64_step((word64*)output))
190 if (_rdrand32_step((word32*)output))
193 output +=
sizeof(val);
205 #if CRYPTOPP_BOOL_X64 || CRYTPOPP_BOOL_X32 206 if (_rdrand64_step(&val))
208 if (_rdrand32_step(&val))
211 memcpy(output, &val, size);
221 #if CRYPTOPP_BOOL_X64 || CRYTPOPP_BOOL_X32 222 *((
volatile word64*)&val) = 0;
224 *((
volatile word32*)&val) = 0;
227 return int(size == 0);
229 #endif // ALL_RDRAND_INTRINSIC_AVAILABLE 231 #if GCC_RDRAND_ASM_AVAILABLE 232 static int GCC_RRA_GenerateBlock(byte *output,
size_t size,
unsigned int safety)
234 assert((output && size) || !(output || size));
235 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 244 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 245 ".byte 0x48, 0x0f, 0xc7, 0xf0;\n" 247 ".byte 0x0f, 0xc7, 0xf0;\n" 250 :
"=a" (val),
"=qm" (rc)
257 if (size >=
sizeof(val))
259 #if defined(CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS) && (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32) 260 *((word64*)output) = val;
261 #elif defined(CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS) && (CRYPTOPP_BOOL_X86) 262 *((word32*)output) = val;
264 memcpy(output, &val,
sizeof(val));
266 output +=
sizeof(val);
271 memcpy(output, &val, size);
282 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 283 *((
volatile word64*)&val) = 0;
285 *((
volatile word32*)&val) = 0;
288 return int(size == 0);
291 #endif // GCC_RDRAND_ASM_AVAILABLE 293 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 296 CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);
297 assert((output && size) || !(output || size));
300 throw NotImplemented(
"RDRAND: rdrand is not available on this platform");
302 int rc; CRYPTOPP_UNUSED(rc);
303 #if MASM_RDRAND_ASM_AVAILABLE 304 rc = MASM_RRA_GenerateBlock(output, size, m_retries);
305 if (!rc) {
throw RDRAND_Err(
"MASM_RRA_GenerateBlock"); }
306 #elif NASM_RDRAND_ASM_AVAILABLE 307 rc = NASM_RRA_GenerateBlock(output, size, m_retries);
308 if (!rc) {
throw RDRAND_Err(
"NASM_RRA_GenerateBlock"); }
309 #elif ALL_RDRAND_INTRIN_AVAILABLE 310 rc = ALL_RRI_GenerateBlock(output, size, m_retries);
311 if (!rc) {
throw RDRAND_Err(
"ALL_RRI_GenerateBlock"); }
312 #elif GCC_RDRAND_ASM_AVAILABLE 313 rc = GCC_RRA_GenerateBlock(output, size, m_retries);
314 if (!rc) {
throw RDRAND_Err(
"GCC_RRA_GenerateBlock"); }
317 throw NotImplemented(
"RDRAND: failed to find a suitable implementation???");
318 #endif // CRYPTOPP_CPUID_AVAILABLE 326 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 342 #endif // CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64 347 #if ALL_RDSEED_INTRIN_AVAILABLE 348 static int ALL_RSI_GenerateBlock(byte *output,
size_t size,
unsigned int safety)
350 assert((output && size) || !(output || size));
351 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 357 while (size >=
sizeof(val))
359 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 360 if (_rdseed64_step((word64*)output))
362 if (_rdseed32_step((word32*)output))
365 output +=
sizeof(val);
377 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 378 if (_rdseed64_step(&val))
380 if (_rdseed32_step(&val))
383 memcpy(output, &val, size);
393 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 394 *((
volatile word64*)&val) = 0;
396 *((
volatile word32*)&val) = 0;
399 return int(size == 0);
401 #endif // ALL_RDSEED_INTRIN_AVAILABLE 403 #if GCC_RDSEED_ASM_AVAILABLE 404 static int GCC_RSA_GenerateBlock(byte *output,
size_t size,
unsigned int safety)
406 assert((output && size) || !(output || size));
407 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 416 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 417 ".byte 0x48, 0x0f, 0xc7, 0xf8;\n" 419 ".byte 0x0f, 0xc7, 0xf8;\n" 422 :
"=a" (val),
"=qm" (rc)
429 if (size >=
sizeof(val))
431 #if defined(CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS) && (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32) 432 *((word64*)output) = val;
433 #elif defined(CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS) && (CRYPTOPP_BOOL_X86) 434 *((word32*)output) = val;
436 memcpy(output, &val,
sizeof(val));
438 output +=
sizeof(val);
443 memcpy(output, &val, size);
454 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 455 *((
volatile word64*)&val) = 0;
457 *((
volatile word32*)&val) = 0;
460 return int(size == 0);
462 #endif // GCC_RDSEED_ASM_AVAILABLE 464 #if (CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64) 467 CRYPTOPP_UNUSED(output), CRYPTOPP_UNUSED(size);
468 assert((output && size) || !(output || size));
471 throw NotImplemented(
"RDSEED: rdseed is not available on this platform");
473 int rc; CRYPTOPP_UNUSED(rc);
474 #if MASM_RDSEED_ASM_AVAILABLE 475 rc = MASM_RSA_GenerateBlock(output, size, m_retries);
476 if (!rc) {
throw RDSEED_Err(
"MASM_RSA_GenerateBlock"); }
477 #elif NASM_RDSEED_ASM_AVAILABLE 478 rc = NASM_RSA_GenerateBlock(output, size, m_retries);
479 if (!rc) {
throw RDRAND_Err(
"NASM_RSA_GenerateBlock"); }
480 #elif ALL_RDSEED_INTRIN_AVAILABLE 481 rc = ALL_RSI_GenerateBlock(output, size, m_retries);
482 if (!rc) {
throw RDSEED_Err(
"ALL_RSI_GenerateBlock"); }
483 #elif GCC_RDSEED_ASM_AVAILABLE 484 rc = GCC_RSA_GenerateBlock(output, size, m_retries);
485 if (!rc) {
throw RDSEED_Err(
"GCC_RSA_GenerateBlock"); }
488 throw NotImplemented(
"RDSEED: failed to find a suitable implementation???");
497 #if CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 513 #endif // CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64 virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
Abstract base classes that provide a uniform interface to this library.
Library configuration file.
Classes for RDRAND and RDSEED.
Classes and functions for secure memory allocations.
Exception thrown when a RDRAND generator encounters a generator related error.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
A method was called which was not implemented.
virtual void DiscardBytes(size_t n)
Generate and discard n bytes.
Fixed size stack-based SecBlock.
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
Classes, functions, intrinsics and features for X86, X32 nd X64 assembly.
T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
Rounds a value up to a multiple of a second value.
Crypto++ library namespace.
size_type SizeInBytes() const
Provides the number of bytes in the SecBlock.
Exception thrown when a RDSEED generator encounters a generator related error.
byte * BytePtr()
Provides a byte pointer to the first element in the memory block.