/************************************************* * Secure Memory Buffers Header File * * (C) 1999-2007 Jack Lloyd * *************************************************/ #ifndef BOTAN_SECURE_MEMORY_BUFFERS_H__ #define BOTAN_SECURE_MEMORY_BUFFERS_H__ #include #include namespace Botan { /************************************************* * Variable Length Memory Buffer * *************************************************/ template class MemoryRegion { public: u32bit size() const { return used; } u32bit is_empty() const { return (used == 0); } u32bit has_items() const { return (used != 0); } operator T* () { return buf; } operator const T* () const { return buf; } T* begin() { return buf; } const T* begin() const { return buf; } T* end() { return (buf + size()); } const T* end() const { return (buf + size()); } bool operator==(const MemoryRegion& other) const { return (size() == other.size() && same_mem(buf, other.buf, size())); } bool operator<(const MemoryRegion&) const; bool operator!=(const MemoryRegion& in) const { return (!(*this == in)); } MemoryRegion& operator=(const MemoryRegion& in) { if(this != &in) set(in); return (*this); } void copy(const T in[], u32bit n) { copy(0, in, n); } void copy(u32bit off, const T in[], u32bit n) { copy_mem(buf + off, in, (n > size() - off) ? (size() - off) : n); } void set(const T in[], u32bit n) { create(n); copy(in, n); } void set(const MemoryRegion& in) { set(in.begin(), in.size()); } void append(const T data[], u32bit n) { grow_to(size()+n); copy(size() - n, data, n); } void append(T x) { append(&x, 1); } void append(const MemoryRegion& x) { append(x.begin(), x.size()); } void clear() { clear_mem(buf, allocated); } void destroy() { create(0); } void create(u32bit); void grow_to(u32bit) const; void swap(MemoryRegion&); ~MemoryRegion() { deallocate(buf, allocated); } protected: MemoryRegion() { buf = 0; alloc = 0; used = allocated = 0; } MemoryRegion(const MemoryRegion& other) { buf = 0; used = allocated = 0; alloc = other.alloc; set(other.buf, other.used); } void init(bool locking, u32bit length = 0) { alloc = Allocator::get(locking); create(length); } private: T* allocate(u32bit n) const { return static_cast(alloc->allocate(sizeof(T)*n)); } void deallocate(T* p, u32bit n) const { alloc->deallocate(p, sizeof(T)*n); } mutable T* buf; mutable u32bit used; mutable u32bit allocated; mutable Allocator* alloc; }; /************************************************* * Create a new buffer * *************************************************/ template void MemoryRegion::create(u32bit n) { if(n <= allocated) { clear(); used = n; return; } deallocate(buf, allocated); buf = allocate(n); allocated = used = n; } /************************************************* * Increase the size of the buffer * *************************************************/ template void MemoryRegion::grow_to(u32bit n) const { if(n > used && n <= allocated) { clear_mem(buf + used, n - used); used = n; return; } else if(n > allocated) { T* new_buf = allocate(n); copy_mem(new_buf, buf, used); deallocate(buf, allocated); buf = new_buf; allocated = used = n; } } /************************************************* * Compare this buffer with another one * *************************************************/ template bool MemoryRegion::operator<(const MemoryRegion& in) const { if(size() < in.size()) return true; if(size() > in.size()) return false; for(u32bit j = 0; j != size(); j++) { if(buf[j] < in[j]) return true; if(buf[j] > in[j]) return false; } return false; } /************************************************* * Swap this buffer with another one * *************************************************/ template void MemoryRegion::swap(MemoryRegion& x) { std::swap(buf, x.buf); std::swap(used, x.used); std::swap(allocated, x.allocated); std::swap(alloc, x.alloc); } /************************************************* * Unlocked Variable Length Buffer * *************************************************/ template class MemoryVector : public MemoryRegion { public: MemoryVector& operator=(const MemoryRegion& in) { if(this != &in) set(in); return (*this); } MemoryVector(u32bit n = 0) { MemoryRegion::init(false, n); } MemoryVector(const T in[], u32bit n) { MemoryRegion::init(false); set(in, n); } MemoryVector(const MemoryRegion& in) { MemoryRegion::init(false); set(in); } MemoryVector(const MemoryRegion& in1, const MemoryRegion& in2) { MemoryRegion::init(false); set(in1); append(in2); } }; /************************************************* * Locked Variable Length Buffer * *************************************************/ template class SecureVector : public MemoryRegion { public: SecureVector& operator=(const MemoryRegion& in) { if(this != &in) set(in); return (*this); } SecureVector(u32bit n = 0) { MemoryRegion::init(true, n); } SecureVector(const T in[], u32bit n) { MemoryRegion::init(true); set(in, n); } SecureVector(const MemoryRegion& in) { MemoryRegion::init(true); set(in); } SecureVector(const MemoryRegion& in1, const MemoryRegion& in2) { MemoryRegion::init(true); set(in1); append(in2); } }; /************************************************* * Locked Fixed Length Buffer * *************************************************/ template class SecureBuffer : public MemoryRegion { public: SecureBuffer& operator=(const SecureBuffer& in) { if(this != &in) set(in); return (*this); } SecureBuffer() { MemoryRegion::init(true, L); } SecureBuffer(const T in[], u32bit n) { MemoryRegion::init(true, L); copy(in, n); } private: SecureBuffer& operator=(const MemoryRegion& in) { if(this != &in) set(in); return (*this); } }; } #endif