secblock.h

Go to the documentation of this file.

// secblock.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_SECBLOCK_H
#define CRYPTOPP_SECBLOCK_H
 
#include "config.h"
#include "allocate.h"
#include "misc.h"
#include "stdcpp.h"
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4231 4275 4700)
# if (CRYPTOPP_MSC_VERSION >= 1400)
#  pragma warning(disable: 6011 6386 28193)
# endif
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
// ************** secure memory allocation ***************
 
 
template<class T>
class AllocatorBase
{
public:
        typedef T value_type;
        typedef size_t size_type;
        typedef std::ptrdiff_t difference_type;
        typedef T * pointer;
        typedef const T * const_pointer;
        typedef T & reference;
        typedef const T & const_reference;
 
        pointer address(reference r) const {return (&r);}
        const_pointer address(const_reference r) const {return (&r); }
        void construct(pointer p, const T& val) {new (p) T(val);}
        void destroy(pointer p) {CRYPTOPP_UNUSED(p); p->~T();}
 
#if defined(CRYPTOPP_DOXYGEN_PROCESSING)
        static const size_type ELEMS_MAX = ...;
#elif defined(_MSC_VER) && (_MSC_VER <= 1400)
        static const size_type ELEMS_MAX = (~(size_type)0)/sizeof(T);
#elif defined(CRYPTOPP_CXX11_STRONG_ENUM)
        enum : size_type {ELEMS_MAX = SIZE_MAX/sizeof(T)};
#else
        static const size_type ELEMS_MAX = SIZE_MAX/sizeof(T);
#endif
 
        CRYPTOPP_CONSTEXPR size_type max_size() const {return ELEMS_MAX;}
 
#if defined(__SUNPRO_CC)
        // https://github.com/weidai11/cryptopp/issues/770
        // and https://stackoverflow.com/q/53999461/608639
        CRYPTOPP_CONSTEXPR size_type max_size(size_type n) const {return SIZE_MAX/n;}
#endif
 
#if defined(CRYPTOPP_CXX11_VARIADIC_TEMPLATES) || defined(CRYPTOPP_DOXYGEN_PROCESSING)
 
    template<typename V, typename... Args>
    void construct(V* ptr, Args&&... args) {::new ((void*)ptr) V(std::forward<Args>(args)...);}
 
    template<typename V>
    void destroy(V* ptr) {if (ptr) ptr->~V();}
 
#endif
 
protected:
 
        static void CheckSize(size_t size)
        {
                // Squash MSC C4100 warning for size. Also see commit 42b7c4ea5673.
                CRYPTOPP_UNUSED(size);
                // C++ throws std::bad_alloc (C++03) or std::bad_array_new_length (C++11) here.
                if (sizeof(T) != 1 && size > ELEMS_MAX)
                        throw InvalidArgument("AllocatorBase: requested size would cause integer overflow");
        }
};
 
#define CRYPTOPP_INHERIT_ALLOCATOR_TYPES(T_type)        \
        typedef typename AllocatorBase<T_type>::value_type value_type;\
        typedef typename AllocatorBase<T_type>::size_type size_type;\
        typedef typename AllocatorBase<T_type>::difference_type difference_type;\
        typedef typename AllocatorBase<T_type>::pointer pointer;\
        typedef typename AllocatorBase<T_type>::const_pointer const_pointer;\
        typedef typename AllocatorBase<T_type>::reference reference;\
        typedef typename AllocatorBase<T_type>::const_reference const_reference;
 
template <class T, class A>
typename A::pointer StandardReallocate(A& alloc, T *oldPtr, typename A::size_type oldSize, typename A::size_type newSize, bool preserve)
{
        // Avoid assert on pointer in reallocate. SecBlock regularly uses NULL
        // pointers rather returning non-NULL 0-sized pointers.
        if (oldSize == newSize)
                return oldPtr;
 
        if (preserve)
        {
                typename A::pointer newPtr = alloc.allocate(newSize, NULLPTR);
                const typename A::size_type copySize = STDMIN(oldSize, newSize) * sizeof(T);
 
                if (oldPtr && newPtr)
                        memcpy_s(newPtr, copySize, oldPtr, copySize);
 
                if (oldPtr)
                        alloc.deallocate(oldPtr, oldSize);
 
                return newPtr;
        }
        else
        {
                if (oldPtr)
                        alloc.deallocate(oldPtr, oldSize);
 
                return alloc.allocate(newSize, NULLPTR);
        }
}
 
