Botan 2.19.5 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
18 namespace Botan {
19
20 template<typename T>
21 class secure_allocator
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
58 operator==(const secure_allocator<T>&, const secure_allocator<U>&)
59 { return true; }
60
61 template<typename T, typename U> inline bool
62 operator!=(const secure_allocator<T>&, const secure_allocator<U>&)
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>
72std::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>
78std::vector<T, Alloc>&
79 operator+=(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
86 template<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
93 template<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
101 template<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*/
113 template<typename T, typename Alloc>
114 void 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*/
123 template<typename T, typename Alloc>
124 void zap(std::vector<T, Alloc>& vec)
125 {
126 zeroise(vec);
127 vec.clear();
128 vec.shrink_to_fit();
129 }
130
131}
132
133#endif
Botan::secure_allocator
Definition: secmem.h:22
Botan::secure_allocator::allocate
T * allocate(std::size_t n)
Definition: secmem.h:46
Botan::secure_allocator::deallocate
void deallocate(T *p, std::size_t n)
Definition: secmem.h:51
Botan::secure_allocator::value_type
T value_type
Definition: secmem.h:32
Botan::secure_allocator::secure_allocator
secure_allocator() noexcept=default
Botan::secure_allocator::size_type
std::size_t size_type
Definition: secmem.h:36
T
fe T
Definition: ge.cpp:37
Botan
Definition: alg_id.cpp:13
Botan::zeroise
void zeroise(std::vector< T, Alloc > &vec)
Definition: secmem.h:114
Botan::secure_deque
std::deque< T, secure_allocator< T > > secure_deque
Definition: secmem.h:66
Botan::allocate_memory
BOTAN_MALLOC_FN void * allocate_memory(size_t elems, size_t elem_size)
Definition: mem_ops.cpp:18
Botan::zap
void zap(std::vector< T, Alloc > &vec)
Definition: secmem.h:124
Botan::deallocate_memory
void deallocate_memory(void *p, size_t elems, size_t elem_size)
Definition: mem_ops.cpp:34
Botan::operator!=
bool operator!=(const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
Definition: alg_id.cpp:82
Botan::unlock
std::vector< T > unlock(const secure_vector< T > &in)
Definition: secmem.h:72
Botan::operator==
bool operator==(const AlgorithmIdentifier &a1, const AlgorithmIdentifier &a2)
Definition: alg_id.cpp:65
Botan::operator+=
std::vector< T, Alloc > & operator+=(std::vector< T, Alloc > &out, const std::vector< T, Alloc2 > &in)
Definition: secmem.h:79
Botan::secure_vector
std::vector< T, secure_allocator< T > > secure_vector
Definition: secmem.h:65
Botan::clear_mem
void clear_mem(T *ptr, size_t n)
Definition: mem_ops.h:115
Botan::SecureVector
secure_vector< T > SecureVector
Definition: secmem.h:69