8#ifndef BOTAN_MEMORY_OPS_H_
9#define BOTAN_MEMORY_OPS_H_
11#include <botan/concepts.h>
12#include <botan/types.h>
27#if !defined(BOTAN_IS_BEING_BUILT)
28 #include <botan/allocator.h>
61#if !defined(BOTAN_IS_BEGIN_BUILT)
105 std::memset(ptr, 0, bytes);
131template <ranges::contiguous_output_range R>
133 requires std::is_trivially_copyable_v<std::ranges::range_value_t<R>>
145 requires std::is_trivial<typename std::decay<T>::type>::value
146inline constexpr void copy_mem(
T* out,
const T* in,
size_t n) {
149 if(in !=
nullptr && out !=
nullptr && n > 0) {
150 std::memmove(out, in,
sizeof(
T) * n);
159template <ranges::contiguous_output_range OutR, ranges::contiguous_range InR>
160 requires std::is_same_v<std::ranges::range_value_t<OutR>, std::ranges::range_value_t<InR>> &&
161 std::is_trivially_copyable_v<std::ranges::range_value_t<InR>>
162inline constexpr void copy_mem(OutR&& out, InR&& in) {
164 if(std::is_constant_evaluated()) {
165 std::copy(std::ranges::begin(in), std::ranges::end(in), std::ranges::begin(out));
175template <ranges::contiguous_output_range ToR, ranges::contiguous_range FromR>
176 requires std::is_trivially_copyable_v<std::ranges::range_value_t<FromR>> &&
177 std::is_trivially_copyable_v<std::ranges::range_value_t<ToR>>
187template <
typename ToT, ranges::contiguous_range FromR>
188 requires std::is_trivially_copyable_v<std::ranges::range_value_t<FromR>> && std::is_trivially_copyable_v<ToT> &&
189 (!std::ranges::range<ToT>)
198template <ranges::contiguous_output_range ToR,
typename FromT>
199 requires std::is_trivially_copyable_v<FromT> &&
200 (!std::ranges::range<FromT>) && std::is_trivially_copyable_v<std::ranges::range_value_t<ToR>>
209template <
typename ToT, ranges::contiguous_range FromR>
210 requires std::is_default_constructible_v<ToT> && std::is_trivially_copyable_v<ToT> &&
211 std::is_trivially_copyable_v<std::ranges::range_value_t<FromR>>
221 requires std::is_trivially_copyable<T>::value
224 typecast_copy(std::span<uint8_t>(out,
sizeof(
T) * N), std::span<const T>(in, N));
230 requires std::is_trivial<T>::value
233 typecast_copy(std::span<T>(out, N), std::span<const uint8_t>(in, N *
sizeof(
T)));
245 requires std::is_trivial<typename std::decay<T>::type>::value
248 typecast_copy(out, std::span<
const uint8_t,
sizeof(
T)>(in,
sizeof(
T)));
252template <
typename To>
253 requires std::is_trivial<To>::value
256 return typecast_copy<To>(std::span<
const uint8_t,
sizeof(To)>(src,
sizeof(To)));
259#if !defined(BOTAN_IS_BEGIN_BUILT)
268inline constexpr
void set_mem(uint8_t* ptr,
size_t n, uint8_t val) {
270 std::memset(ptr, val, n);
276 return reinterpret_cast<const uint8_t*
>(s);
280 return reinterpret_cast<const char*
>(b);
284 return reinterpret_cast<uint8_t*
>(s);
288 return reinterpret_cast<char*
>(b);
291#if !defined(BOTAN_IS_BEING_BUILT)
302 volatile T difference = 0;
304 for(
size_t i = 0; i != n; ++i) {
305 difference = difference | (p1[i] ^ p2[i]);
308 return difference == 0;
312#if !defined(BOTAN_IS_BEING_BUILT)
314template <
typename T,
typename Alloc>
316size_t
buffer_insert(std::vector<
T, Alloc>& buf,
size_t buf_offset, const
T input[],
size_t input_length) {
318 const size_t to_copy = std::min(input_length, buf.size() - buf_offset);
320 copy_mem(&buf[buf_offset], input, to_copy);
325template <
typename T,
typename Alloc,
typename Alloc2>
327size_t
buffer_insert(std::vector<
T, Alloc>& buf,
size_t buf_offset, const std::vector<
T, Alloc2>& input) {
329 const size_t to_copy = std::min(input.size(), buf.size() - buf_offset);
331 copy_mem(&buf[buf_offset], input.data(), to_copy);
350 for(; o.size_bytes() >= 32; o = o.subspan(32), i = i.subspan(32)) {
351 auto x = typecast_copy<std::array<uint64_t, 4>>(o.template first<32>());
352 const auto y = typecast_copy<std::array<uint64_t, 4>>(i.template first<32>());
362 for(
size_t off = 0; off != o.size_bytes(); ++off) {
382 for(; o.size_bytes() >= 32; o = o.subspan(32), i1 = i1.subspan(32), i2 = i2.subspan(32)) {
383 auto x = typecast_copy<std::array<uint64_t, 4>>(i1.template first<32>());
384 const auto y = typecast_copy<std::array<uint64_t, 4>>(i2.template first<32>());
394 for(
size_t off = 0; off != o.size_bytes(); ++off) {
395 o[off] = i1[off] ^ i2[off];
405inline void xor_buf(uint8_t out[],
const uint8_t in[],
size_t length) {
407 xor_buf(std::span{out, length}, std::span{in, length});
417inline void xor_buf(uint8_t out[],
const uint8_t in[],
const uint8_t in2[],
size_t length) {
419 xor_buf(std::span{out, length}, std::span{in, length}, std::span{in2, length});
423inline void xor_buf(std::span<uint8_t> out, std::span<const uint8_t> in,
size_t n) {
426 xor_buf(out.first(n), in.first(n));
430template <
typename Alloc>
431void xor_buf(std::vector<uint8_t, Alloc>& out,
const uint8_t* in,
size_t n) {
434 xor_buf(std::span{out}.first(n), std::span{in, n});
438template <
typename Alloc,
typename Alloc2>
439void xor_buf(std::vector<uint8_t, Alloc>& out,
const uint8_t* in,
const std::vector<uint8_t, Alloc2>& in2,
size_t n) {
443 xor_buf(std::span{out}.first(n), std::span{in, n}, std::span{in2}.first(n));
446template <
typename Alloc,
typename Alloc2>
447std::vector<uint8_t, Alloc>&
operator^=(std::vector<uint8_t, Alloc>& out,
const std::vector<uint8_t, Alloc2>& in) {
448 if(out.size() < in.size()) {
449 out.resize(in.size());
452 xor_buf(std::span{out}.first(in.size()), in);
#define BOTAN_ASSERT_NOMSG(expr)
#define BOTAN_ASSERT_IMPLICATION(expr1, expr2, msg)
#define BOTAN_ARG_CHECK(expr, msg)
#define BOTAN_PUBLIC_API(maj, min)
#define BOTAN_DEPRECATED(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)