template <class T, bool T_Align16 = false>
class AllocatorWithCleanup : public AllocatorBase<T>
{
public:
        CRYPTOPP_INHERIT_ALLOCATOR_TYPES(T)
 
        
        pointer allocate(size_type size, const void *ptr = NULLPTR)
        {
                CRYPTOPP_UNUSED(ptr); CRYPTOPP_ASSERT(ptr == NULLPTR);
                this->CheckSize(size);
                if (size == 0)
                        return NULLPTR;
 
#if CRYPTOPP_BOOL_ALIGN16
                if (T_Align16)
                        return reinterpret_cast<pointer>(AlignedAllocate(size*sizeof(T)));
#endif
 
                return reinterpret_cast<pointer>(UnalignedAllocate(size*sizeof(T)));
        }
 
        void deallocate(void *ptr, size_type size)
        {
                // Avoid assert on pointer in deallocate. SecBlock regularly uses NULL
                // pointers rather returning non-NULL 0-sized pointers.
                if (ptr)
                {
                        SecureWipeArray(reinterpret_cast<pointer>(ptr), size);
 
#if CRYPTOPP_BOOL_ALIGN16
                        if (T_Align16)
                                return AlignedDeallocate(ptr);
#endif
 
                        UnalignedDeallocate(ptr);
                }
        }
 
        pointer reallocate(T *oldPtr, size_type oldSize, size_type newSize, bool preserve)
        {
                CRYPTOPP_ASSERT((oldPtr && oldSize) || !(oldPtr || oldSize));
                return StandardReallocate(*this, oldPtr, oldSize, newSize, preserve);
        }
 
    template <class V> struct rebind { typedef AllocatorWithCleanup<V, T_Align16> other; };
#if _MSC_VER >= 1500
        AllocatorWithCleanup() {}
        template <class V, bool A> AllocatorWithCleanup(const AllocatorWithCleanup<V, A> &) {}
#endif
};
 
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<byte>;
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word16>;
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word32>;
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word64>;
#if defined(CRYPTOPP_WORD128_AVAILABLE)
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word128, true>; // for Integer
#endif
#if CRYPTOPP_BOOL_X86
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word, true>;    // for Integer
#endif
 
template <class T>
class NullAllocator : public AllocatorBase<T>
{
public:
        //LCOV_EXCL_START
        CRYPTOPP_INHERIT_ALLOCATOR_TYPES(T)
 
        // TODO: should this return NULL or throw bad_alloc? Non-Windows C++ standard
        // libraries always throw. And late mode Windows throws. Early model Windows
        // (circa VC++ 6.0) returned NULL.
        pointer allocate(size_type n, const void* unused = NULLPTR)
        {
                CRYPTOPP_UNUSED(n); CRYPTOPP_UNUSED(unused);
                CRYPTOPP_ASSERT(false); return NULLPTR;
        }
 
        void deallocate(void *p, size_type n)
        {
                CRYPTOPP_UNUSED(p); CRYPTOPP_UNUSED(n);
                CRYPTOPP_ASSERT(false);
        }
 
        CRYPTOPP_CONSTEXPR size_type max_size() const {return 0;}
        //LCOV_EXCL_STOP
};
 
template <class T, size_t S, class A = NullAllocator<T>, bool T_Align16 = false>
class FixedSizeAllocatorWithCleanup : public AllocatorBase<T>
{
        // The body of FixedSizeAllocatorWithCleanup is provided in the two
        // partial specializations that follow. The two specializations
        // pivot on the boolean template parameter T_Align16.
};
 
template <class T, size_t S, class A>
class FixedSizeAllocatorWithCleanup<T, S, A, true> : public AllocatorBase<T>
{
public:
        CRYPTOPP_INHERIT_ALLOCATOR_TYPES(T)
 
        
        FixedSizeAllocatorWithCleanup() : m_allocated(false) {}
 
