misc.h File Reference

Utility functions for the Crypto++ library. More...

Go to the source code of this file.

## Classes

class | Empty
| An Empty class. More...
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 >
| Access a block of memory. More...
class | PutBlock< T, B, A >
| Access a block of memory. More...
class | BlockGetAndPut< T, B, GA, PA >
| Access a block of memory. More...
class | SafeShifter< overflow >
| Safely shift values when undefined behavior could occur. More...
class | SafeShifter< true >
| Shifts a value in the presence of overflow. More...
class | SafeShifter< false >
| Shifts a value in the absence of overflow. More...

## 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 *)(void *)(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 *)(void *)(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 *)(void *)(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 *)(void *)(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 *)(void *)(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 *)(void *)(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 *)(void *)(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 *)(void *)(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...
template<class T >
void | vec_swap (T &a, T &b)
| Swaps two variables which are arrays. 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< word64 > (word64 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 from an array of elements. More...
template<class T >
void | ConditionalByteReverse (ByteOrder order, T *out, const T *in, size_t byteCount)
| Conditionally reverses bytes in an element from an array of elements. 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)

## Detailed Description

Utility functions for the Crypto++ library.

Definition in file misc.h.

## Macro Definition Documentation

## SIZE_MAX

#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 95 of file misc.h.

## CRYPTOPP_COMPILE_ASSERT

#define CRYPTOPP_COMPILE_ASSERT | ( |  | expr | ) | ...

Compile time assertion.

Parameters

  expr | the expression to evaluate

Asserts the expression expr though a dummy struct.

Definition at line 123 of file misc.h.

## COUNTOF

#define COUNTOF | ( |  | arr | ) |

Counts elements in an array.

Parameters

  arr | an array of elements

COUNTOF counts elements in an array. On Windows COUNTOF(x) is defined to `_countof(x)` to ensure correct results for pointers.

Note
  COUNTOF does not produce correct results with pointers, and an array must be used. `sizeof(x)/sizeof(x[0])` suffers the same problem. The risk is eliminated by using `_countof(x)` on Windows. Windows will provide the immunity for other platforms.

Definition at line 161 of file misc.h.

## MEMORY_BARRIER

#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 barrier is provided at the customary places in a double-checked initialization.

Internally, MEMORY_BARRIER uses `std::atomic_thread_fence` if C++11 atomics are available. Otherwise, `intrinsic(_ReadWriteBarrier)`, `_ReadWriteBarrier()` or `__asm__("" ::: "memory")` is used.

Definition at line 237 of file misc.h.

## Function Documentation

## memcpy_s()

void memcpy_s | ( | void * | dest,
|  | size_t | sizeInBytes,
|  | const void * | src,
|  | size_t | count
| ) |  |

inline

Bounds checking replacement for memcpy()

Parameters

  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

Exceptions

  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 356 of file misc.h.

## memmove_s()

void memmove_s | ( | void * | dest,
|  | size_t | sizeInBytes,
|  | const void * | src,
|  | size_t | count
| ) |  |

inline

Bounds checking replacement for memmove()

Parameters

  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

Exceptions

  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.

Definition at line 398 of file misc.h.

## vec_swap()

template<class T >

void vec_swap | ( | T & | a,
|  | T & | b
| ) |  |

inline

Swaps two variables which are arrays.

Parameters

  a | the first value
  b | the second value

C++03 does not provide support for `std::swap(__m128i a, __m128i b)` because `__m128i` is an `unsigned long long[2]`. Most compilers support it out of the box, but Sun Studio C++ compilers 12.2 and 12.3 do not.

See also
  How to swap two __m128i variables in C++03 given its an opaque type and an array? on Stack Overflow.

Definition at line 439 of file misc.h.

## memset_z()

void* memset_z | ( | void * | ptr,
|  | int | value,
|  | size_t | num
| ) |  |

inline

Memory block initializer and eraser that attempts to survive optimizations.

Parameters

  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 451 of file misc.h.

## STDMIN()

template<class T >

const T& STDMIN | ( | const T & | a,
|  | const T & | b
| ) |  |

inline

Replacement function for std::min.

Parameters

  a | the first value
  b | the second value

