विनाश पर स्वत: मेमोरी ओवरराइट करने के लिए टेम्पलेट

Question

आदिम/पीओडी प्रकार मान (https://stackoverflow.com/a/11493744/16673 या http://www.codeproject.com/Articles/825/Using-templates-for-initialization) प्रारंभ करने के लिए कंपाइलर को लागू करने के लिए टेम्पलेट का उपयोग करने के लिए यह एक आम पैटर्न है।

क्या एक समान पैटर्न मौजूद है जिसका उपयोग सुरक्षा कारणों से गुजरने के बाद मूल्य को मिटाने के लिए किया जा सकता है, यह सुनिश्चित करने के लिए कि वैरिएबल नष्ट होने के बाद मूल्य स्टैक पर नहीं छोड़ा गया हो? मुझे डर है कि एक बेवकूफ समान कार्यान्वयन काम नहीं कर सकता है, क्योंकि कंपाइलर किसी भी असाइनमेंट को किसी भी असाइनमेंट को अनदेखा करने के लिए स्वतंत्र है, जो कि दायरे से बाहर जा रहा है, क्योंकि मूल्य को तीन बार उपयोग नहीं किया जा सकता है। क्या कुछ सुसंगत और उचित पोर्टेबल समाधान है अस्थिर का उपयोग कर?

Answer 1

आप कुछ C++ 11 सुविधाओं का उपयोग कर सकता है यह अधिक पोर्टेबल बनाने के लिए, लेकिन यह एक प्रारंभिक बिंदु के रूप पर्याप्त हो सकता है:

कक्षा

template<typename T> 
class t_secure_destruct { 
    static const size_t Size = sizeof(T); 
    static const size_t Align = alignof(T); 
public: 
    t_secure_destruct() : d_memory() { 
    new(this->d_memory)T; 
    } 

    ~t_secure_destruct() { 
    reinterpret_cast<T*>(this->d_memory)->~T(); 
    this->scribble(); 
    } 

    // @todo implement or delete op-assign and remaining constructors 

public: 
    T& get() { 
    return *reinterpret_cast<T*>(this->d_memory); 
    } 

    const T& get() const { 
    return *reinterpret_cast<const T*>(this->d_memory); 
    } 

private: 
    void scribble() { 
    for (size_t idx(0); idx < Size; ++idx) { 
     this->d_memory[idx] = random(); 
    } 
    } 

private: 
    __attribute__((aligned(Align))) char d_memory[Size]; 
}; 

डेमो

#include <iostream> 

class t_test { 
public: 
    t_test() : a(-1) { 
    std::cout << "construct\n"; 
    } 

    ~t_test() { 
    std::cout << "destruct\n"; 
    } 

public: 
    void print() const { 
    std::cout << "a = " << a << "\n"; 
    } 

public: 
    int a; 
}; 

int main(int argc, const char* argv[]) { 
    t_secure_destruct<t_test>test; 
    test.get().print(); 
    test.get().a = 100; 
    test.get().print(); 
    return 0; 
} 

बेशक, यदि आप पक्ष करते हैं तो आप एक ढेर आवंटन के साथ उस आवंटन को भी वापस कर सकते हैं। यदि आपको एक ऑप्टिमाइज़र को आउटमार्ट करने की आवश्यकता है, तो आपको स्क्रिबलर को इसकी पहुंच से बाहर रखने की आवश्यकता हो सकती है।

Answer 2

विंडोज एपीआई में एक फंक्शन है जिसे SecureZeroMemory कहा जाता है। आप इसे कार्यान्वित कर सकते हैं।

हालांकि, आम तौर पर बोलते हुए, कंपाइलर को अस्थिर लेखन का सम्मान करने के लिए मजबूर किया जाता है। यदि आप परिवर्तनीय अस्थिर बनाते हैं, तो यह लिखने को हटाने में सक्षम नहीं होना चाहिए।