        pointer allocate(size_type size)
        {
                CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));
 
                if (size <= S && !m_allocated)
                {
                        m_allocated = true;
                        return GetAlignedArray();
                }
                else
                        return m_fallbackAllocator.allocate(size);
        }
 
        pointer allocate(size_type size, const void *hint)
        {
                CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));
 
                if (size <= S && !m_allocated)
                {
                        m_allocated = true;
                        return GetAlignedArray();
                }
                else
                        return m_fallbackAllocator.allocate(size, hint);
        }
 
        void deallocate(void *ptr, size_type size)
        {
                // Avoid assert on pointer in deallocate. SecBlock regularly uses NULL
                // pointers rather returning non-NULL 0-sized pointers.
                if (ptr == GetAlignedArray())
                {
                        // If the m_allocated assert fires then the bit twiddling for
                        // GetAlignedArray() is probably incorrect for the platform.
                        // Be sure to check CRYPTOPP_ALIGN_DATA(8). The platform may
                        // not have a way to declaratively align data to 8.
                        CRYPTOPP_ASSERT(size <= S);
                        CRYPTOPP_ASSERT(m_allocated);
                        m_allocated = false;
                        SecureWipeArray(reinterpret_cast<pointer>(ptr), size);
                }
                else
                {
                        if (ptr)
                                m_fallbackAllocator.deallocate(ptr, size);
                }
        }
 
        pointer reallocate(pointer oldPtr, size_type oldSize, size_type newSize, bool preserve)
        {
                if (oldPtr == GetAlignedArray() && newSize <= S)
                {
                        CRYPTOPP_ASSERT(oldSize <= S);
                        if (oldSize > newSize)
                                SecureWipeArray(oldPtr+newSize, oldSize-newSize);
                        return oldPtr;
                }
 
                pointer newPtr = allocate(newSize, NULLPTR);
                if (preserve && newSize)
                {
                        const size_type copySize = STDMIN(oldSize, newSize);
                        if (newPtr && oldPtr)  // GCC analyzer warning
                                memcpy_s(newPtr, sizeof(T)*newSize, oldPtr, sizeof(T)*copySize);
                }
                deallocate(oldPtr, oldSize);
                return newPtr;
        }
 
        CRYPTOPP_CONSTEXPR size_type max_size() const
        {
                return STDMAX(m_fallbackAllocator.max_size(), S);
        }
 
private:
 
#if CRYPTOPP_BOOL_ALIGN16
 
        // There be demons here... We cannot use CRYPTOPP_ALIGN_DATA(16)
        // because linkers on 32-bit machines and some 64-bit machines
        // align the stack to 8-bytes or less, and not 16-bytes as
        // requested. We can only count on a smaller alignment. All
        // toolchains tested appear to honor CRYPTOPP_ALIGN_DATA(8). Also
        // see http://stackoverflow.com/a/1468656/608639.
        //
        // The 16-byte alignment is achieved by padding the requested
        // size with extra elements so we have at least 8-bytes of slack
        // to work with. Then the array pointer is moved to achieve a
        // 16-byte alignment.
        //
        // The additional 8-bytes introduces a small secondary issue.
        // The secondary issue is, a large T results in 0 = 8/sizeof(T).
        // The library is OK but users may hit it. So we need to guard
        // for a large T, and that is what the enum and PAD achieves.
        T* GetAlignedArray() {
 
                // m_array is aligned on 8 byte boundaries due to
                // CRYPTOPP_ALIGN_DATA(8). If m_array%16 is 0, then the buffer
                // is 16-byte aligned and nothing needs to be done. if
                // m_array%16 is 8, then the buffer is not 16-byte aligned and
                // we need to add 8. 8 has that nice symmetric property.
                //
                // If we needed to use CRYPTOPP_ALIGN_DATA(4) due to toolchain
                // limitations, then the calculation would be slightly more
                // costly: ptr = m_array + (16 - (m_array % 16)) % 16;
                CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));
                int off = reinterpret_cast<uintptr_t>(m_array) % 16;
                byte* ptr = reinterpret_cast<byte*>(m_array) + off;
 
                // Verify the 16-byte alignment. This is the point
                // of these extra gyrations.
                CRYPTOPP_ASSERT(IsAlignedOn(ptr, 16));
                // Verify the lower bound. This is Issue 982/988.
                CRYPTOPP_ASSERT(
                        reinterpret_cast<uintptr_t>(ptr) >=
                          reinterpret_cast<uintptr_t>(m_array)
                );
                // Verify the upper bound. Allocated array with
                // pad is large enough.
                CRYPTOPP_ASSERT(
                        reinterpret_cast<uintptr_t>(ptr+S*sizeof(T)) <=
                          reinterpret_cast<uintptr_t>(m_array+(S+PAD))
                );
 
                // void* to silence Clang warnings
                return reinterpret_cast<T*>(
                  static_cast<void*>(ptr)
                );
        }
 
        // PAD is elements, not bytes, and rounded up to ensure no overflow.
        enum { Q = sizeof(T), PAD = (Q >= 8) ? 1 : (Q >= 4) ? 2 : (Q >= 2) ? 4 : 8 };
        // enum { Q = sizeof(T), PAD = (Q >= 16) ? 1 : (Q >= 8) ? 2 : (Q >= 4) ? 4 : (Q >= 2) ? 8 : 16 };
        CRYPTOPP_ALIGN_DATA(8) T m_array[S+PAD];
 