Returns
  the minimum value based on a comparison of `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 467 of file misc.h.

## STDMAX()

template<class T >

const T& STDMAX | ( | const T & | a,
|  | const T & | b
| ) |  |

inline

Replacement function for std::max.

Parameters

  a | the first value
  b | the second value

Returns
  the minimum value based on a comparison of `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 477 of file misc.h.

## UnsignedMin()

template<class T1 , class T2 >

const T1 UnsignedMin | ( | const T1 & | a,
|  | const T2 & | b
| ) |  |

inline

Safe comparison of values that could be neagtive and incorrectly promoted.

Parameters

  a | the first value
  b | the second value

Returns
  the minimum value based on a comparison a and b using `operator<`.

The comparison `b < a` is performed and the value returned is a's type T1.

Definition at line 503 of file misc.h.

## SafeConvert()

template<class T1 , class T2 >

bool SafeConvert | ( | T1 | from,
|  | T2 & | to
| ) |  |

inline

Tests whether a conversion from -> to is safe to perform.

Parameters

  from | the first value
  to | the second value

Returns
  true if its safe to convert from into to, false otherwise.

Definition at line 517 of file misc.h.

## IntToString()

template<class T >

std::string IntToString | ( | T | value,
|  | unsigned int | base = `10`
| ) |  |

Converts a value to a string.

Parameters

  value | the value to convert
  base | the base to use during the conversion

Returns
  the string representation of value in base.

Definition at line 530 of file misc.h.

## IntToString< word64 >()

template<>

std::string IntToString< word64 > | ( | word64 | value,
|  | unsigned int | base
| ) |  |

Converts an unsigned value to a string.

Parameters

  value | the value to convert
  base | the base to use during the conversion

Returns
  the string representation of value in base.

this template function specialization was added to suppress Coverity findings on IntToString() with unsigned types.

Definition at line 4551 of file integer.cpp.

## IntToString< Integer >()

template<>

std::string IntToString< Integer > | ( | Integer | value,
|  | unsigned int | base
| ) |  |

Converts an Integer to a string.

Parameters

  value | the Integer to convert
  base | the base to use during the conversion

Returns
  the string representation of value in base.

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.

      // Print integer in base 16, uppercase letters
      Integer n...
      const unsigned int UPPER = (1 << 31);
      std::string s = IntToString(n, (UPPER | 16));

Definition at line 4485 of file integer.cpp.

## Parity()

template<class T >

unsigned int Parity | ( | T | value | ) |

Returns the parity of a value.

Parameters

  value | the value to provide the parity

Returns
  1 if the number 1-bits in the value is odd, 0 otherwise

Definition at line 612 of file misc.h.

## BytePrecision()

template<class T >

unsigned int BytePrecision | ( | const T & | value | ) |

Returns the number of 8-bit bytes or octets required for a value.

Parameters

  value | the value to test

Returns
  the minimum number of 8-bit bytes or octets required to represent a value

Definition at line 623 of file misc.h.

## BitPrecision()

template<class T >

unsigned int BitPrecision | ( | const T & | value | ) |

Returns the number of bits required for a value.

Parameters

  value | the value to test

Returns
  the maximum number of bits required to represent a value.

Definition at line 645 of file misc.h.

## TrailingZeros() [1/2]

unsigned int TrailingZeros | ( | word32 | v | ) |

inline

Determines the number of trailing 0-bits in a value.

Parameters

  v | the 32-bit value to test

Returns
  the number of trailing 0-bits in v, starting at the least significant bit position

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.

Note
  The function does not return 0 if no 1-bits are set because 0 collides with a 1-bit at the 0-th position.

Definition at line 670 of file misc.h.

## TrailingZeros() [2/2]

unsigned int TrailingZeros | ( | word64 | v | ) |

inline

Determines the number of trailing 0-bits in a value.

Parameters

  v | the 64-bit value to test

Returns
  the number of trailing 0-bits in v, starting at the least significant bit position

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.

Note
  The function does not return 0 if no 1-bits are set because 0 collides with a 1-bit at the 0-th position.

Definition at line 701 of file misc.h.

## Crop()

template<class T >

T Crop | ( | T | value,
|  | size_t | bits
| ) |  |

inline

Truncates the value to the specified number of bits.

Parameters

  value | the value to truncate or mask
  bits | the number of bits to truncate or mask

