L'AES dans le ASP.NET avec VB.NET

Première

Ne pas le faire! La rédaction de votre propre crypto système peut facilement conduire à faire des erreurs. Il est préférable d'utiliser un système existant, ou si non, demandez à quelqu'un qui connaît la cryptographie pour le faire. Si vous devez le faire vous-même, lisez Pratique De La Cryptographie.

Et s'il vous plaît, rappelez-vous: "Nous avons déjà assez rapide, la précarité des systèmes." (Bruce Schneier) -- Faire des choses correctes et de se soucier de la performance à plus tard.

Cela dit, si vous êtes coincé sur à l'aide d'AES pour restaurer votre choix, voici quelques conseils.

Vecteur D'Initialisation

AES est un algorithme de chiffrement par bloc. Donné une clé et un bloc de texte en clair, il la convertit à un texte chiffré. Le problème, c'est que les mêmes blocs de données génère le même texte chiffré avec la même clé, à chaque fois. Supposons donc que vous envoyez des données comme ceci:

utilisateur=Encrypt(nom d'utilisateur)&les rôles=Encrypt(UserRoles)

Ils sont deux blocs distincts, et le UserRoles de chiffrement aura le même texte chiffré à chaque fois, quel que soit le nom. Tout ce que je besoin est le texte chiffré pour un admin, et je puis déposez-la dans avec mon cipher avait nom d'utilisateur. Oups.

Donc, il y a chiffrement des modes de fonctionnement. L'idée principale est que vous allez prendre le texte chiffré en un seul bloc, et XOR dans le texte chiffré du bloc suivant. De cette façon, nous allons faire Chiffrer(UserRoles, nom d'utilisateur), et le nom de l'utilisateur le texte chiffré est affectée par la UserRoles.

Le problème, c'est que le premier bloc est toujours vulnérable - juste en voyant quelqu'un texte chiffré, je pourrais connaître leurs rôles. Entrez le vecteur d'initialisation. Le IV "démarre" l'algorithme de chiffrement et s'assure qu'elle a données aléatoires pour chiffrer le reste du flux. Alors maintenant, la UserRoles texte chiffré a le cryptogramme de l'aléatoire IV XOR souhaitez. Le problème est résolu.

Donc, assurez-vous de la génération aléatoire IV pour chaque message. Le IV n'est pas sensible et peut être envoyé en clair avec le texte chiffré. Utiliser un IV suffisamment grande, la taille du bloc doit être suffisante pour la plupart des cas.

Intégrité

AES ne fournit pas de fonctionnalités d'intégrité. N'importe qui peut modifier votre texte chiffré, et le décrypter fonctionne toujours. Il est peu probable que ça va être valide de données en général, mais il peut être difficile de savoir ce que les données sont valides. Par exemple, si vous êtes à la transmission d'un GUID chiffré, il serait facile de modifier certains bits et de générer un nom complètement différent. Qui pourrait conduire à des erreurs d'application et ainsi de suite.

Le correctif il y a à exécuter un algorithme de hachage (utiliser SHA256 ou SHA512) sur le texte en clair, et de l'inclure dans les données que vous transmettez. Donc, si mon message est (nom d'utilisateur, de Rôles), vous pourrez envoyer (nom d'utilisateur, de Rôles, de Hachage(nom d'utilisateur, Rôles)). Maintenant, si quelqu'un tente d'altérer le texte chiffré en retournant un peu, le hash n'aura plus de calcul et vous pouvez rejeter le message.

De dérivation de clé

Si vous avez besoin de générer une clé à partir d'un mot de passe, utilisez la classe intégrée: Système.De sécurité.La cryptographie.PasswordDeriveBytes. Cette offre de salage et d'itérations, ce qui peut améliorer la force de la dérivée de clés et de réduire la chance de découvrir le mot de passe si la clé est compromise.

Calendrier/replay

Edit: Désolé pour ne pas mentionner plus tôt :P. Vous devez également vous assurer que vous avez un anti-système de rediffusion. Si vous avez simplement chiffrer le message et le transmettre autour de, toute personne qui reçoit le message peut seulement renvoyer. Pour éviter cela, vous devez ajouter un horodatage du message. Si le timestamp est différente en fonction d'un certain seuil, de rejeter le message. Vous pouvez également inclure une seule fois, ID (ce pourrait être le point IV) et de rejeter temps-valide les messages qui viennent d'autres IPs en utilisant le même IDENTIFIANT.

Il est important de vous assurer de faire la vérification du hachage lorsque vous incluez les informations de synchronisation. Sinon, quelqu'un pourrait trafiquer un peu le texte chiffré et potentiellement générer un timestamp valide si vous n'avez pas de détecter de telles tentatives de brute force.

