.NET Framework
एन्क्रिप्शन / क्रिप्टोग्राफी

टिप्पणियों

RijndaelManaged

आवश्यक नामस्थान: System.Security.Cryptography

private class Encryption {
    
          private const string SecretKey = "topSecretKeyusedforEncryptions";
    
          private const string SecretIv = "secretVectorHere";
    
          public string Encrypt(string data) {
            return string.IsNullOrEmpty(data) ? data : Convert.ToBase64String(this.EncryptStringToBytesAes(data, this.GetCryptographyKey(), this.GetCryptographyIv()));
          }
    
          public string Decrypt(string data) {
            return string.IsNullOrEmpty(data) ? data : this.DecryptStringFromBytesAes(Convert.FromBase64String(data), this.GetCryptographyKey(), this.GetCryptographyIv());
          }
    
          private byte[] GetCryptographyKey() {
            return Encoding.ASCII.GetBytes(SecretKey.Replace('e', '!'));
          }
    
          private byte[] GetCryptographyIv() {
            return Encoding.ASCII.GetBytes(SecretIv.Replace('r', '!'));
          }
    
          private byte[] EncryptStringToBytesAes(string plainText, byte[] key, byte[] iv) {
            MemoryStream encrypt;
            RijndaelManaged aesAlg = null;
            try {
              aesAlg = new RijndaelManaged {
                Key = key,
                IV = iv
              };
              var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
              encrypt = new MemoryStream();
              using (var csEncrypt = new CryptoStream(encrypt, encryptor, CryptoStreamMode.Write)) {
                using (var swEncrypt = new StreamWriter(csEncrypt)) {
                  swEncrypt.Write(plainText);
                }
              }
            } finally {
              aesAlg?.Clear();
            }
            return encrypt.ToArray();
          }
    
          private string DecryptStringFromBytesAes(byte[] cipherText, byte[] key, byte[] iv) {
            RijndaelManaged aesAlg = null;
            string plaintext;
            try {
              aesAlg = new RijndaelManaged {
                Key = key,
                IV = iv
              };
              var decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
              using (var msDecrypt = new MemoryStream(cipherText)) {
                using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) {
                  using (var srDecrypt = new StreamReader(csDecrypt))
                    plaintext = srDecrypt.ReadToEnd();
                }
              }
            } finally {
              aesAlg?.Clear();
            }
            return plaintext;
          }
        }

प्रयोग

var textToEncrypt = "hello World";

 var encrypted = new Encryption().Encrypt(textToEncrypt); //-> zBmW+FUxOvdbpOGm9Ss/vQ==

 var decrypted = new Encryption().Decrypt(encrypted); //-> hello World

ध्यान दें:

• रिजेंडेल मानक सममित क्रिप्टोग्राफिक एल्गोरिदम एईएस का पूर्ववर्ती है।

AES (C # में) का उपयोग करके डेटा एन्क्रिप्ट और डिक्रिप्ट करें

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

namespace Aes_Example
{
    class AesExample
    {
        public static void Main()
        {
            try
            {
                string original = "Here is some data to encrypt!";

                // Create a new instance of the Aes class.
                // This generates a new key and initialization vector (IV).
                using (Aes myAes = Aes.Create())
                {
                    // Encrypt the string to an array of bytes.
                    byte[] encrypted = EncryptStringToBytes_Aes(original, 
                                                                myAes.Key,
                                                                myAes.IV);

                    // Decrypt the bytes to a string.
                    string roundtrip = DecryptStringFromBytes_Aes(encrypted, 
                                                                  myAes.Key, 
                                                                  myAes.IV);

                    //Display the original data and the decrypted data.
                    Console.WriteLine("Original:   {0}", original);
                    Console.WriteLine("Round Trip: {0}", roundtrip);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
            }
        }

        static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            byte[] encrypted;

            // Create an Aes object with the specified key and IV.
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = IV;

                // Create a decrytor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key,
                                                                    aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt,
                                                                     encryptor,
                                                                     CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }

                        encrypted = msEncrypt.ToArray();
                    }
                }
            }

            // Return the encrypted bytes from the memory stream.
            return encrypted;
        }

        static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            // Declare the string used to hold the decrypted text.
            string plaintext = null;

            // Create an Aes object with the specified key and IV.
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Key = Key;
                aesAlg.IV = IV;

                // Create a decrytor to perform the stream transform.
                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key,
                                                                    aesAlg.IV);

                // Create the streams used for decryption.
                using (MemoryStream msDecrypt = new MemoryStream(cipherText))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt,
                                                                     decryptor,
                                                                     CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return plaintext;
        }
    }
}

