foster/bitcoin-bitcoin-core
0
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-02-03 09:56:38 -05:00
Code Issues Activity

Don't derive secure_allocator from std::allocator

Browse source 
Affects both secure_allocator and zero_after_free_allocator.

Giving the C++ Standard Committee control of the public interface of your type means they will break it. C++23 adds a new `allocate_at_least` member to `std::allocator`. Very bad things happen when, say, `std::vector` uses `allocate_at_least` from `secure_allocator`'s base to allocate memory which it then tries to free with `secure_allocator::deallocate`.

Drive-by: Aggressively remove facilities unnecessary since C++11 from both allocators to keep things simple.
This commit is contained in:
Casey Carter 2023-06-21 17:14:53 -07:00
parent 6a473373d4
commit 07c59eda00
2 changed files with 40 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/support/allocators/secure.h
View file

@ -17,27 +17,14 @@
// out of memory and clears its contents before deletion.
//
template <typename T>
struct secure_allocator : public std::allocator<T> {
using base = std::allocator<T>;
using traits = std::allocator_traits<base>;
using size_type = typename traits::size_type;
using difference_type = typename traits::difference_type;
using pointer = typename traits::pointer;
using const_pointer = typename traits::const_pointer;
using value_type = typename traits::value_type;
secure_allocator() noexcept {}
secure_allocator(const secure_allocator& a) noexcept : base(a) {}
template <typename U>
secure_allocator(const secure_allocator<U>& a) noexcept : base(a)
{
}
~secure_allocator() noexcept {}
template <typename Other>
struct rebind {
typedef secure_allocator<Other> other;
};
struct secure_allocator {
using value_type = T;
T* allocate(std::size_t n, const void* hint = nullptr)
secure_allocator() = default;
template <typename U>
secure_allocator(const secure_allocator<U>&) noexcept {}
T* allocate(std::size_t n)
{
T* allocation = static_cast<T*>(LockedPoolManager::Instance().alloc(sizeof(T) * n));
if (!allocation) {
@ -53,6 +40,17 @@ struct secure_allocator : public std::allocator<T> {
}
LockedPoolManager::Instance().free(p);
}
template <typename U>
friend bool operator==(const secure_allocator&, const secure_allocator<U>&) noexcept
{
return true;
}
template <typename U>
friend bool operator!=(const secure_allocator&, const secure_allocator<U>&) noexcept
{
return false;
}
};
// This is exactly like std::string, but with a custom allocator.

39
src/support/allocators/zeroafterfree.h
View file

@ -12,31 +12,36 @@
#include <vector>
template <typename T>
struct zero_after_free_allocator : public std::allocator<T> {
using base = std::allocator<T>;
using traits = std::allocator_traits<base>;
using size_type = typename traits::size_type;
using difference_type = typename traits::difference_type;
using pointer = typename traits::pointer;
using const_pointer = typename traits::const_pointer;
using value_type = typename traits::value_type;
zero_after_free_allocator() noexcept {}
zero_after_free_allocator(const zero_after_free_allocator& a) noexcept : base(a) {}
struct zero_after_free_allocator {
using value_type = T;
zero_after_free_allocator() noexcept = default;
template <typename U>
zero_after_free_allocator(const zero_after_free_allocator<U>& a) noexcept : base(a)
zero_after_free_allocator(const zero_after_free_allocator<U>&) noexcept
{
}
~zero_after_free_allocator() noexcept {}
template <typename Other>
struct rebind {
typedef zero_after_free_allocator<Other> other;
};
T* allocate(std::size_t n)
{
return std::allocator<T>{}.allocate(n);
}
void deallocate(T* p, std::size_t n)
{
if (p != nullptr)
memory_cleanse(p, sizeof(T) * n);
std::allocator<T>::deallocate(p, n);
std::allocator<T>{}.deallocate(p, n);
}
template <typename U>
friend bool operator==(const zero_after_free_allocator&, const zero_after_free_allocator<U>&) noexcept
{
return true;
}
template <typename U>
friend bool operator!=(const zero_after_free_allocator&, const zero_after_free_allocator<U>&) noexcept
{
return false;
}
};