I saw many of the applications with out basic level of security with respect to data transfer etc. Few people uses Base64 Encoding while sending data through URL which is a common practice. But a simple Javascript code can reverse engineer your Base64 encoded string. If you wanna try to reverse engineer your Base64 encoded URL visit the belo link and paste your Encoded String and click on Decode. There you can see the Decoded Data.

http://ostermiller.org/calc/encode.html

If your Data is not secure enough then how you can keep your clients happy in respect of security to their data? In My today’s Blog I would like to explain Symmetric key Encryption and Decryption using Rijndael algorithm.

///////////////////////////////////////////////////////////////////////////////
// SAMPLE: Symmetric key encryption and decryption using Rijndael algorithm.
// THIS CODE AND INFORMATION IS PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND,
// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
///////////////////////////////////////////////////////////////////////////////

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

namespace UmaMahesh.Security
{
    /// 
    /// This class uses a symmetric key algorithm (Rijndael/AES) to encrypt and
    /// decrypt data. As long as encryption and decryption routines use the same
    /// parameters to generate the keys, the keys are guaranteed to be the same.
    /// The class uses static functions with duplicate code to make it easier to
    /// demonstrate encryption and decryption logic. In a real-life application,
    /// this may not be the most efficient way of handling encryption, so – as
    /// soon as you feel comfortable with it – you may want to redesign this class.
    /// 
    public static class AESAlg
    {
        static string saltValue, hashAlgorithm, initVector, passPhrase;
        static int passwordIterations, keySize;
        static AESAlg()
        {
            //string[] EncDecKeys = System.Configuration.ConfigurationManager.AppSettings["EDVal"].Split(‘;’);
            passPhrase = EncDecProp.PassPhrase;
            saltValue = EncDecProp.SaltValue;
            hashAlgorithm = EncDecProp.HashAlgorithm;
            passwordIterations = EncDecProp.PasswordIterations;
            initVector = EncDecProp.InitVector;
            keySize = EncDecProp.KeySize;
        }

        /// 
        /// Encrypts specified plaintext using Rijndael symmetric key algorithm
        /// and returns a base64-encoded result.
        /// 
        /// 
        /// Plaintext value to be encrypted.
        /// 
        /// 
        /// Passphrase from which a pseudo-random password will be derived. The
        /// derived password will be used to generate the encryption key.
        /// Passphrase can be any string. In this example we assume that this
        /// passphrase is an ASCII string.
        /// 
        /// 
        /// Salt value used along with passphrase to generate password. Salt can
        /// be any string. In this example we assume that salt is an ASCII string.
        /// 
        /// 
        /// Hash algorithm used to generate password. Allowed values are: “MD5? and
        /// “SHA1?. SHA1 hashes are a bit slower, but more secure than MD5 hashes.
        /// 
        /// 
        /// Number of iterations used to generate password. One or two iterations
        /// should be enough.
        /// 
        /// 
        /// Initialization vector (or IV). This value is required to encrypt the
        /// first block of plaintext data. For RijndaelManaged class IV must be
        /// exactly 16 ASCII characters long.
        /// 
        /// 
        /// Size of encryption key in bits. Allowed values are: 128, 192, and 256.
        /// Longer keys are more secure than shorter keys.
        /// 
        /// 
        /// Encrypted value formatted as a base64-encoded string.
        /// 

