Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. randomnumbergenerator C#
.NET AIDE

RandomNumberGenerator C#

Curtis Chau
Curtis Chau
Mis à jour:

Parfois, lorsque vous travaillez avec des documents PDF, vous pourriez avoir besoin de générer des nombres aléatoires ou des chaînes aléatoires. Que vous génériez des nombres aléatoires et des mots de passe pour le chiffrement PDF, créiez des noms de fichiers uniques, évitiez les séquences prévisibles, ou deviez générer des nombres pour toute autre raison, l'utilisation de la classe RandomNumberGenerator en C# peut vous aider à faire passer vos projets de génération et de modification de PDF au niveau supérieur.

Contrairement à un objet aléatoire de base créé à partir de la classe Random, ce générateur de nombres aléatoires cryptographiques produit des valeurs aléatoires cryptographiquement fortes, adaptées aux opérations cryptographiques dans des applications sécurisées.

Dans cet article, nous explorerons :

  • Qu'est-ce que RandomNumberGenerator et pourquoi c'est important.

  • Comment utiliser un générateur de nombres aléatoires cryptographiques en C# pour générer des nombres aléatoires, des chaînes aléatoires et d'autres données aléatoires à des fins cryptographiques.

  • Des exemples pratiques d'intégration de RandomNumberGenerator avec IronPDF pour créer des PDF sécurisés et uniques en utilisant les nombres et les chaînes générés.

  • Conseils et meilleures pratiques pour renforcer la sécurité et le professionnalisme de vos applications PDF.

Qu'est-ce que la classe RandomNumberGenerator

Avant d'entrer dans l'intégration avec IronPDF, revoyons brièvement ce qui rend RandomNumberGenerator spécial.

  • Elle fait partie de l'espace de noms System.Security.Cryptography.

  • Elle génère des valeurs aléatoires cryptographiquement fortes en tant qu'octet aléatoire, beaucoup plus sécurisées que celles de la classe Random typique.

  • Elle est idéale pour les scénarios nécessitant une imprévisibilité, comme la génération de jetons sécurisés, de clés, de sels et d'identifiants uniques.

  • Utilise des algorithmes cryptographiques comme AES-CTR DRBG, Fortuna, ou les CSPRNGs fournis par le système d'exploitation. En faisant qu'il résiste à la prédiction.

  • Mieux utilisée pour des tâches telles que la création de clés cryptographiques, la génération de mots de passe, de jetons sécurisés, d'identifiants de documents uniques.

Cette force découle du fait qu'elle repose sur les générateurs de nombres aléatoires sécurisés sous-jacents du système d'exploitation, la rendant résistante à la prédiction ou aux attaques de rétro-ingénierie. Contrairement aux générateurs de nombres pseudo-aléatoires qui peuvent produire la même séquence avec la même valeur initiale, cette classe est conçue pour une vraie aléa et des fins cryptographiques.

Pourquoi utiliser RandomNumberGenerator au lieu de la classe Random de C# ?

Beaucoup de développeurs commencent avec la classe Random de C# pour générer des entiers aléatoires, mais elle n'est pas conçue pour des scénarios de sécurité élevée. Les motifs dans sa sortie peuvent être prédits, surtout si la même valeur de graine ou le temps système est utilisé, ce qui signifie que les nombres générés pourraient être devinés. Cela arrive parce que la méthode génère des valeurs en utilisant des opérations arithmétiques modulaires simples qui peuvent se répéter avec la même entrée.

En revanche, RandomNumberGenerator produit de vrais nombres aléatoires, dérivés de générateurs de nombres aléatoires cryptographiques dans le .NET Framework ou le système d'exploitation sous-jacent. Cela garantit aucun biais de faible valeur et utilise souvent une stratégie de rejet pour maintenir une distribution uniforme entre une limite inférieure (par exemple, int minValue) et une limite supérieure exclusive (par exemple, int maxValue). L'illustration ci-dessous souligne la différence entre un RNG faible et un sécurisé.

RNG faible contre sécurisé

Pourquoi utiliser RandomNumberGenerator avec IronPDF

IronPDF est une bibliothèque PDF .NET robuste, permettant aux développeurs de créer, modifier et sécuriser des documents PDF. Les cas d'utilisation courants où l'aléa est important incluent :

  • Identifiants de documents uniques : Attacher des identifiants cryptographiquement sûrs aux PDFs pour suivi ou validation.

  • Watermarks sécurisés : Intégrer des filigranes ou des codes aléatoires qui découragent la contrefaçon.

  • Clés de chiffrement ou mots de passe : Générer des clés ou mots de passe sécurisés pour le chiffrement des PDFs.

  • Contenu aléatoire : Ajouter des jetons ou sels uniques aléatoires aux documents PDF pour vérification de l'intégrité.

Comment générer des données aléatoires sécurisées en C

Voici un exemple simple de génération d'un jeton aléatoire sécurisé de 128 bits (16 octets). 

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
$vbLabelText   $csharpLabel

Cette méthode crée un tableau d'octets sécurisé et le retourne sous forme de chaîne Base64 — parfait pour intégrer ou suivre dans les tests unitaires, noms de fichiers, ou identifiants sécurisés.

Exemple pratique : Ajouter des identifiants de documents uniques aux documents PDF

Combinons la puissance de RandomNumberGenerator et IronPDF pour générer un PDF avec un identifiant de document unique sécurisé apposé sur chaque page.

Étape 1 : Générer un identifiant de document sécurisé

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
$vbLabelText   $csharpLabel

Cela produit une chaîne hexadécimale aléatoire de 24 caractères (par exemple, "4F3A2C9B7D1E8F0A5B6C7D8E").

