Implement Symmetric And Asymmetric Cryptography Algorithms With C#

Keeping your users' data in a secure environment is very important step while building an application, especially when you are dealing with sensitive information, such as - Emails, Passwords, and E-Payment information (Bank Accounts, Payment cards, .etc.), and also when your application sends and receives the data over a network.In these situations, you have to be sure that no one can tamper with the data or steal it; and make your users feel comfortable while they are using your application because they know that their data is secure.

In this article, I’ll try to explain the differences between symmetric and asymmetric algorithms and how you can implement these algorithms in your app using C# programming language.

So, what are symmetric and asymmetric algorithms?

Before I start with symmetric and asymmetric algorithms, I’ll explain Cryptography in general.

Cryptography is about encrypting and decrypting data. With encryption, you convert a plain text (that’s human readable) into a random array of bytes. Decryption is the opposite process, you convert the random array of bytes into a plain text.

Encrypting any piece of plain text needs a key to do the operation and also, the decrypting process needs a key to convert encrypted data into a plain text. A key is the controller of the encryption process that is used by an algorithm. Actually, here is the main difference between symmetric and asymmetric strategies. A symmetric algorithm uses one key to encrypt and decrypt your data, however, the asymmetric algorithms use two different keys which are mathematically related to each other. One of these keys is public and can be used by everyone. The other key is private and it should be used only by you and never shared with anyone.

Another difference between symmetric and asymmetric algorithms is the performance and size. Symmetric encryption is faster and used to encrypt a large data sets. Asymmetric is well suited for encrypting a small messages. But using these two strategies lead you to implement a robust security system in your application.

 

Implementing symmetric cryptography in your C# application

One of the most popular symmetric algorithms is AES (Advanced Encryption Security). You can find all the cryptography classes in System.Security.Cryptography namespace. In this tutorial, I will use AES algorithm to encrypt a piece of plain text and save it into a file and also read this file and decrypt its content to a plain text.

Note

In this tutorial, I will use Console Application to concentrate only on the encryption code without event handlers and something like this.

Let’s start,

Open Visual Studio (I use Visual Studio 2017) and click on "New project".

 

Choose console application and name the project as you want.

 

Inside the program.cs file, write the following code. The code is self-explanatory. 

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

namespace SymmetricTutorial
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a new instance of the AES algorithm
            SymmetricAlgorithm aes = new AesManaged();

            byte[] key = aes.Key; // Key propery contains the key of the aes algorithm you can create your own

            Console.WriteLine("Enter your message here to encrypt:");
            string message = Console.ReadLine();

            // Call the encryptText method to encrypt the a string and save the result to a file
            EncryptText(aes, message, "encryptedData.dat");

            // Call the decryptData method to get the encrypted text from the file and print it
            Console.WriteLine("Decrypted message: {0}", DecryptData(aes, "encryptedData.dat"));



        }

        // Method to encrypte a string data and save it in a specific file using an AES algorithm
        static void EncryptText(SymmetricAlgorithm aesAlgorithm,string text,string fileName)
        {
            // Create an encryptor from the AES algorithm instance and pass the aes algorithm key and inialiaztion vector to generate a new random sequence each time for the same text
            ICryptoTransform encryptor = aesAlgorithm.CreateEncryptor(aesAlgorithm.Key, aesAlgorithm.IV);

            // Create a memory stream to save the encrypted data in it
            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms,encryptor,CryptoStreamMode.Write))
                {
                    using (StreamWriter writer = new StreamWriter(cs))
                    {
                        // Write the text in the stream writer
                        writer.Write(text);
                    }
                }

                // Get the result as a byte array from the memory stream
                byte[] encryptedDataBuffer = ms.ToArray();

                // Write the data to a file
                File.WriteAllBytes(fileName, encryptedDataBuffer);
            }
        }

        // Method to decrypt a data from a specific file and return the result as a string
        static string DecryptData(SymmetricAlgorithm aesAlgorithm, string fileName)
        {
            // Create a decryptor from the aes algorithm
            ICryptoTransform decryptor = aesAlgorithm.CreateDecryptor(aesAlgorithm.Key, aesAlgorithm.IV);

            // Read the encrypted bytes from the file
            byte[] encryptedDataBuffer = File.ReadAllBytes(fileName);

            // Create a memorystream to write the decrypted data in it
            using (MemoryStream ms = new MemoryStream(encryptedDataBuffer))
            {
                using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader reader = new StreamReader(cs))
                    {
                        // Reutrn all the data from the streamreader
                        return reader.ReadToEnd();
                    }
                }
            }
        }
    }
}

Note: In this example I encrypted a text and saved it to a file. Then, I read this file, decrypted its content, and showed the result on the console window.

 

Implementing Asymmetric cryptography in your C# application

The common asymmetric algorithm is called RSA. So in this example, I'll use it to do the same action that I did in the previous one. Again, create a Console Application project (1 and 2 steps in the previous example).

 

Inside the program.cs file, write the following code,

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

namespace AsymmetricTutorial
{
    class Program
    {

        static void Main(string[] args)
        {
            // Create an instance of the RSA algorithm class
            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            // Get the public keyy
            string publicKey = rsa.ToXmlString(false); // false to get the public key
            string privateKey = rsa.ToXmlString(true); // true to get the private key

            // Call the encryptText method
            EncryptText(publicKey, "Hello from C# Corner", "encryptedData.dat");

            // Call the decryptData method and print the result on the screen
            Console.WriteLine("Decrypted message: {0}", DecryptData(privateKey, "encryptedData.dat"));

        }

        // Create a method to encrypt a text and save it to a specific file using a RSA algorithm public key
        static void EncryptText(string publicKey ,string text,string fileName)
        {
            // Convert the text to an array of bytes
            UnicodeEncoding byteConverter = new UnicodeEncoding();
            byte[] dataToEncrypt = byteConverter.GetBytes(text);

            // Create a byte array to store the encrypted data in it
            byte[] encryptedData;
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                // Set the rsa pulic key
                rsa.FromXmlString(publicKey);

                // Encrypt the data and store it in the encyptedData Array
                encryptedData = rsa.Encrypt(dataToEncrypt, false);
            }
            // Save the encypted data array into a file
            File.WriteAllBytes(fileName, encryptedData);

            Console.WriteLine("Data has been encrypted");
        }

        // Method to decrypt the data withing a specific file using a RSA algorithm private key
        static string DecryptData(string privateKey,string fileName)
        {
            // read the encrypted bytes from the file
            byte[] dataToDecrypt = File.ReadAllBytes(fileName);

            // Create an array to store the decrypted data in it
            byte[] decryptedData;
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                // Set the private key of the algorithm
                rsa.FromXmlString(privateKey);
                decryptedData = rsa.Decrypt(dataToDecrypt, false);
            }

            // Get the string value from the decryptedData byte array
            UnicodeEncoding byteConverter = new UnicodeEncoding();
            return byteConverter.GetString(decryptedData);
        }
    }
}

In this example, I used two keys - one to encrypt the data and one to decrypt.

 

Conclusion

Using Symmetric and Asymmetric algorithms and implementing them correctly in your application increases the security system in the app as well as enhances the usability of your app because it becomes safer for users to share their personal data. This is not the only use of cryptography algorithms; actually, they are used in different situations also, such as - Digital signature, Digital certificates, etc.