Le cryptage/Décryptage de fichiers volumineux (.NET)

Un organisme de grandes est une autre de la petite, même si nous savons tous cher quand on le voit. Clin d'oeil, clin d'oeil.

Essayer de benchmarking quelque chose comme ce qui suit dans votre environnement et de voir où vous en êtes:

MODIFIER 2/13/2012: Le code a été mis à jour comme je le suis devenu (imperceptible) plus intelligente et également remarqué un peu de couper /" coller erreurs qui s'étaient glissées dans. Mea culpa.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
...
//Rfc2898DeriveBytes constants:
public readonly byte[] salt = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; //Must be at least eight bytes.  MAKE THIS SALTIER!
public const int iterations = 1042; //Recommendation is >= 1000.
///<summary>Decrypt a file.</summary>
///<remarks>NB: "Padding is invalid and cannot be removed." is the Universal CryptoServices error.  Make sure the password, salt and iterations are correct before getting nervous.</remarks>
///<param name="sourceFilename">The full path and name of the file to be decrypted.</param>
///<param name="destinationFilename">The full path and name of the file to be output.</param>
///<param name="password">The password for the decryption.</param>
///<param name="salt">The salt to be applied to the password.</param>
///<param name="iterations">The number of iterations Rfc2898DeriveBytes should use before generating the key and initialization vector for the decryption.</param>
public void DecryptFile(string sourceFilename, string destinationFilename, string password, byte[] salt, int iterations)
{
AesManaged aes = new AesManaged();
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
//NB: Rfc2898DeriveBytes initialization and subsequent calls to   GetBytes   must be eactly the same, including order, on both the encryption and decryption sides.
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, salt, iterations);
aes.Key = key.GetBytes(aes.KeySize / 8);
aes.IV = key.GetBytes(aes.BlockSize / 8);
aes.Mode = CipherMode.CBC;
ICryptoTransform transform = aes.CreateDecryptor(aes.Key, aes.IV);
using (FileStream destination = new FileStream(destinationFilename, FileMode.CreateNew, FileAccess.Write, FileShare.None))
{
using (CryptoStream cryptoStream = new CryptoStream(destination, transform, CryptoStreamMode.Write))
{
try
{
using (FileStream source = new FileStream(sourceFilename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
source.CopyTo(cryptoStream);
}
}
catch (CryptographicException exception)
{
if (exception.Message == "Padding is invalid and cannot be removed.")
throw new ApplicationException("Universal Microsoft Cryptographic Exception (Not to be believed!)", exception);
else
throw;
}
}
}
}
///<summary>Encrypt a file.</summary>
///<param name="sourceFilename">The full path and name of the file to be encrypted.</param>
///<param name="destinationFilename">The full path and name of the file to be output.</param>
///<param name="password">The password for the encryption.</param>
///<param name="salt">The salt to be applied to the password.</param>
///<param name="iterations">The number of iterations Rfc2898DeriveBytes should use before generating the key and initialization vector for the decryption.</param>
public void EncryptFile(string sourceFilename, string destinationFilename, string password, byte[] salt, int iterations)
{
AesManaged aes = new AesManaged();
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
//NB: Rfc2898DeriveBytes initialization and subsequent calls to   GetBytes   must be eactly the same, including order, on both the encryption and decryption sides.
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, salt, iterations);
aes.Key = key.GetBytes(aes.KeySize / 8);
aes.IV = key.GetBytes(aes.BlockSize / 8);
aes.Mode = CipherMode.CBC;
ICryptoTransform transform = aes.CreateEncryptor(aes.Key, aes.IV);
using (FileStream destination = new FileStream(destinationFilename, FileMode.CreateNew, FileAccess.Write, FileShare.None))
{
using (CryptoStream cryptoStream = new CryptoStream(destination, transform, CryptoStreamMode.Write))
{
using (FileStream source = new FileStream(sourceFilename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
source.CopyTo(cryptoStream);
}
}
}
}

Généralement la stratégie que vous avez décrit est utilisé lorsque les données seront cryptées sur une machine (comme un serveur), puis déchiffrées par un autre ordinateur (client). Le serveur crypte les données en utilisant le cryptage à clé symétrique (pour la performance) avec une nouvelle clé générée et chiffrer cette clé symétrique avec une clé publique (correspondant à un client clé privée). Le serveur envoie au client à la fois les données chiffrées et la clé symétrique chiffrée. Le client peut déchiffrer la clé symétrique avec sa clé privée, puis utiliser cette clé symétrique pour décrypter les données.
Si vous êtes de crypter et décrypter les données sur la même machine, il ne peut faire sens pour utiliser à la fois du RSA et AES que vous ne seriez pas en essayant de passer la clé de chiffrement à l'autre de la machine.