public static byte[] ComputeHash(byte[] buffer, int offset, int length) { if (buffer == null) { throw new ArgumentNullException("buffer"); } if (offset < 0 || buffer.Length < offset) { throw new ArgumentOutOfRangeException("offset"); } if (length < 0 || (buffer.Length - offset) < length) { throw new ArgumentOutOfRangeException("length"); } uint x = 0xFFFFFFFF; fixed(byte *p_buffer = buffer) { var t_buffer = p_buffer + offset; x = _compute(x, t_buffer, length); } return(NetworkConverter.GetBytes(x ^ 0xFFFFFFFF)); }
public static void Write(Stream stream, byte type, Stream exportStream) { stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(1024 * 4); int length = 0; while ((length = exportStream.Read(buffer, 0, buffer.Length)) > 0) { stream.Write(buffer, 0, length); } } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
private byte[] Function() { if (_blockIndex == uint.MaxValue) { throw new InvalidOperationException("Derived key too long."); } byte[] currentHash; { var input = new byte[this.Salt.Length + 4]; Unsafe.Copy(this.Salt, 0, input, 0, this.Salt.Length); Unsafe.Copy(NetworkConverter.GetBytes(_blockIndex), 0, input, this.Salt.Length, 4); _blockIndex++; currentHash = this.Algorithm.ComputeHash(input); } byte[] finalHash = currentHash; for (int i = 2; i <= this.IterationCount; i++) { currentHash = this.Algorithm.ComputeHash(currentHash, 0, currentHash.Length); Unsafe.Xor(finalHash, currentHash, finalHash); } return(finalHash); }
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)); }
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 void Test_NetworkConverter() { Assert.IsTrue(NetworkConverter.ToHexString(new byte[] { 0x00, 0x9e, 0x0f }) == "009e0f", "ToHexString"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.FromHexString("1af4b"), new byte[] { 0x01, 0xaf, 0x4b }), "FromHexString"); Assert.IsTrue(NetworkConverter.ToBoolean(new byte[] { 0x01 }), "ToBoolean"); Assert.IsTrue(NetworkConverter.ToChar(new byte[] { 0x00, 0x41 }) == 'A', "ToChar"); Assert.IsTrue(NetworkConverter.ToInt16(new byte[] { 0x74, 0xab }) == 0x74ab, "ToInt16"); Assert.IsTrue(NetworkConverter.ToUInt16(new byte[] { 0x74, 0xab }) == 0x74ab, "ToUInt16"); Assert.IsTrue(NetworkConverter.ToInt32(new byte[] { 0x74, 0xab, 0x05, 0xc1 }) == 0x74ab05c1, "ToInt32"); Assert.IsTrue(NetworkConverter.ToUInt32(new byte[] { 0x74, 0xab, 0x05, 0xc1 }) == 0x74ab05c1, "ToUInt32"); Assert.IsTrue(NetworkConverter.ToInt64(new byte[] { 0x74, 0xab, 0xa5, 0xbb, 0xf5, 0x39, 0x7b, 0x15 }) == 0x74aba5bbf5397b15, "ToInt64"); Assert.IsTrue(NetworkConverter.ToUInt64(new byte[] { 0x74, 0xab, 0xa5, 0xbb, 0xf5, 0x39, 0x7b, 0x15 }) == 0x74aba5bbf5397b15, "ToUInt64"); Assert.IsTrue(NetworkConverter.ToSingle(new byte[] { 0x4a, 0x8a, 0xd0, 0x64 }) == 4548658.0, "ToSingle"); Assert.IsTrue(NetworkConverter.ToDouble(new byte[] { 0x41, 0xb8, 0xa6, 0xb9, 0x83, 0x27, 0x97, 0xa3 }) == 413579651.15465754, "ToDouble"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes(true), new byte[] { 0x01 }), "GetBytes #bool"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((char)'A'), new byte[] { 0x00, 0x41 }), "GetBytes #char"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((short)0x74ab), new byte[] { 0x74, 0xab }), "GetBytes #short"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((ushort)0x74ab), new byte[] { 0x74, 0xab }), "GetBytes #ushort"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((int)0x74ab05c1), new byte[] { 0x74, 0xab, 0x05, 0xc1 }), "GetBytes #int"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((uint)0x74ab05c1), new byte[] { 0x74, 0xab, 0x05, 0xc1 }), "GetBytes #uint"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((long)0x74aba5bbf5397b15), new byte[] { 0x74, 0xab, 0xa5, 0xbb, 0xf5, 0x39, 0x7b, 0x15 }), "GetBytes #long"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((ulong)0x74aba5bbf5397b15), new byte[] { 0x74, 0xab, 0xa5, 0xbb, 0xf5, 0x39, 0x7b, 0x15 }), "GetBytes #ulong"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((float)4548658.0), new byte[] { 0x4a, 0x8a, 0xd0, 0x64 }), "GetBytes #float"); Assert.IsTrue(CollectionUtilities.Equals(NetworkConverter.GetBytes((double)413579651.15465754), new byte[] { 0x41, 0xb8, 0xa6, 0xb9, 0x83, 0x27, 0x97, 0xa3 }), "GetBytes #double"); Assert.IsTrue(NetworkConverter.ToInt32(new byte[] { 0x00, 0x00, 0x00, 0x00, 0x74, 0xab, 0x05, 0xc1 }, 4) == 0x74ab05c1, "ToInt32"); for (int i = 0; i < 1024; i++) { byte[] buffer = new byte[_random.Next(0, 128)]; _random.NextBytes(buffer); var s = NetworkConverter.ToBase64UrlString(buffer); Assert.IsTrue(CollectionUtilities.Equals(buffer, NetworkConverter.FromBase64UrlString(s))); } for (int i = 0; i < 1024; i++) { byte[] buffer = new byte[_random.Next(0, 128)]; _random.NextBytes(buffer); var s = NetworkConverter.ToHexString(buffer); Assert.IsTrue(CollectionUtilities.Equals(buffer, NetworkConverter.FromHexString(s))); } }
private static ArraySegment <byte> ToBuffer(IEnumerable <byte[]> buffers, BufferManager bufferManager) { int length = buffers.Sum(n => n.Length); byte[] buffer = bufferManager.TakeBuffer(length); using (MemoryStream memoryStream = new MemoryStream(buffer)) { foreach (var buffer2 in buffers) { memoryStream.Write(NetworkConverter.GetBytes((int)buffer2.Length), 0, 4); memoryStream.Write(buffer2, 0, buffer2.Length); } } return(new ArraySegment <byte>(buffer, 0, length)); }
public override void Connect(TimeSpan timeout, Information options) { if (_disposed) { throw new ObjectDisposedException(this.GetType().FullName); } lock (this.ThisLock) { try { Stopwatch 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 static byte[] ComputeHash(IList <ArraySegment <byte> > value) { if (value == null) { throw new ArgumentNullException("value"); } uint x = 0xFFFFFFFF; for (int i = 0; i < value.Count && value[i].Array != null; i++) { for (int j = 0; j < value[i].Count; j++) { x = _table[(x ^ value[i].Array[value[i].Offset + j]) & 0xFF] ^ (x >> 8); } } return(NetworkConverter.GetBytes(x ^ 0xFFFFFFFF)); }
public byte[] GetBytes(byte[] value, int length) { byte[] buffer = new byte[value.Length + 4]; Unsafe.Copy(value, 0, buffer, 0, value.Length); using (MemoryStream stream = new MemoryStream()) { for (int i = 0; stream.Length < length; i++) { Unsafe.Copy(NetworkConverter.GetBytes(i), 0, buffer, value.Length, 4); var hash = _hashAlgorithm.ComputeHash(buffer); stream.Write(hash, 0, hash.Length); stream.Flush(); } return(stream.ToArray()); } }
public static byte[] ComputeHash(IList <ArraySegment <byte> > value) { if (value == null) { throw new ArgumentNullException("value"); } uint x = 0xFFFFFFFF; for (int i = 0; i < value.Count && value[i].Array != null; i++) { fixed(byte *p_buffer = value[i].Array) { var t_buffer = p_buffer + value[i].Offset; x = _compute(x, t_buffer, value[i].Count); } } return(NetworkConverter.GetBytes(x ^ 0xFFFFFFFF)); }
public override Stream Export(BufferManager bufferManager) { using (DeadlockMonitor.Lock(this.ThisLock)) { List <Stream> streams = new List <Stream>(); // CommandMessages foreach (var m in this.CommandMessages) { Stream exportStream = m.Export(bufferManager); BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); bufferStream.WriteByte((byte)SerializeId.CommandMessage); streams.Add(new JoinStream(bufferStream, exportStream)); } return(new JoinStream(streams)); } }
public static bool VerifyFileCertificate(Certificate certificate, string name, Stream stream) { BufferManager bufferManager = BufferManager.Instance; List <Stream> streams = new List <Stream>(); Encoding encoding = new UTF8Encoding(false); // Name { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true)) using (StreamWriter writer = new StreamWriter(wrapperStream, encoding)) { writer.Write(Path.GetFileName(name)); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 0, 4); bufferStream.WriteByte((byte)FileSerializeId.Name); streams.Add(bufferStream); } // Stream { Stream exportStream = new WrapperStream(stream, true); BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); bufferStream.WriteByte((byte)FileSerializeId.Stream); streams.Add(new UniteStream(bufferStream, exportStream)); } using (var uniteStream = new UniteStream(streams)) { return(certificate.Verify(uniteStream)); } }
public override Stream Export(BufferManager bufferManager) { using (DeadlockMonitor.Lock(this.ThisLock)) { List <Stream> streams = new List <Stream>(); Encoding encoding = new UTF8Encoding(false); // Command if (this.Command != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (CacheStream cacheStream = new CacheStream(bufferStream, 1024, true, bufferManager)) using (StreamWriter writer = new StreamWriter(cacheStream, encoding)) { writer.Write(this.Command); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 0, 4); bufferStream.WriteByte((byte)SerializeId.Command); streams.Add(bufferStream); } // Content if (this.Content != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.Write(NetworkConverter.GetBytes((int)this.Content.Count), 0, 4); bufferStream.WriteByte((byte)SerializeId.Content); bufferStream.Write(this.Content.Array, this.Content.Offset, this.Content.Count); streams.Add(bufferStream); } return(new JoinStream(streams)); } }
public static byte[] ComputeHash(Stream inputStream) { if (inputStream == null) { throw new ArgumentNullException("inputStream"); } uint x = 0xFFFFFFFF; byte[] buffer = new byte[1024 * 4]; int length = 0; fixed(byte *p_buffer = buffer) { while ((length = inputStream.Read(buffer, 0, buffer.Length)) > 0) { x = _compute(x, p_buffer, length); } } return(NetworkConverter.GetBytes(x ^ 0xFFFFFFFF)); }
public static byte[] ComputeHash(Stream inputStream) { if (inputStream == null) { throw new ArgumentNullException("inputStream"); } uint x = 0xFFFFFFFF; byte[] buffer = new byte[1024 * 4]; int length = 0; while (0 < (length = inputStream.Read(buffer, 0, buffer.Length))) { for (int i = 0; i < length; i++) { x = _table[(x ^ buffer[i]) & 0xFF] ^ (x >> 8); } } return(NetworkConverter.GetBytes(x ^ 0xFFFFFFFF)); }
public static void Write(Stream stream, byte type, string value) { Encoding encoding = _threadLocalEncoding.Value; byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(encoding.GetMaxByteCount(value.Length)); var length = encoding.GetBytes(value, 0, value.Length, buffer, 0); stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes(length), 0, 4); stream.Write(buffer, 0, length); } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
public override Stream Export(BufferManager bufferManager) { List <Stream> streams = new List <Stream>(); Encoding encoding = new UTF8Encoding(false); // Id if (this.Id != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.Write(NetworkConverter.GetBytes((int)this.Id.Length), 0, 4); bufferStream.WriteByte((byte)SerializeId.Id); bufferStream.Write(this.Id, 0, this.Id.Length); streams.Add(bufferStream); } // Name if (this.Name != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true)) using (StreamWriter writer = new StreamWriter(wrapperStream, encoding)) { writer.Write(this.Name); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 0, 4); bufferStream.WriteByte((byte)SerializeId.Name); streams.Add(bufferStream); } return(new JoinStream(streams)); }
public static byte[] ComputeHash(byte[] buffer, int offset, int length) { if (buffer == null) { throw new ArgumentNullException("buffer"); } else if (offset < 0 || buffer.Length < offset) { throw new ArgumentOutOfRangeException("offset"); } else if (length < 0 || (buffer.Length - offset) < length) { throw new ArgumentOutOfRangeException("length"); } uint x = 0xFFFFFFFF; for (int i = 0; i < length; i++) { x = _table[(x ^ buffer[offset + i]) & 0xFF] ^ (x >> 8); } return(NetworkConverter.GetBytes(x ^ 0xFFFFFFFF)); }
public override Stream Export(BufferManager bufferManager) { using (DeadlockMonitor.Lock(this.ThisLock)) { List <Stream> streams = new List <Stream>(); Encoding encoding = new UTF8Encoding(false); // Name if (this.Name != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (CacheStream cacheStream = new CacheStream(bufferStream, 1024, true, bufferManager)) using (StreamWriter writer = new StreamWriter(cacheStream, encoding)) { writer.Write(this.Name); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 0, 4); bufferStream.WriteByte((byte)SerializeId.Name); streams.Add(bufferStream); } // State if (this.State != 0) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (CacheStream cacheStream = new CacheStream(bufferStream, 1024, true, bufferManager)) using (StreamWriter writer = new StreamWriter(cacheStream, encoding)) { writer.Write(this.State.ToString()); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 0, 4); bufferStream.WriteByte((byte)SerializeId.State); streams.Add(bufferStream); } // Managers foreach (var m in this.Managers) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.Write(NetworkConverter.GetBytes((int)m.Length), 0, 4); bufferStream.WriteByte((byte)SerializeId.Manager); bufferStream.Write(m, 0, m.Length); streams.Add(bufferStream); } // Members foreach (var m in this.Members) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.Write(NetworkConverter.GetBytes((int)m.Length), 0, 4); bufferStream.WriteByte((byte)SerializeId.Member); bufferStream.Write(m, 0, m.Length); streams.Add(bufferStream); } return(new AddStream(streams)); } }
protected override Stream Export(BufferManager bufferManager, int count) { //if (count > 256) throw new ArgumentException(); lock (this.ThisLock) { List <Stream> streams = new List <Stream>(); Encoding encoding = new UTF8Encoding(false); // Name if (this.Name != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.WriteByte((byte)SerializeId.Name); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true)) using (StreamWriter writer = new StreamWriter(wrapperStream, encoding)) { writer.Write(this.Name); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 1, 4); streams.Add(bufferStream); } // CreationTime if (this.CreationTime != DateTime.MinValue) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.WriteByte((byte)SerializeId.CreationTime); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true)) using (StreamWriter writer = new StreamWriter(wrapperStream, encoding)) { writer.Write(this.CreationTime.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ", System.Globalization.DateTimeFormatInfo.InvariantInfo)); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 1, 4); streams.Add(bufferStream); } // Comment if (this.Comment != null) { BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.WriteByte((byte)SerializeId.Comment); bufferStream.SetLength(5); bufferStream.Seek(5, SeekOrigin.Begin); using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true)) using (StreamWriter writer = new StreamWriter(wrapperStream, encoding)) { writer.Write(this.Comment); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 5), 1, 4); streams.Add(bufferStream); } // Seeds foreach (var s in this.Seeds) { Stream exportStream = s.Export(bufferManager); BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.WriteByte((byte)SerializeId.Seed); bufferStream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); streams.Add(new UniteStream(bufferStream, exportStream)); } // D_Boxes foreach (var b in this.D_Boxes) { Stream exportStream = b.Export(bufferManager, count + 1); BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.WriteByte((byte)SerializeId.D_Box); bufferStream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); streams.Add(new UniteStream(bufferStream, exportStream)); } // Certificate if (this.Certificate != null) { Stream exportStream = this.Certificate.Export(bufferManager); BufferStream bufferStream = new BufferStream(bufferManager); bufferStream.WriteByte((byte)SerializeId.Certificate); bufferStream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); streams.Add(new UniteStream(bufferStream, exportStream)); } return(new UniteStream(streams)); } }
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("stream"); } if (stream.Length == 0) { throw new ArgumentOutOfRangeException("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); byte[] sendBuffer = null; try { sendBuffer = _bufferManager.TakeBuffer(1024 * 4); using (Stream dataStream = new UniteStream(headerStream, new WrapperStream(targetStream, true))) { for (; ;) { int sendLength = (int)Math.Min(dataStream.Length - dataStream.Position, sendBuffer.Length); if (sendLength == 0) { break; } if (_bandwidthLimit != null) { sendLength = _bandwidthLimit.GetOutBandwidth(this, sendLength); if (sendLength < 0) { throw new ConnectionException(); } } dataStream.Read(sendBuffer, 0, sendLength); var time = BaseConnection.CheckTimeout(_sendStopwatch.Elapsed, timeout); time = (time < _sendTimeSpan) ? time : _sendTimeSpan; _cap.Send(sendBuffer, 0, sendLength, time); _aliveStopwatch.Restart(); _sentByteCount.Add(sendLength); } } } finally { _bufferManager.ReturnBuffer(sendBuffer); } _aliveTimer.Change(1000 * 30); } catch (ConnectionException e) { throw e; } catch (Exception e) { throw new ConnectionException(e.Message, e); } } } }
public static void Write(Stream stream, byte type, byte[] value) { stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes((int)value.Length), 0, 4); stream.Write(value, 0, value.Length); }
public static void Write(Stream stream, byte type, long value) { stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes((int)8), 0, 4); stream.Write(NetworkConverter.GetBytes(value), 0, 8); }
public override string ToString() { return(new IPAddress(NetworkConverter.GetBytes(this.Value)).ToString()); }
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 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); } }