static SqlCredential CreateCredential(String username)
    {
        // Prompt the user for a password and construct SqlCredential
        SecureString password = new SecureString();
        Console.WriteLine("Enter password for " + username + ": ");

        ConsoleKeyInfo nextKey = Console.ReadKey(true);

        while (nextKey.Key != ConsoleKey.Enter)
        {
            if (nextKey.Key == ConsoleKey.Backspace)
            {
                if (password.Length > 0)
                {
                    password.RemoveAt(password.Length - 1);
                    // erase the last * as well
                    Console.Write(nextKey.KeyChar);
                    Console.Write(" ");
                    Console.Write(nextKey.KeyChar);
                }
            }
            else
            {
                password.AppendChar(nextKey.KeyChar);
                Console.Write("*");
            }
            nextKey = Console.ReadKey(true);
        }

        Console.WriteLine();
        Console.WriteLine();
        password.MakeReadOnly();
        return new SqlCredential(username, password);
    }

    /// <summary>
    /// Read a password from the console into a SecureString
    /// </summary>
    /// <returns>Password stored in a secure string</returns>
    public static SecureString GetPassword()
    {
        SecureString password = new SecureString();
        Console.WriteLine("Enter password: ");

        // get the first character of the password
        ConsoleKeyInfo nextKey = Console.ReadKey(true);
        while (nextKey.Key != ConsoleKey.Enter)
        {
            if (nextKey.Key == ConsoleKey.Backspace)
            {
                if (password.Length > 0)
                {
                    password.RemoveAt(password.Length - 1);

                    // erase the last * as well
                    Console.Write(nextKey.KeyChar);
                    Console.Write(" ");
                    Console.Write(nextKey.KeyChar);
                }
            }
            else
            {
                password.AppendChar(nextKey.KeyChar);
                Console.Write("*");
            }
            nextKey = Console.ReadKey(true);
        }

        Console.WriteLine();

        // lock the password down
        password.MakeReadOnly();
        return password;
    }

        public string getTokenString(string user, SecureString password)
        {
            //credentials.Add ( new System.Uri ( uri ), "Basic", new NetworkCredential ( boxUser.Text, boxPw.SecurePassword) );
            //var url = Path.Combine ( URL, TOKEN );

            var client = new HttpClient();
            var content = new HttpRequestMessage(HttpMethod.Post, new Uri(URI, TOKEN));
            content.Headers()
            client.PostAsync(new Uri(URI, TOKEN),);

            var request = (HttpWebRequest)HttpWebRequest.Create(new Uri(URI, TOKEN));
            request.ContentType = "text/json";
            request.Credentials = new NetworkCredential(user, password);
            request.Method = "POST";

            //var objStream = request.GetRequestStream ();
            //var writer = new StreamWriter ( objStream );

            //writer.Write ( "{\"comment\":\"ProtonetTool\"}" );
            //writer.Flush ();

            //writer.Close ();

            return ReadResponse(request);
        }

    /// <summary>
    ///     A String extension method that converts the @this to a secure string.
    /// </summary>
    /// <param name="this">The @this to act on.</param>
    /// <returns>@this as a SecureString.</returns>
    public static SecureString ToSecureString(this string @this)
    {
        var secureString = new SecureString();
        foreach (Char c in @this)
            secureString.AppendChar(c);

        return secureString;
    }

 private static SecureString createSecureString(string s)
 {
     SecureString result = new SecureString();
     foreach(char ch in s)
     {
         result.AppendChar(ch);
     }
     return result;
 }

 public static SecureString ToSecureString(string input)
 {
     SecureString secure = new SecureString();
     foreach (char c in input)
     {
         secure.AppendChar(c);
     }
     secure.MakeReadOnly();
     return secure;
 }

 public static SecureString ReadPassword()
 {
     Console.Write("Password: ");
     SecureString secPass = new SecureString();
     ConsoleKeyInfo key = Console.ReadKey(true);
     while (key.KeyChar != '\r')
     {
         secPass.AppendChar(key.KeyChar);
         key = Console.ReadKey(true);
     }
     return secPass;
 }

        public X509Certificate(byte[] rawData, SecureString password, X509KeyStorageFlags keyStorageFlags)
        {
            if (rawData == null || rawData.Length == 0)
                throw new ArgumentException(SR.Arg_EmptyOrNullArray, nameof(rawData));

            ValidateKeyStorageFlags(keyStorageFlags);

            using (var safePasswordHandle = new SafePasswordHandle(password))
            {
                Pal = CertificatePal.FromBlob(rawData, safePasswordHandle, keyStorageFlags);
            }
        }

 public static string ToInsecureString(SecureString input)
 {
     string returnValue = string.Empty;
     IntPtr ptr = System.Runtime.InteropServices.Marshal.SecureStringToBSTR(input);
     try
     {
         returnValue = System.Runtime.InteropServices.Marshal.PtrToStringBSTR(ptr);
     }
     finally
     {
         System.Runtime.InteropServices.Marshal.ZeroFreeBSTR(ptr);
     }
     return returnValue;
 }

    public static SecureString ToSecureString(this IEnumerable<char> input)
    {
        if (input == null)
        {
            return null;
        }

        var secure = new SecureString();

        foreach (var c in input)
        {
            secure.AppendChar(c);
        }

        secure.MakeReadOnly();
        return secure;
    }

    private static void VerifyString(SecureString ss, string exString)
    {
        IntPtr uniStr = IntPtr.Zero;
        try
        {
            uniStr = SecureStringMarshal.SecureStringToCoTaskMemUnicode(ss);
            string acString = Marshal.PtrToStringUni(uniStr);

            Assert.Equal(exString.Length, acString.Length);
            Assert.Equal(exString, acString);
        }
        finally
        {
            if (uniStr != IntPtr.Zero)
                SecureStringMarshal.ZeroFreeCoTaskMemUnicode(uniStr);
        }
    }

    private static SecureString CreateSecureString(string exValue)
    {
        SecureString ss = null;

        if (string.IsNullOrEmpty(exValue))
            ss = new SecureString();
        else
        {
            unsafe
            {
                fixed (char* mychars = exValue.ToCharArray())
                    ss = new SecureString(mychars, exValue.Length);
            }
        }

        Assert.NotNull(ss);
        return ss;
    }

 public static ISshKey GetSshKey(this EntrySettings settings,
     ProtectedStringDictionary strings, ProtectedBinaryDictionary binaries,
     SprContext sprContext)
 {
     if (!settings.AllowUseOfSshKey) {
     return null;
       }
       KeyFormatter.GetPassphraseCallback getPassphraseCallback =
     delegate(string comment)
     {
       var securePassphrase = new SecureString();
     var passphrase = SprEngine.Compile(strings.ReadSafe(
                   PwDefs.PasswordField), sprContext);
       foreach (var c in passphrase) {
     securePassphrase.AppendChar(c);
       }
       return securePassphrase;
     };
       Func<Stream> getPrivateKeyStream;
       Func<Stream> getPublicKeyStream = null;
       switch (settings.Location.SelectedType) {
     case EntrySettings.LocationType.Attachment:
       if (string.IsNullOrWhiteSpace(settings.Location.AttachmentName)) {
     throw new NoAttachmentException();
       }
       var privateKeyData = binaries.Get(settings.Location.AttachmentName);
       var publicKeyData = binaries.Get(settings.Location.AttachmentName + ".pub");
       getPrivateKeyStream = () => new MemoryStream(privateKeyData.ReadData());
       if (publicKeyData != null)
     getPublicKeyStream = () => new MemoryStream(publicKeyData.ReadData());
       return GetSshKey(getPrivateKeyStream, getPublicKeyStream,
                    settings.Location.AttachmentName, getPassphraseCallback);
     case EntrySettings.LocationType.File:
       getPrivateKeyStream = () => File.OpenRead(settings.Location.FileName);
       var publicKeyFile = settings.Location.FileName + ".pub";
       if (File.Exists(publicKeyFile))
     getPublicKeyStream = () => File.OpenRead(publicKeyFile);
       return GetSshKey(getPrivateKeyStream, getPublicKeyStream,
                    settings.Location.AttachmentName, getPassphraseCallback);
     default:
       return null;
       }
 }

 public static IntPtr SecureStringToCoTaskMemAnsi(SecureString s) => s != null ? s.MarshalToString(globalAlloc: false, unicode: false) : IntPtr.Zero;

 public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s) => s != null ? s.MarshalToString(globalAlloc: true, unicode: true) : IntPtr.Zero;

		public override void Import (string fileName, SecureString password, X509KeyStorageFlags keyStorageFlags) 
		{
			byte[] rawData = File.ReadAllBytes (fileName);
			Import (rawData, (string)null, keyStorageFlags);
		}

		public X509Certificate2 (string fileName, SecureString password, X509KeyStorageFlags keyStorageFlags)
		{
			Import (fileName, password, keyStorageFlags);
		}

        public static SecureString FindKeePassPassword(
            PwDatabase database,
            bool caseSensitive = false,
            string username = null,
            string url = null,
            string title = null,
            string notes = null)
        {
            var entries =  FindKeePassEntries(database, caseSensitive, true, username, url, title, notes);
            if (entries == null)
                return null;

            foreach(var entry in entries)
            {
                var secureString = new SecureString();
                var value = entry.Strings.ReadSafe("Password");
                foreach (var c in value)
                    secureString.AppendChar(c);

                return secureString;
            }

            return null;
        }

 public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s);

		public X509Certificate2 (byte[] rawData, SecureString password) : base (rawData, password) 
		{
			_cert = new MX.X509Certificate (base.GetRawCertData ());
		}