Debian Codegraph @

src/mpt/base/secure.hpp

raw
1 /* SPDX-License-Identifier: BSL-1.0 OR BSD-3-Clause */
2
3 #ifndef MPT_BASE_SECURE_HPP
4 #define MPT_BASE_SECURE_HPP
5
6
7
8 #include "mpt/base/integer.hpp"
9 #include "mpt/base/macros.hpp"
10 #include "mpt/base/namespace.hpp"
11
12 #include <atomic>
13 #include <utility>
14 #include <vector>
15
16 #include <cstddef>
17
18
19
20 namespace mpt {
21 inline namespace MPT_INLINE_NS {
22
23
24
25 // C23 memset_explicit
26 inline MPT_NOINLINE void * memset_explicit(void * const dst, int const value, std::size_t const len) noexcept {
27 std::atomic_thread_fence(std::memory_order_seq_cst);
28 volatile unsigned char * volatile p = static_cast<volatile unsigned char *>(dst);
29 std::atomic_thread_fence(std::memory_order_seq_cst);
30 for (volatile std::size_t i = 0; i < len; ++i) {
31 p[i] = static_cast<unsigned char>(value);
32 }
33 std::atomic_thread_fence(std::memory_order_seq_cst);
34 return dst;
35 }
36
37
38
39 namespace secure {
40
41
42
43 inline MPT_NOINLINE void memzero(std::byte * const dst, std::size_t const len) noexcept {
44 std::atomic_thread_fence(std::memory_order_seq_cst);
45 volatile std::byte * volatile p = static_cast<volatile std::byte *>(dst);
46 std::atomic_thread_fence(std::memory_order_seq_cst);
47 for (volatile std::size_t i = 0; i < len; ++i) {
48 p[i] = std::byte{0};
49 }
50 std::atomic_thread_fence(std::memory_order_seq_cst);
51 }
52
53 inline MPT_NOINLINE void memzero(void * const dst, std::size_t const len) noexcept {
54 std::atomic_thread_fence(std::memory_order_seq_cst);
55 volatile std::byte * volatile p = static_cast<volatile std::byte *>(dst);
56 std::atomic_thread_fence(std::memory_order_seq_cst);
57 for (volatile std::size_t i = 0; i < len; ++i) {
58 p[i] = std::byte{0};
59 }
60 std::atomic_thread_fence(std::memory_order_seq_cst);
61 }
62
63 inline MPT_NOINLINE void memzero(char * const dst, std::size_t const len) noexcept {
64 std::atomic_thread_fence(std::memory_order_seq_cst);
65 volatile std::byte * volatile p = reinterpret_cast<volatile std::byte *>(dst);
66 std::atomic_thread_fence(std::memory_order_seq_cst);
67 for (volatile std::size_t i = 0; i < len; ++i) {
68 p[i] = std::byte{0};
69 }
70 std::atomic_thread_fence(std::memory_order_seq_cst);
71 }
72
73 inline MPT_NOINLINE void memzero(uint8 * const dst, std::size_t const len) noexcept {
74 std::atomic_thread_fence(std::memory_order_seq_cst);
75 volatile std::byte * volatile p = reinterpret_cast<volatile std::byte *>(dst);
76 std::atomic_thread_fence(std::memory_order_seq_cst);
77 for (volatile std::size_t i = 0; i < len; ++i) {
78 p[i] = std::byte{0};
79 }
80 std::atomic_thread_fence(std::memory_order_seq_cst);
81 }
82
83
84
85 template <typename T>
86 inline MPT_NOINLINE void clear(T & val) {
87 std::atomic_signal_fence(std::memory_order_seq_cst);
88 volatile T * volatile v = &val;
89 std::atomic_thread_fence(std::memory_order_seq_cst);
90 *v = T{};
91 std::atomic_signal_fence(std::memory_order_seq_cst);
92 }
93
94
95
96 class byte {
97 private:
98 std::byte value;
99
100 public:
101 byte() noexcept
102 : value(std::byte{0}) {
103 return;
104 }
105 explicit byte(std::byte value) noexcept
106 : value(value) {
107 return;
108 }
109 byte(const byte & other) noexcept
110 : value(other.value) {
111 return;
112 }
113 byte(byte && other) noexcept
114 : value(std::move(other.value)) {
115 mpt::secure::clear(other.value);
116 }
117 byte & operator=(const byte & other) noexcept {
118 if (&other == this) {
119 return *this;
120 }
121 value = other.value;
122 return *this;
123 }
124 byte & operator==(byte && other) noexcept {
125 if (&other == this) {
126 return *this;
127 }
128 value = std::move(other.value);
129 mpt::secure::clear(other.value);
130 return *this;
131 }
132 explicit operator std::byte() const noexcept {
133 return value;
134 }
135 ~byte() {
136 mpt::secure::clear(value);
137 }
138 };
139
140
141
142 class buffer {
143 private:
144 std::vector<std::byte> m_data;
145
146 public:
147 buffer()
148 : m_data(0) {
149 return;
150 }
151 explicit buffer(const std::vector<std::byte> & data)
152 : m_data(data) {
153 return;
154 }
155 explicit buffer(const std::byte * beg, const std::byte * end)
156 : m_data(beg, end) {
157 return;
158 }
159 buffer(const buffer & other)
160 : m_data(other.m_data) {
161 return;
162 }
163 buffer(buffer && other) noexcept
164 : m_data(std::move(other.m_data)) {
165 mpt::secure::memzero(other.m_data.data(), other.m_data.size());
166 }
167 buffer & operator=(const buffer & other) {
168 if (&other == this) {
169 return *this;
170 }
171 m_data = other.m_data;
172 return *this;
173 }
174 buffer & operator=(buffer && other) noexcept {
175 if (&other == this) {
176 return *this;
177 }
178 m_data = std::move(other.m_data);
179 mpt::secure::memzero(other.m_data.data(), other.m_data.size());
180 return *this;
181 }
182 ~buffer() {
183 mpt::secure::memzero(m_data.data(), m_data.size());
184 m_data.resize(0);
185 m_data.shrink_to_fit();
186 }
187 explicit operator std::vector<std::byte>() const {
188 return m_data;
189 }
190 const std::byte * data() const {
191 return m_data.data();
192 }
193 std::byte * data() {
194 return m_data.data();
195 }
196 std::size_t size() const {
197 return m_data.size();
198 }
199 };
200
201
202
203 } // namespace secure
204
205
206
207 } // namespace MPT_INLINE_NS
208 } // namespace mpt
209
210
211
212 #endif // MPT_BASE_SECURE_HPP