AES Encryption C#

Introduction:

Encryption is the way of converting plain text into ciphertext, which is a scrambled form of text that cannot be understood by anyone except the authorized recipient. This technique is used to protect sensitive data from unauthorized access. The Advanced Encryption Standard (AES) is a widely used encryption algorithm that provides a high level of security. In this article, we will learn how to implement AES Encryption in C#.

What is AES Encryption?

The AES Encryption algorithm is a Symmetric-key Block Cipher that uses a fixed-length block of 128 bits and key sizes of 128, 192, or 256 bits. It was developed by two Belgian cryptographers, Joan Daemen, and Vincent Rijmen, and was adopted as a U.S. Federal Information Processing Standard (FIPS) in 2001. AES Encryption is widely used in a variety of applications, including secure communication protocols, file encryption, and password protection.

The AES Encryption algorithm uses a series of mathematical operations to encrypt and decrypt data. The encryption process involves several rounds of substitution, permutation, and linear transformation operations. The key used for encrypting and decrypting the code is the same, which is why AES is known as a Symmetric-Key Algorithm. This means that the same key is used to encrypt and decrypt data.

Implementing AES Encryption in C#:

C# provides built-in support for AES Encryption through the System.Security.Cryptography namespace. This namespace contains various classes and methods that can be used to implement different encryption algorithms, including AES.

Below are the steps used in implementing AES Encryption in C#:

Step 1: Create an Instance of the AES Class

To implement AES Encryption in C#, we need to create an instance of the Aes class, which is provided by the System.Security.Cryptography namespace. The Aes class represents the AES Encryption algorithm and provides methods for encrypting and decrypting data.

C# Code:

using System.Security.Cryptography;

Aes aes = Aes.Create();

Step 2: Set the Key Size and Mode

The Aes class provides properties for setting the key size and mode. The key size determines the size of the encryption key that will be used for encryption and decryption. The key size can be 128, 192, or 256 bits. The mode determines how the data will be encrypted. The most commonly used modes are ECB (Electronic Codebook) and CBC (Cipher Block Chaining).

C# Code:

aes.KeySize = 256;
aes.Mode = CipherMode.CBC;

Step 3: Generate a Random Key and Initialization Vector

The AES Encryption algorithm requires a key and an Initialization Vector (IV) for encryption and decryption. The key is a secret value that is used to encrypt and decrypt data, and the IV is a random value that is used to initialize the encryption process. The Aes class provides methods for generating a random key and IV.

C# Code:

aes.GenerateKey();
aes.GenerateIV();

Step 4: Encrypt the Data

To encrypt the data, we need to create an instance of the ICryptoTransform interface, which is provided by the Aes class. The ICryptoTransform interface provides methods for transforming data using the AES Encryption algorithm.

C# Code:

We can then use the encryptor instance to encrypt the data using the TransformBlock method, which takes the plaintext data and returns the corresponding ciphertext.

C# Code:

byte[] plaintext = Encoding.UTF8.GetBytes("Hello, world!");
byte[] ciphertext = encryptor.TransformFinalBlock(plaintext, 0, plaintext.Length);

Step 5: Decrypt the Data

To decrypt the data, we need to create a new instance of the ICryptoTransform interface using the same key and IV that were used for encryption.

C# Code:

ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
byte[] plaintextBytes = decryptor.TransformFinalBlock(ciphertext, 0, ciphertext.Length);
string plaintext = Encoding.UTF8.GetString(plaintextBytes);

Here's the complete code for implementing AES Encryption in C#:

C# Code:

using System;
using System.Security.Cryptography;
using System.Text;

namespace AESExample
{
    class Program
    {
        static void Main(string[] args)
        {
            Aes aes = Aes.Create();
            aes.KeySize = 256;
            aes.Mode = CipherMode.CBC;
            aes.GenerateKey();
            aes.GenerateIV();

            string plaintext = "Hello, world!";
            byte[] ciphertext;

            using (ICryptoTransform encryptor = aes.CreateEncryptor())
            {
                byte[] plaintextBytes = Encoding.UTF8.GetBytes(plaintext);
                ciphertext = encryptor.TransformFinalBlock(plaintextBytes, 0, plaintextBytes.Length);
            }

            string decryptedText;

            using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
            {
                byte[] decryptedBytes = decryptor.TransformFinalBlock(ciphertext, 0, ciphertext.Length);
                decryptedText = Encoding.UTF8.GetString(decryptedBytes);
            }

            Console.WriteLine($"Plaintext: {plaintext}");
            Console.WriteLine($"Ciphertext: {Convert.ToBase64String(ciphertext)}");
            Console.WriteLine($"Decrypted text: {decryptedText}");
        }
    }
}

In this code, we create an instance of the Aes class and set the key size and mode. We then generate a random key and IV using the GenerateKey and GenerateIV methods. We create an ICryptoTransform instance using the CreateEncryptor method and use it to encrypt the plaintext. We then create a new ICryptoTransform instance using the same key and IV and use it to decrypt the ciphertext. Finally, we print the plaintext, ciphertext, and decrypted text to the console.

Next TopicWhat is DLL in C#

← prev next →