AIDE .NET

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

Chaknith Bin

octobre 23, 2024

AES (Advanced Encryption Standard) est l'un des algorithmes de chiffrement 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 chiffrement AES en C#, en utilisant la classe AES pour chiffrer et déchiffrer des données et la bibliothèque IronPDF. Nous aborderons des exemples pratiques, examinerons le processus de chiffrement et verrons comment utiliser le mode Cipher Block Chaining (CBC) pour accroître la sécurité. 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# ;

L'Advanced Encryption Standard (AES) est un algorithme de chiffrement symétrique standardisé 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 dans différents modes de chiffrement, tels que CBC (Cipher Block Chaining) et Electronic CodeBook (ECB), chacun offrant différentes fonctionnalités de sécurité.

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

$vbLabelText $csharpLabel

Chiffrement AES en C# (Comment cela fonctionne pour les développeurs) : Figure 1 - Résultat de chiffrement et de déchiffrement utilisant le flux de mémoire

Explication du code

Aes aes = Aes.Create() : Cela crée une nouvelle instance de l'algorithme de chiffrement AES.
Aes.Key : La clé utilisée pour le chiffrement et le déchiffrement. Il doit être d'une taille valide, telle que 128 bits (16 octets), 192 bits ou 256 bits.
Aes.IV : Le vecteur d'initialisation (IV) est utilisé pour randomiser le processus de chiffrement. 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 sous forme de flux d'octets.
CryptoStream : Il transforme le flux de données (chiffrement ou déchiffrement).

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

Construisons sur l'exemple précédent en générant une clé aléatoire et un IV, assurant ainsi une plus grande sécurité de cryptage.

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

$vbLabelText $csharpLabel

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

Décryptage des données avec AES

Le déchiffrement est le processus inverse de chiffrer les 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

$vbLabelText $csharpLabel

Ce code déchiffre les données cryptées pour revenir aux 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#. Il permet aux développeurs de créer des documents PDF directement à partir de HTML, CSS et JavaScript, ce qui peut être extrêmement utile pour générer dynamiquement des rapports, des factures ou d'autres documents. 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

Cryptage AES en C# (Comment ça fonctionne 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. Le cryptage AES (Advanced Encryption Standard) est une solution parfaite pour crypter de manière sécurisée 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 de 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")

$vbLabelText $csharpLabel

É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

$vbLabelText $csharpLabel

Conclusion

Chiffrement AES C# (Comment ça fonctionne pour les développeurs) : Figure 3 - Licences

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 propose un essai gratuit, ce qui permet aux développeurs de découvrir ses fonctionnalités avant de s'engager. Si vous êtes prêt à intégrer IronPDF dans vos projets, les licences commencent à partir de $749 pour un achat unique.

Chaknith Bin

Discutez avec l'équipe d'ingénierie maintenant

Ingénieur logiciel

Chaknith travaille sur IronXL et IronBarcode. Il possède une expertise approfondie en C# et .NET, aidant à améliorer le logiciel et à soutenir les clients. Ses idées issues des interactions avec les utilisateurs contribuent à de meilleurs produits, une documentation améliorée et une expérience globale enrichie.

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

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