ฉันสามารถใช้ตัวจัดสรรที่กำหนดเองสำหรับ std :: array สำหรับคีย์การเข้ารหัสที่ปลอดภัยได้หรือไม่

ฉันรู้ว่าstd::arrayจัดสรรอย่างสมบูรณ์ในสแต็ก แต่คำถามนี้ได้รับแรงบันดาลใจจากความกังวลด้านความปลอดภัยที่ต้องการสองสิ่ง:

1. ข้อมูลในstd::arrayจะถูก zerod หรือสุ่มเมื่อถูกทำลาย
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 ของคุณจะสามารถบรรลุสิ่งที่คุณต้องการผ่าน Constructor / Deconstructor ที่กำหนดเอง

บางสิ่งเช่นนี้

#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กับตัวจัดสรรที่กำหนดเอง มันอาจทำการจัดสรรล่วงหน้าและเตรียมหน่วยความจำขนาดใหญ่ล่วงหน้าดังนั้นความเร็วในการจัดสรรจะใกล้เคียงกับความเร็วในสแต็ก