#else
 
        // CRYPTOPP_BOOL_ALIGN16 is 0. If we are here then the user
        // probably compiled with CRYPTOPP_DISABLE_ASM. Normally we
        // would use the natural alignment of T. The problem we are
        // having is, some toolchains are changing the boundary for
        // 64-bit arrays. 64-bit elements require 8-byte alignment,
        // but the toolchain is laying the array out on a 4 byte
        // boundary. See GH #992 for mystery alignment,
        // https://github.com/weidai11/cryptopp/issues/992
        T* GetAlignedArray() {return m_array;}
        CRYPTOPP_ALIGN_DATA(8) T m_array[S];
 
#endif
 
        A m_fallbackAllocator;
        bool m_allocated;
};
 
template <class T, size_t S, class A>
class FixedSizeAllocatorWithCleanup<T, S, A, false> : public AllocatorBase<T>
{
public:
        CRYPTOPP_INHERIT_ALLOCATOR_TYPES(T)
 
        
        FixedSizeAllocatorWithCleanup() : m_allocated(false) {}
 
        pointer allocate(size_type size)
        {
                CRYPTOPP_ASSERT(IsAlignedOn(m_array, 8));
 
                if (size <= S && !m_allocated)
                {
                        m_allocated = true;
                        return GetAlignedArray();
                }
                else
                        return m_fallbackAllocator.allocate(size);
        }
 
        pointer allocate(size_type size, const void *hint)
        {
                if (size <= S && !m_allocated)
                {
                        m_allocated = true;
                        return GetAlignedArray();
                }
                else
                        return m_fallbackAllocator.allocate(size, hint);
        }
 
        void deallocate(void *ptr, size_type size)
        {
                // Avoid assert on pointer in deallocate. SecBlock regularly uses NULL
                // pointers rather returning non-NULL 0-sized pointers.
                if (ptr == GetAlignedArray())
                {
                        // If the m_allocated assert fires then
                        // something overwrote the flag.
                        CRYPTOPP_ASSERT(size <= S);
                        CRYPTOPP_ASSERT(m_allocated);
                        m_allocated = false;
                        SecureWipeArray((pointer)ptr, size);
                }
                else
                {
                        if (ptr)
                                m_fallbackAllocator.deallocate(ptr, size);
                        m_allocated = false;
                }
        }
 
        pointer reallocate(pointer oldPtr, size_type oldSize, size_type newSize, bool preserve)
        {
                if (oldPtr == GetAlignedArray() && newSize <= S)
                {
                        CRYPTOPP_ASSERT(oldSize <= S);
                        if (oldSize > newSize)
                                SecureWipeArray(oldPtr+newSize, oldSize-newSize);
                        return oldPtr;
                }
 
                pointer newPtr = allocate(newSize, NULLPTR);
                if (preserve && newSize)
                {
                        const size_type copySize = STDMIN(oldSize, newSize);
                        if (newPtr && oldPtr)  // GCC analyzer warning
                                memcpy_s(newPtr, sizeof(T)*newSize, oldPtr, sizeof(T)*copySize);
                }
                deallocate(oldPtr, oldSize);
                return newPtr;
        }
 