Exemple de code

Depuis, apparemment, à l'aide d'un IV correctement est controversé pour certaines personnes, voici un code qui va générer au hasard des IVs et les ajouter à votre sortie pour vous. Il va également effectuer l'étape d'authentification, assurez vous que les données chiffrées n'était pas modifié.

using System;
using System.Security.Cryptography;
using System.Text;
class AesDemo {
const int HASH_SIZE = 32; //SHA256
///<summary>Performs encryption with random IV (prepended to output), and includes hash of plaintext for verification.</summary>
public static byte[] Encrypt(string password, byte[] passwordSalt, byte[] plainText) {
//Construct message with hash
var msg = new byte[HASH_SIZE + plainText.Length];
var hash = computeHash(plainText, 0, plainText.Length);
Buffer.BlockCopy(hash, 0, msg, 0, HASH_SIZE);
Buffer.BlockCopy(plainText, 0, msg, HASH_SIZE, plainText.Length);
//Encrypt
using (var aes = createAes(password, passwordSalt)) {
aes.GenerateIV();
using (var enc = aes.CreateEncryptor()) {
var encBytes = enc.TransformFinalBlock(msg, 0, msg.Length);
//Prepend IV to result
var res = new byte[aes.IV.Length + encBytes.Length];
Buffer.BlockCopy(aes.IV, 0, res, 0, aes.IV.Length);
Buffer.BlockCopy(encBytes, 0, res, aes.IV.Length, encBytes.Length);
return res;
}
}
}
public static byte[] Decrypt(string password, byte[] passwordSalt, byte[] cipherText) {
using (var aes = createAes(password, passwordSalt)) {
var iv = new byte[aes.IV.Length];
Buffer.BlockCopy(cipherText, 0, iv, 0, iv.Length);
aes.IV = iv; //Probably could copy right to the byte array, but that's not guaranteed
using (var dec = aes.CreateDecryptor()) {
var decBytes = dec.TransformFinalBlock(cipherText, iv.Length, cipherText.Length - iv.Length);
//Verify hash
var hash = computeHash(decBytes, HASH_SIZE, decBytes.Length - HASH_SIZE);
var existingHash = new byte[HASH_SIZE];
Buffer.BlockCopy(decBytes, 0, existingHash, 0, HASH_SIZE);
if (!compareBytes(existingHash, hash)){
throw new CryptographicException("Message hash incorrect.");
}
//Hash is valid, we're done
var res = new byte[decBytes.Length - HASH_SIZE];
Buffer.BlockCopy(decBytes, HASH_SIZE, res, 0, res.Length);
return res;
}
}
}
static bool compareBytes(byte[] a1, byte[] a2) {
if (a1.Length != a2.Length) return false;
for (int i = 0; i < a1.Length; i++) {
if (a1[i] != a2[i]) return false;
}
return true;
}
static Aes createAes(string password, byte[] salt) {
//Salt may not be needed if password is safe
if (password.Length < 8) throw new ArgumentException("Password must be at least 8 characters.", "password");
if (salt.Length < 8) throw new ArgumentException("Salt must be at least 8 bytes.", "salt");
var pdb = new PasswordDeriveBytes(password, salt, "SHA512", 129);
var key = pdb.GetBytes(16);
var aes = Aes.Create();
aes.Mode = CipherMode.CBC;
aes.Key = pdb.GetBytes(aes.KeySize / 8);
return aes;
}
static byte[] computeHash(byte[] data, int offset, int count) {
using (var sha = SHA256.Create()) {
return sha.ComputeHash(data, offset, count);
}
}
public static void Main() {
var password = "1234567890!";
var salt = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
var ct1 = Encrypt(password, salt, Encoding.UTF8.GetBytes("Alice; Bob; Eve;: PerformAct1"));
Console.WriteLine(Convert.ToBase64String(ct1));
var ct2 = Encrypt(password, salt, Encoding.UTF8.GetBytes("Alice; Bob; Eve;: PerformAct2"));
Console.WriteLine(Convert.ToBase64String(ct2));
var pt1 = Decrypt(password, salt, ct1);
Console.WriteLine(Encoding.UTF8.GetString(pt1));
var pt2 = Decrypt(password, salt, ct2);
Console.WriteLine(Encoding.UTF8.GetString(pt2));
//Now check tampering
try {
ct1[30]++;
Decrypt(password, salt, ct1);
Console.WriteLine("Error: tamper detection failed.");
} catch (Exception ex) {
Console.WriteLine("Success: tampering detected.");
Console.WriteLine(ex.ToString());
}
}
}

De sortie:

