AYUDA .NET

Cifrado AES en C# (Cómo funciona para desarrolladores)

Publicado en 23 de octubre, 2024

AES(Estándar de cifrado avanzado) es uno de los algoritmos de cifrado simétrico más utilizados. Utiliza la misma clave para cifrar y descifrar datos, lo que hace que el cifrado AES sea eficaz y rápido para proteger datos confidenciales en muchas aplicaciones.

Este tutorial se centrará en el cifrado AES en C#, utilizando la clase AES para cifrar y descifrar datos yBiblioteca IronPDF. Cubriremos ejemplos prácticos, recorreremos el proceso de cifrado y veremos cómo utilizar el encadenamiento de bloques de cifrado(CBC) modo de aumentar la seguridad. También hablaremos de la gestión de claves de cifrado y del papel del vector de inicialización(IV).

Introducción al cifrado AES en C#

Estándar de cifrado avanzado(AES) es un algoritmo de cifrado simétrico estandarizado por el Instituto Nacional de Estándares y Tecnología(NIST). El algoritmo puede tener claves de 128, 192 o 256 bits y es muy seguro para cifrar datos confidenciales. Utiliza la misma clave de cifrado para cifrar y descifrar datos.

AES funciona dividiendo los datos originales en bloques y aplicando transformaciones a esos bloques. Funciona en diferentes modos de cifrado, como CBC(Encadenamiento de bloques de cifrado) y CodeBook electrónico(BCE)cada una de ellas ofrece características de seguridad diferentes.

Cómo funciona AES en C#

El algoritmo de cifrado AES en C# forma parte del espacio de nombres System.Security.Cryptography. Este espacio de nombres incluye la clase AES, que nos permite crear una instancia de AES, especificar el tamaño de la clave, el modo de cifrado y el modo de relleno y, a continuación, cifrar y descifrar datos utilizando una clave secreta.

Para utilizar AES en C#, siga estos pasos básicos:

Crear una instancia de la clase AES utilizando Aes.Create().
Establezca la clave, el IV y otros parámetros relevantes como el modo de cifrado.
Cifrar los datos utilizando la interfaz ICryptoTransform y escribirlos en un MemoryStream.
Descifrar los datos utilizando la misma clave e IV.
Creemos un programa básico de proceso de cifrado y descifrado 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#

Cifrado AES en C# (Cómo funciona para desarrolladores): Figura 1 - Salida de cifrado y descifrado mediante flujo de memoria

Explicación del Código

Aes aes = Aes.Create(): Esto crea una nueva instancia del algoritmo de cifrado AES.
**Clave Aes: La clave utilizada tanto para el cifrado como para el descifrado. Debe tener un tamaño válido, como 128 bits(16 bytes)192 bits o 256 bits.
Aes.IV: El vector de inicialización(IV), se utiliza para aleatorizar el proceso de cifrado. En este ejemplo, utilizamos un IV de ceros para simplificar.
MemoryStream: Esto nos permite trabajar con los datos encriptados como un flujo de bytes.
CryptoStream: Transforma el flujo de datos(cifrado o descifrado).

Ejemplo avanzado: Cifrado AES con clave personalizada e IV

A partir del ejemplo anterior, vamos a generar una clave aleatoria y un IV para que el cifrado sea más seguro.

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#

En este caso, generamos una nueva clave y un IV cada vez que se llama a la función. Esto proporciona un cifrado más robusto ya que la misma clave no se utiliza para cada operación. AES admite tamaños de clave como 128, 192 y 256 bits.

Descifrar datos con AES

El descifrado es el proceso inverso para cifrar datos. En nuestros ejemplos, para descifrar los datos deben proporcionarse la misma clave y el mismo IV utilizados para el cifrado. El proceso de descifrado consiste en convertir los datos cifrados a su forma original.

He aquí un ejemplo que utiliza los datos previamente codificados:

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#

Este código descifra los datos cifrados y los convierte en los datos originales.

IronPDF con cifrado AES

IronPDF es una biblioteca .NET sencilla y fácil de usar diseñada para generar, editar y manipular archivos PDF utilizando código C# simple. Permite a los desarrolladorescrear documentos PDF directamente a partir de HTMLel lenguaje de programación .NET, CSS y JavaScript puede resultar muy útil para generar informes, facturas u otros documentos de forma dinámica. Con soporte para combinar, dividir e incluso añadir funciones de seguridad como contraseñas o firmas digitales, IronPDF es una solución completa para la generación de PDF en aplicaciones .NET.

Integración de IronPDF con el cifrado AES

Cifrado AES en C# (Cómo funciona para desarrolladores): Figura 2 - IronPDF

Cuando generes informes o documentos confidenciales, es posible que necesites asegurarte de que los datos de esos PDF estén cifrados antes de compartirlos. AES(Estándar de cifrado avanzado) encryption es una solución perfecta para cifrar de forma segura el contenido de archivos PDF. Combinando IronPDF y el cifrado AES, puede proteger los datos de sus PDF sin perder la capacidad de trabajar con el documento en sí.

Paso 1: Crear un PDF con IronPDF

Utilice la clase ChromePdfRenderer para generar un PDF a partir de contenido HTML y guardarlo en un archivo:

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#

Paso 2: Cifrar el PDF con AES

Una vez creado el PDF, codifíquelo con 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#

Conclusión

Cifrado AES en C# (Cómo funciona para desarrolladores): Figura 3 - Licencias

La integración de IronPDF con el cifrado AES permite generar documentos dinámicos y seguros que son a la vez accesibles y cifrados. Tanto si desarrolla aplicaciones que requieren la generación segura de documentos como si gestiona informes confidenciales, la combinación de IronPDF con un cifrado sólido protege sus datos. IronPDF simplifica el trabajo con archivos PDF, mientras que AES garantiza la seguridad del contenido.

IronPDF ofrece unprueba gratuitaademás, debe facilitar a los desarrolladores la exploración de sus características antes de comprometerse. Si está listo para implementar IronPDF en sus proyectos, las licencias cuestan a partir de 749 dólares para una compra única.

< ANTERIOR
C# try catch finally (Cómo funciona para desarrolladores)

SIGUIENTE >
C# HttpClient (Cómo funciona para desarrolladores)