C# 使用MemoryStream时AES解密的结果不正确

为什么这个代码不起作用？也许我做错了什么，但我找不到什么

---

当我运行下面的代码时，我看到消息中只有一部分被正确解密。据我所知，

cryptoStreamReader.ReadToEnd（）

由于某种原因无法读取整个文件

实际上，我已经通过使用XmlTextReader和StringReader进行加密/解密而不是使用MemoryStream解决了这个问题。但我想知道那个代码有什么问题。谁能帮我查一下吗？提前谢谢你

-

使用系统；
使用System.IO；
使用System.Runtime.Serialization；
使用System.Security.Cryptography；
使用System.Collections.Generic；
命名空间测试
{
内部静态类程序
{
私有静态void Main（）
{
#如果生成_数据
var list=新列表（）；
对于（int i=0；i您必须刷新
StreamWriter
，以便将缓冲数据写入底层
设备：

私有静态void序列化和加密（T数据）
{                
...
_toEncrypt=memoryStreamReader.ReadToEnd（）；
cryptoStreamWriter.Write（_toEncrypt）；
//刷新你的流写入器。所以所有的流都被缓冲
//数据被写入底层设备。
cryptoStreamWriter.Flush（）；
cryptoStream.Close（）；
fileStream.Close（）；
memoryStream.Close（）；
}
私有静态T DecryptAndDeserialize（）
{
...
_decrypted=cryptoStreamReader.ReadToEnd（）；
memoryStreamWriter.Write（已解密）；
//刷新缓冲数据。
memoryStreamWriter.Flush（）；
记忆流位置=0L；
var serializer=新的DataContractSerializer（typeof（T））；
var result=（T）serializer.ReadObject（memoryStream）；
memoryStream.Close（）；
cryptoStream.Close（）；
fileStream.Close（）；
返回结果；
}

希望，这会有所帮助。
您必须刷新
StreamWriter
，以便将缓冲数据写入底层
设备：

私有静态void序列化和加密（T数据）
{                
...
_toEncrypt=memoryStreamReader.ReadToEnd（）；
cryptoStreamWriter.Write（_toEncrypt）；
//刷新你的流写入器。所以所有的流都被缓冲
//数据被写入底层设备。
cryptoStreamWriter.Flush（）；
cryptoStream.Close（）；
fileStream.Close（）；
memoryStream.Close（）；
}
私有静态T DecryptAndDeserialize（）
{
...
_decrypted=cryptoStreamReader.ReadToEnd（）；
memoryStreamWriter.Write（已解密）；
//刷新缓冲数据。
memoryStreamWriter.Flush（）；
记忆流位置=0L；
var serializer=新的DataContractSerializer（typeof（T））；
var result=（T）serializer.ReadObject（memoryStream）；
memoryStream.Close（）；
cryptoStream.Close（）；
fileStream.Close（）；
返回结果；
}

希望，这有帮助。
“只有一部分消息被正确解密”——第一部分，最后部分或中间部分。@ HenkHolterman，第一部分被解密。最后一部分从某个位置截断。“只有一部分消息被正确解密”。第一部分，最后一部分还是中间部分？“HenkHolterman，第一部分是解密的。最后一部分是从某个位置截断的。非常感谢。最后，它工作得很好……而且我再次问了NOB的问题。”（非常感谢！最后它工作得很好…我再一次问了NOB的问题。
using System;
using System.IO;
using System.Runtime.Serialization;
using System.Security.Cryptography;
using System.Collections.Generic;

namespace Tests
{
    internal static class Program
    {
        private static void Main()
        {
#if GENERATE_DATA
            var list = new List<int>();
            for (int i = 0; i <= 5 * 1024; i++)
                list.Add(i);
            using (var fileStream = new FileStream("data.xml", FileMode.Create))
            {
                var serializer = new DataContractSerializer(list.GetType());
                serializer.WriteObject(fileStream, list);
            }
#endif


            var originalData = GetData<List<int>>();

            SerializeAndEncrypt(originalData);
            var restoredData = DecryptAndDeserialize<List<int>>();

            Console.ReadKey();
        }

        private static T GetData<T>()
        {
            using (var fileStream = new FileStream("data.xml", FileMode.Open))
            {
                var serializer = new DataContractSerializer(typeof(T));
                return (T)serializer.ReadObject(fileStream);
            }
        }

        private const string ENCRYPTED_DATA_FILE_NAME = "data.enc";

        // 32 bytes
        private static readonly byte[] KEY = new byte[]
                                             {
                                                 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
                                                 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
                                                 1, 2, 3, 4, 5, 6, 7, 8, 9, 0,
                                                 1, 2
                                             };

        // 16 bytes
        private static readonly byte[] INITIALIZATION_VECTOR = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6 };

        private static string _toEncrypt;
        private static string _decrypted;

        private static void SerializeAndEncrypt<T>(T data)
        {
            var memoryStream = new MemoryStream();
            var serializer = new DataContractSerializer(typeof(T));
            serializer.WriteObject(memoryStream, data);
            memoryStream.Position = 0L;
            var memoryStreamReader = new StreamReader(memoryStream);

            var fileStream = File.Open(ENCRYPTED_DATA_FILE_NAME, FileMode.Create);
            var aes = Aes.Create();
            var cryptoTransform = aes.CreateEncryptor(KEY, INITIALIZATION_VECTOR);
            var cryptoStream = new CryptoStream(fileStream, cryptoTransform, CryptoStreamMode.Write);
            var cryptoStreamWriter = new StreamWriter(cryptoStream);


            _toEncrypt = memoryStreamReader.ReadToEnd();
            cryptoStreamWriter.Write(_toEncrypt);


            cryptoStream.Close();
            fileStream.Close();
            memoryStream.Close();
        }

        private static T DecryptAndDeserialize<T>()
        {
            var fileStream = File.Open(ENCRYPTED_DATA_FILE_NAME, FileMode.Open);
            var aes = Aes.Create();
            var cryptoTransform = aes.CreateDecryptor(KEY, INITIALIZATION_VECTOR);
            var cryptoStream = new CryptoStream(fileStream, cryptoTransform, CryptoStreamMode.Read);
            var cryptoStreamReader = new StreamReader(cryptoStream);

            var memoryStream = new MemoryStream();
            var memoryStreamWriter = new StreamWriter(memoryStream);


            // The following line is shorter than the original (_toEncrypt). Why? :(
            _decrypted = cryptoStreamReader.ReadToEnd();
            memoryStreamWriter.Write(_decrypted);


            memoryStream.Position = 0L;
            var serializer = new DataContractSerializer(typeof(T));
            var result = (T)serializer.ReadObject(memoryStream);


            memoryStream.Close();
            cryptoStream.Close();
            fileStream.Close();

            return result;
        }
    }
}

private static void SerializeAndEncrypt<T>(T data)
{                
  ...

  _toEncrypt = memoryStreamReader.ReadToEnd();
  cryptoStreamWriter.Write(_toEncrypt);

  // Flush your stream writer. So all buffered
  // data get written to the underlying device.
  cryptoStreamWriter.Flush(); 

  cryptoStream.Close();
  fileStream.Close();
  memoryStream.Close();
}

private static T DecryptAndDeserialize<T>()
{
  ...

  _decrypted = cryptoStreamReader.ReadToEnd();
  memoryStreamWriter.Write(_decrypted);

  // Flush buffered data.
  memoryStreamWriter.Flush();

  memoryStream.Position = 0L;
  var serializer = new DataContractSerializer(typeof(T));
  var result = (T)serializer.ReadObject(memoryStream);
  memoryStream.Close();
  cryptoStream.Close();
  fileStream.Close();

  return result;
}