Was ist die RandomNumberGenerator-Klasse in C#?

Die RandomNumberGenerator-Klasse in C# ist Teil des System.Security.Cryptography-Namespace und stellt Methoden zur Verfügung, um kryptographisch sichere Zufallszahlen zu erzeugen. Sie ist besonders nützlich in Situationen wie PDF-Verschlüsselung und bei der Erstellung einzigartiger Identifikatoren.

Wie kann der RandomNumberGenerator in PDF-Projekten verwendet werden?

In PDF-Projekten kann RandomNumberGenerator verwendet werden, um sichere Passwörter für die PDF-Verschlüsselung zu erstellen, einzigartige Dateinamen zu erzeugen und vorhersehbare Sequenzen zu eliminieren, wodurch die Sicherheit und Einzigartigkeit Ihrer Dokumente verbessert wird.

Warum den RandomNumberGenerator für die Zufallszahlerzeugung wählen?

RandomNumberGenerator wird bevorzugt für die Zufallszahlerzeugung verwendet, da er kryptographisch sichere Zahlen erzeugt, die sich für sicherheitssensible Anwendungen wie die Verschlüsselung in PDF-Dokumenten eignen.

Kann RandomNumberGenerator helfen, vorhersehbare Sequenzen zu vermeiden?

Ja, RandomNumberGenerator hilft, vorhersehbare Sequenzen zu vermeiden, indem er kryptographisch sichere Zahlen erzeugt, die sicherstellen, dass die Sequenzen zufällig und nicht leicht vorhersehbar sind.

Ist RandomNumberGenerator geeignet, um Zufallsstrings zu erzeugen?

Ja, RandomNumberGenerator kann verwendet werden, um Zufallsstrings zu erzeugen, indem zunächst zufällige Bytes erzeugt werden, die dann in Strings umgewandelt werden können. Dies ist nützlich zur Erstellung sicherer Passwörter oder einzigartiger Identifikatoren in PDF-Projekten.

Welche Anwendungsfälle gibt es für RandomNumberGenerator in C#?

Anwendungsfälle für RandomNumberGenerator in C# umfassen PDF-Verschlüsselung, die Erstellung einzigartiger Dateinamen, Erzeugung zufälliger Passwörter und jede Situation, die kryptographisch sichere Zufallszahlen benötigt.

Wie verbessert RandomNumberGenerator die Sicherheit von PDF-Dokumenten?

RandomNumberGenerator verbessert die Sicherheit von PDF-Dokumenten, indem es kryptographisch sichere Zufallszahlen bereitstellt, die für Verschlüsselungsschlüssel, Passwörter und andere Sicherheitsmaßnahmen verwendet werden können, um den Dokumenteninhalt zu schützen.

Was ist der Vorteil der Verwendung des RandomNumberGenerator gegenüber anderen Zufallszahlengeneratoren?

Der Vorteil der Verwendung von RandomNumberGenerator gegenüber anderen Zufallszahlengeneratoren liegt in seiner Fähigkeit, kryptographisch sichere Zahlen zu erzeugen, was ihn für Anwendungen, die ein hohes Maß an Sicherheit erfordern, wie die Verschlüsselung von PDF-Dateien, geeignet macht.

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

ENTWICKLER-UPDATES

Vereinfachen Sie das E-Invoicing mit IronPDFs neuem Update: PDF/A-3-Konformität und ZUGFeRD-Unterstützung

Jacob Mellor

Updated: 21. April 2026

Manchmal, wenn Sie mit PDF-Dokumenten arbeiten, benötigen Sie möglicherweise Zufallszahlen oder zufällige Zeichenfolgen. Egal ob Sie Zufallszahlen und Passwörter für die PDF-Verschlüsselung generieren, eindeutige Dateinamen erstellen, vorhersehbare Sequenzen vermeiden oder Zahlen aus anderen Gründen generieren müssen, die Verwendung der RandomNumberGenerator C#-Klasse kann Ihre PDF-Erstellungs- und Bearbeitungsprojekte auf die nächste Stufe heben.

Im Gegensatz zu einem einfachen Zufallsobjekt, das aus der Random-Klasse erstellt wird, erzeugt dieser kryptografische Zufallszahlengenerator kryptografisch starke Zufallswerte, die sich für kryptografische Operationen in sicheren Anwendungen eignen.

In diesem Artikel werden wir untersuchen:

