AIDE .NET

C# AES Encryption (How It Works For Developers) (Chiffrement AES en C# (Comment ça marche pour les développeurs))

Publié octobre 23, 2024

AES(Norme de chiffrement avancée) est l'un des algorithmes de cryptage symétrique les plus couramment utilisés. Il utilise la même clé pour crypter et décrypter les données, ce qui rend le cryptage AES efficace et rapide pour sécuriser les données sensibles dans de nombreuses applications.

Ce tutoriel se concentrera sur le cryptage AES en C#, en utilisant la classe AES pour crypter et décrypter des données et desBibliothèque IronPDF. Nous aborderons des exemples pratiques, le processus de chiffrement et l'utilisation de la chaîne de blocs de chiffrement (Cipher Block Chaining)(CBC) la traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Nous aborderons également la gestion des clés de chiffrement et le rôle du vecteur d'initialisation(IV).

Introduction du chiffrement AES dans le C# ;

Norme de cryptage avancée(AES) est un algorithme de cryptage symétrique normalisé par le National Institute of Standards and Technology(NIST). L'algorithme peut avoir des tailles de clé de 128, 192 ou 256 bits et est hautement sécurisé pour le cryptage de données confidentielles. Il utilise la même clé de cryptage pour crypter et décrypter les données.

AES fonctionne en divisant les données originales en blocs et en appliquant des transformations sur ces blocs. Il fonctionne selon différents modes de chiffrement, tels que CBC(Chaîne de blocs de chiffrement) et Electronic CodeBook(BCE)ces outils sont des logiciels de sécurité, chacun offrant des caractéristiques de sécurité différentes.

Comment fonctionne le système AES en C# ;

L'algorithme de chiffrement AES en C# fait partie de l'espace de noms System.Security.Cryptography. Cet espace de noms comprend la classe AES, qui nous permet de créer une instance d'AES, de spécifier la taille de la clé, le mode de chiffrement et le mode de remplissage, puis de chiffrer et de déchiffrer des données à l'aide d'une clé secrète.

Pour utiliser AES dans C#, suivez les étapes de base suivantes :

Créez une instance de la classe AES à l'aide de Aes.Create().
Définissez la clé, l'IV et d'autres paramètres pertinents tels que le mode de chiffrement.
Cryptez les données à l'aide de l'interface ICryptoTransform et écrivez-les dans un MemoryStream.
Décryptez les données en utilisant la même clé et le même IV.
Créons un processus de cryptage et un programme de décryptage de base en C#.

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
class Program
{
    // Declare a static byte array for encrypted data
    public static byte[] encryptedData;
    // static void Main
    public static void Main(string[] args)
    {
        // string plaintext to be encrypted
        string plaintext = "This is some sensitive data!";
        string key = "abcdefghijklmnop"; // 128-bit key (16 characters)
        // Encrypt the plaintext
        string ciphertext = Encrypt(plaintext, key);
        Console.WriteLine("Encrypted Data: " + ciphertext);
        // Decrypt the ciphertext
        string decryptedData = Decrypt(ciphertext, key);
        Console.WriteLine("Decrypted Data: " + decryptedData);
    }
    public static string Encrypt(string plaintext, string key)
    {
        // AES algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cs))
                    {
                        sw.Write(plaintext);
                    }
                }
                // Store the encrypted data in the public static byte array
                encryptedData = ms.ToArray();
                return Convert.ToBase64String(encryptedData);
            }
        }
    }
    public static string Decrypt(string ciphertext, string key)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader sr = new StreamReader(cs))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }
    }
}

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
class Program
{
    // Declare a static byte array for encrypted data
    public static byte[] encryptedData;
    // static void Main
    public static void Main(string[] args)
    {
        // string plaintext to be encrypted
        string plaintext = "This is some sensitive data!";
        string key = "abcdefghijklmnop"; // 128-bit key (16 characters)
        // Encrypt the plaintext
        string ciphertext = Encrypt(plaintext, key);
        Console.WriteLine("Encrypted Data: " + ciphertext);
        // Decrypt the ciphertext
        string decryptedData = Decrypt(ciphertext, key);
        Console.WriteLine("Decrypted Data: " + decryptedData);
    }
    public static string Encrypt(string plaintext, string key)
    {
        // AES algorithm
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter sw = new StreamWriter(cs))
                    {
                        sw.Write(plaintext);
                    }
                }
                // Store the encrypted data in the public static byte array
                encryptedData = ms.ToArray();
                return Convert.ToBase64String(encryptedData);
            }
        }
    }
    public static string Decrypt(string ciphertext, string key)
    {
        using (Aes aes = Aes.Create())
        {
            aes.Key = Encoding.UTF8.GetBytes(key);
            aes.IV = new byte[16]; // Initialization vector (IV)
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader sr = new StreamReader(cs))
                    {
                        return sr.ReadToEnd();
                    }
                }
            }
        }
    }
}

