Crypto++
5.6.3
Free C++ class library of cryptographic schemes
|
Utility functions for the Crypto++ library. More...
Go to the source code of this file.
Classes | |
class | ObjectHolder< T > |
Uses encapsulation to hide an object in derived classes. More... | |
class | NotCopyable |
Ensures an object is not copyable. More... | |
class | NewObject< T > |
An object factory function. More... | |
class | Singleton< T, F, instance > |
Restricts the instantiation of a class to one static object without locks. More... | |
class | GetBlock< T, B, A > |
class | PutBlock< T, B, A > |
struct | BlockGetAndPut< T, B, GA, PA > |
struct | SafeShifter< overflow > |
struct | SafeShifter< true > |
struct | SafeShifter< false > |
Macros | |
#define | SIZE_MAX ... |
The maximum value of a machine word. More... | |
#define | CRYPTOPP_COMPILE_ASSERT(expr) ... |
Compile time assertion. More... | |
#define | COUNTOF(arr) |
Counts elements in an array. More... | |
#define | MEMORY_BARRIER ... |
A memory barrier. More... | |
#define | RETURN_IF_NONZERO(x) size_t returnedValue = x; if (returnedValue) return returnedValue |
#define | GETBYTE(x, y) (unsigned int)byte((x)>>(8*(y))) |
#define | CRYPTOPP_GET_BYTE_AS_BYTE(x, y) byte((x)>>(8*(y))) |
#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);} |
#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);} |
#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);} |
#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);} |
#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);} |
#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);} |
#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);} |
#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);} |
#define | CRYPTOPP_BLOCKS_END(i) size_t SST() {return SS##i();} void AllocateBlocks() {m_aggregate.New(SST());} AlignedSecByteBlock m_aggregate; |
Typedefs | |
typedef LittleEndian | NativeByteOrder |
Functions | |
void | memcpy_s (void *dest, size_t sizeInBytes, const void *src, size_t count) |
Bounds checking replacement for memcpy() More... | |
void | memmove_s (void *dest, size_t sizeInBytes, const void *src, size_t count) |
Bounds checking replacement for memmove() More... | |
void * | memset_z (void *ptr, int value, size_t num) |
Memory block initializer and eraser that attempts to survive optimizations. More... | |
template<class T > | |
const T & | STDMIN (const T &a, const T &b) |
Replacement function for std::min. More... | |
template<class T > | |
const T & | STDMAX (const T &a, const T &b) |
Replacement function for std::max. More... | |
template<class T1 , class T2 > | |
const T1 | UnsignedMin (const T1 &a, const T2 &b) |
Safe comparison of values that could be neagtive and incorrectly promoted. More... | |
template<class T1 , class T2 > | |
bool | SafeConvert (T1 from, T2 &to) |
Tests whether a conversion from → to is safe to perform. More... | |
template<class T > | |
std::string | IntToString (T value, unsigned int base=10) |
Converts a value to a string. More... | |
template<> | |
std::string | IntToString< unsigned long long > (unsigned long long value, unsigned int base) |
Converts an unsigned value to a string. More... | |
template<> | |
std::string | IntToString< Integer > (Integer value, unsigned int base) |
Converts an Integer to a string. More... | |
template<class T > | |
unsigned int | Parity (T value) |
Returns the parity of a value. More... | |
template<class T > | |
unsigned int | BytePrecision (const T &value) |
Returns the number of 8-bit bytes or octets required for a value. More... | |
template<class T > | |
unsigned int | BitPrecision (const T &value) |
Returns the number of bits required for a value. More... | |
unsigned int | TrailingZeros (word32 v) |
Determines the number of trailing 0-bits in a value. More... | |
unsigned int | TrailingZeros (word64 v) |
Determines the number of trailing 0-bits in a value. More... | |
template<class T > | |
T | Crop (T value, size_t bits) |
Truncates the value to the specified number of bits. More... | |
size_t | BitsToBytes (size_t bitCount) |
Returns the number of 8-bit bytes or octets required for the specified number of bits. More... | |
size_t | BytesToWords (size_t byteCount) |
Returns the number of words required for the specified number of bytes. More... | |
size_t | BitsToWords (size_t bitCount) |
Returns the number of words required for the specified number of bits. More... | |
size_t | BitsToDwords (size_t bitCount) |
Returns the number of double words required for the specified number of bits. More... | |
void | xorbuf (byte *buf, const byte *mask, size_t count) |
Performs an XOR of a buffer with a mask. More... | |
void | xorbuf (byte *output, const byte *input, const byte *mask, size_t count) |
Performs an XOR of an input buffer with a mask and stores the result in an output buffer. More... | |
bool | VerifyBufsEqual (const byte *buf1, const byte *buf2, size_t count) |
Performs a near constant-time comparison of two equally sized buffers. More... | |
template<class T > | |
bool | IsPowerOf2 (const T &value) |
Tests whether a value is a power of 2. More... | |
template<class T1 , class T2 > | |
T2 | ModPowerOf2 (const T1 &a, const T2 &b) |
Tests whether the residue of a value is a power of 2. More... | |
template<class T1 , class T2 > | |
T1 | RoundDownToMultipleOf (const T1 &n, const T2 &m) |
Rounds a value down to a multiple of a second value. More... | |
template<class T1 , class T2 > | |
T1 | RoundUpToMultipleOf (const T1 &n, const T2 &m) |
Rounds a value up to a multiple of a second value. More... | |
template<class T > | |
unsigned int | GetAlignmentOf (T *dummy=NULL) |
Returns the minimum alignment requirements of a type. More... | |
bool | IsAlignedOn (const void *ptr, unsigned int alignment) |
Determines whether ptr is aligned to a minimum value. More... | |
template<class T > | |
bool | IsAligned (const void *ptr, T *dummy=NULL) |
Determines whether ptr is minimally aligned. More... | |
ByteOrder | GetNativeByteOrder () |
Returns NativeByteOrder as an enumerated ByteOrder value. More... | |
bool | NativeByteOrderIs (ByteOrder order) |
Determines whether order follows native byte ordering. More... | |
template<class T1 , class T2 > | |
T1 | SaturatingSubtract (const T1 &a, const T2 &b) |
Performs a saturating subtract clamped at 0. More... | |
template<class T1 , class T2 > | |
T1 | SaturatingSubtract1 (const T1 &a, const T2 &b) |
Performs a saturating subtract clamped at 1. More... | |
template<class T > | |
CipherDir | GetCipherDir (const T &obj) |
Returns the direction the cipher is being operated. More... | |
void | CallNewHandler () |
Attempts to reclaim unused memory. More... | |
void | IncrementCounterByOne (byte *inout, unsigned int size) |
Performs an addition with carry on a block of bytes. More... | |
void | IncrementCounterByOne (byte *output, const byte *input, unsigned int size) |
Performs an addition with carry on a block of bytes. More... | |
template<class T > | |
void | ConditionalSwap (bool c, T &a, T &b) |
Performs a branchless swap of values a and b if condition c is true. More... | |
template<class T > | |
void | ConditionalSwapPointers (bool c, T &a, T &b) |
Performs a branchless swap of pointers a and b if condition c is true. More... | |
template<class T > | |
void | SecureWipeBuffer (T *buf, size_t n) |
Sets each element of an array to 0. More... | |
template<class T > | |
void | SecureWipeArray (T *buf, size_t n) |
Sets each element of an array to 0. More... | |
void * | AlignedAllocate (size_t size) |
Allocates a buffer on 16-byte boundary. More... | |
void | AlignedDeallocate (void *ptr) |
Frees a buffer allocated with AlignedAllocate. More... | |
void * | UnalignedAllocate (size_t size) |
Allocates a buffer. More... | |
void | UnalignedDeallocate (void *ptr) |
Frees a buffer allocated with UnalignedAllocate. More... | |
template<class T > | |
T | rotlFixed (T x, unsigned int y) |
Performs a left rotate. More... | |
template<class T > | |
T | rotrFixed (T x, unsigned int y) |
Performs a right rotate. More... | |
template<class T > | |
T | rotlVariable (T x, unsigned int y) |
Performs a left rotate. More... | |
template<class T > | |
T | rotrVariable (T x, unsigned int y) |
Performs a right rotate. More... | |
template<class T > | |
T | rotlMod (T x, unsigned int y) |
Performs a left rotate. More... | |
template<class T > | |
T | rotrMod (T x, unsigned int y) |
Performs a right rotate. More... | |
template<class T > | |
unsigned int | GetByte (ByteOrder order, T value, unsigned int index) |
Gets a byte from a value. More... | |
byte | ByteReverse (byte value) |
Reverses bytes in a 8-bit value. More... | |
word16 | ByteReverse (word16 value) |
Reverses bytes in a 16-bit value. More... | |
word32 | ByteReverse (word32 value) |
Reverses bytes in a 32-bit value. More... | |
word64 | ByteReverse (word64 value) |
Reverses bytes in a 64-bit value. More... | |
byte | BitReverse (byte value) |
Reverses bits in a 8-bit value. More... | |
word16 | BitReverse (word16 value) |
Reverses bits in a 16-bit value. More... | |
word32 | BitReverse (word32 value) |
Reverses bits in a 32-bit value. More... | |
word64 | BitReverse (word64 value) |
Reverses bits in a 64-bit value. More... | |
template<class T > | |
T | BitReverse (T value) |
Reverses bits in a value. More... | |
template<class T > | |
T | ConditionalByteReverse (ByteOrder order, T value) |
Reverses bytes in a value depending upon endianess. More... | |
template<class T > | |
void | ByteReverse (T *out, const T *in, size_t byteCount) |
Reverses bytes in an element among an array of elements. More... | |
template<class T > | |
void | ConditionalByteReverse (ByteOrder order, T *out, const T *in, size_t byteCount) |
Reverses bytes in an element among an array of elements depending upon endianess. More... | |
template<class T > | |
void | GetUserKey (ByteOrder order, T *out, size_t outlen, const byte *in, size_t inlen) |
byte | UnalignedGetWordNonTemplate (ByteOrder order, const byte *block, const byte *) |
word16 | UnalignedGetWordNonTemplate (ByteOrder order, const byte *block, const word16 *) |
word32 | UnalignedGetWordNonTemplate (ByteOrder order, const byte *block, const word32 *) |
word64 | UnalignedGetWordNonTemplate (ByteOrder order, const byte *block, const word64 *) |
void | UnalignedbyteNonTemplate (ByteOrder order, byte *block, byte value, const byte *xorBlock) |
void | UnalignedbyteNonTemplate (ByteOrder order, byte *block, word16 value, const byte *xorBlock) |
void | UnalignedbyteNonTemplate (ByteOrder order, byte *block, word32 value, const byte *xorBlock) |
void | UnalignedbyteNonTemplate (ByteOrder order, byte *block, word64 value, const byte *xorBlock) |
template<class T > | |
T | GetWord (bool assumeAligned, ByteOrder order, const byte *block) |
template<class T > | |
void | GetWord (bool assumeAligned, ByteOrder order, T &result, const byte *block) |
template<class T > | |
void | PutWord (bool assumeAligned, ByteOrder order, byte *block, T value, const byte *xorBlock=NULL) |
template<class T > | |
std::string | WordToString (T value, ByteOrder order=BIG_ENDIAN_ORDER) |
template<class T > | |
T | StringToWord (const std::string &str, ByteOrder order=BIG_ENDIAN_ORDER) |
template<unsigned int bits, class T > | |
T | SafeRightShift (T value) |
template<unsigned int bits, class T > | |
T | SafeLeftShift (T value) |
Utility functions for the Crypto++ library.
Definition in file misc.h.
#define SIZE_MAX ... |
The maximum value of a machine word.
SIZE_MAX provides the maximum value of a machine word. The value is 0xffffffff
on 32-bit machines, and 0xffffffffffffffff
on 64-bit machines. Internally, SIZE_MAX is defined as __SIZE_MAX__ if __SIZE_MAX__ is defined. If not defined, then SIZE_T_MAX is tried. If neither __SIZE_MAX__ nor SIZE_T_MAX is is defined, the library uses std::numeric_limits<size_t>::max(). The library prefers __SIZE_MAX__ because its a constexpr that is optimized well by all compilers. std::numeric_limits<size_t>::max() is not a constexpr, and it is not always optimized well.
Definition at line 70 of file misc.h.
Referenced by PolynomialMod2::AllOnes(), AllocatorBase< word32 >::destroy(), FilterWithBufferedInput::FilterWithBufferedInput(), FixedRNG::GenerateBlock(), FilterWithBufferedInput::IsolatedInitialize(), MeterFilter::IsolatedMessageSeriesEnd(), AllocatorBase< word32 >::max_size(), RoundUpToMultipleOf(), and FileStore::TransferTo2().
#define CRYPTOPP_COMPILE_ASSERT | ( | expr | ) | ... |
Compile time assertion.
expr | the expression to evaluate |
Asserts the expression expr though a dummy struct.
Definition at line 98 of file misc.h.
Referenced by RandomPool::GenerateIntoBufferedTransformation(), and UnsignedMin().
#define COUNTOF | ( | arr | ) |
Counts elements in an array.
arr | an array of elements |
COUNTOF counts elements in an array. On Windows COUNTOF(x) is deinfed to _countof(x)
to ensure correct results for pointers. Since the library code is cross-platform, Windows will ensure the safety on non-Windows platforms.
Definition at line 137 of file misc.h.
Referenced by Deflator::IsolatedFlush().
#define MEMORY_BARRIER ... |
A memory barrier.
MEMORY_BARRIER attempts to ensure reads and writes are completed in the absence of a language synchronization point. It is used by the Singleton class if the compiler supports it. The use is provided at the customary check points in a double-checked initialization.
Internally, MEMORY_BARRIER uses intrinsic(_ReadWriteBarrier)
, _ReadWriteBarrier()
or __asm__("" ::: "memory")
.
Definition at line 210 of file misc.h.
Referenced by Singleton< T, F, instance >::Ref().
|
inline |
Bounds checking replacement for memcpy()
dest | pointer to the desination memory block |
sizeInBytes | the size of the desination memory block, in bytes |
src | pointer to the source memory block |
count | the size of the source memory block, in bytes |
InvalidArgument |
ISO/IEC TR-24772 provides bounds checking interfaces for potentially unsafe functions like memcpy(), strcpy() and memmove(). However, not all standard libraries provides them, like Glibc. The library's memcpy_s() is a near-drop in replacement. Its only a near-replacement because the library's version throws an InvalidArgument on a bounds violation.
memcpy_s() and memmove_s() are guarded by __STDC_WANT_SECURE_LIB__. If __STDC_WANT_SECURE_LIB__ is not defined or defined to 0, then the library makes memcpy_s() and memmove_s() available. The library will also optionally make the symbols available if CRYPTOPP_WANT_SECURE_LIB
is defined. CRYPTOPP_WANT_SECURE_LIB
is in config.h, but it is disabled by default.
memcpy_s() will assert the pointers src and dest are not NULL in debug builds. Passing NULL for either pointer is undefined behavior.
Definition at line 296 of file misc.h.
Referenced by SecBlock< word32 >::Assign(), ConditionalByteReverse(), HKDF< T >::DeriveKey(), PKCS5_PBKDF2_HMAC< T >::DeriveKey(), PKCS12_PBKDF< T >::DeriveKey(), IncrementCounterByOne(), CFB_ModePolicy::IVRequirement(), SecBlock< word32 >::operator+(), SecBlock< word32 >::operator+=(), FixedSizeAllocatorWithCleanup< unsigned int, S >::reallocate(), BlockOrientedCipherModeBase::Resynchronize(), SecBlock< word32 >::SecBlock(), and StandardReallocate().
|
inline |
Bounds checking replacement for memmove()
dest | pointer to the desination memory block |
sizeInBytes | the size of the desination memory block, in bytes |
src | pointer to the source memory block |
count | the size of the source memory block, in bytes |
InvalidArgument |
ISO/IEC TR-24772 provides bounds checking interfaces for potentially unsafe functions like memcpy(), strcpy() and memmove(). However, not all standard libraries provides them, like Glibc. The library's memmove_s() is a near-drop in replacement. Its only a near-replacement because the library's version throws an InvalidArgument on a bounds violation.
memcpy_s() and memmove_s() are guarded by __STDC_WANT_SECURE_LIB__. If __STDC_WANT_SECURE_LIB__ is not defined or defined to 0, then the library makes memcpy_s() and memmove_s() available. The library will also optionally make the symbols available if CRYPTOPP_WANT_SECURE_LIB
is defined. CRYPTOPP_WANT_SECURE_LIB
is in config.h, but it is disabled by default.
memmove_s() will assert the pointers src and dest are not NULL in debug builds. Passing NULL for either pointer is undefined behavior.
|
inline |
Memory block initializer and eraser that attempts to survive optimizations.
ptr | pointer to the memory block being written |
value | the integer value to write for each byte |
num | the size of the source memory block, in bytes |
Internally the function calls memset with the value value, and receives the return value from memset as a volatile
pointer.
Definition at line 370 of file misc.h.
Referenced by SecBlock< word32 >::CleanGrow(), SecBlock< word32 >::CleanNew(), and ConditionalByteReverse().
|
inline |
Replacement function for std::min.
a | the first value |
b | the second value |
b < a
using operator<
STDMIN was provided because the library could not use std::min or std::max in MSVC60 or Cygwin 1.1.0
Definition at line 386 of file misc.h.
Referenced by ESIGNFunction::ApplyFunction(), RSAFunction_ISO::ApplyFunction(), DL_GroupParameters_IntegerBased::AssignFrom(), EqualityComparisonFilter::ChannelPut2(), ByteQueue::CopyRangeTo2(), MessageQueue::CopyRangeTo2(), BERGeneralDecoder::CopyRangeTo2(), NullStore::CopyRangeTo2(), HKDF< T >::DeriveKey(), PKCS5_PBKDF2_HMAC< T >::DeriveKey(), PKCS12_PBKDF< T >::DeriveKey(), PolynomialMod2::Divide(), AdditiveCipherTemplate< BASE >::GenerateBlock(), KDF2_RNG::GenerateBlock(), InvertibleRWFunction::GenerateRandom(), NetworkSink::GetMaxObservedSpeed(), NetworkSource::GetWaitObjects(), IntegrityCheckModule(), PolynomialMod2::IsIrreducible(), Deflator::IsolatedFlush(), MeterFilter::IsolatedMessageSeriesEnd(), MaurerProvablePrime(), MihailescuProvablePrime(), PolynomialMod2::Parity(), Grouper::Put2(), ArraySink::Put2(), ArrayXorSink::Put2(), FixedSizeAllocatorWithCleanup< unsigned int, S >::reallocate(), AutoSeededX917RNG< BLOCK_CIPHER >::Reseed(), Deflator::SetDeflateLevel(), StandardReallocate(), FileStore::TransferTo2(), ByteQueue::TransferTo2(), MessageQueue::TransferTo2(), ByteQueue::Walker::TransferTo2(), and DL_GroupParameters_DSA::ValidateGroup().
|
inline |
Replacement function for std::max.
a | the first value |
b | the second value |
a < b
using operator<
STDMAX was provided because the library could not use std::min or std::max in MSVC60 or Cygwin 1.1.0
Definition at line 396 of file misc.h.
Referenced by NetworkSink::ComputeCurrentSpeed(), ByteQueue::CreatePutSpace(), DefaultDecryptor::DefaultDecryptor(), DEREncodeBitString(), PolynomialOver< T >::Divide(), Integer::Encode(), PolynomialMod2::MinEncodedSize(), Integer::MinEncodedSize(), ByteQueue::Put2(), FilterTester::Put2(), ArrayXorSink::Put2(), FixedSizeAllocatorWithCleanup< unsigned int, S >::reallocate(), and Deflator::SetDeflateLevel().
|
inline |
Safe comparison of values that could be neagtive and incorrectly promoted.
a | the first value |
b | the second value |
operator<
.The comparison b < a
is performed and the value returned is a's type T1.
Definition at line 422 of file misc.h.
References CRYPTOPP_COMPILE_ASSERT.
Referenced by StringStore::CopyRangeTo2(), NonblockingSource::GeneralPump2(), RandomPool::GenerateIntoBufferedTransformation(), X917RNG::GenerateIntoBufferedTransformation(), RandomNumberGenerator::GenerateIntoBufferedTransformation(), GetAlignmentOf(), MessageQueue::GetNextMessage(), NetworkSource::GetWaitObjects(), Inflator::IsolatedFlush(), Inflator::IsolatedInitialize(), GCM_Base::OptimalDataAlignment(), NetworkSink::Put2(), AutoSeededX917RNG< BLOCK_CIPHER >::Reseed(), Deflator::SetDeflateLevel(), NonblockingSink::TimedFlush(), FileStore::TransferTo2(), RandomNumberStore::TransferTo2(), DMAC_Base< T >::UncheckedSetKey(), Weak::MD2::Update(), CMAC_Base::Update(), and X917RNG::X917RNG().
|
inline |
Tests whether a conversion from → to is safe to perform.
from | the first value |
to | the second value |
Definition at line 436 of file misc.h.
Referenced by DERLengthEncode(), PolynomialMod2::Divide(), FileSink::Put2(), PK_DefaultEncryptionFilter::Put2(), PK_DefaultDecryptionFilter::Put2(), and FileStore::Skip().
std::string IntToString | ( | T | value, |
unsigned int | base = 10 |
||
) |
Converts a value to a string.
value | the value to convert |
base | the base to use during the conversion |
Definition at line 449 of file misc.h.
References IntToString< Integer >(), and IntToString< unsigned long long >().
Referenced by VMAC_Base::AlgorithmName(), SHA3::AlgorithmName(), TF_DecryptorBase::Decrypt(), TF_EncryptorBase::Encrypt(), FixedRNG::GenerateBlock(), NetworkSource::GetWaitObjects(), Deflator::IsolatedInitialize(), MaurerRandomnessTest::Put2(), NetworkSink::Put2(), SecureWipeArray(), Deflator::SetDeflateLevel(), SimpleKeyingInterface::SetKeyWithIV(), AuthenticatedSymmetricCipher::SpecifyDataLengths(), TTMAC_Base::TruncatedFinal(), AuthenticatedSymmetricCipherBase::TruncatedFinal(), and HashTransformation::TruncatedVerify().
std::string IntToString< unsigned long long > | ( | unsigned long long | value, |
unsigned int | base | ||
) |
Converts an unsigned value to a string.
value | the value to convert |
base | the base to use during the conversion |
this template function specialization was added to suppress Coverity findings on IntToString() with unsigned types.
Definition at line 4373 of file integer.cpp.
Referenced by IntToString().
std::string IntToString< Integer > | ( | Integer | value, |
unsigned int | base | ||
) |
Converts an Integer to a string.
value | the Integer to convert |
base | the base to use during the conversion |
This is a template specialization of IntToString(). Use it like IntToString():
// Print integer in base 10 Integer n... std::string s = IntToString(n, 10);
The string is presented with lowercase letters by default. A hack is available to switch to uppercase letters without modifying the function signature.sha
// Print integer in base 10, uppercase letters Integer n... const unsigned int UPPER = (1 << 31); std::string s = IntToString(n, (UPPER | 10));
Definition at line 4307 of file integer.cpp.
References BitPrecision(), Integer::Divide(), and SaturatingSubtract1().
Referenced by IntToString().
unsigned int Parity | ( | T | value | ) |
Returns the parity of a value.
value | the value to provide the parity |
Definition at line 532 of file misc.h.
Referenced by PolynomialMod2::operator[](), and PolynomialMod2::Parity().
unsigned int BytePrecision | ( | const T & | value | ) |
Returns the number of 8-bit bytes or octets required for a value.
value | the value to test |
Definition at line 543 of file misc.h.
Referenced by PolynomialMod2::ByteCount(), Integer::ByteCount(), and DERLengthEncode().
unsigned int BitPrecision | ( | const T & | value | ) |
Returns the number of bits required for a value.
value | the value to test |
Definition at line 565 of file misc.h.
Referenced by PolynomialMod2::BitCount(), Integer::BitCount(), DEREncodeBitString(), Integer::Divide(), MersenneTwister< K, M, N, F, S >::GenerateWord32(), RandomNumberGenerator::GenerateWord32(), and IntToString< Integer >().
|
inline |
Determines the number of trailing 0-bits in a value.
v | the 32-bit value to test |
TrailingZeros returns the number of trailing 0-bits in v, starting at the least significant bit position. The return value is undefined if there are no 1-bits set in the value v.
Definition at line 590 of file misc.h.
Referenced by TrailingZeros().
|
inline |
Determines the number of trailing 0-bits in a value.
v | the 64-bit value to test |
TrailingZeros returns the number of trailing 0-bits in v, starting at the least significant bit position. The return value is undefined if there are no 1-bits set in the value v.
Definition at line 616 of file misc.h.
References TrailingZeros().
|
inline |
Truncates the value to the specified number of bits.
value | the value to truncate or mask |
bits | the number of bits to truncate or mask |
This function masks the low-order bits of value and returns the result. The mask is created with (1 << bits) - 1
.
Definition at line 638 of file misc.h.
Referenced by PolynomialMod2::AllOnes(), MersenneTwister< K, M, N, F, S >::GenerateWord32(), RandomNumberGenerator::GenerateWord32(), PolynomialMod2::IsIrreducible(), PolynomialMod2::PolynomialMod2(), and Integer::Randomize().
|
inline |
Returns the number of 8-bit bytes or octets required for the specified number of bits.
bitCount | the number of bits |
BitsToBytes is effectively a ceiling function based on 8-bit bytes.
Definition at line 650 of file misc.h.
Referenced by Inflator::IsolatedFlush(), Integer::OpenPGPDecode(), Integer::OpenPGPEncode(), and DL_GroupParameters_DSA::ValidateGroup().
|
inline |
Returns the number of words required for the specified number of bytes.
byteCount | the number of bytes |
BytesToWords is effectively a ceiling function based on WORD_SIZE
. WORD_SIZE
is defined in config.h
Definition at line 660 of file misc.h.
Referenced by Integer::Decode(), PolynomialMod2::Encode(), PolynomialMod2::SetByte(), and Integer::SetByte().
|
inline |
Returns the number of words required for the specified number of bits.
bitCount | the number of bits |
BitsToWords is effectively a ceiling function based on WORD_BITS
. WORD_BITS
is defined in config.h
Definition at line 670 of file misc.h.
Referenced by PolynomialMod2::Divide(), Integer::DivideByPowerOf2(), PolynomialMod2::IsIrreducible(), Integer::Power2(), and Integer::SetBit().
|
inline |
Returns the number of double words required for the specified number of bits.
bitCount | the number of bits |
BitsToDwords is effectively a ceiling function based on 2*WORD_BITS
. WORD_BITS
is defined in config.h
Definition at line 680 of file misc.h.
References VerifyBufsEqual(), and xorbuf().
void xorbuf | ( | byte * | buf, |
const byte * | mask, | ||
size_t | count | ||
) |
Performs an XOR of a buffer with a mask.
buf | the buffer to XOR with the mask |
mask | the mask to XOR with the buffer |
count | the size of the buffers, in bytes |
The function effectively visits each element in the buffers and performs buf[i] ^= mask[i]
. buf and mask must be of equal size.
Definition at line 25 of file misc.cpp.
Referenced by BlockTransformation::AdvancedProcessBlocks(), BitsToDwords(), DES::CorrectKeyParityBits(), PKCS5_PBKDF2_HMAC< T >::DeriveKey(), AdditiveCipherTemplate< BASE >::GenerateBlock(), X917RNG::GenerateIntoBufferedTransformation(), TestDataNameValuePairs::GetVoidValue(), CBC_CTS_Encryption::ProcessLastBlock(), CBC_CTS_Decryption::ProcessLastBlock(), ArrayXorSink::Put2(), CMAC_Base::Update(), SHA3::Update(), and X917RNG::X917RNG().
void xorbuf | ( | byte * | output, |
const byte * | input, | ||
const byte * | mask, | ||
size_t | count | ||
) |
Performs an XOR of an input buffer with a mask and stores the result in an output buffer.
output | the destination buffer |
input | the source buffer to XOR with the mask |
mask | the mask buffer to XOR with the input buffer |
count | the size of the buffers, in bytes |
The function effectively visits each element in the buffers and performs output[i] = input[i] ^ mask[i]
. output, input and mask must be of equal size.
bool VerifyBufsEqual | ( | const byte * | buf1, |
const byte * | buf2, | ||
size_t | count | ||
) |
Performs a near constant-time comparison of two equally sized buffers.
buf1 | the first buffer |
buf2 | the second buffer |
count | the size of the buffers, in bytes |
The function effectively performs an XOR of the elements in two equally sized buffers and retruns a result based on the XOR operation. The function is near constant-time because CPU micro-code timings could affect the "constant-ness". Calling code is responsible for mitigating timing attacks if the buffers are not equally sized.
Definition at line 93 of file misc.cpp.
Referenced by BitsToDwords(), DefaultDecryptor::DefaultDecryptor(), IntegrityCheckModule(), SecBlock< word32 >::operator==(), VMAC_Base::Resynchronize(), and HashTransformation::TruncatedVerify().
|
inline |
Tests whether a value is a power of 2.
value | the value to test |
The function creates a mask of value - 1
and returns the result of an AND operation compared to 0. If value is 0 or less than 0, then the function returns false.
Definition at line 718 of file misc.h.
Referenced by IsAlignedOn(), ModPowerOf2(), and RoundDownToMultipleOf().
|
inline |
Tests whether the residue of a value is a power of 2.
a | the value to test |
b | the value to use to reduce to its residue |
a%b
is a power of 2, false otherwiseThe function effectively creates a mask of b - 1
and returns the result of an AND operation compared to 0. b must be a power of 2 or the result is undefined.
Definition at line 730 of file misc.h.
References IsPowerOf2().
Referenced by IsAlignedOn(), VMAC_Base::OptimalDataAlignment(), RoundDownToMultipleOf(), and VMAC_Base::TruncatedFinal().
|
inline |
Rounds a value down to a multiple of a second value.
n | the value to reduce |
m | the value to reduce to to a multiple |
RoundDownToMultipleOf is effectively a floor function based on m. The function returns the value n - n%m
. If n is a multiple of m, then the original value is returned.
Definition at line 743 of file misc.h.
References IsPowerOf2(), and ModPowerOf2().
Referenced by FilterWithBufferedInput::IsolatedFlush(), ArrayXorSink::Put2(), and RoundUpToMultipleOf().
|
inline |
Rounds a value up to a multiple of a second value.
n | the value to reduce |
m | the value to reduce to to a multiple |
RoundUpToMultipleOf is effectively a ceiling function based on m. The function returns the value n + n%m
. If n is a multiple of m, then the original value is returned. If the value n would overflow, then an InvalidArgument exception is thrown.
Definition at line 759 of file misc.h.
References RoundDownToMultipleOf(), and SIZE_MAX.
Referenced by ConditionalByteReverse(), DEREncodeBitString(), PKCS12_PBKDF< T >::DeriveKey(), MersenneTwister< K, M, N, F, S >::DiscardBytes(), AdditiveCipherTemplate< BASE >::GenerateBlock(), and Deflator::IsolatedFlush().
|
inline |
Returns the minimum alignment requirements of a type.
dummy | an unused Visual C++ 6.0 workaround |
Internally the function calls C++11's alignof if available. If not available, the function uses compiler specific extensions such as __alignof and _alignof_. sizeof(T) is used if the others are not available. In all cases, if CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS is defined, then the function returns 1.
Definition at line 774 of file misc.h.
References UnsignedMin().
|
inline |
Determines whether ptr is aligned to a minimum value.
ptr | the pointer being checked for alignment |
alignment | the alignment value to test the pointer against |
Internally the function tests whether alignment is 1. If so, the function returns true. If not, then the function effectively performs a modular reduction and returns true if the residue is 0
Definition at line 801 of file misc.h.
References IsPowerOf2(), and ModPowerOf2().
Referenced by FixedSizeAllocatorWithCleanup< unsigned int, S >::allocate(), CallNewHandler(), AdditiveCipherTemplate< BASE >::GenerateBlock(), and IsAligned().
|
inline |
Determines whether ptr is minimally aligned.
ptr | the pointer to check for alignment |
dummy | an unused Visual C++ 6.0 workaround |
Internally the function calls IsAlignedOn with a second parameter of GetAlignmentOf<T>
Definition at line 812 of file misc.h.
References IsAlignedOn().
|
inline |
Returns NativeByteOrder as an enumerated ByteOrder value.
NativeByteOrder is a typedef depending on the platform. If IS_LITTLE_ENDIAN is set in GetNativeByteOrder returns LittleEndian. If IS_BIG_ENDIAN is set, then GetNativeByteOrder returns BigEndian.
Definition at line 834 of file misc.h.
Referenced by NativeByteOrderIs().
|
inline |
Determines whether order follows native byte ordering.
order | the ordering being tested against native byte ordering |
Definition at line 842 of file misc.h.
References GetNativeByteOrder().
Referenced by ConditionalByteReverse().
|
inline |
Performs a saturating subtract clamped at 0.
a | the minuend |
b | the subtrahend |
Saturating arithmetic restricts results to a fixed range. Results that are less than 0 are clamped at 0.
Use of saturating arithmetic in places can be advantageous because it can avoid a branch by using an instruction like a conditional move (CMOVE
).
Definition at line 855 of file misc.h.
Referenced by ArraySink::CreatePutSpace(), NonblockingSource::GeneralPump2(), NetworkSource::GetWaitObjects(), ESIGNFunction::ImageBound(), OAEP_Base::MaxUnpaddedLength(), PKCS_EncryptionPaddingScheme::MaxUnpaddedLength(), Filter::MessageSeriesEnd(), NetworkSink::Put2(), ArraySink::Put2(), ArrayXorSink::Put2(), Deflator::SetDeflateLevel(), NonblockingSink::TimedFlush(), and DL_GroupParameters_DSA::ValidateGroup().
|
inline |
Performs a saturating subtract clamped at 1.
a | the minuend |
b | the subtrahend |
Saturating arithmetic restricts results to a fixed range. Results that are less than 1 are clamped at 1.
Use of saturating arithmetic in places can be advantageous because it can avoid a branch by using an instruction like a conditional move (CMOVE
).
Definition at line 869 of file misc.h.
Referenced by IntToString< Integer >().
|
inline |
Returns the direction the cipher is being operated.
obj | the cipher object being queried |
ciphers can be operated in a "forward" direction (encryption) and a "reverse" direction (decryption). The operations do not have to be symmetric, meaning a second application of the transformation does not necessariy return the original message. That is, E(D(m))
may not equal E(E(m))
; and D(E(m))
may not equal D(D(m))
.
Definition at line 884 of file misc.h.
References CallNewHandler().
Referenced by AdditiveCipherTemplate< BASE >::GenerateBlock().
void CallNewHandler | ( | ) |
Attempts to reclaim unused memory.
bad_alloc |
In the normal course of running a program, a request for memory normally succeeds. If a call to AlignedAllocate or UnalignedAllocate fails, then CallNewHandler is called in an effort to recover. Internally, CallNewHandler calls set_new_handler(NULL) in an effort to free memory. There is no guarantee CallNewHandler will be able to procure more memory so an allocation succeeds. If the call to set_new_handler fails, then CallNewHandler throws a bad_alloc exception.
Definition at line 138 of file misc.cpp.
References AlignedAllocate(), AlignedDeallocate(), and IsAlignedOn().
Referenced by GetCipherDir(), and UnalignedAllocate().
|
inline |
Performs an addition with carry on a block of bytes.
inout | the byte block |
size | the size of the block, in bytes |
Performs an addition with carry by adding 1 on a block of bytes starting at the least significant byte. Once carry is 0, the function terminates and returns to the caller.
Definition at line 905 of file misc.h.
Referenced by X917RNG::GenerateIntoBufferedTransformation().
|
inline |
Performs an addition with carry on a block of bytes.
output | the destination block of bytes |
input | the source block of bytes |
size | the size of the block |
Performs an addition with carry on a block of bytes starting at the least significant byte. Once carry is 0, the remaining bytes from input are copied to output using memcpy.
The function is close to near-constant time because it operates on all the bytes in the blocks.
Definition at line 919 of file misc.h.
References memcpy_s().
|
inline |
|
inline |
void SecureWipeBuffer | ( | T * | buf, |
size_t | n | ||
) |
Sets each element of an array to 0.
buf | an array of elements |
n | the number of elements in the array |
The operation is effectively a wipe or zeroization. The operation attempts to survive optimizations and dead code removal
Definition at line 961 of file misc.h.
Referenced by SecureWipeArray().
|
inline |
Sets each element of an array to 0.
buf | an array of elements |
n | the number of elements in the array |
The operation is effectively a wipe or zeroization. The operation attempts to survive optimizations and dead code removal
Definition at line 1038 of file misc.h.
References AlignedAllocate(), AlignedDeallocate(), IntToString(), SecureWipeBuffer(), UnalignedAllocate(), and UnalignedDeallocate().
Referenced by AllocatorWithCleanup< word32 >::deallocate(), FixedSizeAllocatorWithCleanup< unsigned int, S >::deallocate(), and FixedSizeAllocatorWithCleanup< unsigned int, S >::reallocate().
void* AlignedAllocate | ( | size_t | size | ) |
Allocates a buffer on 16-byte boundary.
size | the size of the buffer |
AlignedAllocate is primarily used when the data will be proccessed by MMX and SSE2 instructions. The assembly language routines rely on the alignment. If the alignment is not respected, then a SIGBUS is generated under Unix and an EXCEPTION_DATATYPE_MISALIGNMENT is generated under Windows.
Referenced by AllocatorWithCleanup< word32 >::allocate(), CallNewHandler(), and SecureWipeArray().
void AlignedDeallocate | ( | void * | ptr | ) |
Frees a buffer allocated with AlignedAllocate.
ptr | the buffer to free |
Referenced by CallNewHandler(), AllocatorWithCleanup< word32 >::deallocate(), and SecureWipeArray().
void* UnalignedAllocate | ( | size_t | size | ) |
Allocates a buffer.
size | the size of the buffer |
Definition at line 192 of file misc.cpp.
References CallNewHandler().
Referenced by AllocatorWithCleanup< word32 >::allocate(), and SecureWipeArray().
void UnalignedDeallocate | ( | void * | ptr | ) |
Frees a buffer allocated with UnalignedAllocate.
ptr | the buffer to free |
Definition at line 200 of file misc.cpp.
Referenced by AllocatorWithCleanup< word32 >::deallocate(), and SecureWipeArray().
|
inline |
Performs a left rotate.
x | the value to rotate |
y | the number of bit positions to rotate the value |
This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits.
y must be in the range [0, sizeof(T)*8 - 1]
to avoid undefined behavior. Use rotlMod if the rotate amount y is outside the range.
rotate IMM
instruction because its often faster than a rotate REG
. Immediate rotates can be up to three times faster than their register counterparts. Definition at line 1166 of file misc.h.
Referenced by BitReverse(), ByteReverse(), and SAFER::Base::UncheckedSetKey().
|
inline |
Performs a right rotate.
x | the value to rotate |
y | the number of bit positions to rotate the value |
This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits.
y must be in the range [0, sizeof(T)*8 - 1]
to avoid undefined behavior. Use rotrMod if the rotate amount y is outside the range.
rotate IMM
instruction because its often faster than a rotate REG
. Immediate rotates can be up to three times faster than their register counterparts. Definition at line 1189 of file misc.h.
Referenced by ByteReverse().
|
inline |
Performs a left rotate.
x | the value to rotate |
y | the number of bit positions to rotate the value |
This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits.
y must be in the range [0, sizeof(T)*8 - 1]
to avoid undefined behavior. Use rotlMod if the rotate amount y is outside the range.
rotate IMM
instruction because its often faster than a rotate REG
. Immediate rotates can be up to three times faster than their register counterparts.
|
inline |
Performs a right rotate.
x | the value to rotate |
y | the number of bit positions to rotate the value |
This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits.
y must be in the range [0, sizeof(T)*8 - 1]
to avoid undefined behavior. Use rotrMod if the rotate amount y is outside the range.
rotate IMM
instruction because its often faster than a rotate REG
. Immediate rotates can be up to three times faster than their register counterparts.
|
inline |
Performs a left rotate.
x | the value to rotate |
y | the number of bit positions to rotate the value |
This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits.
y is reduced to the range [0, sizeof(T)*8 - 1]
to avoid undefined behavior.
rotate IMM
or rotate REG
.
|
inline |
Performs a right rotate.
x | the value to rotate |
y | the number of bit positions to rotate the value |
This is a portable C/C++ implementation. The value x to be rotated can be 8 to 64-bits.
y is reduced to the range [0, sizeof(T)*8 - 1]
to avoid undefined behavior.
rotate IMM
or rotate REG
.
|
inline |
Gets a byte from a value.
order | the ByteOrder of the value |
value | the value to retrieve the byte |
index | the location of the byte to retrieve |
Definition at line 1540 of file misc.h.
Referenced by PolynomialMod2::GetBit(), and RandomNumberGenerator::Shuffle().
|
inline |
Reverses bytes in a 8-bit value.
value | the 8-bit value to reverse |
Definition at line 1551 of file misc.h.
Referenced by BitReverse(), ByteReverse(), ConditionalByteReverse(), and MersenneTwister< K, M, N, F, S >::GenerateBlock().
|
inline |
Reverses bytes in a 16-bit value.
Performs an endian reversal
value | the 16-bit value to reverse |
ByteReverse calls bswap if available. Otherwise the function performs a 8-bit rotate on the word16
Definition at line 1560 of file misc.h.
References rotlFixed().
|
inline |
Reverses bytes in a 32-bit value.
Performs an endian reversal
value | the 32-bit value to reverse |
ByteReverse calls bswap if available. Otherwise the function uses a combination of rotates on the word32
Definition at line 1575 of file misc.h.
References rotlFixed(), and rotrFixed().
|
inline |
Reverses bytes in a 64-bit value.
Performs an endian reversal
value | the 64-bit value to reverse |
ByteReverse calls bswap if available. Otherwise the function uses a combination of rotates on the word64
Definition at line 1600 of file misc.h.
References ByteReverse(), and rotlFixed().
|
inline |
Reverses bits in a 8-bit value.
value | the 8-bit value to reverse |
BitReverse performs a combination of shifts on the byte
Definition at line 1621 of file misc.h.
References rotlFixed().
Referenced by BitReverse(), and HuffmanEncoder::Initialize().
|
inline |
Reverses bits in a 16-bit value.
value | the 16-bit value to reverse |
BitReverse performs a combination of shifts on the word16
Definition at line 1631 of file misc.h.
References ByteReverse().
|
inline |
Reverses bits in a 32-bit value.
value | the 32-bit value to reverse |
BitReverse performs a combination of shifts on the word32
Definition at line 1642 of file misc.h.
References ByteReverse().
|
inline |
Reverses bits in a 64-bit value.
value | the 64-bit value to reverse |
BitReverse performs a combination of shifts on the word64
Definition at line 1653 of file misc.h.
References BitReverse(), and ByteReverse().
|
inline |
Reverses bits in a value.
value | the value to reverse |
The template overload of BitReverse operates on signed and unsigned values. Internally the size of T is checked, and then value is cast to a byte, word16, word32 or word64. After the cast, the appropriate BitReverse overload is called.
Definition at line 1672 of file misc.h.
References BitReverse().
|
inline |
Reverses bytes in a value depending upon endianess.
T | the class or type |
order | the ByteOrder the data is represented |
value | the value to conditionally reverse |
Internally, the ConditionalByteReverse calls NativeByteOrderIs. If order matches native byte order, then the original value is returned. If not, then ByteReverse is called on the value before returning to the caller.
Definition at line 1695 of file misc.h.
References ByteReverse(), and NativeByteOrderIs().
Referenced by ConditionalByteReverse(), and VMAC_Base::TruncatedFinal().
void ByteReverse | ( | T * | out, |
const T * | in, | ||
size_t | byteCount | ||
) |
Reverses bytes in an element among an array of elements.
T | the class or type |
out | the output array of elements |
in | the input array of elements |
byteCount | the byte count of the arrays |
Internally, ByteReverse visits each element in the in array calls ByteReverse on it, and writes the result to out.
ByteReverse does not process tail byes, or bytes that are not part of a full element. If T is int (and int is 4 bytes), then byteCount = 10
means only the first 8 bytes are reversed.
Definition at line 1713 of file misc.h.
References ByteReverse().
|
inline |
Reverses bytes in an element among an array of elements depending upon endianess.
T | the class or type |
order | the ByteOrder the data is represented |
out | the output array of elements |
in | the input array of elements |
byteCount | the byte count of the arrays |
Internally, ByteReverse visits each element in the in array calls ByteReverse on it, and writes the result to out.
ByteReverse does not process tail byes, or bytes that are not part of a full element. If T is int (and int is 4 bytes), then byteCount = 10
means only the first 8 bytes are reversed.
Definition at line 1735 of file misc.h.
References ByteReverse(), ConditionalByteReverse(), memcpy_s(), memset_z(), NativeByteOrderIs(), and RoundUpToMultipleOf().