JZVaD327sDmCmdzY0PsysnRgHbbC3eHb7yxalb0qxfvlr7lkj8waozwc1aywcvfhtuz/y0QMz+uv0PwmuG8VBVEQThaNTD02JlhIs1DjJtg=
QQvDujNJ31qTu/foDFUiVMeWTU0jKL/UJJfFAvmFtz361o3KSUlk/zH+4701mlFEU4Ce6VuAAuaiP1EENBJ74Wc8me/QTofkUMHoa65/5e4=
Alice, Bob; Eve;: PerformAct1 Alice;
Bob; Eve;: PerformAct2 Succès:
l'altération est détectée.
Système.De sécurité.La cryptographie.CryptographicException:
Message de hachage incorrect. au
AesDemo.Décrypter(String mot de passe,
Byte[] passwordSalt, Byte[]
texte chiffré) dans
C:\Program.cs:ligne
46 à AesDemo.Main() dans
C:\Program.cs:ligne
100

Après la suppression de l'aléatoire IV et le hachage, voici le type de sortie:

tZfHJSFTXYX8V38AqEfYVXU5Dl/meUVAond70yIKGHY=
tZfHJSFTXYX8V38AqEfYVcf9a3U8vIEk1luqgeyrzxm=

Remarquez comment le premier bloc, correspondant à "Alice; Bob; Eve;" est le même. "Des cas de coin" en effet.

Exemple sans hachage

Voici un simple exemple de passage d'un entier de 64 bits. Juste chiffrer et vous êtes ouvert à l'attaque. En fait, l'attaque se fait facilement, même avec CBC rembourrage.

public static void Main() {
var buff = new byte[8];
new Random().NextBytes(buff);
var v = BitConverter.ToUInt64(buff, 0);
Console.WriteLine("Value: " + v.ToString());
Console.WriteLine("Value (bytes): " + BitConverter.ToString(BitConverter.GetBytes(v)));
var aes = Aes.Create();
aes.GenerateIV();
aes.GenerateKey();
var encBytes = aes.CreateEncryptor().TransformFinalBlock(BitConverter.GetBytes(v), 0, 8);
Console.WriteLine("Encrypted: " + BitConverter.ToString(encBytes));
var dec = aes.CreateDecryptor();
Console.WriteLine("Decrypted: " + BitConverter.ToUInt64(dec.TransformFinalBlock(encBytes, 0, encBytes.Length), 0));
for (int i = 0; i < 8; i++) {
for (int x = 0; x < 250; x++) {
encBytes[i]++;
try {
Console.WriteLine("Attacked: " + BitConverter.ToUInt64(dec.TransformFinalBlock(encBytes, 0, encBytes.Length), 0));
return;
} catch { }
}
}
}

De sortie:

Valeur: 6598637501946607785 Valeur

(octets): A9-38-19-D1-D8-11-93-5B

Chiffré:

31-59-B0-25-FD-C5-13-D7-81-D8-F5-8A-33-2A-57-DD

Décrypté: 6598637501946607785

Attaqué: 14174658352338201502

Donc, si c'est le genre de ID que vous envoyez, il pourrait très facilement être changé pour une autre valeur. Vous devez vous authentifier à l'extérieur de votre message. Parfois, la structure du message est peu probable de tomber en place et peut sorta agir comme un garde-fou, mais pourquoi compter sur quelque chose qui pourrait peut-être changer? Vous avez besoin de pouvoir compter sur votre crypto travail correctement quelle que soit l'application.

OriginalL'auteur MichaelGG

Vous trouverez ci-dessous une classe qui fournit l'AES Chiffrement/Déchiffrement des méthodes qui prévoient explicitement URL-amicale des chaînes pour l'utilisation dans des applications comme la vôtre. Il a aussi les méthodes de travail avec des tableaux d'octets.

REMARQUE: vous devez utiliser différentes valeurs dans la Clé et le Vecteur des tableaux! Vous ne voudriez pas que quelqu'un de comprendre vos clés par juste en supposant que vous avez utilisé ce code tel qu'il est! Tout ce que vous avez à faire est de changer certaines de nombres (doit être <= 255) dans la Clé de Vecteur et matrices.

Son utilisation est facile: il suffit d'instancier la classe et puis les appeler (en général) EncryptToString(string StringToEncrypt) et DecryptString(string StringToDecrypt) que des méthodes. Il ne pouvait pas être plus facile (ou plus sûr) une fois que vous avez cette classe.

---