        CRYPTOPP_CONSTEXPR size_type max_size() const
        {
                return STDMAX(m_fallbackAllocator.max_size(), S);
        }
 
private:
 
        // T_Align16 is false. Normally we would use the natural
        // alignment of T. The problem we are having is, some toolchains
        // are changing the boundary for 64-bit arrays. 64-bit elements
        // require 8-byte alignment, but the toolchain is laying the array
        // out on a 4 byte boundary. See GH #992 for mystery alignment,
        // https://github.com/weidai11/cryptopp/issues/992
        T* GetAlignedArray() {return m_array;}
        CRYPTOPP_ALIGN_DATA(8) T m_array[S];
 
        A m_fallbackAllocator;
        bool m_allocated;
};
 
template <class T, class A = AllocatorWithCleanup<T> >
class SecBlock
{
public:
        typedef typename A::value_type value_type;
        typedef typename A::pointer iterator;
        typedef typename A::const_pointer const_iterator;
        typedef typename A::size_type size_type;
 
#if defined(CRYPTOPP_DOXYGEN_PROCESSING)
        static const size_type ELEMS_MAX = ...;
#elif defined(_MSC_VER) && (_MSC_VER <= 1400)
        static const size_type ELEMS_MAX = (~(size_type)0)/sizeof(T);
#elif defined(CRYPTOPP_CXX11_STRONG_ENUM)
        enum : size_type {ELEMS_MAX = A::ELEMS_MAX};
#else
        static const size_type ELEMS_MAX = SIZE_MAX/sizeof(T);
#endif
 
        explicit SecBlock(size_type size=0)
                : m_mark(ELEMS_MAX), m_size(size), m_ptr(m_alloc.allocate(size, NULLPTR)) { }
 
        SecBlock(const SecBlock<T, A> &t)
                : m_mark(t.m_mark), m_size(t.m_size), m_ptr(m_alloc.allocate(t.m_size, NULLPTR)) {
                        CRYPTOPP_ASSERT((!t.m_ptr && !m_size) || (t.m_ptr && m_size));
                        if (m_ptr && t.m_ptr)
                                memcpy_s(m_ptr, m_size*sizeof(T), t.m_ptr, t.m_size*sizeof(T));
                }
 
        SecBlock(const T *ptr, size_type len)
                : m_mark(ELEMS_MAX), m_size(len), m_ptr(m_alloc.allocate(len, NULLPTR)) {
                        CRYPTOPP_ASSERT((!m_ptr && !m_size) || (m_ptr && m_size));
                        if (m_ptr && ptr)
                                memcpy_s(m_ptr, m_size*sizeof(T), ptr, len*sizeof(T));
                        else if (m_ptr && m_size)
                                memset(m_ptr, 0, m_size*sizeof(T));
                }
 
        ~SecBlock()
                {m_alloc.deallocate(m_ptr, STDMIN(m_size, m_mark));}
 
#ifdef __BORLANDC__
        operator T *() const
                {return (T*)m_ptr;}
#else
        operator const void *() const
                {return m_ptr;}
 
        operator void *()
                {return m_ptr;}
 
        operator const T *() const
                {return m_ptr;}
 
        operator T *()
                {return m_ptr;}
#endif
 
        iterator begin()
                {return m_ptr;}
        const_iterator begin() const
                {return m_ptr;}
        iterator end()
                {return m_ptr+m_size;}
        const_iterator end() const
                {return m_ptr+m_size;}
 
        typename A::pointer data() {return m_ptr;}
        typename A::const_pointer data() const {return m_ptr;}
 
        size_type size() const {return m_size;}
        bool empty() const {return m_size == 0;}
 
        byte * BytePtr() {return (byte *)m_ptr;}
        const byte * BytePtr() const {return (const byte *)m_ptr;}
        size_type SizeInBytes() const {return m_size*sizeof(T);}
 
        void Assign(const T *ptr, size_type len)
        {
                New(len);
                if (m_ptr && ptr)  // GCC analyzer warning
                        memcpy_s(m_ptr, m_size*sizeof(T), ptr, len*sizeof(T));
                m_mark = ELEMS_MAX;
        }
 