Was RandomNumberGenerator ist und warum es wichtig ist.
Wie man einen kryptografischen Zufallszahlengenerator in C# verwendet, um Zufallszahlen, zufällige Zeichenfolgen und andere zufällige Daten für kryptografische Zwecke zu generieren.
Praktische Beispiele für die Integration des RandomNumberGenerators mit IronPDF, um sichere, einzigartige PDFs mit den generierten Zahlen und Zeichenfolgen zu erstellen.
Tipps und bewährte Praktiken zur Erhöhung der Sicherheit und Professionalität Ihrer PDF-Anwendungen.

Was ist die RandomNumberGenerator-Klasse

Bevor wir uns mit der IronPDF-Integration befassen, wollen wir kurz darauf eingehen, was den RandomNumberGenerator besonders macht.

Es ist Teil des Namespaces System.Security.Cryptography.
Es werden kryptografisch starke Zufallswerte als Zufallsbytes generiert, die viel sicherer sind als die typische Random-Klasse.
Es ist ideal für Szenarien, die Unvorhersehbarkeit erfordern, wie die Generierung von sicheren Tokens, Schlüsseln, Salzen und einzigartigen Kennungen.
Verwendet kryptografische Algorithmen wie AES-CTR DRBG, Fortuna oder vom Betriebssystem bereitgestellte CSPRNGs. * Macht es resistent gegen Vorhersagen.
Am besten geeignet für Aufgaben wie die Erstellung kryptografischer Schlüssel, Passwortgenerierung, sichere Tokens, einzigartige Dokument-IDs.

Diese Stärke stammt aus der Abhängigkeit von den zugrunde liegenden sicheren Zufallszahlengeneratoren des Betriebssystems, die es resistent gegen Vorhersage- oder Reverse-Engineering-Angriffe machen. Im Gegensatz zu Pseudozufallszahlengeneratoren, die mit demselben Startwert dieselbe Sequenz erzeugen können, ist diese Klasse für echte Zufälligkeit und kryptografische Zwecke ausgelegt.

Warum den RandomNumberGenerator anstelle der Random-Klasse von C# verwenden?

Viele Entwickler beginnen mit der Random-Klasse von C#, um Zufallszahlen zu erzeugen, aber sie ist nicht für hochsichere Szenarien ausgelegt. Muster in ihrem Output können vorhergesagt werden, insbesondere wenn derselbe Saatwert oder die Systemzeit verwendet wird, was bedeutet, dass die erzeugten Zahlen erraten werden könnten. Dies liegt daran, dass die Methode Werte mit einfachen modularen Arithmetikoperationen erzeugt, die sich bei gleichen Eingaben wiederholen können.

Im Gegensatz dazu erzeugt der RandomNumberGenerator echte Zufallszahlen, die aus kryptografischen Zufallszahlengeneratoren in der .NET Framework oder dem zugrunde liegenden Betriebssystem abgeleitet sind. Dies stellt sicher, dass es keine niedrige Wert-Voreingenommenheit gibt und oft eine Verwerfen-und-Wiederholen-Strategie verwendet wird, um die gleichmäßige Verteilung zwischen einer unteren Schranke (z.B. int minValue) und einer exklusiven oberen Schranke (z.B. int maxValue) aufrechtzuerhalten. Die folgende Darstellung hebt den Unterschied zwischen einem schwachen RNG und einem sicheren hervor.

"Weak" vs. Secure RNG

Warum RandomNumberGenerator mit IronPDF verwenden

IronPDF ist eine robuste .NET PDF-Bibliothek, die es Entwicklern ermöglicht, PDF-Dokumente zu erstellen, zu bearbeiten und zu sichern. Häufige Anwendungsfälle, bei denen Zufälligkeit wichtig ist, umfassen:

Eindeutige Dokumentkennungen: Kryptografisch sichere IDs an PDFs für Tracking oder Validierung anhängen.
Sichere Wasserzeichen: Zufällige Wasserzeichen oder Codes einfügen, die Fälschungen verhindern.
Verschlüsselungsschlüssel oder Passwörter: Sichere Schlüssel oder Passwörter für die PDF-Verschlüsselung generieren.
Zufällige Inhalte: Zufällige eindeutige Tokens oder Salze zu PDF-Dokumenten hinzufügen, um die Integrität zu überprüfen.

Wie man sichere Zufallsdaten in C# generiert