using System;
using System.Data;
using System.Security.Cryptography;
using System.IO;
public class SimpleAES
{
//Change these keys
private byte[] Key = { 123, 217, 19, 11, 24, 26, 85, 45, 114, 184, 27, 162, 37, 112, 222, 209, 241, 24, 175, 144, 173, 53, 196, 29, 24, 26, 17, 218, 131, 236, 53, 209 };
private byte[] Vector = { 146, 64, 191, 111, 23, 3, 113, 119, 231, 121, 2521, 112, 79, 32, 114, 156 };
private ICryptoTransform EncryptorTransform, DecryptorTransform;
private System.Text.UTF8Encoding UTFEncoder;
public SimpleAES()
{
//This is our encryption method
RijndaelManaged rm = new RijndaelManaged();
//Create an encryptor and a decryptor using our encryption method, key, and vector.
EncryptorTransform = rm.CreateEncryptor(this.Key, this.Vector);
DecryptorTransform = rm.CreateDecryptor(this.Key, this.Vector);
//Used to translate bytes to text and vice versa
UTFEncoder = new System.Text.UTF8Encoding();
}
///-------------- Two Utility Methods (not used but may be useful) -----------
///Generates an encryption key.
static public byte[] GenerateEncryptionKey()
{
//Generate a Key.
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateKey();
return rm.Key;
}
///Generates a unique encryption vector
static public byte[] GenerateEncryptionVector()
{
//Generate a Vector
RijndaelManaged rm = new RijndaelManaged();
rm.GenerateIV();
return rm.IV;
}
///----------- The commonly used methods ------------------------------    
///Encrypt some text and return a string suitable for passing in a URL.
public string EncryptToString(string TextValue)
{
return ByteArrToString(Encrypt(TextValue));
}
///Encrypt some text and return an encrypted byte array.
public byte[] Encrypt(string TextValue)
{
//Translates our text value into a byte array.
Byte[] bytes = UTFEncoder.GetBytes(TextValue);
//Used to stream the data in and out of the CryptoStream.
MemoryStream memoryStream = new MemoryStream();
/*
* We will have to write the unencrypted bytes to the stream,
* then read the encrypted result back from the stream.
*/
#region Write the decrypted value to the encryption stream
CryptoStream cs = new CryptoStream(memoryStream, EncryptorTransform, CryptoStreamMode.Write);
cs.Write(bytes, 0, bytes.Length);
cs.FlushFinalBlock();
#endregion
#region Read encrypted value back out of the stream
memoryStream.Position = 0;
byte[] encrypted = new byte[memoryStream.Length];
memoryStream.Read(encrypted, 0, encrypted.Length);
#endregion
//Clean up.
cs.Close();
memoryStream.Close();
return encrypted;
}
///The other side: Decryption methods
public string DecryptString(string EncryptedString)
{
return Decrypt(StrToByteArray(EncryptedString));
}
///Decryption when working with byte arrays.    
public string Decrypt(byte[] EncryptedValue)
{
#region Write the encrypted value to the decryption stream
MemoryStream encryptedStream = new MemoryStream();
CryptoStream decryptStream = new CryptoStream(encryptedStream, DecryptorTransform, CryptoStreamMode.Write);
decryptStream.Write(EncryptedValue, 0, EncryptedValue.Length);
decryptStream.FlushFinalBlock();
#endregion
#region Read the decrypted value from the stream.
encryptedStream.Position = 0;
Byte[] decryptedBytes = new Byte[encryptedStream.Length];
encryptedStream.Read(decryptedBytes, 0, decryptedBytes.Length);
encryptedStream.Close();
#endregion
return UTFEncoder.GetString(decryptedBytes);
}
///Convert a string to a byte array.  NOTE: Normally we'd create a Byte Array from a string using an ASCII encoding (like so).
//     System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
//     return encoding.GetBytes(str);
//However, this results in character values that cannot be passed in a URL.  So, instead, I just
//lay out all of the byte values in a long string of numbers (three per - must pad numbers less than 100).
public byte[] StrToByteArray(string str)
{
if (str.Length == 0)
throw new Exception("Invalid string value in StrToByteArray");
byte val;
byte[] byteArr = new byte[str.Length / 3];
int i = 0;
int j = 0;
do
{
val = byte.Parse(str.Substring(i, 3));
byteArr[j++] = val;
i += 3;
}
while (i < str.Length);
return byteArr;
}
//Same comment as above.  Normally the conversion would use an ASCII encoding in the other direction:
//     System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
//     return enc.GetString(byteArr);    
public string ByteArrToString(byte[] byteArr)
{
byte val;
string tempStr = "";
for (int i = 0; i <= byteArr.GetUpperBound(0); i++)
{
val = byteArr[i];
if (val < (byte)10)
tempStr += "00" + val.ToString();
else if (val < (byte)100)
tempStr += "0" + val.ToString();
else
tempStr += val.ToString();
}
return tempStr;
}
}

---

OriginalL'auteur Mark Brittingham