        void Assign(size_type count, T value)
        {
                New(count);
                for (size_t i=0; i<count; ++i)
                        m_ptr[i] = value;
                m_mark = ELEMS_MAX;
        }
 
        void Assign(const SecBlock<T, A> &t)
        {
                if (this != &t)
                {
                        New(t.m_size);
                        if (m_ptr && t.m_ptr)  // GCC analyzer warning
                                memcpy_s(m_ptr, m_size*sizeof(T), t, t.m_size*sizeof(T));
                }
                m_mark = ELEMS_MAX;
        }
 
        void Append(const T *ptr, size_type len)
        {
                if (ELEMS_MAX - m_size < len)
                        throw InvalidArgument("SecBlock: buffer overflow");
 
                const size_type oldSize = m_size;
                Grow(m_size+len);
                if (m_ptr && ptr)  // GCC analyzer warning
                        memcpy_s(m_ptr+oldSize, (m_size-oldSize)*sizeof(T), ptr, len*sizeof(T));
                m_mark = ELEMS_MAX;
        }
 
        void Append(const SecBlock<T, A> &t)
        {
                if (ELEMS_MAX - m_size < t.m_size)
                        throw InvalidArgument("SecBlock: buffer overflow");
 
                const size_type oldSize = m_size;
                if (this != &t)  // s += t
                {
                        Grow(m_size+t.m_size);
                        if (m_ptr && t.m_ptr)  // GCC analyzer warning
                                memcpy_s(m_ptr+oldSize, (m_size-oldSize)*sizeof(T), t.m_ptr, t.m_size*sizeof(T));
                }
                else            // t += t
                {
                        Grow(m_size*2);
                        if (m_ptr)  // GCC analyzer warning
                                memmove_s(m_ptr+oldSize, (m_size-oldSize)*sizeof(T), m_ptr, oldSize*sizeof(T));
                }
                m_mark = ELEMS_MAX;
        }
 
        void Append(size_type count, T value)
        {
                if (ELEMS_MAX - m_size < count)
                        throw InvalidArgument("SecBlock: buffer overflow");
 
                const size_type oldSize = m_size;
                Grow(m_size+count);
                for (size_t i=oldSize; i<oldSize+count; ++i)
                        m_ptr[i] = value;
                m_mark = ELEMS_MAX;
        }
 
        void SetMark(size_t count) {m_mark = count;}
 
        SecBlock<T, A>& operator=(const SecBlock<T, A> &t)
        {
                // Assign guards for self-assignment
                Assign(t);
                return *this;
        }
 
        SecBlock<T, A>& operator+=(const SecBlock<T, A> &t)
        {
                // Append guards for overflow
                Append(t);
                return *this;
        }
 
        SecBlock<T, A> operator+(const SecBlock<T, A> &t)
        {
                CRYPTOPP_ASSERT((!m_ptr && !m_size) || (m_ptr && m_size));
                CRYPTOPP_ASSERT((!t.m_ptr && !t.m_size) || (t.m_ptr && t.m_size));
                if(!t.m_size) return SecBlock(*this);
 
                SecBlock<T, A> result(m_size+t.m_size);
                if (m_size)
                        memcpy_s(result.m_ptr, result.m_size*sizeof(T), m_ptr, m_size*sizeof(T));
                if (result.m_ptr && t.m_ptr)  // GCC analyzer warning
                        memcpy_s(result.m_ptr+m_size, (result.m_size-m_size)*sizeof(T), t.m_ptr, t.m_size*sizeof(T));
                return result;
        }
 
        bool operator==(const SecBlock<T, A> &t) const
        {
                return m_size == t.m_size && VerifyBufsEqual(
                        reinterpret_cast<const byte*>(m_ptr),
                        reinterpret_cast<const byte*>(t.m_ptr), m_size*sizeof(T));
        }
 
        bool operator!=(const SecBlock<T, A> &t) const
        {
                return !operator==(t);
        }
 