        public static string Encrypt(string plainText)
        {
            // Convert strings into byte arrays.
            // Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
            // Convert our plaintext into a byte array.
            // Let us assume that plaintext contains UTF8-encoded characters.
            byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
            // First, we must create a password, from which the key will be derived.
            // This password will be generated from the specified passphrase and
            // salt value. The password will be created using the specified hash
            // algorithm. Password creation can be done in several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
            passPhrase,
            saltValueBytes,
            hashAlgorithm,
            passwordIterations);
            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);
            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged();
            // It is reasonable to set encryption mode to Cipher Block Chaining
            // (CBC). Use default options for other symmetric key parameters.
            symmetricKey.Mode = CipherMode.CBC;
            // Generate encryptor from the existing key bytes and initialization
            // vector. Key size will be defined based on the number of the key
            // bytes.
            ICryptoTransform encryptor = symmetricKey.CreateEncryptor(
            keyBytes,
            initVectorBytes);
            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = new MemoryStream();
            // Define cryptographic stream (always use Write mode for encryption).
            CryptoStream cryptoStream = new CryptoStream(memoryStream,
            encryptor,
            CryptoStreamMode.Write);
            // Start encrypting.
            cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
            // Finish encrypting.
            cryptoStream.FlushFinalBlock();
            // Convert our encrypted data from a memory stream into a byte array.
            byte[] cipherTextBytes = memoryStream.ToArray();
            // Close both streams.
            memoryStream.Close();
            cryptoStream.Close();
            // Convert encrypted data into a base64-encoded string.
            string cipherText = Convert.ToBase64String(cipherTextBytes);
            // Return encrypted string.
            return cipherText;
        }

        /// 
        /// Decrypts specified ciphertext using Rijndael symmetric key algorithm.
        /// 
        /// 
        /// Base64-formatted ciphertext value.
        /// 
        /// 
        /// Passphrase from which a pseudo-random password will be derived. The
        /// derived password will be used to generate the encryption key.
        /// Passphrase can be any string. In this example we assume that this
        /// passphrase is an ASCII string.
        /// 
        /// 
        /// Salt value used along with passphrase to generate password. Salt can
        /// be any string. In this example we assume that salt is an ASCII string.
        /// 
        /// 
        /// Hash algorithm used to generate password. Allowed values are: “MD5? and
        /// “SHA1?. SHA1 hashes are a bit slower, but more secure than MD5 hashes.
        /// 
        /// 
        /// Number of iterations used to generate password. One or two iterations
        /// should be enough.
        /// 
        /// 
        /// Initialization vector (or IV). This value is required to encrypt the
        /// first block of plaintext data. For RijndaelManaged class IV must be
        /// exactly 16 ASCII characters long.
        /// 
        /// 
        /// Size of encryption key in bits. Allowed values are: 128, 192, and 256.
        /// Longer keys are more secure than shorter keys.
        /// 
        /// 
        /// Decrypted string value.
        /// 
        /// 
        /// Most of the logic in this function is similar to the Encrypt
        /// logic. In order for decryption to work, all parameters of this function
        /// – except cipherText value – must match the corresponding parameters of
        /// the Encrypt function which was called to generate the
        /// ciphertext.
        /// 
        public static string Decrypt(string cipherText)
        {
            // Convert strings defining encryption key characteristics into byte
            // arrays. Let us assume that strings only contain ASCII codes.
            // If strings include Unicode characters, use Unicode, UTF7, or UTF8
            // encoding.
            byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
            byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
            // Convert our ciphertext into a byte array.
            byte[] cipherTextBytes = Convert.FromBase64String(cipherText);
            // First, we must create a password, from which the key will be
            // derived. This password will be generated from the specified
            // passphrase and salt value. The password will be created using
            // the specified hash algorithm. Password creation can be done in
            // several iterations.
            PasswordDeriveBytes password = new PasswordDeriveBytes(
            passPhrase,
            saltValueBytes,
            hashAlgorithm,
            passwordIterations);
            // Use the password to generate pseudo-random bytes for the encryption
            // key. Specify the size of the key in bytes (instead of bits).
            byte[] keyBytes = password.GetBytes(keySize / 8);
            // Create uninitialized Rijndael encryption object.
            RijndaelManaged symmetricKey = new RijndaelManaged();
            // It is reasonable to set encryption mode to Cipher Block Chaining
            // (CBC). Use default options for other symmetric key parameters.
            symmetricKey.Mode = CipherMode.CBC;
            // Generate decryptor from the existing key bytes and initialization
            // vector. Key size will be defined based on the number of the key
            // bytes.
            ICryptoTransform decryptor = symmetricKey.CreateDecryptor(
            keyBytes,
            initVectorBytes);
            // Define memory stream which will be used to hold encrypted data.
            MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
            // Define cryptographic stream (always use Read mode for encryption).
            CryptoStream cryptoStream = new CryptoStream(memoryStream,
            decryptor,
            CryptoStreamMode.Read);
            // Since at this point we don’t know what the size of decrypted data
            // will be, allocate the buffer long enough to hold ciphertext;
            // plaintext is never longer than ciphertext.
            byte[] plainTextBytes = new byte[cipherTextBytes.Length];
            // Start decrypting.
            int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
            // Close both streams.
            memoryStream.Close();
            cryptoStream.Close();
            // Convert decrypted data into a string.
            // Let us assume that the original plaintext string was UTF8-encoded.
            string plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);

            // Return decrypted string.
            return plainText;
        }
    }
    static class EncDecProp
    {
        public static readonly string PassPhrase = "Uw@W@h3$h", HashAlgorithm = "SHA1", SaltValue = "s@lTMagi”, InitVector = “@AB2cd3EF4gh5IJ$";
        public static readonly int KeySize = 256, PasswordIterations = 2;
    }
}

