我需要读取未知长度的流，不包括最后20个字节（散列数据）。设置大致如下：
源流（SHA1哈希最后20个字节） - ＆gt; SHA1 Hasher Stream（在流结束时即时计算并与嵌入式流哈希进行比较） - ＆gt; AES解密流 - ＆gt;做数据的东西......
我无法在处理之前缓冲整个源流，因为它可能是几千兆字节，所有这些都需要在运行中进行。源流不可搜索。目前SHA1流读的是最后20个字节到其缓冲区，打破一切，我不知道有什么方法可以控制此行为。
我想在源之间插入一个包装流的和SHA1流，实施滚动缓冲器（？）呈现源流到AES包装在4096个字节的块，然后“假货”的流的末尾最后一次读取前20个字节。然后通过属性公开20字节哈希。
这是最佳解决方案，我将如何实施？
粗略的代码流程如下（来自内存，可能无法编译）：
SourceStream = TcpClient.Stream
HashedStream = New CryptoStream(SourceStream, Sha1Hasher, CryptoStreamMode.Read)
AesDecryptedStream = New CryptoStream(HashedStream, AesDecryptor, CryptoStreamMode.Read)
' Read out and deserialize data
AesDecryptedStream.Read(etc...)
' Check if signatures match, throw data away if not
If Not Sha1Hash.SequenceEqual(ExpectedHash)
' Do stuff with the data here
修改：流格式如下：
[ StreamFormat | String | Required ]
[ WrapperFlags | 8 Bit BitArray | Required ]
[ Sha1 Hashed Data Wrapper | Optional ]
[ AesIV | 16 Bytes | Required if Aes Encrypted ]
[ Aes Encrypted Data Wrapper | Optional ]
[ Gzip Compressed Data Wrapper | Optional ]
[ Payload Data | Binary | Required ]
[ End Gzip Compressed Data ]
[ End Aes Encrypted Data ]
[ End Sha1 Hashed Data ]
[ Sha1HashValue | 20 Bytes | Required if Sha1 Hashed ]
答案 0 :(得分：1)
我写了一个快速的小流，缓冲前20个字节。我已正确覆盖的唯一真正实现是Read()成员，您可能必须根据您的情况适当地检查其他Stream成员。还有一个免费的测试课程！奖金！我对它进行了更彻底的测试，但您可以根据自己的意愿调整这些测试用例哦，顺便说一句，我没有测试它的长度小于20个字节的流。
[TestClass]
public class TruncateStreamTests
{
[TestMethod]
public void TestTruncateLast20Bytes()
{
string testInput = "This is a string.-- final 20 bytes --";
string expectedOutput = "This is a string.";
string testOutput;
using (var testStream = new StreamWhichEndsBeforeFinal20Bytes(new MemoryStream(Encoding.ASCII.GetBytes(testInput))))
using (var streamReader = new StreamReader(testStream, Encoding.ASCII))
{
testOutput = streamReader.ReadLine();
}
Assert.AreEqual(expectedOutput, testOutput);
}
[TestMethod]
public void TestTruncateLast20BytesRead3BytesAtATime()
{
string testInput = "This is a really really really really really long string, longer than all the others\n\rit even has some carriage returns in it, etc.-- final 20 bytes --";
string expectedOutput = "This is a really really really really really long string, longer than all the others\n\rit even has some carriage returns in it, etc.";
StringBuilder testOutputBuilder = new StringBuilder();
using (var testStream = new StreamWhichEndsBeforeFinal20Bytes(new MemoryStream(Encoding.ASCII.GetBytes(testInput))))
{
int bytesRead = 0;
do
{
byte[] buffer = new byte[3];
bytesRead = testStream.Read(buffer, 0, 3);
testOutputBuilder.Append(Encoding.ASCII.GetString(buffer, 0, bytesRead));
} while (bytesRead > 0);
}
Assert.AreEqual(expectedOutput, testOutputBuilder.ToString());
}
}
public class StreamWhichEndsBeforeFinal20Bytes : Stream
{
private readonly Stream sourceStream;
private static int TailBytesCount = 20;
public StreamWhichEndsBeforeFinal20Bytes(Stream sourceStream)
{
this.sourceStream = sourceStream;
}
public byte[] TailBytes { get { return previousTailBuffer; } }
public override void Flush()
{
sourceStream.Flush();
}
public override long Seek(long offset, SeekOrigin origin)
{
return sourceStream.Seek(offset, origin);
}
public override void SetLength(long value)
{
sourceStream.SetLength(value);
}
private byte[] previousTailBuffer;
public override int Read(byte[] buffer, int offset, int count)
{
byte[] tailBuffer = new byte[TailBytesCount];
int expectedBytesRead;
if (previousTailBuffer == null)
expectedBytesRead = count + TailBytesCount;
else
expectedBytesRead = count;
try
{
byte[] readBuffer = new byte[expectedBytesRead];
int actualBytesRead = sourceStream.Read(readBuffer, offset, expectedBytesRead);
if (actualBytesRead == 0) return 0;
if (actualBytesRead < TailBytesCount)
{
int pickPreviousByteCount = TailBytesCount - actualBytesRead;
if (previousTailBuffer != null)
{
int pickFromIndex = previousTailBuffer.Length - pickPreviousByteCount;
Array.Copy(previousTailBuffer, 0, buffer, offset, count);
Array.Copy(previousTailBuffer, pickFromIndex, tailBuffer, 0, pickPreviousByteCount);
}
Array.Copy(readBuffer, 0, tailBuffer, pickPreviousByteCount, actualBytesRead);
return actualBytesRead;
}
Array.Copy(readBuffer, actualBytesRead - TailBytesCount, tailBuffer, 0, TailBytesCount);
Array.Copy(readBuffer, 0, buffer, offset, actualBytesRead - TailBytesCount);
if (actualBytesRead < expectedBytesRead)
{
return actualBytesRead - TailBytesCount;
}
return count;
}
finally
{
previousTailBuffer = tailBuffer;
}
}
public override void Write(byte[] buffer, int offset, int count)
{
sourceStream.Write(buffer, offset, count);
}
public override bool CanRead
{
get { return sourceStream.CanRead; }
}
public override bool CanSeek
{
get { return sourceStream.CanSeek; }
}
public override bool CanWrite
{
get { return sourceStream.CanWrite; }
}
public override long Length
{
get
{
if (sourceStream.Length < TailBytesCount) return sourceStream.Length;
return sourceStream.Length - TailBytesCount;
}
}
public override long Position
{
get { return sourceStream.Position; }
set { sourceStream.Position = value; }
}
}