Returns
  the value truncated to the specified number of bits, starting at the least significant bit position

This function masks the low-order bits of value and returns the result. The mask is created with `(1 << bits) - 1`.

Definition at line 728 of file misc.h.

## BitsToBytes()

size_t BitsToBytes | ( | size_t | bitCount | ) |

inline

Returns the number of 8-bit bytes or octets required for the specified number of bits.

Parameters

  bitCount | the number of bits

Returns
  the minimum number of 8-bit bytes or octets required by bitCount

BitsToBytes is effectively a ceiling function based on 8-bit bytes.

Definition at line 740 of file misc.h.

## BytesToWords()

size_t BytesToWords | ( | size_t | byteCount | ) |

inline

Returns the number of words required for the specified number of bytes.

Parameters

  byteCount | the number of bytes

Returns
  the minimum number of words required by byteCount

BytesToWords is effectively a ceiling function based on `WORD_SIZE`. `WORD_SIZE` is defined in config.h

Definition at line 750 of file misc.h.

## BitsToWords()

size_t BitsToWords | ( | size_t | bitCount | ) |

inline

Returns the number of words required for the specified number of bits.

Parameters

  bitCount | the number of bits

Returns
  the minimum number of words required by bitCount

BitsToWords is effectively a ceiling function based on `WORD_BITS`. `WORD_BITS` is defined in config.h

Definition at line 760 of file misc.h.

## BitsToDwords()

size_t BitsToDwords | ( | size_t | bitCount | ) |

inline

Returns the number of double words required for the specified number of bits.

Parameters

  bitCount | the number of bits

Returns
  the minimum number of double words required by bitCount

BitsToDwords is effectively a ceiling function based on `2*WORD_BITS`. `WORD_BITS` is defined in config.h

Definition at line 770 of file misc.h.

## xorbuf() [1/2]

void xorbuf | ( | byte * | buf,
|  | const byte * | mask,
|  | size_t | count
| ) |  |

Performs an XOR of a buffer with a mask.

Parameters

  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 28 of file misc.cpp.

## xorbuf() [2/2]

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.

Parameters

  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.

Definition at line 61 of file misc.cpp.

## VerifyBufsEqual()

bool VerifyBufsEqual | ( | const byte * | buf1,
|  | const byte * | buf2,
|  | size_t | count
| ) |  |

Performs a near constant-time comparison of two equally sized buffers.

Parameters

  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 96 of file misc.cpp.

## IsPowerOf2()

template<class T >

bool IsPowerOf2 | ( | const T & | value | ) |

inline

Tests whether a value is a power of 2.

Parameters

  value | the value to test

Returns
  true if value is a power of 2, false otherwise

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 808 of file misc.h.

## ModPowerOf2()

template<class T1 , class T2 >

T2 ModPowerOf2 | ( | const T1 & | a,
|  | const T2 & | b
| ) |  |

inline

Tests whether the residue of a value is a power of 2.

Parameters

  a | the value to test
  b | the value to use to reduce to its residue

Returns
  true if `a%b` is a power of 2, false otherwise

The 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 836 of file misc.h.

## RoundDownToMultipleOf()

template<class T1 , class T2 >

T1 RoundDownToMultipleOf | ( | const T1 & | n,
|  | const T2 & | m
| ) |  |

inline

Rounds a value down to a multiple of a second value.

Parameters

  n | the value to reduce
  m | the value to reduce to to a multiple

Returns
  the possibly unmodified value

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 849 of file misc.h.

## RoundUpToMultipleOf()

template<class T1 , class T2 >

T1 RoundUpToMultipleOf | ( | const T1 & | n,
|  | const T2 & | m
| ) |  |

inline

Rounds a value up to a multiple of a second value.

Parameters

  n | the value to reduce
  m | the value to reduce to to a multiple

Returns
  the possibly unmodified value

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 865 of file misc.h.

## GetAlignmentOf()

template<class T >

unsigned int GetAlignmentOf | ( | T * | dummy = `NULL` | ) |

inline

Returns the minimum alignment requirements of a type.

Parameters

  dummy | an unused Visual C++ 6.0 workaround

Returns
  the minimum alignment requirements of a type, in bytes

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 880 of file misc.h.

## IsAlignedOn()

