Чи можу я використовувати спеціальний розподільник для std :: array для захищених криптографічних ключів?

Я знаю std::array, повністю розподілений у стеці, але це питання мотивоване питаннями безпеки, які потребують двох речей:

1. Дані в std::arrayбуде знищені або рандомізовані при знищенні
2. Дані в std::arrayбуде заблоковано , так що вони ніколи не переходять на диск ні при збої, ні в обмін пам'яті

Зазвичай, з std::vector, рішення, це створити спеціальний розподільник, який робить ці речі . Однак, std::arrayя не бачу, як це зробити, і звідси це питання.

Найкраще, що я міг зробити це:

template <typename T, std::size_t Size>
struct SecureArray : public std::array<T, Size>
{
    static_assert(std::is_pod<T>::value, "Only POD types allowed")
    static_assert(sizeof(T) == 1, "Only 1-byte types allowed")
    virtual ~SecureArray()
    {
        std::vector<uint8_t> d = RandomBytes(Size); // generates Size random bytes
        std::memcpy(this->data(), d.data(), Size);
    }
}

Але цього, очевидно, не вистачає блокування пам'яті і ускладнює схему продуктивності, std::arrayяку потрібно отримати, std::arrayв першу чергу, використовуючи.

Чи є краще рішення?

std::arrayне може використовувати розподільник; однак, схоже, ваш клас SecureArray може досягти того, що ви хочете, завдяки спеціальному конструктору / деконструктору.

Щось на зразок цього:

#include <sys/mman.h>

template<class T, std::size_t Size>
struct SecureArray : public std::array<T, Size>
{
    // Your static_asserts...

    SecureArray(void) {
        mlock(std::array<T, Size>::data(), sizeof(T) * Size);
    }

    ~SecureArray(void) {
        char *bytes = reinterpret_cast<char *>(std::array<T, Size>::data());
        for (std::size_t i = 0; i < sizeof(T) * Size; i++)
            bytes[i] = 0;
        munlock(bytes, sizeof(T) * N);
    }
};

Я знаю std::array, повністю виділений у стеку

Це не зовсім так. std::arrayне виділяє жодної пам’яті, тому це залежить від того, куди ви її виділите.

auto* arr = new std::array<int, 100>(); // BUM! it is allocated on the heap

Але цього, очевидно, не вистачає блокування пам'яті і ускладнює схему продуктивності, std::arrayяку потрібно отримати, std::arrayв першу чергу, використовуючи.

По-перше, це не проблема заблокувати пам'ять на стеці. Дивіться приклад POSIX:

#include <iostream>
#include <sys/mman.h>
#include <array>

int main()
{
    std::array<int, 3> a = {1, 2, 3};        // std::array allocated on the stack
    if (mlock(a.data(), sizeof(a)) == 0)
    {
        std::cout << "LOCKED" << std::endl;
    }
}

Отже, ви можете просто зателефонувати mlockабо будь-який портативний аналог в SecureArrayконструктор.

По-друге, який приріст продуктивності ви очікуєте отримати? Швидкість читання / запису пам'яті не залежить від того, де ви виділите масив, на купі чи на стеці. Отже, мова йде про те, як швидко можна виділити та заблокувати пам'ять. Якщо продуктивність критична, блокування пам'яті може бути занадто повільним (чи ні, хто знає?), Щоб викликати це щоразу в SecureArrayконструкторі, навіть якщо пам'ять виділяється на стек.

Отже, зручніше користуватися std::vectorспеціальним алокатором. Це може попередньо виділити та передблокувати великі шматки пам’яті, тому швидкість розподілу буде майже такою ж швидкою, як на стеку.