Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# AES-Verschlüsselung
.NET HILFE

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

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

AES (Advanced Encryption Standard) ist einer der am häufigsten verwendeten symmetrischen Verschlüsselungsalgorithmen. Es verwendet denselben Schlüssel, um Daten zu verschlüsseln und zu entschlüsseln, wodurch AES-Verschlüsselung effizient und schnell für die Sicherung sensibler Daten in vielen Anwendungen ist.

Dieses Tutorial konzentriert sich auf die AES-Verschlüsselung in C#, indem die AES-Klasse verwendet wird, um Daten zu verschlüsseln und zu entschlüsseln, sowie die IronPDF-Bibliothek. Wir werden praktische Beispiele behandeln, den Verschlüsselungsprozess durchgehen und sehen, wie der Cipher Block Chaining (CBC)-Modus zur Erhöhung der Sicherheit genutzt wird. Wir werden auch die Verwaltung von Verschlüsselungsschlüsseln und die Rolle des Initialisierungsvektors (IV) besprechen.

Introduction of AES Encryption in C#

Advanced Encryption Standard (AES) ist ein symmetrischer Verschlüsselungsalgorithmus, standardisiert vom National Institute of Standards and Technology (NIST). Der Algorithmus kann Schlüssellängen von 128, 192 oder 256 Bit haben und ist hochsicher für die Verschlüsselung vertraulicher Daten. Er verwendet denselben Schlüssel zum Verschlüsseln und Entschlüsseln.

AES arbeitet, indem die Originaldaten in Blöcke aufgeteilt und Transformationen auf diesen Blöcken angewendet werden. Es operiert in verschiedenen Chiffriermodi, wie CBC (Cipher Block Chaining) und Electronic CodeBook (ECB), die jeweils unterschiedliche Sicherheitsfunktionen bieten.

How AES Works in C#

Der AES-Verschlüsselungsalgorithmus in C# ist Teil des Namespace System.Security.Cryptography. Dieser Namespace enthält die AES-Klasse, die es uns ermöglicht, eine Instanz von AES zu erstellen, die Schlüsselgröße, den Chiffriermodus und den Auffüllmodus festzulegen und dann Daten unter Verwendung eines geheimen Schlüssels zu verschlüsseln und zu entschlüsseln.

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

  1. Erstellen Sie eine Instanz der AES-Klasse mit Aes.Create().
  2. Setzen Sie den Schlüssel, IV und andere relevante Parameter wie den Chiffriermodus.
  3. Verschlüsseln Sie die Daten mit der ICryptoTransform-Schnittstelle und schreiben Sie sie in einen MemoryStream.
  4. Entschlüsseln Sie die Daten mit demselben Schlüssel und IV.

Lassen Sie uns einen einfachen Verschlüsselungs- und Entschlüsselungsprozess 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;

    // Main method to demonstrate encryption and decryption
    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);
    }

    // Method to encrypt data
    public static string Encrypt(string plaintext, string key)
    {
        // Create a new instance of the AES encryption algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)

            // Create an encryptor to perform the stream transform
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

            // Create the streams used for encryption
            using (MemoryStream ms = new MemoryStream())
            {
                // Create a CryptoStream using the encryptor
                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);
            }
        }
    }

    // Method to decrypt data
    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)

            // Create a decryptor to perform the stream transform
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

            // Create the streams used for decryption
            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;

    // Main method to demonstrate encryption and decryption
    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);
    }

    // Method to encrypt data
    public static string Encrypt(string plaintext, string key)
    {
        // Create a new instance of the AES encryption algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)

            // Create an encryptor to perform the stream transform
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

            // Create the streams used for encryption
            using (MemoryStream ms = new MemoryStream())
            {
                // Create a CryptoStream using the encryptor
                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);
            }
        }
    }

    // Method to decrypt data
    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)

            // Create a decryptor to perform the stream transform
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

            // Create the streams used for decryption
            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();
                    }
                }
            }
        }
    }
}
$vbLabelText   $csharpLabel

C# AES-Verschlüsselung (Funktionsweise für Entwickler): Abbildung 1 - Ausgaben von Verschlüsselung und Entschlüsselung mit Memory Stream

