it-swarm-ja.com

C#での文字列の暗号化と復号化

C#で以下を満たす最も近代的な(最善の)方法は何ですか?

string encryptedString = SomeStaticClass.Encrypt(sourceString);

string decryptedString = SomeStaticClass.Decrypt(encryptedString);

しかし、塩、鍵、byte []などを使った煩わしさを最小限にとどめたうえで.

Googleで検索していて、私が見つけているものに混乱しています(これはよくある質問ですが、似たようなSO Qsのリストを参照できます)。

300
Richard

UPDATE 23/Dec/2015:この回答には多くの賛成票が寄せられているようですので、愚かなバグを修正し、コメントとフィードバックに基づいてコードを一般的に改善するように更新しました。特定の改善点のリストについては、投稿の最後をご覧ください。

他の人が言ったように、暗号化は単純ではないので、「独自のローリング」暗号化アルゴリズムを避けるのが最善です。

ただし、組み込みの RijndaelManaged 暗号化クラスのようなものを「独自にロール」することができます。

Rijndaelは、現在の Advanced Encryption Standard のアルゴリズム名であるため、「ベストプラクティス」と見なせるアルゴリズムを使用しています。

RijndaelManaged クラスは通常、バイト配列、ソルト、キー、初期化ベクトルなどを「いじる」必要がありますが、これはまさに「ラッパー」内で多少抽象化できる詳細です。 「クラス。

次のクラスは、文字列ベースのプレーンテキストを文字列ベースのパスワードで暗号化できる単純な単一メソッド呼び出しであり、結果の暗号化された文字列も文字列として表されます。もちろん、同じパスワードで暗号化された文字列を復号化する同等の方法があります。

毎回まったく同じソルト値とIV値を使用したこのコードの最初のバージョンとは異なり、この新しいバージョンは毎回ランダムなソルト値とIV値を生成します。特定の文字列の暗号化と復号化ではソルトとIVが同じである必要があるため、復号化を実行するために、暗号化時に暗号化テキストにソルトとIVが追加され、そこから再び抽出されます。この結果、まったく同じ平文をまったく同じパスワードで暗号化すると、毎回まったく異なる暗号文が得られます。

これを使用する「強さ」は、暗号化キーを生成するSystem.Security.Cryptography名前空間の Rfc2898DeriveBytes 関数を使用するとともに、 RijndaelManaged クラスを使用して暗号化を実行することから得られます。指定した文字列ベースのパスワードに基づいて、標準の安全なアルゴリズム(具体的には PBKDF2 )を使用します。 (これは、以前のPBKDF1アルゴリズムの最初のバージョンの使用の改善であることに注意してください)。

最後に、これはまだunauthenticated暗号化であることに注意することが重要です。暗号化のみではプライバシーのみが提供されます(つまり、メッセージはサードパーティに知られていません)。認証された暗号化は、プライバシーと信頼性の両方を提供することを目的としています(つまり、受信者はメッセージが送信者によって送信されたことを知っています)。

正確な要件を知らなくても、ここのコードがニーズに対して十分に安全であるかどうかを判断することは困難ですが、実装の相対的な単純さと「品質」のバランスが取れるように作成されています。たとえば、暗号化された文字列の「受信者」が信頼できる「送信者」から文字列を直接受信している場合、認証 必要ない場合もあります

より複雑なものが必要で、認証された暗号化が必要な場合は、実装について this post をチェックしてください。

コードは次のとおりです。

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;
        }
    }
}

上記のクラスは、次のようなコードで非常に簡単に使用できます。

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();
        }
    }
}

(簡単なVS2013サンプルソリューション(いくつかの単体テストを含む)をダウンロードできます) here )。

UPDATE 23/Dec/2015:コードの特定の改善点のリストは次のとおりです。

  • 暗号化と復号化でエンコードが異なるという愚かなバグを修正しました。 saltとIVの値が生成されるメカニズムが変更されたため、エンコードは不要になりました。
  • Salt/IVの変更により、16文字の文字列をエンコードするUTF8が32バイトを生成すると誤って示していた以前のコードコメントは適用できなくなりました(エンコードが不要になったため)。
  • 置き換えられたPBKDF1アルゴリズムの使用は、より新しいPBKDF2アルゴリズムの使用に置き換えられました。
  • パスワードの派生は以前はまったくソルトされていませんでしたが、適切にソルトされています(別の愚かなバグがつぶされました)。
692
CraigTP
using System.IO;
using System.Text;
using System.Security.Cryptography;

public static class EncryptionHelper
{
    public static string Encrypt(string clearText)
    {
        string EncryptionKey = "abc123";
        byte[] clearBytes = Encoding.Unicode.GetBytes(clearText);
        using (Aes encryptor = Aes.Create())
        {
            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, 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();
                }
                clearText = Convert.ToBase64String(ms.ToArray());
            }
        }
        return clearText;
    }
    public static string Decrypt(string cipherText)
    {
        string EncryptionKey = "abc123";
        cipherText = cipherText.Replace(" ", "+");
        byte[] cipherBytes = Convert.FromBase64String(cipherText);
        using (Aes encryptor = Aes.Create())
        {
            Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, 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;
    }
}
76
A Ghazal

