blocks|key|3327703|text|见鬼。在发布了这篇文章之后，我在this+article中找到了答案。但是，如果有人知道如何访问此方法公开的非托管、未加密的IntPtr缓冲区，请一次访问一个字节，这样我就不必在其中创建托管字符串对象来保持高安全性，请添加答案。:)|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3327704|static+String+SecureStringToString(SecureString+value)
{
++++IntPtr+bstr+=+Marshal.SecureStringToBSTR(value);

++++try
++++{
++++++++return+Marshal.PtrToStringBSTR(bstr);
++++}
++++finally
++++{
++++++++Marshal.FreeBSTR(bstr);
++++}
}|code-block|syntax|javascript|3327705|entityMap|0|LINK|mutability|MUTABLE|url|http://www.microsoft.com/indonesia/msdn/credmgmt.aspx^0|G|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Dang. right after posting this I found the answer deep in <a href="http://www.microsoft.com/indonesia/msdn/credmgmt.aspx" rel="noreferrer">this article</a>. But if anyone knows how to access the IntPtr unmanaged, unencrypted buffer that this method exposes, one byte at a time so that I don't have to create a managed string object out of it to keep my security high, please add an answer. :)

<pre><code>static String SecureStringToString(SecureString value)
{
 IntPtr bstr = Marshal.SecureStringToBSTR(value);

 try
 {
 return Marshal.PtrToStringBSTR(bstr);
 }
 finally
 {
 Marshal.FreeBSTR(bstr);
 }
}
</code></pre>

blocks|key|342605|text|使用System.Runtime.InteropServices.Marshal类：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|342606|String+SecureStringToString(SecureString+value)+{
++IntPtr+valuePtr+=+IntPtr.Zero;
++try+{
++++valuePtr+=+Marshal.SecureStringToGlobalAllocUnicode(value);
++++return+Marshal.PtrToStringUni(valuePtr);
++}+finally+{
++++Marshal.ZeroFreeGlobalAllocUnicode(valuePtr);
++}
}|code-block|syntax|javascript|342607|如果要避免创建托管字符串对象，可以使用Marshal.ReadInt16(IntPtr,+Int32)访问原始数据|342608|void+HandleSecureString(SecureString+value)+{
++IntPtr+valuePtr+=+IntPtr.Zero;
++try+{
++++valuePtr+=+Marshal.SecureStringToGlobalAllocUnicode(value);
++++for+(int+i=0;+i+<+value.Length;+i%2B%2B)+{
++++++short+unicodeChar+=+Marshal.ReadInt16(valuePtr,+i*2);
++++++//+handle+unicodeChar
++++}
++}+finally+{
++++Marshal.ZeroFreeGlobalAllocUnicode(valuePtr);
++}
}|342609|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.aspx|1|https://msdn.microsoft.com/en-us/library/a0zbzkx2.aspx^0|2|12|2|12|0|0|0|J|W|J|W|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

Use the <a href="http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal.aspx" rel="noreferrer"><code>System.Runtime.InteropServices.Marshal</code></a> class:

<pre><code>String SecureStringToString(SecureString value) {
 IntPtr valuePtr = IntPtr.Zero;
 try {
 valuePtr = Marshal.SecureStringToGlobalAllocUnicode(value);
 return Marshal.PtrToStringUni(valuePtr);
 } finally {
 Marshal.ZeroFreeGlobalAllocUnicode(valuePtr);
 }
}
</code></pre>

If you want to avoid creating a managed string object, you can access the raw data using <a href="https://msdn.microsoft.com/en-us/library/a0zbzkx2.aspx" rel="noreferrer"><code>Marshal.ReadInt16(IntPtr, Int32)</code></a>:

<pre><code>void HandleSecureString(SecureString value) {
 IntPtr valuePtr = IntPtr.Zero;
 try {
 valuePtr = Marshal.SecureStringToGlobalAllocUnicode(value);
 for (int i=0; i &lt; value.Length; i++) {
 short unicodeChar = Marshal.ReadInt16(valuePtr, i*2);
 // handle unicodeChar
 }
 } finally {
 Marshal.ZeroFreeGlobalAllocUnicode(valuePtr);
 }
}
</code></pre>

blocks|key|3114977|text|显然，您知道这与SecureString的全部目的背道而驰，但我还是要重申这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3114978|如果你想要一行程序，试试这个：(仅限.NET+4和更高版本)|3114979|string+password+=+new+System.Net.NetworkCredential(string.Empty,+securePassword).Password;|code-block|syntax|javascript|3114980|其中securePassword是一个SecureString。|3114981|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Obviously you know how this defeats the whole purpose of a SecureString, but I'll restate it anyway.

If you want a one-liner, try this: (.NET 4 and above only)

<pre><code>string password = new System.Net.NetworkCredential(string.Empty, securePassword).Password;
</code></pre>

Where securePassword is a SecureString.

blocks|key|3327772|text|//+using+so+that+Marshal+doesn't+have+to+be+qualified
using+System.Runtime.InteropServices;++++
//using+for+SecureString
using+System.Security;
public+string+DecodeSecureString+(SecureString+Convert)+
{
++++//convert+to+IntPtr+using+Marshal
++++IntPtr+cvttmpst+=+Marshal.SecureStringToBSTR(Convert);
++++//convert+to+string+using+Marshal
++++string+cvtPlainPassword+=+Marshal.PtrToStringAuto(cvttmpst);
++++//return+the+now+plain+string
++++return+cvtPlainPassword;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3327773|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>// using so that Marshal doesn't have to be qualified
using System.Runtime.InteropServices; 
//using for SecureString
using System.Security;
public string DecodeSecureString (SecureString Convert) 
{
 //convert to IntPtr using Marshal
 IntPtr cvttmpst = Marshal.SecureStringToBSTR(Convert);
 //convert to string using Marshal
 string cvtPlainPassword = Marshal.PtrToStringAuto(cvttmpst);
 //return the now plain string
 return cvtPlainPassword;
}
</code></pre>

blocks|key|341258|text|我认为对于SecureString依赖函数来说，最好将它们的依赖逻辑封装在一个匿名函数中，以便更好地控制内存中的解密字符串(一旦锁定)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|341259|在这段代码中解密SecureStrings的实现如下：|341260|341261|将字符串放入内存中(这是您想要做的，但在这里的大多数答案中似乎都没有)。|ordered-list-item|341262|将its+reference从内存中传递给函数/操作，并在finally块中释放GC。|341263|341264|这显然使得“标准化”和维护调用者比依赖不太可取的替代方案容易得多：|341265|341266|从string+DecryptSecureString(...)帮助器function.|unordered-list-item|341267|Duplicating此代码返回解密的字符串。|341268|341269|请注意，这里有两个选项：|341270|341271|static+T+DecryptSecureString<T>，它允许您从调用者访问Func委托的结果(如DecryptSecureStringWithFunc测试method).|341272|static+void+DecryptSecureString中所示)，它只是一个“空”版本，它在您实际上不想/需要返回任何东西的情况下使用Action委托(如DecryptSecureStringWithAction测试方法中所示)。|341273|341274|在包含的StringsTest类中可以找到这两种方法的用法示例。|341275|Strings.cs|BOLD|341276|using+System;
using+System.Runtime.InteropServices;
using+System.Security;

namespace+SecurityUtils
{
++++public+partial+class+Strings
++++{
++++++++///+<summary>
++++++++///+Passes+decrypted+password+String+pinned+in+memory+to+Func+delegate+scrubbed+on+return.
++++++++///+</summary>
++++++++///+<typeparam+name="T">Generic+type+returned+by+Func+delegate</typeparam>
++++++++///+<param+name="action">Func+delegate+which+will+receive+the+decrypted+password+pinned+in+memory+as+a+String+object</param>
++++++++///+<returns>Result+of+Func+delegate</returns>
++++++++public+static+T+DecryptSecureString<T>(SecureString+secureString,+Func<string,+T>+action)
++++++++{
++++++++++++var+insecureStringPointer+=+IntPtr.Zero;
++++++++++++var+insecureString+=+String.Empty;
++++++++++++var+gcHandler+=+GCHandle.Alloc(insecureString,+GCHandleType.Pinned);

++++++++++++try
++++++++++++{
++++++++++++++++insecureStringPointer+=+Marshal.SecureStringToGlobalAllocUnicode(secureString);
++++++++++++++++insecureString+=+Marshal.PtrToStringUni(insecureStringPointer);

++++++++++++++++return+action(insecureString);
++++++++++++}
++++++++++++finally
++++++++++++{
++++++++++++++++//clear+memory+immediately+-+don't+wait+for+garbage+collector
++++++++++++++++fixed(char*+ptr+=+insecureString+)
++++++++++++++++{
++++++++++++++++++++for(int+i+=+0;+i+<+insecureString.Length;+i%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++ptr[i]+=+'\0';
++++++++++++++++++++}
++++++++++++++++}

++++++++++++++++insecureString+=+null;

++++++++++++++++gcHandler.Free();
++++++++++++++++Marshal.ZeroFreeGlobalAllocUnicode(insecureStringPointer);
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Runs+DecryptSecureString+with+support+for+Action+to+leverage+void+return+type
++++++++///+</summary>
++++++++///+<param+name="secureString"></param>
++++++++///+<param+name="action"></param>
++++++++public+static+void+DecryptSecureString(SecureString+secureString,+Action<string>+action)
++++++++{
++++++++++++DecryptSecureString<int>(secureString,+(s)+=>
++++++++++++{
++++++++++++++++action(s);
++++++++++++++++return+0;
++++++++++++});
++++++++}
++++}
}|code-block|syntax|javascript|341277|StringsTest.cs|341278|using+Microsoft.VisualStudio.TestTools.UnitTesting;
using+System.Security;

namespace+SecurityUtils.Test
{
++++[TestClass]
++++public+class+StringsTest
++++{
++++++++[TestMethod]
++++++++public+void+DecryptSecureStringWithFunc()
++++++++{
++++++++++++//+Arrange
++++++++++++var+secureString+=+new+SecureString();

++++++++++++foreach+(var+c+in+"UserPassword123".ToCharArray())
++++++++++++++++secureString.AppendChar(c);

++++++++++++secureString.MakeReadOnly();

++++++++++++//+Act
++++++++++++var+result+=+Strings.DecryptSecureString<bool>(secureString,+(password)+=>
++++++++++++{
++++++++++++++++return+password.Equals("UserPassword123");
++++++++++++});

++++++++++++//+Assert
++++++++++++Assert.IsTrue(result);
++++++++}

++++++++[TestMethod]
++++++++public+void+DecryptSecureStringWithAction()
++++++++{
++++++++++++//+Arrange
++++++++++++var+secureString+=+new+SecureString();

++++++++++++foreach+(var+c+in+"UserPassword123".ToCharArray())
++++++++++++++++secureString.AppendChar(c);

++++++++++++secureString.MakeReadOnly();

++++++++++++//+Act
++++++++++++var+result+=+false;

++++++++++++Strings.DecryptSecureString(secureString,+(password)+=>
++++++++++++{
++++++++++++++++result+=+password.Equals("UserPassword123");
++++++++++++});

++++++++++++//+Assert
++++++++++++Assert.IsTrue(result);
++++++++}
++++}
}|341279|显然，这并不能防止以下面的方式滥用这个函数，所以请注意不要这样做：|341280|[TestMethod]
public+void+DecryptSecureStringWithAction()
{
++++//+Arrange
++++var+secureString+=+new+SecureString();

++++foreach+(var+c+in+"UserPassword123".ToCharArray())
++++++++secureString.AppendChar(c);

++++secureString.MakeReadOnly();

++++//+Act
++++string+copyPassword+=+null;

++++Strings.DecryptSecureString(secureString,+(password)+=>
++++{
++++++++copyPassword+=+password;+//+Please+don't+do+this!
++++});

++++//+Assert
++++Assert.IsNull(copyPassword);+//+Fails
}|341281|祝你编码愉快！|341282|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/10792603/how-are-strings-passed-in-net/10792823#10792823^0|5|C|0|0|0|0|T|7|1|D|0|0|0|0|0|1|V|0|0|0|0|0|0|V|16|4|1H|R|0|0|V|1Y|6|28|T|0|0|4|B|0|0|A|0|0|0|E|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|20|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|21|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|22|8|@]|D|@]|E|$]]|$1|L|3|M|5|K|7|23|8|@$9|24|A|25|B|C]]|D|@$9|26|A|27|1|28]]|E|$]]|$1|N|3|-4|5|6|7|29|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|2A|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|2B|8|@]|D|@]|E|$]]|$1|R|3|S|5|T|7|2C|8|@$9|2D|A|2E|B|C]]|D|@]|E|$]]|$1|U|3|V|5|T|7|2F|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|2G|8|@]|D|@]|E|$]]|$1|X|3|Y|5|6|7|2H|8|@]|D|@]|E|$]]|$1|Z|3|-4|5|6|7|2I|8|@]|D|@]|E|$]]|$1|10|3|11|5|K|7|2J|8|@$9|2K|A|2L|B|C]|$9|2M|A|2N|B|C]|$9|2O|A|2P|B|C]]|D|@]|E|$]]|$1|12|3|13|5|K|7|2Q|8|@$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2X|8|@]|D|@]|E|$]]|$1|15|3|16|5|6|7|2Y|8|@$9|2Z|A|30|B|C]]|D|@]|E|$]]|$1|17|3|18|5|6|7|31|8|@$9|32|A|33|B|19]]|D|@]|E|$]]|$1|1A|3|1B|5|1C|7|34|8|@]|D|@]|E|$1D|1E]]|$1|1F|3|1G|5|6|7|35|8|@$9|36|A|37|B|19]]|D|@]|E|$]]|$1|1H|3|1I|5|1C|7|38|8|@]|D|@]|E|$1D|1E]]|$1|1J|3|1K|5|6|7|39|8|@]|D|@]|E|$]]|$1|1L|3|1M|5|1C|7|3A|8|@]|D|@]|E|$1D|1E]]|$1|1N|3|1O|5|6|7|3B|8|@]|D|@]|E|$]]|$1|1P|3|-4|5|6|7|3C|8|@]|D|@]|E|$]]]|1Q|$1R|$5|1S|1T|1U|E|$1V|1W]]]]

I think it would be best for <code>SecureString</code> dependent functions to encapsulate their dependent logic in an anonymous function for better control over the decrypted string in memory (once pinned).

The implementation for decrypting SecureStrings in this snippet will:

<ol>
<li>Pin the string in memory (which is what you want to do but appears to be missing from most answers here).</li>
<li>Pass <a href="https://stackoverflow.com/questions/10792603/how-are-strings-passed-in-net/10792823#10792823">its reference</a> to the Func/Action delegate.</li>
<li>Scrub it from memory and release the GC in the <code>finally</code> block.</li>
</ol>

This obviously makes it a lot easier to "standardize" and maintain callers vs. relying on less desirable alternatives:

<ul>
<li>Returning the decrypted string from a <code>string DecryptSecureString(...)</code> helper function.</li>
<li>Duplicating this code wherever it is needed.</li>
</ul>

Notice here, you have two options:

<ol>
<li><code>static T DecryptSecureString&lt;T&gt;</code> which allows you to access the result of the <code>Func</code> delegate from the caller (as shown in the <code>DecryptSecureStringWithFunc</code> test method).</li>
<li><code>static void DecryptSecureString</code> is simply a "void" version which employ an <code>Action</code> delegate in cases where you actually don't want/need to return anything (as demonstrated in the <code>DecryptSecureStringWithAction</code> test method).</li>
</ol>

Example usage for both can be found in the <code>StringsTest</code> class included.

Strings.cs

<pre><code>using System;
using System.Runtime.InteropServices;
using System.Security;

namespace SecurityUtils
{
 public partial class Strings
 {
 /// &lt;summary&gt;
 /// Passes decrypted password String pinned in memory to Func delegate scrubbed on return.
 /// &lt;/summary&gt;
 /// &lt;typeparam name="T"&gt;Generic type returned by Func delegate&lt;/typeparam&gt;
 /// &lt;param name="action"&gt;Func delegate which will receive the decrypted password pinned in memory as a String object&lt;/param&gt;
 /// &lt;returns&gt;Result of Func delegate&lt;/returns&gt;
 public static T DecryptSecureString&lt;T&gt;(SecureString secureString, Func&lt;string, T&gt; action)
 {
 var insecureStringPointer = IntPtr.Zero;
 var insecureString = String.Empty;
 var gcHandler = GCHandle.Alloc(insecureString, GCHandleType.Pinned);

 try
 {
 insecureStringPointer = Marshal.SecureStringToGlobalAllocUnicode(secureString);
 insecureString = Marshal.PtrToStringUni(insecureStringPointer);

 return action(insecureString);
 }
 finally
 {
 //clear memory immediately - don't wait for garbage collector
 fixed(char* ptr = insecureString )
 {
 for(int i = 0; i &lt; insecureString.Length; i++)
 {
 ptr[i] = '\0';
 }
 }

 insecureString = null;

 gcHandler.Free();
 Marshal.ZeroFreeGlobalAllocUnicode(insecureStringPointer);
 }
 }

 /// &lt;summary&gt;
 /// Runs DecryptSecureString with support for Action to leverage void return type
 /// &lt;/summary&gt;
 /// &lt;param name="secureString"&gt;&lt;/param&gt;
 /// &lt;param name="action"&gt;&lt;/param&gt;
 public static void DecryptSecureString(SecureString secureString, Action&lt;string&gt; action)
 {
 DecryptSecureString&lt;int&gt;(secureString, (s) =&gt;
 {
 action(s);
 return 0;
 });
 }
 }
}
</code></pre>

StringsTest.cs

<pre><code>using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Security;

namespace SecurityUtils.Test
{
 [TestClass]
 public class StringsTest
 {
 [TestMethod]
 public void DecryptSecureStringWithFunc()
 {
 // Arrange
 var secureString = new SecureString();

 foreach (var c in "UserPassword123".ToCharArray())
 secureString.AppendChar(c);

 secureString.MakeReadOnly();

 // Act
 var result = Strings.DecryptSecureString&lt;bool&gt;(secureString, (password) =&gt;
 {
 return password.Equals("UserPassword123");
 });

 // Assert
 Assert.IsTrue(result);
 }

 [TestMethod]
 public void DecryptSecureStringWithAction()
 {
 // Arrange
 var secureString = new SecureString();

 foreach (var c in "UserPassword123".ToCharArray())
 secureString.AppendChar(c);

 secureString.MakeReadOnly();

 // Act
 var result = false;

 Strings.DecryptSecureString(secureString, (password) =&gt;
 {
 result = password.Equals("UserPassword123");
 });

 // Assert
 Assert.IsTrue(result);
 }
 }
}
</code></pre>

Obviously, this doesn't prevent abuse of this function in the following manner, so just be careful not to do this:

<pre><code>[TestMethod]
public void DecryptSecureStringWithAction()
{
 // Arrange
 var secureString = new SecureString();

 foreach (var c in "UserPassword123".ToCharArray())
 secureString.AppendChar(c);

 secureString.MakeReadOnly();

 // Act
 string copyPassword = null;

 Strings.DecryptSecureString(secureString, (password) =&gt;
 {
 copyPassword = password; // Please don't do this!
 });

 // Assert
 Assert.IsNull(copyPassword); // Fails
}
</code></pre>

Happy coding!

blocks|key|343565|text|如果使用StringBuilder而不是string，则可以在完成时覆盖内存中的实际值。这样，密码就不会在内存中挂起，直到垃圾收集器将其回收。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|343566|StringBuilder.Append(plainTextPassword);
StringBuilder.Clear();
//+overwrite+with+reasonably+random+characters
StringBuilder.Append(New+Guid().ToString());|code-block|syntax|javascript|343567|entityMap^0|4|D|K|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

If you use a <code>StringBuilder</code> instead of a <code>string</code>, you can overwrite the actual value in memory when you are done. That way the password won't hang around in memory until garbage collection picks it up.

<pre><code>StringBuilder.Append(plainTextPassword);
StringBuilder.Clear();
// overwrite with reasonably random characters
StringBuilder.Append(New Guid().ToString());
</code></pre>

blocks|key|3327856|text|在我看来，扩展方法是解决这个问题的最好方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3327857|我将Steve+in+CO's+excellent+answer放入一个扩展类中，如下所示，再加上我添加的第二个方法，以支持另一个方向(string+->+secure+string)，这样您就可以创建一个安全字符串，然后将其转换为普通字符串：|3327858|public+static+class+Extensions
{
++++//+convert+a+secure+string+into+a+normal+plain+text+string
++++public+static+String+ToPlainString(this+System.Security.SecureString+secureStr)
++++{
++++++++String+plainStr=new+System.Net.NetworkCredential(string.Empty,+secureStr).Password;
++++++++return+plainStr;
++++}

++++//+convert+a+plain+text+string+into+a+secure+string
++++public+static+System.Security.SecureString+ToSecureString(this+String+plainStr)
++++{
++++++++var+secStr+=+new+System.Security.SecureString();+secStr.Clear();
++++++++foreach+(char+c+in+plainStr.ToCharArray())
++++++++{
++++++++++++secStr.AppendChar(c);
++++++++}
++++++++return+secStr;
++++}
}|code-block|syntax|javascript|3327859|这样，您现在就可以像这样简单地在中来回转换字符串：|3327860|//+create+a+secure+string
System.Security.SecureString+securePassword+=+"MyCleverPwd123".ToSecureString();+
//+convert+it+back+to+plain+text
String+plainPassword+=+securePassword.ToPlainString();++//+convert+back+to+normal+string|3327861|但请记住，解码方法应该仅用于测试。|3327862|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/3885063/steve-in-co|1|https://stackoverflow.com/a/25751722/1016343^0|5|4|0|2|D|0|G|G|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@$9|16|A|17|1|18]|$9|19|A|1A|1|1B]]|E|$]]|$1|H|3|I|5|J|7|1C|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1F|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|Z]]|10|$5|V|W|X|E|$Y|11]]]]

In my opinion, extension methods are the most comfortable way to solve this. 

I took <a href="https://stackoverflow.com/users/3885063/steve-in-co">Steve in CO's</a> <a href="https://stackoverflow.com/a/25751722/1016343">excellent answer</a> and put it into an extension class as follows, together with a second method I added to support the other direction (string -> secure string) as well, so you can create a secure string and convert it into a normal string afterwards:

<pre><code>public static class Extensions
{
 // convert a secure string into a normal plain text string
 public static String ToPlainString(this System.Security.SecureString secureStr)
 {
 String plainStr=new System.Net.NetworkCredential(string.Empty, secureStr).Password;
 return plainStr;
 }

 // convert a plain text string into a secure string
 public static System.Security.SecureString ToSecureString(this String plainStr)
 {
 var secStr = new System.Security.SecureString(); secStr.Clear();
 foreach (char c in plainStr.ToCharArray())
 {
 secStr.AppendChar(c);
 }
 return secStr;
 }
}
</code></pre>

With this, you can now simply convert your strings back and forth like so:

<pre><code>// create a secure string
System.Security.SecureString securePassword = "MyCleverPwd123".ToSecureString(); 
// convert it back to plain text
String plainPassword = securePassword.ToPlainString(); // convert back to normal string
</code></pre>

But keep in mind the decoding method should only be used for testing.

blocks|key|342711|text|我创建了以下基于answer+from+rdev5的扩展方法。固定托管字符串很重要，因为它可以防止垃圾回收器移动它并留下您无法擦除的副本。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|342712|我认为我的解决方案的优点是不需要不安全的代码。|342713|///+<summary>
///+Allows+a+decrypted+secure+string+to+be+used+whilst+minimising+the+exposure+of+the
///+unencrypted+string.
///+</summary>
///+<typeparam+name="T">Generic+type+returned+by+Func+delegate.</typeparam>
///+<param+name="secureString">The+string+to+decrypt.</param>
///+<param+name="action">
///+Func+delegate+which+will+receive+the+decrypted+password+as+a+string+object
///+</param>
///+<returns>Result+of+Func+delegate</returns>
///+<remarks>
///+This+method+creates+an+empty+managed+string+and+pins+it+so+that+the+garbage+collector
///+cannot+move+it+around+and+create+copies.+An+unmanaged+copy+of+the+the+secure+string+is
///+then+created+and+copied+into+the+managed+string.+The+action+is+then+called+using+the
///+managed+string.+Both+the+managed+and+unmanaged+strings+are+then+zeroed+to+erase+their
///+contents.+The+managed+string+is+unpinned+so+that+the+garbage+collector+can+resume+normal
///+behaviour+and+the+unmanaged+string+is+freed.
///+</remarks>
public+static+T+UseDecryptedSecureString<T>(this+SecureString+secureString,+Func<string,+T>+action)
{
++++int+length+=+secureString.Length;
++++IntPtr+sourceStringPointer+=+IntPtr.Zero;

++++//+Create+an+empty+string+of+the+correct+size+and+pin+it+so+that+the+GC+can't+move+it+around.
++++string+insecureString+=+new+string('\0',+length);
++++var+insecureStringHandler+=+GCHandle.Alloc(insecureString,+GCHandleType.Pinned);

++++IntPtr+insecureStringPointer+=+insecureStringHandler.AddrOfPinnedObject();

++++try
++++{
++++++++//+Create+an+unmanaged+copy+of+the+secure+string.
++++++++sourceStringPointer+=+Marshal.SecureStringToBSTR(secureString);

++++++++//+Use+the+pointers+to+copy+from+the+unmanaged+to+managed+string.
++++++++for+(int+i+=+0;+i+<+secureString.Length;+i%2B%2B)
++++++++{
++++++++++++short+unicodeChar+=+Marshal.ReadInt16(sourceStringPointer,+i+*+2);
++++++++++++Marshal.WriteInt16(insecureStringPointer,+i+*+2,+unicodeChar);
++++++++}

++++++++return+action(insecureString);
++++}
++++finally
++++{
++++++++//+Zero+the+managed+string+so+that+the+string+is+erased.+Then+unpin+it+to+allow+the
++++++++//+GC+to+take+over.
++++++++Marshal.Copy(new+byte[length],+0,+insecureStringPointer,+length);
++++++++insecureStringHandler.Free();

++++++++//+Zero+and+free+the+unmanaged+string.
++++++++Marshal.ZeroFreeBSTR(sourceStringPointer);
++++}
}

///+<summary>
///+Allows+a+decrypted+secure+string+to+be+used+whilst+minimising+the+exposure+of+the
///+unencrypted+string.
///+</summary>
///+<param+name="secureString">The+string+to+decrypt.</param>
///+<param+name="action">
///+Func+delegate+which+will+receive+the+decrypted+password+as+a+string+object
///+</param>
///+<returns>Result+of+Func+delegate</returns>
///+<remarks>
///+This+method+creates+an+empty+managed+string+and+pins+it+so+that+the+garbage+collector
///+cannot+move+it+around+and+create+copies.+An+unmanaged+copy+of+the+the+secure+string+is
///+then+created+and+copied+into+the+managed+string.+The+action+is+then+called+using+the
///+managed+string.+Both+the+managed+and+unmanaged+strings+are+then+zeroed+to+erase+their
///+contents.+The+managed+string+is+unpinned+so+that+the+garbage+collector+can+resume+normal
///+behaviour+and+the+unmanaged+string+is+freed.
///+</remarks>
public+static+void+UseDecryptedSecureString(this+SecureString+secureString,+Action<string>+action)
{
++++UseDecryptedSecureString(secureString,+(s)+=>
++++{
++++++++action(s);
++++++++return+0;
++++});
}|code-block|syntax|javascript|342714|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/33679932/1326370^0|8|H|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

I created the following extension methods based on the <a href="https://stackoverflow.com/a/33679932/1326370">answer from rdev5</a>. Pinning the managed string is important as it prevents the garbage collector from moving it around and leaving behind copies that you're unable to erase.

I think the advantage of my solution has is that no unsafe code is needed.

<pre><code>/// &lt;summary&gt;
/// Allows a decrypted secure string to be used whilst minimising the exposure of the
/// unencrypted string.
/// &lt;/summary&gt;
/// &lt;typeparam name="T"&gt;Generic type returned by Func delegate.&lt;/typeparam&gt;
/// &lt;param name="secureString"&gt;The string to decrypt.&lt;/param&gt;
/// &lt;param name="action"&gt;
/// Func delegate which will receive the decrypted password as a string object
/// &lt;/param&gt;
/// &lt;returns&gt;Result of Func delegate&lt;/returns&gt;
/// &lt;remarks&gt;
/// This method creates an empty managed string and pins it so that the garbage collector
/// cannot move it around and create copies. An unmanaged copy of the the secure string is
/// then created and copied into the managed string. The action is then called using the
/// managed string. Both the managed and unmanaged strings are then zeroed to erase their
/// contents. The managed string is unpinned so that the garbage collector can resume normal
/// behaviour and the unmanaged string is freed.
/// &lt;/remarks&gt;
public static T UseDecryptedSecureString&lt;T&gt;(this SecureString secureString, Func&lt;string, T&gt; action)
{
 int length = secureString.Length;
 IntPtr sourceStringPointer = IntPtr.Zero;

 // Create an empty string of the correct size and pin it so that the GC can't move it around.
 string insecureString = new string('\0', length);
 var insecureStringHandler = GCHandle.Alloc(insecureString, GCHandleType.Pinned);

 IntPtr insecureStringPointer = insecureStringHandler.AddrOfPinnedObject();

 try
 {
 // Create an unmanaged copy of the secure string.
 sourceStringPointer = Marshal.SecureStringToBSTR(secureString);

 // Use the pointers to copy from the unmanaged to managed string.
 for (int i = 0; i &lt; secureString.Length; i++)
 {
 short unicodeChar = Marshal.ReadInt16(sourceStringPointer, i * 2);
 Marshal.WriteInt16(insecureStringPointer, i * 2, unicodeChar);
 }

 return action(insecureString);
 }
 finally
 {
 // Zero the managed string so that the string is erased. Then unpin it to allow the
 // GC to take over.
 Marshal.Copy(new byte[length], 0, insecureStringPointer, length);
 insecureStringHandler.Free();

 // Zero and free the unmanaged string.
 Marshal.ZeroFreeBSTR(sourceStringPointer);
 }
}

/// &lt;summary&gt;
/// Allows a decrypted secure string to be used whilst minimising the exposure of the
/// unencrypted string.
/// &lt;/summary&gt;
/// &lt;param name="secureString"&gt;The string to decrypt.&lt;/param&gt;
/// &lt;param name="action"&gt;
/// Func delegate which will receive the decrypted password as a string object
/// &lt;/param&gt;
/// &lt;returns&gt;Result of Func delegate&lt;/returns&gt;
/// &lt;remarks&gt;
/// This method creates an empty managed string and pins it so that the garbage collector
/// cannot move it around and create copies. An unmanaged copy of the the secure string is
/// then created and copied into the managed string. The action is then called using the
/// managed string. Both the managed and unmanaged strings are then zeroed to erase their
/// contents. The managed string is unpinned so that the garbage collector can resume normal
/// behaviour and the unmanaged string is freed.
/// &lt;/remarks&gt;
public static void UseDecryptedSecureString(this SecureString secureString, Action&lt;string&gt; action)
{
 UseDecryptedSecureString(secureString, (s) =&gt;
 {
 action(s);
 return 0;
 });
}
</code></pre>

blocks|key|342716|text|这段C#代码就是您想要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342717|%25ProjectPath%25/SecureStringsEasy.cs|offset|length|style|CODE|342718|using+System;
using+System.Security;
using+System.Runtime.InteropServices;
namespace+SecureStringsEasy
{
++++public+static+class+MyExtensions
++++{
++++++++public+static+SecureString+ToSecureString(string+input)
++++++++{
++++++++++++SecureString+secureString+=+new+SecureString();
++++++++++++foreach+(var+item+in+input)
++++++++++++{
++++++++++++++++secureString.AppendChar(item);
++++++++++++}
++++++++++++return+secureString;
++++++++}
++++++++public+static+string+ToNormalString(SecureString+input)
++++++++{
++++++++++++IntPtr+strptr+=+Marshal.SecureStringToBSTR(input);
++++++++++++string+normal+=+Marshal.PtrToStringBSTR(strptr);
++++++++++++Marshal.ZeroFreeBSTR(strptr);
++++++++++++return+normal;
++++++++}
++++}
}|code-block|syntax|javascript|342719|entityMap^0|0|0|Y|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This C# code is what you want.

<code>%ProjectPath%/SecureStringsEasy.cs</code>

<pre><code>using System;
using System.Security;
using System.Runtime.InteropServices;
namespace SecureStringsEasy
{
 public static class MyExtensions
 {
 public static SecureString ToSecureString(string input)
 {
 SecureString secureString = new SecureString();
 foreach (var item in input)
 {
 secureString.AppendChar(item);
 }
 return secureString;
 }
 public static string ToNormalString(SecureString input)
 {
 IntPtr strptr = Marshal.SecureStringToBSTR(input);
 string normal = Marshal.PtrToStringBSTR(strptr);
 Marshal.ZeroFreeBSTR(strptr);
 return normal;
 }
 }
}
</code></pre>

blocks|key|3115185|text|我从This+answer+by+sclarke81派生而来。我喜欢他的答案，并且我使用的是派生函数，但是sclarke81有一个bug。我没有名气，所以我不能评论。这个问题看起来很小，它不需要另一个答案，我可以编辑它。所以我就这么做了。它被拒绝了。所以现在我们有了另一个答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3115186|sclarke81我希望你能看到这个(在最后)：|3115187|Marshal.Copy(new+byte[length],+0,+insecureStringPointer,+length);|code-block|syntax|javascript|3115188|应该是：|3115189|Marshal.Copy(new+byte[length+*+2],+0,+insecureStringPointer,+length+*+2);|3115190|以及错误修复的完整答案：|3115191|++++///+
++++///+Allows+a+decrypted+secure+string+to+be+used+whilst+minimising+the+exposure+of+the
++++///+unencrypted+string.
++++///+
++++///+Generic+type+returned+by+Func+delegate.
++++///+The+string+to+decrypt.
++++///+
++++///+Func+delegate+which+will+receive+the+decrypted+password+as+a+string+object
++++///+
++++///+Result+of+Func+delegate
++++///+
++++///+This+method+creates+an+empty+managed+string+and+pins+it+so+that+the+garbage+collector
++++///+cannot+move+it+around+and+create+copies.+An+unmanaged+copy+of+the+the+secure+string+is
++++///+then+created+and+copied+into+the+managed+string.+The+action+is+then+called+using+the
++++///+managed+string.+Both+the+managed+and+unmanaged+strings+are+then+zeroed+to+erase+their
++++///+contents.+The+managed+string+is+unpinned+so+that+the+garbage+collector+can+resume+normal
++++///+behaviour+and+the+unmanaged+string+is+freed.
++++///+
++++public+static+T+UseDecryptedSecureString(this+SecureString+secureString,+Func+action)
++++{
++++++++int+length+=+secureString.Length;
++++++++IntPtr+sourceStringPointer+=+IntPtr.Zero;

++++++++//+Create+an+empty+string+of+the+correct+size+and+pin+it+so+that+the+GC+can't+move+it+around.
++++++++string+insecureString+=+new+string('\0',+length);
++++++++var+insecureStringHandler+=+GCHandle.Alloc(insecureString,+GCHandleType.Pinned);

++++++++IntPtr+insecureStringPointer+=+insecureStringHandler.AddrOfPinnedObject();

++++++++try
++++++++{
++++++++++++//+Create+an+unmanaged+copy+of+the+secure+string.
++++++++++++sourceStringPointer+=+Marshal.SecureStringToBSTR(secureString);

++++++++++++//+Use+the+pointers+to+copy+from+the+unmanaged+to+managed+string.
++++++++++++for+(int+i+=+0;+i+<+secureString.Length;+i%2B%2B)
++++++++++++{
++++++++++++++++short+unicodeChar+=+Marshal.ReadInt16(sourceStringPointer,+i+*+2);
++++++++++++++++Marshal.WriteInt16(insecureStringPointer,+i+*+2,+unicodeChar);
++++++++++++}

++++++++++++return+action(insecureString);
++++++++}
++++++++finally
++++++++{
++++++++++++//+Zero+the+managed+string+so+that+the+string+is+erased.+Then+unpin+it+to+allow+the
++++++++++++//+GC+to+take+over.
++++++++++++Marshal.Copy(new+byte[length+*+2],+0,+insecureStringPointer,+length+*+2);
++++++++++++insecureStringHandler.Free();

++++++++++++//+Zero+and+free+the+unmanaged+string.
++++++++++++Marshal.ZeroFreeBSTR(sourceStringPointer);
++++++++}
++++}

++++///+
++++///+Allows+a+decrypted+secure+string+to+be+used+whilst+minimising+the+exposure+of+the
++++///+unencrypted+string.
++++///+
++++///+The+string+to+decrypt.
++++///+
++++///+Func+delegate+which+will+receive+the+decrypted+password+as+a+string+object
++++///+
++++///+Result+of+Func+delegate
++++///+
++++///+This+method+creates+an+empty+managed+string+and+pins+it+so+that+the+garbage+collector
++++///+cannot+move+it+around+and+create+copies.+An+unmanaged+copy+of+the+the+secure+string+is
++++///+then+created+and+copied+into+the+managed+string.+The+action+is+then+called+using+the
++++///+managed+string.+Both+the+managed+and+unmanaged+strings+are+then+zeroed+to+erase+their
++++///+contents.+The+managed+string+is+unpinned+so+that+the+garbage+collector+can+resume+normal
++++///+behaviour+and+the+unmanaged+string+is+freed.
++++///+
++++public+static+void+UseDecryptedSecureString(this+SecureString+secureString,+Action+action)
++++{
++++++++UseDecryptedSecureString(secureString,+(s)+=>
++++++++{
++++++++++++action(s);
++++++++++++return+0;
++++++++});
++++}
}|3115192|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/54422529/12264345^0|2|O|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

I derived from <a href="https://stackoverflow.com/a/54422529/12264345">This answer by sclarke81</a>. I like his answer and I'm using the derivative but sclarke81's has a bug. I don't have reputation so I can't comment. The problem seems small enough that it didn't warrant another answer and I could edit it. So I did. It got rejected. So now we have another answer.

sclarke81 I hope you see this (in finally):

<pre><code>Marshal.Copy(new byte[length], 0, insecureStringPointer, length);
</code></pre>

should be:

<pre><code>Marshal.Copy(new byte[length * 2], 0, insecureStringPointer, length * 2);
</code></pre>

And the full answer with the bug fix:

<pre><code>
 /// 
 /// Allows a decrypted secure string to be used whilst minimising the exposure of the
 /// unencrypted string.
 /// 
 /// Generic type returned by Func delegate.
 /// The string to decrypt.
 /// 
 /// Func delegate which will receive the decrypted password as a string object
 /// 
 /// Result of Func delegate
 /// 
 /// This method creates an empty managed string and pins it so that the garbage collector
 /// cannot move it around and create copies. An unmanaged copy of the the secure string is
 /// then created and copied into the managed string. The action is then called using the
 /// managed string. Both the managed and unmanaged strings are then zeroed to erase their
 /// contents. The managed string is unpinned so that the garbage collector can resume normal
 /// behaviour and the unmanaged string is freed.
 /// 
 public static T UseDecryptedSecureString(this SecureString secureString, Func action)
 {
 int length = secureString.Length;
 IntPtr sourceStringPointer = IntPtr.Zero;

 // Create an empty string of the correct size and pin it so that the GC can't move it around.
 string insecureString = new string('\0', length);
 var insecureStringHandler = GCHandle.Alloc(insecureString, GCHandleType.Pinned);

 IntPtr insecureStringPointer = insecureStringHandler.AddrOfPinnedObject();

 try
 {
 // Create an unmanaged copy of the secure string.
 sourceStringPointer = Marshal.SecureStringToBSTR(secureString);

 // Use the pointers to copy from the unmanaged to managed string.
 for (int i = 0; i &lt; secureString.Length; i++)
 {
 short unicodeChar = Marshal.ReadInt16(sourceStringPointer, i * 2);
 Marshal.WriteInt16(insecureStringPointer, i * 2, unicodeChar);
 }

 return action(insecureString);
 }
 finally
 {
 // Zero the managed string so that the string is erased. Then unpin it to allow the
 // GC to take over.
 Marshal.Copy(new byte[length * 2], 0, insecureStringPointer, length * 2);
 insecureStringHandler.Free();

 // Zero and free the unmanaged string.
 Marshal.ZeroFreeBSTR(sourceStringPointer);
 }
 }

 /// 
 /// Allows a decrypted secure string to be used whilst minimising the exposure of the
 /// unencrypted string.
 /// 
 /// The string to decrypt.
 /// 
 /// Func delegate which will receive the decrypted password as a string object
 /// 
 /// Result of Func delegate
 /// 
 /// This method creates an empty managed string and pins it so that the garbage collector
 /// cannot move it around and create copies. An unmanaged copy of the the secure string is
 /// then created and copied into the managed string. The action is then called using the
 /// managed string. Both the managed and unmanaged strings are then zeroed to erase their
 /// contents. The managed string is unpinned so that the garbage collector can resume normal
 /// behaviour and the unmanaged string is freed.
 /// 
 public static void UseDecryptedSecureString(this SecureString secureString, Action action)
 {
 UseDecryptedSecureString(secureString, (s) =>
 {
 action(s);
 return 0;
 });
 }
}
</code></pre>

blocks|key|3327947|text|根据sclarke81解决方案和John+Flaherty修复的最终工作解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3327948|++++public+static+class+Utils
++++{
++++++++///+<remarks>
++++++++///+This+method+creates+an+empty+managed+string+and+pins+it+so+that+the+garbage+collector
++++++++///+cannot+move+it+around+and+create+copies.+An+unmanaged+copy+of+the+the+secure+string+is
++++++++///+then+created+and+copied+into+the+managed+string.+The+action+is+then+called+using+the
++++++++///+managed+string.+Both+the+managed+and+unmanaged+strings+are+then+zeroed+to+erase+their
++++++++///+contents.+The+managed+string+is+unpinned+so+that+the+garbage+collector+can+resume+normal
++++++++///+behaviour+and+the+unmanaged+string+is+freed.
++++++++///+</remarks>
++++++++public+static+T+UseDecryptedSecureString<T>(this+SecureString+secureString,+Func<string,+T>+action)
++++++++{
++++++++++++int+length+=+secureString.Length;
++++++++++++IntPtr+sourceStringPointer+=+IntPtr.Zero;

++++++++++++//+Create+an+empty+string+of+the+correct+size+and+pin+it+so+that+the+GC+can't+move+it+around.
++++++++++++string+insecureString+=+new+string('\0',+length);
++++++++++++var+insecureStringHandler+=+GCHandle.Alloc(insecureString,+GCHandleType.Pinned);

++++++++++++IntPtr+insecureStringPointer+=+insecureStringHandler.AddrOfPinnedObject();

++++++++++++try
++++++++++++{
++++++++++++++++//+Create+an+unmanaged+copy+of+the+secure+string.
++++++++++++++++sourceStringPointer+=+Marshal.SecureStringToBSTR(secureString);

++++++++++++++++//+Use+the+pointers+to+copy+from+the+unmanaged+to+managed+string.
++++++++++++++++for+(int+i+=+0;+i+<+secureString.Length;+i%2B%2B)
++++++++++++++++{
++++++++++++++++++++short+unicodeChar+=+Marshal.ReadInt16(sourceStringPointer,+i+*+2);
++++++++++++++++++++Marshal.WriteInt16(insecureStringPointer,+i+*+2,+unicodeChar);
++++++++++++++++}

++++++++++++++++return+action(insecureString);
++++++++++++}
++++++++++++finally
++++++++++++{
++++++++++++++++//+Zero+the+managed+string+so+that+the+string+is+erased.+Then+unpin+it+to+allow+the
++++++++++++++++//+GC+to+take+over.
++++++++++++++++Marshal.Copy(new+byte[length+*+2],+0,+insecureStringPointer,+length+*+2);
++++++++++++++++insecureStringHandler.Free();

++++++++++++++++//+Zero+and+free+the+unmanaged+string.
++++++++++++++++Marshal.ZeroFreeBSTR(sourceStringPointer);
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Allows+a+decrypted+secure+string+to+be+used+whilst+minimising+the+exposure+of+the
++++++++///+unencrypted+string.
++++++++///+</summary>
++++++++///+<param+name="secureString">The+string+to+decrypt.</param>
++++++++///+<param+name="action">
++++++++///+Func+delegate+which+will+receive+the+decrypted+password+as+a+string+object
++++++++///+</param>
++++++++///+<returns>Result+of+Func+delegate</returns>
++++++++///+<remarks>
++++++++///+This+method+creates+an+empty+managed+string+and+pins+it+so+that+the+garbage+collector
++++++++///+cannot+move+it+around+and+create+copies.+An+unmanaged+copy+of+the+the+secure+string+is
++++++++///+then+created+and+copied+into+the+managed+string.+The+action+is+then+called+using+the
++++++++///+managed+string.+Both+the+managed+and+unmanaged+strings+are+then+zeroed+to+erase+their
++++++++///+contents.+The+managed+string+is+unpinned+so+that+the+garbage+collector+can+resume+normal
++++++++///+behaviour+and+the+unmanaged+string+is+freed.
++++++++///+</remarks>
++++++++public+static+void+UseDecryptedSecureString(this+SecureString+secureString,+Action<string>+action)
++++++++{
++++++++++++UseDecryptedSecureString(secureString,+(s)+=>
++++++++++++{
++++++++++++++++action(s);
++++++++++++++++return+0;
++++++++++++});
++++++++}
++++}|code-block|syntax|javascript|3327949|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Final working solution according to sclarke81 solution and John Flaherty fixes is:

<pre><code> public static class Utils
 {
 /// &lt;remarks&gt;
 /// This method creates an empty managed string and pins it so that the garbage collector
 /// cannot move it around and create copies. An unmanaged copy of the the secure string is
 /// then created and copied into the managed string. The action is then called using the
 /// managed string. Both the managed and unmanaged strings are then zeroed to erase their
 /// contents. The managed string is unpinned so that the garbage collector can resume normal
 /// behaviour and the unmanaged string is freed.
 /// &lt;/remarks&gt;
 public static T UseDecryptedSecureString&lt;T&gt;(this SecureString secureString, Func&lt;string, T&gt; action)
 {
 int length = secureString.Length;
 IntPtr sourceStringPointer = IntPtr.Zero;

 // Create an empty string of the correct size and pin it so that the GC can't move it around.
 string insecureString = new string('\0', length);
 var insecureStringHandler = GCHandle.Alloc(insecureString, GCHandleType.Pinned);

 IntPtr insecureStringPointer = insecureStringHandler.AddrOfPinnedObject();

 try
 {
 // Create an unmanaged copy of the secure string.
 sourceStringPointer = Marshal.SecureStringToBSTR(secureString);

 // Use the pointers to copy from the unmanaged to managed string.
 for (int i = 0; i &lt; secureString.Length; i++)
 {
 short unicodeChar = Marshal.ReadInt16(sourceStringPointer, i * 2);
 Marshal.WriteInt16(insecureStringPointer, i * 2, unicodeChar);
 }

 return action(insecureString);
 }
 finally
 {
 // Zero the managed string so that the string is erased. Then unpin it to allow the
 // GC to take over.
 Marshal.Copy(new byte[length * 2], 0, insecureStringPointer, length * 2);
 insecureStringHandler.Free();

 // Zero and free the unmanaged string.
 Marshal.ZeroFreeBSTR(sourceStringPointer);
 }
 }

 /// &lt;summary&gt;
 /// Allows a decrypted secure string to be used whilst minimising the exposure of the
 /// unencrypted string.
 /// &lt;/summary&gt;
 /// &lt;param name="secureString"&gt;The string to decrypt.&lt;/param&gt;
 /// &lt;param name="action"&gt;
 /// Func delegate which will receive the decrypted password as a string object
 /// &lt;/param&gt;
 /// &lt;returns&gt;Result of Func delegate&lt;/returns&gt;
 /// &lt;remarks&gt;
 /// This method creates an empty managed string and pins it so that the garbage collector
 /// cannot move it around and create copies. An unmanaged copy of the the secure string is
 /// then created and copied into the managed string. The action is then called using the
 /// managed string. Both the managed and unmanaged strings are then zeroed to erase their
 /// contents. The managed string is unpinned so that the garbage collector can resume normal
 /// behaviour and the unmanaged string is freed.
 /// &lt;/remarks&gt;
 public static void UseDecryptedSecureString(this SecureString secureString, Action&lt;string&gt; action)
 {
 UseDecryptedSecureString(secureString, (s) =&gt;
 {
 action(s);
 return 0;
 });
 }
 }
</code></pre>

blocks|key|343645|text|被接受为答案的代码是正确的，并且在大多数情况下都可以工作，但正如评论中提到的那样，使用BSTR会更好，并且将涵盖所有情况：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|343646|private+string+SecureStringToString(SecureString+value)+{
++++IntPtr+valuePtr+=+IntPtr.Zero;
++++try+{
++++++++valuePtr+=+Marshal.SecureStringToBSTR(value);
++++++++return+Marshal.PtrToStringBSTR(valuePtr);
++++}+finally+{
++++++++Marshal.ZeroFreeBSTR(valuePtr);
++++}
}|code-block|syntax|javascript|343647|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The code accepted as the answer is correct, and will work in most circumstances, but as mentioned in the comments using BSTR would be better and will cover all circumstances:
<pre><code>private string SecureStringToString(SecureString value) {
 IntPtr valuePtr = IntPtr.Zero;
 try {
 valuePtr = Marshal.SecureStringToBSTR(value);
 return Marshal.PtrToStringBSTR(valuePtr);
 } finally {
 Marshal.ZeroFreeBSTR(valuePtr);
 }
}
</code></pre>

blocks|key|342757|text|使用以下内容：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|342758|var+plaintextPwd+=+new+System.Net.NetworkCredential("",+<securestring+with+your+encrypted+password>).Password|code-block|syntax|javascript|342759|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use the following:
<pre><code>var plaintextPwd = new System.Net.NetworkCredential(&quot;&quot;, &lt;securestring with your encrypted password&gt;).Password
</code></pre>

All reservations about unsecuring your SecureString by creating a System.String out of it aside, how can it be done?

How can I convert an ordinary System.Security.SecureString to System.String?

I'm sure many of you who are familiar with SecureString are going to respond that one should never transform a SecureString to an ordinary .NET string because it removes all security protections. I know. But right now my program does everything with ordinary strings anyway, and I'm trying to enhance its security and although I'm going to be using an API that returns a SecureString to me I am not trying to use that to increase my security. 

I'm aware of Marshal.SecureStringToBSTR, but I don't know how to take that BSTR and make a System.String out of it.

For those who may demand to know why I would ever want to do this, well, I'm taking a password from a user and submitting it as an html form POST to log the user into a web site. So... this really has to be done with managed, unencrypted buffers. If I could even get access to the unmanaged, unencrypted buffer I imagine I could do byte-by-byte stream writing on the network stream and hope that that keeps the password secure the whole way. I'm hoping for an answer to at least one of these scenarios.

How to convert SecureString to System.String?

除了之外，所有关于通过创建一个System.String来解除你的SecureString安全的保留意见，该怎么做呢？如何将普通System.Security.SecureString转换为System.String？我相信你们中许多熟悉SecureString的人都会回应说，永远不应该将SecureString转换为...

问如何将SecureString转换为System.String？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将SecureString转换为System.String？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何将SecureString转换为System.String？
EN