Question

如何将String转换为SecureString？

Answer 1

你没有。使用SecureString对象的全部原因是为了避免创建一个字符串对象（它被加载到内存中并以明文形式保存在垃圾收集之前）。但是，您可以通过附加它们来为SecureString添加字符。

var s = new SecureString();
s.AppendChar('d');
s.AppendChar('u');
s.AppendChar('m');
s.AppendChar('b');
s.AppendChar('p');
s.AppendChar('a');
s.AppendChar('s');
s.AppendChar('s');
s.AppendChar('w');
s.AppendChar('d');

Answer 2

还有另一种在SecureString和String之间进行转换的方法。

<强> 1。字符串到SecureString

SecureString theSecureString = new NetworkCredential("", "myPass").SecurePassword;

<强> 2。 SecureString to String

string theString = new NetworkCredential("", theSecureString).Password;

以下是link

Answer 3

下面的方法有助于将字符串转换为安全字符串

private SecureString ConvertToSecureString(string password)
{
    if (password == null)
        throw new ArgumentNullException("password");

    var securePassword = new SecureString();

    foreach (char c in password)
        securePassword.AppendChar(c);

    securePassword.MakeReadOnly();
    return securePassword;
}

Answer 4

你可以这样说：

string password = "test";
SecureString sec_pass = new SecureString();
Array.ForEach(password.ToArray(), sec_pass.AppendChar);
sec_pass.MakeReadOnly();

Answer 5

我会把它扔出去。为什么呢？

您不能只是将所有字符串更改为安全字符串，而且您的应用程序突然变得“安全”。安全字符串旨在尽可能长时间地保持字符串加密，并且只在很短的时间内解密，在对其执行操作后擦除内存。

我担心在担心保护应用程序字符串之前，您可能会遇到一些设计级问题需要处理。向我们提供有关您尝试做什么的更多信息，我们可以提供更好的帮助。

Answer 6

unsafe 
{
    fixed(char* psz = password)
        return new SecureString(psz, password.Length);
}

Answer 7

这是一个便宜的linq技巧。

            SecureString sec = new SecureString();
            string pwd = "abc123"; /* Not Secure! */
            pwd.ToCharArray().ToList().ForEach(c => sec.AppendChar(c));
            /* and now : seal the deal */
            sec.MakeReadOnly();

Answer 8

我同意Spence（+1），但是如果你是为了学习或测试pourposes，你可以在字符串中使用foreach，使用AppendChar方法将每个char附加到securestring。

Answer 9

没有花哨的linq，不是手工添加所有字符，只是简单明了：

var str = "foo";
var sc = new SecureString();
foreach(char c in str) sc.appendChar(c);

Answer 10

如果您想将string转换为SecureString转换为LINQ语句，可以按以下方式表达：

var plain  = "The quick brown fox jumps over the lazy dog";
var secure = plain
             .ToCharArray()
             .Aggregate( new SecureString()
                       , (s, c) => { s.AppendChar(c); return s; }
                       , (s)    => { s.MakeReadOnly(); return s; }
                       );

但是，请记住，使用LINQ并不能提高此解决方案的安全性。它存在与从string到SecureString的任何转换相同的缺陷。只要原始string保留在内存中，数据就容易受到攻击。

话虽如此，上述声明可以提供的是SecureString的创建，它与数据的初始化，最后将其从修改中锁定。

Answer 11

以下2个扩展应该可以解决问题：

对于char数组

public static SecureString ToSecureString(this char[] _self)
{
    SecureString knox = new SecureString();
    foreach (char c in _self)
    {
        knox.AppendChar(c);
    }
    return knox;
}

适用于string

public static SecureString ToSecureString(this string _self)
{
    SecureString knox = new SecureString();
    char[] chars = _self.ToCharArray();
    foreach (char c in chars)
    {
        knox.AppendChar(c);
    }
    return knox;
}

感谢John Dagg推荐AppendChar。

Answer 12

我只想指出所有人都说，＆＃34;这不是SecureString＆＃34;的问题，很多人提出这个问题可能是在应用程序，无论出于何种原因，无论是否合理，他们不特别关注将密码的临时副本作为GC-able字符串放在堆上，但是他们必须使用API 仅接受SecureString个对象。所以，你有一个应用程序，你不在乎密码是否在堆上，也许它只是内部使用而密码只在那里，因为它是＆＃39;基础网络协议所需的，并且您发现存储密码的字符串不能用于例如设置一个远程PowerShell Runspace - 但是没有简单，直接的单行程来创建你需要的SecureString。这是一个小小的不便 - 但可能值得确保真正需要{{1>}的应用程序不会诱使作者使用SecureString或System.String个中间人。： - ）

Answer 13

你可以使用这个简单的脚本

private SecureString SecureStringConverter(string pass)
{
    SecureString ret = new SecureString();

    foreach (char chr in pass.ToCharArray())
        ret.AppendChar(chr);

    return ret;
}

Answer 14

为了完整起见，我添加了两个单元测试和方法来将字符数组和字符串转换为 SecureString，然后再转换回来。您应该尝试完全避免使用字符串，并且只传递指向 char 数组的指针或 char 数组本身，就像我在此处提供的方法一样，因为字符串是不安全的，因为它们将数据以纯文本形式保存在托管内存中，因此数量相当不确定直到下一次 GC 运行或强制执行的时间，最好尽快将您的字符数组放入 SecureString 并将其保留在那里，然后将其作为字符数组再次读取。

测试如下所示：

using NUnit.Framework;
using System;
using SecureStringExtensions;
using System.Security;

namespace SecureStringExtensions.Test
{
    [TestFixture]
    public class SecureStringExtensionsTest
    {
        [Test]
        [TestCase(new char[] { 'G', 'O', 'A', 'T', '1', '2', '3' })]
        public void CopyCharArrayToSecureStringAndCopyBackToCharArrayReturnsExpected(char[] inputChars)
        {
            SecureString sec = inputChars.ToSecureString();
            var copiedFromSec = sec.FromSecureStringToCharArray();
            CollectionAssert.AreEqual(copiedFromSec, inputChars);                
        }

        [Test]
        [TestCase("GOAT456")]
        public void CopyStringToSecureStringAndCopyBackToUnsafeStringReturnsExpected(string inputString)
        {
            SecureString sec = inputString.ToSecureString();
            var copiedFromSec = sec.FromSecureStringToUnsafeString();
            Assert.AreEqual(copiedFromSec, inputString);
        }
    }
}

我们在这里有我们的扩展方法：

using System;
using System.Runtime.InteropServices;
using System.Security;

namespace SecureStringExtensions
{
    public static class SecureStringExtensions
    {
        public static SecureString ToSecureString(this string str)
        {
            return ToSecureString(str.ToCharArray());
        }

        public static SecureString ToSecureString(this char[] str)
        {
            var secureString = new SecureString();
            Array.ForEach(str, secureString.AppendChar);
            return secureString;
        }

        /// <summary>
        /// Creates a managed character array from the secure string using methods in System.Runetime.InteropServices
        /// copying data into a BSTR (unmanaged binary string) and then into a managed character array which is returned from this method.
        /// Data in the unmanaged memory temporarily used are freed up before the method returns.
        /// </summary>
        /// <param name="secureString"></param>
        /// <returns></returns>
        public static char[] FromSecureStringToCharArray(this SecureString secureString)
        {
            char[] bytes;
            var ptr = IntPtr.Zero;
            try
            {
                //alloc unmanaged binary string  (BSTR) and copy contents of SecureString into this BSTR
                ptr = Marshal.SecureStringToBSTR(secureString);
                bytes = new char[secureString.Length];
                //copy to managed memory char array from unmanaged memory 
                Marshal.Copy(ptr, bytes, 0, secureString.Length);
            }
            finally
            {
                if (ptr != IntPtr.Zero)
                {
                    //free unmanaged memory
                    Marshal.ZeroFreeBSTR(ptr);
                }
            }
            return bytes;
        }

        /// <summary>
        /// Returns an unsafe string in managed memory from SecureString. 
        /// The use of this method is not recommended - use instead the <see cref="FromSecureStringToCharArray(SecureString)"/> method
        /// as that method has not got multiple copies of data in managed memory like this method.
        /// Data in unmanaged memory temporarily used are freed up before the method returns.
        /// </summary>
        /// <param name="secureString"></param>
        /// <returns></returns>
        public static string FromSecureStringToUnsafeString(this SecureString secureString)
        {
            if (secureString == null)
            {
                throw new ArgumentNullException(nameof(secureString));
            }
            var unmanagedString = IntPtr.Zero;
            try
            {
                //copy secure string into unmanaged memory
                unmanagedString = Marshal.SecureStringToGlobalAllocUnicode(secureString);
                //alloc managed string and copy contents of unmanaged string data into it
                return Marshal.PtrToStringUni(unmanagedString);
            }
            finally
            {
                    if (unmanagedString != IntPtr.Zero)
                {
                    Marshal.FreeBSTR(unmanagedString);
                }
            }
        }

    }
}

在这里，我们使用 System.Runtime.InteropServices 中的方法来临时分配 BSTR（二进制非托管字符串），并确保释放临时使用的非托管内存。

Answer 15

可以使用更简单的方法：

# Take password and convert it to a secure string
$mySS = "MyCurrentPassword" | ConvertTo-SecureString -AsPlainText -Force

将String转换为SecureString

15 个答案: