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.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

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

Jacob Mellor

Updated: 21. April 2026

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:

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

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

	' Main method to demonstrate encryption and decryption
	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

	' Method to encrypt data
	Public Shared Function Encrypt(ByVal plaintext As String, ByVal key As String) As String
		' Create a new instance of the AES encryption algorithm
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)

			' Create an encryptor to perform the stream transform
			Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)

			' Create the streams used for encryption
			Using ms As New MemoryStream()
				' Create a CryptoStream using the encryptor
				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

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

			' Create a decryptor to perform the stream transform
			Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)

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

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

	' Main method to demonstrate encryption and decryption
	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

	' Method to encrypt data
	Public Shared Function Encrypt(ByVal plaintext As String, ByVal key As String) As String
		' Create a new instance of the AES encryption algorithm
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)

			' Create an encryptor to perform the stream transform
			Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)

			' Create the streams used for encryption
			Using ms As New MemoryStream()
				' Create a CryptoStream using the encryptor
				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

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

			' Create a decryptor to perform the stream transform
			Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)

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

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

Erläuterung des Codes

Aes.Create(): Dies erstellt eine neue Instanz des AES-Verschlüsselungsalgorithmus.
aes.Key: Der Schlüssel, der sowohl für Verschlüsselung als auch für Entschlüsselung verwendet wird. Er muss eine gültige Größe haben, wie 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 zur Vereinfachung einen IV von Nullen.
MemoryStream: Dies ermöglicht es uns, mit den verschlüsselten Daten als Byte-Stream zu arbeiten.
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());
        }
    }
}

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

		' Randomly generate key and IV
		Using rng As RandomNumberGenerator = RandomNumberGenerator.Create()
			rng.GetBytes(aes.Key) ' Generate a random key
			rng.GetBytes(aes.IV) ' Generate a random IV
		End Using

		' Create an encryptor to perform the stream transform
		Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)

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

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

		' Randomly generate key and IV
		Using rng As RandomNumberGenerator = RandomNumberGenerator.Create()
			rng.GetBytes(aes.Key) ' Generate a random key
			rng.GetBytes(aes.IV) ' Generate a random IV
		End Using

		' Create an encryptor to perform the stream transform
		Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)

		' Create the streams used for encryption
		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 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();
                }
            }
        }
    }
}

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

		' Create a decryptor to perform the stream transform
		Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)

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

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

		' Create a decryptor to perform the stream transform
		Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)

		' Create the streams used for decryption
		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 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 (Wie es 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 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");

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")

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 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

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

Abschluss

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 implementieren, beginnen Lizenzen bei $999 für einen einmaligen Kauf.

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 Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...