Étape 2 : Créer le PDF et marquer l'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:
$vbLabelText   $csharpLabel

  • Génère un nombre aléatoire pour un identifiant de document unique et sécurisé cryptographiquement.

  • Rend un HTML en PDF intégrant cet identifiant.

  • Ajoute un pied de page sur chaque page avec l'identifiant du document et l'horodatage.

  • Enregistre le PDF en utilisant l'ID dans le nom de fichier pour un suivi facile.

Exemple de code complet

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
$vbLabelText   $csharpLabel

Sortie

PDF avec identifiant de document

Cas d'utilisation avancé : Chiffrement PDF sécurisé avec des clés aléatoires

IronPDF prend en charge le chiffrement PDF, offrant un fort support pour la création de PDFs sécurisés. Vous pouvez utiliser RandomNumberGenerator pour créer des mots de passe ou des clés fortes pour le chiffrement :

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
$vbLabelText   $csharpLabel

Cette méthode utilise l'implémentation par défaut du RNG du système d'exploitation, produisant un mot de passe adapté aux opérations cryptographiques.

Cela appliquera le mot de passe sécurisé généré, donc seuls les utilisateurs ayant accès aux mots de passe pourront visualiser le document.

Fenêtre contextuelle de protection par mot de passe

De plus, nous aurons un document sécurisé et chiffré avec nos paramètres de permission :

Paramètres PDF chiffré

Meilleures pratiques et conseils

  • Utilisez toujours RandomNumberGenerator pour tout ce qui est lié à la sécurité. Évitez Random pour les identifiants, jetons ou mots de passe.

  • Gardez les données sensibles hors des journaux ou des messages orientés utilisateur, mais consignez suffisamment pour le suivi et l'audit.

  • Envisagez d'utiliser des horodatages et d'autres métadonnées avec des identifiants aléatoires pour une meilleure traçabilité.

  • Utilisez les fonctionnalités de sécurité intégrées d'IronPDF combinées à des clés aléatoires pour protéger vos documents.

  • Validez la longueur et le codage des données aléatoires pour garantir leur utilisabilité dans votre contexte (par exemple, noms de fichiers, URLs, codes-barres).

Résumé

Intégrer la classe RandomNumberGenerator de C# avec IronPDF vous permet de générer des PDFs sécurisés et uniques répondant aux normes de sécurité modernes. Que vous apposiez des ID uniques, génériez des clés de chiffrement ou intégriez des jetons sécurisés, cette approche vous aide à :

  • Prévenir la contrefaçon de documents

  • Améliorer la traçabilité

  • Sécuriser les données sensibles dans vos PDFs

En combinant la force cryptographique de cette classe avec les outils PDF polyvalents d'IronPDF, vos solutions PDF deviennent plus sûres et plus professionnelles.

Essayez par vous-même !

Prêt à renforcer la sécurité de vos PDFs ? Essayez la version d'essai gratuite d'IronPDF et commencez à expérimenter avec des données aléatoires sécurisées dès aujourd'hui !

Questions Fréquemment Posées

Qu'est-ce que la classe RandomNumberGenerator en C#?

La classe RandomNumberGenerator en C# fait partie de l'espace de noms System.Security.Cryptography qui fournit des méthodes pour générer des nombres aléatoires sécurisés cryptographiquement. Elle est particulièrement utile dans des scénarios comme le cryptage de PDF et la génération d'identifiants uniques.

Comment RandomNumberGenerator peut-il être utilisé dans les projets PDF?

Dans les projets PDF, RandomNumberGenerator peut être utilisé pour créer des mots de passe sécurisés pour le cryptage PDF, générer des noms de fichiers uniques et éliminer les séquences prévisibles, renforçant la sécurité et l'unicité de vos documents.

Pourquoi choisir RandomNumberGenerator pour générer des nombres aléatoires?

RandomNumberGenerator est préféré pour générer des nombres aléatoires car il produit des nombres sécurisés cryptographiquement, le rendant adapté aux applications sensibles à la sécurité comme le cryptage dans les documents PDF.

RandomNumberGenerator peut-il aider à éviter les séquences prévisibles?

Oui, RandomNumberGenerator aide à éviter les séquences prévisibles en générant des nombres sécurisés cryptographiquement, garantissant que les séquences sont aléatoires et non facilement prévisibles.

RandomNumberGenerator est-il adapté pour générer des chaînes aléatoires?

Oui, RandomNumberGenerator peut être utilisé pour générer des chaînes aléatoires en générant d'abord des octets aléatoires, qui peuvent ensuite être convertis en chaînes. Cela est utile pour créer des mots de passe sécurisés ou des identifiants uniques dans les projets PDF.

Quels sont les cas d'utilisation de RandomNumberGenerator en C#?

Les cas d'utilisation de RandomNumberGenerator en C# incluent le cryptage de PDF, la génération de noms de fichiers uniques, la création de mots de passe aléatoires, et tout scénario nécessitant des nombres aléatoires sécurisés cryptographiquement.

Comment RandomNumberGenerator améliore-t-il la sécurité des documents PDF?

RandomNumberGenerator améliore la sécurité des documents PDF en fournissant des nombres aléatoires sécurisés cryptographiquement, qui peuvent être utilisés pour les clés de cryptage, les mots de passe et d'autres mesures de sécurité pour protéger le contenu du document.

Quel est l'avantage d'utiliser RandomNumberGenerator par rapport à d'autres générateurs de nombres aléatoires?

L'avantage d'utiliser RandomNumberGenerator par rapport à d'autres générateurs de nombres aléatoires est sa capacité à produire des nombres sécurisés cryptographiquement, le rendant adapté aux applications nécessitant un niveau élevé de sécurité, comme le cryptage de fichiers PDF.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit