C# AES-Verschlüsselung (Wie es für Entwickler funktioniert)

AES (Advanced Encryption Standard) ist einer der am häufigsten verwendeten symmetrischen Verschlüsselungsalgorithmen. Es wird derselbe Schlüssel zum Ver- und Entschlüsseln von Daten verwendet, was die AES-Verschlüsselung effizient und schnell macht, um sensible Daten in vielen Anwendungen zu schützen.

Dieses Tutorial konzentriert sich auf AES-Verschlüsselung in C#, indem die AES-Klasse zum Verschlüsseln und Entschlüsseln von Daten und die IronPDF Library verwendet wird. Wir werden praktische Beispiele behandeln, den Verschlüsselungsprozess durchgehen und sehen, wie man den Cipher Block Chaining (CBC) Modus verwendet, um die Sicherheit zu erhöhen. Wir werden auch die Verwaltung von Verschlüsselungsschlüsseln und die Rolle des Initialisierungsvektors (IV) besprechen.

Einführung in die AES-Verschlüsselung in C#;

Advanced Encryption Standard (AES) ist ein symmetrischer Verschlüsselungsalgorithmus, der vom National Institute of Standards and Technology (NIST) standardisiert wurde. Der Algorithmus kann Schlüsselgrößen von 128, 192 oder 256 Bit haben und ist hochsicher für die Verschlüsselung vertraulicher Daten. Zum Ver- und Entschlüsseln von Daten wird derselbe Verschlüsselungscode verwendet.

AES funktioniert, indem es die Originaldaten in Blöcke aufteilt und auf diese Blöcke Transformationen anwendet. Es arbeitet in verschiedenen Chiffriermodi, wie CBC (Cipher Block Chaining) und Electronic CodeBook (ECB), die jeweils unterschiedliche Sicherheitsmerkmale bieten.

Die Funktionsweise von AES in C#

Der AES-Verschlüsselungsalgorithmus in C# ist Teil des Namespace System.Security.Cryptography. Dieser Namespace enthält die AES-Klasse, mit der wir eine Instanz von AES erstellen, die Schlüsselgröße, den Verschlüsselungsmodus und den Auffüllmodus angeben und dann Daten mit einem geheimen Schlüssel ver- und entschlüsseln können.

Um AES in C# zu verwenden, befolgen Sie diese grundlegenden Schritte:

1. Erstellen Sie eine Instanz der AES-Klasse mit Aes.Create().

2. Legen Sie den Schlüssel, den IV und andere relevante Parameter wie den Verschlüsselungsmodus fest.

3. Verschlüsseln Sie die Daten mithilfe der Schnittstelle ICryptoTransform und schreiben Sie sie in einen MemoryStream.

4. Entschlüsseln Sie die Daten mit demselben Schlüssel und IV.

   Lassen Sie uns ein einfaches Verschlüsselungs- und Entschlüsselungsprogramm in C# erstellen.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