bool IsAlignedOn | ( | const void * | ptr,
|  | unsigned int | alignment
| ) |  |

inline

Determines whether ptr is aligned to a minimum value.

Parameters

  ptr | the pointer being checked for alignment
  alignment | the alignment value to test the pointer against

Returns
  true if ptr is aligned on at least align boundary

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 907 of file misc.h.

## IsAligned()

template<class T >

bool IsAligned | ( | const void * | ptr,
|  | T * | dummy = `NULL`
| ) |  |

inline

Determines whether ptr is minimally aligned.

Parameters

  ptr | the pointer to check for alignment
  dummy | an unused Visual C++ 6.0 workaround

Returns
  true if ptr follows native byte ordering, false otherwise

Internally the function calls IsAlignedOn with a second parameter of GetAlignmentOf<T>

Definition at line 918 of file misc.h.

## GetNativeByteOrder()

ByteOrder GetNativeByteOrder | ( |  | ) |

inline

Returns NativeByteOrder as an enumerated ByteOrder value.

Returns
  LittleEndian if the native byte order is little-endian, and BigEndian if the native byte order is big-endian

NativeByteOrder is a typedef depending on the platform. If IS_LITTLE_ENDIAN is set in config.h, then GetNativeByteOrder returns LittleEndian. If IS_BIG_ENDIAN is set, then GetNativeByteOrder returns BigEndian.

Note
  There are other byte orders besides little- and big-endian, and they include bi-endian and PDP-endian. If a system is neither little-endian nor big-endian, then a compile time error occurs.

Definition at line 940 of file misc.h.

## NativeByteOrderIs()

bool NativeByteOrderIs | ( | ByteOrder | order | ) |

inline

Determines whether order follows native byte ordering.

Parameters

  order | the ordering being tested against native byte ordering

Returns
  true if order follows native byte ordering, false otherwise

Definition at line 948 of file misc.h.

## SaturatingSubtract()

template<class T1 , class T2 >

T1 SaturatingSubtract | ( | const T1 & | a,
|  | const T2 & | b
| ) |  |

inline

Performs a saturating subtract clamped at 0.

Parameters

  a | the minuend
  b | the subtrahend

Returns
  the difference produced by the saturating subtract

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 961 of file misc.h.

## SaturatingSubtract1()

template<class T1 , class T2 >

T1 SaturatingSubtract1 | ( | const T1 & | a,
|  | const T2 & | b
| ) |  |

inline

Performs a saturating subtract clamped at 1.

Parameters

  a | the minuend
  b | the subtrahend

Returns
  the difference produced by the saturating subtract

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 976 of file misc.h.

## GetCipherDir()

template<class T >

CipherDir GetCipherDir | ( | const T & | obj | ) |

inline

Returns the direction the cipher is being operated.

Parameters

  obj | the cipher object being queried

Returns
  `ENCRYPTION` if the cipher obj is being operated in its forward direction, `DECRYPTION` otherwise

A cipher can be operated in a "forward" direction (encryption) or 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 992 of file misc.h.

## CallNewHandler()

void CallNewHandler | ( |  | ) |

Attempts to reclaim unused memory.

Exceptions

  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 199 of file misc.cpp.

## IncrementCounterByOne() [1/2]

void IncrementCounterByOne | ( | byte * | inout,
|  | unsigned int | size
| ) |  |

inline

Performs an addition with carry on a block of bytes.

Parameters

  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.

Note
  The function is not constant time because it stops processing when the carry is 0.

Definition at line 1013 of file misc.h.

## IncrementCounterByOne() [2/2]

void IncrementCounterByOne | ( | byte * | output,
|  | const byte * | input,
|  | unsigned int | size
| ) |  |

inline

Performs an addition with carry on a block of bytes.

Parameters

  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 1027 of file misc.h.

## ConditionalSwap()

template<class T >

void ConditionalSwap | ( | bool | c,
|  | T & | a,
|  | T & | b
| ) |  |

inline

Performs a branchless swap of values a and b if condition c is true.

Parameters

  c | the condition to perform the swap
  a | the first value
  b | the second value

Definition at line 1042 of file misc.h.

## ConditionalSwapPointers()

template<class T >

void ConditionalSwapPointers | ( | bool | c,
|  | T & | a,
|  | T & | b
| ) |  |

