.NET Framework
Verschlüsselung / Kryptographie
Suche…
Bemerkungen
.NET Framework bietet die Implementierung vieler kryptografischer Algorithmen. Sie umfassen im Wesentlichen symmetrische Algorithmen, asymmetrische Algorithmen und Hashes.
RijndaelManaged
Erforderlicher Namensraum: System.Security.Cryptography
private class Encryption {
private const string SecretKey = "topSecretKeyusedforEncryptions";
private const string SecretIv = "secretVectorHere";
public string Encrypt(string data) {
return string.IsNullOrEmpty(data) ? data : Convert.ToBase64String(this.EncryptStringToBytesAes(data, this.GetCryptographyKey(), this.GetCryptographyIv()));
}
public string Decrypt(string data) {
return string.IsNullOrEmpty(data) ? data : this.DecryptStringFromBytesAes(Convert.FromBase64String(data), this.GetCryptographyKey(), this.GetCryptographyIv());
}
private byte[] GetCryptographyKey() {
return Encoding.ASCII.GetBytes(SecretKey.Replace('e', '!'));
}
private byte[] GetCryptographyIv() {
return Encoding.ASCII.GetBytes(SecretIv.Replace('r', '!'));
}
private byte[] EncryptStringToBytesAes(string plainText, byte[] key, byte[] iv) {
MemoryStream encrypt;
RijndaelManaged aesAlg = null;
try {
aesAlg = new RijndaelManaged {
Key = key,
IV = iv
};
var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
encrypt = new MemoryStream();
using (var csEncrypt = new CryptoStream(encrypt, encryptor, CryptoStreamMode.Write)) {
using (var swEncrypt = new StreamWriter(csEncrypt)) {
swEncrypt.Write(plainText);
}
}
} finally {
aesAlg?.Clear();
}
return encrypt.ToArray();
}
private string DecryptStringFromBytesAes(byte[] cipherText, byte[] key, byte[] iv) {
RijndaelManaged aesAlg = null;
string plaintext;
try {
aesAlg = new RijndaelManaged {
Key = key,
IV = iv
};
var decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (var msDecrypt = new MemoryStream(cipherText)) {
using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) {
using (var srDecrypt = new StreamReader(csDecrypt))
plaintext = srDecrypt.ReadToEnd();
}
}
} finally {
aesAlg?.Clear();
}
return plaintext;
}
}
Verwendungszweck
var textToEncrypt = "hello World";
var encrypted = new Encryption().Encrypt(textToEncrypt); //-> zBmW+FUxOvdbpOGm9Ss/vQ==
var decrypted = new Encryption().Decrypt(encrypted); //-> hello World
Hinweis:
- Rijndael ist der Vorgänger des standardmäßigen symmetrischen kryptographischen Algorithmus AES.
Daten mit AES verschlüsseln und entschlüsseln (in C #)
using System;
using System.IO;
using System.Security.Cryptography;
namespace Aes_Example
{
class AesExample
{
public static void Main()
{
try
{
string original = "Here is some data to encrypt!";
// Create a new instance of the Aes class.
// This generates a new key and initialization vector (IV).
using (Aes myAes = Aes.Create())
{
// Encrypt the string to an array of bytes.
byte[] encrypted = EncryptStringToBytes_Aes(original,
myAes.Key,
myAes.IV);
// Decrypt the bytes to a string.
string roundtrip = DecryptStringFromBytes_Aes(encrypted,
myAes.Key,
myAes.IV);
//Display the original data and the decrypted data.
Console.WriteLine("Original: {0}", original);
Console.WriteLine("Round Trip: {0}", roundtrip);
}
}
catch (Exception e)
{
Console.WriteLine("Error: {0}", e.Message);
}
}
static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
{
// Check arguments.
if (plainText == null || plainText.Length <= 0)
throw new ArgumentNullException("plainText");
if (Key == null || Key.Length <= 0)
throw new ArgumentNullException("Key");
if (IV == null || IV.Length <= 0)
throw new ArgumentNullException("IV");
byte[] encrypted;
// Create an Aes object with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
// Create a decrytor to perform the stream transform.
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key,
aesAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt,
encryptor,
CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream.
return encrypted;
}
static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
{
// Check arguments.
if (cipherText == null || cipherText.Length <= 0)
throw new ArgumentNullException("cipherText");
if (Key == null || Key.Length <= 0)
throw new ArgumentNullException("Key");
if (IV == null || IV.Length <= 0)
throw new ArgumentNullException("IV");
// Declare the string used to hold the decrypted text.
string plaintext = null;
// Create an Aes object with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key,
aesAlg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt,
decryptor,
CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return plaintext;
}
}
}
Dieses Beispiel stammt von MSDN .
Es ist eine Konsolen-Demoanwendung, die zeigt, wie eine Zeichenfolge mit der Standard- AES- Verschlüsselung verschlüsselt und anschließend entschlüsselt wird.
( AES = Advanced Encryption Standard , eine Spezifikation, die 2001 vom US-amerikanischen National Institute of Standards und Technology (NIST) für die Verschlüsselung elektronischer Daten festgelegt wurde und nach wie vor der De-facto-Standard für symmetrische Verschlüsselung ist.)
Anmerkungen:
In einem echten Verschlüsselungsszenario müssen Sie einen geeigneten Verschlüsselungsmodus auswählen (kann der Eigenschaft
Modezugewiesen werden, indem Sie einen Wert aus derCipherModeEnumerationCipherMode). VerwendenCipherMode.ECBniemalsCipherMode.ECB(Electronic Codebook-Modus), da dies einen schwachen Chiffrestream hervorruftUm einen guten (und nicht einen schwachen)
Keyzu erstellen, verwenden Sie entweder einen kryptographischen Zufallsgenerator oder das obige Beispiel ( Erstellen eines Schlüssels aus einem Kennwort ). Die empfohlene Schlüsselgröße ist 256 Bit. Unterstützte Schlüsselgrößen sind über dieLegalKeySizesEigenschaft verfügbar.Um den Initialisierungsvektor
IVzu initialisieren, können Sie ein SALT verwenden, wie im obigen Beispiel gezeigt ( Random SALT ).Unterstützte Blockgrößen sind über die Eigenschaft
SupportedBlockSizesverfügbar. Die Blockgröße kann über die EigenschaftBlockSizezugewiesen werden
Verwendung: siehe Main () - Methode.
Erstellen eines Schlüssels aus einem Passwort / zufälligem SALT (in C #)
using System;
using System.Security.Cryptography;
using System.Text;
public class PasswordDerivedBytesExample
{
public static void Main(String[] args)
{
// Get a password from the user.
Console.WriteLine("Enter a password to produce a key:");
byte[] pwd = Encoding.Unicode.GetBytes(Console.ReadLine());
byte[] salt = CreateRandomSalt(7);
// Create a TripleDESCryptoServiceProvider object.
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
try
{
Console.WriteLine("Creating a key with PasswordDeriveBytes...");
// Create a PasswordDeriveBytes object and then create
// a TripleDES key from the password and salt.
PasswordDeriveBytes pdb = new PasswordDeriveBytes(pwd, salt);
// Create the key and set it to the Key property
// of the TripleDESCryptoServiceProvider object.
tdes.Key = pdb.CryptDeriveKey("TripleDES", "SHA1", 192, tdes.IV);
Console.WriteLine("Operation complete.");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
// Clear the buffers
ClearBytes(pwd);
ClearBytes(salt);
// Clear the key.
tdes.Clear();
}
Console.ReadLine();
}
#region Helper methods
/// <summary>
/// Generates a random salt value of the specified length.
/// </summary>
public static byte[] CreateRandomSalt(int length)
{
// Create a buffer
byte[] randBytes;
if (length >= 1)
{
randBytes = new byte[length];
}
else
{
randBytes = new byte[1];
}
// Create a new RNGCryptoServiceProvider.
RNGCryptoServiceProvider rand = new RNGCryptoServiceProvider();
// Fill the buffer with random bytes.
rand.GetBytes(randBytes);
// return the bytes.
return randBytes;
}
/// <summary>
/// Clear the bytes in a buffer so they can't later be read from memory.
/// </summary>
public static void ClearBytes(byte[] buffer)
{
// Check arguments.
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
// Set each byte in the buffer to 0.
for (int x = 0; x < buffer.Length; x++)
{
buffer[x] = 0;
}
}
#endregion
}
Dieses Beispiel stammt aus MSDN.
Es ist eine Konsolen-Demo. Sie zeigt, wie Sie einen sicheren Schlüssel basierend auf einem benutzerdefinierten Kennwort erstellen und ein zufälliges SALT basierend auf dem kryptografischen Zufallsgenerator erstellen.
Anmerkungen:
Die integrierte Funktion
PasswordDeriveBytesverwendet den Standard-PBKDF1-Algorithmus, um einen Schlüssel aus dem Kennwort zu generieren. Standardmäßig werden 100 Iterationen verwendet, um den Schlüssel zu generieren, um Brute-Force-Angriffe zu verlangsamen. Das zufällig erzeugte SALT verstärkt den Schlüssel weiter.Die Funktion
CryptDeriveKeykonvertiert den vonPasswordDeriveBytesgenerierten Schlüssel in einen mit dem angegebenen Verschlüsselungsalgorithmus (hier "TripleDES") kompatiblen Schlüssel, indem der angegebene Hash-Algorithmus (hier "SHA1") verwendet wird. Die Schlüsselgröße beträgt in diesem Beispiel 192 Bytes, und der Initialisierungsvektor IV wird vom Triple-DES-Krypto-Provider übernommenNormalerweise wird dieser Mechanismus verwendet, um einen stärker zufällig generierten Schlüssel durch ein Kennwort zu schützen, das große Datenmengen verschlüsselt. Sie können es auch verwenden, um mehrere Passwörter verschiedener Benutzer bereitzustellen, um Zugriff auf dieselben Daten zu gewähren (die durch einen anderen Zufallsschlüssel geschützt werden).
Leider unterstützt
CryptDeriveKeyderzeit kein AES. Sehen Sie hier.
HINWEIS: Zur Problemumgehung können Sie einen zufälligen AES-Schlüssel zur Verschlüsselung der mit AES zu schützenden Daten erstellen und den AES-Schlüssel in einem TripleDES-Container speichern, der den vonCryptDeriveKeygenerierten SchlüsselCryptDeriveKey. Dies beschränkt jedoch die Sicherheit auf TripleDES, nutzt die größeren Schlüsselgrößen von AES nicht und schafft eine Abhängigkeit von TripleDES.
Verwendung: Siehe Main () - Methode.
Verschlüsselung und Entschlüsselung mittels Kryptographie (AES)
Entschlüsselungscode
public static string Decrypt(string cipherText)
{
if (cipherText == null)
return null;
byte[] cipherBytes = Convert.FromBase64String(cipherText);
using (Aes encryptor = Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(CryptKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(cipherBytes, 0, cipherBytes.Length);
cs.Close();
}
cipherText = Encoding.Unicode.GetString(ms.ToArray());
}
}
return cipherText;
}
Verschlüsselungscode
public static string Encrypt(string cipherText)
{
if (cipherText == null)
return null;
byte[] clearBytes = Encoding.Unicode.GetBytes(cipherText);
using (Aes encryptor = Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(CryptKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(clearBytes, 0, clearBytes.Length);
cs.Close();
}
cipherText = Convert.ToBase64String(ms.ToArray());
}
}
return cipherText;
}
Verwendungszweck
var textToEncrypt = "TestEncrypt";
var encrypted = Encrypt(textToEncrypt);
var decrypted = Decrypt(encrypted);