Güvenli şifreleme anahtarları için std :: array için özel bir ayırıcı kullanabilir miyim?

std::arrayYığında tamamen tahsis edildiğini biliyorum , ancak bu soru iki şey gerektiren güvenlik endişeleri tarafından teşvik ediliyor:

1. İçindeki veriler std::arraysıfır veya imha üzerine rastgele olacak
2. İçindeki veriler kilitlenecek , böylece kilitlenme veya takas belleğinde asla diske std::arraygitmeyecek

Genellikle ile std::vector, çözüm yaratmaktır özel allocator bunları yapar . Ancak, std::arraybunun nasıl yapılacağını ve dolayısıyla bu soruyu göremiyorum.

Yapabileceğim en iyi şey şudur:

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

Ancak bu açıkça bellek kilitlenmesinden yoksundur ve ilk etapta std::arraykullanılmasıyla elde edilecek performans şemasını zorlaştırır std::array.

Daha iyi bir çözüm var mı?

std::arraybir ayırıcı kullanamaz; ancak, SecureArray sınıfınız özel bir kurucu / kod çözücü aracılığıyla istediğinizi başarabiliyor gibi görünüyor.

Bunun gibi bir şey:

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

Ben std::arraytamamen yığın tahsis biliyorum

Bu tam olarak doğru değil. std::arraybellek ayırmaz, bu yüzden nereye ayırdığınıza bağlıdır.

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

Ancak bu açıkça bellek kilitlenmesinden yoksundur ve ilk etapta std::arraykullanılmasıyla elde edilecek performans şemasını zorlaştırır std::array.

İlk olarak, yığındaki belleği kilitlemek bir sorun değildir. POSIX örneğine bakın:

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

Böylece, sadece kurucuda mlockveya herhangi bir taşınabilir analogu çağırabilirsiniz SecureArray.

İkincisi, ne gibi bir performans kazancı bekliyorsunuz? Bellek okuma / yazma hızı, dizinizi nereye ayırdığınıza, yığına veya yığına bağlı değildir. Yani, her şey hafızayı ne kadar hızlı tahsis edip kilitleyebileceğinizle ilgilidir. Performans kritikse, bellek kilitleme yığınta SecureArraybellek ayrılmış olsa bile yapıcıda her seferinde çağıracak kadar yavaş olabilir (ya da bilmez?) .

Bu nedenle, std::vectorözel ayırıcı ile kullanmak daha kullanışlıdır . Büyük bellek yığınlarını önceden konumlandırabilir ve önleyebilir, bu nedenle ayırma hızı neredeyse yığındaki kadar hızlı olacaktır.