Comment enregistrer en toute sécurité le nom d'utilisateur / mot de passe (local)?

Je crée une application Windows, à laquelle vous devez d'abord vous connecter.
Les détails du compte se composent du nom d'utilisateur et du mot de passe, et ils doivent être enregistrés localement.
C'est juste une question de sécurité, donc les autres personnes utilisant le même ordinateur ne peuvent pas voir les données personnelles de tout le monde.
Quelle est la meilleure / la plus sûre façon de sauvegarder ces données?

Je ne veux pas utiliser de base de données, j'ai donc essayé certaines choses avec les fichiers de ressources.
Mais comme je suis un peu nouveau avec ça, je ne suis pas tout à fait sûr de ce que je fais et où je devrais chercher une solution.

Si vous souhaitez simplement vérifier / valider le nom d'utilisateur et le mot de passe saisis , utilisez la classe Rfc2898DerivedBytes (également appelée fonction de dérivation de clé basée sur le mot de passe 2 ou PBKDF2). C'est plus sûr que d'utiliser un cryptage comme Triple DES ou AES car il n'y a pas de moyen pratique de passer du résultat de RFC2898DerivedBytes au mot de passe. Vous ne pouvez passer que d'un mot de passe au résultat. Voir Est-il acceptable d'utiliser le hachage SHA1 du mot de passe comme sel lors de la dérivation de la clé de chiffrement et IV de la chaîne de mot de passe? pour un exemple et une discussion pour .Net ou String crypter / décrypter avec le mot de passe c # Metro Style pour WinRT / Metro.

Si vous stockez le mot de passe pour le réutiliser, par exemple le fournir à un tiers, utilisez l' API de protection des données Windows (DPAPI) . Cela utilise les clés générées et protégées par le système d'exploitation et l' algorithme de cryptage Triple DES pour crypter et décrypter les informations. Cela signifie que votre application n'a pas à se soucier de la génération et de la protection des clés de chiffrement, une préoccupation majeure lors de l'utilisation de la cryptographie.

En C #, utilisez la classe System.Security.Cryptography.ProtectedData . Par exemple, pour crypter une donnée, utilisez ProtectedData.Protect():

// Data to protect. Convert a string to a byte[] using Encoding.UTF8.GetBytes().
byte[] plaintext; 

// Generate additional entropy (will be used as the Initialization vector)
byte[] entropy = new byte[20];
using(RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
    rng.GetBytes(entropy);
}

byte[] ciphertext = ProtectedData.Protect(plaintext, entropy,
    DataProtectionScope.CurrentUser);

Stockez l'entropie et le texte chiffré en toute sécurité, par exemple dans un fichier ou une clé de registre avec des autorisations définies afin que seul l'utilisateur actuel puisse le lire. Pour accéder aux données d'origine, utilisez ProtectedData.Unprotect():

byte[] plaintext= ProtectedData.Unprotect(ciphertext, entropy,
    DataProtectionScope.CurrentUser);

Notez qu'il existe des considérations de sécurité supplémentaires. Par exemple, évitez de stocker des secrets comme des mots de passe sous forme de fichier string. Les chaînes sont immuables, car elles ne peuvent pas être notifiées en mémoire afin que quelqu'un qui regarde la mémoire de l'application ou une image mémoire puisse voir le mot de passe. Utilisez plutôt SecureString ou un octet [] et n'oubliez pas de les supprimer ou de les remettre à zéro dès que le mot de passe n'est plus nécessaire.

Je l'ai déjà utilisé et je pense que pour m'assurer que les informations d'identification persistent et de la meilleure manière sécurisée

1. vous pouvez les écrire dans le fichier de configuration de l'application en utilisant la ConfigurationManagerclasse
2. sécurisation du mot de passe à l'aide de la SecureStringclasse
3. puis le chiffrer à l'aide des outils de l' Cryptographyespace de noms.

Ce lien sera d'une grande aide j'espère: Cliquez ici

DPAPI est juste à cet effet. Utilisez DPAPI pour crypter le mot de passe la première fois que l'utilisateur entre, stockez-le dans un emplacement sécurisé (registre de l'utilisateur, répertoire de données d'application de l'utilisateur, sont quelques choix). Chaque fois que l'application est lancée, vérifiez l'emplacement pour voir si votre clé existe, si elle utilise DPAPI pour la déchiffrer et autoriser l'accès, sinon refusez-la.