Imports System
Imports System.IO
Imports System.Security.Cryptography
Imports System.Text
Friend Class Program
	' Declare a static byte array for encrypted data
	Public Shared encryptedData() As Byte
	' static void Main
	Public Shared Sub Main(ByVal args() As String)
		' string plaintext to be encrypted
		Dim plaintext As String = "This is some sensitive data!"
		Dim key As String = "abcdefghijklmnop" ' 128-bit key (16 characters)
		' Encrypt the plaintext
		Dim ciphertext As String = Encrypt(plaintext, key)
		Console.WriteLine("Encrypted Data: " & ciphertext)
		' Decrypt the ciphertext
		Dim decryptedData As String = Decrypt(ciphertext, key)
		Console.WriteLine("Decrypted Data: " & decryptedData)
	End Sub
	Public Shared Function Encrypt(ByVal plaintext As String, ByVal key As String) As String
		' AES algorithm
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)
			Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)
			Using ms As New MemoryStream()
				Using cs As New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
					Using sw As New StreamWriter(cs)
						sw.Write(plaintext)
					End Using
				End Using
				' Store the encrypted data in the public static byte array
				encryptedData = ms.ToArray()
				Return Convert.ToBase64String(encryptedData)
			End Using
		End Using
	End Function
	Public Shared Function Decrypt(ByVal ciphertext As String, ByVal key As String) As String
		Using aes As Aes = System.Security.Cryptography.Aes.Create()
			aes.Key = Encoding.UTF8.GetBytes(key)
			aes.IV = New Byte(15){} ' Initialization vector (IV)
			Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)
			Using ms As New MemoryStream(Convert.FromBase64String(ciphertext))
				Using cs As New CryptoStream(ms, decryptor, CryptoStreamMode.Read)
					Using sr As New StreamReader(cs)
						Return sr.ReadToEnd()
					End Using
				End Using
			End Using
		End Using
	End Function
End Class

VB C#

Chiffrement AES en C# (Comment ça marche pour les développeurs) : Figure 1 - Sortie de chiffrement et de déchiffrement à l'aide d'un flux de mémoire

Explication du code

Aes aes = Aes.Create() : Cette opération crée une nouvelle instance de l'algorithme de chiffrement AES.
Clé Aes : La clé utilisée pour le cryptage et le décryptage. Elle doit être d'une taille valide, par exemple 128 bits(16 octets)le nombre de bits est limité à 192 bits ou 256 bits.
Aes.IV : Le vecteur d'initialisation(IV)la clé de cryptage, qui est utilisée pour randomiser le processus de cryptage. Dans cet exemple, nous utilisons un IV de zéros pour plus de simplicité.
MemoryStream : Cela nous permet de travailler avec les données cryptées en tant que flux d'octets.
CryptoStream : Il transforme le flux de données(cryptage ou décryptage).

Exemple avancé : Chiffrement AES avec clé personnalisée et IV

Développons l'exemple précédent en générant une clé aléatoire et une IV, afin de garantir un cryptage plus sûr.

