.NET-HILFE

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

Veröffentlicht 23. Oktober 2024

Teilen Sie:

AES(Erweiterter Verschlüsselungsstandard) 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 die AES-Verschlüsselung in C#, die Verwendung der AES-Klasse zum Ver- und Entschlüsseln von Daten undIronPDF-Bibliothek. Wir werden praktische Beispiele behandeln, den Verschlüsselungsprozess durchlaufen und sehen, wie man Cipher Block Chaining verwendet(CBC) modus zur Erhöhung der Sicherheit. Wir werden auch die Verwaltung von Verschlüsselungsschlüsseln und die Rolle des Initialisierungsvektors diskutieren(IV).

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

Erweiterter Verschlüsselungsstandard(AES) ist ein symmetrischer Verschlüsselungsalgorithmus, der vom National Institute of Standards and Technology standardisiert wurde(NIST). 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 mit verschiedenen Verschlüsselungsmodi, wie z. B. CBC(Cipher Block Chaining) und Elektronisches Codebuch(ECB)sie bieten jeweils unterschiedliche Sicherheitsfunktionen.

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:

Erstellen Sie eine Instanz der AES-Klasse mit Aes.Create().
Legen Sie den Schlüssel, den IV und andere relevante Parameter wie den Verschlüsselungsmodus fest.
Verschlüsseln Sie die Daten mithilfe der Schnittstelle ICryptoTransform und schreiben Sie sie in einen MemoryStream.
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

VB C#

C# AES-Verschlüsselung (Wie es für Entwickler funktioniert): Abbildung 1 - Verschlüsselungs- und Entschlüsselungsausgabe mit Memory Stream

Erläuterung des Codes

Aes aes = Aes.Create(): Dies erzeugt eine neue Instanz des AES-Verschlüsselungsalgorithmus.
Aes.Key: Der Schlüssel, der sowohl für die Verschlüsselung als auch für die Entschlüsselung verwendet wird. Sie muss eine gültige Größe haben, z. B. 128 Bit(16 Bytes), 192 Bit oder 256 Bit.
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.
MemoryStream: Damit können wir mit den verschlüsselten Daten als Bytestrom arbeiten.
CryptoStream: Es wandelt den Datenstrom um(verschlüsselung oder Entschlüsselung).

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

Bauen wir auf dem vorherigen Beispiel auf, indem wir einen Zufallsschlüssel und 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

VB C#

In diesem Fall erzeugen wir bei jedem Funktionsaufruf einen neuen Schlüssel und IV. Dies bietet eine robustere Verschlüsselung, da der gleiche Schlüssel für jeden Vorgang nicht verwendet wird. AES unterstützt Schlüsselgrößen wie 128, 192 und 256 Bit.

Daten mit AES entschlüsseln

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

VB C#

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

IronPDF mit AES-Verschlüsselung

IronPDF ist eine einfache und entwicklerfreundliche .NET-Bibliothek zum Erzeugen, Bearbeiten und Manipulieren von PDFs mit einfachem C#-Code. Sie ermöglicht es EntwicklernpDF-Dokumente direkt aus HTML erstellendie Übersetzung muss die Funktionen von .NET, CSS und JavaScript enthalten, die bei der dynamischen Erstellung von Berichten, Rechnungen oder anderen Dokumenten von großem Nutzen sein können. 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

C# AES-Verschlüsselung (Wie sie für Entwickler funktioniert): Abbildung 2 - IronPDF

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(Erweiterter Verschlüsselungsstandard) encryption ist eine perfekte Lösung, um den Inhalt von PDF-Dateien sicher zu verschlüsseln. 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 Klasse ChromePdfRenderer, um ein PDF aus HTML-Inhalten zu erzeugen 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")

VB C#

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

Sobald die PDF-Datei erstellt ist, verschlüsseln Sie sie 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

VB C#

Schlussfolgerung

C# AES-Verschlüsselung (Wie es für Entwickler funktioniert): Abbildung 3 - Lizenzierung

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 einekostenloser Testsie soll es den Entwicklern leicht machen, 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.

< PREVIOUS
C# try catch finally (Wie es für Entwickler funktioniert)

NÄCHSTES >
C# HttpClient (Wie es für Entwickler funktioniert)