Cela ne fonctionne que sur Windows, donc si vous envisagez d'utiliser multiplateforme dotnet core, vous devrez chercher ailleurs. Voir https://github.com/dotnet/corefx/blob/master/Documentation/architecture/cross-platform-cryptography.md

Je voulais crypter et décrypter la chaîne en tant que chaîne lisible.

Voici un exemple rapide très simple dans C # Visual Studio 2019 WinForms basé sur la réponse de @Pradip.

Cliquez avec le bouton droit sur projet> propriétés> paramètres> Créer un paramètre usernameet password.

Vous pouvez désormais exploiter les paramètres que vous venez de créer. Ici, je sauvegarde le usernameet passwordmais je ne crypte que le passwordchamp de valeur respectable du user.configfichier.

Exemple de chaîne cryptée dans le user.configfichier.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <userSettings>
        <secure_password_store.Properties.Settings>
            <setting name="username" serializeAs="String">
                <value>admin</value>
            </setting>
            <setting name="password" serializeAs="String">
                <value>AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAAQpgaPYIUq064U3o6xXkQOQAAAAACAAAAAAAQZgAAAAEAACAAAABlQQ8OcONYBr9qUhH7NeKF8bZB6uCJa5uKhk97NdH93AAAAAAOgAAAAAIAACAAAAC7yQicDYV5DiNp0fHXVEDZ7IhOXOrsRUbcY0ziYYTlKSAAAACVDQ+ICHWooDDaUywJeUOV9sRg5c8q6/vizdq8WtPVbkAAAADciZskoSw3g6N9EpX/8FOv+FeExZFxsm03i8vYdDHUVmJvX33K03rqiYF2qzpYCaldQnRxFH9wH2ZEHeSRPeiG</value>
            </setting>
        </secure_password_store.Properties.Settings>
    </userSettings>
</configuration>

Code complet

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace secure_password_store
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Exit_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

        private void Login_Click(object sender, EventArgs e)
        {
            if (checkBox1.Checked == true)
            {
                Properties.Settings.Default.username = textBox1.Text;
                Properties.Settings.Default.password = EncryptString(ToSecureString(textBox2.Text));
                Properties.Settings.Default.Save();
            }
            else if (checkBox1.Checked == false)
            {
                Properties.Settings.Default.username = "";
                Properties.Settings.Default.password = "";
                Properties.Settings.Default.Save();
            }
            MessageBox.Show("{\"data\": \"some data\"}","Login Message Alert",MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        private void DecryptString_Click(object sender, EventArgs e)
        {
            SecureString password = DecryptString(Properties.Settings.Default.password);
            string readable = ToInsecureString(password);
            textBox4.AppendText(readable + Environment.NewLine);
        }
        private void Form_Load(object sender, EventArgs e)
        {
            //textBox1.Text = "UserName";
            //textBox2.Text = "Password";
            if (Properties.Settings.Default.username != string.Empty)
            {
                textBox1.Text = Properties.Settings.Default.username;
                checkBox1.Checked = true;
                SecureString password = DecryptString(Properties.Settings.Default.password);
                string readable = ToInsecureString(password);
                textBox2.Text = readable;
            }
            groupBox1.Select();
        }


        static byte[] entropy = Encoding.Unicode.GetBytes("SaLtY bOy 6970 ePiC");

        public static string EncryptString(SecureString input)
        {
            byte[] encryptedData = ProtectedData.Protect(Encoding.Unicode.GetBytes(ToInsecureString(input)),entropy,DataProtectionScope.CurrentUser);
            return Convert.ToBase64String(encryptedData);
        }

        public static SecureString DecryptString(string encryptedData)
        {
            try
            {
                byte[] decryptedData = ProtectedData.Unprotect(Convert.FromBase64String(encryptedData),entropy,DataProtectionScope.CurrentUser);
                return ToSecureString(Encoding.Unicode.GetString(decryptedData));
            }
            catch
            {
                return new SecureString();
            }
        }

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

        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;
        }

        private void EncryptString_Click(object sender, EventArgs e)
        {
            Properties.Settings.Default.password = EncryptString(ToSecureString(textBox2.Text));
            textBox3.AppendText(Properties.Settings.Default.password.ToString() + Environment.NewLine);
        }
    }
}