public static string EncryptData(string plaintext)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = new byte[32]; // AES-256 requires a 256-bit key (32 bytes)
        aes.IV = new byte[16];  // 128-bit block size
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream())
        {
            using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                using (StreamWriter sw = new StreamWriter(cs))
                {
                    sw.Write(plaintext);
                }
            }
            return Convert.ToBase64String(ms.ToArray());
        }
    }
}

public static string EncryptData(string plaintext)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = new byte[32]; // AES-256 requires a 256-bit key (32 bytes)
        aes.IV = new byte[16];  // 128-bit block size
        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(aes.Key); // Generate a random key
            rng.GetBytes(aes.IV);  // Generate a random IV
        }
        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream())
        {
            using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
            {
                using (StreamWriter sw = new StreamWriter(cs))
                {
                    sw.Write(plaintext);
                }
            }
            return Convert.ToBase64String(ms.ToArray());
        }
    }
}

Public Shared Function EncryptData(ByVal plaintext As String) As String
	Using aes As Aes = Aes.Create()
		aes.Key = New Byte(31){} ' AES-256 requires a 256-bit key (32 bytes)
		aes.IV = New Byte(15){} ' 128-bit block size
		Using rng As RandomNumberGenerator = RandomNumberGenerator.Create()
			rng.GetBytes(aes.Key) ' Generate a random key
			rng.GetBytes(aes.IV) ' Generate a random IV
		End Using
		Dim encryptor As ICryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV)
		Using ms As New MemoryStream()
			Using cs As New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
				Using sw As New StreamWriter(cs)
					sw.Write(plaintext)
				End Using
			End Using
			Return Convert.ToBase64String(ms.ToArray())
		End Using
	End Using
End Function

VB C#

Dans ce cas, nous générons une nouvelle clé et un IV à chaque fois que la fonction est appelée. Cela permet un cryptage plus robuste car la même clé est inutilisée pour chaque opération. AES prend en charge des tailles de clés telles que 128, 192 et 256 bits.

Décryptage des données avec AES

Le décryptage est le processus inverse du chiffrement des données. Dans nos exemples, la clé et l'IV utilisés pour le cryptage doivent être fournis pour décrypter les données. Le processus de décryptage consiste à reconvertir les données cryptées dans leur forme originale.

Voici un exemple qui utilise les données précédemment cryptées :

public static string DecryptData(string ciphertext, byte[] key, byte[] iv)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.IV = iv;
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
        {
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                using (StreamReader sr = new StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}

public static string DecryptData(string ciphertext, byte[] key, byte[] iv)
{
    using (Aes aes = Aes.Create())
    {
        aes.Key = key;
        aes.IV = iv;
        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
        using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(ciphertext)))
        {
            using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
            {
                using (StreamReader sr = new StreamReader(cs))
                {
                    return sr.ReadToEnd();
                }
            }
        }
    }
}

Public Shared Function DecryptData(ByVal ciphertext As String, ByVal key() As Byte, ByVal iv() As Byte) As String
	Using aes As Aes = Aes.Create()
		aes.Key = key
		aes.IV = iv
		Dim decryptor As ICryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV)
		Using ms As New MemoryStream(Convert.FromBase64String(ciphertext))
			Using cs As New CryptoStream(ms, decryptor, CryptoStreamMode.Read)
				Using sr As New StreamReader(cs)
					Return sr.ReadToEnd()
				End Using
			End Using
		End Using
	End Using
End Function

VB C#

Ce code décrypte les données cryptées pour les retransformer en données originales.

IronPDF avec cryptage AES

IronPDF est une bibliothèque .NET simple et conviviale pour les développeurs, conçue pour générer, éditer et manipuler des PDF à l'aide d'un simple code C#. Elle permet aux développeurs decréer des documents PDF directement à partir de HTMLla traduction doit rester professionnelle et préserver l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement. Avec la prise en charge de la fusion, de la division et même de l'ajout de fonctions de sécurité telles que les mots de passe ou les signatures numériques, IronPDF est une solution complète pour la génération de PDF dans les applications .NET.

