Szyfrowanie i deszyfrowanie łańcucha w C# [duplikat]

UPDATE 23/Dec / 2015: ponieważ ta odpowiedź wydaje się być coraz wiele upvotes, zaktualizowałem go naprawić głupie błędy i ogólnie poprawić kod na podstawie komentarzy i opinii. Lista konkretnych ulepszeń znajduje się na końcu postu.

Jak mówili inni, Kryptografia nie jest prosta, więc najlepiej unikać "kręcenia własnego" algorytmu szyfrowania.

Możesz jednak "zwijać własną" klasę owijania wokół czegoś takiego jak wbudowany RijndaelManaged zajęcia z kryptografii.

Rijndael to algorytmiczna nazwa obecnego standardu Advanced Encryption Standard, więc z pewnością używasz algorytmu, który można uznać za"najlepszą praktykę".

The RijndaelManaged Klasa rzeczywiście normalnie wymaga "obijania się" z tablicami bajtów, solami, kluczami, wektorami inicjalizacyjnymi itp. ale jest to dokładnie ten rodzaj szczegółów, który można nieco wyabstrahować w ramach klasy "owijarki".

Następująca Klasa to jeden I napisał jakiś czas temu, aby wykonać dokładnie to, czego szukasz, proste wywołanie pojedynczej metody, aby umożliwić szyfrowanie tekstu zwykłego za pomocą hasła opartego na łańcuchu, a wynikowy zaszyfrowany ciąg jest również reprezentowany jako ciąg. Oczywiście istnieje równoważna metoda odszyfrowania zaszyfrowanego ciągu za pomocą tego samego hasła.

W przeciwieństwie do pierwszej wersji tego kodu, która używała dokładnie tych samych wartości salt I IV za każdym razem, ta nowsza wersja wygeneruje losowy sól i kroplówki za każdym razem. Ponieważ salt I IV muszą być takie same między szyfrowaniem a deszyfrowaniem danego ciągu, salt I IV są dołączane do zaszyfrowanego tekstu po zaszyfrowaniu i wydobywane z niego ponownie w celu wykonania deszyfrowania. Rezultatem tego jest to, że zaszyfrowanie dokładnie tego samego zwykłego tekstu za pomocą tego samego hasła daje za każdym razem zupełnie inny wynik zaszyfrowania.

"Siła" używania tego pochodzi z używania RijndaelManaged Klasa do wykonania szyfrowanie dla ciebie, wraz z użyciem funkcji Rfc2898DeriveBytes przestrzeni nazw System.Security.Cryptography, która wygeneruje Twój klucz szyfrowania przy użyciu standardowego i bezpiecznego algorytmu (w szczególności PBKDF2) w oparciu o podane hasło oparte na łańcuchu znaków. (Zauważ, że jest to poprawa wykorzystania w pierwszej wersji starszego algorytmu PBKDF1).

Wreszcie, ważne jest, aby pamiętać, że to wciąż nieautoryzowane szyfrowanie. Samo szyfrowanie zapewnia tylko prywatność (tzn. wiadomość jest nieznana stronom trzecim), podczas gdy uwierzytelnione szyfrowanie ma na celu zapewnienie zarówno prywatności, jak i autentyczności (tzn. odbiorca wie, że wiadomość została wysłana przez nadawcę).

Nie znając Twoich dokładnych wymagań, trudno powiedzieć, czy kod tutaj jest wystarczająco bezpieczny dla Twoich potrzeb, jednak został wyprodukowany, aby zapewnić dobrą równowagę między względną prostotą implementacji a "jakością". Na przykład, jeśli "odbiorca" zaszyfrowanego ciągu jest otrzymanie łańcucha bezpośrednio od zaufanego "nadawcy", wtedy uwierzytelnienie może nawet nie być konieczne.

Jeśli potrzebujesz czegoś bardziej złożonego i oferującego uwierzytelnione szyfrowanie, sprawdź ten post dla implementacji.

Oto kod:

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

namespace EncryptStringSample
{
    public static class StringCipher
    {
        // This constant is used to determine the keysize of the encryption algorithm in bits.
        // We divide this by 8 within the code below to get the equivalent number of bytes.
        private const int Keysize = 256;

        // This constant determines the number of iterations for the password bytes generation function.
        private const int DerivationIterations = 1000;