このクラスを試してください。

public class DataEncryptor
{
    TripleDESCryptoServiceProvider symm;

    #region Factory
    public DataEncryptor()
    {
        this.symm = new TripleDESCryptoServiceProvider();
        this.symm.Padding = PaddingMode.PKCS7;
    }
    public DataEncryptor(TripleDESCryptoServiceProvider keys)
    {
        this.symm = keys;
    }

    public DataEncryptor(byte[] key, byte[] iv)
    {
        this.symm = new TripleDESCryptoServiceProvider();
        this.symm.Padding = PaddingMode.PKCS7;
        this.symm.Key = key;
        this.symm.IV = iv;
    }

    #endregion

    #region Properties
    public TripleDESCryptoServiceProvider Algorithm
    {
        get { return symm; }
        set { symm = value; }
    }
    public byte[] Key
    {
        get { return symm.Key; }
        set { symm.Key = value; }
    }
    public byte[] IV
    {
        get { return symm.IV; }
        set { symm.IV = value; }
    }

    #endregion

    #region Crypto

    public byte[] Encrypt(byte[] data) { return Encrypt(data, data.Length); }
    public byte[] Encrypt(byte[] data, int length)
    {
        try
        {
            // Create a MemoryStream.
            var ms = new MemoryStream();

            // Create a CryptoStream using the MemoryStream 
            // and the passed key and initialization vector (IV).
            var cs = new CryptoStream(ms,
                symm.CreateEncryptor(symm.Key, symm.IV),
                CryptoStreamMode.Write);

            // Write the byte array to the crypto stream and flush it.
            cs.Write(data, 0, length);
            cs.FlushFinalBlock();

            // Get an array of bytes from the 
            // MemoryStream that holds the 
            // encrypted data.
            byte[] ret = ms.ToArray();

            // Close the streams.
            cs.Close();
            ms.Close();

            // Return the encrypted buffer.
            return ret;
        }
        catch (CryptographicException ex)
        {
            Console.WriteLine("A cryptographic error occured: {0}", ex.Message);
        }
        return null;
    }

    public string EncryptString(string text)
    {
        return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(text)));
    }

    public byte[] Decrypt(byte[] data) { return Decrypt(data, data.Length); }
    public byte[] Decrypt(byte[] data, int length)
    {
        try
        {
            // Create a new MemoryStream using the passed 
            // array of encrypted data.
            MemoryStream ms = new MemoryStream(data);

            // Create a CryptoStream using the MemoryStream 
            // and the passed key and initialization vector (IV).
            CryptoStream cs = new CryptoStream(ms,
                symm.CreateDecryptor(symm.Key, symm.IV),
                CryptoStreamMode.Read);

            // Create buffer to hold the decrypted data.
            byte[] result = new byte[length];

            // Read the decrypted data out of the crypto stream
            // and place it into the temporary buffer.
            cs.Read(result, 0, result.Length);
            return result;
        }
        catch (CryptographicException ex)
        {
            Console.WriteLine("A cryptographic error occured: {0}", ex.Message);
        }
        return null;
    }

    public string DecryptString(string data)
    {
        return Encoding.UTF8.GetString(Decrypt(Convert.FromBase64String(data))).TrimEnd('\0');
    }

    #endregion

}

そしてこれを次のように使います。

string message="A very secret message here.";
DataEncryptor keys=new DataEncryptor();
string encr=keys.EncryptString(message);

// later
string actual=keys.DecryptString(encr);
28
ja72

パスワードをメモリに保存する必要があり、それを暗号化したい場合は SecureString を使用してください。

http://msdn.Microsoft.com/ja-jp/library/system.security.securestring.aspx

より一般的な用途では、以前はRijndaelとして知られていたAdvanced Encryption StandardなどのFIPS承認済みアルゴリズムを使用します。実装例については、このページを参照してください。

http://msdn.Microsoft.com/ja-jp/library/system.security.cryptography.rijndael.aspx

19
Ulises

RijndaelManagedをまだサポートしていないASP.NET Coreをターゲットにしている場合は、IDataProtectionProviderを使用できます。

まず、データ保護を使用するようにアプリケーションを設定します。

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDataProtection();
    }
    // ...
}

それからIDataProtectionProviderインスタンスを注入し、それを使ってデータを暗号化/復号化することができます。

public class MyService : IService
{
    private const string Purpose = "my protection purpose";
    private readonly IDataProtectionProvider _provider;

    public MyService(IDataProtectionProvider provider)
    {
        _provider = provider;
    }

    public string Encrypt(string plainText)
    {
        var protector = _provider.CreateProtector(Purpose);
        return protector.Protect(plainText);
    }

    public string Decrypt(string cipherText)
    {
        var protector = _provider.CreateProtector(Purpose);
        return protector.Unprotect(cipherText);
    }
}

詳しくは この記事 をご覧ください。

14
Sergey Kolodiy

ユーザーのログオン資格情報を使用してデータを暗号化するProtectedDataクラスを探しているかもしれません。

9
SLaks