Intégration d'IronPDF avec le cryptage AES

Chiffrement AES en C#(Comment cela fonctionne-t-il pour les développeurs ?) : Figure 2 - IronPDF

Lorsque vous produisez des rapports ou des documents sensibles, vous pouvez avoir besoin de vous assurer que les données contenues dans ces PDF sont cryptées avant de les partager. AES(Norme de chiffrement avancée) encryption est une solution parfaite pour crypter en toute sécurité le contenu des fichiers PDF. En combinant IronPDF et le cryptage AES, vous pouvez protéger les données contenues dans vos PDF tout en conservant la possibilité de travailler avec le document lui-même.

Étape 1 : Créer un PDF à l'aide d'IronPDF

Utilisez la classe ChromePdfRenderer pour générer un PDF à partir d'un contenu HTML et l'enregistrer dans un fichier :

var htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(@"C:\Reports\ConfidentialReport.pdf");

var htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs(@"C:\Reports\ConfidentialReport.pdf");

Dim htmlContent = "<h1>Confidential</h1><p>This is sensitive data.</p>"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("C:\Reports\ConfidentialReport.pdf")

VB C#

Étape 2 : Cryptage du PDF à l'aide d'AES

Une fois le PDF créé, cryptez-le avec AES :

byte[] pdfBytes = File.ReadAllBytes(@"C:\Reports\ConfidentialReport.pdf");
using (Aes aes = Aes.Create())
{
    aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop");
    aes.IV = new byte[16];
    using (var encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
    using (var ms = new MemoryStream())
    {
        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
            cs.Write(pdfBytes, 0, pdfBytes.Length);
        }
        File.WriteAllBytes(@"C:\Reports\ConfidentialReport.encrypted", ms.ToArray());
    }
}

byte[] pdfBytes = File.ReadAllBytes(@"C:\Reports\ConfidentialReport.pdf");
using (Aes aes = Aes.Create())
{
    aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop");
    aes.IV = new byte[16];
    using (var encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
    using (var ms = new MemoryStream())
    {
        using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
            cs.Write(pdfBytes, 0, pdfBytes.Length);
        }
        File.WriteAllBytes(@"C:\Reports\ConfidentialReport.encrypted", ms.ToArray());
    }
}

Dim pdfBytes() As Byte = File.ReadAllBytes("C:\Reports\ConfidentialReport.pdf")
Using aes As Aes = Aes.Create()
	aes.Key = Encoding.UTF8.GetBytes("abcdefghijklmnop")
	aes.IV = New Byte(15){}
	Using encryptor = aes.CreateEncryptor(aes.Key, aes.IV)
	Using ms = New MemoryStream()
		Using cs = New CryptoStream(ms, encryptor, CryptoStreamMode.Write)
			cs.Write(pdfBytes, 0, pdfBytes.Length)
		End Using
		File.WriteAllBytes("C:\Reports\ConfidentialReport.encrypted", ms.ToArray())
	End Using
	End Using
End Using

VB C#

Conclusion

Chiffrement AES en C# (Comment ça marche pour les développeurs) : Figure 3 - Licence

L'intégration d'IronPDF avec le cryptage AES vous permet de générer des documents dynamiques et sécurisés qui sont à la fois accessibles et cryptés. Qu'il s'agisse de développer des applications nécessitant la génération de documents sécurisés ou de gérer des rapports sensibles, la combinaison d'IronPDF avec un chiffrement solide protège vos données. IronPDF simplifie le travail avec les PDF, tandis qu'AES garantit la sécurité du contenu.

IronPDF offre un service deessai gratuitla traduction doit également permettre aux développeurs d'explorer facilement les fonctionnalités avant de s'engager. Si vous êtes prêt à mettre en œuvre IronPDF dans vos projets, les licences commencent à 749 $ pour un achat unique.

< PRÉCÉDENT
C# try catch finally (Comment ça marche pour les développeurs)

SUIVANT >
C# HttpClient (Comment ça marche pour les développeurs)