secure_string.h

 
#pragma once
 
#include <system/object.h>
#include <system/idisposable.h>
#include <system/string.h>
#include <system/details/spin_lock.h>
#include <mutex>
#include <memory>
 
namespace System { namespace Runtime { namespace InteropServices { class Marshal; }}}
 
namespace System { namespace Security {
 
class SecureString;
typedef SharedPtr<SecureString> SecureStringPtr;
 
class ASPOSECPP_SHARED_CLASS SecureString final : public IDisposable
{
    RTTI_INFO(System::Security::SecureString, ::System::BaseTypesInfo<System::Object>)
 
public:
    ASPOSECPP_SHARED_API SecureString();
 
    ASPOSECPP_SHARED_API SecureString(const char16_t* value, int32_t length);
 
    ASPOSECPP_SHARED_API ~SecureString();
 
    SecureString(const SecureString&) = delete;
    SecureString& operator=(const SecureString&) = delete;
 
    ASPOSECPP_SHARED_API int32_t get_Length() const;
 
    ASPOSECPP_SHARED_API void AppendChar(char16_t c);
 
    ASPOSECPP_SHARED_API void Clear();
 
    ASPOSECPP_SHARED_API SecureStringPtr Copy() const;
 
    ASPOSECPP_SHARED_API void InsertAt(int32_t index, char16_t c);
 
    ASPOSECPP_SHARED_API bool IsReadOnly() const;
 
    ASPOSECPP_SHARED_API void MakeReadOnly();
 
    ASPOSECPP_SHARED_API void RemoveAt(int32_t index);
 
    ASPOSECPP_SHARED_API void SetAt(int32_t index, char16_t c);
 
    ASPOSECPP_SHARED_API void Dispose() override;
 
    ASPOSECPP_SHARED_API String ToUnsecureString() const;
 
private:
    struct Impl;
    std::unique_ptr<Impl> m_impl;
 
    using Lockable = Details::SpinLock;
    using LockGuard = std::lock_guard<Lockable>;
 
    mutable Lockable m_lockable;
 
    void VerifyWriteable() const;
    void VerifyNotDisposed() const;
    void VerifyEnoughSpace() const;
 
    friend class System::Runtime::InteropServices::Marshal;
 
    IntPtr MarshalToString(bool global_alloc, bool unicode);
};
 
}} // namespace System::Security