Botan 2.19.2
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.insert(out.end(), in.begin(), in.end());
83 return out;
84 }
85
86template<typename T, typename Alloc>
87std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out, T in)
88 {
89 out.push_back(in);
90 return out;
91 }
92
93template<typename T, typename Alloc, typename L>
94std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out,
95 const std::pair<const T*, L>& in)
96 {
97 out.insert(out.end(), in.first, in.first + in.second);
98 return out;
99 }
100
101template<typename T, typename Alloc, typename L>
102std::vector<T, Alloc>& operator+=(std::vector<T, Alloc>& out,
103 const std::pair<T*, L>& in)
104 {
105 out.insert(out.end(), in.first, in.first + in.second);
106 return out;
107 }
108
109/**
110* Zeroise the values; length remains unchanged
111* @param vec the vector to zeroise
112*/
113template<typename T, typename Alloc>
114void zeroise(std::vector<T, Alloc>& vec)
115 {
116 clear_mem(vec.data(), vec.size());
117 }
118
119/**
120* Zeroise the values then free the memory
121* @param vec the vector to zeroise and free
122*/
123template<typename T, typename Alloc>
124void zap(std::vector<T, Alloc>& vec)
125 {
126 zeroise(vec);
127 vec.clear();
128 vec.shrink_to_fit();
129 }
130
131}
132
133#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:114
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:124
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