class Program
{
    // Declare a static byte array for encrypted data
    public static byte[] encryptedData;
    // static void Main
    public static void Main(string[] args)
    {
        // string plaintext to be encrypted
        string plaintext = "This is some sensitive data!";
        string key = "abcdefghijklmnop"; // 128-bit key (16 characters)
        // Encrypt the plaintext
        string ciphertext = Encrypt(plaintext, key);
        Console.WriteLine("Encrypted Data: " + ciphertext);
        // Decrypt the ciphertext
        string decryptedData = Decrypt(ciphertext, key);
        Console.WriteLine("Decrypted Data: " + decryptedData);
    }
    public static string Encrypt(string plaintext, string key)
    {
        // AES algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cs))
                    {
                        sw.Write(plaintext);
                    }
                }
                // Store the encrypted data in the public static byte array
                encryptedData = ms.ToArray();
                return Convert.ToBase64String(encryptedData);
            }
        }
    }
    public static string Decrypt(string ciphertext, string key)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader sr = new StreamReader(cs))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }
    }
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
class Program
{
    // Declare a static byte array for encrypted data
    public static byte[] encryptedData;
    // static void Main
    public static void Main(string[] args)
    {
        // string plaintext to be encrypted
        string plaintext = "This is some sensitive data!";
        string key = "abcdefghijklmnop"; // 128-bit key (16 characters)
        // Encrypt the plaintext
        string ciphertext = Encrypt(plaintext, key);
        Console.WriteLine("Encrypted Data: " + ciphertext);
        // Decrypt the ciphertext
        string decryptedData = Decrypt(ciphertext, key);
        Console.WriteLine("Decrypted Data: " + decryptedData);
    }
    public static string Encrypt(string plaintext, string key)
    {
        // AES algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cs))
                    {
                        sw.Write(plaintext);
                    }
                }
                // Store the encrypted data in the public static byte array
                encryptedData = ms.ToArray();
                return Convert.ToBase64String(encryptedData);
            }
        }
    }
    public static string Decrypt(string ciphertext, string key)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader sr = new StreamReader(cs))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }
    }
}

Imports System
Imports System.IO
Imports System.Security.Cryptography
Imports System.Text
Friend Class Program
	' Declare a static byte array for encrypted data
	Public Shared encryptedData() As Byte
	' static void Main
	Public Shared Sub Main(ByVal args() As String)
		' string plaintext to be encrypted
		Dim plaintext As String = "This is some sensitive data!"
		Dim key As String = "abcdefghijklmnop" ' 128-bit key (16 characters)
		' Encrypt the plaintext
		Dim ciphertext As String = Encrypt(plaintext, key)
		Console.WriteLine("Encrypted Data: " & ciphertext)
		' Decrypt the ciphertext
		Dim decryptedData As String = Decrypt(ciphertext, key)
		Console.WriteLine("Decrypted Data: " & decryptedData)
	End Sub
	Public Shared Function Encrypt(ByVal plaintext As String, ByVal key As String) As String
		' AES algorithm
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)
			Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)
			Using ms As New MemoryStream()
				Using cs As New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
					Using sw As New StreamWriter(cs)
						sw.Write(plaintext)
					End Using
				End Using
				' Store the encrypted data in the public static byte array
				encryptedData = ms.ToArray()
				Return Convert.ToBase64String(encryptedData)
			End Using
		End Using
	End Function
	Public Shared Function Decrypt(ByVal ciphertext As String, ByVal key As String) As String
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)
			Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)
			Using ms As New MemoryStream(Convert.FromBase64String(ciphertext))
				Using cs As New CryptoStream(ms, decryptor, CryptoStreamMode.Read)
					Using sr As New StreamReader(cs)
						Return sr.ReadToEnd()
					End Using
				End Using
			End Using
		End Using
	End Function
End Class

Erläuterung des Codes

1. Aes aes = Aes.Create(): Dies erstellt eine neue Instanz des AES-Verschlüsselungsalgorithmus.

2. Aes.Key: Der Schlüssel, der sowohl für die Verschlüsselung als auch für die Entschlüsselung verwendet wird. Es muss eine gültige Größe haben, wie zum Beispiel 128 Bit (16 Bytes), 192 Bit oder 256 Bit.

3. Aes.IV: Der Initialisierungsvektor (IV) wird verwendet, um den Verschlüsselungsprozess zu randomisieren. In diesem Beispiel verwenden wir der Einfachheit halber eine IV mit Nullen.

4. MemoryStream: Damit können wir mit den verschlüsselten Daten als Byte-Stream arbeiten.

5. CryptoStream: Es transformiert den Datenstrom (Verschlüsselung oder Entschlüsselung).

Fortgeschrittenes Beispiel: AES-Verschlüsselung mit benutzerdefiniertem Schlüssel und IV

Lassen Sie uns auf dem vorherigen Beispiel aufbauen, indem wir einen zufälligen Schlüssel und eine IV generieren, um die Verschlüsselung sicherer zu machen.

