Botan  2.18.1
Crypto and TLS for C++11
secmem.h
Go to the documentation of this file.
1 /*
2 * Secure Memory Buffers
3 * (C) 1999-2007,2012 Jack Lloyd
4 *
5 * Botan is released under the Simplified BSD License (see license.txt)
6 */
7 
8 #ifndef BOTAN_SECURE_MEMORY_BUFFERS_H_
9 #define BOTAN_SECURE_MEMORY_BUFFERS_H_
10 
11 #include <botan/types.h> // IWYU pragma: export
12 #include <botan/mem_ops.h> // IWYU pragma: export
13 #include <vector> // IWYU pragma: export
14 #include <algorithm>
15 #include <deque>
16 #include <type_traits>
17 
18 namespace Botan {
19 
20 template<typename T>
22  {
23  public:
24  /*
25  * Assert exists to prevent someone from doing something that will
26  * probably crash anyway (like secure_vector<non_POD_t> where ~non_POD_t
27  * deletes a member pointer which was zeroed before it ran).
28  * MSVC in debug mode uses non-integral proxy types in container types
29  * like std::vector, thus we disable the check there.
30  */
31 #if !defined(_ITERATOR_DEBUG_LEVEL) || _ITERATOR_DEBUG_LEVEL == 0
32  static_assert(std::is_integral<T>::value, "secure_allocator supports only integer types");
33 #endif
34 
35  typedef T value_type;
36  typedef std::size_t size_type;
37 
38  secure_allocator() noexcept = default;
39  secure_allocator(const secure_allocator&) noexcept = default;
40  secure_allocator& operator=(const secure_allocator&) noexcept = default;
41  ~secure_allocator() noexcept = default;
42 
43  template<typename U>
44  secure_allocator(const secure_allocator<U>&) noexcept {}
45 
46  T* allocate(std::size_t n)
47  {
48  return static_cast<T*>(allocate_memory(n, sizeof(T)));
49  }
50 
51  void deallocate(T* p, std::size_t n)
52  {
53  deallocate_memory(p, n, sizeof(T));
54  }
55  };
56 
57 template<typename T, typename U> inline bool
59  { return true; }
60 
61 template<typename T, typename U> inline bool
63  { return false; }
64 
65 template<typename T> using secure_vector = std::vector<T, secure_allocator<T>>;
66 template<typename T> using secure_deque = std::deque<T, secure_allocator<T>>;
67 
68 // For better compatibility with 1.10 API
69 template<typename T> using SecureVector = secure_vector<T>;
70 
71 template<typename T>
72 std::vector<T> unlock(const secure_vector<T>& in)
73  {
74  return std::vector<T>(in.begin(), in.end());
75  }
76 
77 template<typename T, typename Alloc, typename Alloc2>
78 std::vector<T, Alloc>&
79 operator+=(std::vector<T, Alloc>& out,
80  const std::vector<T, Alloc2>& in)
81  {
82  out.reserve(out.size() + in.size());
83  out.insert(out.end(), in.begin(), in.end());
84  return out;
85  }
86 
87 template<typename T, typename Alloc>
88 std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, T in)
89  {
90  out.push_back(in);
91  return out;
92  }
93 
94 template<typename T, typename Alloc, typename L>
95 std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out,
96  const std::pair<const T*, L>& in)
97  {
98  out.reserve(out.size() + in.second);
99  out.insert(out.end(), in.first, in.first + in.second);
100  return out;
101  }
102 
103 template<typename T, typename Alloc, typename L>
104 std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out,
105  const std::pair<T*, L>& in)
106  {
107  out.reserve(out.size() + in.second);
108  out.insert(out.end(), in.first, in.first + in.second);
109  return out;
110  }
111 
112 /**
113 * Zeroise the values; length remains unchanged
114 * @param vec the vector to zeroise
115 */
116 template<typename T, typename Alloc>
117 void zeroise(std::vector<T, Alloc>& vec)
118  {
119  clear_mem(vec.data(), vec.size());
120  }
121 
122 /**
123 * Zeroise the values then free the memory
124 * @param vec the vector to zeroise and free
125 */
126 template<typename T, typename Alloc>
127 void zap(std::vector<T, Alloc>& vec)
128  {
129  zeroise(vec);
130  vec.clear();
131  vec.shrink_to_fit();
132  }
133 
134 }
135 
136 #endif
void deallocate(T *p, std::size_t n)
Definition: secmem.h:51
bool operator!=(const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
Definition: alg_id.cpp:82
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:127
std::deque< T, secure_allocator< T > > secure_deque
Definition: secmem.h:66
BOTAN_MALLOC_FN void * allocate_memory(size_t elems, size_t elem_size)
Definition: mem_ops.cpp:18
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115
T * allocate(std::size_t n)
Definition: secmem.h:46
secure_allocator() noexcept=default
std::size_t size_type
Definition: secmem.h:36
secure_vector< T > SecureVector
Definition: secmem.h:69
void deallocate_memory(void *p, size_t elems, size_t elem_size)
Definition: mem_ops.cpp:34
std::vector< T, Alloc > & operator+=(std::vector< T, Alloc > &out, const std::vector< T, Alloc2 > &in)
Definition: secmem.h:79
Definition: alg_id.cpp:13
std::vector< T > unlock(const secure_vector< T > &in)
Definition: secmem.h:72
fe T
Definition: ge.cpp:37
bool operator==(const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
Definition: alg_id.cpp:65
std::vector< T, secure_allocator< T > > secure_vector
Definition: secmem.h:65
void zeroise(std::vector< T, Alloc > &vec)
Definition: secmem.h:117