Hier ist ein einfaches Beispiel für die Generierung eines 128-Bit (16-Byte) sicheren Zufallstokens.

using System;
using System.Security.Cryptography;

public static string GenerateSecureToken(int size = 16)
{
    byte[] randomBytes = new byte[size];
    RandomNumberGenerator.Fill(randomBytes);
    return Convert.ToBase64String(randomBytes);
}

using System;
using System.Security.Cryptography;

public static string GenerateSecureToken(int size = 16)
{
    byte[] randomBytes = new byte[size];
    RandomNumberGenerator.Fill(randomBytes);
    return Convert.ToBase64String(randomBytes);
}

Imports System
Imports System.Security.Cryptography

Public Shared Function GenerateSecureToken(Optional ByVal size As Integer = 16) As String
	Dim randomBytes(size - 1) As Byte
	RandomNumberGenerator.Fill(randomBytes)
	Return Convert.ToBase64String(randomBytes)
End Function

Imports System
Imports System.Security.Cryptography

Public Shared Function GenerateSecureToken(Optional ByVal size As Integer = 16) As String
	Dim randomBytes(size - 1) As Byte
	RandomNumberGenerator.Fill(randomBytes)
	Return Convert.ToBase64String(randomBytes)
End Function

Diese Methode erstellt ein sicheres Byte-Array und gibt es als Base64-Zeichenfolge zurück — perfekt zum Einbetten oder Verfolgen in Unit-Tests, Dateinamen oder sicheren IDs.

Praktisches Beispiel: Hinzufügen eindeutiger Dokument-IDs zu PDF-Dokumenten

Lassen Sie uns die Leistungsfähigkeit des RandomNumberGenerators und IronPDF kombinieren, um ein PDF mit einer einzigartigen, sicheren Dokument-ID zu erzeugen, die auf jeder Seite gestempelt wird.

Schritt 1: Erzeugen einer sicheren Dokument-ID

string GenerateDocumentId()
{
    byte[] idBytes = new byte[12]; // 96-bit ID
    RandomNumberGenerator.Fill(idBytes);
    return BitConverter.ToString(idBytes).Replace("-", "");
}

string GenerateDocumentId()
{
    byte[] idBytes = new byte[12]; // 96-bit ID
    RandomNumberGenerator.Fill(idBytes);
    return BitConverter.ToString(idBytes).Replace("-", "");
}

Private Function GenerateDocumentId() As String
	Dim idBytes(11) As Byte ' 96-bit ID
	RandomNumberGenerator.Fill(idBytes)
	Return BitConverter.ToString(idBytes).Replace("-", "")
End Function

Private Function GenerateDocumentId() As String
	Dim idBytes(11) As Byte ' 96-bit ID
	RandomNumberGenerator.Fill(idBytes)
	Return BitConverter.ToString(idBytes).Replace("-", "")
End Function

Dies erzeugt einen 24-stelligen hexadezimalen Zufallsstring (z.B. "4F3A2C9B7D1E8F0A5B6C7D8E").

Schritt 2: Erstellen der PDF-Datei und Stempeln der ID

using IronPdf;

void CreatePdfWithSecureId()
{
    var documentId = GenerateDocumentId();

    var renderer = new ChromePdfRenderer();

    // Add a custom footer with the document ID
    renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
    {
        HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
        DrawDividerLine = true,
    };
    var pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>");

    string outputPath = $"SecurePdf_{documentId}.pdf";
    pdf.SaveAs(outputPath);

    Console.WriteLine($"PDF saved as {outputPath}");
}What this Code Does:

using IronPdf;

void CreatePdfWithSecureId()
{
    var documentId = GenerateDocumentId();

    var renderer = new ChromePdfRenderer();

    // Add a custom footer with the document ID
    renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
    {
        HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
        DrawDividerLine = true,
    };
    var pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>");

    string outputPath = $"SecurePdf_{documentId}.pdf";
    pdf.SaveAs(outputPath);

    Console.WriteLine($"PDF saved as {outputPath}");
}What this Code Does:

Imports IronPdf

Private Sub CreatePdfWithSecureId()
	Dim documentId = GenerateDocumentId()

	Dim renderer = New ChromePdfRenderer()

	' Add a custom footer with the document ID
	renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
		.HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
		.DrawDividerLine = True
	}
	Dim pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>")

	Dim outputPath As String = $"SecurePdf_{documentId}.pdf"
	pdf.SaveAs(outputPath)

	Console.WriteLine($"PDF saved as {outputPath}")
End Sub
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'What Me Code Does:

Imports IronPdf

Private Sub CreatePdfWithSecureId()
	Dim documentId = GenerateDocumentId()

	Dim renderer = New ChromePdfRenderer()

	' Add a custom footer with the document ID
	renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
		.HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
		.DrawDividerLine = True
	}
	Dim pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>")

	Dim outputPath As String = $"SecurePdf_{documentId}.pdf"
	pdf.SaveAs(outputPath)

	Console.WriteLine($"PDF saved as {outputPath}")
End Sub
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'What Me Code Does:

Erzeugt eine Zufallszahl für eine kryptografisch sichere, einzigartige Dokument-ID.
Rendert ein HTML zu PDF, das diese ID einbettet.
Fügt jeder Seite einen Fußzeilentext mit der Dokument-ID und einem Zeitstempel hinzu.
Speichert das PDF unter Verwendung der ID im Dateinamen zur einfachen Nachverfolgung.

Voll funktionsfähiges Code-Beispiel

using IronPdf;
using IronPdf.Editing;
using System;
using System.Security.Cryptography;

class Program
{
    public static void Main(string[] args)
    {
        // Create an instance of Program to run non-static methods
        var program = new Program();
        program.CreatePdfWithSecureId()
    }

    string GenerateDocumentId()
    {
        byte[] idBytes = new byte[12]; // 96-bit ID
        RandomNumberGenerator.Fill(idBytes);
        return BitConverter.ToString(idBytes).Replace("-", "");
    }

    void CreatePdfWithSecureId()
    {
        var documentId = GenerateDocumentId();

        var renderer = new ChromePdfRenderer();
        // Add a custom footer with the document ID
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
        {
            HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
            DrawDividerLine = true,
        };
        var pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>");

        string outputPath = $"SecurePdf_{documentId}.pdf";
        pdf.SaveAs(outputPath);

        Console.WriteLine($"PDF saved as {outputPath}");
    }
}

using IronPdf;
using IronPdf.Editing;
using System;
using System.Security.Cryptography;

class Program
{
    public static void Main(string[] args)
    {
        // Create an instance of Program to run non-static methods
        var program = new Program();
        program.CreatePdfWithSecureId()
    }

    string GenerateDocumentId()
    {
        byte[] idBytes = new byte[12]; // 96-bit ID
        RandomNumberGenerator.Fill(idBytes);
        return BitConverter.ToString(idBytes).Replace("-", "");
    }

    void CreatePdfWithSecureId()
    {
        var documentId = GenerateDocumentId();

        var renderer = new ChromePdfRenderer();
        // Add a custom footer with the document ID
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
        {
            HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
            DrawDividerLine = true,
        };
        var pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>");

        string outputPath = $"SecurePdf_{documentId}.pdf";
        pdf.SaveAs(outputPath);

        Console.WriteLine($"PDF saved as {outputPath}");
    }
}

Imports IronPdf
Imports IronPdf.Editing
Imports System
Imports System.Security.Cryptography

Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Create an instance of Program to run non-static methods
'INSTANT VB NOTE: The variable program was renamed since it may cause conflicts with calls to static members of the user-defined type with this name:
		Dim program_Conflict As New Program()
		program_Conflict.CreatePdfWithSecureId()
	End Sub

	Private Function GenerateDocumentId() As String
		Dim idBytes(11) As Byte ' 96-bit ID
		RandomNumberGenerator.Fill(idBytes)
		Return BitConverter.ToString(idBytes).Replace("-", "")
	End Function

	Private Sub CreatePdfWithSecureId()
		Dim documentId = GenerateDocumentId()

		Dim renderer = New ChromePdfRenderer()
		' Add a custom footer with the document ID
		renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
			.HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
			.DrawDividerLine = True
		}
		Dim pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>")

		Dim outputPath As String = $"SecurePdf_{documentId}.pdf"
		pdf.SaveAs(outputPath)

		Console.WriteLine($"PDF saved as {outputPath}")
	End Sub
End Class

Imports IronPdf
Imports IronPdf.Editing
Imports System
Imports System.Security.Cryptography

Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Create an instance of Program to run non-static methods
'INSTANT VB NOTE: The variable program was renamed since it may cause conflicts with calls to static members of the user-defined type with this name:
		Dim program_Conflict As New Program()
		program_Conflict.CreatePdfWithSecureId()
	End Sub

	Private Function GenerateDocumentId() As String
		Dim idBytes(11) As Byte ' 96-bit ID
		RandomNumberGenerator.Fill(idBytes)
		Return BitConverter.ToString(idBytes).Replace("-", "")
	End Function

	Private Sub CreatePdfWithSecureId()
		Dim documentId = GenerateDocumentId()

		Dim renderer = New ChromePdfRenderer()
		' Add a custom footer with the document ID
		renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
			.HtmlFragment = $"<div style='text-align: center; font-size: 10px;'>Document ID: {documentId} - Generated on {DateTime.UtcNow:yyyy-MM-dd HH:mm:ss} UTC</div>",
			.DrawDividerLine = True
		}
		Dim pdf = renderer.RenderHtmlAsPdf($"<h1>Secure Document</h1><p>Document ID: {documentId}</p>")

		Dim outputPath As String = $"SecurePdf_{documentId}.pdf"
		pdf.SaveAs(outputPath)

		Console.WriteLine($"PDF saved as {outputPath}")
	End Sub
End Class

Ausgabe

PDF mit Dokumenten-ID

Erweiterter Anwendungsfall: Sichere PDF-Verschlüsselung mit zufälligen Schlüsseln

IronPDF unterstützt PDF-Verschlüsselung und bietet eine starke Unterstützung für die sichere PDF-Erstellung. Sie können den RandomNumberGenerator verwenden, um starke Passwörter oder Schlüssel für die Verschlüsselung zu erstellen:

using IronPdf;
using IronPdf.Editing;
using System;
using System.Security.Cryptography;

class Program
{
    public static void Main(string[] args)
    {
        // Create an instance of Program to run non-static methods
        var program = new Program();
        program.CreateEncryptedPdf();
    }

    string GenerateSecurePassword(int length = 12)
    {
        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
        byte[] data = new byte[length];
        RandomNumberGenerator.Fill(data);

        char[] result = new char[length];
        for (int i = 0; i < length; i++)
        {
            result[i] = chars[data[i] % chars.Length];
        }
        return new string(result);
    }

    void CreateEncryptedPdf()
    {
        string password = GenerateSecurePassword();

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential PDF</h1><p>Access is restricted.</p>");

        // Set security settings
        pdf.SecuritySettings.UserPassword = password;
        pdf.SecuritySettings.AllowUserAnnotations = false;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
        pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint;

        string filePath = "EncryptedSecurePdf.pdf";
        pdf.SaveAs(filePath);

        Console.WriteLine($"Encrypted PDF saved to {filePath} with password: {password}");
    }
}

using IronPdf;
using IronPdf.Editing;
using System;
using System.Security.Cryptography;

class Program
{
    public static void Main(string[] args)
    {
        // Create an instance of Program to run non-static methods
        var program = new Program();
        program.CreateEncryptedPdf();
    }

    string GenerateSecurePassword(int length = 12)
    {
        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
        byte[] data = new byte[length];
        RandomNumberGenerator.Fill(data);

        char[] result = new char[length];
        for (int i = 0; i < length; i++)
        {
            result[i] = chars[data[i] % chars.Length];
        }
        return new string(result);
    }

    void CreateEncryptedPdf()
    {
        string password = GenerateSecurePassword();

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential PDF</h1><p>Access is restricted.</p>");

        // Set security settings
        pdf.SecuritySettings.UserPassword = password;
        pdf.SecuritySettings.AllowUserAnnotations = false;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
        pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint;

        string filePath = "EncryptedSecurePdf.pdf";
        pdf.SaveAs(filePath);

        Console.WriteLine($"Encrypted PDF saved to {filePath} with password: {password}");
    }
}

Imports IronPdf
Imports IronPdf.Editing
Imports System
Imports System.Security.Cryptography

Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Create an instance of Program to run non-static methods
'INSTANT VB NOTE: The variable program was renamed since it may cause conflicts with calls to static members of the user-defined type with this name:
		Dim program_Conflict As New Program()
		program_Conflict.CreateEncryptedPdf()
	End Sub

	Private Function GenerateSecurePassword(Optional ByVal length As Integer = 12) As String
		Const chars As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
		Dim data(length - 1) As Byte
		RandomNumberGenerator.Fill(data)

		Dim result(length - 1) As Char
		For i As Integer = 0 To length - 1
			result(i) = chars.Chars(data(i) Mod chars.Length)
		Next i
		Return New String(result)
	End Function

	Private Sub CreateEncryptedPdf()
		Dim password As String = GenerateSecurePassword()

		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential PDF</h1><p>Access is restricted.</p>")

		' Set security settings
		pdf.SecuritySettings.UserPassword = password
		pdf.SecuritySettings.AllowUserAnnotations = False
		pdf.SecuritySettings.AllowUserCopyPasteContent = False
		pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint

		Dim filePath As String = "EncryptedSecurePdf.pdf"
		pdf.SaveAs(filePath)

		Console.WriteLine($"Encrypted PDF saved to {filePath} with password: {password}")
	End Sub
