Tôi có thể sử dụng một cấp phát tùy chỉnh cho std :: mảng cho các khóa mật mã an toàn không?

Tôi biết std::arrayđược phân bổ hoàn toàn trong ngăn xếp, nhưng câu hỏi này được thúc đẩy bởi các mối quan tâm bảo mật đòi hỏi hai điều:

1. Dữ liệu trong std::arraysẽ là zerod hoặc ngẫu nhiên khi hủy
2. Dữ liệu trong std::arraysẽ bị khóa , sao cho nó không bao giờ vào đĩa mà không gặp sự cố hoặc trên bộ nhớ trao đổi

Thông thường, với std::vector, giải pháp là để tạo ra một cấp phát tùy chỉnh mà làm các điều ấy . Tuy nhiên, đối với std::array, tôi không thấy làm thế nào để làm điều này, và do đó câu hỏi này.

Điều tốt nhất tôi có thể làm là đây:

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

Nhưng điều này rõ ràng là thiếu khóa bộ nhớ và làm phức tạp sơ đồ hiệu suất của std::arrayđiều đó sẽ đạt được bằng cách sử dụng std::arrayở nơi đầu tiên.

Có giải pháp nào tốt hơn không?

std::arraykhông thể sử dụng một bộ cấp phát; tuy nhiên, có vẻ như lớp SecureArray của bạn có thể đạt được những gì bạn muốn thông qua một hàm tạo / giải mã tùy chỉnh.

Một cái gì đó như thế này:

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

Tôi biết std::arraylà hoàn toàn được phân bổ trong ngăn xếp

Điều này hoàn toàn không đúng. std::arraykhông phân bổ bất kỳ bộ nhớ, vì vậy nó phụ thuộc vào nơi bạn phân bổ nó.

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

Nhưng điều này rõ ràng là thiếu khóa bộ nhớ và làm phức tạp sơ đồ hiệu suất của std::arrayđiều đó sẽ đạt được bằng cách sử dụng std::arrayở nơi đầu tiên.

Thứ nhất, nó không phải là một vấn đề để khóa bộ nhớ trên ngăn xếp. Xem ví dụ 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;
    }
}

Vì vậy, bạn chỉ có thể gọi mlockhoặc bất kỳ tương tự di động trong SecureArrayconstructor.

Thứ hai, những gì bạn đạt được hiệu suất đạt được? Tốc độ đọc / ghi bộ nhớ không phụ thuộc vào nơi bạn phân bổ mảng của mình, trên heap hoặc trên ngăn xếp. Vì vậy, tất cả là về tốc độ bạn có thể phân bổ và khóa bộ nhớ. Nếu hiệu suất là quan trọng, khóa bộ nhớ có thể quá chậm (hoặc không, ai biết?) Để gọi nó mỗi lần trong hàm SecureArraytạo ngay cả khi bộ nhớ được cấp phát trên ngăn xếp.

Vì vậy, nó thuận tiện hơn để sử dụng std::vectorvới phân bổ tùy chỉnh. Nó có thể preallocate và prelock bộ nhớ lớn, do đó tốc độ phân bổ sẽ nhanh như trên stack.