C# SecureString.MakeReadOnly方法代码示例

		public static byte[] CreateSelfSignCertificate(string distinguishedName, DateTime startTime, DateTime endTime, string insecurePassword)
		{
			SecureString password = null;
			try
			{
				if (!string.IsNullOrEmpty(insecurePassword))
				{
					password = new SecureString();
					foreach (char ch in insecurePassword)
					{
						password.AppendChar(ch);
					}

					password.MakeReadOnly();
				}

				return CreateSelfSignCertificate(distinguishedName, startTime, endTime, password);
			}
			finally
			{
				if (password != null)
				{
					password.Dispose();
				}
			}
		}

        static void Main(string[] args)
        {
            // The SecureString is used with a using statement,
            // so the Dispose method is called when you are done with the string
            // so that it doesn’t stay in memory any longer then strictly necessary.
            using (SecureString ss = new SecureString())
            {
                Console.WriteLine("Please enter password: ");
                while(true)
                {
                    ConsoleKeyInfo cki = Console.ReadKey(true);
                    if (cki.Key == ConsoleKey.Enter) break;

                    ss.AppendChar(cki.KeyChar);
                    Console.Write("*");
                }
                ss.MakeReadOnly();

                Console.WriteLine();

                ConvertToUnsecureString(ss);
            }

            Console.ReadLine();
        }

        public static SecureString Decrypt(this string cipher)
        {
            if (cipher == null) throw new ArgumentNullException("cipher");

            byte[] saltInclusive = Convert.FromBase64String(cipher);
            MemoryStream ms;

            byte[] entropy;
            byte[] data;

            using (ms = new MemoryStream(saltInclusive))
            {
                BinaryReader reader = new BinaryReader(ms, Encoding.Unicode);
                entropy = reader.ReadBytes(16);
                data = reader.ReadBytes(saltInclusive.Length - 16);
            }

            byte[] decrypted = ProtectedData.Unprotect(data, entropy, DataProtectionScope.CurrentUser);

            SecureString secured = new SecureString();

            int count = Encoding.Unicode.GetCharCount(decrypted);
            int bc = decrypted.Length / count;

            for (int i = 0; i < count; i++)
                secured.AppendChar(Encoding.Unicode.GetChars(decrypted, i * bc, bc)[0]);

            secured.MakeReadOnly();

            return secured;
        }

        public void SetAzureAutomationCredentialByNameWithParametersSuccessfull()
        {
            // Setup
            string accountName = "automation";
            string credentialName = "credential";
            string username = "testUser";
            string password = "password";
            string description = "desc";

            var secureString = new SecureString();
            Array.ForEach(password.ToCharArray(), secureString.AppendChar);
            secureString.MakeReadOnly();

            var value = new PSCredential(username, secureString);

            this.mockAutomationClient.Setup(f => f.UpdateCredential(accountName, credentialName, username, password, description));

            // Test
            this.cmdlet.AutomationAccountName = accountName;
            this.cmdlet.Name = credentialName;
            this.cmdlet.Description = description;
            this.cmdlet.Value = value;
            this.cmdlet.ExecuteCmdlet();

            // Assert
            this.mockAutomationClient.Verify(f => f.UpdateCredential(accountName, credentialName, username, password, description), Times.Once());
        }

        /// <span class="code-SummaryComment"><summary></span>
        /// Decrypts a base64 encrypted string and returns the decrpyted data
        /// wrapped into a <span class="code-SummaryComment"><see cref="SecureString"/> instance.</span>
        /// <span class="code-SummaryComment"></summary></span>
        /// <span class="code-SummaryComment"><param name="cipher">A base64 encoded string that was created</span>
        /// through the <span class="code-SummaryComment"><see cref="Encrypt(string)"/> or</span>
        /// <span class="code-SummaryComment"><see cref="Encrypt(SecureString)"/> extension methods.</param></span>
        /// <span class="code-SummaryComment"><returns>The decrypted string, wrapped into a</span>
        /// <span class="code-SummaryComment"><see cref="SecureString"/> instance.</returns></span>
        /// <span class="code-SummaryComment"><exception cref="ArgumentNullException">If <paramref name="cipher"/></span>
        /// is a null reference.<span class="code-SummaryComment"></exception></span>
        public static SecureString DecryptSecure(this string cipher)
        {
            if (cipher == null) throw new ArgumentNullException("cipher");

            //parse base64 string
            byte[] data = Convert.FromBase64String(cipher);

            //decrypt data
            byte[] decrypted = ProtectedData.Unprotect(data, null, Scope);

            SecureString ss = new SecureString();

            //parse characters one by one - doesn't change the fact that
            //we have them in memory however...
            int count = Encoding.Unicode.GetCharCount(decrypted);
            int bc = decrypted.Length / count;
            for (int i = 0; i < count; i++)
            {
                ss.AppendChar(Encoding.Unicode.GetChars(decrypted, i * bc, bc)[0]);
            }

            //mark as read-only
            ss.MakeReadOnly();
            return ss;
        }

        public void NewAzureAutomationCertificateByNameSuccessfull()
        {
            // Setup
            string resourceGroupName = "resourceGroup";
            string accountName = "automation";
            string certificateName = "certificate";
            string path = "testCert.pfx";
            string password = "password";
            string description = "desc";

            var secureString = new SecureString();
            Array.ForEach(password.ToCharArray(), secureString.AppendChar);
            secureString.MakeReadOnly();

            this.mockAutomationClient.Setup(
                f => f.CreateCertificate(resourceGroupName, accountName, certificateName, path, secureString, description, false));

            this.cmdlet.ResourceGroupName = resourceGroupName;
            this.cmdlet.AutomationAccountName = accountName;
            this.cmdlet.Name = certificateName;
            this.cmdlet.Description = description;
            this.cmdlet.Path = path;
            this.cmdlet.Password = secureString;
            this.cmdlet.ExecuteCmdlet();

            // Assert
            this.mockAutomationClient.Verify(f => f.CreateCertificate(resourceGroupName, accountName, certificateName, path, secureString, description, false), Times.Once());
        }

        public static SecureString GetPassword()
        {
            SecureString pwd = new SecureString();
            while (true)
            {
                ConsoleKeyInfo i = Console.ReadKey(true);
                if (i.Key == ConsoleKey.Enter)
                {
                    break;
                }
                else if (i.Key == ConsoleKey.Backspace)
                {
                    if (pwd.Length > 0)
                    {
                        pwd.RemoveAt(pwd.Length - 1);
                        Console.Write("\b \b");
                    }
                }
                else
                {
                    pwd.AppendChar(i.KeyChar);
                    Console.Write("*");
                }
            }

            pwd.MakeReadOnly();
            Console.WriteLine();
            return pwd;
        }

 public static SecureString ReadSecureString(string prompt)
 {
     const string t = " !\"#$%&'()*+,-./0123456789:;<=>[email protected][\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
     SecureString securePwd = new SecureString();
     ConsoleKeyInfo key;
     Console.Write(prompt);
     Console.Write(':');
     do
     {
         key = Console.ReadKey(true);
         if (t.IndexOf(key.KeyChar) != -1)
         {
             securePwd.AppendChar(key.KeyChar);
             Console.Write('*');
         }
         else if (key.Key == ConsoleKey.Backspace && securePwd.Length > 0)
         {
             securePwd.RemoveAt(securePwd.Length - 1);
             Console.Write(key.KeyChar);
             Console.Write(' ');
             Console.Write(key.KeyChar);
         }
     } while (key.Key != ConsoleKey.Enter);
     Console.WriteLine();
     securePwd.MakeReadOnly();
     return securePwd;
 }

        /// <summary>
        /// Read a password from the console and return it as SecureString
        /// </summary>
        /// <returns></returns>
        public static bool ReadPasswordFromConsole(out SecureString secStr)
        {
            secStr = new SecureString();

            for (ConsoleKeyInfo c = Console.ReadKey(true); c.Key != ConsoleKey.Enter; c = Console.ReadKey(true))
            {
                if (c.Key == ConsoleKey.Backspace && secStr.Length > 0)
                    secStr.RemoveAt(secStr.Length - 1);

                if (c.Key == ConsoleKey.Escape)
                {
                    // cancel
                    secStr.Dispose();
                    Console.WriteLine();
                    return false;
                }

                if (!Char.IsControl(c.KeyChar))
                    secStr.AppendChar(c.KeyChar);
            }

            secStr.MakeReadOnly();
            Console.WriteLine();
            return true;
        }

        /// <summary>
        /// Invoke the Enable-AzureServiceProjectRemoteDesktop enableRDCmdlet.
        /// </summary>
        /// <param name="username">Username.</param>
        /// <param name="password">Password.</param>
        public static void EnableRemoteDesktop(string username, string password)
        {
            SecureString securePassword = null;
            if (password != null)
            {
                securePassword = new SecureString();
                foreach (char ch in password)
                {
                    securePassword.AppendChar(ch);
                }
                securePassword.MakeReadOnly();
            }

            if (enableRDCmdlet == null)
            {
                enableRDCmdlet = new EnableAzureServiceProjectRemoteDesktopCommand();
                if (mockCommandRuntime == null)
                {
                    mockCommandRuntime = new MockCommandRuntime();
                }
                enableRDCmdlet.CommandRuntime = mockCommandRuntime;
            }

            enableRDCmdlet.Username = username;
            enableRDCmdlet.Password = securePassword;
            enableRDCmdlet.EnableRemoteDesktop();
        }

        public void ExecuteNonQueryProcedure(string procedureName, System.Collections.Specialized.NameValueCollection parametersCollection)
        {
            try
            {
                string password = "wolfstein";
                var pwdarr = password.ToCharArray();
                SecureString securePwd = new SecureString();
                foreach (char c in pwdarr)
                {
                    securePwd.AppendChar(c);
                }
                securePwd.MakeReadOnly();

                using (
                    SqlConnection conn = new SqlConnection(this.db.Database.Connection.ConnectionString))
                {
                    conn.Open();
                    SqlCommand cmd = new SqlCommand();
                    cmd.Connection = conn;
                    cmd.CommandText = procedureName;
                    cmd.CommandType = CommandType.StoredProcedure;
                    foreach (var key in parametersCollection.AllKeys)
                    {
                        cmd.Parameters.AddWithValue(key, parametersCollection[key]);
                    }
                    var result = cmd.ExecuteNonQuery();
                }
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }

        static void Main(string[] args)
        {
            using (SecureString ss = new SecureString())
            {
                Console.WriteLine("Please enter password:");
                while (true)
                {
                    ConsoleKeyInfo cki = Console.ReadKey(true);
                    if (cki.Key == ConsoleKey.Enter)
                    {
                        break;
                    }

                    ss.AppendChar(cki.KeyChar);
                    Console.Write("*");
                }

                ss.MakeReadOnly();
                Console.WriteLine();
                ConvertToUnsecureString(ss);
            }

            Console.WriteLine("Press a key to exit");
            Console.ReadKey();
        }

 public static SecureString Secure(this string input)
 {
     var result = new SecureString();
     foreach (var c in input) result.AppendChar(c);
     result.MakeReadOnly();
     return result;
 }

 public static SecureString ToSecureString (string value)
 {
   var result = new SecureString ();
   foreach (var c in value)
     result.AppendChar (c);
   result.MakeReadOnly ();
   return result;
 }

 static SecureString GetPassword(string password)
 {
     SecureString spassword = new SecureString();
     foreach (char c in password)
         spassword.AppendChar(c);
     spassword.MakeReadOnly();
     return spassword;
 }