public static int Compare <T>(IList <T> source, int sourceIndex, IList <T> destination, int destinationIndex, int length) { if (source is byte[] x && destination is byte[] y) { if ((source.Count - sourceIndex) < 0) { throw new ArgumentOutOfRangeException(nameof(sourceIndex)); } if ((destination.Count - destinationIndex) < 0) { throw new ArgumentOutOfRangeException(nameof(destinationIndex)); } if (length > (source.Count - sourceIndex)) { throw new ArgumentOutOfRangeException(nameof(length)); } if (length > (destination.Count - destinationIndex)) { throw new ArgumentOutOfRangeException(nameof(length)); } return(BytesOperations.Compare(x.AsSpan(sourceIndex, length), y.AsSpan(destinationIndex, length))); } var compare = Comparer <T> .Default; return(CollectionHelper.Compare(source, sourceIndex, destination, destinationIndex, length, compare)); }
public static bool Equals <T>(IList <T> source, int sourceIndex, IList <T> destination, int destinationIndex, int length) { if (source is byte[] x && destination is byte[] y) { if ((x.Length - sourceIndex) < 0) { throw new ArgumentOutOfRangeException(nameof(sourceIndex)); } if ((y.Length - destinationIndex) < 0) { throw new ArgumentOutOfRangeException(nameof(destinationIndex)); } if (length > (x.Length - sourceIndex)) { throw new ArgumentOutOfRangeException(nameof(length)); } if (length > (y.Length - destinationIndex)) { throw new ArgumentOutOfRangeException(nameof(length)); } return(BytesOperations.Equals(x.AsSpan(sourceIndex, length), y.AsSpan(destinationIndex, length))); } var equalityComparer = EqualityComparer <T> .Default; return(Equals(source, sourceIndex, destination, destinationIndex, length, equalityComparer)); }
public async Task Encode(ReadOnlyMemory<byte>[] sources, int[] index, Memory<byte>[] repairs, int packetLength, int concurrency = 1, CancellationToken token = default) { if (sources == null) throw new ArgumentNullException(nameof(sources)); if (repairs == null) throw new ArgumentNullException(nameof(repairs)); if (index == null) throw new ArgumentNullException(nameof(index)); await Enumerable.Range(0, repairs.Length).ForEachAsync(row => { return Task.Run(() => { token.ThrowIfCancellationRequested(); // *remember* indices start at 0, k starts at 1. if (index[row] < _k) { // < k, systematic so direct copy. BytesOperations.Copy(sources[index[row]].Span, repairs[row].Span, packetLength); } else { // index[row] >= k && index[row] < n int pos = index[row] * _k; BytesOperations.Zero(repairs[row].Span.Slice(packetLength)); for (int col = 0; col < _k; col++) { token.ThrowIfCancellationRequested(); ReadSolomonMath.AddMul(sources[col].Span, repairs[row].Span, _encMatrix[pos + col], packetLength); } } }); }, concurrency, token, false); }
public static byte[] Encode(IEnumerable <ReadOnlyMemory <byte> > collection) { var pipe = new Pipe(); { foreach (var value in collection) { Varint.SetUInt64((uint)value.Length, pipe.Writer); BytesOperations.Copy(value.Span, pipe.Writer.GetSpan(value.Length), value.Length); pipe.Writer.Advance(value.Length); } pipe.Writer.Complete(); } byte[] result; { pipe.Reader.TryRead(out var readResult); result = readResult.Buffer.ToArray(); pipe.Reader.Complete(); } return(result); }
public static int Compare <T>(IList <T> source, int sourceIndex, IList <T> destination, int destinationIndex, int length) { { var x = source as byte[]; var y = destination as byte[]; if (x != null && y != null) { if (0 > (source.Count - sourceIndex)) { throw new ArgumentOutOfRangeException(nameof(sourceIndex)); } if (0 > (destination.Count - destinationIndex)) { throw new ArgumentOutOfRangeException(nameof(destinationIndex)); } if (length > (source.Count - sourceIndex)) { throw new ArgumentOutOfRangeException(nameof(length)); } if (length > (destination.Count - destinationIndex)) { throw new ArgumentOutOfRangeException(nameof(length)); } return(BytesOperations.Compare(x.AsSpan(sourceIndex, length), y.AsSpan(destinationIndex, length))); } } { var compare = Comparer <T> .Default; return(CollectionHelper.Compare(source, sourceIndex, destination, destinationIndex, length, compare)); } }
public static IEnumerable <KademliaElement <T> > Search <T>(ReadOnlySpan <byte> baseId, ReadOnlySpan <byte> targetId, IEnumerable <KademliaElement <T> > elements, int count) where T : notnull { if (elements is null) { throw new ArgumentNullException(nameof(elements)); } if (count == 0) { Array.Empty <KademliaElement <T> >(); } var targetList = new List <SortEntry <T> >(); if (baseId != null) { var xor = new byte[targetId.Length]; BytesOperations.Xor(targetId, baseId, xor); targetList.Add(new SortEntry <T>(null, xor)); } foreach (var node in elements) { var xor = new byte[targetId.Length]; BytesOperations.Xor(targetId, node.Id.Span, xor); targetList.Add(new SortEntry <T>(node, xor)); } for (int i = 1; i < targetList.Count; i++) { var temp = targetList[i]; int left = 0; int right = Math.Min(i, count); while (left < right) { int middle = (left + right) / 2; if (BytesOperations.Compare(targetList[middle].Xor, temp.Xor) <= 0) { left = middle + 1; } else { right = middle; } } for (int j = Math.Min(i, count); left < j; --j) { targetList[j] = targetList[j - 1]; } targetList[left] = temp; } return(targetList.Take(count).TakeWhile(n => n.Node.HasValue).Select(n => n.Node !.Value).ToList()); }
public override int Read(byte[] buffer, int offset, int count) { if (_disposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (offset < 0 || buffer.Length < offset) { throw new ArgumentOutOfRangeException(nameof(offset)); } if (count < 0 || (buffer.Length - offset) < count) { throw new ArgumentOutOfRangeException(nameof(count)); } if (count == 0) { return(0); } if (_blockIsUpdated) { this.Flush(); } count = (int)Math.Min(count, _length - _position); int readSumLength = 0; while (count > 0) { long p = (_position / SectorSize) * SectorSize; if (_blockPosition != p) { _blockPosition = p; _blockOffset = 0; _stream.Seek(_blockPosition, SeekOrigin.Begin); int readLength = _stream.Read(_blockBuffer, 0, SectorSize); readLength = (int)Math.Min(_length - _blockPosition, readLength); _blockCount = readLength; } int blockReadPosition = (int)(_position - p); int length = Math.Min(SectorSize - blockReadPosition, count); BytesOperations.Copy(_blockBuffer.AsSpan(blockReadPosition), buffer.AsSpan(offset), length); offset += length; count -= length; _position += length; readSumLength += length; } return(readSumLength); }
private static Stream RemoveHash(Stream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } int type = (int)Varint.GetUInt64(stream); if (type == (int)ConvertHashAlgorithm.Sha256) { var value = new byte[32]; stream.Read(value, 0, value.Length); var dataStream = new RangeStream(stream, true); if (!BytesOperations.SequenceEqual(value, Sha256.Compute(new WrapperStream(dataStream)))) { throw new ArgumentException("Hash"); } dataStream.Seek(0, SeekOrigin.Begin); return(dataStream); } else { throw new NotSupportedException(); } }
public void WriteAndReadTest() { var random = new Random(0); var cases = new int[] { 0, 1, 10, 100, random.Next(0, 1024 * 64), random.Next(0, 1024 * 64), random.Next(0, 1024 * 64), random.Next(0, 1024 * 64), }; foreach (var length in cases) { var inBody = new byte[length]; random.NextBytes(inBody); Assert.True(TryEncode(inBody, out var message)); Assert.True(TryDecode(message !, out var outBody)); Assert.True(BytesOperations.Equals(inBody.AsSpan(), outBody.AsSpan())); } }
public static uint Verify_Simple_Sha2_256(ReadOnlySpan <byte> key, ReadOnlySpan <byte> value) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (key.Length != 32) { throw new ArgumentOutOfRangeException(nameof(key)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } if (value.Length != 32) { throw new ArgumentOutOfRangeException(nameof(value)); } Span <byte> buffer = stackalloc byte[64]; byte[] hash; { BytesOperations.Copy(key, buffer, key.Length); BytesOperations.Copy(value, buffer[key.Length..], value.Length);
public void CompareTest() { Assert.True(BytesOperations.Compare(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 3, 4 }) == 0); Assert.True(BytesOperations.Compare(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 3, 5 }) < 0); Assert.True(BytesOperations.Compare(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 3, 3 }) > 0); Assert.True(BytesOperations.Compare(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 5 }) > 0); Assert.True(BytesOperations.Compare(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 0, 0, 0 }) < 0); }
public static bool IsGlobalIpAddress(IPAddress ipAddress) { if (ipAddress.AddressFamily == AddressFamily.InterNetwork) { if (ipAddress == IPAddress.Any || ipAddress == IPAddress.Loopback || ipAddress == IPAddress.Broadcast) { return(false); } var bytes = ipAddress.GetAddressBytes(); // Loopback Address if (BytesOperations.Compare(bytes, _ipAddress_127_0_0_0.Span) >= 0 && BytesOperations.Compare(bytes, _ipAddress_127_255_255_255.Span) <= 0) { return(false); } // Class A if (BytesOperations.Compare(bytes, _ipAddress_10_0_0_0.Span) >= 0 && BytesOperations.Compare(bytes, _ipAddress_10_255_255_255.Span) <= 0) { return(false); } // Class B if (BytesOperations.Compare(bytes, _ipAddress_172_16_0_0.Span) >= 0 && BytesOperations.Compare(bytes, _ipAddress_172_31_255_255.Span) <= 0) { return(false); } // Class C if (BytesOperations.Compare(bytes, _ipAddress_192_168_0_0.Span) >= 0 && BytesOperations.Compare(bytes, _ipAddress_192_168_255_255.Span) <= 0) { return(false); } // Link Local Address if (BytesOperations.Compare(bytes, _ipAddress_169_254_0_0.Span) >= 0 && BytesOperations.Compare(bytes, _ipAddress_169_254_255_255.Span) <= 0) { return(false); } } if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6) { if (ipAddress == IPAddress.IPv6Any || ipAddress == IPAddress.IPv6Loopback || ipAddress == IPAddress.IPv6None || ipAddress.IsIPv4MappedToIPv6 || ipAddress.IsIPv6LinkLocal || ipAddress.IsIPv6Multicast || ipAddress.IsIPv6SiteLocal || ipAddress.IsIPv6Teredo) { return(false); } } return(true); }
public void EqualsTest() { var random = new Random(); Assert.True(BytesOperations.SequenceEqual(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 3, 4 })); Assert.False(BytesOperations.SequenceEqual(new byte[] { 0, 1, 2, 3, 4 }, new byte[] { 0, 1, 2, 3, 4, 5 })); Assert.True(BytesOperations.SequenceEqual(new byte[] { 0, 1, 2, 3, 4 }.AsSpan().Slice(2), new byte[] { 0, 1, 2, 3, 4 }.AsSpan().Slice(2))); Assert.False(BytesOperations.SequenceEqual(new byte[] { 0, 1, 2, 3, 4 }.AsSpan().Slice(1), new byte[] { 0, 1, 2, 3, 4 }.AsSpan().Slice(2))); }
public void RandomSendAndReceiveTest() { var random = new Random(); var caseList = new List <int>(); caseList.AddRange(Enumerable.Range(1, 32)); caseList.AddRange(new int[] { 100, 1000, 10000, 1024 * 1024, 1024 * 1024 * 32 }); var(socket1, socket2) = SocketHelpers.GetSockets(); var options = new OmniNonblockingConnectionOptions() { MaxReceiveByteCount = 1024 * 1024 * 256, MaxSendByteCount = 1024 * 1024 * 256, BufferPool = BufferPool.Shared, }; using (var connection1 = new OmniNonblockingConnection(new SocketCap(socket1, false), options)) using (var connection2 = new OmniNonblockingConnection(new SocketCap(socket2, false), options)) { foreach (var bufferSize in caseList) { var buffer1 = new byte[bufferSize]; var buffer2 = new byte[bufferSize]; random.NextBytes(buffer1); var valueTask1 = connection1.EnqueueAsync((bufferWriter) => { bufferWriter.Write(buffer1); }); var valueTask2 = connection2.DequeueAsync((sequence) => { sequence.CopyTo(buffer2); }); var stopwatch = Stopwatch.StartNew(); while (!valueTask1.IsCompleted || !valueTask2.IsCompleted) { if (stopwatch.Elapsed.TotalSeconds > 60) { throw new TimeoutException("SendAndReceive"); } Thread.Sleep(100); connection1.DoEvents(); connection2.DoEvents(); } Assert.True(BytesOperations.SequenceEqual(buffer1, buffer2)); } } }
private static bool IsGlobalIpAddress(IPAddress ipAddress) { if (ipAddress.AddressFamily == AddressFamily.InterNetwork) { if (ipAddress == IPAddress.Any || ipAddress == IPAddress.Loopback || ipAddress == IPAddress.Broadcast) { return(false); } if (BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("10.0.0.0").GetAddressBytes()) >= 0 && BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("10.255.255.255").GetAddressBytes()) <= 0) { return(false); } if (BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("172.16.0.0").GetAddressBytes()) >= 0 && BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("172.31.255.255").GetAddressBytes()) <= 0) { return(false); } if (BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("127.0.0.0").GetAddressBytes()) >= 0 && BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("127.255.255.255").GetAddressBytes()) <= 0) { return(false); } if (BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("192.168.0.0").GetAddressBytes()) >= 0 && BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("192.168.255.255").GetAddressBytes()) <= 0) { return(false); } if (BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("169.254.0.0").GetAddressBytes()) >= 0 && BytesOperations.Compare(ipAddress.GetAddressBytes(), IPAddress.Parse("169.254.255.255").GetAddressBytes()) <= 0) { return(false); } } if (ipAddress.AddressFamily == AddressFamily.InterNetworkV6) { if (ipAddress == IPAddress.IPv6Any || ipAddress == IPAddress.IPv6Loopback || ipAddress == IPAddress.IPv6None) { return(false); } if (ipAddress.ToString().StartsWith("fe80:")) { return(false); } if (ipAddress.ToString().StartsWith("2001:")) { return(false); } if (ipAddress.ToString().StartsWith("2002:")) { return(false); } } return(true); }
public static bool Equals <T>(IList <T> source, IList <T> destination) { if (source is byte[] x && destination is byte[] y) { return(BytesOperations.Equals(x.AsSpan(), y.AsSpan())); } var equalityComparer = EqualityComparer <T> .Default; return(CollectionHelper.Equals(source, destination, equalityComparer)); }
public static int Compare <T>(IList <T> source, IList <T> destination) { if (source is byte[] x && destination is byte[] y) { return(BytesOperations.Compare(x, y)); } var compare = Comparer <T> .Default; return(CollectionHelper.Compare(source, destination, compare)); }
public static byte[] CreateDecodeMatrix(byte[] encMatrix, int[] index, int k, int n) { var matrix = CreateGFMatrix(k, k); for (int i = 0, pos = 0; i < k; i++, pos += k) { BytesOperations.Copy(encMatrix.AsSpan(index[i] * k), matrix.AsSpan(pos), k); } InvertMatrix(matrix, k); return matrix; }
public override void Write(byte[] buffer, int offset, int count) { if (_disposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (offset < 0 || buffer.Length < offset) { throw new ArgumentOutOfRangeException(nameof(offset)); } if (count < 0 || (buffer.Length - offset) < count) { throw new ArgumentOutOfRangeException(nameof(count)); } if (count == 0) { return; } while (count > 0) { long p = (_position / SectorSize) * SectorSize; if (_blockPosition != p) { this.Flush(); } _stream.Seek(p, SeekOrigin.Begin); int blockWritePosition = (int)(_position - p); int length = Math.Min(SectorSize - blockWritePosition, count); _blockPosition = p; BytesOperations.Copy(buffer.AsSpan(offset), _blockBuffer.AsSpan(blockWritePosition), length); if (_blockCount == 0) { _blockOffset = blockWritePosition; } _blockCount = (length + blockWritePosition) - _blockOffset; _blockIsUpdated = true; offset += length; count -= length; _position += length; } }
public override void Write(ReadOnlySpan <byte> buffer) { if (_disposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (buffer.Length == 0) { return; } this.Search(); int offset = 0; int count = buffer.Length; int writeSumLength = 0; while (count > 0) { if (_currentBufferIndex >= _buffers.Count) { var tempBuffer = _bytesPool.Array.Rent(_bufferSize); if (_bufferSize < 1024 * 32) { _bufferSize *= 2; } _buffers.Add(tempBuffer); } int length = Math.Min(_buffers[_currentBufferIndex].Length - _currentBufferPosition, count); BytesOperations.Copy(buffer.Slice(offset), _buffers[_currentBufferIndex].AsSpan(_currentBufferPosition), length); _currentBufferPosition += length; offset += length; count -= length; writeSumLength += length; if (_currentBufferPosition == _buffers[_currentBufferIndex].Length) { _currentBufferIndex++; _currentBufferPosition = 0; } } _position += writeSumLength; _length = Math.Max(_length, _position); }
public static byte[] CreateEncodeMatrix(int k, int n) { if (k > _gfSize + 1 || n > _gfSize + 1 || k > n) { throw new ArgumentException("Invalid parameters n=" + n + ",k=" + k + ",gfSize=" + _gfSize); } var encMatrix = CreateGFMatrix(n, k); /* * The encoding matrix is computed starting with a Vandermonde matrix, * and then transforming it into a systematic matrix. * * fill the matrix with powers of field elements, starting from 0. * The first row is special, cannot be computed with exp. table. */ var tmpMatrix = CreateGFMatrix(n, k); tmpMatrix[0] = (byte)1; // first row should be 0's, fill in the rest. for (int pos = k, row = 0; row < n - 1; row++, pos += k) { for (int col = 0; col < k; col++) { tmpMatrix[pos + col] = _gf_exp[Modnn(row * col)]; } } /* * quick code to build systematic matrix: invert the top * k*k vandermonde matrix, multiply right the bottom n-k rows * by the inverse, and construct the identity matrix at the top. */ // much faster than invertMatrix InvertVandermonde(tmpMatrix, k); MatMul(tmpMatrix, k * k, tmpMatrix, 0, encMatrix, k * k, n - k, k, k); /* * the upper matrix is I so do not bother with a slow multiply */ BytesOperations.Zero(encMatrix.AsSpan(0, k * k)); for (int i = 0, col = 0; col < k; col++, i += k + 1) { encMatrix[i] = (byte)1; } return encMatrix; }
public static uint Verify_Simple_Sha2_256(ReadOnlySpan <byte> key, ReadOnlySpan <byte> value) { if (key == null) { throw new ArgumentNullException(nameof(key)); } if (key.Length != 32) { throw new ArgumentOutOfRangeException(nameof(key)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } if (value.Length != 32) { throw new ArgumentOutOfRangeException(nameof(value)); } Span <byte> buffer = stackalloc byte[64]; byte[] hash; { BytesOperations.Copy(key, buffer, key.Length); BytesOperations.Copy(value, buffer.Slice(key.Length), value.Length); hash = Sha2_256.ComputeHash(buffer); } uint count = 0; for (int i = 0; i < 32; i++) { for (int j = 0; j < 8; j++) { if (((hash[i] << j) & 0x80) == 0) { count++; } else { goto End; } } } End: return(count); }
public static bool TryComputeHash(ReadOnlySequence <byte> sequence, ReadOnlySpan <byte> key, Span <byte> destination) { if (destination.Length < 32) { throw new ArgumentOutOfRangeException(nameof(destination)); } Span <byte> extendedKey = stackalloc byte[_blockLength]; if (key.Length > _blockLength) { Sha2_256.TryComputeHash(key, extendedKey); } else { BytesOperations.Copy(key, extendedKey, Math.Min(key.Length, extendedKey.Length)); } Span <byte> ixor = stackalloc byte[_blockLength]; BytesOperations.Xor(_ipad, extendedKey, ixor); Span <byte> oxor = stackalloc byte[_blockLength]; BytesOperations.Xor(_opad, extendedKey, oxor); Span <byte> ihash = stackalloc byte[32]; using (var incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256)) { incrementalHash.AppendData(ixor); foreach (var segment in sequence) { incrementalHash.AppendData(segment.Span); } incrementalHash.TryGetHashAndReset(ihash, out _); } using (var incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256)) { incrementalHash.AppendData(oxor); incrementalHash.AppendData(ihash); return(incrementalHash.TryGetHashAndReset(destination, out _)); } }
public async Task Decode(Memory<byte>[] packets, int[] index, int packetLength, int concurrency = 1, CancellationToken token = default) { if (packets == null) throw new ArgumentNullException(nameof(packets)); if (index == null) throw new ArgumentNullException(nameof(index)); Shuffle(packets, index, _k); var decMatrix = ReadSolomonMath.CreateDecodeMatrix(_encMatrix, index, _k, _n); // do the actual decoding.. var tempPackets = new byte[_k][]; await Enumerable.Range(0, _k).ForEachAsync(row => { return Task.Run(() => { token.ThrowIfCancellationRequested(); if (index[row] >= _k) { tempPackets[row] = _bufferPool.GetArrayPool().Rent(packetLength); BytesOperations.Zero(tempPackets[row].AsSpan(0, packetLength)); for (int col = 0; col < _k; col++) { token.ThrowIfCancellationRequested(); ReadSolomonMath.AddMul(packets[col].Span, tempPackets[row], decMatrix[row * _k + col], packetLength); } } }); }, concurrency, token, false); token.ThrowIfCancellationRequested(); // move pkts to their final destination for (int row = 0; row < _k; row++) { if (index[row] >= _k) { // only copy those actually decoded. BytesOperations.Copy(tempPackets[row], packets[row].Span, packetLength); index[row] = row; _bufferPool.GetArrayPool().Return(tempPackets[row]); } } }
public void RandomReadAndWriteTest(int seed, int loopCount, int bufferLength) { var random = new Random(seed); var bytesPool = BytesPool.Shared; using var buffer1 = bytesPool.Memory.Rent(bufferLength); using var buffer2 = bytesPool.Memory.Rent(bufferLength); using var recyclableMemoryStream = new RecyclableMemoryStream(BytesPool.Shared); using var memoryStream = new MemoryStream(); // Write foreach (var i in Enumerable.Range(0, loopCount)) { random.NextBytes(buffer1.Memory.Span); var s = buffer1.Memory.Span.Slice(0, random.Next(0, buffer1.Memory.Length)); recyclableMemoryStream.Write(s); memoryStream.Write(s); } Assert.Equal(recyclableMemoryStream.Position, memoryStream.Position); Assert.Equal(recyclableMemoryStream.Length, memoryStream.Length); recyclableMemoryStream.Seek(0, SeekOrigin.Begin); memoryStream.Seek(0, SeekOrigin.Begin); // Read while (memoryStream.Position < memoryStream.Length) { var length = random.Next(0, buffer1.Memory.Length); var s1 = buffer1.Memory.Span.Slice(0, length); var s2 = buffer1.Memory.Span.Slice(0, length); recyclableMemoryStream.Read(s1); memoryStream.Read(s2); Assert.Equal(recyclableMemoryStream.Position, memoryStream.Position); Assert.Equal(recyclableMemoryStream.Length, memoryStream.Length); Assert.True(BytesOperations.Equals(s1, s2)); } using var m1 = recyclableMemoryStream.ToMemoryOwner(); var m2 = memoryStream.ToArray(); Assert.True(BytesOperations.Equals(m1.Memory.Span, m2)); }
public void SetLength(ulong length) { ulong byteCount = MathHelper.Roundup(length, 8); ulong sectorCount = MathHelper.Roundup(byteCount, SectorSize); _bufferList = new byte[sectorCount][]; for (int i = 0; i < _bufferList.Length; i++) { var buffer = _bufferPool.GetArrayPool().Rent((int)SectorSize); BytesOperations.Zero(buffer); _bufferList[i] = buffer; } _length = length; }
public static bool Equals <T>(IList <T> source, IList <T> destination) { { var x = source as byte[]; var y = destination as byte[]; if (x != null && y != null) { return(BytesOperations.SequenceEqual(x.AsSpan(), y.AsSpan())); } } { var equalityComparer = EqualityComparer <T> .Default; return(CollectionHelper.Equals(source, destination, equalityComparer)); } }
public static int Compare <T>(IList <T> source, IList <T> destination) { { var x = source as byte[]; var y = destination as byte[]; if (x != null && y != null) { return(BytesOperations.Compare(x, y)); } } { var compare = Comparer <T> .Default; return(CollectionHelper.Compare(source, destination, compare)); } }
public static bool TryComputeHash(ReadOnlySpan <byte> password, ReadOnlySpan <byte> salt, int iterationCount, Span <byte> destination) { const int hashLength = 32; int keyLength = destination.Length / hashLength; if (destination.Length % hashLength != 0) { keyLength++; } var extendedkeyLength = (salt.Length + 4); Span <byte> extendedkey = extendedkeyLength <= 128 ? stackalloc byte[extendedkeyLength] : new byte[extendedkeyLength]; BytesOperations.Copy(salt, extendedkey, salt.Length); Span <byte> f = stackalloc byte[hashLength]; Span <byte> u = stackalloc byte[hashLength]; for (int i = 0; i < keyLength; i++) { extendedkey[salt.Length] = (byte)(((i + 1) >> 24) & 0xFF); extendedkey[salt.Length + 1] = (byte)(((i + 1) >> 16) & 0xFF); extendedkey[salt.Length + 2] = (byte)(((i + 1) >> 8) & 0xFF); extendedkey[salt.Length + 3] = (byte)(((i + 1)) & 0xFF); Hmac_Sha2_256.TryComputeHash(extendedkey, password, u); BytesOperations.Zero(extendedkey.Slice(salt.Length, 4)); BytesOperations.Copy(u, f, hashLength); for (int j = 1; j < iterationCount; j++) { Hmac_Sha2_256.TryComputeHash(u, password, u); BytesOperations.Xor(f, u, f); } int position = i * hashLength; int remain = Math.Min(hashLength, destination.Length - position); BytesOperations.Copy(f, destination.Slice(position), remain); } return(true); }
public bool Equals(NodeInfo <T> other) { if ((this.Id == null) != (other.Id == null) || !this.Value.Equals(other.Value)) { return(false); } if (this.Id != null && other.Id != null) { if (!BytesOperations.SequenceEqual(this.Id, other.Id)) { return(false); } } return(true); }