        void New(size_type newSize)
        {
                m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, false);
                m_size = newSize;
                m_mark = ELEMS_MAX;
        }
 
        void CleanNew(size_type newSize)
        {
                New(newSize);
                if (m_ptr) {memset_z(m_ptr, 0, m_size*sizeof(T));}
                m_mark = ELEMS_MAX;
        }
 
        void Grow(size_type newSize)
        {
                if (newSize > m_size)
                {
                        m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, true);
                        m_size = newSize;
                }
                m_mark = ELEMS_MAX;
        }
 
        void CleanGrow(size_type newSize)
        {
                if (newSize > m_size)
                {
                        m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, true);
                        memset_z(m_ptr+m_size, 0, (newSize-m_size)*sizeof(T));
                        m_size = newSize;
                }
                m_mark = ELEMS_MAX;
        }
 
        void resize(size_type newSize)
        {
                m_ptr = m_alloc.reallocate(m_ptr, m_size, newSize, true);
                m_size = newSize;
                m_mark = ELEMS_MAX;
        }
 
        void swap(SecBlock<T, A> &b)
        {
                // Swap must occur on the allocator in case its FixedSize that spilled into the heap.
                std::swap(m_alloc, b.m_alloc);
                std::swap(m_mark, b.m_mark);
                std::swap(m_size, b.m_size);
                std::swap(m_ptr, b.m_ptr);
        }
 
protected:
        A m_alloc;
        size_type m_mark, m_size;
        T *m_ptr;
};
 
#ifdef CRYPTOPP_DOXYGEN_PROCESSING
class SecByteBlock : public SecBlock<byte> {};
class SecWordBlock : public SecBlock<word> {};
class AlignedSecByteBlock : public SecBlock<byte, AllocatorWithCleanup<byte, true> > {};
#else
typedef SecBlock<byte> SecByteBlock;
typedef SecBlock<word> SecWordBlock;
typedef SecBlock<byte, AllocatorWithCleanup<byte, true> > AlignedSecByteBlock;
#endif
 
// No need for move semantics on derived class *if* the class does not add any
// data members; see http://stackoverflow.com/q/31755703, and Rule of {0|3|5}.
 
template <class T, unsigned int S, class A = FixedSizeAllocatorWithCleanup<T, S> >
class FixedSizeSecBlock : public SecBlock<T, A>
{
public:
        explicit FixedSizeSecBlock() : SecBlock<T, A>(S) {}
};
 
template <class T, unsigned int S, bool T_Align16 = true>
class FixedSizeAlignedSecBlock : public FixedSizeSecBlock<T, S, FixedSizeAllocatorWithCleanup<T, S, NullAllocator<T>, T_Align16> >
{
};
 
template <class T, unsigned int S, class A = FixedSizeAllocatorWithCleanup<T, S, AllocatorWithCleanup<T> > >
class SecBlockWithHint : public SecBlock<T, A>
{
public:
        explicit SecBlockWithHint(size_t size) : SecBlock<T, A>(size) {}
};
 
template<class T, bool A, class V, bool B>
inline bool operator==(const CryptoPP::AllocatorWithCleanup<T, A>&, const CryptoPP::AllocatorWithCleanup<V, B>&) {return (true);}
template<class T, bool A, class V, bool B>
inline bool operator!=(const CryptoPP::AllocatorWithCleanup<T, A>&, const CryptoPP::AllocatorWithCleanup<V, B>&) {return (false);}
 
NAMESPACE_END
 
NAMESPACE_BEGIN(std)
 
 
template <class T, class A>
inline void swap(CryptoPP::SecBlock<T, A> &a, CryptoPP::SecBlock<T, A> &b)
{
        a.swap(b);
}
 
#if defined(_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) || (defined(_STLPORT_VERSION) && !defined(_STLP_MEMBER_TEMPLATE_CLASSES))
// working for STLport 5.1.3 and MSVC 6 SP5
template <class _Tp1, class _Tp2>
inline CryptoPP::AllocatorWithCleanup<_Tp2>&
__stl_alloc_rebind(CryptoPP::AllocatorWithCleanup<_Tp1>& __a, const _Tp2*)
{
        return (CryptoPP::AllocatorWithCleanup<_Tp2>&)(__a);
}
#endif
 
NAMESPACE_END
 
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
 
#endif