Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / clr / src / BCL / System / Security / Cryptography / CryptoStream.cs / 1 / CryptoStream.cs
// ==++== // // Copyright (c) Microsoft Corporation. All rights reserved. // // ==--== // // CryptoStream.cs // namespace System.Security.Cryptography { using System; using System.IO; using System.Runtime.InteropServices; [Serializable] [System.Runtime.InteropServices.ComVisible(true)] public enum CryptoStreamMode { Read = 0, Write = 1, } [System.Runtime.InteropServices.ComVisible(true)] public class CryptoStream : Stream, IDisposable { // Member veriables private Stream _stream; private ICryptoTransform _Transform; private byte[] _InputBuffer; // read from _stream before _Transform private int _InputBufferIndex = 0; private int _InputBlockSize; private byte[] _OutputBuffer; // buffered output of _Transform private int _OutputBufferIndex = 0; private int _OutputBlockSize; private CryptoStreamMode _transformMode; private bool _canRead = false; private bool _canWrite = false; private bool _finalBlockTransformed = false; // Constructors public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode mode) { _stream = stream; _transformMode = mode; _Transform = transform; switch (_transformMode) { case CryptoStreamMode.Read: if (!(_stream.CanRead)) throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotReadable"),"stream"); _canRead = true; break; case CryptoStreamMode.Write: if (!(_stream.CanWrite)) throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotWritable"),"stream"); _canWrite = true; break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidValue")); } InitializeBuffer(); } public override bool CanRead { get { return _canRead; } } // For now, assume we can never seek into the middle of a cryptostream // and get the state right. This is too strict. public override bool CanSeek { get { return false; } } public override bool CanWrite { get { return _canWrite; } } public override long Length { get { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } } public override long Position { get { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } set { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } } // The flush final block functionality used to be part of close, but that meant you couldn't do something like this: // MemoryStream ms = new MemoryStream(); // CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write); // cs.Write(foo, 0, foo.Length); // cs.Close(); // and get the encrypted data out of ms, because the cs.Close also closed ms and the data went away. // so now do this: // cs.Write(foo, 0, foo.Length); // cs.FlushFinalBlock() // which can only be called once // byte[] ciphertext = ms.ToArray(); // cs.Close(); public void FlushFinalBlock() { if (_finalBlockTransformed) throw new NotSupportedException(Environment.GetResourceString("Cryptography_CryptoStream_FlushFinalBlockTwice")); // We have to process the last block here. First, we have the final block in _InputBuffer, so transform it byte[] finalBytes = _Transform.TransformFinalBlock(_InputBuffer, 0, _InputBufferIndex); _finalBlockTransformed = true; // Now, write out anything sitting in the _OutputBuffer... if (_canWrite && _OutputBufferIndex > 0) { _stream.Write(_OutputBuffer, 0, _OutputBufferIndex); _OutputBufferIndex = 0; } // Write out finalBytes if (_canWrite) _stream.Write(finalBytes, 0, finalBytes.Length); // If the inner stream is a CryptoStream, then we want to call FlushFinalBlock on it too, otherwise just Flush. if (_stream is CryptoStream) { ((CryptoStream) _stream).FlushFinalBlock(); } else { _stream.Flush(); } // zeroize plain text material before returning if (_InputBuffer != null) Array.Clear(_InputBuffer, 0, _InputBuffer.Length); if (_OutputBuffer != null) Array.Clear(_OutputBuffer, 0, _OutputBuffer.Length); return; } public override void Flush() { return; } public override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } public override void SetLength(long value) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } public override int Read([In, Out] byte[] buffer, int offset, int count) { // argument checking if (!_canRead) throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnreadableStream")); if (offset < 0) throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (count < 0) throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (buffer.Length - offset < count) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen")); // read <= count bytes from the input stream, transforming as we go. // Basic idea: first we deliver any bytes we already have in the // _OutputBuffer, because we know they're good. Then, if asked to deliver // more bytes, we read & transform a block at a time until either there are // no bytes ready or we've delivered enough. int bytesToDeliver = count; int currentOutputIndex = offset; if (_OutputBufferIndex != 0) { // we have some already-transformed bytes in the output buffer if (_OutputBufferIndex <= count) { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, offset, _OutputBufferIndex); bytesToDeliver -= _OutputBufferIndex; currentOutputIndex += _OutputBufferIndex; _OutputBufferIndex = 0; } else { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, offset, count); Buffer.InternalBlockCopy(_OutputBuffer, count, _OutputBuffer, 0, _OutputBufferIndex - count); _OutputBufferIndex -= count; return(count); } } // _finalBlockTransformed == true implies we're at the end of the input stream // if we got through the previous if block then _OutputBufferIndex = 0, meaning // we have no more transformed bytes to give // so return count-bytesToDeliver, the amount we were able to hand back // eventually, we'll just always return 0 here because there's no more to read if (_finalBlockTransformed) { return(count - bytesToDeliver); } // ok, now loop until we've delivered enough or there's nothing available int amountRead = 0; int numOutputBytes; // OK, see first if it's a multi-block transform and we can speed up things if (bytesToDeliver > _OutputBlockSize) { if (_Transform.CanTransformMultipleBlocks) { int BlocksToProcess = bytesToDeliver / _OutputBlockSize; int numWholeBlocksInBytes = BlocksToProcess * _InputBlockSize; byte[] tempInputBuffer = new byte[numWholeBlocksInBytes]; // get first the block already read Buffer.InternalBlockCopy(_InputBuffer, 0, tempInputBuffer, 0, _InputBufferIndex); amountRead = _InputBufferIndex; amountRead += _stream.Read(tempInputBuffer, _InputBufferIndex, numWholeBlocksInBytes - _InputBufferIndex); _InputBufferIndex = 0; if (amountRead <= _InputBlockSize) { _InputBuffer = tempInputBuffer; _InputBufferIndex = amountRead; goto slow; } // Make amountRead an integral multiple of _InputBlockSize int numWholeReadBlocksInBytes = (amountRead / _InputBlockSize) * _InputBlockSize; int numIgnoredBytes = amountRead - numWholeReadBlocksInBytes; if (numIgnoredBytes != 0) { _InputBufferIndex = numIgnoredBytes; Buffer.InternalBlockCopy(tempInputBuffer, numWholeReadBlocksInBytes, _InputBuffer, 0, numIgnoredBytes); } byte[] tempOutputBuffer = new byte[(numWholeReadBlocksInBytes / _InputBlockSize) * _OutputBlockSize]; numOutputBytes = _Transform.TransformBlock(tempInputBuffer, 0, numWholeReadBlocksInBytes, tempOutputBuffer, 0); Buffer.InternalBlockCopy(tempOutputBuffer, 0, buffer, currentOutputIndex, numOutputBytes); // Now, tempInputBuffer and tempOutputBuffer are no more needed, so zeroize them to protect plain text Array.Clear(tempInputBuffer, 0, tempInputBuffer.Length); Array.Clear(tempOutputBuffer, 0, tempOutputBuffer.Length); bytesToDeliver -= numOutputBytes; currentOutputIndex += numOutputBytes; } } slow: // try to fill _InputBuffer so we have something to transform while (bytesToDeliver > 0) { while (_InputBufferIndex < _InputBlockSize) { amountRead = _stream.Read(_InputBuffer, _InputBufferIndex, _InputBlockSize - _InputBufferIndex); // first, check to see if we're at the end of the input stream if (amountRead == 0) goto ProcessFinalBlock; _InputBufferIndex += amountRead; } numOutputBytes = _Transform.TransformBlock(_InputBuffer, 0, _InputBlockSize, _OutputBuffer, 0); _InputBufferIndex = 0; if (bytesToDeliver >= numOutputBytes) { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, numOutputBytes); currentOutputIndex += numOutputBytes; bytesToDeliver -= numOutputBytes; } else { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, bytesToDeliver); _OutputBufferIndex = numOutputBytes - bytesToDeliver; Buffer.InternalBlockCopy(_OutputBuffer, bytesToDeliver, _OutputBuffer, 0, _OutputBufferIndex); return count; } } return count; ProcessFinalBlock: // if so, then call TransformFinalBlock to get whatever is left byte[] finalBytes = _Transform.TransformFinalBlock(_InputBuffer, 0, _InputBufferIndex); // now, since _OutputBufferIndex must be 0 if we're in the while loop at this point, // reset it to be what we just got back _OutputBuffer = finalBytes; _OutputBufferIndex = finalBytes.Length; // set the fact that we've transformed the final block _finalBlockTransformed = true; // now, return either everything we just got or just what's asked for, whichever is smaller if (bytesToDeliver < _OutputBufferIndex) { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, bytesToDeliver); _OutputBufferIndex -= bytesToDeliver; Buffer.InternalBlockCopy(_OutputBuffer, bytesToDeliver, _OutputBuffer, 0, _OutputBufferIndex); return(count); } else { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, _OutputBufferIndex); bytesToDeliver -= _OutputBufferIndex; _OutputBufferIndex = 0; return(count - bytesToDeliver); } } public override void Write(byte[] buffer, int offset, int count) { if (!_canWrite) throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnwritableStream")); if (offset < 0) throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (count < 0) throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (buffer.Length - offset < count) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen")); // write <= count bytes to the output stream, transforming as we go. // Basic idea: using bytes in the _InputBuffer first, make whole blocks, // transform them, and write them out. Cache any remaining bytes in the _InputBuffer. int bytesToWrite = count; int currentInputIndex = offset; // if we have some bytes in the _InputBuffer, we have to deal with those first, // so let's try to make an entire block out of it if (_InputBufferIndex > 0) { if (count >= _InputBlockSize - _InputBufferIndex) { // we have enough to transform at least a block, so fill the input block Buffer.InternalBlockCopy(buffer, offset, _InputBuffer, _InputBufferIndex, _InputBlockSize - _InputBufferIndex); currentInputIndex += (_InputBlockSize - _InputBufferIndex); bytesToWrite -= (_InputBlockSize - _InputBufferIndex); _InputBufferIndex = _InputBlockSize; // Transform the block and write it out } else { // not enough to transform a block, so just copy the bytes into the _InputBuffer // and return Buffer.InternalBlockCopy(buffer, offset, _InputBuffer, _InputBufferIndex, count); _InputBufferIndex += count; return; } } // If the OutputBuffer has anything in it, write it out if (_OutputBufferIndex > 0) { _stream.Write(_OutputBuffer, 0, _OutputBufferIndex); _OutputBufferIndex = 0; } // At this point, either the _InputBuffer is full, empty, or we've already returned. // If full, let's process it -- we now know the _OutputBuffer is empty int numOutputBytes; if (_InputBufferIndex == _InputBlockSize) { numOutputBytes = _Transform.TransformBlock(_InputBuffer, 0, _InputBlockSize, _OutputBuffer, 0); // write out the bytes we just got _stream.Write(_OutputBuffer, 0, numOutputBytes); // reset the _InputBuffer _InputBufferIndex = 0; } while (bytesToWrite > 0) { if (bytesToWrite >= _InputBlockSize) { // We have at least an entire block's worth to transform // If the transform will handle multiple blocks at once, do that if (_Transform.CanTransformMultipleBlocks) { int numWholeBlocks = bytesToWrite / _InputBlockSize; int numWholeBlocksInBytes = numWholeBlocks * _InputBlockSize; byte[] _tempOutputBuffer = new byte[numWholeBlocks * _OutputBlockSize]; numOutputBytes = _Transform.TransformBlock(buffer, currentInputIndex, numWholeBlocksInBytes, _tempOutputBuffer, 0); _stream.Write(_tempOutputBuffer, 0, numOutputBytes); currentInputIndex += numWholeBlocksInBytes; bytesToWrite -= numWholeBlocksInBytes; } else { // do it the slow way numOutputBytes = _Transform.TransformBlock(buffer, currentInputIndex, _InputBlockSize, _OutputBuffer, 0); _stream.Write(_OutputBuffer, 0, numOutputBytes); currentInputIndex += _InputBlockSize; bytesToWrite -= _InputBlockSize; } } else { // In this case, we don't have an entire block's worth left, so store it up in the // input buffer, which by now must be empty. Buffer.InternalBlockCopy(buffer, currentInputIndex, _InputBuffer, 0, bytesToWrite); _InputBufferIndex += bytesToWrite; return; } } return; } public void Clear() { Close(); } protected override void Dispose(bool disposing) { try { if (disposing) { if (!_finalBlockTransformed) { FlushFinalBlock(); } _stream.Close(); // we need to clear all the internal buffers if (_InputBuffer != null) Array.Clear(_InputBuffer, 0, _InputBuffer.Length); if (_OutputBuffer != null) Array.Clear(_OutputBuffer, 0, _OutputBuffer.Length); _InputBuffer = null; _OutputBuffer = null; } } finally { base.Dispose(disposing); } } // Private methods private void InitializeBuffer() { if (_Transform != null) { _InputBlockSize = _Transform.InputBlockSize; _InputBuffer = new byte[_InputBlockSize]; _OutputBlockSize = _Transform.OutputBlockSize; _OutputBuffer = new byte[_OutputBlockSize]; } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // ==++== // // Copyright (c) Microsoft Corporation. All rights reserved. // // ==--== // // CryptoStream.cs // namespace System.Security.Cryptography { using System; using System.IO; using System.Runtime.InteropServices; [Serializable] [System.Runtime.InteropServices.ComVisible(true)] public enum CryptoStreamMode { Read = 0, Write = 1, } [System.Runtime.InteropServices.ComVisible(true)] public class CryptoStream : Stream, IDisposable { // Member veriables private Stream _stream; private ICryptoTransform _Transform; private byte[] _InputBuffer; // read from _stream before _Transform private int _InputBufferIndex = 0; private int _InputBlockSize; private byte[] _OutputBuffer; // buffered output of _Transform private int _OutputBufferIndex = 0; private int _OutputBlockSize; private CryptoStreamMode _transformMode; private bool _canRead = false; private bool _canWrite = false; private bool _finalBlockTransformed = false; // Constructors public CryptoStream(Stream stream, ICryptoTransform transform, CryptoStreamMode mode) { _stream = stream; _transformMode = mode; _Transform = transform; switch (_transformMode) { case CryptoStreamMode.Read: if (!(_stream.CanRead)) throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotReadable"),"stream"); _canRead = true; break; case CryptoStreamMode.Write: if (!(_stream.CanWrite)) throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotWritable"),"stream"); _canWrite = true; break; default: throw new ArgumentException(Environment.GetResourceString("Argument_InvalidValue")); } InitializeBuffer(); } public override bool CanRead { get { return _canRead; } } // For now, assume we can never seek into the middle of a cryptostream // and get the state right. This is too strict. public override bool CanSeek { get { return false; } } public override bool CanWrite { get { return _canWrite; } } public override long Length { get { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } } public override long Position { get { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } set { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } } // The flush final block functionality used to be part of close, but that meant you couldn't do something like this: // MemoryStream ms = new MemoryStream(); // CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write); // cs.Write(foo, 0, foo.Length); // cs.Close(); // and get the encrypted data out of ms, because the cs.Close also closed ms and the data went away. // so now do this: // cs.Write(foo, 0, foo.Length); // cs.FlushFinalBlock() // which can only be called once // byte[] ciphertext = ms.ToArray(); // cs.Close(); public void FlushFinalBlock() { if (_finalBlockTransformed) throw new NotSupportedException(Environment.GetResourceString("Cryptography_CryptoStream_FlushFinalBlockTwice")); // We have to process the last block here. First, we have the final block in _InputBuffer, so transform it byte[] finalBytes = _Transform.TransformFinalBlock(_InputBuffer, 0, _InputBufferIndex); _finalBlockTransformed = true; // Now, write out anything sitting in the _OutputBuffer... if (_canWrite && _OutputBufferIndex > 0) { _stream.Write(_OutputBuffer, 0, _OutputBufferIndex); _OutputBufferIndex = 0; } // Write out finalBytes if (_canWrite) _stream.Write(finalBytes, 0, finalBytes.Length); // If the inner stream is a CryptoStream, then we want to call FlushFinalBlock on it too, otherwise just Flush. if (_stream is CryptoStream) { ((CryptoStream) _stream).FlushFinalBlock(); } else { _stream.Flush(); } // zeroize plain text material before returning if (_InputBuffer != null) Array.Clear(_InputBuffer, 0, _InputBuffer.Length); if (_OutputBuffer != null) Array.Clear(_OutputBuffer, 0, _OutputBuffer.Length); return; } public override void Flush() { return; } public override long Seek(long offset, SeekOrigin origin) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } public override void SetLength(long value) { throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnseekableStream")); } public override int Read([In, Out] byte[] buffer, int offset, int count) { // argument checking if (!_canRead) throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnreadableStream")); if (offset < 0) throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (count < 0) throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (buffer.Length - offset < count) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen")); // read <= count bytes from the input stream, transforming as we go. // Basic idea: first we deliver any bytes we already have in the // _OutputBuffer, because we know they're good. Then, if asked to deliver // more bytes, we read & transform a block at a time until either there are // no bytes ready or we've delivered enough. int bytesToDeliver = count; int currentOutputIndex = offset; if (_OutputBufferIndex != 0) { // we have some already-transformed bytes in the output buffer if (_OutputBufferIndex <= count) { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, offset, _OutputBufferIndex); bytesToDeliver -= _OutputBufferIndex; currentOutputIndex += _OutputBufferIndex; _OutputBufferIndex = 0; } else { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, offset, count); Buffer.InternalBlockCopy(_OutputBuffer, count, _OutputBuffer, 0, _OutputBufferIndex - count); _OutputBufferIndex -= count; return(count); } } // _finalBlockTransformed == true implies we're at the end of the input stream // if we got through the previous if block then _OutputBufferIndex = 0, meaning // we have no more transformed bytes to give // so return count-bytesToDeliver, the amount we were able to hand back // eventually, we'll just always return 0 here because there's no more to read if (_finalBlockTransformed) { return(count - bytesToDeliver); } // ok, now loop until we've delivered enough or there's nothing available int amountRead = 0; int numOutputBytes; // OK, see first if it's a multi-block transform and we can speed up things if (bytesToDeliver > _OutputBlockSize) { if (_Transform.CanTransformMultipleBlocks) { int BlocksToProcess = bytesToDeliver / _OutputBlockSize; int numWholeBlocksInBytes = BlocksToProcess * _InputBlockSize; byte[] tempInputBuffer = new byte[numWholeBlocksInBytes]; // get first the block already read Buffer.InternalBlockCopy(_InputBuffer, 0, tempInputBuffer, 0, _InputBufferIndex); amountRead = _InputBufferIndex; amountRead += _stream.Read(tempInputBuffer, _InputBufferIndex, numWholeBlocksInBytes - _InputBufferIndex); _InputBufferIndex = 0; if (amountRead <= _InputBlockSize) { _InputBuffer = tempInputBuffer; _InputBufferIndex = amountRead; goto slow; } // Make amountRead an integral multiple of _InputBlockSize int numWholeReadBlocksInBytes = (amountRead / _InputBlockSize) * _InputBlockSize; int numIgnoredBytes = amountRead - numWholeReadBlocksInBytes; if (numIgnoredBytes != 0) { _InputBufferIndex = numIgnoredBytes; Buffer.InternalBlockCopy(tempInputBuffer, numWholeReadBlocksInBytes, _InputBuffer, 0, numIgnoredBytes); } byte[] tempOutputBuffer = new byte[(numWholeReadBlocksInBytes / _InputBlockSize) * _OutputBlockSize]; numOutputBytes = _Transform.TransformBlock(tempInputBuffer, 0, numWholeReadBlocksInBytes, tempOutputBuffer, 0); Buffer.InternalBlockCopy(tempOutputBuffer, 0, buffer, currentOutputIndex, numOutputBytes); // Now, tempInputBuffer and tempOutputBuffer are no more needed, so zeroize them to protect plain text Array.Clear(tempInputBuffer, 0, tempInputBuffer.Length); Array.Clear(tempOutputBuffer, 0, tempOutputBuffer.Length); bytesToDeliver -= numOutputBytes; currentOutputIndex += numOutputBytes; } } slow: // try to fill _InputBuffer so we have something to transform while (bytesToDeliver > 0) { while (_InputBufferIndex < _InputBlockSize) { amountRead = _stream.Read(_InputBuffer, _InputBufferIndex, _InputBlockSize - _InputBufferIndex); // first, check to see if we're at the end of the input stream if (amountRead == 0) goto ProcessFinalBlock; _InputBufferIndex += amountRead; } numOutputBytes = _Transform.TransformBlock(_InputBuffer, 0, _InputBlockSize, _OutputBuffer, 0); _InputBufferIndex = 0; if (bytesToDeliver >= numOutputBytes) { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, numOutputBytes); currentOutputIndex += numOutputBytes; bytesToDeliver -= numOutputBytes; } else { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, bytesToDeliver); _OutputBufferIndex = numOutputBytes - bytesToDeliver; Buffer.InternalBlockCopy(_OutputBuffer, bytesToDeliver, _OutputBuffer, 0, _OutputBufferIndex); return count; } } return count; ProcessFinalBlock: // if so, then call TransformFinalBlock to get whatever is left byte[] finalBytes = _Transform.TransformFinalBlock(_InputBuffer, 0, _InputBufferIndex); // now, since _OutputBufferIndex must be 0 if we're in the while loop at this point, // reset it to be what we just got back _OutputBuffer = finalBytes; _OutputBufferIndex = finalBytes.Length; // set the fact that we've transformed the final block _finalBlockTransformed = true; // now, return either everything we just got or just what's asked for, whichever is smaller if (bytesToDeliver < _OutputBufferIndex) { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, bytesToDeliver); _OutputBufferIndex -= bytesToDeliver; Buffer.InternalBlockCopy(_OutputBuffer, bytesToDeliver, _OutputBuffer, 0, _OutputBufferIndex); return(count); } else { Buffer.InternalBlockCopy(_OutputBuffer, 0, buffer, currentOutputIndex, _OutputBufferIndex); bytesToDeliver -= _OutputBufferIndex; _OutputBufferIndex = 0; return(count - bytesToDeliver); } } public override void Write(byte[] buffer, int offset, int count) { if (!_canWrite) throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnwritableStream")); if (offset < 0) throw new ArgumentOutOfRangeException("offset", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (count < 0) throw new ArgumentOutOfRangeException("count", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); if (buffer.Length - offset < count) throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen")); // write <= count bytes to the output stream, transforming as we go. // Basic idea: using bytes in the _InputBuffer first, make whole blocks, // transform them, and write them out. Cache any remaining bytes in the _InputBuffer. int bytesToWrite = count; int currentInputIndex = offset; // if we have some bytes in the _InputBuffer, we have to deal with those first, // so let's try to make an entire block out of it if (_InputBufferIndex > 0) { if (count >= _InputBlockSize - _InputBufferIndex) { // we have enough to transform at least a block, so fill the input block Buffer.InternalBlockCopy(buffer, offset, _InputBuffer, _InputBufferIndex, _InputBlockSize - _InputBufferIndex); currentInputIndex += (_InputBlockSize - _InputBufferIndex); bytesToWrite -= (_InputBlockSize - _InputBufferIndex); _InputBufferIndex = _InputBlockSize; // Transform the block and write it out } else { // not enough to transform a block, so just copy the bytes into the _InputBuffer // and return Buffer.InternalBlockCopy(buffer, offset, _InputBuffer, _InputBufferIndex, count); _InputBufferIndex += count; return; } } // If the OutputBuffer has anything in it, write it out if (_OutputBufferIndex > 0) { _stream.Write(_OutputBuffer, 0, _OutputBufferIndex); _OutputBufferIndex = 0; } // At this point, either the _InputBuffer is full, empty, or we've already returned. // If full, let's process it -- we now know the _OutputBuffer is empty int numOutputBytes; if (_InputBufferIndex == _InputBlockSize) { numOutputBytes = _Transform.TransformBlock(_InputBuffer, 0, _InputBlockSize, _OutputBuffer, 0); // write out the bytes we just got _stream.Write(_OutputBuffer, 0, numOutputBytes); // reset the _InputBuffer _InputBufferIndex = 0; } while (bytesToWrite > 0) { if (bytesToWrite >= _InputBlockSize) { // We have at least an entire block's worth to transform // If the transform will handle multiple blocks at once, do that if (_Transform.CanTransformMultipleBlocks) { int numWholeBlocks = bytesToWrite / _InputBlockSize; int numWholeBlocksInBytes = numWholeBlocks * _InputBlockSize; byte[] _tempOutputBuffer = new byte[numWholeBlocks * _OutputBlockSize]; numOutputBytes = _Transform.TransformBlock(buffer, currentInputIndex, numWholeBlocksInBytes, _tempOutputBuffer, 0); _stream.Write(_tempOutputBuffer, 0, numOutputBytes); currentInputIndex += numWholeBlocksInBytes; bytesToWrite -= numWholeBlocksInBytes; } else { // do it the slow way numOutputBytes = _Transform.TransformBlock(buffer, currentInputIndex, _InputBlockSize, _OutputBuffer, 0); _stream.Write(_OutputBuffer, 0, numOutputBytes); currentInputIndex += _InputBlockSize; bytesToWrite -= _InputBlockSize; } } else { // In this case, we don't have an entire block's worth left, so store it up in the // input buffer, which by now must be empty. Buffer.InternalBlockCopy(buffer, currentInputIndex, _InputBuffer, 0, bytesToWrite); _InputBufferIndex += bytesToWrite; return; } } return; } public void Clear() { Close(); } protected override void Dispose(bool disposing) { try { if (disposing) { if (!_finalBlockTransformed) { FlushFinalBlock(); } _stream.Close(); // we need to clear all the internal buffers if (_InputBuffer != null) Array.Clear(_InputBuffer, 0, _InputBuffer.Length); if (_OutputBuffer != null) Array.Clear(_OutputBuffer, 0, _OutputBuffer.Length); _InputBuffer = null; _OutputBuffer = null; } } finally { base.Dispose(disposing); } } // Private methods private void InitializeBuffer() { if (_Transform != null) { _InputBlockSize = _Transform.InputBlockSize; _InputBuffer = new byte[_InputBlockSize]; _OutputBlockSize = _Transform.OutputBlockSize; _OutputBuffer = new byte[_OutputBlockSize]; } } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- Block.cs
- SmtpMail.cs
- CustomAttributeBuilder.cs
- SamlSubjectStatement.cs
- autovalidator.cs
- MultiSelector.cs
- MexBindingElement.cs
- HtmlInputControl.cs
- SupportsPreviewControlAttribute.cs
- Membership.cs
- EncodingNLS.cs
- SqlNotificationRequest.cs
- InvalidCommandTreeException.cs
- TabletCollection.cs
- Point3DValueSerializer.cs
- ListCollectionView.cs
- ResXResourceWriter.cs
- DefaultTextStore.cs
- UnlockCardRequest.cs
- XmlSchemaDocumentation.cs
- URI.cs
- CodeObject.cs
- FilterableAttribute.cs
- DataTransferEventArgs.cs
- IOException.cs
- Comparer.cs
- XmlSchemaInferenceException.cs
- CatalogPartChrome.cs
- BrowsableAttribute.cs
- MemberExpression.cs
- StringUtil.cs
- GridErrorDlg.cs
- GPStream.cs
- D3DImage.cs
- XmlILTrace.cs
- Base64Stream.cs
- ReadWriteObjectLock.cs
- PKCS1MaskGenerationMethod.cs
- IsolationInterop.cs
- DatatypeImplementation.cs
- BitVector32.cs
- ResourceDisplayNameAttribute.cs
- PeerNameResolver.cs
- ActiveXContainer.cs
- NameValuePair.cs
- Options.cs
- SystemUnicastIPAddressInformation.cs
- OverlappedAsyncResult.cs
- ZipIOLocalFileBlock.cs
- SqlServer2KCompatibilityCheck.cs
- DataGridViewCell.cs
- MachineKeyConverter.cs
- dataobject.cs
- TextTreeRootNode.cs
- SslStreamSecurityElement.cs
- DropShadowEffect.cs
- DeploymentSection.cs
- LoginView.cs
- ClientUtils.cs
- TreeBuilder.cs
- PreviewPrintController.cs
- CustomAttribute.cs
- MarkupExtensionParser.cs
- ConfigurationElement.cs
- BaseTemplateCodeDomTreeGenerator.cs
- ProgressBarAutomationPeer.cs
- ContextDataSourceContextData.cs
- Quad.cs
- UserControl.cs
- StrongNameKeyPair.cs
- ProviderCollection.cs
- GridViewSortEventArgs.cs
- DefaultObjectMappingItemCollection.cs
- QueryCacheManager.cs
- ReadOnlyHierarchicalDataSource.cs
- DataSourceCollectionBase.cs
- MetadataPropertyvalue.cs
- ItemsPresenter.cs
- RandomDelayQueuedSendsAsyncResult.cs
- RectAnimationUsingKeyFrames.cs
- errorpatternmatcher.cs
- COM2TypeInfoProcessor.cs
- Exception.cs
- LineVisual.cs
- FontInfo.cs
- BindingExpressionBase.cs
- Accessible.cs
- VerificationException.cs
- ExplicitDiscriminatorMap.cs
- ConfigXmlSignificantWhitespace.cs
- EntityReference.cs
- shaper.cs
- PageStatePersister.cs
- CodeDelegateInvokeExpression.cs
- keycontainerpermission.cs
- SqlDataSourceStatusEventArgs.cs
- QilGeneratorEnv.cs
- XamlFilter.cs
- BitmapSource.cs
- NamespaceDisplayAutomationPeer.cs