public void Test_CacheStream()
{
//for (int i = 0; i < 10; i++)
Parallel.For(0, 32, new ParallelOptions() { MaxDegreeOfParallelism = 64 }, i =>
{
//using (MemoryStream stream = new MemoryStream())
using (BufferStream bufferStream = new BufferStream(_bufferManager))
using (CacheStream stream = new CacheStream(bufferStream, 1024, _bufferManager))
{
byte[] buffer = _bufferManager.TakeBuffer(1024 * 1024); //new byte[_random.Next(128, 1024 * 1024 * 10)];
long seek = _random.Next(64, buffer.Length);
//long seek = 0;
_random.NextBytes(buffer);
stream.Write(buffer, 0, buffer.Length);
stream.Position = seek;
byte[] buff2 = _bufferManager.TakeBuffer(buffer.Length); //new byte[buffer.Length];
stream.Read(buff2, (int)seek, buff2.Length - (int)seek);
if (!CollectionUtilities.Equals(buffer, (int)seek, buff2, (int)seek, buffer.Length - (int)seek))
{
Assert.IsTrue(CollectionUtilities.Equals(buffer, (int)seek, buff2, (int)seek, buffer.Length - (int)seek));
}
_bufferManager.ReturnBuffer(buffer);
_bufferManager.ReturnBuffer(buff2);
}
});
using (MemoryStream mstream = new MemoryStream())
using (BufferStream bufferStream = new BufferStream(_bufferManager))
using (CacheStream stream = new CacheStream(bufferStream, 1024, _bufferManager))
{
for (int i = 0; i < 1024 * 1024; i++)
{
var v = (byte)_random.Next(0, 255);
mstream.WriteByte(v);
stream.WriteByte(v);
}
mstream.Seek(0, SeekOrigin.Begin);
stream.Seek(0, SeekOrigin.Begin);
Assert.IsTrue(mstream.Length == stream.Length);
for (int i = 0; i < 1024 * 1024; i++)
{
Assert.IsTrue(mstream.ReadByte() == stream.ReadByte());
}
}
}
public static string GetSignature(Certificate certificate)
{
if (certificate == null || certificate.Nickname == null || certificate.PublicKey == null) return null;
try
{
if (certificate.DigitalSignatureAlgorithm == DigitalSignatureAlgorithm.EcDsaP521_Sha256
|| certificate.DigitalSignatureAlgorithm == DigitalSignatureAlgorithm.Rsa2048_Sha256)
{
using (BufferStream bufferStream = new BufferStream(_bufferManager))
{
Signature.WriteString(bufferStream, certificate.Nickname);
bufferStream.Write(certificate.PublicKey, 0, certificate.PublicKey.Length);
bufferStream.Seek(0, SeekOrigin.Begin);
var signature = certificate.Nickname + "@" + NetworkConverter.ToBase64UrlString(Sha256.ComputeHash(bufferStream));
return _signatureCache.GetValue(signature, certificate);
}
}
return null;
}
catch (Exception)
{
return null;
}
}
public override void Send(Stream stream, TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
if (!_connect) throw new ConnectionException();
if (stream == null) throw new ArgumentNullException(nameof(stream));
if (stream.Length == 0) throw new ArgumentOutOfRangeException(nameof(stream));
lock (_sendLock)
{
using (RangeStream targetStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position, true))
{
try
{
_sendStopwatch.Restart();
Stream headerStream = new BufferStream(_bufferManager);
headerStream.Write(NetworkConverter.GetBytes((int)targetStream.Length), 0, 4);
using (Stream dataStream = new UniteStream(headerStream, new WrapperStream(targetStream, true)))
using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 32))
{
for (;;)
{
var sendLength = (int)Math.Min(dataStream.Length - dataStream.Position, safeBuffer.Value.Length);
if (sendLength == 0) break;
if (_bandwidthLimit != null && _bandwidthLimit.Out != 0)
{
sendLength = _bandwidthLimit.GetOutBandwidth(this, sendLength);
if (sendLength < 0) throw new ConnectionException();
}
dataStream.Read(safeBuffer.Value, 0, sendLength);
var time = Connection.CheckTimeout(_sendStopwatch.Elapsed, timeout);
time = (time < _sendTimeSpan) ? time : _sendTimeSpan;
_cap.Send(safeBuffer.Value, 0, sendLength, time);
_aliveStopwatch.Restart();
_sentByteCount.Add(sendLength);
}
}
_aliveTimer.Change(1000 * 30);
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
}
}
}
public override Stream Receive(TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
if (!_connect) throw new ConnectionException();
lock (_receiveLock)
{
try
{
_receiveStopwatch.Restart();
Restart:;
int length = 0;
{
byte[] lengthBuffer = new byte[4];
var time = Connection.CheckTimeout(_receiveStopwatch.Elapsed, timeout);
time = (time < _receiveTimeSpan) ? time : _receiveTimeSpan;
_cap.Receive(lengthBuffer, time);
_receivedByteCount.Add(4);
length = NetworkConverter.ToInt32(lengthBuffer);
}
if (length == 0)
{
Thread.Sleep(300);
goto Restart;
}
else if (length > _maxReceiveCount)
{
throw new ConnectionException();
}
BufferStream bufferStream = null;
try
{
bufferStream = new BufferStream(_bufferManager);
using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 32))
{
do
{
int receiveLength = Math.Min(safeBuffer.Value.Length, length);
var time = Connection.CheckTimeout(_receiveStopwatch.Elapsed, timeout);
time = (time < _receiveTimeSpan) ? time : _receiveTimeSpan;
if (_bandwidthLimit != null && _bandwidthLimit.In != 0)
{
if (_cap.Available == 0)
{
Thread.Sleep(300);
continue;
}
receiveLength = _bandwidthLimit.GetInBandwidth(this, Math.Min(_cap.Available, receiveLength));
if (receiveLength < 0) throw new ConnectionException();
}
_cap.Receive(safeBuffer.Value, 0, receiveLength, time);
_receivedByteCount.Add(receiveLength);
bufferStream.Write(safeBuffer.Value, 0, receiveLength);
length -= receiveLength;
} while (length > 0);
}
}
catch (Exception e)
{
if (bufferStream != null)
{
bufferStream.Dispose();
}
throw e;
}
bufferStream.Seek(0, SeekOrigin.Begin);
return bufferStream;
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
}
}
public override void Send(Stream stream, TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
if (stream == null) throw new ArgumentNullException("stream");
if (stream.Length == 0) throw new ArgumentOutOfRangeException("stream");
if (!_connect) throw new ConnectionException();
lock (_sendLock)
{
try
{
using (RangeStream targetStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position, true))
{
if (_version.HasFlag(SecureConnectionVersion.Version3))
{
using (BufferStream bufferStream = new BufferStream(_bufferManager))
{
bufferStream.SetLength(8);
bufferStream.Seek(8, SeekOrigin.Begin);
if (_informationVersion3.CryptoAlgorithm.HasFlag(SecureVersion3.CryptoAlgorithm.Aes256))
{
byte[] iv = new byte[16];
_random.GetBytes(iv);
bufferStream.Write(iv, 0, iv.Length);
using (var aes = Aes.Create())
{
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
using (CryptoStream cs = new CryptoStream(new WrapperStream(bufferStream, true), aes.CreateEncryptor(_informationVersion3.MyCryptoKey, iv), CryptoStreamMode.Write))
{
byte[] sendBuffer = null;
try
{
sendBuffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = targetStream.Read(sendBuffer, 0, sendBuffer.Length)) > 0)
{
cs.Write(sendBuffer, 0, i);
}
}
finally
{
if (sendBuffer != null)
{
_bufferManager.ReturnBuffer(sendBuffer);
}
}
}
}
}
else
{
throw new ConnectionException();
}
_totalSendSize += (bufferStream.Length - 8);
bufferStream.Seek(0, SeekOrigin.Begin);
byte[] totalSendSizeBuff = NetworkConverter.GetBytes(_totalSendSize);
bufferStream.Write(totalSendSizeBuff, 0, totalSendSizeBuff.Length);
if (_informationVersion3.HashAlgorithm.HasFlag(SecureVersion3.HashAlgorithm.Sha256))
{
bufferStream.Seek(0, SeekOrigin.Begin);
byte[] hmacBuff = HmacSha256.ComputeHash(bufferStream, _informationVersion3.MyHmacKey);
bufferStream.Seek(0, SeekOrigin.End);
bufferStream.Write(hmacBuff, 0, hmacBuff.Length);
}
else
{
throw new ConnectionException();
}
bufferStream.Seek(0, SeekOrigin.Begin);
_connection.Send(bufferStream, timeout, options);
}
}
else
{
throw new ConnectionException();
}
}
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
}
}
private static Stream AddPadding(Stream stream, int size)
{
if (stream == null) throw new ArgumentNullException("stream");
try
{
byte[] seedBuffer = new byte[4];
_random.GetBytes(seedBuffer);
Random random = new Random(NetworkConverter.ToInt32(seedBuffer));
BufferStream metadataStream = new BufferStream(_bufferManager);
byte[] lengthBuffer = NetworkConverter.GetBytes((int)stream.Length);
metadataStream.Write(lengthBuffer, 0, lengthBuffer.Length);
int paddingLength = size - ((int)stream.Length + 4);
BufferStream paddingStream = new BufferStream(_bufferManager);
{
byte[] buffer = null;
try
{
buffer = _bufferManager.TakeBuffer(1024);
while (paddingLength > 0)
{
int writeSize = Math.Min(paddingLength, buffer.Length);
random.NextBytes(buffer);
paddingStream.Write(buffer, 0, writeSize);
paddingLength -= writeSize;
}
}
finally
{
_bufferManager.ReturnBuffer(buffer);
}
}
return new UniteStream(metadataStream, new WrapperStream(stream, true), paddingStream);
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
public override System.IO.Stream Receive(TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
if (!_connect) throw new ConnectionException();
lock (_receiveLock)
{
Stream stream = null;
try
{
stream = _connection.Receive(timeout, options);
var version = (byte)stream.ReadByte();
Stream dataStream = null;
try
{
dataStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position);
if (version == (byte)0)
{
return dataStream;
}
else if (version == (byte)1)
{
BufferStream deflateBufferStream = null;
try
{
deflateBufferStream = new BufferStream(_bufferManager);
using (DeflateStream deflateStream = new DeflateStream(dataStream, CompressionMode.Decompress, true))
using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4))
{
int length;
while ((length = deflateStream.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0)
{
deflateBufferStream.Write(safeBuffer.Value, 0, length);
if (deflateBufferStream.Length > _maxReceiveCount) throw new ConnectionException();
}
}
}
catch (Exception e)
{
if (deflateBufferStream != null)
{
deflateBufferStream.Dispose();
}
throw e;
}
#if DEBUG
Debug.WriteLine("Receive : {0}→{1} {2}",
NetworkConverter.ToSizeString(stream.Length),
NetworkConverter.ToSizeString(deflateBufferStream.Length),
NetworkConverter.ToSizeString(stream.Length - deflateBufferStream.Length));
#endif
deflateBufferStream.Seek(0, SeekOrigin.Begin);
dataStream.Dispose();
return deflateBufferStream;
}
else
{
throw new ArgumentException("ArgumentException");
}
}
catch (ConnectionException e)
{
if (dataStream != null) dataStream.Dispose();
throw e;
}
catch (Exception e)
{
if (dataStream != null) dataStream.Dispose();
throw new ConnectionException(e.Message, e);
}
}
catch (ConnectionException e)
{
if (stream != null) stream.Dispose();
throw e;
}
catch (Exception e)
{
if (stream != null) stream.Dispose();
throw new ConnectionException(e.Message, e);
}
}
}
public static string GetSignature(DigitalSignature digitalSignature)
{
if (digitalSignature == null || digitalSignature.Nickname == null || digitalSignature.PublicKey == null) return null;
try
{
if (digitalSignature.DigitalSignatureAlgorithm == DigitalSignatureAlgorithm.EcDsaP521_Sha256
|| digitalSignature.DigitalSignatureAlgorithm == DigitalSignatureAlgorithm.Rsa2048_Sha256)
{
using (BufferStream bufferStream = new BufferStream(_bufferManager))
{
Signature.WriteString(bufferStream, digitalSignature.Nickname);
bufferStream.Write(digitalSignature.PublicKey, 0, digitalSignature.PublicKey.Length);
bufferStream.Seek(0, SeekOrigin.Begin);
return string.Concat(digitalSignature.Nickname, "@", NetworkConverter.ToBase64UrlString(Sha256.ComputeHash(bufferStream)));
}
}
return null;
}
catch (Exception)
{
return null;
}
}
private static Stream Decrypt(Stream stream, IExchangeDecrypt privateKey)
{
if (stream == null) throw new ArgumentNullException("stream");
if (privateKey == null) throw new ArgumentNullException("privateKey");
try
{
byte type = (byte)stream.ReadByte();
if (type == (byte)ConvertCryptoAlgorithm.Aes256)
{
byte[] cryptoKey;
{
byte[] lengthBuffer = new byte[4];
if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) throw new ArgumentException();
int length = NetworkConverter.ToInt32(lengthBuffer);
byte[] encryptedBuffer = new byte[length];
if (stream.Read(encryptedBuffer, 0, encryptedBuffer.Length) != encryptedBuffer.Length) throw new ArgumentException();
cryptoKey = Exchange.Decrypt(privateKey, encryptedBuffer);
}
BufferStream outStream = null;
try
{
outStream = new BufferStream(_bufferManager);
using (Stream dataStream = new WrapperStream(stream, true))
{
var iv = new byte[32];
dataStream.Read(iv, 0, iv.Length);
using (var rijndael = new RijndaelManaged() { KeySize = 256, BlockSize = 256, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 })
using (var inStream = new RangeStream(dataStream, dataStream.Position, dataStream.Length - dataStream.Position))
using (CryptoStream cs = new CryptoStream(inStream, rijndael.CreateDecryptor(cryptoKey, iv), CryptoStreamMode.Read))
{
byte[] buffer = null;
try
{
buffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = cs.Read(buffer, 0, buffer.Length)) > 0)
{
outStream.Write(buffer, 0, i);
}
}
finally
{
_bufferManager.ReturnBuffer(buffer);
}
}
}
outStream.Seek(0, SeekOrigin.Begin);
}
catch (Exception)
{
if (outStream != null)
{
outStream.Dispose();
}
throw;
}
return outStream;
}
throw new NotSupportedException();
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream Encrypt(Stream stream, IExchangeEncrypt publicKey)
{
if (stream == null) throw new ArgumentNullException("stream");
if (publicKey == null) throw new ArgumentNullException("publicKey");
try
{
BufferStream outStream = null;
try
{
outStream = new BufferStream(_bufferManager);
outStream.WriteByte((byte)ConvertCryptoAlgorithm.Aes256);
byte[] cryptoKey = new byte[32];
_random.GetBytes(cryptoKey);
{
var encryptedBuffer = Exchange.Encrypt(publicKey, cryptoKey);
outStream.Write(NetworkConverter.GetBytes((int)encryptedBuffer.Length), 0, 4);
outStream.Write(encryptedBuffer, 0, encryptedBuffer.Length);
}
byte[] iv = new byte[32];
_random.GetBytes(iv);
outStream.Write(iv, 0, iv.Length);
using (Stream inStream = new WrapperStream(stream, true))
{
using (var rijndael = new RijndaelManaged() { KeySize = 256, BlockSize = 256, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 })
using (CryptoStream cs = new CryptoStream(inStream, rijndael.CreateEncryptor(cryptoKey, iv), CryptoStreamMode.Read))
{
byte[] buffer = null;
try
{
buffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = cs.Read(buffer, 0, buffer.Length)) > 0)
{
outStream.Write(buffer, 0, i);
}
}
finally
{
if (buffer != null)
{
_bufferManager.ReturnBuffer(buffer);
}
}
}
}
outStream.Seek(0, SeekOrigin.Begin);
}
catch (Exception)
{
if (outStream != null)
{
outStream.Dispose();
}
throw;
}
return outStream;
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream Decompress(Stream stream)
{
if (stream == null) throw new ArgumentNullException("stream");
try
{
var targetStream = new RangeStream(stream, true);
byte type = (byte)targetStream.ReadByte();
if (type == (byte)ConvertCompressionAlgorithm.None)
{
return new RangeStream(targetStream);
}
else if (type == (byte)ConvertCompressionAlgorithm.Deflate)
{
using (Stream dataStream = new WrapperStream(targetStream, true))
{
BufferStream deflateBufferStream = null;
try
{
deflateBufferStream = new BufferStream(_bufferManager);
using (DeflateStream deflateStream = new DeflateStream(dataStream, CompressionMode.Decompress, true))
{
byte[] decompressBuffer = null;
try
{
decompressBuffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = deflateStream.Read(decompressBuffer, 0, decompressBuffer.Length)) > 0)
{
deflateBufferStream.Write(decompressBuffer, 0, i);
}
}
finally
{
if (decompressBuffer != null)
{
_bufferManager.ReturnBuffer(decompressBuffer);
}
}
}
deflateBufferStream.Seek(0, SeekOrigin.Begin);
#if DEBUG
Debug.WriteLine("ContentConverter Decompress {3} : {0}→{1} {2}",
NetworkConverter.ToSizeString(dataStream.Length),
NetworkConverter.ToSizeString(deflateBufferStream.Length),
NetworkConverter.ToSizeString(dataStream.Length - deflateBufferStream.Length),
ConvertCompressionAlgorithm.Deflate);
#endif
return deflateBufferStream;
}
catch (Exception)
{
if (deflateBufferStream != null)
{
deflateBufferStream.Dispose();
}
}
}
}
throw new ArgumentException("ArgumentException");
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
private static Stream Compress(Stream stream)
{
if (stream == null) throw new ArgumentNullException("stream");
var targetStream = new RangeStream(stream, true);
List<KeyValuePair<byte, Stream>> list = new List<KeyValuePair<byte, Stream>>();
try
{
targetStream.Seek(0, SeekOrigin.Begin);
BufferStream deflateBufferStream = null;
try
{
deflateBufferStream = new BufferStream(_bufferManager);
using (DeflateStream deflateStream = new DeflateStream(deflateBufferStream, CompressionMode.Compress, true))
{
byte[] compressBuffer = null;
try
{
compressBuffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = targetStream.Read(compressBuffer, 0, compressBuffer.Length)) > 0)
{
deflateStream.Write(compressBuffer, 0, i);
}
}
finally
{
if (compressBuffer != null)
{
_bufferManager.ReturnBuffer(compressBuffer);
}
}
}
deflateBufferStream.Seek(0, SeekOrigin.Begin);
list.Add(new KeyValuePair<byte, Stream>((byte)ConvertCompressionAlgorithm.Deflate, deflateBufferStream));
}
catch (Exception)
{
if (deflateBufferStream != null)
{
deflateBufferStream.Dispose();
}
}
}
catch (Exception)
{
}
list.Add(new KeyValuePair<byte, Stream>((byte)ConvertCompressionAlgorithm.None, targetStream));
list.Sort((x, y) =>
{
int c = x.Value.Length.CompareTo(y.Value.Length);
if (c != 0) return c;
return x.Key.CompareTo(y.Key);
});
#if DEBUG
if (list[0].Value.Length != targetStream.Length)
{
Debug.WriteLine("ContentConverter Compress {3} : {0}→{1} {2}",
NetworkConverter.ToSizeString(targetStream.Length),
NetworkConverter.ToSizeString(list[0].Value.Length),
NetworkConverter.ToSizeString(list[0].Value.Length - targetStream.Length),
(ConvertCompressionAlgorithm)list[0].Key);
}
#endif
for (int i = 1; i < list.Count; i++)
{
list[i].Value.Dispose();
}
BufferStream metadataStream = new BufferStream(_bufferManager);
metadataStream.WriteByte((byte)list[0].Key);
return new UniteStream(metadataStream, list[0].Value);
}
private static Stream AddType(Stream stream, string type)
{
if (stream == null) throw new ArgumentNullException("stream");
List<Stream> streams = new List<Stream>();
Encoding encoding = new UTF8Encoding(false);
// Type
if (type != null)
{
BufferStream bufferStream = new BufferStream(_bufferManager);
bufferStream.SetLength(4);
bufferStream.Seek(4, SeekOrigin.Begin);
using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true))
using (StreamWriter writer = new StreamWriter(wrapperStream, encoding))
{
writer.Write(type);
}
bufferStream.Seek(0, SeekOrigin.Begin);
bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 4), 0, 4);
streams.Add(bufferStream);
}
streams.Add(new WrapperStream(stream, true));
return new UniteStream(streams);
}
public void Test_Metadata()
{
foreach (var a in new DigitalSignatureAlgorithm[] { DigitalSignatureAlgorithm.Rsa2048_Sha256, DigitalSignatureAlgorithm.EcDsaP521_Sha256 })
{
var id = new byte[32];
_random.NextBytes(id);
var key = new Key(id, HashAlgorithm.Sha256);
var tag = new Chat("oooo", new byte[32]);
var miner = new Miner(CashAlgorithm.Version1, -1, TimeSpan.Zero);
var digitalSignature = new DigitalSignature("123", a);
var metadata = new ChatMessageMetadata(tag, DateTime.UtcNow, key, miner, digitalSignature);
ChatMessageMetadata metadata2;
{
var ds = new DataContractSerializer(typeof(ChatMessageMetadata));
using (BufferStream stream = new BufferStream(BufferManager.Instance))
{
using (WrapperStream wrapperStream = new WrapperStream(stream, true))
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(wrapperStream))
{
ds.WriteObject(xmlDictionaryWriter, metadata);
}
stream.Position = 0;
using (XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
metadata2 = (ChatMessageMetadata)ds.ReadObject(xmlDictionaryReader);
}
}
}
Assert.AreEqual(metadata, metadata2, "Metadata #1");
ChatMessageMetadata metadata3;
using (var metadataStream = metadata.Export(_bufferManager))
{
metadata3 = ChatMessageMetadata.Import(metadataStream, _bufferManager);
}
Assert.AreEqual(metadata, metadata3, "Metadata #2");
Assert.IsTrue(metadata3.VerifyCertificate(), "Metadata #3");
}
}
private void DecodeManagerThread()
{
for (; ; )
{
Thread.Sleep(1000 * 3);
if (this.State == ManagerState.Stop) return;
BackgroundDownloadItem item = null;
try
{
lock (this.ThisLock)
{
if (_settings.BackgroundDownloadItems.Count > 0)
{
item = _settings.BackgroundDownloadItems
.Where(n => n.State == BackgroundDownloadState.Decoding)
.OrderBy(n => (n.Rank != n.Seed.Rank) ? 0 : 1)
.FirstOrDefault();
}
}
}
catch (Exception)
{
return;
}
if (item == null) continue;
try
{
if (item.Rank == 1)
{
if (!_cacheManager.Contains(item.Seed.Key))
{
item.State = BackgroundDownloadState.Downloading;
}
else
{
item.State = BackgroundDownloadState.Decoding;
if (item.Rank < item.Seed.Rank)
{
string fileName = null;
bool largeFlag = false;
try
{
using (FileStream stream = BackgroundDownloadManager.GetUniqueFileStream(Path.Combine(_workDirectory, "index")))
using (ProgressStream decodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
{
isStop = (this.State == ManagerState.Stop || !_settings.BackgroundDownloadItems.Contains(item));
if (!isStop && (stream.Length > item.Seed.Length))
{
isStop = true;
largeFlag = true;
}
}, 1024 * 1024, true))
{
fileName = stream.Name;
_cacheManager.Decoding(decodingProgressStream, item.Seed.CompressionAlgorithm, item.Seed.CryptoAlgorithm, item.Seed.CryptoKey,
new KeyCollection() { item.Seed.Key });
}
}
catch (StopIoException)
{
if (File.Exists(fileName))
File.Delete(fileName);
if (largeFlag)
{
throw new Exception();
}
continue;
}
catch (Exception)
{
if (File.Exists(fileName))
File.Delete(fileName);
throw;
}
Index index;
using (FileStream stream = new FileStream(fileName, FileMode.Open))
{
index = Index.Import(stream, _bufferManager);
}
File.Delete(fileName);
lock (this.ThisLock)
{
this.UncheckState(item.Index);
item.Index = index;
this.CheckState(item.Index);
foreach (var group in item.Index.Groups)
{
foreach (var key in group.Keys)
{
_cacheManager.Lock(key);
}
}
item.Indexes.Add(index);
item.Rank++;
item.State = BackgroundDownloadState.Downloading;
}
}
else
{
bool largeFlag = false;
object value = null;
try
{
using (Stream stream = new BufferStream(_bufferManager))
using (ProgressStream decodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
{
isStop = (this.State == ManagerState.Stop || !_settings.BackgroundDownloadItems.Contains(item));
if (!isStop && (stream.Length > item.Seed.Length))
{
isStop = true;
largeFlag = true;
}
}, 1024 * 1024, true))
{
_cacheManager.Decoding(decodingProgressStream, item.Seed.CompressionAlgorithm, item.Seed.CryptoAlgorithm, item.Seed.CryptoKey,
new KeyCollection() { item.Seed.Key });
if (stream.Length != item.Seed.Length) throw new Exception();
stream.Seek(0, SeekOrigin.Begin);
if (item.Type == BackgroundItemType.Link)
{
value = Link.Import(stream, _bufferManager);
}
else if (item.Type == BackgroundItemType.Store)
{
value = Store.Import(stream, _bufferManager);
}
}
}
catch (StopIoException)
{
if (largeFlag)
{
throw new Exception();
}
continue;
}
catch (Exception)
{
throw;
}
lock (this.ThisLock)
{
item.Value = value;
if (item.Seed.Key != null)
{
_cacheManager.Unlock(item.Seed.Key);
}
foreach (var index in item.Indexes)
{
foreach (var group in index.Groups)
{
foreach (var key in group.Keys)
{
_cacheManager.Unlock(key);
}
}
}
item.Indexes.Clear();
item.State = BackgroundDownloadState.Completed;
}
}
}
}
else
{
if (!item.Index.Groups.All(n => _existManager.GetCount(n) >= n.InformationLength))
{
item.State = BackgroundDownloadState.Downloading;
}
else
{
List<Key> keys = new List<Key>();
try
{
foreach (var group in item.Index.Groups.ToArray())
{
keys.AddRange(_cacheManager.ParityDecoding(group, (object state2) =>
{
return (this.State == ManagerState.Stop || !_settings.BackgroundDownloadItems.Contains(item));
}));
}
}
catch (StopException)
{
continue;
}
item.State = BackgroundDownloadState.Decoding;
if (item.Rank < item.Seed.Rank)
{
string fileName = null;
bool largeFlag = false;
try
{
using (FileStream stream = BackgroundDownloadManager.GetUniqueFileStream(Path.Combine(_workDirectory, "index")))
using (ProgressStream decodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
{
isStop = (this.State == ManagerState.Stop || !_settings.BackgroundDownloadItems.Contains(item));
if (!isStop && (stream.Length > item.Seed.Length))
{
isStop = true;
largeFlag = true;
}
}, 1024 * 1024, true))
{
fileName = stream.Name;
_cacheManager.Decoding(decodingProgressStream, item.Index.CompressionAlgorithm, item.Index.CryptoAlgorithm, item.Index.CryptoKey,
new KeyCollection(keys));
}
}
catch (StopIoException)
{
if (File.Exists(fileName))
File.Delete(fileName);
if (largeFlag)
{
throw new Exception();
}
continue;
}
catch (Exception)
{
if (File.Exists(fileName))
File.Delete(fileName);
throw;
}
Index index;
using (FileStream stream = new FileStream(fileName, FileMode.Open))
{
index = Index.Import(stream, _bufferManager);
}
File.Delete(fileName);
lock (this.ThisLock)
{
this.UncheckState(item.Index);
item.Index = index;
this.CheckState(item.Index);
foreach (var group in item.Index.Groups)
{
foreach (var key in group.Keys)
{
_cacheManager.Lock(key);
}
}
item.Indexes.Add(index);
item.Rank++;
item.State = BackgroundDownloadState.Downloading;
}
}
else
{
item.State = BackgroundDownloadState.Decoding;
bool largeFlag = false;
object value = null;
try
{
using (Stream stream = new BufferStream(_bufferManager))
using (ProgressStream decodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
{
isStop = (this.State == ManagerState.Stop || !_settings.BackgroundDownloadItems.Contains(item));
if (!isStop && (stream.Length > item.Seed.Length))
{
isStop = true;
largeFlag = true;
}
}, 1024 * 1024, true))
{
_cacheManager.Decoding(decodingProgressStream, item.Index.CompressionAlgorithm, item.Index.CryptoAlgorithm, item.Index.CryptoKey,
new KeyCollection(keys));
if (stream.Length != item.Seed.Length) throw new Exception();
stream.Seek(0, SeekOrigin.Begin);
if (item.Type == BackgroundItemType.Link)
{
value = Link.Import(stream, _bufferManager);
}
else if (item.Type == BackgroundItemType.Store)
{
value = Store.Import(stream, _bufferManager);
}
}
}
catch (StopIoException)
{
if (largeFlag)
{
throw new Exception();
}
continue;
}
catch (Exception)
{
throw;
}
lock (this.ThisLock)
{
item.Value = value;
if (item.Seed.Key != null)
{
_cacheManager.Unlock(item.Seed.Key);
}
foreach (var index in item.Indexes)
{
foreach (var group in index.Groups)
{
foreach (var key in group.Keys)
{
_cacheManager.Unlock(key);
}
}
}
item.Indexes.Clear();
item.State = BackgroundDownloadState.Completed;
}
}
}
}
}
catch (Exception e)
{
if (_cacheManager.Contains(item.Seed.Key))
{
ArraySegment<byte> buffer = new ArraySegment<byte>();
try
{
buffer = _cacheManager[item.Seed.Key];
}
catch (Exception)
{
}
finally
{
if (buffer.Array != null)
{
_bufferManager.ReturnBuffer(buffer.Array);
}
}
}
foreach (var index in item.Indexes)
{
foreach (var group in index.Groups)
{
foreach (var key in group.Keys)
{
if (this.State == ManagerState.Stop) return;
if (!_cacheManager.Contains(key)) continue;
ArraySegment<byte> buffer = new ArraySegment<byte>();
try
{
buffer = _cacheManager[key];
}
catch (Exception)
{
}
finally
{
if (buffer.Array != null)
{
_bufferManager.ReturnBuffer(buffer.Array);
}
}
}
}
}
item.State = BackgroundDownloadState.Error;
Log.Error(e);
}
}
}
public void Test_Tag()
{
var tag = new Chat("oooo", new byte[32]);
Chat tag2;
{
var ds = new DataContractSerializer(typeof(Chat));
using (BufferStream stream = new BufferStream(BufferManager.Instance))
{
using (WrapperStream wrapperStream = new WrapperStream(stream, true))
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(wrapperStream))
{
ds.WriteObject(xmlDictionaryWriter, tag);
}
stream.Position = 0;
using (XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
{
tag2 = (Chat)ds.ReadObject(xmlDictionaryReader);
}
}
}
Assert.AreEqual(tag, tag2, "Tag #1");
Chat tag3;
using (var tagStream = tag.Export(_bufferManager))
{
tag3 = Chat.Import(tagStream, _bufferManager);
}
Assert.AreEqual(tag, tag3, "Tag #2");
}
public override void Connect(TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
lock (this.ThisLock)
{
try
{
SecureVersion3.ProtocolInformation myProtocol3;
SecureVersion3.ProtocolInformation otherProtocol3;
{
OperatingSystem osInfo = Environment.OSVersion;
// Windows Vista�ȏ�B
if (osInfo.Platform == PlatformID.Win32NT && osInfo.Version >= new Version(6, 0))
{
{
byte[] sessionId = new byte[32];
_random.GetBytes(sessionId);
myProtocol3 = new SecureVersion3.ProtocolInformation()
{
KeyExchangeAlgorithm = SecureVersion3.KeyExchangeAlgorithm.EcDiffieHellmanP521 | SecureVersion3.KeyExchangeAlgorithm.Rsa2048,
KeyDerivationAlgorithm = SecureVersion3.KeyDerivationAlgorithm.Pbkdf2,
CryptoAlgorithm = SecureVersion3.CryptoAlgorithm.Aes256,
HashAlgorithm = SecureVersion3.HashAlgorithm.Sha256,
SessionId = sessionId,
};
}
}
else
{
{
byte[] sessionId = new byte[32];
_random.GetBytes(sessionId);
myProtocol3 = new SecureVersion3.ProtocolInformation()
{
KeyExchangeAlgorithm = SecureVersion3.KeyExchangeAlgorithm.Rsa2048,
KeyDerivationAlgorithm = SecureVersion3.KeyDerivationAlgorithm.Pbkdf2,
CryptoAlgorithm = SecureVersion3.CryptoAlgorithm.Aes256,
HashAlgorithm = SecureVersion3.HashAlgorithm.Sha256,
SessionId = sessionId,
};
}
}
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
using (BufferStream stream = new BufferStream(_bufferManager))
using (XmlTextWriter xml = new XmlTextWriter(stream, new UTF8Encoding(false)))
{
xml.WriteStartDocument();
xml.WriteStartElement("Protocol");
if (_myVersion.HasFlag(SecureConnectionVersion.Version3))
{
xml.WriteStartElement("SecureConnection");
xml.WriteAttributeString("Version", "3");
xml.WriteEndElement(); //Protocol
}
xml.WriteEndElement(); //Configuration
xml.WriteEndDocument();
xml.Flush();
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
_connection.Send(stream, CheckTimeout(stopwatch.Elapsed, timeout));
}
otherProtocol3 = new SecureVersion3.ProtocolInformation();
using (Stream stream = _connection.Receive(CheckTimeout(stopwatch.Elapsed, timeout)))
using (XmlTextReader xml = new XmlTextReader(stream))
{
while (xml.Read())
{
if (xml.NodeType == XmlNodeType.Element)
{
if (xml.LocalName == "SecureConnection")
{
if (xml.GetAttribute("Version") == "3")
{
_otherVersion |= SecureConnectionVersion.Version3;
}
}
}
}
}
_version = _myVersion & _otherVersion;
// Version3
if (_version.HasFlag(SecureConnectionVersion.Version3))
{
using (Stream stream = myProtocol3.Export(_bufferManager))
{
_connection.Send(stream, CheckTimeout(stopwatch.Elapsed, timeout));
}
using (Stream stream = _connection.Receive(CheckTimeout(stopwatch.Elapsed, timeout)))
{
otherProtocol3 = SecureVersion3.ProtocolInformation.Import(stream, _bufferManager);
}
var keyExchangeAlgorithm = myProtocol3.KeyExchangeAlgorithm & otherProtocol3.KeyExchangeAlgorithm;
var keyDerivationFunctionAlgorithm = myProtocol3.KeyDerivationAlgorithm & otherProtocol3.KeyDerivationAlgorithm;
var cryptoAlgorithm = myProtocol3.CryptoAlgorithm & otherProtocol3.CryptoAlgorithm;
var hashAlgorithm = myProtocol3.HashAlgorithm & otherProtocol3.HashAlgorithm;
byte[] myCryptoKey;
byte[] otherCryptoKey;
byte[] myHmacKey;
byte[] otherHmacKey;
byte[] myProtocolHash = null;
byte[] otherProtocolHash = null;
if (hashAlgorithm.HasFlag(SecureVersion3.HashAlgorithm.Sha256))
{
using (var myProtocolHashStream = myProtocol3.Export(_bufferManager))
using (var otherProtocolHashStream = otherProtocol3.Export(_bufferManager))
{
myProtocolHash = Sha256.ComputeHash(myProtocolHashStream);
otherProtocolHash = Sha256.ComputeHash(otherProtocolHashStream);
}
}
byte[] seed = null;
if (keyExchangeAlgorithm.HasFlag(SecureVersion3.KeyExchangeAlgorithm.EcDiffieHellmanP521))
{
byte[] publicKey, privateKey;
EcDiffieHellmanP521.CreateKeys(out publicKey, out privateKey);
{
SecureVersion3.ConnectionSignature connectionSignature = new SecureVersion3.ConnectionSignature();
connectionSignature.ExchangeKey = publicKey;
if (_digitalSignature != null)
{
connectionSignature.CreationTime = DateTime.UtcNow;
connectionSignature.ProtocolHash = myProtocolHash;
connectionSignature.CreateCertificate(_digitalSignature);
}
using (Stream stream = connectionSignature.Export(_bufferManager))
{
_connection.Send(stream, CheckTimeout(stopwatch.Elapsed, timeout));
}
}
byte[] otherPublicKey = null;
using (Stream stream = _connection.Receive(CheckTimeout(stopwatch.Elapsed, timeout)))
{
SecureVersion3.ConnectionSignature connectionSignature = SecureVersion3.ConnectionSignature.Import(stream, _bufferManager);
if (connectionSignature.VerifyCertificate())
{
if (connectionSignature.Certificate != null)
{
DateTime now = DateTime.UtcNow;
TimeSpan span = (now > connectionSignature.CreationTime) ? now - connectionSignature.CreationTime : connectionSignature.CreationTime - now;
if (span > new TimeSpan(0, 30, 0)) throw new ConnectionException();
if (!Unsafe.Equals(connectionSignature.ProtocolHash, otherProtocolHash)) throw new ConnectionException();
}
_certificate = connectionSignature.Certificate;
otherPublicKey = connectionSignature.ExchangeKey;
}
else
{
throw new ConnectionException();
}
}
if (hashAlgorithm.HasFlag(SecureVersion3.HashAlgorithm.Sha256))
{
seed = EcDiffieHellmanP521.DeriveKeyMaterial(privateKey, otherPublicKey, CngAlgorithm.Sha256);
}
if (seed == null) throw new ConnectionException();
}
else if (keyExchangeAlgorithm.HasFlag(SecureVersion3.KeyExchangeAlgorithm.Rsa2048))
{
byte[] publicKey, privateKey;
Rsa2048.CreateKeys(out publicKey, out privateKey);
{
SecureVersion3.ConnectionSignature connectionSignature = new SecureVersion3.ConnectionSignature();
connectionSignature.ExchangeKey = publicKey;
if (_digitalSignature != null)
{
connectionSignature.CreationTime = DateTime.UtcNow;
connectionSignature.ProtocolHash = myProtocolHash;
connectionSignature.CreateCertificate(_digitalSignature);
}
using (Stream stream = connectionSignature.Export(_bufferManager))
{
_connection.Send(stream, CheckTimeout(stopwatch.Elapsed, timeout));
}
}
byte[] otherPublicKey;
using (Stream stream = _connection.Receive(CheckTimeout(stopwatch.Elapsed, timeout)))
{
SecureVersion3.ConnectionSignature connectionSignature = SecureVersion3.ConnectionSignature.Import(stream, _bufferManager);
if (connectionSignature.VerifyCertificate())
{
if (connectionSignature.Certificate != null)
{
DateTime now = DateTime.UtcNow;
TimeSpan span = (now > connectionSignature.CreationTime) ? now - connectionSignature.CreationTime : connectionSignature.CreationTime - now;
if (span > new TimeSpan(0, 30, 0)) throw new ConnectionException();
if (!Unsafe.Equals(connectionSignature.ProtocolHash, otherProtocolHash)) throw new ConnectionException();
}
_certificate = connectionSignature.Certificate;
otherPublicKey = connectionSignature.ExchangeKey;
}
else
{
throw new ConnectionException();
}
}
byte[] mySeed = new byte[128];
_random.GetBytes(mySeed);
using (MemoryStream stream = new MemoryStream(Rsa2048.Encrypt(otherPublicKey, mySeed)))
{
_connection.Send(stream, CheckTimeout(stopwatch.Elapsed, timeout));
}
byte[] otherSeed;
using (Stream stream = _connection.Receive(CheckTimeout(stopwatch.Elapsed, timeout)))
{
var buffer = new byte[stream.Length];
stream.Read(buffer, 0, buffer.Length);
otherSeed = Rsa2048.Decrypt(privateKey, buffer);
}
if (otherSeed == null) throw new ConnectionException();
seed = new byte[Math.Max(mySeed.Length, otherSeed.Length)];
Unsafe.Xor(mySeed, otherSeed, seed);
}
else
{
throw new ConnectionException();
}
if (keyDerivationFunctionAlgorithm.HasFlag(SecureVersion3.KeyDerivationAlgorithm.Pbkdf2))
{
byte[] xorSessionId = new byte[Math.Max(myProtocol3.SessionId.Length, otherProtocol3.SessionId.Length)];
Unsafe.Xor(myProtocol3.SessionId, otherProtocol3.SessionId, xorSessionId);
HMAC hmac = null;
if (hashAlgorithm.HasFlag(SecureVersion3.HashAlgorithm.Sha256))
{
hmac = new HMACSHA256();
hmac.HashName = "SHA256";
}
else
{
throw new ConnectionException();
}
Pbkdf2 pbkdf2 = new Pbkdf2(hmac, seed, xorSessionId, 1024);
int cryptoKeyLength;
int hmacKeyLength;
if (cryptoAlgorithm.HasFlag(SecureVersion3.CryptoAlgorithm.Aes256))
{
cryptoKeyLength = 32;
}
else
{
throw new ConnectionException();
}
if (hashAlgorithm.HasFlag(SecureVersion3.HashAlgorithm.Sha256))
{
hmacKeyLength = 32;
}
else
{
throw new ConnectionException();
}
myCryptoKey = new byte[cryptoKeyLength];
otherCryptoKey = new byte[cryptoKeyLength];
myHmacKey = new byte[hmacKeyLength];
otherHmacKey = new byte[hmacKeyLength];
using (MemoryStream stream = new MemoryStream(pbkdf2.GetBytes((cryptoKeyLength + hmacKeyLength) * 2)))
{
if (_type == SecureConnectionType.Connect)
{
stream.Read(myCryptoKey, 0, myCryptoKey.Length);
stream.Read(otherCryptoKey, 0, otherCryptoKey.Length);
stream.Read(myHmacKey, 0, myHmacKey.Length);
stream.Read(otherHmacKey, 0, otherHmacKey.Length);
}
else if (_type == SecureConnectionType.Accept)
{
stream.Read(otherCryptoKey, 0, otherCryptoKey.Length);
stream.Read(myCryptoKey, 0, myCryptoKey.Length);
stream.Read(otherHmacKey, 0, otherHmacKey.Length);
stream.Read(myHmacKey, 0, myHmacKey.Length);
}
else
{
throw new ConnectionException();
}
}
}
else
{
throw new ConnectionException();
}
_informationVersion3 = new InformationVersion3();
_informationVersion3.CryptoAlgorithm = cryptoAlgorithm;
_informationVersion3.HashAlgorithm = hashAlgorithm;
_informationVersion3.MyCryptoKey = myCryptoKey;
_informationVersion3.OtherCryptoKey = otherCryptoKey;
_informationVersion3.MyHmacKey = myHmacKey;
_informationVersion3.OtherHmacKey = otherHmacKey;
}
else
{
throw new ConnectionException();
}
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
_connect = true;
}
}
public override void Connect(TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
lock (this.ThisLock)
{
try
{
var stopwatch = new Stopwatch();
stopwatch.Start();
using (BufferStream stream = new BufferStream(_bufferManager))
{
byte[] buffer = NetworkConverter.GetBytes((uint)_myCompressAlgorithm);
stream.Write(buffer, 0, buffer.Length);
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
_connection.Send(stream, CheckTimeout(stopwatch.Elapsed, timeout));
}
using (Stream stream = _connection.Receive(CheckTimeout(stopwatch.Elapsed, timeout)))
{
byte[] buffer = new byte[4];
stream.Read(buffer, 0, buffer.Length);
_otherCompressAlgorithm = (CompressAlgorithm)NetworkConverter.ToUInt32(buffer);
}
}
catch (ConnectionException ex)
{
throw ex;
}
catch (Exception ex)
{
throw new ConnectionException(ex.Message, ex);
}
_connect = true;
}
}
public override Stream Receive(TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
if (!_connect) throw new ConnectionException();
lock (_receiveLock)
{
try
{
if (_version.HasFlag(SecureConnectionVersion.Version3))
{
using (Stream stream = _connection.Receive(timeout, options))
{
byte[] totalReceiveSizeBuff = new byte[8];
if (stream.Read(totalReceiveSizeBuff, 0, totalReceiveSizeBuff.Length) != totalReceiveSizeBuff.Length) throw new ConnectionException();
long totalReceiveSize = NetworkConverter.ToInt64(totalReceiveSizeBuff);
if (_informationVersion3.HashAlgorithm.HasFlag(SecureVersion3.HashAlgorithm.Sha256))
{
const int hashLength = 32;
_totalReceiveSize += (stream.Length - (8 + hashLength));
if (totalReceiveSize != _totalReceiveSize) throw new ConnectionException();
byte[] otherHmacBuff = new byte[hashLength];
stream.Seek(-hashLength, SeekOrigin.End);
if (stream.Read(otherHmacBuff, 0, otherHmacBuff.Length) != otherHmacBuff.Length) throw new ConnectionException();
stream.SetLength(stream.Length - hashLength);
stream.Seek(0, SeekOrigin.Begin);
byte[] myHmacBuff = HmacSha256.ComputeHash(stream, _informationVersion3.OtherHmacKey);
if (!Unsafe.Equals(otherHmacBuff, myHmacBuff)) throw new ConnectionException();
stream.Seek(8, SeekOrigin.Begin);
}
else
{
throw new ConnectionException();
}
BufferStream bufferStream = new BufferStream(_bufferManager);
if (_informationVersion3.CryptoAlgorithm.HasFlag(SecureVersion3.CryptoAlgorithm.Aes256))
{
byte[] iv = new byte[16];
stream.Read(iv, 0, iv.Length);
using (var aes = Aes.Create())
{
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
using (CryptoStream cs = new CryptoStream(new WrapperStream(bufferStream, true), aes.CreateDecryptor(_informationVersion3.OtherCryptoKey, iv), CryptoStreamMode.Write))
{
byte[] receiveBuffer = null;
try
{
receiveBuffer = _bufferManager.TakeBuffer(1024 * 4);
int i = -1;
while ((i = stream.Read(receiveBuffer, 0, receiveBuffer.Length)) > 0)
{
cs.Write(receiveBuffer, 0, i);
}
}
finally
{
if (receiveBuffer != null)
{
_bufferManager.ReturnBuffer(receiveBuffer);
}
}
}
}
}
else
{
throw new ConnectionException();
}
bufferStream.Seek(0, SeekOrigin.Begin);
return bufferStream;
}
}
else
{
throw new ConnectionException();
}
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
}
}
public override void Send(System.IO.Stream stream, TimeSpan timeout, Information options)
{
if (_disposed) throw new ObjectDisposedException(this.GetType().FullName);
if (!_connect) throw new ConnectionException();
if (stream == null) throw new ArgumentNullException(nameof(stream));
if (stream.Length == 0) throw new ArgumentOutOfRangeException(nameof(stream));
bool isCompress = true;
if (options != null)
{
if (options.Contains("IsCompress")) isCompress = (bool)options["IsCompress"];
}
lock (_sendLock)
{
using (RangeStream targetStream = new RangeStream(stream, stream.Position, stream.Length - stream.Position, true))
{
try
{
var list = new List<KeyValuePair<byte, Stream>>();
if (isCompress)
{
if (_otherCompressAlgorithm.HasFlag(CompressAlgorithm.Deflate))
{
BufferStream deflateBufferStream = null;
try
{
deflateBufferStream = new BufferStream(_bufferManager);
using (DeflateStream deflateStream = new DeflateStream(deflateBufferStream, CompressionMode.Compress, true))
using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4))
{
int length;
while ((length = targetStream.Read(safeBuffer.Value, 0, safeBuffer.Value.Length)) > 0)
{
deflateStream.Write(safeBuffer.Value, 0, length);
}
}
deflateBufferStream.Seek(0, SeekOrigin.Begin);
list.Add(new KeyValuePair<byte, Stream>((byte)1, deflateBufferStream));
}
catch (Exception e)
{
if (deflateBufferStream != null)
{
deflateBufferStream.Dispose();
}
throw e;
}
}
}
list.Add(new KeyValuePair<byte, Stream>((byte)0, new WrapperStream(targetStream, true)));
list.Sort((x, y) =>
{
int c = x.Value.Length.CompareTo(y.Value.Length);
if (c != 0) return c;
return x.Key.CompareTo(y.Key);
});
#if DEBUG
if (list[0].Value.Length != targetStream.Length)
{
Debug.WriteLine("Send : {0}→{1} {2}",
NetworkConverter.ToSizeString(targetStream.Length),
NetworkConverter.ToSizeString(list[0].Value.Length),
NetworkConverter.ToSizeString(list[0].Value.Length - targetStream.Length));
}
#endif
for (int i = 1; i < list.Count; i++)
{
list[i].Value.Dispose();
}
var headerStream = new BufferStream(_bufferManager);
headerStream.WriteByte((byte)list[0].Key);
using (var dataStream = new UniteStream(headerStream, list[0].Value))
{
_connection.Send(dataStream, timeout, options);
}
}
catch (ConnectionException e)
{
throw e;
}
catch (Exception e)
{
throw new ConnectionException(e.Message, e);
}
}
}
}
private static Stream AddHash(Stream stream)
{
if (stream == null) throw new ArgumentNullException("stream");
try
{
var targetStream = new RangeStream(stream, true);
BufferStream metadataStream = new BufferStream(_bufferManager);
metadataStream.WriteByte((byte)ConvertHashAlgorithm.Sha256);
targetStream.Seek(0, SeekOrigin.Begin);
var hash = Sha256.ComputeHash(targetStream);
BufferStream hashStream = new BufferStream(_bufferManager);
hashStream.Write(hash, 0, hash.Length);
return new UniteStream(metadataStream, targetStream, hashStream);
}
catch (Exception e)
{
throw new ArgumentException(e.Message, e);
}
}
