6 #ifndef CRYPTOPP_MISC_H 7 #define CRYPTOPP_MISC_H 11 #if !CRYPTOPP_DOXYGEN_PROCESSING 13 #if CRYPTOPP_MSC_VERSION 14 # pragma warning(push) 15 # pragma warning(disable: 6326) 25 #define _interlockedbittestandset CRYPTOPP_DISABLED_INTRINSIC_1 26 #define _interlockedbittestandreset CRYPTOPP_DISABLED_INTRINSIC_2 27 #define _interlockedbittestandset64 CRYPTOPP_DISABLED_INTRINSIC_3 28 #define _interlockedbittestandreset64 CRYPTOPP_DISABLED_INTRINSIC_4 30 #undef _interlockedbittestandset 31 #undef _interlockedbittestandreset 32 #undef _interlockedbittestandset64 33 #undef _interlockedbittestandreset64 34 #define CRYPTOPP_FAST_ROTATE(x) 1 35 #elif _MSC_VER >= 1300 36 #define CRYPTOPP_FAST_ROTATE(x) ((x) == 32 | (x) == 64) 38 #define CRYPTOPP_FAST_ROTATE(x) ((x) == 32) 40 #elif (defined(__MWERKS__) && TARGET_CPU_PPC) || \ 41 (defined(__GNUC__) && (defined(_ARCH_PWR2) || defined(_ARCH_PWR) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || defined(_ARCH_COM))) 42 #define CRYPTOPP_FAST_ROTATE(x) ((x) == 32) 43 #elif defined(__GNUC__) && (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X86) // depend on GCC's peephole optimization to generate rotate instructions 44 #define CRYPTOPP_FAST_ROTATE(x) 1 46 #define CRYPTOPP_FAST_ROTATE(x) 0 53 #if defined(__GNUC__) && defined(__linux__) 54 #define CRYPTOPP_BYTESWAP_AVAILABLE 58 #endif // CRYPTOPP_DOXYGEN_PROCESSING 60 #if CRYPTOPP_DOXYGEN_PROCESSING 76 # if defined(__SIZE_MAX__) 77 # define SIZE_MAX __SIZE_MAX__ 78 # elif defined(SIZE_T_MAX) 79 # define SIZE_MAX SIZE_T_MAX 81 # define SIZE_MAX ((std::numeric_limits<size_t>::max)()) 85 #endif // CRYPTOPP_DOXYGEN_PROCESSING 94 #if CRYPTOPP_DOXYGEN_PROCESSING 98 #define CRYPTOPP_COMPILE_ASSERT(expr) ... 99 #else // CRYPTOPP_DOXYGEN_PROCESSING 103 static char dummy[2*b-1];
107 #define CRYPTOPP_COMPILE_ASSERT(assertion) CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, __LINE__) 108 #if defined(CRYPTOPP_EXPORTS) || defined(CRYPTOPP_IMPORTS) 109 #define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) 111 # if defined(__GNUC__) 112 # define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) \ 113 static CompileAssert<(assertion)> \ 114 CRYPTOPP_ASSERT_JOIN(cryptopp_assert_, instance) __attribute__ ((unused)) 116 # define CRYPTOPP_COMPILE_ASSERT_INSTANCE(assertion, instance) \ 117 static CompileAssert<(assertion)> \ 118 CRYPTOPP_ASSERT_JOIN(cryptopp_assert_, instance) 121 #define CRYPTOPP_ASSERT_JOIN(X, Y) CRYPTOPP_DO_ASSERT_JOIN(X, Y) 122 #define CRYPTOPP_DO_ASSERT_JOIN(X, Y) X##Y 124 #endif // CRYPTOPP_DOXYGEN_PROCESSING 128 #if CRYPTOPP_DOXYGEN_PROCESSING 137 # define COUNTOF(arr) 141 # if defined(_MSC_VER) && (_MSC_VER >= 1400) 142 # define COUNTOF(x) _countof(x) 144 # define COUNTOF(x) (sizeof(x)/sizeof(x[0])) 147 #endif // CRYPTOPP_DOXYGEN_PROCESSING 151 #if !CRYPTOPP_DOXYGEN_PROCESSING 152 class CRYPTOPP_DLL Empty
156 template <
class BASE1,
class BASE2>
157 class CRYPTOPP_NO_VTABLE TwoBases :
public BASE1,
public BASE2
161 template <
class BASE1,
class BASE2,
class BASE3>
162 class CRYPTOPP_NO_VTABLE ThreeBases :
public BASE1,
public BASE2,
public BASE3
165 #endif // CRYPTOPP_DOXYGEN_PROCESSING 199 T* operator()()
const {
return new T;}
202 #if CRYPTOPP_DOXYGEN_PROCESSING 210 #define MEMORY_BARRIER ... 212 #if defined(_MSC_VER) 213 # pragma intrinsic(_ReadWriteBarrier) 214 # define MEMORY_BARRIER() _ReadWriteBarrier() 215 #elif defined(__INTEL_COMPILER) 216 # define MEMORY_BARRIER() __memory_barrier() 217 #elif defined(__GNUC__) || defined(__clang__) 218 # define MEMORY_BARRIER() __asm__ __volatile__ ("" ::: "memory") 222 #endif // CRYPTOPP_DOXYGEN_PROCESSING 232 template <
class T,
class F = NewObject<T>,
int instance=0>
236 Singleton(F objectFactory = F()) : m_objectFactory(objectFactory) {}
239 CRYPTOPP_NOINLINE
const T & Ref(CRYPTOPP_NOINLINE_DOTDOTDOT)
const;
248 template <
class T,
class F,
int instance>
252 T *p = s_pObject.m_p;
258 T *newObject = m_objectFactory();
268 s_pObject.m_p = newObject;
276 #if (!__STDC_WANT_SECURE_LIB__ && !defined(_MEMORY_S_DEFINED)) || defined(CRYPTOPP_WANT_SECURE_LIB) 296 inline void memcpy_s(
void *dest,
size_t sizeInBytes,
const void *src,
size_t count)
301 assert(dest != NULL); assert(src != NULL);
303 assert(sizeInBytes >= count);
304 if (count > sizeInBytes)
307 #if CRYPTOPP_MSC_VERSION 308 # pragma warning(push) 309 # pragma warning(disable 4996 6386) 311 memcpy(dest, src, count);
312 #if CRYPTOPP_MSC_VERSION 313 # pragma warning(pop) 335 inline void memmove_s(
void *dest,
size_t sizeInBytes,
const void *src,
size_t count)
340 assert(dest != NULL); assert(src != NULL);
342 assert(sizeInBytes >= count);
343 if (count > sizeInBytes)
346 #if CRYPTOPP_MSC_VERSION 347 # pragma warning(push) 348 # pragma warning(disable 4996 6386) 350 memmove(dest, src, count);
351 #if CRYPTOPP_MSC_VERSION 352 # pragma warning(pop) 356 #if __BORLANDC__ >= 0x620 358 # define memcpy_s CryptoPP::memcpy_s 359 # define memmove_s CryptoPP::memmove_s 362 #endif // __STDC_WANT_SECURE_LIB__ 370 inline void *
memset_z(
void *ptr,
int value,
size_t num)
373 #if CRYPTOPP_GCC_VERSION >= 30001 374 if (__builtin_constant_p(num) && num==0)
377 volatile void* x = memset(ptr, value, num);
378 return const_cast<void*
>(x);
386 template <
class T>
inline const T&
STDMIN(
const T& a,
const T& b)
388 return b < a ? b : a;
396 template <
class T>
inline const T&
STDMAX(
const T& a,
const T& b)
399 return a < b ? b : a;
402 #if CRYPTOPP_MSC_VERSION 403 # pragma warning(push) 404 # pragma warning(disable: 4389) 407 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE 408 # pragma GCC diagnostic push 409 # pragma GCC diagnostic ignored "-Wsign-compare" 410 # if (CRYPTOPP_CLANG_VERSION >= 20800) || (CRYPTOPP_APPLE_CLANG_VERSION >= 30000) 411 # pragma GCC diagnostic ignored "-Wtautological-compare" 412 # elif (CRYPTOPP_GCC_VERSION >= 40300) 413 # pragma GCC diagnostic ignored "-Wtype-limits" 422 template <
class T1,
class T2>
inline const T1
UnsignedMin(
const T1& a,
const T2& b)
425 if (
sizeof(T1)<=
sizeof(T2))
426 return b < (T2)a ? (T1)b : a;
428 return (T1)b < a ? (T1)b : a;
435 template <
class T1,
class T2>
439 if (from != to || (from > 0) != (to > 0))
452 static const unsigned int HIGH_BIT = (1U << 31);
453 const char CH = !!(base & HIGH_BIT) ?
'A' :
'a';
469 T digit = value % base;
470 result = char((digit < 10 ?
'0' : (CH - 10)) + digit) + result;
474 result =
"-" + result;
484 template <> CRYPTOPP_DLL
507 template <> CRYPTOPP_DLL
510 #if CRYPTOPP_MSC_VERSION 511 # pragma warning(pop) 514 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE 515 # pragma GCC diagnostic pop 518 #define RETURN_IF_NONZERO(x) size_t returnedValue = x; if (returnedValue) return returnedValue 521 #define GETBYTE(x, y) (unsigned int)byte((x)>>(8*(y))) 526 #define CRYPTOPP_GET_BYTE_AS_BYTE(x, y) byte((x)>>(8*(y))) 534 for (
unsigned int i=8*
sizeof(value)/2; i>0; i/=2)
536 return (
unsigned int)value&1;
548 unsigned int l=0, h=8*
sizeof(value);
551 unsigned int t = (l+h)/2;
570 unsigned int l=0, h=8*
sizeof(value);
574 unsigned int t = (l+h)/2;
593 #if defined(__GNUC__) && CRYPTOPP_GCC_VERSION >= 30400 594 return __builtin_ctz(v);
595 #elif defined(_MSC_VER) && _MSC_VER >= 1400 596 unsigned long result;
597 _BitScanForward(&result, v);
601 static const int MultiplyDeBruijnBitPosition[32] =
603 0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
604 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
606 return MultiplyDeBruijnBitPosition[((word32)((v & -v) * 0x077CB531U)) >> 27];
619 #if defined(__GNUC__) && CRYPTOPP_GCC_VERSION >= 30400 620 return __builtin_ctzll(v);
621 #elif defined(_MSC_VER) && _MSC_VER >= 1400 && (defined(_M_X64) || defined(_M_IA64)) 622 unsigned long result;
623 _BitScanForward64(&result, v);
638 inline T
Crop(T value,
size_t bits)
640 if (bits < 8*
sizeof(value))
641 return T(value & ((T(1) << bits) - 1));
652 return ((bitCount+7)/(8));
662 return ((byteCount+WORD_SIZE-1)/WORD_SIZE);
672 return ((bitCount+WORD_BITS-1)/(WORD_BITS));
682 return ((bitCount+2*WORD_BITS-1)/(2*WORD_BITS));
691 CRYPTOPP_DLL
void CRYPTOPP_API
xorbuf(byte *buf,
const byte *mask,
size_t count);
700 CRYPTOPP_DLL
void CRYPTOPP_API
xorbuf(byte *output,
const byte *input,
const byte *mask,
size_t count);
710 CRYPTOPP_DLL
bool CRYPTOPP_API
VerifyBufsEqual(
const byte *buf1,
const byte *buf2,
size_t count);
720 return value > 0 && (value & (value-1)) == 0;
729 template <
class T1,
class T2>
733 return T2(a) & (b-1);
742 template <
class T1,
class T2>
758 template <
class T1,
class T2>
777 #if defined(CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS) 781 CRYPTOPP_UNUSED(dummy);
782 #if defined(CRYPTOPP_CXX11_ALIGNOF) 784 #elif (_MSC_VER >= 1300) 786 #elif defined(__GNUC__) 787 return __alignof__(T);
788 #elif CRYPTOPP_BOOL_SLOW_WORD64 803 return alignment==1 || (
IsPowerOf2(alignment) ?
ModPowerOf2((
size_t)ptr, alignment) == 0 : (size_t)ptr % alignment == 0);
814 CRYPTOPP_UNUSED(dummy);
818 #if defined(IS_LITTLE_ENDIAN) 820 #elif defined(IS_BIG_ENDIAN) 823 # error "Unable to determine endian-ness" 836 return NativeByteOrder::ToEnum();
854 template <
class T1,
class T2>
858 return T1((a > b) ? (a - b) : 0);
868 template <
class T1,
class T2>
872 return T1((a > b) ? (a - b) : 1);
886 return obj.IsForwardTransformation() ? ENCRYPTION : DECRYPTION;
907 assert(inout != NULL); assert(size < INT_MAX);
908 for (
int i=
int(size-1), carry=1; i>=0 && carry; i--)
921 assert(output != NULL); assert(input != NULL); assert(size < INT_MAX);
924 for (i=
int(size-1), carry=1; i>=0 && carry; i--)
925 carry = ((output[i] = input[i]+1) == 0);
948 ptrdiff_t t = size_t(c) * (a - b);
964 volatile T *p = buf+n;
966 *((
volatile T*)(--p)) = 0;
969 #if (_MSC_VER >= 1400 || defined(__GNUC__)) && (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X86) 977 volatile byte *p = buf;
979 asm volatile(
"rep stosb" :
"+c"(n),
"+D"(p) :
"a"(0) :
"memory");
981 __stosb((byte *)(
size_t)p, 0, n);
991 volatile word16 *p = buf;
993 asm volatile(
"rep stosw" :
"+c"(n),
"+D"(p) :
"a"(0) :
"memory");
995 __stosw((word16 *)(
size_t)p, 0, n);
1005 volatile word32 *p = buf;
1007 asm volatile(
"rep stosl" :
"+c"(n),
"+D"(p) :
"a"(0) :
"memory");
1009 __stosd((
unsigned long *)(
size_t)p, 0, n);
1019 #if CRYPTOPP_BOOL_X64 1020 volatile word64 *p = buf;
1022 asm volatile(
"rep stosq" :
"+c"(n),
"+D"(p) :
"a"(0) :
"memory");
1024 __stosq((word64 *)(
size_t)p, 0, n);
1031 #endif // #if (_MSC_VER >= 1400 || defined(__GNUC__)) && (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X86) 1040 if (
sizeof(T) % 8 == 0 && GetAlignmentOf<T>() % GetAlignmentOf<word64>() == 0)
1042 else if (
sizeof(T) % 4 == 0 && GetAlignmentOf<T>() % GetAlignmentOf<word32>() == 0)
1044 else if (
sizeof(T) % 2 == 0 && GetAlignmentOf<T>() % GetAlignmentOf<word16>() == 0)
1062 #ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562 1063 static inline std::string StringNarrow(
const wchar_t *str,
bool throwOnError =
true)
1065 static std::string StringNarrow(
const wchar_t *str,
bool throwOnError =
true)
1072 #if (CRYPTOPP_MSC_VERSION >= 1400) 1073 size_t len=0, size = 0;
1078 len = wcslen(str)+1;
1080 err = wcstombs_s(&size, NULL, 0, str, len*
sizeof(
wchar_t));
1082 if (err != 0) {
goto CONVERSION_ERROR;}
1084 result.resize(size);
1085 err = wcstombs_s(&size, &result[0], size, str, len*
sizeof(
wchar_t));
1094 return std::string();
1098 if (!result.empty() && result[size - 1] ==
'\0')
1099 result.erase(size - 1);
1101 size_t size = wcstombs(NULL, str, 0);
1102 assert(size != (
size_t)-1);
1103 if (size == (
size_t)-1) {
goto CONVERSION_ERROR;}
1105 result.resize(size);
1106 size = wcstombs(&result[0], str, size);
1107 assert(size != (
size_t)-1);
1109 if (size == (
size_t)-1)
1115 return std::string();
1122 #ifdef CRYPTOPP_DOXYGEN_PROCESSING 1140 #endif // CRYPTOPP_DOXYGEN_PROCESSING 1142 #if CRYPTOPP_BOOL_ALIGN16 1145 #endif // CRYPTOPP_BOOL_ALIGN16 1173 static const unsigned int THIS_SIZE =
sizeof(T)*8;
1174 static const unsigned int MASK = THIS_SIZE-1;
1176 assert(y < THIS_SIZE);
1177 return T((x<<y)|(x>>(-y&MASK)));
1195 static const unsigned int THIS_SIZE =
sizeof(T)*8;
1196 static const unsigned int MASK = THIS_SIZE-1;
1197 assert(y < THIS_SIZE);
1198 return T((x >> y)|(x<<(-y&MASK)));
1212 static const unsigned int THIS_SIZE =
sizeof(T)*8;
1213 static const unsigned int MASK = THIS_SIZE-1;
1214 assert(y < THIS_SIZE);
1215 return T((x<<y)|(x>>(-y&MASK)));
1229 static const unsigned int THIS_SIZE =
sizeof(T)*8;
1230 static const unsigned int MASK = THIS_SIZE-1;
1231 assert(y < THIS_SIZE);
1232 return T((x>>y)|(x<<(-y&MASK)));
1241 template <
class T>
inline T
rotlMod(T x,
unsigned int y)
1243 static const unsigned int THIS_SIZE =
sizeof(T)*8;
1244 static const unsigned int MASK = THIS_SIZE-1;
1245 return T((x<<(y&MASK))|(x>>(-y&MASK)));
1254 template <
class T>
inline T
rotrMod(T x,
unsigned int y)
1256 static const unsigned int THIS_SIZE =
sizeof(T)*8;
1257 static const unsigned int MASK = THIS_SIZE-1;
1258 return T((x>>(y&MASK))|(x<<(-y&MASK)));
1270 template<>
inline word32 rotlFixed<word32>(word32 x,
unsigned int y)
1273 assert(y < 8*
sizeof(x));
1274 return y ? _lrotl(x, static_cast<byte>(y)) : x;
1284 template<>
inline word32 rotrFixed<word32>(word32 x,
unsigned int y)
1287 assert(y < 8*
sizeof(x));
1288 return y ? _lrotr(x, static_cast<byte>(y)) : x;
1298 template<>
inline word32 rotlVariable<word32>(word32 x,
unsigned int y)
1300 assert(y < 8*
sizeof(x));
1301 return _lrotl(x, static_cast<byte>(y));
1311 template<>
inline word32 rotrVariable<word32>(word32 x,
unsigned int y)
1313 assert(y < 8*
sizeof(x));
1314 return _lrotr(x, static_cast<byte>(y));
1323 template<>
inline word32 rotlMod<word32>(word32 x,
unsigned int y)
1326 return _lrotl(x, static_cast<byte>(y));
1335 template<>
inline word32 rotrMod<word32>(word32 x,
unsigned int y)
1338 return _lrotr(x, static_cast<byte>(y));
1341 #endif // #ifdef _MSC_VER 1343 #if _MSC_VER >= 1300 && !defined(__INTEL_COMPILER) 1353 template<>
inline word64 rotlFixed<word64>(word64 x,
unsigned int y)
1356 assert(y < 8*
sizeof(x));
1357 return y ? _rotl64(x, static_cast<byte>(y)) : x;
1367 template<>
inline word64 rotrFixed<word64>(word64 x,
unsigned int y)
1370 assert(y < 8*
sizeof(x));
1371 return y ? _rotr64(x, static_cast<byte>(y)) : x;
1381 template<>
inline word64 rotlVariable<word64>(word64 x,
unsigned int y)
1383 assert(y < 8*
sizeof(x));
1384 return _rotl64(x, static_cast<byte>(y));
1394 template<>
inline word64 rotrVariable<word64>(word64 x,
unsigned int y)
1396 assert(y < 8*
sizeof(x));
1397 return y ? _rotr64(x, static_cast<byte>(y)) : x;
1406 template<>
inline word64 rotlMod<word64>(word64 x,
unsigned int y)
1408 assert(y < 8*
sizeof(x));
1409 return y ? _rotl64(x, static_cast<byte>(y)) : x;
1418 template<>
inline word64 rotrMod<word64>(word64 x,
unsigned int y)
1420 assert(y < 8*
sizeof(x));
1421 return y ? _rotr64(x, static_cast<byte>(y)) : x;
1424 #endif // #if _MSC_VER >= 1310 1426 #if _MSC_VER >= 1400 && !defined(__INTEL_COMPILER) 1429 template<>
inline word16 rotlFixed<word16>(word16 x,
unsigned int y)
1432 return _rotl16(x, static_cast<byte>(y));
1435 template<>
inline word16 rotrFixed<word16>(word16 x,
unsigned int y)
1438 return _rotr16(x, static_cast<byte>(y));
1441 template<>
inline word16 rotlVariable<word16>(word16 x,
unsigned int y)
1443 return _rotl16(x, static_cast<byte>(y));
1446 template<>
inline word16 rotrVariable<word16>(word16 x,
unsigned int y)
1448 return _rotr16(x, static_cast<byte>(y));
1451 template<>
inline word16 rotlMod<word16>(word16 x,
unsigned int y)
1453 return _rotl16(x, static_cast<byte>(y));
1456 template<>
inline word16 rotrMod<word16>(word16 x,
unsigned int y)
1458 return _rotr16(x, static_cast<byte>(y));
1461 template<>
inline byte rotlFixed<byte>(byte x,
unsigned int y)
1464 return _rotl8(x, static_cast<byte>(y));
1467 template<>
inline byte rotrFixed<byte>(byte x,
unsigned int y)
1470 return _rotr8(x, static_cast<byte>(y));
1473 template<>
inline byte rotlVariable<byte>(byte x,
unsigned int y)
1475 return _rotl8(x, static_cast<byte>(y));
1478 template<>
inline byte rotrVariable<byte>(byte x,
unsigned int y)
1480 return _rotr8(x, static_cast<byte>(y));
1483 template<>
inline byte rotlMod<byte>(byte x,
unsigned int y)
1485 return _rotl8(x, static_cast<byte>(y));
1488 template<>
inline byte rotrMod<byte>(byte x,
unsigned int y)
1490 return _rotr8(x, static_cast<byte>(y));
1493 #endif // #if _MSC_VER >= 1400 1495 #if (defined(__MWERKS__) && TARGET_CPU_PPC) 1497 template<>
inline word32 rotlFixed<word32>(word32 x,
unsigned int y)
1500 return y ? __rlwinm(x,y,0,31) : x;
1503 template<>
inline word32 rotrFixed<word32>(word32 x,
unsigned int y)
1506 return y ? __rlwinm(x,32-y,0,31) : x;
1509 template<>
inline word32 rotlVariable<word32>(word32 x,
unsigned int y)
1512 return (__rlwnm(x,y,0,31));
1515 template<>
inline word32 rotrVariable<word32>(word32 x,
unsigned int y)
1518 return (__rlwnm(x,32-y,0,31));
1521 template<>
inline word32 rotlMod<word32>(word32 x,
unsigned int y)
1523 return (__rlwnm(x,y,0,31));
1526 template<>
inline word32 rotrMod<word32>(word32 x,
unsigned int y)
1528 return (__rlwnm(x,32-y,0,31));
1531 #endif // #if (defined(__MWERKS__) && TARGET_CPU_PPC) 1542 if (order == LITTLE_ENDIAN_ORDER)
1543 return GETBYTE(value, index);
1545 return GETBYTE(value,
sizeof(T)-index-1);
1562 #ifdef CRYPTOPP_BYTESWAP_AVAILABLE 1563 return bswap_16(value);
1564 #elif defined(_MSC_VER) && _MSC_VER >= 1300 1565 return _byteswap_ushort(value);
1577 #if defined(__GNUC__) && defined(CRYPTOPP_X86_ASM_AVAILABLE) 1578 __asm__ (
"bswap %0" :
"=r" (value) :
"0" (value));
1580 #elif defined(CRYPTOPP_BYTESWAP_AVAILABLE) 1581 return bswap_32(value);
1582 #elif defined(__MWERKS__) && TARGET_CPU_PPC 1583 return (word32)__lwbrx(&value,0);
1584 #elif _MSC_VER >= 1400 || (_MSC_VER >= 1300 && !defined(_DLL)) 1585 return _byteswap_ulong(value);
1586 #elif CRYPTOPP_FAST_ROTATE(32) 1591 value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
1602 #if defined(__GNUC__) && defined(CRYPTOPP_X86_ASM_AVAILABLE) && defined(__x86_64__) 1603 __asm__ (
"bswap %0" :
"=r" (value) :
"0" (value));
1605 #elif defined(CRYPTOPP_BYTESWAP_AVAILABLE) 1606 return bswap_64(value);
1607 #elif defined(_MSC_VER) && _MSC_VER >= 1300 1608 return _byteswap_uint64(value);
1609 #elif CRYPTOPP_BOOL_SLOW_WORD64 1612 value = ((value & W64LIT(0xFF00FF00FF00FF00)) >> 8) | ((value & W64LIT(0x00FF00FF00FF00FF)) << 8);
1613 value = ((value & W64LIT(0xFFFF0000FFFF0000)) >> 16) | ((value & W64LIT(0x0000FFFF0000FFFF)) << 16);
1623 value = ((value & 0xAA) >> 1) | ((value & 0x55) << 1);
1624 value = ((value & 0xCC) >> 2) | ((value & 0x33) << 2);
1633 value = ((value & 0xAAAA) >> 1) | ((value & 0x5555) << 1);
1634 value = ((value & 0xCCCC) >> 2) | ((value & 0x3333) << 2);
1635 value = ((value & 0xF0F0) >> 4) | ((value & 0x0F0F) << 4);
1644 value = ((value & 0xAAAAAAAA) >> 1) | ((value & 0x55555555) << 1);
1645 value = ((value & 0xCCCCCCCC) >> 2) | ((value & 0x33333333) << 2);
1646 value = ((value & 0xF0F0F0F0) >> 4) | ((value & 0x0F0F0F0F) << 4);
1655 #if CRYPTOPP_BOOL_SLOW_WORD64 1658 value = ((value & W64LIT(0xAAAAAAAAAAAAAAAA)) >> 1) | ((value & W64LIT(0x5555555555555555)) << 1);
1659 value = ((value & W64LIT(0xCCCCCCCCCCCCCCCC)) >> 2) | ((value & W64LIT(0x3333333333333333)) << 2);
1660 value = ((value & W64LIT(0xF0F0F0F0F0F0F0F0)) >> 4) | ((value & W64LIT(0x0F0F0F0F0F0F0F0F)) << 4);
1676 else if (
sizeof(T) == 2)
1678 else if (
sizeof(T) == 4)
1682 assert(
sizeof(T) == 8);
1715 assert(byteCount %
sizeof(T) == 0);
1716 size_t count = byteCount/
sizeof(T);
1717 for (
size_t i=0; i<count; i++)
1740 memcpy_s(out, byteCount, in, byteCount);
1744 inline void GetUserKey(
ByteOrder order, T *out,
size_t outlen,
const byte *in,
size_t inlen)
1746 const size_t U =
sizeof(T);
1747 assert(inlen <= outlen*U);
1748 memcpy_s(out, outlen*U, in, inlen);
1749 memset_z((byte *)out+inlen, 0, outlen*U-inlen);
1753 #ifndef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS 1754 inline byte UnalignedGetWordNonTemplate(
ByteOrder order,
const byte *block,
const byte *)
1756 CRYPTOPP_UNUSED(order);
1760 inline word16 UnalignedGetWordNonTemplate(
ByteOrder order,
const byte *block,
const word16 *)
1762 return (order == BIG_ENDIAN_ORDER)
1763 ? block[1] | (block[0] << 8)
1764 : block[0] | (block[1] << 8);
1767 inline word32 UnalignedGetWordNonTemplate(
ByteOrder order,
const byte *block,
const word32 *)
1769 return (order == BIG_ENDIAN_ORDER)
1770 ? word32(block[3]) | (word32(block[2]) << 8) | (word32(block[1]) << 16) | (word32(block[0]) << 24)
1771 : word32(block[0]) | (word32(block[1]) << 8) | (word32(block[2]) << 16) | (word32(block[3]) << 24);
1774 inline word64 UnalignedGetWordNonTemplate(
ByteOrder order,
const byte *block,
const word64 *)
1776 return (order == BIG_ENDIAN_ORDER)
1779 (word64(block[6]) << 8) |
1780 (word64(block[5]) << 16) |
1781 (word64(block[4]) << 24) |
1782 (word64(block[3]) << 32) |
1783 (word64(block[2]) << 40) |
1784 (word64(block[1]) << 48) |
1785 (word64(block[0]) << 56))
1788 (word64(block[1]) << 8) |
1789 (word64(block[2]) << 16) |
1790 (word64(block[3]) << 24) |
1791 (word64(block[4]) << 32) |
1792 (word64(block[5]) << 40) |
1793 (word64(block[6]) << 48) |
1794 (word64(block[7]) << 56));
1797 inline void UnalignedbyteNonTemplate(
ByteOrder order, byte *block, byte value,
const byte *xorBlock)
1799 CRYPTOPP_UNUSED(order);
1800 block[0] = xorBlock ? (value ^ xorBlock[0]) : value;
1803 inline void UnalignedbyteNonTemplate(
ByteOrder order, byte *block, word16 value,
const byte *xorBlock)
1805 if (order == BIG_ENDIAN_ORDER)
1809 block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1810 block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1814 block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1815 block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1822 block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1823 block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1827 block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1828 block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1833 inline void UnalignedbyteNonTemplate(
ByteOrder order, byte *block, word32 value,
const byte *xorBlock)
1835 if (order == BIG_ENDIAN_ORDER)
1839 block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1840 block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1841 block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1842 block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1846 block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1847 block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1848 block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1849 block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1856 block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1857 block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1858 block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1859 block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1863 block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1864 block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1865 block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1866 block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1871 inline void UnalignedbyteNonTemplate(
ByteOrder order, byte *block, word64 value,
const byte *xorBlock)
1873 if (order == BIG_ENDIAN_ORDER)
1877 block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
1878 block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
1879 block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
1880 block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
1881 block[4] = xorBlock[4] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1882 block[5] = xorBlock[5] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1883 block[6] = xorBlock[6] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1884 block[7] = xorBlock[7] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1888 block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
1889 block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
1890 block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
1891 block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
1892 block[4] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1893 block[5] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1894 block[6] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1895 block[7] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1902 block[0] = xorBlock[0] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1903 block[1] = xorBlock[1] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1904 block[2] = xorBlock[2] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1905 block[3] = xorBlock[3] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1906 block[4] = xorBlock[4] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
1907 block[5] = xorBlock[5] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
1908 block[6] = xorBlock[6] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
1909 block[7] = xorBlock[7] ^ CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
1913 block[0] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 0);
1914 block[1] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 1);
1915 block[2] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 2);
1916 block[3] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 3);
1917 block[4] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 4);
1918 block[5] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 5);
1919 block[6] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 6);
1920 block[7] = CRYPTOPP_GET_BYTE_AS_BYTE(value, 7);
1924 #endif // #ifndef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS 1927 inline T GetWord(
bool assumeAligned,
ByteOrder order,
const byte *block)
1935 CRYPTOPP_UNUSED(assumeAligned);
1936 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS 1940 memcpy(&temp, block,
sizeof(T));
1946 inline void GetWord(
bool assumeAligned,
ByteOrder order, T &result,
const byte *block)
1948 result = GetWord<T>(assumeAligned, order, block);
1952 inline void PutWord(
bool assumeAligned,
ByteOrder order, byte *block, T value,
const byte *xorBlock = NULL)
1961 CRYPTOPP_UNUSED(assumeAligned);
1962 #ifdef CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS 1963 *
reinterpret_cast<T *
>(block) =
ConditionalByteReverse(order, value) ^ (xorBlock ? *
reinterpret_cast<const T *
>(xorBlock) : 0);
1967 if (xorBlock) memcpy(&t2, xorBlock,
sizeof(T));
1968 memmove(block, &(t1 ^= t2),
sizeof(T));
1972 template <
class T,
class B,
bool A=false>
1977 : m_block((
const byte *)block) {}
1983 x = GetWord<T>(A, B::ToEnum(), m_block);
1984 m_block +=
sizeof(T);
1989 const byte *m_block;
1992 template <
class T,
class B,
bool A=false>
1996 PutBlock(
const void *xorBlock,
void *block)
1997 : m_xorBlock((
const byte *)xorBlock), m_block((byte *)block) {}
2002 PutWord(A, B::ToEnum(), m_block, (T)x, m_xorBlock);
2003 m_block +=
sizeof(T);
2005 m_xorBlock +=
sizeof(T);
2010 const byte *m_xorBlock;
2014 template <
class T,
class B,
bool GA=false,
bool PA=false>
2023 std::string WordToString(T value,
ByteOrder order = BIG_ENDIAN_ORDER)
2028 return std::string((
char *)&value,
sizeof(value));
2032 T StringToWord(
const std::string &str,
ByteOrder order = BIG_ENDIAN_ORDER)
2046 static inline T RightShift(T value,
unsigned int bits)
2048 CRYPTOPP_UNUSED(value); CRYPTOPP_UNUSED(bits);
2053 static inline T LeftShift(T value,
unsigned int bits)
2055 CRYPTOPP_UNUSED(value); CRYPTOPP_UNUSED(bits);
2063 static inline T RightShift(T value,
unsigned int bits)
2065 return value >> bits;
2069 static inline T LeftShift(T value,
unsigned int bits)
2071 return value << bits;
2075 template <
unsigned int bits,
class T>
2076 inline T SafeRightShift(T value)
2081 template <
unsigned int bits,
class T>
2082 inline T SafeLeftShift(T value)
2089 #define CRYPTOPP_BLOCK_1(n, t, s) t* m_##n() {return (t *)(m_aggregate+0);} size_t SS1() {return sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2090 #define CRYPTOPP_BLOCK_2(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS1());} size_t SS2() {return SS1()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2091 #define CRYPTOPP_BLOCK_3(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS2());} size_t SS3() {return SS2()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2092 #define CRYPTOPP_BLOCK_4(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS3());} size_t SS4() {return SS3()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2093 #define CRYPTOPP_BLOCK_5(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS4());} size_t SS5() {return SS4()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2094 #define CRYPTOPP_BLOCK_6(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS5());} size_t SS6() {return SS5()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2095 #define CRYPTOPP_BLOCK_7(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS6());} size_t SS7() {return SS6()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2096 #define CRYPTOPP_BLOCK_8(n, t, s) t* m_##n() {return (t *)(m_aggregate+SS7());} size_t SS8() {return SS7()+sizeof(t)*(s);} size_t m_##n##Size() {return (s);} 2097 #define CRYPTOPP_BLOCKS_END(i) size_t SST() {return SS##i();} void AllocateBlocks() {m_aggregate.New(SST());} AlignedSecByteBlock m_aggregate; 2101 #if CRYPTOPP_MSC_VERSION 2102 # pragma warning(pop) void SecureWipeBuffer(T *buf, size_t n)
Sets each element of an array to 0.
An invalid argument was detected.
bool NativeByteOrderIs(ByteOrder order)
Determines whether order follows native byte ordering.
void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memmove()
bool SafeConvert(T1 from, T2 &to)
Tests whether a conversion from → to is safe to perform.
unsigned int GetAlignmentOf(T *dummy=NULL)
Returns the minimum alignment requirements of a type.
ByteOrder
Provides the byte ordering.
void AlignedDeallocate(void *ptr)
Frees a buffer allocated with AlignedAllocate.
Restricts the instantiation of a class to one static object without locks.
void IncrementCounterByOne(byte *inout, unsigned int size)
Performs an addition with carry on a block of bytes.
T2 ModPowerOf2(const T1 &a, const T2 &b)
Tests whether the residue of a value is a power of 2.
size_t BitsToBytes(size_t bitCount)
Returns the number of 8-bit bytes or octets required for the specified number of bits.
T rotlFixed(T x, unsigned int y)
Performs a left rotate.
size_t BitsToWords(size_t bitCount)
Returns the number of words required for the specified number of bits.
unsigned int BytePrecision(const T &value)
Returns the number of 8-bit bytes or octets required for a value.
Converts a typename to an enumerated value.
CipherDir
Specifies a direction for a cipher to operate.
Abstract base classes that provide a uniform interface to this library.
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
An object factory function.
Classes for automatic resource management.
Library configuration file.
bool IsAligned(const void *ptr, T *dummy=NULL)
Determines whether ptr is minimally aligned.
size_t BytesToWords(size_t byteCount)
Returns the number of words required for the specified number of bytes.
T rotlVariable(T x, unsigned int y)
Performs a left rotate.
byte BitReverse(byte value)
Reverses bits in a 8-bit value.
void SecureWipeArray(T *buf, size_t n)
Sets each element of an array to 0.
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
Uses encapsulation to hide an object in derived classes.
void * UnalignedAllocate(size_t size)
Allocates a buffer.
Manages resources for a single object.
unsigned int TrailingZeros(word32 v)
Determines the number of trailing 0-bits in a value.
void CallNewHandler()
Attempts to reclaim unused memory.
#define CRYPTOPP_COMPILE_ASSERT(expr)
Compile time assertion.
T Crop(T value, size_t bits)
Truncates the value to the specified number of bits.
T ConditionalByteReverse(ByteOrder order, T value)
Reverses bytes in a value depending upon endianess.
void ConditionalSwapPointers(bool c, T &a, T &b)
Performs a branchless swap of pointers a and b if condition c is true.
Multiple precision integer with arithmetic operations.
T1 SaturatingSubtract(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 0.
CipherDir GetCipherDir(const T &obj)
Returns the direction the cipher is being operated.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be neagtive and incorrectly promoted.
bool IsPowerOf2(const T &value)
Tests whether a value is a power of 2.
#define MEMORY_BARRIER
A memory barrier.
void * memset_z(void *ptr, int value, size_t num)
Memory block initializer and eraser that attempts to survive optimizations.
unsigned int Parity(T value)
Returns the parity of a value.
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
std::string IntToString< unsigned long long >(unsigned long long value, unsigned int base)
Converts an unsigned value to a string.
void ConditionalSwap(bool c, T &a, T &b)
Performs a branchless swap of values a and b if condition c is true.
T1 SaturatingSubtract1(const T1 &a, const T2 &b)
Performs a saturating subtract clamped at 1.
void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
bool VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count)
Performs a near constant-time comparison of two equally sized buffers.
ByteOrder GetNativeByteOrder()
Returns NativeByteOrder as an enumerated ByteOrder value.
T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
Rounds a value up to a multiple of a second value.
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
std::string IntToString< Integer >(Integer value, unsigned int base)
Converts an Integer to a string.
Crypto++ library namespace.
T rotrVariable(T x, unsigned int y)
Performs a right rotate.
T rotlMod(T x, unsigned int y)
Performs a left rotate.
unsigned int GetByte(ByteOrder order, T value, unsigned int index)
Gets a byte from a value.
T rotrMod(T x, unsigned int y)
Performs a right rotate.
const T & Ref(...) const
Return a reference to the inner Singleton object.
T rotrFixed(T x, unsigned int y)
Performs a right rotate.
Ensures an object is not copyable.
byte ByteReverse(byte value)
Reverses bytes in a 8-bit value.
void UnalignedDeallocate(void *ptr)
Frees a buffer allocated with UnalignedAllocate.
unsigned int BitPrecision(const T &value)
Returns the number of bits required for a value.
size_t BitsToDwords(size_t bitCount)
Returns the number of double words required for the specified number of bits.
T1 RoundDownToMultipleOf(const T1 &n, const T2 &m)
Rounds a value down to a multiple of a second value.
void * AlignedAllocate(size_t size)
Allocates a buffer on 16-byte boundary.
#define SIZE_MAX
The maximum value of a machine word.