inline

Performs a branchless swap of pointers a and b if condition c is true.

Parameters

  c | the condition to perform the swap
  a | the first pointer
  b | the second pointer

Definition at line 1054 of file misc.h.

## SecureWipeBuffer()

template<class T >

void SecureWipeBuffer | ( | T * | buf,
|  | size_t | n
| ) |  |

Sets each element of an array to 0.

Parameters

  buf | an array of elements
  n | the number of elements in the array

The operation performs a wipe or zeroization. The function attempts to survive optimizations and dead code removal

Definition at line 1069 of file misc.h.

## SecureWipeArray()

template<class T >

void SecureWipeArray | ( | T * | buf,
|  | size_t | n
| ) |  |

inline

Sets each element of an array to 0.

Parameters

  buf | an array of elements
  n | the number of elements in the array

The operation performs a wipe or zeroization. The function attempts to survive optimizations and dead code removal.

Definition at line 1176 of file misc.h.

## AlignedAllocate()

void* AlignedAllocate | ( | size_t | size | ) |

Allocates a buffer on 16-byte boundary.

Parameters

  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.

Note
  AlignedAllocate and AlignedDeallocate are available when CRYPTOPP_BOOL_ALIGN16 is defined. CRYPTOPP_BOOL_ALIGN16 is defined in config.h

## AlignedDeallocate()

void AlignedDeallocate | ( | void * | ptr | ) |

Frees a buffer allocated with AlignedAllocate.

Parameters

  ptr | the buffer to free

Note
  AlignedAllocate and AlignedDeallocate are available when CRYPTOPP_BOOL_ALIGN16 is defined. CRYPTOPP_BOOL_ALIGN16 is defined in config.h

## UnalignedAllocate()

void* UnalignedAllocate | ( | size_t | size | ) |

Allocates a buffer.

Parameters

  size | the size of the buffer

Definition at line 253 of file misc.cpp.

## UnalignedDeallocate()

void UnalignedDeallocate | ( | void * | ptr | ) |

Frees a buffer allocated with UnalignedAllocate.

Parameters

  ptr | the buffer to free

Definition at line 261 of file misc.cpp.

## rotlFixed()

template<class T >

T rotlFixed | ( | T | x,
|  | unsigned int | y
| ) |  |

inline

Performs a left rotate.

Template Parameters

  T | the word type

Parameters

  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.

Note
  rotlFixed attempts to enlist a `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 1305 of file misc.h.

## rotrFixed()

template<class T >

T rotrFixed | ( | T | x,
|  | unsigned int | y
| ) |  |

inline

Performs a right rotate.

Template Parameters

  T | the word type

Parameters

  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.

Note
  rotrFixed attempts to enlist a `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 1327 of file misc.h.

## rotlVariable()

template<class T >

T rotlVariable | ( | T | x,
|  | unsigned int | y
| ) |  |

inline

Performs a left rotate.

Template Parameters

  T | the word type

Parameters

  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.

Note
  rotlVariable attempts to enlist a `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 1349 of file misc.h.

## rotrVariable()

template<class T >

T rotrVariable | ( | T | x,
|  | unsigned int | y
| ) |  |

inline

Performs a right rotate.

Template Parameters

  T | the word type

Parameters

  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.

Note
  rotrVariable attempts to enlist a `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 1367 of file misc.h.

## rotlMod()

template<class T >

T rotlMod | ( | T | x,
|  | unsigned int | y
| ) |  |

inline

Performs a left rotate.

Template Parameters

  T | the word type

Parameters

  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.

Note
  rotrVariable will use either `rotate IMM` or `rotate REG`.

Definition at line 1382 of file misc.h.

## rotrMod()

template<class T >

T rotrMod | ( | T | x,
|  | unsigned int | y
| ) |  |

inline

Performs a right rotate.

Template Parameters

  T | the word type

Parameters

  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.

Note
  rotrVariable will use either `rotate IMM` or `rotate REG`.

Definition at line 1396 of file misc.h.

## GetByte()

template<class T >

unsigned int GetByte | ( | ByteOrder | order,
|  | T | value,
|  | unsigned int | index
| ) |  |

inline

Gets a byte from a value.

Parameters

  order | the ByteOrder of the value
  value | the value to retrieve the byte
  index | the location of the byte to retrieve

