Is SecureString ever practical in a C# application?
Feel free to correct me if my assumptions are wrong here, but let me explain why I'm asking.
Taken from MSDN, a SecureString :
Represents text that should be kept confidential. The text is encrypted for privacy when being used, and deleted from computer memory when no longer needed.
I get this, it makes complete sense to store a password or other private information in a SecureString over a System.String , because you can control how and when it is actually stored in memory, because a System.String :
is both immutable and, when no longer needed, cannot be programmatically scheduled for garbage collection; that is, the instance is read-only after it is created and it is not possible to predict when the instance will be deleted from computer memory. Consequently, if a String object contains sensitive information such as a password, credit card number, or personal data, there is a risk the information could be revealed after it is used because your application cannot delete the data from computer memory.
However, in the case of a GUI application (for example, an ssh client), the SecureString has to be built from a System.String . All of the text controls use a string as its underlying data type.
So, this means that every time the user presses a key, the old string that was there is discarded, and a new string is built to represent what the value inside the text box is, even if using a password mask. And we can't control when or if any of those values are discarded from memory.
Now it's time to log in to the server. Guess what? You need to pass a string over the connection for authentication. So let's convert our SecureString into a System.String .... and now we have a string on the heap with no way to force it to go through garbage collection (or write 0's to its buffer).
My point is : no matter what you do, somewhere along the line, that SecureString is going to be converted into a System.String , meaning it will at least exist on the heap at some point (without any guarantee of garbage collection).
My point is not : whether there are ways of circumventing sending a string to an ssh connection, or circumventing having a control store a string (make a custom control). For this question, you can replace "ssh connection" with "login form", "registration form", "payment form", "foods-you-would-feed-your-puppy-but-not-your-children form", etc.
SecureString actually become practical? System.String object? SecureString to simply reduce the amount of time a System.String is on the heap (reducing its risk of moving to a physical swap file)? SecureString prevent him from getting to the data anyways? Sorry if I'm laying the questions on too thick, curiosity just got the better of me. Feel free to answer any or all of my questions (or tell me that my assumptions are completely wrong). :)
There are actually very practical uses of SecureString .
Do you know how many times I've seen such scenarios? (the answer is: many!):
RedGate software that could capture the "value" of local variables in case of exceptions, amazingly useful. Though, I can imagine that it will log "string passwords" accidentally. Do you know how to avoid all these problems? SecureString . It generally makes sure you don't make silly mistakes as such. How does it avoid it? By making sure that password is encrypted in unmanaged memory and the real value can be only accessed when you are 90% sure what you're doing.
In the sense, SecureString works pretty easily:
1) Everything is encrypted
2) User calls AppendChar
3) Decrypt everything in UNMANAGED MEMORY and add the character
4) Encrypt everything again in UNMANAGED MEMORY.
What if the user has access to your computer? Would a virus be able to get access to all the SecureStrings ? Yes. All you need to do is hook yourself into RtlEncryptMemory when the memory is being decrypted, you will get the location of the unencrypted memory address, and read it out. Voila! In fact, you could make a virus that will constantly scan for usage of SecureString and log all the activities with it. I am not saying it will be an easy task, but it can be done. As you can see, the "powerfulness" of SecureString is completely gone once there's a user/virus in your system.
You have a few points in your post. Sure, if you use some of the UI controls that hold a "string password" internally, using actual SecureString is not that useful. Though, still, it can protect against some stupidity I've listed above.
Also, as others have noted, WPF supports PasswordBox which uses SecureString internally through its SecurePassword property.
The bottom line is; if you have sensitive data(passwords, credit-cards, ..), use SecureString . This is what C# Framework is following. For example, NetworkCredential class stores password as SecureString . If you look at this, you can see over ~80 different usages in .NET framework of SecureString .
There are many cases when you have to convert SecureString to string, because some API expects it.
The usual problem is either:
You raised good point: what happens when SecureString is converted to string ? This can only happen because of the first point. Eg the API does not know that it's sensitive data. I have personally not seen that happening. Getting string out of SecureString is not that simple.
It's not simple for a simple reason ; it was never intended to let the user convert SecureString to string, as you stated: GC will kick in. If you see yourself doing that, you need to step back and ask yourself: Why am I even doing this, or do I really need this, why?
There's one interesting case I saw. Namely, the WinApi function LogonUser takes LPTSTR as a password, which means you need to call SecureStringToGlobalAllocUnicode . That basically gives you unencrypted password that lives in unmanaged memory. You need to get rid of that as soon as you're done:
// Marshal the SecureString to unmanaged memory.
IntPtr rawPassword = Marshal.SecureStringToGlobalAllocUnicode(password);
try
{
//...snip...
}
finally
{
// Zero-out and free the unmanaged string reference.
Marshal.ZeroFreeGlobalAllocUnicode(rawPassword);
}
You can always extend the SecureString class with an extension method, such as ToEncryptedString(__SERVER__PUBLIC_KEY) , which gives you a string instance of SecureString that is encrypted using server's public key. Only server can then decrypt it. Problem solved: Garbage Collection will never see the "original" string, as you never expose it in managed memory. This is exactly what is being done in PSRemotingCryptoHelper ( EncryptSecureStringCore(SecureString secureString) ).
And as something very almost-related: Mono SecureString does not encrypt at all . The implementation has been commented out because ..wait for it.. "It somehow causes nunit test breakage", which brings to my last point:
SecureString is not supported in everywhere. If the platform/architecture does not support SecureString , you'll get an exception. There's a list of platforms that are supported in the documentation.
The are few issue in your assumptions.
First of all the SecureString class does not have a String constructor. In order to create one you allocate an object and then append the chars.
In the case of a GUI or a console, you can very easily pass each pressed key to a secure string.
The class is designed in a way that you cannot, by mistake, access the value that is stored. This means that you can not obtain the string as a password directly from it.
So for using it, for example, to authenticate through the web, you will have to use proper classes that are also secure.
In the .NET framework you have a few classes that can use SecureString
(more)
To conclude, the SecureString class can be useful, but requires more attention from the developer.
All this, with examples, is well described in MSDN's documentation of SecureString
A SecureString is useful if:
You build it character by character (eg from console input) or obtain it from an unmanaged API
You use it by passing it to an unmanaged API (SecureStringToBSTR).
If you ever convert it to a managed string, you've defeated its purpose.
UPDATE in response to comment
... or BSTR like you mention, which doesn't seem any more secure
After its been converted to a BSTR, the unmanaged component that consumes the BSTR can zero the memory. Unmanaged memory is more secure in the sense that it can be reset in this way.
However, there are very few, APIs in the .NET Framework that support SecureString, so you're right to say that it's of very limited value today.
The main use case I would see is in a client application that requires the user to enter a highly sensitive code or password. The user input could be used character by character to build a SecureString, then this could be passed to an unmanaged API, which zeroes the BSTR it receives after using it. Any subsequent memory dump will not contain the sensitive string.
In a server application it's hard to see where it would be useful.
UPDATE 2
One example of a .NET API that accepts a SecureString is this constructor for the X509Certificate class. If you spelunk with ILSpy or similar, you'll see that the SecureString is internally converted to an unmanaged buffer ( Marshal.SecureStringToGlobalAllocUnicode ), which is then zeroed when finished with ( Marshal.ZeroFreeGlobalAllocUnicode ).
上一篇: 存储信用卡信息与重新输入信息