Botan 2.19.0
Crypto and TLS for C&
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
18namespace Botan {
19
20template<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
57template<typename T, typename U> inline bool
59 { return true; }
60
61template<typename T, typename U> inline bool
63 { return false; }
64
65template<typename T> using secure_vector = std::vector<T, secure_allocator<T>>;
66template<typename T> using secure_deque = std::deque<T, secure_allocator<T>>;
67
68// For better compatibility with 1.10 API
69template<typename T> using SecureVector = secure_vector<T>;
70
71template<typename T>
72std::vector<T> unlock(const secure_vector<T>& in)
73 {
74 return std::vector<T>(in.begin(), in.end());
75 }
76
77template<typename T, typename Alloc, typename Alloc2>
78std::vector<T, Alloc>&
79operator+=(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
87template<typename T, typename Alloc>
88std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, T in)
89 {
90 out.push_back(in);
91 return out;
92 }
93
94template<typename T, typename Alloc, typename L>
95std::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
103template<typename T, typename Alloc, typename L>
104std::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*/
116template<typename T, typename Alloc>
117void 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*/
126template<typename T, typename Alloc>
127void zap(std::vector<T, Alloc>& vec)
128 {
129 zeroise(vec);
130 vec.clear();
131 vec.shrink_to_fit();
132 }
133
134}
135
136#endif
T * allocate(std::size_t n)
Definition: secmem.h:46
void deallocate(T *p, std::size_t n)
Definition: secmem.h:51
secure_allocator() noexcept=default
std::size_t size_type
Definition: secmem.h:36
fe T
Definition: ge.cpp:37
Definition: alg_id.cpp:13
void zeroise(std::vector< T, Alloc > &vec)
Definition: secmem.h:117
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 zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:127
void deallocate_memory(void *p, size_t elems, size_t elem_size)
Definition: mem_ops.cpp:34
bool operator!=(const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
Definition: alg_id.cpp:82
std::vector< T > unlock(const secure_vector< T > &in)
Definition: secmem.h:72
bool operator==(const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
Definition: alg_id.cpp:65
std::vector< T, Alloc > & operator+=(std::vector< T, Alloc > &out, const std::vector< T, Alloc2 > &in)
Definition: secmem.h:79
std::vector< T, secure_allocator< T > > secure_vector
Definition: secmem.h:65
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115
secure_vector< T > SecureVector
Definition: secmem.h:69