End Class

Imports IronPdf
Imports IronPdf.Editing
Imports System
Imports System.Security.Cryptography

Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Create an instance of Program to run non-static methods
'INSTANT VB NOTE: The variable program was renamed since it may cause conflicts with calls to static members of the user-defined type with this name:
		Dim program_Conflict As New Program()
		program_Conflict.CreateEncryptedPdf()
	End Sub

	Private Function GenerateSecurePassword(Optional ByVal length As Integer = 12) As String
		Const chars As String = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()"
		Dim data(length - 1) As Byte
		RandomNumberGenerator.Fill(data)

		Dim result(length - 1) As Char
		For i As Integer = 0 To length - 1
			result(i) = chars.Chars(data(i) Mod chars.Length)
		Next i
		Return New String(result)
	End Function

	Private Sub CreateEncryptedPdf()
		Dim password As String = GenerateSecurePassword()

		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential PDF</h1><p>Access is restricted.</p>")

		' Set security settings
		pdf.SecuritySettings.UserPassword = password
		pdf.SecuritySettings.AllowUserAnnotations = False
		pdf.SecuritySettings.AllowUserCopyPasteContent = False
		pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint

		Dim filePath As String = "EncryptedSecurePdf.pdf"
		pdf.SaveAs(filePath)

		Console.WriteLine($"Encrypted PDF saved to {filePath} with password: {password}")
	End Sub
End Class

Diese Methode verwendet die Standardimplementierung des RNG aus dem Betriebssystem und erzeugt ein Passwort, das für kryptografische Operationen geeignet ist.

Dies wird das generierte sichere Passwort anwenden, sodass nur Benutzer mit Zugriff auf die Passwörter das Dokument anzeigen können.

Passwortschutz-Pop-up

Darüber hinaus bleibt uns ein verschlüsseltes, sicheres Dokument mit unseren festgelegten Berechtigungen:

Verschlüsselte PDF-Einstellungen

Beste Praktiken und Tipps

Verwenden Sie immer den RandomNumberGenerator für alles, was mit Sicherheit zu tun hat. Vermeiden Sie Random für IDs, Tokens oder Passwörter.
Halten Sie sensible Daten aus Protokollen heraus, aber protokollieren Sie genügend für das Tracking.
Erwägen Sie die Verwendung von Zeitstempeln und anderen Metadaten zusammen mit zufälligen IDs für eine bessere Rückverfolgbarkeit.
Verwenden Sie die integrierten Sicherheitsfunktionen von IronPDF in Kombination mit zufälligen Schlüsseln, um Ihre Dokumente zu schützen.
Prüfen Sie die Länge und Kodierung der Zufallsdaten, um die Nutzbarkeit in Ihrem Kontext sicherzustellen (z.B. Dateinamen, URLs, Barcodes).

Zusammenfassung

Durch die Integration der RandomNumberGenerator-Klasse von C# mit IronPDF können Sie sichere, einzigartige PDFs erstellen, die modernen Sicherheitsstandards entsprechen. Egal, ob Sie eindeutige IDs stempeln, Verschlüsselungsschlüssel generieren oder sichere Tokens einbetten, dieser Ansatz hilft Ihnen dabei:

Dokumentfälschung verhindern
Rückverfolgbarkeit verbessern
Sensible Daten innerhalb Ihrer PDFs sichern

Durch die Kombination der kryptographischen Stärke dieser Klasse mit den vielseitigen PDF-Tools von IronPDF werden Ihre PDF-Lösungen sicherer und professioneller.

Versuchen Sie es selbst!

Bereit, Ihre PDF-Sicherheit zu verbessern? Testen Sie IronPDF kostenlos und experimentieren Sie noch heute mit sicheren Zufallsdaten!

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.

...