Erläuterung des Codes

  1. 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. Er muss eine gültige Größe haben, wie z.B. 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 zur Vereinfachung einen IV von Nullen.
  4. MemoryStream: Dies ermöglicht es uns, mit den verschlüsselten Daten als Byte-Strom zu arbeiten.
  5. CryptoStream: Es transformiert den Datenstrom (Verschlüsselung oder Entschlüsselung).

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

Bauen wir auf dem vorherigen Beispiel auf, indem wir einen zufälligen Schlüssel und IV generieren, um sicherzustellen, dass die Verschlüsselung sicherer ist.

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

        // Randomly generate key and IV
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }

        // Create an encryptor to perform the stream transform
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

        // Create the streams used for encryption
        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

        // Randomly generate key and IV
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }

        // Create an encryptor to perform the stream transform
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

        // Create the streams used for encryption
        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());
        }
    }
}
$vbLabelText   $csharpLabel

In diesem Fall erzeugen wir jedes Mal, wenn die Funktion aufgerufen wird, einen neuen Schlüssel und einen neuen 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, um Daten zu verschlüsseln. In unseren Beispielen müssen derselbe Schlüssel und IV wie bei der Verschlüsselung bereitgestellt werden, um die Daten zu entschlüsseln. Der Entschlüsselungsprozess beinhaltet das Zurückverwandeln der verschlüsselten Daten in ihre ursprüngliche Form.

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;

        // Create a decryptor to perform the stream transform
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

        // Create the streams used for decryption
        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;

        // Create a decryptor to perform the stream transform
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

        // Create the streams used for decryption
        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();
                }
            }
        }
    }
}
$vbLabelText   $csharpLabel

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, die entwickelt wurde, um PDFs mit einfachem C#-Code zu erzeugen, zu bearbeiten und zu manipulieren. Es ermöglicht Entwicklern, PDF-Dokumente direkt aus HTML, CSS und JavaScript zu erstellen, was unglaublich nützlich sein kann, um Berichte, Rechnungen oder andere Dokumente dynamisch zu erstellen. Mit Funktionen zum Zusammenführen, Aufteilen und sogar zum Hinzufügen von Sicherheitsfunktionen wie Passwörtern oder digitalen Signaturen ist IronPDF eine umfassende Lösung für die PDF-Erstellung in .NET-Anwendungen.

Integration von IronPDF mit AES-Verschlüsselung

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

Wenn Sie sensible Berichte oder Dokumente erstellen, müssen Sie möglicherweise sicherstellen, dass die Daten in diesen PDFs vor dem Teilen verschlüsselt werden. AES (Advanced Encryption Standard)-Verschlüsselung ist eine perfekte Lösung, um die Inhalte von PDF-Dateien sicher zu verschlüsseln. Indem Sie IronPDF und AES-Verschlüsselung kombinieren, können Sie die Daten in Ihren PDFs schützen, während Sie die Möglichkeit zur Bearbeitung des Dokuments beibehalten.

Schritt 1: Erstellen einer PDF-Datei mit IronPDF

Verwenden Sie die ChromePdfRenderer-Klasse, um ein PDF aus HTML-Inhalten zu erstellen und es in eine 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");
$vbLabelText   $csharpLabel

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());
    }
}
$vbLabelText   $csharpLabel

Abschluss

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

Die Integration von IronPDF mit AES-Verschlüsselung ermöglicht es Ihnen, dynamische und sichere Dokumente zu erzeugen, die sowohl zugänglich als auch verschlüsselt sind. Egal, ob Sie sichere Dokumentenerstellung oder sensible Berichte verwalten, IronPDF mit starker Verschlüsselung schützt Ihre Daten. IronPDF vereinfacht die Arbeit mit PDFs, während AES garantiert, dass die Inhalte sicher bleiben.

IronPDF bietet eine kostenlose Testversion, die es Entwicklern leicht macht, seine Funktionen zu erkunden, bevor sie sich entscheiden. Wenn Sie bereit sind, IronPDF in Ihre Projekte zu integrieren, beginnen die Lizenzen bei $799 für einen einmaligen Kauf.

