Czy mogę użyć niestandardowego alokatora dla std :: array dla bezpiecznych kluczy kryptograficznych?

Wiem, że std::arrayjest całkowicie przydzielony na stosie, ale to pytanie jest uzasadnione względami bezpieczeństwa, które wymagają dwóch rzeczy:

1. Dane std::arrayzostaną zerowane lub losowo po zniszczeniu
2. Dane std::arrayzostaną zablokowane , tak aby nigdy nie trafiały na dysk ani w przypadku awarii, ani w pamięci wymiany

Zwykle std::vectorrozwiązaniem jest utworzenie niestandardowego programu przydzielającego, który wykonuje te czynności . Jednak std::arraynie widzę, jak to zrobić, i stąd to pytanie.

Najlepsze, co mogłem zrobić, to:

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);
    }
}

Ale to oczywiście nie blokuje pamięci i komplikuje schemat wydajności, std::arrayktóry należy uzyskać, używając std::arrayw pierwszej kolejności.

Czy jest jakieś lepsze rozwiązanie?

std::arraynie może użyć alokatora; Wydaje się jednak, że klasa SecureArray może osiągnąć to, co chcesz, za pomocą niestandardowego konstruktora / dekonstratora.

Coś takiego:

#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);
    }
};

Wiem, że std::arrayjest całkowicie przydzielony na stosie

To nie do końca prawda. std::arraynie przydziela żadnej pamięci, więc zależy to od tego, gdzie ją przydzielisz.

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

Ale to oczywiście nie blokuje pamięci i komplikuje schemat wydajności, std::arrayktóry należy uzyskać, używając std::arrayw pierwszej kolejności.

Po pierwsze, zablokowanie pamięci na stosie nie stanowi problemu. Zobacz przykład 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;
    }
}

Możesz więc po prostu wywołać mlocklub dowolny przenośny analog w SecureArraykonstruktorze.

Po drugie, jakiego wzrostu wydajności oczekujesz? Szybkość odczytu / zapisu pamięci nie zależy od tego, gdzie przydzielisz tablicę, na stercie lub na stosie. Chodzi więc o to, jak szybko można przydzielić i zablokować pamięć. Jeśli wydajność jest krytyczna, blokowanie pamięci może być zbyt wolne (czy nie, kto wie?), Aby wywoływać ją za każdym razem w SecureArraykonstruktorze, nawet jeśli pamięć jest przydzielona na stosie.

Dlatego bardziej przydatne jest użycie std::vectorniestandardowego programu przydzielającego. Może wstępnie alokować i blokować duże porcje pamięci, więc szybkość alokacji będzie prawie tak duża jak na stosie.