Come scrivere una classe sicura per la password?

Question

Questa domanda segue un suggerimento fatto da @sharptooth in this related question.

È possibile modificare il numero std::string in modo da renderlo sicuro per la password?

In caso contrario, quali sarebbero le linee guida per scrivere una classe di gestione delle password (quindi una classe che presta grande attenzione a ciò che scrive in memoria e la cancella prima della distruzione)?

Answer 1

Sì, prima definire un allocatore personalizzato:

template <class T> class SecureAllocator : public std::allocator<T> 
{ 
public: 
    template<class U> struct rebind { typedef SecureAllocator<U> other; }; 

    SecureAllocator() throw() {} 
    SecureAllocator(const SecureAllocator&) throw() {} 
    template <class U> SecureAllocator(const SecureAllocator<U>&) throw() {} 

    void deallocate(pointer p, size_type n) 
    { 
     std::fill_n((volatile char*)p, n*sizeof(T), 0); 
     std::allocator<T>::deallocate(p, n); 
    } 
}; 

Questo allocatore di zeri memoria prima deallocando. Ora è Typedef:

typedef std::basic_string<char, std::char_traits<char>, SecureAllocator<char>> SecureString; 

Tuttavia c'è un piccolo problema, std :: string può utilizzare l'ottimizzazione stringa piccola e memorizzare alcuni dati all'interno di sé, senza l'allocazione dinamica. Quindi si deve esplicitamente chiaro su distruzione o allocare sul mucchio con il nostro allocatore personalizzato:

int main(int, char**) 
{ 
    using boost::shared_ptr; 
    using boost::allocate_shared; 
    shared_ptr<SecureString> str = allocate_shared<SecureString>(SecureAllocator<SecureString>(), "aaa"); 

} 

Questo garantisce che tutti i dati viene azzerato prima della deallocazione, compresa la dimensione della stringa, per esempio.