public static string EncryptData(string plaintext)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = new byte[32]; // AES-256 requires a 256-bit key (32 bytes)
        aes.IV = new byte[16];  // 128-bit block size
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream())
        {
            using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                using (StreamWriter sw = new StreamWriter(cs))
                {
                    sw.Write(plaintext);
                }
            }
            return Convert.ToBase64String(ms.ToArray());
        }
    }
}

public static string EncryptData(string plaintext)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = new byte[32]; // AES-256 requires a 256-bit key (32 bytes)
        aes.IV = new byte[16];  // 128-bit block size
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream())
        {
            using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                using (StreamWriter sw = new StreamWriter(cs))
                {
                    sw.Write(plaintext);
                }
            }
            return Convert.ToBase64String(ms.ToArray());
        }
    }
}

Public Shared Function EncryptData(ByVal plaintext As String) As String
	Using aes As Aes = Aes.Create()
		aes.Key = New Byte(31){} ' AES-256 requires a 256-bit key (32 bytes)
		aes.IV = New Byte(15){} ' 128-bit block size
		Using rng As RandomNumberGenerator = RandomNumberGenerator.Create()
			rng.GetBytes(aes.Key) ' Generate a random key
			rng.GetBytes(aes.IV) ' Generate a random IV
		End Using
		Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)
		Using ms As New MemoryStream()
			Using cs As New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
				Using sw As New StreamWriter(cs)
					sw.Write(plaintext)
				End Using
			End Using
			Return Convert.ToBase64String(ms.ToArray())
		End Using
	End Using
End Function

In diesem Fall erzeugen wir bei jedem Aufruf der Funktion einen neuen Schlüssel und eine IV. Dies bietet eine robustere Verschlüsselung, da der gleiche Schlüssel nicht für jede Operation verwendet wird. AES unterstützt Schlüssellängen wie 128, 192 und 256 Bit.

Daten mit AES entschlüsseln

Die Entschlüsselung ist der umgekehrte Prozess zur Verschlüsselung von Daten. In unseren Beispielen müssen für die Entschlüsselung der Daten derselbe Schlüssel und dieselbe IV wie für die Verschlüsselung verwendet werden. Bei der Entschlüsselung werden die verschlüsselten Daten wieder in ihre ursprüngliche Form zurückverwandelt.

Hier ist ein Beispiel, das die zuvor verschlüsselten Daten verwendet:

