Encrypt a Text in C#

Encrypting text is a common practice in order to protect the confidentiality of information. There are various techniques that can be used to encrypt text, each with its own set of advantages and disadvantages. In this article, we will discuss some of the possible techniques to encrypt text in C# and provide examples of how they can be implemented.

Symmetric Key Encryption

Symmetric key encryption is a technique in which the same key is used for both encryption and decryption of the text. Some examples of symmetric key algorithms are AES (Advanced Encryption Standard) and DES (Data Encryption Standard).

Here is an example of how symmetric key encryption can be implemented in C# using the AES algorithm:

using System;
using System.IO;
using System.Security.Cryptography;

namespace SymmetricEncryptionExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Generate a random key
            var key = new byte[32];
            using (var rng = RandomNumberGenerator.Create())
            {
                rng.GetBytes(key);
            }

            // Encrypt the text
            string plainText = "Hello, World!";
            byte[] encryptedText = Encrypt(plainText, key);

            // Decrypt the text
            string decryptedText = Decrypt(encryptedText, key);

            Console.WriteLine($"Plain text: {plainText}");
            Console.WriteLine($"Decrypted text: {decryptedText}");
        }

        static byte[] Encrypt(string plainText, byte[] key)
        {
            byte[] encryptedText;
            using (var aes = Aes.Create())
            {
                aes.Key = key;
                aes.GenerateIV();
                using (var encryptor = aes.CreateEncryptor())
                using (var ms = new MemoryStream())
                {
                    using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
                    using (var sw = new StreamWriter(cs))
                    {
                        sw.Write(plainText);
                    }
                    encryptedText = ms.ToArray();
                }
            }
            return encryptedText;
        }

        static string Decrypt(byte[] encryptedText, byte[] key)
        {
            string plainText;
            using (var aes = Aes.Create())
            {
                aes.Key = key;
                using (var decryptor = aes.CreateDecryptor())
                using (var ms = new MemoryStream(encryptedText))
                {
                    using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                    using (var sr = new StreamReader(cs))
                    {
                        plainText = sr.ReadToEnd();
                    }
                }
            }
            return plainText;
        }
    }
}

Asymmetric Key Encryption

Asymmetric key encryption, also known as public-key encryption, is a technique in which a pair of keys is used for encryption and decryption of the text. One of the keys, known as the private key, is kept secret and is used for decryption, while the other key, known as the public key, is made publicly available and is used for encryption. Some examples of asymmetric key algorithms are RSA (Rivest-Shamir-Adleman) and ECC (Elliptic Curve Cryptography).

Here is an example of how asymmetric key encryption can be implemented in C# using the RSA algorithm:

using System;
using System.IO;
using System.Security.Cryptography;

namespace AsymmetricEncryptionExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Generate a new key pair
            var keyPair = GenerateKeyPair();

            // Encrypt the text
            string plainText = "Hello, World!";
            byte[] encryptedText = Encrypt(plainText, keyPair.PublicKey);

            // Decrypt the text
            string decryptedText = Decrypt(encryptedText, keyPair.PrivateKey);

            Console.WriteLine($"Plain text: {plainText}");
            Console.WriteLine($"Decrypted text: {decryptedText}");
        }

        static (RSAParameters PublicKey, RSAParameters PrivateKey) GenerateKeyPair()
        {
            using (var rsa = RSA.Create())
            {
                return (rsa.ExportParameters(false), rsa.ExportParameters(true));
            }
        }

        static byte[] Encrypt(string plainText, RSAParameters publicKey)
        {
            byte[] encryptedText;
            using (var rsa = RSA.Create())
            {
                rsa.ImportParameters(publicKey);
                encryptedText = rsa.Encrypt(System.Text.Encoding.UTF8.GetBytes(plainText), RSAEncryptionPadding.OaepSHA1);
            }
            return encryptedText;
        }

        static string Decrypt(byte[] encryptedText, RSAParameters privateKey)
        {
            string plainText;
            using (var rsa = RSA.Create())
            {
                rsa.ImportParameters(privateKey);
                plainText = System.Text.Encoding.UTF8.GetString(rsa.Decrypt(encryptedText, RSAEncryptionPadding.OaepSHA1));
            }
            return plainText;
        }
    }
}

Hash-Based Encryption

Hash-based encryption, also known as message authentication, is a technique in which a fixed-size hash value is generated from the text and is used as a representation of the text. The hash value can be used to verify the integrity of the text, but it cannot be used to recover the original text. Some examples of hash algorithms are SHA (Secure Hash Algorithm) and MD5 (Message Digest Algorithm 5).

Here is an example of how hash-based encryption can be implemented in C# using the SHA256 algorithm:

using System;
using System.Security.Cryptography;

namespace HashBasedEncryptionExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Generate the hash value
            string plainText = "Hello, World!";
            byte[] hashValue = GenerateHash(plainText);

            // Verify the hash value
            bool isValid = VerifyHash(plainText, hashValue);

            Console.WriteLine($"Plain text: {plainText}");
            Console.WriteLine($"Hash value {Convert.ToBase64String(hashValue)}");
            Console.WriteLine($"Is valid: {isValid}");
}

    static byte[] GenerateHash(string plainText)
    {
        using (var sha = SHA256.Create())
        {
            return sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(plainText));
        }
    }

    static bool VerifyHash(string plainText, byte[] hashValue)
    {
        using (var sha = SHA256.Create())
        {
            byte[] computedHashValue = sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(plainText));
            return computedHashValue.Equals(hashValue);
        }
    }
}
}

Conclusion

In this article, we discussed some of the possible techniques to encrypt text in C#, including symmetric key encryption, asymmetric key encryption, and hash-based encryption. Each technique has its own set of advantages and disadvantages, and the appropriate technique should be chosen based on the specific requirements and constraints of the application.