secure_memory_allocator.hpp

// Copyright Take Vos 2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../security/security.hpp"
#include "../macros.hpp"
#include <type_traits>
#include <cstddef>
#include <memory>
 
hi_export_module(hikogui.memory.secure_memory_allocator);
 
hi_export namespace hi::inline v1 {
 
template<typename T>
class secure_memory_allocator {
public:
    using value_type = T;
    using size_type = std::size_t;
    using difference_type = ptrdiff_t;
 
    template<typename U>
    struct rebind {
        using other = secure_memory_allocator<U>;
    };
    struct rebind {…};
 
    constexpr secure_memory_allocator() noexcept {};
 
    constexpr secure_memory_allocator(secure_memory_allocator const &other) noexcept {}
 
    template<typename U>
    constexpr secure_memory_allocator(secure_memory_allocator<U> const &other) noexcept
    {
    }
 
    [[nodiscard]] value_type *allocate(size_type n) const noexcept
    {
        auto allocator = std::allocator<std::byte>{};
        auto *p = std::allocator_traits<decltype(allocator)>::allocate(allocator, n * sizeof (value_type));
        return reinterpret_cast<value_type *>(p);
    }
 
    void deallocate(value_type *p, size_type n) const noexcept
    {
        secure_clear(p, n * sizeof (value_type));
 
        auto allocator = std::allocator<std::byte>{};
        std::allocator_traits<decltype(allocator)>::deallocate(allocator, reinterpret_cast<std::byte *>(p),  n * sizeof (value_type));
    }
};
class secure_memory_allocator {…};
 
} // namespace hi::inline v1