public static string DecryptData(string ciphertext, byte[] key, byte[] iv)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.IV = iv;
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
        {
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                using (StreamReader sr = new StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}

public static string DecryptData(string ciphertext, byte[] key, byte[] iv)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.IV = iv;
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
        {
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                using (StreamReader sr = new StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}

Public Shared Function DecryptData(ByVal ciphertext As String, ByVal key() As Byte, ByVal iv() As Byte) As String
	Using aes As Aes = Aes.Create()
		aes.Key = key
		aes.IV = iv
		Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)
		Using ms As New MemoryStream(Convert.FromBase64String(ciphertext))
			Using cs As New CryptoStream(ms, decryptor, CryptoStreamMode.Read)
				Using sr As New StreamReader(cs)
					Return sr.ReadToEnd()
				End Using
			End Using
		End Using
	End Using
End Function

Dieser Code entschlüsselt die verschlüsselten Daten zurück in die ursprünglichen Daten.

IronPDF mit AES-Verschlüsselung

IronPDF ist eine einfache und entwicklerfreundliche .NET-Bibliothek zum Erzeugen, Bearbeiten und Manipulieren von PDFs mit einfachem C#-Code. Es ermöglicht Entwicklern, PDF-Dokumente direkt aus HTML, CSS und JavaScript zu erstellen, was unglaublich nützlich für das dynamische Erstellen von Berichten, Rechnungen oder anderen Dokumenten sein kann. IronPDF unterstützt das Zusammenführen, Aufteilen und sogar das Hinzufügen von Sicherheitsfunktionen wie Passwörtern oder digitalen Signaturen und ist damit eine umfassende Lösung für die PDF-Erzeugung in .NET-Anwendungen.

Integration von IronPDF mit AES-Verschlüsselung

Wenn Sie sensible Berichte oder Dokumente erstellen, müssen Sie möglicherweise sicherstellen, dass die Daten in diesen PDFs vor der Weitergabe verschlüsselt werden. AES (Advanced Encryption Standard) Verschlüsselung ist eine perfekte Lösung für die sichere Verschlüsselung der Inhalte von PDF-Dateien. Durch die Kombination von IronPDF und AES-Verschlüsselung können Sie die Daten in Ihren PDFs schützen und gleichzeitig die Möglichkeit haben, mit dem Dokument selbst zu arbeiten.

Schritt 1: Erstellen einer PDF-Datei mit IronPDF

Verwenden Sie die ChromePdfRenderer-Klasse, um ein PDF aus HTML-Inhalten zu erstellen und in einer Datei zu speichern:

var htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(@"C:\Reports\ConfidentialReport.pdf");

var htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(@"C:\Reports\ConfidentialReport.pdf");

Dim htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("C:\Reports\ConfidentialReport.pdf")

Schritt 2: Verschlüsseln der PDF-Datei mit AES

Sobald das PDF erstellt ist, verschlüsseln Sie es mit AES:

byte[] pdfBytes = File.ReadAllBytes(@"C:\Reports\ConfidentialReport.pdf");
using (Aes aes = Aes.Create())
{
    aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop");
    aes.IV = new byte[16];
    using (var encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
    using (var ms = new MemoryStream())
    {
        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
            cs.Write(pdfBytes, 0, pdfBytes.Length);
        }
        File.WriteAllBytes(@"C:\Reports\ConfidentialReport.encrypted", ms.ToArray());
    }
}

byte[] pdfBytes = File.ReadAllBytes(@"C:\Reports\ConfidentialReport.pdf");
using (Aes aes = Aes.Create())
{
    aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop");
    aes.IV = new byte[16];
    using (var encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
    using (var ms = new MemoryStream())
    {
        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
            cs.Write(pdfBytes, 0, pdfBytes.Length);
        }
        File.WriteAllBytes(@"C:\Reports\ConfidentialReport.encrypted", ms.ToArray());
    }
}

Dim pdfBytes() As Byte = File.ReadAllBytes("C:\Reports\ConfidentialReport.pdf")
Using aes As Aes = Aes.Create()
	aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop")
	aes.IV = New Byte(15){}
	Using encryptor = aes.CreateEncryptor(aes.Key, aes.IV)
	Using ms = New MemoryStream()
		Using cs = New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
			cs.Write(pdfBytes, 0, pdfBytes.Length)
		End Using
		File.WriteAllBytes("C:\Reports\ConfidentialReport.encrypted", ms.ToArray())
	End Using
	End Using
End Using

Schlussfolgerung

Durch die Integration von IronPDF mit AES-Verschlüsselung können Sie dynamische, sichere Dokumente erstellen, die sowohl zugänglich als auch verschlüsselt sind. Ob bei der Entwicklung von Anwendungen, die eine sichere Dokumentenerstellung erfordern, oder bei der Verwaltung sensibler Berichte, die Kombination von IronPDF mit solider Verschlüsselung schützt Ihre Daten. IronPDF vereinfacht die Arbeit mit PDFs, während AES die Sicherheit der Inhalte garantiert.

IronPDF bietet eine kostenlose Testversion, die es Entwicklern erleichtert, die Funktionen zu erkunden, bevor sie sich festlegen. Wenn Sie bereit sind, IronPDF in Ihre Projekte zu integrieren, beginnen die Lizenzen ab $749 für einen einmaligen Kauf.