1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
|
//
// System.Security.Cryptography CryptoStream.cs
//
// Authors:
// Thomas Neidhart (tome@sbox.tugraz.at)
// Sebastien Pouliot (sebastien@ximian.com)
//
// Portions (C) 2002, 2003 Motus Technologies Inc. (http://www.motus.com)
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.Globalization;
using System.IO;
using System.Runtime.InteropServices;
namespace System.Security.Cryptography {
#if NET_2_0
[ComVisible (true)]
#endif
public class CryptoStream : Stream {
private Stream _stream;
private ICryptoTransform _transform;
private CryptoStreamMode _mode;
private byte[] _currentBlock;
private bool _disposed;
private bool _flushedFinalBlock;
private int _partialCount;
private bool _endOfStream;
private byte[] _waitingBlock;
private int _waitingCount;
private byte[] _transformedBlock;
private int _transformedPos;
private int _transformedCount;
private byte[] _workingBlock;
private int _workingCount;
public CryptoStream (Stream stream, ICryptoTransform transform, CryptoStreamMode mode)
{
if ((mode == CryptoStreamMode.Read) && (!stream.CanRead)) {
throw new ArgumentException (
Locale.GetText ("Can't read on stream"));
}
if ((mode == CryptoStreamMode.Write) && (!stream.CanWrite)) {
throw new ArgumentException (
Locale.GetText ("Can't write on stream"));
}
_stream = stream;
_transform = transform;
_mode = mode;
_disposed = false;
if (transform != null) {
_workingBlock = new byte [transform.InputBlockSize];
if (mode == CryptoStreamMode.Read)
_currentBlock = new byte [transform.InputBlockSize];
else if (mode == CryptoStreamMode.Write)
_currentBlock = new byte [transform.OutputBlockSize];
}
}
~CryptoStream ()
{
Dispose (false);
}
public override bool CanRead {
get { return (_mode == CryptoStreamMode.Read); }
}
public override bool CanSeek {
get { return false; }
}
public override bool CanWrite {
get { return (_mode == CryptoStreamMode.Write); }
}
public override long Length {
get { throw new NotSupportedException ("Length"); }
}
public override long Position {
get { throw new NotSupportedException ("Position"); }
set { throw new NotSupportedException ("Position"); }
}
public void Clear ()
{
Dispose (true);
GC.SuppressFinalize (this); // not called in Stream.Dispose
}
// LAMESPEC: A CryptoStream can be close in read mode
public override void Close ()
{
// only flush in write mode (bugzilla 46143)
if ((!_flushedFinalBlock) && (_mode == CryptoStreamMode.Write))
FlushFinalBlock ();
if (_stream != null)
_stream.Close ();
}
public override int Read ([In,Out] byte[] buffer, int offset, int count)
{
if (_mode != CryptoStreamMode.Read) {
throw new NotSupportedException (
Locale.GetText ("not in Read mode"));
}
if (offset < 0) {
throw new ArgumentOutOfRangeException ("offset",
Locale.GetText ("negative"));
}
if (count < 0) {
throw new ArgumentOutOfRangeException ("count",
Locale.GetText ("negative"));
}
// yes - buffer.Length will throw a NullReferenceException if buffer is null
// but by doing so we match MS implementation
// re-ordered to avoid integer overflow
if (offset > buffer.Length - count) {
throw new ArgumentException ("(offset+count)",
Locale.GetText ("buffer overflow"));
}
// for some strange reason ObjectDisposedException isn't throw
// instead we get a ArgumentNullException (probably from an internal method)
if (_workingBlock == null) {
throw new ArgumentNullException (
Locale.GetText ("object _disposed"));
}
int result = 0;
if ((count == 0) || ((_transformedPos == _transformedCount) && (_endOfStream)))
return result;
if (_waitingBlock == null) {
_transformedBlock = new byte [_transform.OutputBlockSize << 2];
_transformedPos = 0;
_transformedCount = 0;
_waitingBlock = new byte [_transform.InputBlockSize];
_waitingCount = _stream.Read (_waitingBlock, 0, _waitingBlock.Length);
}
while (count > 0) {
// transformed but not yet returned
int length = (_transformedCount - _transformedPos);
// need more data - at least one full block must be available if we haven't reach the end of the stream
if (length < _transform.InputBlockSize) {
int transformed = 0;
// load a new block
_workingCount = _stream.Read (_workingBlock, 0, _workingBlock.Length);
_endOfStream = (_workingCount < _transform.InputBlockSize);
if (!_endOfStream) {
// transform the waiting block
transformed = _transform.TransformBlock (_waitingBlock, 0, _waitingBlock.Length, _transformedBlock, _transformedCount);
// transfer temporary to waiting
Buffer.BlockCopy (_workingBlock, 0, _waitingBlock, 0, _workingCount);
_waitingCount = _workingCount;
}
else {
if (_workingCount > 0) {
// transform the waiting block
transformed = _transform.TransformBlock (_waitingBlock, 0, _waitingBlock.Length, _transformedBlock, _transformedCount);
// transfer temporary to waiting
Buffer.BlockCopy (_workingBlock, 0, _waitingBlock, 0, _workingCount);
_waitingCount = _workingCount;
length += transformed;
_transformedCount += transformed;
}
byte[] input = _transform.TransformFinalBlock (_waitingBlock, 0, _waitingCount);
transformed = input.Length;
Buffer.BlockCopy (input, 0, _transformedBlock, _transformedCount, input.Length);
// zeroize this last block
Array.Clear (input, 0, input.Length);
}
length += transformed;
_transformedCount += transformed;
}
// compaction
if (_transformedPos > _transform.InputBlockSize) {
Buffer.BlockCopy (_transformedBlock, _transformedPos, _transformedBlock, 0, length);
_transformedCount -= _transformedPos;
_transformedPos = 0;
}
length = ((count < length) ? count : length);
if (length > 0) {
Buffer.BlockCopy (_transformedBlock, _transformedPos, buffer, offset, length);
_transformedPos += length;
result += length;
offset += length;
count -= length;
}
// there may not be enough data in the stream for a
// complete block
if (((length != _transform.InputBlockSize) && (_waitingCount != _transform.InputBlockSize)) || (_endOfStream)) {
count = 0; // no more data can be read
}
}
return result;
}
public override void Write (byte[] buffer, int offset, int count)
{
if (_mode != CryptoStreamMode.Write) {
throw new NotSupportedException (
Locale.GetText ("not in Write mode"));
}
if (offset < 0) {
throw new ArgumentOutOfRangeException ("offset",
Locale.GetText ("negative"));
}
if (count < 0) {
throw new ArgumentOutOfRangeException ("count",
Locale.GetText ("negative"));
}
// re-ordered to avoid integer overflow
if (offset > buffer.Length - count) {
throw new ArgumentException ("(offset+count)",
Locale.GetText ("buffer overflow"));
}
// partial block (in progress)
if ((_partialCount > 0) && (_partialCount != _transform.InputBlockSize)) {
int remainder = _transform.InputBlockSize - _partialCount;
remainder = ((count < remainder) ? count : remainder);
Buffer.BlockCopy (buffer, offset, _workingBlock, _partialCount, remainder);
_partialCount += remainder;
offset += remainder;
count -= remainder;
}
int bufferPos = offset;
while (count > 0) {
if (_partialCount == _transform.InputBlockSize) {
// use partial block to avoid (re)allocation
int len = _transform.TransformBlock (_workingBlock, 0, _partialCount, _currentBlock, 0);
_stream.Write (_currentBlock, 0, len);
// reset
_partialCount = 0;
}
if (_transform.CanTransformMultipleBlocks) {
// transform all except the last block (which may be the last block
// of the stream and require TransformFinalBlock)
int numBlock = ((_partialCount + count) / _transform.InputBlockSize);
int multiSize = (numBlock * _transform.InputBlockSize);
if (numBlock > 0) {
byte[] multiBlocks = new byte [multiSize];
int len = _transform.TransformBlock (buffer, offset, multiSize, multiBlocks, 0);
_stream.Write (multiBlocks, 0, len);
// copy last block into _currentBlock
_partialCount = count - multiSize;
Buffer.BlockCopy (buffer, offset + multiSize, _workingBlock, 0, _partialCount);
}
else {
Buffer.BlockCopy (buffer, offset, _workingBlock, _partialCount, count);
_partialCount += count;
}
count = 0; // the last block, if any, is in _workingBlock
}
else {
int len = Math.Min (_transform.InputBlockSize - _partialCount, count);
Buffer.BlockCopy (buffer, bufferPos, _workingBlock, _partialCount, len);
bufferPos += len;
_partialCount += len;
count -= len;
// here block may be full, but we wont TransformBlock it until next iteration
// so that the last block will be called in FlushFinalBlock using TransformFinalBlock
}
}
}
public override void Flush ()
{
if (_stream != null)
_stream.Flush ();
}
public void FlushFinalBlock ()
{
if (_flushedFinalBlock) {
throw new NotSupportedException (
Locale.GetText ("This method cannot be called twice."));
}
if (_mode != CryptoStreamMode.Write) {
throw new NotSupportedException (
Locale.GetText ("cannot flush a non-writeable CryptoStream"));
}
_flushedFinalBlock = true;
byte[] finalBuffer = _transform.TransformFinalBlock (_workingBlock, 0, _partialCount);
if (_stream != null) {
_stream.Write (finalBuffer, 0, finalBuffer.Length);
if (_stream is CryptoStream) {
// for cascading crypto streams
(_stream as CryptoStream).FlushFinalBlock ();
}
_stream.Flush ();
}
// zeroize
Array.Clear (finalBuffer, 0, finalBuffer.Length);
}
public override long Seek (long offset, SeekOrigin origin)
{
throw new NotSupportedException ("Seek");
}
// LAMESPEC: Exception NotSupportedException not documented
public override void SetLength (long value)
{
throw new NotSupportedException ("SetLength");
}
#if NET_2_0
protected override void Dispose (bool disposing)
#else
protected virtual void Dispose (bool disposing)
#endif
{
if (!_disposed) {
_disposed = true;
// always cleared for security reason
if (_workingBlock != null)
Array.Clear (_workingBlock, 0, _workingBlock.Length);
if (_currentBlock != null)
Array.Clear (_currentBlock, 0, _currentBlock.Length);
if (disposing) {
_stream = null;
_workingBlock = null;
_currentBlock = null;
}
}
}
}
}
|