Comment chiffrer les paramètres de l'utilisateur (comme les mots de passe) dans mon application?

Je veux offrir à l'utilisateur la possibilité d'enregistrer des données à caractère personnel codées. Cela pourrait être banal, ou peut-être déjà demandé, mais je ne suis pas en mesure de trouver un exemple d'un outil facile à utiliser pour crypter/décrypter un mot de passe.

Je n'ai vraiment pas besoin d'un super-magie-incassable mot de passe. J'ai juste besoin de mot de passe pour être comme difficile à briser.

J'ai vu quelques msdn et AINSI de questions mais je n'ai pas trouvé quelque chose à utiliser.

  • Question connexe: Comment crypter un mot de passe pour l'enregistrer par la suite dans une base de données ou un fichier texte?. Et beaucoup, beaucoup plus: les Questions contenant 'c# crypter le mot de passe" .
  • Notez que quoi que vous fassiez, vous ne pas déchiffrer les mots de passe. Plutôt, vous vous assurez que les deux hachages de match.
  • est-il possible d'envoyer le mot de passe haché dans la chaîne de connexion sql?
  • Ne sais rien à propos de SQL, mais je suis sûre qu'il doit être. Un mot de passe haché serait exactement comme n'importe quel autre texte ou une valeur numérique.
  • Vous ne voulez pas utiliser les mots de passe des utilisateurs dans les chaînes de connexion. En supposant que vous êtes sur SQL Server, faire qui empêche les connexions de mise en commun et donc diminue les performances. Au lieu de cela, avoir un compte qui se connecte à SQL Server à l'aide de l'authentification Windows.
InformationsquelleAutor Odys | 2012-01-15
  1. 33

    David, J'ai pensé votre réponse était chouette, mais je croyais que ce serait niftier que les méthodes d'extension. Permettant cette syntaxe:

    string cypherText;
string clearText;

using (var secureString = "Some string to encrypt".ToSecureString())
{
    cypherText = secureString.EncryptString();
}

using (var secureString = cypherText.DecryptString())
{
    clearText = secureString.ToInsecureString();
}

    Voici le code mis à jour:

    using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Cryptography;
using System.Text;
public static class SecureIt
{
private static readonly byte[] entropy = Encoding.Unicode.GetBytes("Salt Is Not A Password");
public static string EncryptString(this SecureString input)
{
if (input == null)
{
return null;
}
var encryptedData = ProtectedData.Protect(
Encoding.Unicode.GetBytes(input.ToInsecureString()),
entropy,
DataProtectionScope.CurrentUser);
return Convert.ToBase64String(encryptedData);
}
public static SecureString DecryptString(this string encryptedData)
{
if (encryptedData == null)
{
return null;
}
try
{
var decryptedData = ProtectedData.Unprotect(
Convert.FromBase64String(encryptedData),
entropy,
DataProtectionScope.CurrentUser);
return Encoding.Unicode.GetString(decryptedData).ToSecureString();
}
catch
{
return new SecureString();
}
}
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;
}
public static string ToInsecureString(this SecureString input)
{
if (input == null)
{
return null;
}
var ptr = Marshal.SecureStringToBSTR(input);
try
{
return Marshal.PtrToStringBSTR(ptr);
}
finally
{
Marshal.ZeroFreeBSTR(ptr);
}
}
}
    • Belle amélioration. J'ai copié le code à partir d'un vieux projet de tests unitaires, où j'ai été en utilisant des comptes d'utilisateur et des mots de passe pour les tests. Je voulais stocker les mots de passe de manière sécurisée afin que je puisse exécuter les tests sans avoir à afficher ou enregistrer les mots de passe en texte clair.
    • Voir la note que j'ai laissé ci-dessous sur @DavidClarke 's réponse, et de voir cette msdn lien
    InformationsquelleAutor Jesse C. Slicer
  2. 16

    La suite est à peu près aussi simple que cela, en supposant que vous vraiment voulez juste être en mesure de crypter/décrypter une chaîne et de les stocker sur le disque. Remarque ce n'est pas utiliser un mot de passe, il utilise le contexte de sécurité de l'utilisateur connecté Système.De sécurité.La cryptographie.DataProtectionScope.CurrentUser pour sécuriser les données.

    public class SecureIt
{
static byte[] entropy = System.Text.Encoding.Unicode.GetBytes("Salt Is Not A Password");
public static string EncryptString(System.Security.SecureString input)
{
byte[] encryptedData = System.Security.Cryptography.ProtectedData.Protect(
System.Text.Encoding.Unicode.GetBytes(ToInsecureString(input)),
entropy,
System.Security.Cryptography.DataProtectionScope.CurrentUser);
return Convert.ToBase64String(encryptedData);
}
public static SecureString DecryptString(string encryptedData)
{
try
{
byte[] decryptedData = System.Security.Cryptography.ProtectedData.Unprotect(
Convert.FromBase64String(encryptedData),
entropy,
System.Security.Cryptography.DataProtectionScope.CurrentUser);
return ToSecureString(System.Text.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;
}
}

    Alors de crypter une chaîne de caractères:

      var clearText = "Some string to encrypt";
var cypherText = SecureIt.EncryptString( SecureIt.ToSecureString( clearText));

    Et à la suite de décrypter:

    var clearText = SecureIt.ToInsecureString( SecureIt.DecryptString(cypherText));
    • Si vous décrypter une chaîne sécurisée il n'y a pas de point à l'aide d'une chaîne sécurisée. Le but est de garder la chaîne complète d'un seul bloc de mémoire. Vous n'êtes mieux d'utiliser cette méthode que si vous avez juste pris une corde et chiffrées: A SecureString object should never be constructed from a String, because the sensitive data is already subject to the memory persistence consequences of the immutable String class. The best way to construct a SecureString object is from a character-at-a-time unmanaged source, such as the Console.ReadKey method.
    • C'est un bon point. Je ne dis pas que toutes les méthodes doivent être utilisées dans la même application. J'ai été à l'aide d'une console séparée application de capturer la chaîne et de la chiffrer avant de les stocker en toute sécurité dans les paramètres d'un projet de tests unitaires. L'intention était de garantir une sécurité suffisante pour le contexte dans lequel il est utilisé.
    InformationsquelleAutor David Clarke
  3. 1

    Pour mon but, j'ai modifier Jesse C. Trancheuse solution pour ne pas utiliser SecureString que ce n'est pas important pour moi, pour protéger la mémoire. J'ai juste besoin de sérialiser des chaînes cryptées. Pour faire de ce projet a nécessité de faire référence à System.Security (non seulement à l'aide de l'énoncé).

    public static class StringSecurityHelper
{
private static readonly byte[] entropy = Encoding.Unicode.GetBytes("5ID'&mc %sJo@lGtbi%n!G^ fiVn8 *tNh3eB %rDaVijn!.c b");
public static string EncryptString(this string input)
{
if (input == null)
{
return null;
}
byte[] encryptedData = ProtectedData.Protect(Encoding.Unicode.GetBytes(input), entropy, DataProtectionScope.CurrentUser);
return Convert.ToBase64String(encryptedData);
}
public static string DecryptString(this string encryptedData)
{
if (encryptedData == null)
{
return null;
}
try
{
byte[] decryptedData = ProtectedData.Unprotect(Convert.FromBase64String(encryptedData), entropy, DataProtectionScope.CurrentUser);
return Encoding.Unicode.GetString(decryptedData);
}
catch
{
return null;
}
}
}

    Et de l'utiliser:

    string cypherText = "My string".EncryptString();
string clearText = cypherText.DecryptString();
    InformationsquelleAutor Logman