यह उदाहरण MSDN का है ।

यह एक कंसोल डेमो एप्लिकेशन है, जिसमें दिखाया गया है कि मानक एईएस एन्क्रिप्शन का उपयोग करके स्ट्रिंग को कैसे एन्क्रिप्ट किया जाए, और बाद में इसे कैसे डिक्रिप्ट किया जाए।

( एईएस = उन्नत एन्क्रिप्शन स्टैंडर्ड , 2001 में यूएस नेशनल इंस्टीट्यूट ऑफ स्टैंडर्ड एंड टेक्नोलॉजी (एनआईएसटी) द्वारा स्थापित इलेक्ट्रॉनिक डेटा के एन्क्रिप्शन के लिए एक विनिर्देश जो अभी भी सममित एन्क्रिप्शन के लिए वास्तविक मानक है)

टिप्पणियाँ:

• एक वास्तविक एन्क्रिप्शन परिदृश्य में, आपको एक उचित सिफर मोड चुनने की आवश्यकता होती है (इसे CipherMode एन्यूमरेशन से मान चुनकर Mode प्रॉपर्टी को सौंपा जा सकता है)। कभी भी CipherMode.ECB (इलेक्ट्रॉनिक कोडबुक मोड) का उपयोग न करें, क्योंकि यह एक कमजोर साइबर स्ट्रीम की खरीद करता है

• एक अच्छा (और कमजोर नहीं) Key , या तो एक क्रिप्टोग्राफिक यादृच्छिक जनरेटर का उपयोग करें या ऊपर दिए गए उदाहरण का उपयोग करें ( एक पासवर्ड से कुंजी बनाएं )। अनुशंसित KeySize 256 बिट है। समर्थित कुंजी आकार LegalKeySizes संपत्ति के माध्यम से उपलब्ध हैं।

• प्रारंभिक सदिश IV को आरंभ करने के लिए, आप एक SALT का उपयोग कर सकते हैं जैसा कि ऊपर दिए गए उदाहरण में दिखाया गया है ( रैंडम SALT )

• सपोर्टेड ब्लॉक आकार SupportedBlockSizes प्रॉपर्टी के माध्यम से उपलब्ध हैं, ब्लॉक साइज को BlockSize प्रॉपर्टी के जरिए असाइन किया जा सकता है

उपयोग: मुख्य () विधि देखें।

