Crypto++  8.2
Free C++ class library of cryptographic schemes
secblock.h
Go to the documentation of this file.
1 // secblock.h - originally written and placed in the public domain by Wei Dai
2 
3 /// \file secblock.h
4 /// \brief Classes and functions for secure memory allocations.
5 
6 #ifndef CRYPTOPP_SECBLOCK_H
7 #define CRYPTOPP_SECBLOCK_H
8 
9 #include "config.h"
10 #include "allocate.h"
11 #include "misc.h"
12 #include "stdcpp.h"
13 
14 #if CRYPTOPP_MSC_VERSION
15 # pragma warning(push)
16 # pragma warning(disable: 4231 4275 4700)
17 # if (CRYPTOPP_MSC_VERSION >= 1400)
18 # pragma warning(disable: 6011 6386 28193)
19 # endif
20 #endif
21 
22 NAMESPACE_BEGIN(CryptoPP)
23 
24 // ************** secure memory allocation ***************
25 
26 /// \brief Base class for all allocators used by SecBlock
27 /// \tparam T the class or type
28 template<class T>
30 {
31 public:
32  typedef T value_type;
33  typedef size_t size_type;
34  typedef std::ptrdiff_t difference_type;
35  typedef T * pointer;
36  typedef const T * const_pointer;
37  typedef T & reference;
38  typedef const T & const_reference;
39 
40  pointer address(reference r) const {return (&r);}
41  const_pointer address(const_reference r) const {return (&r); }
42  void construct(pointer p, const T& val) {new (p) T(val);}
43  void destroy(pointer p) {CRYPTOPP_UNUSED(p); p->~T();}
44 
45  /// \brief Returns the maximum number of elements the allocator can provide
46  /// \details <tt>ELEMS_MAX</tt> is the maximum number of elements the
47  /// <tt>Allocator</tt> can provide. The value of <tt>ELEMS_MAX</tt> is
48  /// <tt>SIZE_MAX/sizeof(T)</tt>. <tt>std::numeric_limits</tt> was avoided
49  /// due to lack of <tt>constexpr</tt>-ness in C++03 and below.
50  /// \note In C++03 and below <tt>ELEMS_MAX</tt> is a static data member of type
51  /// <tt>size_type</tt>. In C++11 and above <tt>ELEMS_MAX</tt> is an <tt>enum</tt>
52  /// inheriting from <tt>size_type</tt>. In both cases <tt>ELEMS_MAX</tt> can be
53  /// used before objects are fully constructed, and it does not suffer the
54  /// limitations of class methods like <tt>max_size</tt>.
55  /// \sa <A HREF="http://github.com/weidai11/cryptopp/issues/346">Issue 346/CVE-2016-9939</A>
56  /// \since Crypto++ 6.0
57 #if defined(CRYPTOPP_DOXYGEN_PROCESSING)
58  static const size_type ELEMS_MAX = ...;
59 #elif defined(_MSC_VER) && (_MSC_VER <= 1400)
60  static const size_type ELEMS_MAX = (~(size_type)0)/sizeof(T);
61 #elif defined(CRYPTOPP_CXX11_ENUM)
62  enum : size_type {ELEMS_MAX = SIZE_MAX/sizeof(T)};
63 #else
64  static const size_type ELEMS_MAX = SIZE_MAX/sizeof(T);
65 #endif
66 
67  /// \brief Returns the maximum number of elements the allocator can provide
68  /// \returns the maximum number of elements the allocator can provide
69  /// \details Internally, preprocessor macros are used rather than std::numeric_limits
70  /// because the latter is not a constexpr. Some compilers, like Clang, do not
71  /// optimize it well under all circumstances. Compilers like GCC, ICC and MSVC appear
72  /// to optimize it well in either form.
73  CRYPTOPP_CONSTEXPR size_type max_size() const {return ELEMS_MAX;}
74 
75 #if defined(__SUNPRO_CC)
76  // https://github.com/weidai11/cryptopp/issues/770
77  // and https://stackoverflow.com/q/53999461/608639
78  CRYPTOPP_CONSTEXPR size_type max_size(size_type n) const {return SIZE_MAX/n;}
79 #endif
80 
81 #if defined(CRYPTOPP_CXX11_VARIADIC_TEMPLATES) || defined(CRYPTOPP_DOXYGEN_PROCESSING)
82 
83  /// \brief Constructs a new V using variadic arguments
84  /// \tparam V the type to be forwarded
85  /// \tparam Args the arguments to be forwarded
86  /// \param ptr pointer to type V
87  /// \param args variadic arguments
88  /// \details This is a C++11 feature. It is available when CRYPTOPP_CXX11_VARIADIC_TEMPLATES
89  /// is defined. The define is controlled by compiler versions detected in config.h.
90  template<typename V, typename... Args>
91  void construct(V* ptr, Args&&... args) {::new ((void*)ptr) V(std::forward<Args>(args)...);}
92 
93  /// \brief Destroys an V constructed with variadic arguments
94  /// \tparam V the type to be forwarded
95  /// \details This is a C++11 feature. It is available when CRYPTOPP_CXX11_VARIADIC_TEMPLATES
96  /// is defined. The define is controlled by compiler versions detected in config.h.
97  template<typename V>
98  void destroy(V* ptr) {if (ptr) ptr->~V();}
99 
100 #endif
101 
102 protected:
103 
104  /// \brief Verifies the allocator can satisfy a request based on size
105  /// \param size the size of the allocation, in elements
106  /// \throws InvalidArgument
107  /// \details CheckSize verifies the number of elements requested is valid.
108  /// \details If size is greater than max_size(), then InvalidArgument is thrown.
109  /// The library throws InvalidArgument if the size is too large to satisfy.
110  /// \details Internally, preprocessor macros are used rather than std::numeric_limits
111  /// because the latter is not a constexpr. Some compilers, like Clang, do not
112  /// optimize it well under all circumstances. Compilers like GCC, ICC and MSVC appear
113  /// to optimize it well in either form.
114  /// \details The <tt>sizeof(T) != 1</tt> in the condition attempts to help the
115  /// compiler optimize the check for byte types. Coverity findings for
116  /// CONSTANT_EXPRESSION_RESULT were generated without it. For byte types,
117  /// size never exceeded ELEMS_MAX but the code was not removed.
118  /// \note size is the count of elements, and not the number of bytes
119  static void CheckSize(size_t size)
120  {
121  // Squash MSC C4100 warning for size. Also see commit 42b7c4ea5673.
122  CRYPTOPP_UNUSED(size);
123  // C++ throws std::bad_alloc (C++03) or std::bad_array_new_length (C++11) here.
124  if (sizeof(T) != 1 && size > ELEMS_MAX)
125  throw InvalidArgument("AllocatorBase: requested size would cause integer overflow");
126  }
127 };
128 
129 #define CRYPTOPP_INHERIT_ALLOCATOR_TYPES \
130 typedef typename AllocatorBase<T>::value_type value_type;\
131 typedef typename AllocatorBase<T>::size_type size_type;\
132 typedef typename AllocatorBase<T>::difference_type difference_type;\
133 typedef typename AllocatorBase<T>::pointer pointer;\
134 typedef typename AllocatorBase<T>::const_pointer const_pointer;\
135 typedef typename AllocatorBase<T>::reference reference;\
136 typedef typename AllocatorBase<T>::const_reference const_reference;
137 
138 /// \brief Reallocation function
139 /// \tparam T the class or type
140 /// \tparam A the class or type's allocator
141 /// \param alloc the allocator
142 /// \param oldPtr the previous allocation
143 /// \param oldSize the size of the previous allocation
144 /// \param newSize the new, requested size
145 /// \param preserve flag that indicates if the old allocation should be preserved
146 /// \note oldSize and newSize are the count of elements, and not the
147 /// number of bytes.
148 template <class T, class A>
149 typename A::pointer StandardReallocate(A& alloc, T *oldPtr, typename A::size_type oldSize, typename A::size_type newSize, bool preserve)
150 {
151  // Avoid assert on pointer in reallocate. SecBlock regularly uses NULL
152  // pointers rather returning non-NULL 0-sized pointers.
153  if (oldSize == newSize)
154  return oldPtr;
155 
156  if (preserve)
157  {
158  typename A::pointer newPointer = alloc.allocate(newSize, NULLPTR);
159  const typename A::size_type copySize = STDMIN(oldSize, newSize) * sizeof(T);
160 
161  if (oldPtr && newPointer)
162  memcpy_s(newPointer, copySize, oldPtr, copySize);
163 
164  if (oldPtr)
165  alloc.deallocate(oldPtr, oldSize);
166 
167  return newPointer;
168  }
169  else
170  {
171  if (oldPtr)
172  alloc.deallocate(oldPtr, oldSize);
173 
174  return alloc.allocate(newSize, NULLPTR);
175  }
176 }
177 
178 /// \brief Allocates a block of memory with cleanup
179 /// \tparam T class or type
180 /// \tparam T_Align16 boolean that determines whether allocations should be aligned on a 16-byte boundary
181 /// \details If T_Align16 is true, then AllocatorWithCleanup calls AlignedAllocate()
182 /// for memory allocations. If T_Align16 is false, then AllocatorWithCleanup() calls
183 /// UnalignedAllocate() for memory allocations.
184 /// \details Template parameter T_Align16 is effectively controlled by cryptlib.h and mirrors
185 /// CRYPTOPP_BOOL_ALIGN16. CRYPTOPP_BOOL_ALIGN16 is often used as the template parameter.
186 template <class T, bool T_Align16 = false>
188 {
189 public:
190  CRYPTOPP_INHERIT_ALLOCATOR_TYPES
191 
192  /// \brief Allocates a block of memory
193  /// \param ptr the size of the allocation
194  /// \param size the size of the allocation, in elements
195  /// \returns a memory block
196  /// \throws InvalidArgument
197  /// \details allocate() first checks the size of the request. If it is non-0
198  /// and less than max_size(), then an attempt is made to fulfill the request
199  /// using either AlignedAllocate() or UnalignedAllocate(). AlignedAllocate() is
200  /// used if T_Align16 is true. UnalignedAllocate() used if T_Align16 is false.
201  /// \details This is the C++ *Placement New* operator. ptr is not used, and the
202  /// function asserts in Debug builds if ptr is non-NULL.
203  /// \sa CallNewHandler() for the methods used to recover from a failed
204  /// allocation attempt.
205  /// \note size is the count of elements, and not the number of bytes
206  pointer allocate(size_type size, const void *ptr = NULLPTR)
207  {
208  CRYPTOPP_UNUSED(ptr); CRYPTOPP_ASSERT(ptr == NULLPTR);
209  this->CheckSize(size);
210  if (size == 0)
211  return NULLPTR;
212 
213 #if CRYPTOPP_BOOL_ALIGN16
214  if (T_Align16)
215  return reinterpret_cast<pointer>(AlignedAllocate(size*sizeof(T)));
216 #endif
217 
218  return reinterpret_cast<pointer>(UnalignedAllocate(size*sizeof(T)));
219  }
220 
221  /// \brief Deallocates a block of memory
222  /// \param ptr the pointer for the allocation
223  /// \param size the size of the allocation, in elements
224  /// \details Internally, SecureWipeArray() is called before deallocating the
225  /// memory. Once the memory block is wiped or zeroized, AlignedDeallocate()
226  /// or UnalignedDeallocate() is called.
227  /// \details AlignedDeallocate() is used if T_Align16 is true.
228  /// UnalignedDeallocate() used if T_Align16 is false.
229  void deallocate(void *ptr, size_type size)
230  {
231  // Avoid assert on pointer in deallocate. SecBlock regularly uses NULL
232  // pointers rather returning non-NULL 0-sized pointers.
233  if (ptr)
234  {
235  SecureWipeArray(reinterpret_cast<pointer>(ptr), size);
236 
237 #if CRYPTOPP_BOOL_ALIGN16
238  if (T_Align16)
239  return AlignedDeallocate(ptr);
240 #endif
241 
242  UnalignedDeallocate(ptr);
243  }
244  }
245 
246  /// \brief Reallocates a block of memory
247  /// \param oldPtr the previous allocation
248  /// \param oldSize the size of the previous allocation
249  /// \param newSize the new, requested size
250  /// \param preserve flag that indicates if the old allocation should be preserved
251  /// \returns pointer to the new memory block
252  /// \details Internally, reallocate() calls StandardReallocate().
253  /// \details If preserve is true, then index 0 is used to begin copying the
254  /// old memory block to the new one. If the block grows, then the old array
255  /// is copied in its entirety. If the block shrinks, then only newSize
256  /// elements are copied from the old block to the new one.
257  /// \note oldSize and newSize are the count of elements, and not the
258  /// number of bytes.
259  pointer reallocate(T *oldPtr, size_type oldSize, size_type newSize, bool preserve)
260  {
261  CRYPTOPP_ASSERT((oldPtr && oldSize) || !(oldPtr || oldSize));
262  return StandardReallocate(*this, oldPtr, oldSize, newSize, preserve);
263  }
264 
265  /// \brief Template class member Rebind
266  /// \tparam V bound class or type
267  /// \details Rebind allows a container class to allocate a different type of object
268  /// to store elements. For example, a std::list will allocate std::list_node to
269  /// store elements in the list.
270  /// \details VS.NET STL enforces the policy of "All STL-compliant allocators
271  /// have to provide a template class member called rebind".
272  template <class V> struct rebind { typedef AllocatorWithCleanup<V, T_Align16> other; };
273 #if _MSC_VER >= 1500
275  template <class V, bool A> AllocatorWithCleanup(const AllocatorWithCleanup<V, A> &) {}
276 #endif
277 };
278 
279 CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<byte>;
280 CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word16>;
281 CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word32>;
282 CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word64>;
283 #if defined(CRYPTOPP_WORD128_AVAILABLE)
284 CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word128, true>; // for Integer
285 #endif
286 #if CRYPTOPP_BOOL_X86
287 CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word, true>; // for Integer
288 #endif
289 
290 /// \brief NULL allocator
291 /// \tparam T class or type
292 /// \details A NullAllocator is useful for fixed-size, stack based allocations
293 /// (i.e., static arrays used by FixedSizeAllocatorWithCleanup).
294 /// \details A NullAllocator always returns 0 for max_size(), and always returns
295 /// NULL for allocation requests. Though the allocator does not allocate at
296 /// runtime, it does perform a secure wipe or zeroization during cleanup.
297 template <class T>
298 class NullAllocator : public AllocatorBase<T>
299 {
300 public:
301  //LCOV_EXCL_START
302  CRYPTOPP_INHERIT_ALLOCATOR_TYPES
303 
304  // TODO: should this return NULL or throw bad_alloc? Non-Windows C++ standard
305  // libraries always throw. And late mode Windows throws. Early model Windows
306  // (circa VC++ 6.0) returned NULL.
307  pointer allocate(size_type n, const void* unused = NULLPTR)
308  {
309  CRYPTOPP_UNUSED(n); CRYPTOPP_UNUSED(unused);
310  CRYPTOPP_ASSERT(false); return NULLPTR;
311  }
312 
313  void deallocate(void *p, size_type n)
314  {
315  CRYPTOPP_UNUSED(p); CRYPTOPP_UNUSED(n);
316  CRYPTOPP_ASSERT(false);
317  }
318 
319  CRYPTOPP_CONSTEXPR size_type max_size() const {return 0;}
320  //LCOV_EXCL_STOP
321 };
322 
323 /// \brief Static secure memory block with cleanup
324 /// \tparam T class or type
325 /// \tparam S fixed-size of the stack-based memory block, in elements
326 /// \tparam T_Align16 boolean that determines whether allocations should
327 /// be aligned on a 16-byte boundary
328 /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
329 /// based allocation at compile time. The class can grow its memory
330 /// block at runtime if a suitable allocator is available. If size
331 /// grows beyond S and a suitable allocator is available, then the
332 /// statically allocated array is obsoleted.
333 /// \note This allocator can't be used with standard collections because
334 /// they require that all objects of the same allocator type are equivalent.
335 template <class T, size_t S, class A = NullAllocator<T>, bool T_Align16 = false>
337 {
338  // The body of FixedSizeAllocatorWithCleanup is provided in the two
339  // partial specializations that follow. The two specialiations
340  // pivot on the boolean template parameter T_Align16. AIX, Solaris,
341  // IBM XLC and SunCC receive a little extra help. We managed to
342  // clear most of the warnings.
343 };
344 
345 /// \brief Static secure memory block with cleanup
346 /// \tparam T class or type
347 /// \tparam S fixed-size of the stack-based memory block, in elements
348 /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
349 /// based allocation at compile time. The class can grow its memory
350 /// block at runtime if a suitable allocator is available. If size
351 /// grows beyond S and a suitable allocator is available, then the
352 /// statically allocated array is obsoleted.
353 /// \note This allocator can't be used with standard collections because
354 /// they require that all objects of the same allocator type are equivalent.
355 template <class T, size_t S, class A>
356 class FixedSizeAllocatorWithCleanup<T, S, A, true> : public AllocatorBase<T>
357 {
358 public:
359  CRYPTOPP_INHERIT_ALLOCATOR_TYPES
360 
361  /// \brief Constructs a FixedSizeAllocatorWithCleanup
362  FixedSizeAllocatorWithCleanup() : m_allocated(false) {}
363 
364  /// \brief Allocates a block of memory
365  /// \param size the count elements in the memory block
366  /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-based
367  /// allocation at compile time. If size is less than or equal to
368  /// <tt>S</tt>, then a pointer to the static array is returned.
369  /// \details The class can grow its memory block at runtime if a suitable
370  /// allocator is available. If size grows beyond S and a suitable
371  /// allocator is available, then the statically allocated array is
372  /// obsoleted. If a suitable allocator is not available, as with a
373  /// NullAllocator, then the function returns NULL and a runtime error
374  /// eventually occurs.
375  /// \sa reallocate(), SecBlockWithHint
376  pointer allocate(size_type size)
377  {
378  CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));
379 
380  if (size <= S && !m_allocated)
381  {
382  m_allocated = true;
383  return GetAlignedArray();
384  }
385  else
386  return m_fallbackAllocator.allocate(size);
387  }
388 
389  /// \brief Allocates a block of memory
390  /// \param size the count elements in the memory block
391  /// \param hint an unused hint
392  /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
393  /// based allocation at compile time. If size is less than or equal to
394  /// S, then a pointer to the static array is returned.
395  /// \details The class can grow its memory block at runtime if a suitable
396  /// allocator is available. If size grows beyond S and a suitable
397  /// allocator is available, then the statically allocated array is
398  /// obsoleted. If a suitable allocator is not available, as with a
399  /// NullAllocator, then the function returns NULL and a runtime error
400  /// eventually occurs.
401  /// \sa reallocate(), SecBlockWithHint
402  pointer allocate(size_type size, const void *hint)
403  {
404  if (size <= S && !m_allocated)
405  {
406  m_allocated = true;
407  return GetAlignedArray();
408  }
409  else
410  return m_fallbackAllocator.allocate(size, hint);
411  }
412 
413  /// \brief Deallocates a block of memory
414  /// \param ptr a pointer to the memory block to deallocate
415  /// \param size the count elements in the memory block
416  /// \details The memory block is wiped or zeroized before deallocation.
417  /// If the statically allocated memory block is active, then no
418  /// additional actions are taken after the wipe.
419  /// \details If a dynamic memory block is active, then the pointer and
420  /// size are passed to the allocator for deallocation.
421  void deallocate(void *ptr, size_type size)
422  {
423  // Avoid assert on pointer in deallocate. SecBlock regularly uses NULL
424  // pointers rather returning non-NULL 0-sized pointers.
425  if (ptr == GetAlignedArray())
426  {
427  // If the m_allocated assert fires then the bit twiddling for
428  // GetAlignedArray() is probably incorrect for the platform.
429  // Be sure to check CRYPTOPP_ALIGN_DATA(8). The platform may
430  // not have a way to declaritively align data to 8.
431  CRYPTOPP_ASSERT(size <= S);
432  CRYPTOPP_ASSERT(m_allocated);
433  m_allocated = false;
434  SecureWipeArray(reinterpret_cast<pointer>(ptr), size);
435  }
436  else
437  {
438  if (ptr)
439  m_fallbackAllocator.deallocate(ptr, size);
440  }
441  }
442 
443  /// \brief Reallocates a block of memory
444  /// \param oldPtr the previous allocation
445  /// \param oldSize the size of the previous allocation
446  /// \param newSize the new, requested size
447  /// \param preserve flag that indicates if the old allocation should
448  /// be preserved
449  /// \returns pointer to the new memory block
450  /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
451  /// based allocation at compile time. If size is less than or equal to
452  /// S, then a pointer to the static array is returned.
453  /// \details The class can grow its memory block at runtime if a suitable
454  /// allocator is available. If size grows beyond S and a suitable
455  /// allocator is available, then the statically allocated array is
456  /// obsoleted. If a suitable allocator is not available, as with a
457  /// NullAllocator, then the function returns NULL and a runtime error
458  /// eventually occurs.
459  /// \note size is the count of elements, and not the number of bytes.
460  /// \sa reallocate(), SecBlockWithHint
461  pointer reallocate(pointer oldPtr, size_type oldSize, size_type newSize, bool preserve)
462  {
463  if (oldPtr == GetAlignedArray() && newSize <= S)
464  {
465  CRYPTOPP_ASSERT(oldSize <= S);
466  if (oldSize > newSize)
467  SecureWipeArray(oldPtr+newSize, oldSize-newSize);
468  return oldPtr;
469  }
470 
471  pointer newPointer = allocate(newSize, NULLPTR);
472  if (preserve && newSize)
473  {
474  const size_type copySize = STDMIN(oldSize, newSize);
475  memcpy_s(newPointer, sizeof(T)*newSize, oldPtr, sizeof(T)*copySize);
476  }
477  deallocate(oldPtr, oldSize);
478  return newPointer;
479  }
480 
481  CRYPTOPP_CONSTEXPR size_type max_size() const
482  {
483  return STDMAX(m_fallbackAllocator.max_size(), S);
484  }
485 
486 private:
487 
488 #if defined(CRYPTOPP_BOOL_ALIGN16) && (defined(_M_X64) || defined(__x86_64__))
489  // Before we can add additional platforms we need to check the
490  // linker documentation for alignment behavior for stack variables.
491  // CRYPTOPP_ALIGN_DATA(16) is known OK on Linux, OS X, Solaris.
492  // Also see http://stackoverflow.com/a/1468656/608639.
493  T* GetAlignedArray() {
494  CRYPTOPP_ASSERT(IsAlignedOn(m_array, 16));
495  return m_array;
496  }
497  CRYPTOPP_ALIGN_DATA(16) T m_array[S];
498 
499 #elif defined(CRYPTOPP_BOOL_ALIGN16)
500 
501  // There be demons here... We cannot use CRYPTOPP_ALIGN_DATA(16)
502  // because linkers on 32-bit machines (and some 64-bit machines)
503  // align the stack to 8-bytes or less by default, not 16-bytes as
504  // requested. Additionally, the AIX linker seems to use 4-bytes
505  // by default. However, all linkers tested appear to honor
506  // CRYPTOPP_ALIGN_DATA(8). Also see
507  // http://stackoverflow.com/a/1468656/608639.
508  //
509  // The 16-byte alignment is achieved by padding the requested
510  // size with extra elements so we have at least 16-bytes of slack
511  // to work with. Then the pointer is moved down to achieve a
512  // 16-byte alignment (stacks grow down).
513  //
514  // The additional 16-bytes introduces a small secondary issue.
515  // The secondary issue is, a large T results in 0 = 8/sizeof(T).
516  // The library is OK but users may hit it. So we need to guard
517  // for a large T, and that is what PAD achieves.
518  T* GetAlignedArray() {
519  T* p_array = reinterpret_cast<T*>(static_cast<void*>((reinterpret_cast<byte*>(m_array)) + (0-reinterpret_cast<size_t>(m_array))%16));
520  // Verify the 16-byte alignment
521  CRYPTOPP_ASSERT(IsAlignedOn(p_array, 16));
522  // Verify allocated array with pad is large enough.
523  CRYPTOPP_ASSERT(p_array+S <= m_array+(S+PAD));
524  return p_array;
525  }
526 
527 # if defined(_AIX)
528  // PAD is elements, not bytes, and rounded up to ensure no overflow.
529  enum { Q = sizeof(T), PAD = (Q >= 16) ? 1 : (Q >= 8) ? 2 : (Q >= 4) ? 4 : (Q >= 2) ? 8 : 16 };
530  CRYPTOPP_ALIGN_DATA(8) T m_array[S+PAD];
531 # else
532  // PAD is elements, not bytes, and rounded up to ensure no overflow.
533  enum { Q = sizeof(T), PAD = (Q >= 8) ? 1 : (Q >= 4) ? 2 : (Q >= 2) ? 4 : 8 };
534  CRYPTOPP_ALIGN_DATA(8) T m_array[S+PAD];
535 # endif
536 
537 #else
538 
539  // CRYPTOPP_BOOL_ALIGN16 is 0. Use natural alignment of T.
540  T* GetAlignedArray() {return m_array;}
541  CRYPTOPP_ALIGN_DATA(4) T m_array[S];
542 
543 #endif
544 
545  A m_fallbackAllocator;
546  bool m_allocated;
547 };
548 
549 /// \brief Static secure memory block with cleanup
550 /// \tparam T class or type
551 /// \tparam S fixed-size of the stack-based memory block, in elements
552 /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
553 /// based allocation at compile time. The class can grow its memory
554 /// block at runtime if a suitable allocator is available. If size
555 /// grows beyond S and a suitable allocator is available, then the
556 /// statically allocated array is obsoleted.
557 /// \note This allocator can't be used with standard collections because
558 /// they require that all objects of the same allocator type are equivalent.
559 template <class T, size_t S, class A>
560 class FixedSizeAllocatorWithCleanup<T, S, A, false> : public AllocatorBase<T>
561 {
562 public:
563  CRYPTOPP_INHERIT_ALLOCATOR_TYPES
564 
565  /// \brief Constructs a FixedSizeAllocatorWithCleanup
566  FixedSizeAllocatorWithCleanup() : m_allocated(false) {}
567 
568  /// \brief Allocates a block of memory
569  /// \param size the count elements in the memory block
570  /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-based
571  /// allocation at compile time. If size is less than or equal to
572  /// <tt>S</tt>, then a pointer to the static array is returned.
573  /// \details The class can grow its memory block at runtime if a suitable
574  /// allocator is available. If size grows beyond S and a suitable
575  /// allocator is available, then the statically allocated array is
576  /// obsoleted. If a suitable allocator is not available, as with a
577  /// NullAllocator, then the function returns NULL and a runtime error
578  /// eventually occurs.
579  /// \sa reallocate(), SecBlockWithHint
580  pointer allocate(size_type size)
581  {
582  CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));
583 
584  if (size <= S && !m_allocated)
585  {
586  m_allocated = true;
587  return GetAlignedArray();
588  }
589  else
590  return m_fallbackAllocator.allocate(size);
591  }
592 
593  /// \brief Allocates a block of memory
594  /// \param size the count elements in the memory block
595  /// \param hint an unused hint
596  /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
597  /// based allocation at compile time. If size is less than or equal to
598  /// S, then a pointer to the static array is returned.
599  /// \details The class can grow its memory block at runtime if a suitable
600  /// allocator is available. If size grows beyond S and a suitable
601  /// allocator is available, then the statically allocated array is
602  /// obsoleted. If a suitable allocator is not available, as with a
603  /// NullAllocator, then the function returns NULL and a runtime error
604  /// eventually occurs.
605  /// \sa reallocate(), SecBlockWithHint
606  pointer allocate(size_type size, const void *hint)
607  {
608  if (size <= S && !m_allocated)
609  {
610  m_allocated = true;
611  return GetAlignedArray();
612  }
613  else
614  return m_fallbackAllocator.allocate(size, hint);
615  }
616 
617  /// \brief Deallocates a block of memory
618  /// \param ptr a pointer to the memory block to deallocate
619  /// \param size the count elements in the memory block
620  /// \details The memory block is wiped or zeroized before deallocation.
621  /// If the statically allocated memory block is active, then no
622  /// additional actions are taken after the wipe.
623  /// \details If a dynamic memory block is active, then the pointer and
624  /// size are passed to the allocator for deallocation.
625  void deallocate(void *ptr, size_type size)
626  {
627  // Avoid assert on pointer in deallocate. SecBlock regularly uses NULL
628  // pointers rather returning non-NULL 0-sized pointers.
629  if (ptr == GetAlignedArray())
630  {
631  // If the m_allocated assert fires then
632  // something overwrote the flag.
633  CRYPTOPP_ASSERT(size <= S);
634  CRYPTOPP_ASSERT(m_allocated);
635  m_allocated = false;
636  SecureWipeArray((pointer)ptr, size);
637  }
638  else
639  {
640  if (ptr)
641  m_fallbackAllocator.deallocate(ptr, size);
642  m_allocated = false;
643  }
644  }
645 
646  /// \brief Reallocates a block of memory
647  /// \param oldPtr the previous allocation
648  /// \param oldSize the size of the previous allocation
649  /// \param newSize the new, requested size
650  /// \param preserve flag that indicates if the old allocation should
651  /// be preserved
652  /// \returns pointer to the new memory block
653  /// \details FixedSizeAllocatorWithCleanup provides a fixed-size, stack-
654  /// based allocation at compile time. If size is less than or equal to
655  /// S, then a pointer to the static array is returned.
656  /// \details The class can grow its memory block at runtime if a suitable
657  /// allocator is available. If size grows beyond S and a suitable
658  /// allocator is available, then the statically allocated array is
659  /// obsoleted. If a suitable allocator is not available, as with a
660  /// NullAllocator, then the function returns NULL and a runtime error
661  /// eventually occurs.
662  /// \note size is the count of elements, and not the number of bytes.
663  /// \sa reallocate(), SecBlockWithHint
664  pointer reallocate(pointer oldPtr, size_type oldSize, size_type newSize, bool preserve)
665  {
666  if (oldPtr == GetAlignedArray() && newSize <= S)
667  {
668  CRYPTOPP_ASSERT(oldSize <= S);
669  if (oldSize > newSize)
670  SecureWipeArray(oldPtr+newSize, oldSize-newSize);
671  return oldPtr;
672  }
673 
674  pointer newPointer = allocate(newSize, NULLPTR);
675  if (preserve && newSize)
676  {
677  const size_type copySize = STDMIN(oldSize, newSize);
678  memcpy_s(newPointer, sizeof(T)*newSize, oldPtr, sizeof(T)*copySize);
679  }
680  deallocate(oldPtr, oldSize);
681  return newPointer;
682  }
683 
684  CRYPTOPP_CONSTEXPR size_type max_size() const
685  {
686  return STDMAX(m_fallbackAllocator.max_size(), S);
687  }
688 
689 private:
690 
691  // The 8-byte alignments follows convention of Linux and Windows.
692  // Linux and Windows receives most testing. Duplicate it here for
693  // other platforms like AIX and Solaris. AIX and Solaris often use
694  // alignments smaller than expected. In fact AIX caught us by
695  // surprise with word16 and word32.
696  T* GetAlignedArray() {return m_array;}
697  CRYPTOPP_ALIGN_DATA(8) T m_array[S];
698 
699  A m_fallbackAllocator;
700  bool m_allocated;
701 };
702 
703 /// \brief Secure memory block with allocator and cleanup
704 /// \tparam T a class or type
705 /// \tparam A AllocatorWithCleanup derived class for allocation and cleanup
706 template <class T, class A = AllocatorWithCleanup<T> >
707 class SecBlock
708 {
709 public:
710  typedef typename A::value_type value_type;
711  typedef typename A::pointer iterator;
712  typedef typename A::const_pointer const_iterator;
713  typedef typename A::size_type size_type;
714 
715  /// \brief Returns the maximum number of elements the block can hold
716  /// \details <tt>ELEMS_MAX</tt> is the maximum number of elements the
717  /// <tt>SecBlock</tt> can hold. The value of <tt>ELEMS_MAX</tt> is
718  /// <tt>SIZE_MAX/sizeof(T)</tt>. <tt>std::numeric_limits</tt> was avoided
719  /// due to lack of <tt>constexpr</tt>-ness in C++03 and below.
720  /// \note In C++03 and below <tt>ELEMS_MAX</tt> is a static data member of type
721  /// <tt>size_type</tt>. In C++11 and above <tt>ELEMS_MAX</tt> is an <tt>enum</tt>
722  /// inheriting from <tt>size_type</tt>. In both cases <tt>ELEMS_MAX</tt> can be
723  /// used before objects are fully constructed, and it does not suffer the
724  /// limitations of class methods like <tt>max_size</tt>.
725  /// \sa <A HREF="http://github.com/weidai11/cryptopp/issues/346">Issue 346/CVE-2016-9939</A>
726  /// \since Crypto++ 6.0
727 #if defined(CRYPTOPP_DOXYGEN_PROCESSING)
728  static const size_type ELEMS_MAX = ...;
729 #elif defined(_MSC_VER) && (_MSC_VER <= 1400)
730  static const size_type ELEMS_MAX = (~(size_type)0)/sizeof(T);
731 #elif defined(CRYPTOPP_CXX11_ENUM)
732  enum : size_type {ELEMS_MAX = A::ELEMS_MAX};
733 #else
734  static const size_type ELEMS_MAX = SIZE_MAX/sizeof(T);
735 #endif
736 
737  /// \brief Construct a SecBlock with space for size elements.
738  /// \param size the size of the allocation, in elements
739  /// \throws std::bad_alloc
740  /// \details The elements are not initialized.
741  /// \note size is the count of elements, and not the number of bytes
742  explicit SecBlock(size_type size=0)
743  : m_mark(ELEMS_MAX), m_size(size), m_ptr(m_alloc.allocate(size, NULLPTR)) { }
744 
745  /// \brief Copy construct a SecBlock from another SecBlock
746  /// \param t the other SecBlock
747  /// \throws std::bad_alloc
749  : m_mark(t.m_mark), m_size(t.m_size), m_ptr(m_alloc.allocate(t.m_size, NULLPTR)) {
750  CRYPTOPP_ASSERT((!t.m_ptr && !m_size) || (t.m_ptr && m_size));
751  if (t.m_ptr) {memcpy_s(m_ptr, m_size*sizeof(T), t.m_ptr, t.m_size*sizeof(T));}
752  }
753 
754  /// \brief Construct a SecBlock from an array of elements.
755  /// \param ptr a pointer to an array of T
756  /// \param len the number of elements in the memory block
757  /// \throws std::bad_alloc
758  /// \details If <tt>ptr!=NULL</tt> and <tt>len!=0</tt>, then the block is initialized from the pointer
759  /// <tt>ptr</tt>. If <tt>ptr==NULL</tt> and <tt>len!=0</tt>, then the block is initialized to 0.
760  /// Otherwise, the block is empty and not initialized.
761  /// \note size is the count of elements, and not the number of bytes
762  SecBlock(const T *ptr, size_type len)
763  : m_mark(ELEMS_MAX), m_size(len), m_ptr(m_alloc.allocate(len, NULLPTR)) {
764  CRYPTOPP_ASSERT((!m_ptr && !m_size) || (m_ptr && m_size));
765  if (ptr && m_ptr)
766  memcpy_s(m_ptr, m_size*sizeof(T), ptr, len*sizeof(T));
767  else if (m_size)
768  memset(m_ptr, 0, m_size*sizeof(T));
769  }
770 
771  ~SecBlock()
772  {m_alloc.deallocate(m_ptr, STDMIN(m_size, m_mark));}
773 
774 #ifdef __BORLANDC__
775  /// \brief Cast operator
776  /// \returns block pointer cast to non-const <tt>T *</tt>
777  operator T *() const
778  {return (T*)m_ptr;}
779 #else
780  /// \brief Cast operator
781  /// \returns block pointer cast to <tt>const void *</tt>
782  operator const void *() const
783  {return m_ptr;}
784 
785  /// \brief Cast operator
786  /// \returns block pointer cast to non-const <tt>void *</tt>
787  operator void *()
788  {return m_ptr;}
789 
790  /// \brief Cast operator
791  /// \returns block pointer cast to <tt>const T *</tt>
792  operator const T *() const
793  {return m_ptr;}
794 
795  /// \brief Cast operator
796  /// \returns block pointer cast to non-const <tt>T *</tt>
797  operator T *()
798  {return m_ptr;}
799 #endif
800 
801  /// \brief Provides an iterator pointing to the first element in the memory block
802  /// \returns iterator pointing to the first element in the memory block
803  iterator begin()
804  {return m_ptr;}
805  /// \brief Provides a constant iterator pointing to the first element in the memory block
806  /// \returns constant iterator pointing to the first element in the memory block
807  const_iterator begin() const
808  {return m_ptr;}
809  /// \brief Provides an iterator pointing beyond the last element in the memory block
810  /// \returns iterator pointing beyond the last element in the memory block
811  iterator end()
812  {return m_ptr+m_size;}
813  /// \brief Provides a constant iterator pointing beyond the last element in the memory block
814  /// \returns constant iterator pointing beyond the last element in the memory block
815  const_iterator end() const
816  {return m_ptr+m_size;}
817 
818  /// \brief Provides a pointer to the first element in the memory block
819  /// \returns pointer to the first element in the memory block
820  typename A::pointer data() {return m_ptr;}
821  /// \brief Provides a pointer to the first element in the memory block
822  /// \returns constant pointer to the first element in the memory block
823  typename A::const_pointer data() const {return m_ptr;}
824 
825  /// \brief Provides the count of elements in the SecBlock
826  /// \returns number of elements in the memory block
827  /// \note the return value is the count of elements, and not the number of bytes
828  size_type size() const {return m_size;}
829  /// \brief Determines if the SecBlock is empty
830  /// \returns true if number of elements in the memory block is 0, false otherwise
831  bool empty() const {return m_size == 0;}
832 
833  /// \brief Provides a byte pointer to the first element in the memory block
834  /// \returns byte pointer to the first element in the memory block
835  byte * BytePtr() {return (byte *)m_ptr;}
836  /// \brief Return a byte pointer to the first element in the memory block
837  /// \returns constant byte pointer to the first element in the memory block
838  const byte * BytePtr() const {return (const byte *)m_ptr;}
839  /// \brief Provides the number of bytes in the SecBlock
840  /// \return the number of bytes in the memory block
841  /// \note the return value is the number of bytes, and not count of elements.
842  size_type SizeInBytes() const {return m_size*sizeof(T);}
843 
844  /// \brief Sets the number of elements to zeroize
845  /// \param count the number of elements
846  /// \details SetMark is a remediation for Issue 346/CVE-2016-9939 while
847  /// preserving the streaming interface. The <tt>count</tt> controls the number of
848  /// elements zeroized, which can be less than <tt>size</tt> or 0.
849  /// \details An internal variable, <tt>m_mark</tt>, is initialized to the maximum number
850  /// of elements. The maximum number of elements is <tt>ELEMS_MAX</tt>. Deallocation
851  /// triggers a zeroization, and the number of elements zeroized is
852  /// <tt>STDMIN(m_size, m_mark)</tt>. After zeroization, the memory is returned to the
853  /// system.
854  /// \details The ASN.1 decoder uses SetMark() to set the element count to 0
855  /// before throwing an exception. In this case, the attacker provides a large
856  /// BER encoded length (say 64MB) but only a small number of content octets
857  /// (say 16). If the allocator zeroized all 64MB, then a transient DoS could
858  /// occur as CPU cycles are spent zeroizing unintialized memory.
859  /// \details Generally speaking, any operation which changes the size of the SecBlock
860  /// results in the mark being reset to <tt>ELEMS_MAX</tt>. In particular, if Assign(),
861  /// New(), Grow(), CleanNew(), CleanGrow() are called, then the count is reset to
862  /// <tt>ELEMS_MAX</tt>. The list is not exhaustive.
863  /// \since Crypto++ 6.0
864  /// \sa <A HREF="http://github.com/weidai11/cryptopp/issues/346">Issue 346/CVE-2016-9939</A>
865  void SetMark(size_t count) {m_mark = count;}
866 
867  /// \brief Set contents and size from an array
868  /// \param ptr a pointer to an array of T
869  /// \param len the number of elements in the memory block
870  /// \details If the memory block is reduced in size, then the reclaimed memory is set to 0.
871  /// Assign() resets the element count after the previous block is zeroized.
872  void Assign(const T *ptr, size_type len)
873  {
874  New(len);
875  if (m_ptr && ptr)
876  {memcpy_s(m_ptr, m_size*sizeof(T), ptr, len*sizeof(T));}
877  m_mark = ELEMS_MAX;
878  }
879 
880  /// \brief Set contents from a value
881  /// \param count the number of values to copy
882  /// \param value the value, repeated count times
883  /// \details If the memory block is reduced in size, then the reclaimed memory is set to 0.
884  /// Assign() resets the element count after the previous block is zeroized.
885  void Assign(size_type count, T value)
886  {
887  New(count);
888  for (size_t i=0; i<count; ++i)
889  m_ptr[i] = value;
890 
891  m_mark = ELEMS_MAX;
892  }
893 
894  /// \brief Copy contents from another SecBlock
895  /// \param t the other SecBlock
896  /// \details Assign checks for self assignment.
897  /// \details If the memory block is reduced in size, then the reclaimed memory is set to 0.
898  /// If an assignment occurs, then Assign() resets the element count after the previous block
899  /// is zeroized.
900  void Assign(const SecBlock<T, A> &t)
901  {
902  if (this != &t)
903  {
904  New(t.m_size);
905  if (m_ptr && t.m_ptr)
906  {memcpy_s(m_ptr, m_size*sizeof(T), t, t.m_size*sizeof(T));}
907  }
908  m_mark = ELEMS_MAX;
909  }
910 
911  /// \brief Assign contents from another SecBlock
912  /// \param t the other SecBlock
913  /// \details Internally, operator=() calls Assign().
914  /// \details If the memory block is reduced in size, then the reclaimed memory is set to 0.
915  /// If an assignment occurs, then Assign() resets the element count after the previous block
916  /// is zeroized.
918  {
919  // Assign guards for self-assignment
920  Assign(t);
921  return *this;
922  }
923 
924  /// \brief Append contents from another SecBlock
925  /// \param t the other SecBlock
926  /// \details Internally, this SecBlock calls Grow and then appends t.
928  {
929  CRYPTOPP_ASSERT((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));
930  if (t.m_size)
931  {
932  const size_type oldSize = m_size;
933  if (this != &t) // s += t
934  {
935  Grow(m_size+t.m_size);
936  memcpy_s(m_ptr+oldSize, (m_size-oldSize)*sizeof(T), t.m_ptr, t.m_size*sizeof(T));
937  }
938  else // t += t
939  {
940  Grow(m_size*2);
941  memcpy_s(m_ptr+oldSize, (m_size-oldSize)*sizeof(T), m_ptr, oldSize*sizeof(T));
942  }
943  }
944  m_mark = ELEMS_MAX;
945  return *this;
946  }
947 
948  /// \brief Construct a SecBlock from this and another SecBlock
949  /// \param t the other SecBlock
950  /// \returns a newly constructed SecBlock that is a conacentation of this and t
951  /// \details Internally, a new SecBlock is created from this and a concatenation of t.
953  {
954  CRYPTOPP_ASSERT((!m_ptr && !m_size) || (m_ptr && m_size));
955  CRYPTOPP_ASSERT((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));
956  if(!t.m_size) return SecBlock(*this);
957 
958  SecBlock<T, A> result(m_size+t.m_size);
959  if (m_size) {memcpy_s(result.m_ptr, result.m_size*sizeof(T), m_ptr, m_size*sizeof(T));}
960  memcpy_s(result.m_ptr+m_size, (result.m_size-m_size)*sizeof(T), t.m_ptr, t.m_size*sizeof(T));
961  return result;
962  }
963 
964  /// \brief Bitwise compare two SecBlocks
965  /// \param t the other SecBlock
966  /// \returns true if the size and bits are equal, false otherwise
967  /// \details Uses a constant time compare if the arrays are equal size. The constant time
968  /// compare is VerifyBufsEqual() found in misc.h.
969  /// \sa operator!=()
970  bool operator==(const SecBlock<T, A> &t) const
971  {
972  return m_size == t.m_size && VerifyBufsEqual(
973  reinterpret_cast<const byte*>(m_ptr),
974  reinterpret_cast<const byte*>(t.m_ptr), m_size*sizeof(T));
975  }
976 
977  /// \brief Bitwise compare two SecBlocks
978  /// \param t the other SecBlock
979  /// \returns true if the size and bits are equal, false otherwise
980  /// \details Uses a constant time compare if the arrays are equal size. The constant time
981  /// compare is VerifyBufsEqual() found in misc.h.
982  /// \details Internally, operator!=() returns the inverse of operator==().
983  /// \sa operator==()
984  bool operator!=(const SecBlock<T, A> &t) const
985  {
986  return !operator==(t);
987  }
988 
989  /// \brief Change size without preserving contents
990  /// \param newSize the new size of the memory block
991  /// \details Old content is not preserved. If the memory block is reduced in size,
992  /// then the reclaimed memory is set to 0. If the memory block grows in size, then
993  /// the new memory is not initialized. New() resets the element count after the
994  /// previous block is zeroized.
995  /// \details Internally, this SecBlock calls reallocate().
996  /// \sa New(), CleanNew(), Grow(), CleanGrow(), resize()
997  void New(size_type newSize)
998  {
999  m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, false);
1000  m_size = newSize;
1001  m_mark = ELEMS_MAX;
1002  }
1003 
1004  /// \brief Change size without preserving contents
1005  /// \param newSize the new size of the memory block
1006  /// \details Old content is not preserved. If the memory block is reduced in size,
1007  /// then the reclaimed content is set to 0. If the memory block grows in size, then
1008  /// the new memory is initialized to 0. CleanNew() resets the element count after the
1009  /// previous block is zeroized.
1010  /// \details Internally, this SecBlock calls New().
1011  /// \sa New(), CleanNew(), Grow(), CleanGrow(), resize()
1012  void CleanNew(size_type newSize)
1013  {
1014  New(newSize);
1015  if (m_ptr) {memset_z(m_ptr, 0, m_size*sizeof(T));}
1016  m_mark = ELEMS_MAX;
1017  }
1018 
1019  /// \brief Change size and preserve contents
1020  /// \param newSize the new size of the memory block
1021  /// \details Old content is preserved. New content is not initialized.
1022  /// \details Internally, this SecBlock calls reallocate() when size must increase. If the
1023  /// size does not increase, then Grow() does not take action. If the size must
1024  /// change, then use resize(). Grow() resets the element count after the
1025  /// previous block is zeroized.
1026  /// \sa New(), CleanNew(), Grow(), CleanGrow(), resize()
1027  void Grow(size_type newSize)
1028  {
1029  if (newSize > m_size)
1030  {
1031  m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, true);
1032  m_size = newSize;
1033  }
1034  m_mark = ELEMS_MAX;
1035  }
1036 
1037  /// \brief Change size and preserve contents
1038  /// \param newSize the new size of the memory block
1039  /// \details Old content is preserved. New content is initialized to 0.
1040  /// \details Internally, this SecBlock calls reallocate() when size must increase. If the
1041  /// size does not increase, then CleanGrow() does not take action. If the size must
1042  /// change, then use resize(). CleanGrow() resets the element count after the
1043  /// previous block is zeroized.
1044  /// \sa New(), CleanNew(), Grow(), CleanGrow(), resize()
1045  void CleanGrow(size_type newSize)
1046  {
1047  if (newSize > m_size)
1048  {
1049  m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, true);
1050  memset_z(m_ptr+m_size, 0, (newSize-m_size)*sizeof(T));
1051  m_size = newSize;
1052  }
1053  m_mark = ELEMS_MAX;
1054  }
1055 
1056  /// \brief Change size and preserve contents
1057  /// \param newSize the new size of the memory block
1058  /// \details Old content is preserved. If the memory block grows in size, then
1059  /// new memory is not initialized. resize() resets the element count after
1060  /// the previous block is zeroized.
1061  /// \details Internally, this SecBlock calls reallocate().
1062  /// \sa New(), CleanNew(), Grow(), CleanGrow(), resize()
1063  void resize(size_type newSize)
1064  {
1065  m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, true);
1066  m_size = newSize;
1067  m_mark = ELEMS_MAX;
1068  }
1069 
1070  /// \brief Swap contents with another SecBlock
1071  /// \param b the other SecBlock
1072  /// \details Internally, std::swap() is called on m_alloc, m_size and m_ptr.
1074  {
1075  // Swap must occur on the allocator in case its FixedSize that spilled into the heap.
1076  std::swap(m_alloc, b.m_alloc);
1077  std::swap(m_mark, b.m_mark);
1078  std::swap(m_size, b.m_size);
1079  std::swap(m_ptr, b.m_ptr);
1080  }
1081 
1082 protected:
1083  A m_alloc;
1084  size_type m_mark, m_size;
1085  T *m_ptr;
1086 };
1087 
1088 #ifdef CRYPTOPP_DOXYGEN_PROCESSING
1089 /// \brief \ref SecBlock "SecBlock<byte>" typedef.
1090 class SecByteBlock : public SecBlock<byte> {};
1091 /// \brief \ref SecBlock "SecBlock<word>" typedef.
1092 class SecWordBlock : public SecBlock<word> {};
1093 /// \brief SecBlock using \ref AllocatorWithCleanup "AllocatorWithCleanup<byte, true>" typedef
1094 class AlignedSecByteBlock : public SecBlock<byte, AllocatorWithCleanup<byte, true> > {};
1095 #else
1099 #endif
1100 
1101 // No need for move semantics on derived class *if* the class does not add any
1102 // data members; see http://stackoverflow.com/q/31755703, and Rule of {0|3|5}.
1103 
1104 /// \brief Fixed size stack-based SecBlock
1105 /// \tparam T class or type
1106 /// \tparam S fixed-size of the stack-based memory block, in elements
1107 /// \tparam A AllocatorBase derived class for allocation and cleanup
1108 template <class T, unsigned int S, class A = FixedSizeAllocatorWithCleanup<T, S> >
1109 class FixedSizeSecBlock : public SecBlock<T, A>
1110 {
1111 public:
1112  /// \brief Construct a FixedSizeSecBlock
1113  explicit FixedSizeSecBlock() : SecBlock<T, A>(S) {}
1114 };
1115 
1116 /// \brief Fixed size stack-based SecBlock with 16-byte alignment
1117 /// \tparam T class or type
1118 /// \tparam S fixed-size of the stack-based memory block, in elements
1119 /// \tparam T_Align16 boolean that determines whether allocations should be aligned on a 16-byte boundary
1120 template <class T, unsigned int S, bool T_Align16 = true>
1121 class FixedSizeAlignedSecBlock : public FixedSizeSecBlock<T, S, FixedSizeAllocatorWithCleanup<T, S, NullAllocator<T>, T_Align16> >
1122 {
1123 };
1124 
1125 /// \brief Stack-based SecBlock that grows into the heap
1126 /// \tparam T class or type
1127 /// \tparam S fixed-size of the stack-based memory block, in elements
1128 /// \tparam A AllocatorBase derived class for allocation and cleanup
1129 template <class T, unsigned int S, class A = FixedSizeAllocatorWithCleanup<T, S, AllocatorWithCleanup<T> > >
1130 class SecBlockWithHint : public SecBlock<T, A>
1131 {
1132 public:
1133  /// construct a SecBlockWithHint with a count of elements
1134  explicit SecBlockWithHint(size_t size) : SecBlock<T, A>(size) {}
1135 };
1136 
1137 template<class T, bool A, class V, bool B>
1138 inline bool operator==(const CryptoPP::AllocatorWithCleanup<T, A>&, const CryptoPP::AllocatorWithCleanup<V, B>&) {return (true);}
1139 template<class T, bool A, class V, bool B>
1140 inline bool operator!=(const CryptoPP::AllocatorWithCleanup<T, A>&, const CryptoPP::AllocatorWithCleanup<V, B>&) {return (false);}
1141 
1142 NAMESPACE_END
1143 
1144 NAMESPACE_BEGIN(std)
1145 
1146 /// \brief Swap two SecBlocks
1147 /// \tparam T class or type
1148 /// \tparam A AllocatorBase derived class for allocation and cleanup
1149 /// \param a the first SecBlock
1150 /// \param b the second SecBlock
1151 template <class T, class A>
1152 inline void swap(CryptoPP::SecBlock<T, A> &a, CryptoPP::SecBlock<T, A> &b)
1153 {
1154  a.swap(b);
1155 }
1156 
1157 #if defined(_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) || (defined(_STLPORT_VERSION) && !defined(_STLP_MEMBER_TEMPLATE_CLASSES))
1158 // working for STLport 5.1.3 and MSVC 6 SP5
1159 template <class _Tp1, class _Tp2>
1160 inline CryptoPP::AllocatorWithCleanup<_Tp2>&
1161 __stl_alloc_rebind(CryptoPP::AllocatorWithCleanup<_Tp1>& __a, const _Tp2*)
1162 {
1163  return (CryptoPP::AllocatorWithCleanup<_Tp2>&)(__a);
1164 }
1165 #endif
1166 
1167 NAMESPACE_END
1168 
1169 #if CRYPTOPP_MSC_VERSION
1170 # pragma warning(pop)
1171 #endif
1172 
1173 #endif
iterator end()
Provides an iterator pointing beyond the last element in the memory block.
Definition: secblock.h:811
An invalid argument was detected.
Definition: cryptlib.h:202
void construct(V *ptr, Args &&... args)
Constructs a new V using variadic arguments.
Definition: secblock.h:91
CRYPTOPP_DLL void CRYPTOPP_API UnalignedDeallocate(void *ptr)
Frees a buffer allocated with UnalignedAllocate.
Definition: allocate.cpp:100
Base class for all allocators used by SecBlock.
Definition: secblock.h:29
void swap(SecBlock< T, A > &b)
Swap contents with another SecBlock.
Definition: secblock.h:1073
Stack-based SecBlock that grows into the heap.
Definition: secblock.h:1130
Utility functions for the Crypto++ library.
FixedSizeSecBlock()
Construct a FixedSizeSecBlock.
Definition: secblock.h:1113
void CleanNew(size_type newSize)
Change size without preserving contents.
Definition: secblock.h:1012
SecBlock< T, A > & operator=(const SecBlock< T, A > &t)
Assign contents from another SecBlock.
Definition: secblock.h:917
size_type SizeInBytes() const
Provides the number of bytes in the SecBlock.
Definition: secblock.h:842
void resize(size_type newSize)
Change size and preserve contents.
Definition: secblock.h:1063
SecBlock< T, A > & operator+=(const SecBlock< T, A > &t)
Append contents from another SecBlock.
Definition: secblock.h:927
static const size_type ELEMS_MAX
Returns the maximum number of elements the allocator can provide.
Definition: secblock.h:58
void CleanGrow(size_type newSize)
Change size and preserve contents.
Definition: secblock.h:1045
CRYPTOPP_DLL void *CRYPTOPP_API AlignedAllocate(size_t size)
Allocates a buffer on 16-byte boundary.
Definition: allocate.cpp:43
const_iterator end() const
Provides a constant iterator pointing beyond the last element in the memory block.
Definition: secblock.h:815
void Assign(const SecBlock< T, A > &t)
Copy contents from another SecBlock.
Definition: secblock.h:900
SecBlock< T, A > operator+(const SecBlock< T, A > &t)
Construct a SecBlock from this and another SecBlock.
Definition: secblock.h:952
pointer allocate(size_type size, const void *hint)
Allocates a block of memory.
Definition: secblock.h:606
SecBlock(size_type size=0)
Construct a SecBlock with space for size elements.
Definition: secblock.h:742
Secure memory block with allocator and cleanup.
Definition: secblock.h:707
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
Definition: misc.h:506
Library configuration file.
bool operator!=(const SecBlock< T, A > &t) const
Bitwise compare two SecBlocks.
Definition: secblock.h:984
STL namespace.
Common C++ header files.
void New(size_type newSize)
Change size without preserving contents.
Definition: secblock.h:997
SecBlock<byte> typedef.
Definition: secblock.h:1090
pointer allocate(size_type size, const void *hint)
Allocates a block of memory.
Definition: secblock.h:402
pointer reallocate(T *oldPtr, size_type oldSize, size_type newSize, bool preserve)
Reallocates a block of memory.
Definition: secblock.h:259
pointer reallocate(pointer oldPtr, size_type oldSize, size_type newSize, bool preserve)
Reallocates a block of memory.
Definition: secblock.h:461
bool operator==(const OID &lhs, const OID &rhs)
Compare two OIDs for equality.
Static secure memory block with cleanup.
Definition: secblock.h:336
Allocates a block of memory with cleanup.
Definition: secblock.h:187
size_type max_size() const
Returns the maximum number of elements the allocator can provide.
Definition: secblock.h:73
Functions for allocating aligned buffers.
pointer allocate(size_type size)
Allocates a block of memory.
Definition: secblock.h:580
bool operator!=(const OID &lhs, const OID &rhs)
Compare two OIDs for inequality.
void SecureWipeArray(T *buf, size_t n)
Sets each element of an array to 0.
Definition: misc.h:1471
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
Definition: misc.h:1207
pointer allocate(size_type size)
Allocates a block of memory.
Definition: secblock.h:376
CRYPTOPP_DLL bool CRYPTOPP_API VerifyBufsEqual(const byte *buf1, const byte *buf2, size_t count)
Performs a near constant-time comparison of two equally sized buffers.
Definition: misc.cpp:114
Template class member Rebind.
Definition: secblock.h:272
A::pointer data()
Provides a pointer to the first element in the memory block.
Definition: secblock.h:820
void Assign(const T *ptr, size_type len)
Set contents and size from an array.
Definition: secblock.h:872
FixedSizeAllocatorWithCleanup()
Constructs a FixedSizeAllocatorWithCleanup.
Definition: secblock.h:362
A::const_pointer data() const
Provides a pointer to the first element in the memory block.
Definition: secblock.h:823
Fixed size stack-based SecBlock with 16-byte alignment.
Definition: secblock.h:1121
void deallocate(void *ptr, size_type size)
Deallocates a block of memory.
Definition: secblock.h:421
pointer reallocate(pointer oldPtr, size_type oldSize, size_type newSize, bool preserve)
Reallocates a block of memory.
Definition: secblock.h:664
FixedSizeAllocatorWithCleanup()
Constructs a FixedSizeAllocatorWithCleanup.
Definition: secblock.h:566
SecBlock using AllocatorWithCleanup<byte, true> typedef.
Definition: secblock.h:1094
CRYPTOPP_DLL void *CRYPTOPP_API UnalignedAllocate(size_t size)
Allocates a buffer.
Definition: allocate.cpp:92
pointer allocate(size_type size, const void *ptr=NULL)
Allocates a block of memory.
Definition: secblock.h:206
Fixed size stack-based SecBlock.
Definition: secblock.h:1109
SecBlock(const SecBlock< T, A > &t)
Copy construct a SecBlock from another SecBlock.
Definition: secblock.h:748
void * memset_z(void *ptr, int value, size_t num)
Memory block initializer and eraser that attempts to survive optimizations.
Definition: misc.h:613
const T & STDMIN(const T &a, const T &b)
Replacement function for std::min.
Definition: misc.h:630
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Definition: trap.h:69
void deallocate(void *ptr, size_type size)
Deallocates a block of memory.
Definition: secblock.h:229
iterator begin()
Provides an iterator pointing to the first element in the memory block.
Definition: secblock.h:803
bool operator==(const SecBlock< T, A > &t) const
Bitwise compare two SecBlocks.
Definition: secblock.h:970
NULL allocator.
Definition: secblock.h:298
CRYPTOPP_DLL void CRYPTOPP_API AlignedDeallocate(void *ptr)
Frees a buffer allocated with AlignedAllocate.
Definition: allocate.cpp:72
SecBlockWithHint(size_t size)
construct a SecBlockWithHint with a count of elements
Definition: secblock.h:1134
const byte * BytePtr() const
Return a byte pointer to the first element in the memory block.
Definition: secblock.h:838
A::pointer StandardReallocate(A &alloc, T *oldPtr, typename A::size_type oldSize, typename A::size_type newSize, bool preserve)
Reallocation function.
Definition: secblock.h:149
const_iterator begin() const
Provides a constant iterator pointing to the first element in the memory block.
Definition: secblock.h:807
SecBlock(const T *ptr, size_type len)
Construct a SecBlock from an array of elements.
Definition: secblock.h:762
const T & STDMAX(const T &a, const T &b)
Replacement function for std::max.
Definition: misc.h:641
void deallocate(void *ptr, size_type size)
Deallocates a block of memory.
Definition: secblock.h:625
void Grow(size_type newSize)
Change size and preserve contents.
Definition: secblock.h:1027
Crypto++ library namespace.
void destroy(V *ptr)
Destroys an V constructed with variadic arguments.
Definition: secblock.h:98
void Assign(size_type count, T value)
Set contents from a value.
Definition: secblock.h:885
void SetMark(size_t count)
Sets the number of elements to zeroize.
Definition: secblock.h:865
void swap(::SecBlock< T, A > &a, ::SecBlock< T, A > &b)
Swap two SecBlocks.
Definition: secblock.h:1152
bool empty() const
Determines if the SecBlock is empty.
Definition: secblock.h:831
SecBlock<word> typedef.
Definition: secblock.h:1092
size_type size() const
Provides the count of elements in the SecBlock.
Definition: secblock.h:828
#define SIZE_MAX
The maximum value of a machine word.
Definition: misc.h:116
byte * BytePtr()
Provides a byte pointer to the first element in the memory block.
Definition: secblock.h:835