        public static string Encrypt(string plainText, string passPhrase)
        {
            // Salt and IV is randomly generated each time, but is preprended to encrypted cipher text
            // so that the same Salt and IV values can be used when decrypting.  
            var saltStringBytes = Generate256BitsOfRandomEntropy();
            var ivStringBytes = Generate256BitsOfRandomEntropy();
            var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
            using (var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations))
            {
                var keyBytes = password.GetBytes(Keysize / 8);
                using (var symmetricKey = new RijndaelManaged())
                {
                    symmetricKey.BlockSize = 256;
                    symmetricKey.Mode = CipherMode.CBC;
                    symmetricKey.Padding = PaddingMode.PKCS7;
                    using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, ivStringBytes))
                    {
                        using (var memoryStream = new MemoryStream())
                        {
                            using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                            {
                                cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
                                cryptoStream.FlushFinalBlock();
                                // Create the final bytes as a concatenation of the random salt bytes, the random iv bytes and the cipher bytes.
                                var cipherTextBytes = saltStringBytes;
                                cipherTextBytes = cipherTextBytes.Concat(ivStringBytes).ToArray();
                                cipherTextBytes = cipherTextBytes.Concat(memoryStream.ToArray()).ToArray();
                                memoryStream.Close();
                                cryptoStream.Close();
                                return Convert.ToBase64String(cipherTextBytes);
                            }
                        }
                    }
                }
            }
        }

        public static string Decrypt(string cipherText, string passPhrase)
        {
            // Get the complete stream of bytes that represent:
            // [32 bytes of Salt] + [32 bytes of IV] + [n bytes of CipherText]
            var cipherTextBytesWithSaltAndIv = Convert.FromBase64String(cipherText);
            // Get the saltbytes by extracting the first 32 bytes from the supplied cipherText bytes.
            var saltStringBytes = cipherTextBytesWithSaltAndIv.Take(Keysize / 8).ToArray();
            // Get the IV bytes by extracting the next 32 bytes from the supplied cipherText bytes.
            var ivStringBytes = cipherTextBytesWithSaltAndIv.Skip(Keysize / 8).Take(Keysize / 8).ToArray();
            // Get the actual cipher text bytes by removing the first 64 bytes from the cipherText string.
            var cipherTextBytes = cipherTextBytesWithSaltAndIv.Skip((Keysize / 8) * 2).Take(cipherTextBytesWithSaltAndIv.Length - ((Keysize / 8) * 2)).ToArray();

            using (var password = new Rfc2898DeriveBytes(passPhrase, saltStringBytes, DerivationIterations))
            {
                var keyBytes = password.GetBytes(Keysize / 8);
                using (var symmetricKey = new RijndaelManaged())
                {
                    symmetricKey.BlockSize = 256;
                    symmetricKey.Mode = CipherMode.CBC;
                    symmetricKey.Padding = PaddingMode.PKCS7;
                    using (var decryptor = symmetricKey.CreateDecryptor(keyBytes, ivStringBytes))
                    {
                        using (var memoryStream = new MemoryStream(cipherTextBytes))
                        {
                            using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                            {
                                var plainTextBytes = new byte[cipherTextBytes.Length];
                                var decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
                                memoryStream.Close();
                                cryptoStream.Close();
                                return Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount);
                            }
                        }
                    }
                }
            }
        }

        private static byte[] Generate256BitsOfRandomEntropy()
        {
            var randomBytes = new byte[32]; // 32 Bytes will give us 256 bits.
            using (var rngCsp = new RNGCryptoServiceProvider())
            {
                // Fill the array with cryptographically secure random bytes.
                rngCsp.GetBytes(randomBytes);
            }
            return randomBytes;
        }
    }
}

Powyższa klasa może być użyta w prosty sposób z kodem podobnym do następującego:

using System;

namespace EncryptStringSample
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Please enter a password to use:");
            string password = Console.ReadLine();
            Console.WriteLine("Please enter a string to encrypt:");
            string plaintext = Console.ReadLine();
            Console.WriteLine("");

            Console.WriteLine("Your encrypted string is:");
            string encryptedstring = StringCipher.Encrypt(plaintext, password);
            Console.WriteLine(encryptedstring);
            Console.WriteLine("");

            Console.WriteLine("Your decrypted string is:");
            string decryptedstring = StringCipher.Decrypt(encryptedstring, password);
            Console.WriteLine(decryptedstring);
            Console.WriteLine("");

            Console.WriteLine("Press any key to exit...");
            Console.ReadLine();
        }
    }
}

(możesz pobrać proste przykładowe rozwiązanie VS2013 (które zawiera kilka testów jednostkowych) tutaj ).

Aktualizacja 23 / Grudzień/2015: Lista konkretnych ulepszeń w kodzie to:

• Naprawiono głupi błąd, w którym kodowanie różniło się między szyfrowaniem a odszyfrowuję. Ponieważ mechanizm generowania wartości salt I IV uległ zmianie, kodowanie nie jest już konieczne.
• ze względu na zmianę salt / IV, poprzedni komentarz do kodu, który nieprawidłowo wskazywał, że kodowanie UTF8 16 znaków daje 32 bajty, nie ma już zastosowania (jako kodowanie nie jest już konieczne).
• użycie zastąpionego algorytmu PBKDF1 zostało zastąpione użyciem bardziej nowoczesnego algorytmu PBKDF2.
• wyprowadzenie hasła jest teraz odpowiednio solone, podczas gdy wcześniej nie było solone w ogóle (kolejny głupi błąd zgnieciony).