Häufig gestellte Fragen

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Sie können auch HTML-Dateien mit RenderHtmlFileAsPdf in PDFs konvertieren.

Was ist AES-Verschlüsselung und wie wird sie in C# verwendet?

AES (Advanced Encryption Standard) ist ein symmetrischer Verschlüsselungsalgorithmus zur Sicherung von Daten. In C# wird die AES-Verschlüsselung mit der AES-Klasse aus dem Namespace System.Security.Cryptography implementiert. Sie erstellen eine AES-Instanz, setzen die Schlüssel- und IV-Parameter und verwenden die ICryptoTransform-Schnittstelle zur Verschlüsselung und Entschlüsselung von Daten.

Welche Vorteile bietet der Cipher Block Chaining (CBC)-Modus bei der AES-Verschlüsselung?

Der Cipher Block Chaining (CBC)-Modus erhöht die Sicherheit, indem er sicherstellt, dass identische Klartextblöcke unterschiedliche Chiffretextblöcke erzeugen. Dies wird durch die Verwendung eines Initialisierungsvektors (IV) zur Verknüpfung der Blockverschlüsselungen erreicht.

Wie kann ich ein PDF-Dokument mit AES in C# verschlüsseln?

Um ein PDF mit AES in C# zu verschlüsseln, kann man IronPDF verwenden, um die PDF-Datei zu bearbeiten und dann die AES-Verschlüsselung anwenden, indem man die PDF-Bytes mit einem angegebenen Schlüssel und IV verschlüsselt, bevor man die verschlüsselten Daten in eine neue Datei schreibt.

Welche Schritte sind erforderlich, um AES-Verschlüsselung in einer C#-Anwendung zu implementieren?

Um AES-Verschlüsselung in C# zu implementieren, müssen Sie eine AES-Instanz erstellen, den Schlüssel und IV festlegen, einen Verschlüsseler erstellen und MemoryStream sowie CryptoStream verwenden, um die Daten zu transformieren.

Kann ich einen benutzerdefinierten Schlüssel und IV für AES in C# verwenden?

Ja, bei der AES-Verschlüsselung können Sie einen benutzerdefinierten Schlüssel und IV angeben, um die Sicherheit zu erhöhen. Es wird empfohlen, für jede Verschlüsselungssitzung zufällige Werte zu generieren, um den Schutz zu verbessern.

Wie können Entwickler die Sicherheit von PDF-Dokumenten in C# verbessern?

Entwickler können IronPDF in Kombination mit der AES-Verschlüsselung verwenden, um die Sicherheit von PDF-Dokumenten in C# zu verbessern, wodurch das Erstellen, Bearbeiten und Sichern von PDFs, einschließlich dem Hinzufügen von Passwörtern und digitalen Signaturen, ermöglicht wird.

Wie hilft IronPDF beim Sichern von PDF-Inhalten vor der Freigabe?

IronPDF hilft beim Sichern von PDF-Inhalten vor der Freigabe, indem es Entwicklern ermöglicht, PDFs mit AES zu verschlüsseln. Dieser Prozess umfasst das Generieren, Bearbeiten und Manipulieren von PDF-Dateien mit Verschlüsselungsmethoden, um den Datenschutz zu gewährleisten.

Warum ist Schlüsselverwaltung bei der AES-Verschlüsselung wichtig?

Die Schlüsselverwaltung ist bei der AES-Verschlüsselung entscheidend, da die Sicherheit der verschlüsselten Daten stark von der Geheimhaltung und Stärke des Verschlüsselungsschlüssels abhängt. Eine ordnungsgemäße Verwaltung verhindert unbefugten Zugriff.

Was sind die Hauptmerkmale der IronPDF-Bibliothek für C#-Entwickler?

Die IronPDF-Bibliothek ermöglicht es C#-Entwicklern, einfach PDF-Dokumente zu erstellen, zu bearbeiten und zu manipulieren. Sie unterstützt Funktionen wie das Zusammenführen, Aufteilen und Sichern von PDFs mit Verschlüsselung und verbessert die Dokumentenverwaltung und -sicherheit.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me