PS: Please Change PassPhrase, SaltValue, InitVector Values based on your Choice. Based on those key values the Encryption and Decryption of the Data Happens

Hope You Enjoyed the blog…

Comments (30)

  1. Kearl

    Thanks for the share. I really enjoyed the post

  2. Then finally a very good writing related to the topic, keep up the great work and therefore I wish to examine much more of your stuff in the longer term.

  3. Thanks a ton for share really great informations. Your internet is wonderful, I am fascinated by the facts that you just have on this weblog. It reveals how effectively you have an understanding of this topic. Bookmarked this page, will come back again for alot more. You, my buddy, I discovered just the material I currently looked everywhere and just couldn’t find. What an ideal blog. Like this internet site your internet site is one particular of my new absolute favorites.I like this data proven and it has given me some type of drive to possess achievement for some purpose, so retain up the decent work!

  4. Samson

    I just added your blog site to my blogroll.

  5. online car games

    Good blog! I truly love how it’s easy on my eyes as well as the details are well written. I have subscribed to your rss feed! Have a nice day!

  6. Ron Tedwater

    Really nice post, added your blog link in my site

  7. Rudolph Sambucetti

    Nice Post. I Really Liked it:)

  8. jim

    Finally, an issue that I am passionate about. I have looked for information of this caliber for the last several hours. Your site is greatly appreciated.

  9. Jane

    Wow this is a great resource.. I’m enjoying it.. good article

  10. maria andros

    You are a Excellent Blogger. Great work keep it coming

  11. Saul Mikami

    Wow this is a great resource.. I’m enjoying it.. good article

  12. Vinod

    Valuable info. Lucky me I found your site by accident, I bookmarked it.

  13. dany

    Nice site, nice and easy on the eyes and great content too.

  14. Krystle Vanhauen

    Appreciate it for taking the moment to discuss about this, I fully feel fervently about it and I love acquiring knowledge about this theme. Please, as you gain information, please add more to this weblog with more information. I have found it very beneficial

  15. Patch Clarissa

    I love to visit at your weblog frequently, nice posts in a single website.

  16. Splett

    Hiya! I simply want to give an enormous thumbs up for the nice info you will have here on this post. I can be coming again to your weblog for more soon.

  17. gracelyn

    ha-ha-ha-ha! That is standart point of view, be more original!

  18. Danial

    Your place is valueble for me. Thanks!…

  19. dave

    Can I simply say what a relief to seek out somebody who truly is aware of what theyre speaking about on the internet. You definitely know how to convey a problem to gentle and make it important. Extra people have to learn this and understand this facet of the story. I cant consider youre no more common because you positively have the gift.

  20. hellya

    Nonetheless, you’ve got obtained an edginess to what you’re furnishing the following

  21. Jimmy

    Hello Mr. Expert,

    When are going to write up a follow up article on this post… is it going to be anytime soon? 🙂

    Jimmy

Comments are closed.