Definition at line 1694 of file misc.h.

## ByteReverse() [1/5]

byte ByteReverse | ( | byte | value | ) |

inline

Reverses bytes in a 8-bit value.

Parameters

  value | the 8-bit value to reverse

Note
  ByteReverse returns the value passed to it since there is nothing to reverse

Definition at line 1705 of file misc.h.

## ByteReverse() [2/5]

word16 ByteReverse | ( | word16 | value | ) |

inline

Reverses bytes in a 16-bit value.

Performs an endian reversal

Parameters

  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 1714 of file misc.h.

## ByteReverse() [3/5]

word32 ByteReverse | ( | word32 | value | ) |

inline

Reverses bytes in a 32-bit value.

Performs an endian reversal

Parameters

  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 1729 of file misc.h.

## ByteReverse() [4/5]

word64 ByteReverse | ( | word64 | value | ) |

inline

Reverses bytes in a 64-bit value.

Performs an endian reversal

Parameters

  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 1754 of file misc.h.

## BitReverse() [1/5]

byte BitReverse | ( | byte | value | ) |

inline

Reverses bits in a 8-bit value.

Parameters

  value | the 8-bit value to reverse

BitReverse performs a combination of shifts on the byte

Definition at line 1775 of file misc.h.

## BitReverse() [2/5]

word16 BitReverse | ( | word16 | value | ) |

inline

Reverses bits in a 16-bit value.

Parameters

  value | the 16-bit value to reverse

BitReverse performs a combination of shifts on the word16

Definition at line 1785 of file misc.h.

## BitReverse() [3/5]

word32 BitReverse | ( | word32 | value | ) |

inline

Reverses bits in a 32-bit value.

Parameters

  value | the 32-bit value to reverse

BitReverse performs a combination of shifts on the word32

Definition at line 1796 of file misc.h.

## BitReverse() [4/5]

word64 BitReverse | ( | word64 | value | ) |

inline

Reverses bits in a 64-bit value.

Parameters

  value | the 64-bit value to reverse

BitReverse performs a combination of shifts on the word64

Definition at line 1807 of file misc.h.

## BitReverse() [5/5]

template<class T >

T BitReverse | ( | T | value | ) |

inline

Reverses bits in a value.

Parameters

  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 1826 of file misc.h.

## ConditionalByteReverse() [1/2]

template<class T >

T ConditionalByteReverse | ( | ByteOrder | order,
|  | T | value
| ) |  |

inline

Reverses bytes in a value depending upon endianess.

Template Parameters

  T | the class or type

Parameters

  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 1849 of file misc.h.

## ByteReverse() [5/5]

template<class T >

void ByteReverse | ( | T * | out,
|  | const T * | in,
|  | size_t | byteCount
| ) |  |

Reverses bytes in an element from an array of elements.

Template Parameters

  T | the class or type

Parameters

  out | the output array of elements
  in | the input array of elements
  byteCount | the total number of bytes in the array

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 2 elements or 8 bytes are reversed.

The follwoing program should help illustrate the behavior.

    vector<word32> v1, v2;

    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);

    v2.resize(v1.size());
    ByteReverse<word32>(&v2[0], &v1[0], 16);

    cout << "V1: ";
    for(unsigned int i = 0; i < v1.size(); i++)
      cout << std::hex << v1[i] << " ";
    cout << endl;

    cout << "V2: ";
    for(unsigned int i = 0; i < v2.size(); i++)
      cout << std::hex << v2[i] << " ";
    cout << endl;

The program above results in the follwoing output.

    V1: 00000001 00000002 00000003 00000004
    V2: 01000000 02000000 03000000 04000000

See also
  ConditionalByteReverse

Definition at line 1890 of file misc.h.

## ConditionalByteReverse() [2/2]

template<class T >

void ConditionalByteReverse | ( | ByteOrder | order,
|  | T * | out,
|  | const T * | in,
|  | size_t | byteCount
| ) |  |

inline

Conditionally reverses bytes in an element from an array of elements.

Template Parameters

  T | the class or type

Parameters

  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 depending on the desired endianess, 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 2 elements or 8 bytes are reversed.

See also
  ByteReverse

Definition at line 1912 of file misc.h.