पासवर्ड / रैंडम SALT से एक कुंजी बनाएँ (C # में)

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

public class PasswordDerivedBytesExample
{
    public static void Main(String[] args)
    {
        // Get a password from the user.
        Console.WriteLine("Enter a password to produce a key:");

        byte[] pwd = Encoding.Unicode.GetBytes(Console.ReadLine());

        byte[] salt = CreateRandomSalt(7);

        // Create a TripleDESCryptoServiceProvider object.
        TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();

        try
        {
            Console.WriteLine("Creating a key with PasswordDeriveBytes...");

            // Create a PasswordDeriveBytes object and then create
            // a TripleDES key from the password and salt.
            PasswordDeriveBytes pdb = new PasswordDeriveBytes(pwd, salt);

            // Create the key and set it to the Key property
            // of the TripleDESCryptoServiceProvider object.
            tdes.Key = pdb.CryptDeriveKey("TripleDES", "SHA1", 192, tdes.IV);

            Console.WriteLine("Operation complete.");
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            // Clear the buffers
            ClearBytes(pwd);
            ClearBytes(salt);

            // Clear the key.
            tdes.Clear();
        }

        Console.ReadLine();
    }

    #region Helper methods

    /// <summary>
    /// Generates a random salt value of the specified length.
    /// </summary>
    public static byte[] CreateRandomSalt(int length)
    {
        // Create a buffer
        byte[] randBytes;

        if (length >= 1)
        {
            randBytes = new byte[length];
        }
        else
        {
            randBytes = new byte[1];
        }

        // Create a new RNGCryptoServiceProvider.
        RNGCryptoServiceProvider rand = new RNGCryptoServiceProvider();

        // Fill the buffer with random bytes.
        rand.GetBytes(randBytes);

        // return the bytes.
        return randBytes;
    }

    /// <summary>
    /// Clear the bytes in a buffer so they can't later be read from memory.
    /// </summary>
    public static void ClearBytes(byte[] buffer)
    {
        // Check arguments.
        if (buffer == null)
        {
            throw new ArgumentNullException("buffer");
        }

        // Set each byte in the buffer to 0.
        for (int x = 0; x < buffer.Length; x++)
        {
            buffer[x] = 0;
        }
    }

    #endregion
}

यह उदाहरण MSDN से लिया गया है ।

यह एक कंसोल डेमो है, और यह दिखाता है कि उपयोगकर्ता द्वारा परिभाषित पासवर्ड के आधार पर एक सुरक्षित कुंजी कैसे बनाई जाए, और क्रिप्टोग्राफिक यादृच्छिक जनरेटर के आधार पर यादृच्छिक SALT कैसे बनाया जाए।

टिप्पणियाँ:

• बिल्ट-इन फ़ंक्शन PasswordDeriveBytes से कुंजी बनाने के लिए मानक PBKDF1 एल्गोरिथ्म का उपयोग करता है। डिफ़ॉल्ट रूप से, यह क्रूर बल के हमलों को धीमा करने के लिए कुंजी उत्पन्न करने के लिए 100 पुनरावृत्तियों का उपयोग करता है। SALT कुंजी को बेतरतीब ढंग से आगे बढ़ाती है।

• फ़ंक्शन CryptDeriveKey , PasswordDeriveBytes द्वारा बनाई गई कुंजी को निर्दिष्ट हैश एल्गोरिथ्म (यहां "SHA1") का उपयोग करके निर्दिष्ट एन्क्रिप्शन एल्गोरिथ्म (यहां "ट्रिपलडीईएस") के साथ संगत में परिवर्तित करता है। इस उदाहरण में कीज़ेट 192 बाइट्स है, और इनिशियलाइज़ेशन वेक्टर IV ट्रिपल-डेस क्रिप्टो प्रदाता से लिया गया है

• आमतौर पर, इस तंत्र का उपयोग पासवर्ड द्वारा एक मजबूत यादृच्छिक उत्पन्न कुंजी की रक्षा के लिए किया जाता है, जो बड़ी मात्रा में डेटा को एन्क्रिप्ट करता है। आप एक ही डेटा (एक अलग यादृच्छिक कुंजी द्वारा संरक्षित किया जा रहा है) तक पहुँच प्रदान करने के लिए विभिन्न उपयोगकर्ताओं के कई पासवर्ड प्रदान करने के लिए भी इसका उपयोग कर सकते हैं।

• दुर्भाग्य से, CryptDeriveKey वर्तमान में एईएस का समर्थन नहीं करता है। यहाँ देखें
  नोट: वर्कअराउंड के रूप में, आप एईएस के साथ संरक्षित किए जाने वाले डेटा के एन्क्रिप्शन के लिए एक यादृच्छिक एईएस कुंजी बना सकते हैं और एईएस कुंजी को CryptDeriveKey -कंटेनर में स्टोर कर सकते हैं जो CryptDeriveKey द्वारा निर्मित कुंजी का उपयोग करता है। लेकिन यह ट्रिपलडीईएस की सुरक्षा को सीमित करता है, एईएस की बड़ी चाबियों का लाभ नहीं उठाता है और ट्रिपलडीईएस पर निर्भरता पैदा करता है।

उपयोग: मुख्य () विधि देखें।

क्रिप्टोग्राफी (एईएस) का उपयोग करते हुए एन्क्रिप्शन और डिक्रिप्शन

डिक्रिप्शन कोड

    public static string Decrypt(string cipherText)
    {
        if (cipherText == null)
            return null;

        byte[] cipherBytes = Convert.FromBase64String(cipherText);
        using (Aes encryptor = Aes.Create())
        {
            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(CryptKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
            encryptor.Key = pdb.GetBytes(32);
            encryptor.IV = pdb.GetBytes(16);

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(cipherBytes, 0, cipherBytes.Length);
                    cs.Close();
                }

                cipherText = Encoding.Unicode.GetString(ms.ToArray());
            }
        }
    
        return cipherText;
    }

एन्क्रिप्शन कोड

    public static string Encrypt(string cipherText)
    {
        if (cipherText == null)
            return null;
      
        byte[] clearBytes = Encoding.Unicode.GetBytes(cipherText);
        using (Aes encryptor = Aes.Create())
        {
            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(CryptKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
            encryptor.Key = pdb.GetBytes(32);
            encryptor.IV = pdb.GetBytes(16);

            using (MemoryStream ms = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(clearBytes, 0, clearBytes.Length);
                    cs.Close();
                }

                cipherText = Convert.ToBase64String(ms.ToArray());
            }
        }
        return cipherText;
    }

प्रयोग

var textToEncrypt = "TestEncrypt";

var encrypted = Encrypt(textToEncrypt);

var decrypted = Decrypt(encrypted);