8#ifndef BOTAN_MEMORY_OPS_H_
9#define BOTAN_MEMORY_OPS_H_
11#include <botan/assert.h>
12#include <botan/concepts.h>
13#include <botan/types.h>
30#if !defined(BOTAN_IS_BEING_BUILT)
31 #include <botan/allocator.h>
64#if !defined(BOTAN_IS_BEGIN_BUILT)
108 std::memset(ptr, 0, bytes);
134template <ranges::contiguous_output_range R>
136 requires std::is_trivially_copyable_v<std::ranges::range_value_t<R>>
148 requires std::is_trivial<typename std::decay<T>::type>::value
149inline constexpr void copy_mem(T* out,
const T* in,
size_t n) {
152 if(in !=
nullptr && out !=
nullptr && n > 0) {
153 std::memmove(out, in,
sizeof(T) * n);
162template <ranges::contiguous_output_range OutR, ranges::contiguous_range InR>
163 requires std::is_same_v<std::ranges::range_value_t<OutR>, std::ranges::range_value_t<InR>> &&
164 std::is_trivially_copyable_v<std::ranges::range_value_t<InR>>
165inline constexpr void copy_mem(OutR&& out, InR&& in) {
167 if(std::is_constant_evaluated()) {
168 std::copy(std::ranges::begin(in), std::ranges::end(in), std::ranges::begin(out));
178template <ranges::contiguous_output_range ToR, ranges::contiguous_range FromR>
179 requires std::is_trivially_copyable_v<std::ranges::range_value_t<FromR>> &&
180 std::is_trivially_copyable_v<std::ranges::range_value_t<ToR>>
190template <
typename ToT, ranges::contiguous_range FromR>
191 requires std::is_trivially_copyable_v<std::ranges::range_value_t<FromR>> && std::is_trivially_copyable_v<ToT> &&
192 (!std::ranges::range<ToT>)
201template <ranges::contiguous_output_range ToR,
typename FromT>
202 requires std::is_trivially_copyable_v<FromT> &&
203 (!std::ranges::range<FromT>) && std::is_trivially_copyable_v<std::ranges::range_value_t<ToR>>
212template <
typename ToT, ranges::contiguous_range FromR>
213 requires std::is_default_constructible_v<ToT> && std::is_trivially_copyable_v<ToT> &&
214 std::is_trivially_copyable_v<std::ranges::range_value_t<FromR>>
224 requires std::is_trivially_copyable<T>::value
227 typecast_copy(std::span<uint8_t>(out,
sizeof(T) * N), std::span<const T>(in, N));
233 requires std::is_trivial<T>::value
236 typecast_copy(std::span<T>(out, N), std::span<const uint8_t>(in, N *
sizeof(T)));
243 typecast_copy(std::span<uint8_t,
sizeof(T)>(out,
sizeof(T)), in);
248 requires std::is_trivial<typename std::decay<T>::type>::value
251 typecast_copy(out, std::span<
const uint8_t,
sizeof(T)>(in,
sizeof(T)));
255template <
typename To>
256 requires std::is_trivial<To>::value
262#if !defined(BOTAN_IS_BEGIN_BUILT)
271 std::memset(ptr, val, n);
277 return reinterpret_cast<const uint8_t*
>(s);
281 return reinterpret_cast<const char*
>(b);
285 return reinterpret_cast<uint8_t*
>(s);
289 return reinterpret_cast<char*
>(b);
292#if !defined(BOTAN_IS_BEING_BUILT)
302inline
bool same_mem(const T* p1, const T* p2,
size_t n) {
303 volatile T difference = 0;
305 for(
size_t i = 0; i != n; ++i) {
306 difference = difference | (p1[i] ^ p2[i]);
309 return difference == 0;
313#if !defined(BOTAN_IS_BEING_BUILT)
315template <
typename T,
typename Alloc>
317size_t
buffer_insert(std::vector<T, Alloc>& buf,
size_t buf_offset, const T input[],
size_t input_length) {
319 const size_t to_copy = std::min(input_length, buf.size() - buf_offset);
321 copy_mem(&buf[buf_offset], input, to_copy);
326template <
typename T,
typename Alloc,
typename Alloc2>
328size_t
buffer_insert(std::vector<T, Alloc>& buf,
size_t buf_offset, const std::vector<T, Alloc2>& input) {
330 const size_t to_copy = std::min(input.size(), buf.size() - buf_offset);
332 copy_mem(&buf[buf_offset], input.data(), to_copy);
348 std::span<uint8_t> o(out);
349 std::span<const uint8_t> i(in);
351 for(; o.size_bytes() >= 32; o = o.subspan(32), i = i.subspan(32)) {
363 for(
size_t off = 0; off != o.size_bytes(); ++off) {
383 for(; o.size_bytes() >= 32; o = o.subspan(32), i1 = i1.subspan(32), i2 = i2.subspan(32)) {
395 for(
size_t off = 0; off != o.size_bytes(); ++off) {
396 o[off] = i1[off] ^ i2[off];
406inline void xor_buf(uint8_t out[],
const uint8_t in[],
size_t length) {
408 xor_buf(std::span{out, length}, std::span{in, length});
418inline void xor_buf(uint8_t out[],
const uint8_t in[],
const uint8_t in2[],
size_t length) {
420 xor_buf(std::span{out, length}, std::span{in, length}, std::span{in2, length});
424inline void xor_buf(std::span<uint8_t> out, std::span<const uint8_t> in,
size_t n) {
427 xor_buf(out.first(n), in.first(n));
431template <
typename Alloc>
432void xor_buf(std::vector<uint8_t, Alloc>& out,
const uint8_t* in,
size_t n) {
435 xor_buf(std::span{out}.first(n), std::span{in, n});
439template <
typename Alloc,
typename Alloc2>
440void xor_buf(std::vector<uint8_t, Alloc>& out,
const uint8_t* in,
const std::vector<uint8_t, Alloc2>& in2,
size_t n) {
444 xor_buf(std::span{out}.first(n), std::span{in, n}, std::span{in2}.first(n));
447template <
typename Alloc,
typename Alloc2>
448std::vector<uint8_t, Alloc>&
operator^=(std::vector<uint8_t, Alloc>& out,
const std::vector<uint8_t, Alloc2>& in) {
449 if(out.size() < in.size()) {
450 out.resize(in.size());
453 xor_buf(std::span{out}.first(in.size()), in);
#define BOTAN_PUBLIC_API(maj, min)
#define BOTAN_FUTURE_INTERNAL_HEADER(hdr)
#define BOTAN_DEPRECATED(msg)
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ASSERT_IMPLICATION(expr1, expr2, msg)
#define BOTAN_ARG_CHECK(expr, msg)
constexpr size_t size_bytes(spanable_range auto &&r)
constexpr void assert_equal_byte_lengths(R0 &&r0, Rs &&... rs)
size_t buffer_insert(std::vector< T, Alloc > &buf, size_t buf_offset, const T input[], size_t input_length)
constexpr void typecast_copy(ToR &&out, FromR &&in)
constexpr void set_mem(uint8_t *ptr, size_t n, uint8_t val)
constexpr void clear_bytes(void *ptr, size_t bytes)
void secure_scrub_memory(void *ptr, size_t n)
uint8_t ct_compare_u8(const uint8_t x[], const uint8_t y[], size_t len)
std::vector< uint8_t, Alloc > & operator^=(std::vector< uint8_t, Alloc > &out, const std::vector< uint8_t, Alloc2 > &in)
constexpr void xor_buf(ranges::contiguous_output_range< uint8_t > auto &&out, ranges::contiguous_range< uint8_t > auto &&in)
bool same_mem(const T *p1, const T *p2, size_t n)
const char * cast_uint8_ptr_to_char(const uint8_t *b)
bool constant_time_compare(std::span< const uint8_t > x, std::span< const uint8_t > y)
constexpr void copy_mem(T *out, const T *in, size_t n)
constexpr void clear_mem(T *ptr, size_t n)
const uint8_t * cast_char_ptr_to_uint8(const char *s)