0

RSA 公開鍵と秘密鍵を使用して、大きな文字列を暗号化および復号化する必要があります。次のサンプルコードを使用して、より大きなテキストを暗号化することができました

public static string Encrypt(string publicKey, string data, RsaKeyLengths length)
        {
            // full array of bytes to encrypt
            byte[] bytesToEncrypt;

            // worker byte array
            byte[] block;

            // encrypted bytes
            byte[] encryptedBytes;

            // length of bytesToEncrypt
            var dataLength = 0;

            // number of bytes in key                
            var keySize = 0;

            // maximum block length to encrypt          
            var maxLength = 0;

            // how many blocks must we encrypt to encrypt entire message?
            var iterations = 0;

            // the encrypted data
            var encryptedData = new StringBuilder();

            // instantiate the crypto provider with the correct key length
            var rsaCryptoServiceProvider = new RSACryptoServiceProvider((int)length);

            // initialize the RSA object from the given public key
            rsaCryptoServiceProvider.FromXmlString(publicKey);

            // convert data to byte array
            bytesToEncrypt = Encoding.Unicode.GetBytes(data);

            // get length of byte array
            dataLength = bytesToEncrypt.Length;

            // convert length of key from bits to bytes
            keySize = (int)length / 8;

            // .NET RSACryptoServiceProvider uses SHA1 Hash function
            // use this to work out the maximum length to encrypt per block
            maxLength = ((keySize - 2) - (2 * SHA1.Create().ComputeHash(bytesToEncrypt).Length));

            // how many blocks do we need to encrypt?
            iterations = dataLength / maxLength;

            // encrypt block by block
            for (int index = 0; index <= iterations; index++)
            {
                // is there more than one full block of data left to encrypt?
                if ((dataLength - maxLength * index) > maxLength)
                {
                    block = new byte[maxLength];
                }
                else
                {
                    block = new byte[dataLength - maxLength * index];
                }

                // copy the required number of bytes from the array of bytes to encrypt to our worker array
                Buffer.BlockCopy(bytesToEncrypt, maxLength * index, block, 0, block.Length);

                // encrypt the current worker array block of bytes
                encryptedBytes = rsaCryptoServiceProvider.Encrypt(block, true);

                // RSACryptoServiceProvider reverses the order of encrypted bytesToEncrypt after encryption and before decryption.
                // Undo this reversal for compatibility with other implementations
                Array.Reverse(encryptedBytes);

                // convert to base 64 string
                encryptedData.Append(Convert.ToBase64String(encryptedBytes));

            }
            return encryptedData.ToString();

        }

次に、次のコードを使用してより大きなテキストを解読しようとしました

/// <summary>
        /// Encrypt an arbitrary string of data under the supplied public key
        /// </summary>
        /// <param name="publicKey">The public key to encrypt under</param>
        /// <param name="data">The data to encrypt</param>
        /// <param name="length">The bit length or strength of the public key: 1024, 2048 or 4096 bits. This must match the 
        /// value actually used to create the publicKey</param>
        /// <returns></returns>
        public static string Decrypt(string privateKey, string data, RsaKeyLengths length)
        {
            // full array of bytes to encrypt
            byte[] bytesToDecrypt;

            // worker byte array
            byte[] block;

            // encrypted bytes
            byte[] decryptedBytes;

            // length of bytesToEncrypt
            var dataLength = 0;

            // number of bytes in key                
            var keySize = 0;

            // maximum block length to encrypt          
            var maxLength = 0;

            // how many blocks must we encrypt to encrypt entire message?
            var iterations = 0;

            // the encrypted data
            var decryptedData = new StringBuilder();

            // instantiate the crypto provider with the correct key length
            var rsaCryptoServiceProvider = new RSACryptoServiceProvider((int)length);

            // initialize the RSA object from the given public key
            rsaCryptoServiceProvider.FromXmlString(privateKey);

            // convert data to byte array
            bytesToDecrypt = Encoding.Unicode.GetBytes(data);

            // get length of byte array
            dataLength = bytesToDecrypt.Length;

            // convert length of key from bits to bytes
            keySize = (int)length / 8;

            // .NET RSACryptoServiceProvider uses SHA1 Hash function
            // use this to work out the maximum length to encrypt per block
            //maxLength = ((keySize - 2) - (2 * SHA1.Create().ComputeHash(bytesToDecrypt).Length));
            maxLength = ((keySize / 8) % 3 != 0) ?
              (((keySize / 8) / 3) * 4) + 4 : ((keySize / 8) / 3) * 4; ;

            // how many blocks do we need to encrypt?
            iterations = dataLength / maxLength;

            // encrypt block by block
            for (int index = 0; index <= iterations; index++)
            {
                // is there more than one full block of data left to encrypt?
                if ((dataLength - maxLength * index) > maxLength)
                {
                    block = new byte[maxLength];
                }
                else
                {
                    block = new byte[dataLength - maxLength * index];
                }

                // copy the required number of bytes from the array of bytes to encrypt to our worker array
                Buffer.BlockCopy(bytesToDecrypt, maxLength * index, block, 0, block.Length);

                // encrypt the current worker array block of bytes
                decryptedBytes = rsaCryptoServiceProvider.Decrypt(block, true);

                // RSACryptoServiceProvider reverses the order of encrypted bytesToEncrypt after encryption and before decryption.
                // Undo this reversal for compatibility with other implementations
                Array.Reverse(decryptedBytes);

                // convert to base 64 string
                decryptedData.Append(Convert.ToBase64String(decryptedBytes));

            }
            return decryptedData.ToString();
        }

実際、暗号化は順調に進んでいます。問題ありません。しかし、私がそれを解読しようとしているとき。次の例外が発生しています

未処理の例外: System.Security.Cryptography.CryptographicException: OAEP パディングのデコード中にエラーが発生しました。

誰でも私を助けることができますか?

4

2 に答える 2

1

代わりにストリーム暗号を使用し、RSAを使用してこの暗号のキーのみを暗号化します。これは、公開鍵と秘密鍵のロジックのためにRSAが必要であり、暗号化と復号化に異なる鍵を使用したい場合に役立つことがあります。ストリーム暗号を使用すると、ギガバイトのデータを問題なく暗号化および復号化できます。

RSAは通常、非常に大量のデータには使用されません。

于 2013-02-08T11:34:03.183 に答える
0

少し遅いかもしれませんが、http://tekaris.com/blog/2013/02/08/encrypting-large-data-with-asymetric-rsacryptoserviceprovider/が役に立ちました。ここでのトリックは明らかに、データを分割し、暗号化し、データを再結合することです。

于 2013-03-26T18:42:26.297 に答える