/// <summary>
///
/// </summary>
/// <param name="buffer"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public override async ValueTask <int> WriteAsync(ReadOnlyMemory <byte> buffer, CancellationToken cancellationToken = default)
{
UpdateLastActive();
if (_closed)
{
return(-1);
}
int written = -1;
try
{
var arr = ArrayPool <byte> .Shared.Rent(buffer.Length);
buffer.CopyTo(arr.AsMemory());
written = await _sock.SendToAsync(new ArraySegment <byte>(arr), SocketFlags.None, _remote);//TODO waiting for a overload.
ArrayPool <byte> .Shared.Return(arr, true);
}
catch (SocketException ex)
{
_logger?.LogError(ex, "UdpClient2 SendToAsync error.");
return(-1);
}
return(written);
}
public override ReadOnlyMemory <byte> Encrypt(ReadOnlyMemory <byte> data, KerberosKey key, KeyUsage usage)
{
var k1 = key.GetKey(this);
var salt = GetSalt((int)usage);
var k2 = HMACMD5(k1, salt);
var confounder = GenerateRandomBytes(ConfounderSize);
var plaintextBuffer = new byte[data.Length + confounder.Length];
var plaintext = new Memory <byte>(plaintextBuffer);
confounder.CopyTo(plaintext);
data.CopyTo(plaintext.Slice(confounder.Length));
var checksum = HMACMD5(k2, plaintextBuffer);
var k3 = HMACMD5(k2, checksum);
var ciphertext = new Memory <byte>(new byte[plaintext.Length + checksum.Length]);
RC4.Transform(k3, plaintext.Span, ciphertext.Span.Slice(checksum.Length));
checksum.CopyTo(ciphertext.Span);
return(ciphertext);
}
public void CopyMemory()
{
var sourceMemory = new ReadOnlyMemory <byte>(_data);
var destinationMemory = _destination.AsMemory();
sourceMemory.CopyTo(destinationMemory);
}
//private SymbolParser _symbolParser;
/// <summary>
/// Provides the functionality to map a DLL from memory into a process
/// </summary>
public void Assign(System.Diagnostics.Process process, ReadOnlyMemory <byte> dllBytes)
{
// Validate the arguments
if (process is null || process.HasExited)
{
throw new ArgumentException("The process provided was invalid");
}
if (dllBytes.IsEmpty)
{
throw new ArgumentException("The DLL bytes provided were invalid");
}
EnterDebugMode();
_dllBytes = new Memory <byte>(new byte[dllBytes.Length]);
dllBytes.CopyTo(_dllBytes);
_peImage = new PeImage(dllBytes);
_processManager = new ProcessAccessor(process);
//_symbolParser = new SymbolParser(RetrieveNtdllFilePath(process), "RtlInsertInvertedFunctionTable", "RtlRemoveInvertedFunctionTable");
}
private static int[] SuffixArrayByDoubling(ReadOnlyMemory <int> source)
{
var n = source.Length;
var sa = Enumerable.Range(0, n).ToArray();
var s1 = new int[n];
var s2 = new int[n];
source.CopyTo(s1.AsMemory());
for (var k = 1; k < n; k *= 2)
{
int Compare(int x, int y)
{
if (s1[x] != s1[y])
{
return(s1[x].CompareTo(s1[y]));
}
var rx = x + k < n ? s1[x + k] : -1;
var ry = y + k < n ? s1[y + k] : -1;
return(rx.CompareTo(ry));
}
Array.Sort(sa, Compare);
s2[sa[0]] = 0;
for (var i = 1; i < n; i++)
{
s2[sa[i]] = s2[sa[i - 1]] + (Compare(sa[i - 1], sa[i]) < 0 ? 1 : 0);
}
(s2, s1) = (s1, s2);
}
return(sa);
}
public override async Task <T> SendMessage <T>(string domain, ReadOnlyMemory <byte> req, CancellationToken cancellation = default)
{
var kdc = LocateKdc(domain);
var messageBytes = new Memory <byte>(new byte[req.Length + 4]);
Endian.ConvertToBigEndian(req.Length, messageBytes.Slice(0, 4));
req.CopyTo(messageBytes.Slice(4, req.Length));
var message = new KdcProxyMessage
{
TargetDomain = domain,
KerbMessage = messageBytes,
DcLocatorHint = Hint
};
var response = await Client.PostAsync(kdc, new BinaryContent(message.Encode()));
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsByteArrayAsync();
var kdcResponse = KdcProxyMessage.Decode(responseBody);
return(Decode <T>(kdcResponse.KerbMessage.Slice(4)));
}
public ValueTask WriteAsync(Socket socket, IReadOnlyList <ReadOnlyMemory <byte> > buffers, CancellationToken cancellationToken = default)
{
int bufferCount = buffers.Count;
_gatheredSegments ??= new List <ArraySegment <byte> >(buffers.Count);
for (int i = 0; i < bufferCount; ++i)
{
ReadOnlyMemory <byte> buffer = buffers[i];
if (!MemoryMarshal.TryGetArray(buffer, out ArraySegment <byte> segment))
{
_pooledArrays ??= new List <byte[]>();
byte[] array = ArrayPool <byte> .Shared.Rent(buffer.Length);
_pooledArrays.Add(array);
buffer.CopyTo(array);
segment = new ArraySegment <byte>(array, 0, buffer.Length);
}
_gatheredSegments.Add(segment);
}
BufferList = _gatheredSegments;
Reset();
if (!socket.SendAsync(this))
{
OnCompleted();
}
return(Task);
}
// don't work with CFLIST atm
public static string CalculateKey(byte[] type, byte[] appnonce, byte[] netid, ReadOnlyMemory <byte> devnonce, byte[] appKey)
{
Aes aes = new AesManaged
{
Key = appKey,
Mode = CipherMode.ECB,
Padding = PaddingMode.None
};
var pt = new byte[type.Length + appnonce.Length + netid.Length + devnonce.Length + 7];
var destIndex = 0;
Array.Copy(type, 0, pt, destIndex, type.Length);
destIndex += type.Length;
Array.Copy(appnonce, 0, pt, destIndex, appnonce.Length);
destIndex += appnonce.Length;
Array.Copy(netid, 0, pt, destIndex, netid.Length);
destIndex += netid.Length;
devnonce.CopyTo(new Memory <byte>(pt, destIndex, devnonce.Length));
aes.IV = new byte[16];
ICryptoTransform cipher;
cipher = aes.CreateEncryptor();
var key = cipher.TransformFinalBlock(pt, 0, pt.Length);
return(ConversionHelper.ByteArrayToString(key));
}
public override T Decode <T>(ReadOnlyMemory <byte> buffer, Flags flags, OpCode opcode)
{
if (typeof(T) == typeof(byte[]))
{
object value = DecodeBinary(buffer.Span);
return((T)value);
}
if (typeof(T) == typeof(IMemoryOwner <byte>))
{
// Note: it is important for the consumer to dispose of the returned IMemoryOwner<byte>, in keeping
// with IMemoryOwner<T> conventions. Failure to properly dispose this object will result in the memory
// not being returned to the pool, which will increase GC impact across various parts of the framework.
var memoryOwner = MemoryPool <byte> .Shared.RentAndSlice(buffer.Length);
try
{
buffer.CopyTo(memoryOwner.Memory);
// This boxes the SlicedMemoryOwner on the heap, making it act like a class to the consumer
return((T)(object)memoryOwner);
}
catch
{
// Cleanup if the copy fails
memoryOwner.Dispose();
throw;
}
}
throw new InvalidOperationException("The RawBinaryTranscoder can only decode byte arrays or IMemoryOwner<byte>.");
}
public static void Write(this Stream stream, ReadOnlyMemory <byte> buffer)
{
if (buffer.Length == 0)
{
return;
}
if (MemoryMarshal.TryGetArray(buffer, out var segment))
{
// ReSharper disable once AssignNullToNotNullAttribute
stream.Write(segment.Array, segment.Offset, segment.Count);
}
else
{
var byteBuffer = ArrayPool <byte> .Shared.Rent(buffer.Length);
try
{
buffer.CopyTo(byteBuffer);
stream.Write(byteBuffer, 0, buffer.Length);
}
finally
{
ArrayPool <byte> .Shared.Return(byteBuffer);
}
}
}
private unsafe void GenerateKey(ReadOnlyMemory <byte> modulus, ReadOnlyMemory <byte> generator, ref IntPtr hPrivateKey)
{
var status = BCryptGenerateKeyPair(this.hAlgorithm, ref hPrivateKey, this.ModulusSize, 0);
ThrowIfNotNtSuccess(status);
var structSize = sizeof(BCRYPT_DH_PARAMETER_HEADER) + modulus.Length + generator.Length;
using (var rented = CryptoPool.Rent <byte>(structSize))
{
rented.Memory.Span.Fill(0);
fixed(byte *pParam = &MemoryMarshal.GetReference(rented.Memory.Span))
{
BCRYPT_DH_PARAMETER *param = (BCRYPT_DH_PARAMETER *)pParam;
param->Header.CbLength = structSize;
param->Header.CbKeyLength = modulus.Length;
param->Header.DwMagic = BCRYPT_DH_PARAMETERS_MAGIC;
modulus.CopyTo(rented.Memory.Slice(sizeof(BCRYPT_DH_PARAMETER_HEADER)));
generator.CopyTo(rented.Memory.Slice(sizeof(BCRYPT_DH_PARAMETER_HEADER) + modulus.Length));
status = BCryptSetProperty(hPrivateKey, BCRYPT_DH_PARAMETERS, pParam, param->Header.CbLength, 0);
ThrowIfNotNtSuccess(status);
}
}
status = BCryptFinalizeKeyPair(hPrivateKey, 0);
ThrowIfNotNtSuccess(status);
}
public static async Task NewPackageAsync(this TcpDataReader tcpDataReader, ReadOnlyMemory <byte> bytes)
{
var buf = await tcpDataReader.AllocateBufferToWriteAsync(CancellationToken.None);
bytes.CopyTo(buf);
tcpDataReader.CommitWrittenData(bytes.Length);
}
private static void Write(PipeWriter writer, ReadOnlyMemory <byte> value)
{
var buffer = writer.GetMemory(value.Length);
value.CopyTo(buffer);
writer.Advance(value.Length);
}
/// <summary>
/// Reads the next value as a Integer with a specified tag, returning the contents
/// as a <see cref="BigInteger"/> over the original data.
/// </summary>
/// <param name="expectedTag">The tag to check for before reading.</param>
/// <returns>
/// The bytes of the Integer value, in signed big-endian form.
/// </returns>
/// <exception cref="CryptographicException">
/// the next value does not have the correct tag --OR--
/// the length encoding is not valid under the current encoding rules --OR--
/// the contents are not valid under the current encoding rules
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="expectedTag"/>.<see cref="Asn1Tag.TagClass"/> is
/// <see cref="TagClass.Universal"/>, but
/// <paramref name="expectedTag"/>.<see cref="Asn1Tag.TagValue"/> is not correct for
/// the method
/// </exception>
public BigInteger ReadInteger(Asn1Tag expectedTag)
{
ReadOnlyMemory <byte> contents =
this.GetIntegerContents(expectedTag, UniversalTagNumber.Integer, out int headerLength);
// TODO: Split this for netcoreapp/netstandard to use the Big-Endian BigInteger parsing
byte[] tmp = CryptoPool.Rent(contents.Length);
BigInteger value;
try
{
byte fill = (contents.Span[0] & 0x80) == 0 ? (byte)0 : (byte)0xFF;
// Fill the unused portions of tmp with positive or negative padding.
new Span <byte>(tmp, contents.Length, tmp.Length - contents.Length).Fill(fill);
contents.CopyTo(tmp);
// Convert to Little-Endian.
AsnWriter.Reverse(new Span <byte>(tmp, 0, contents.Length));
value = new BigInteger(tmp);
}
finally
{
// Let CryptoPool.Return clear the whole tmp so that not even the sign bit
// is returned to the array pool.
CryptoPool.Return(tmp);
}
this._data = this._data.Slice(headerLength + contents.Length);
return(value);
}
/// <summary>
/// Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.
/// </summary>
/// <param name="buffer">The buffer to write data from.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="P:System.Threading.CancellationToken.None" />.</param>
/// <returns>A task that represents the asynchronous write operation.</returns>
public Task WriteAsync2(ReadOnlyMemory <byte> buffer, CancellationToken cancellationToken)
{
var buf = ArrayPool <byte> .Shared.Rent(buffer.Length);
buffer.CopyTo(buf);
return(stream.WriteAsync(buf, 0, buf.Length, cancellationToken));
}
protected private override void ImplWriteBytes(ref State state, ReadOnlyMemory <byte> bytes)
{
var length = bytes.Length;
if (flushLock != 0 || length <= ioBuffer.Length) // write to the buffer
{
DemandSpace(length, this, ref state);
bytes.CopyTo(new Memory <byte>(ioBuffer, ioIndex, length));
ioIndex += length;
}
else
{
// writing data that is bigger than the buffer (and the buffer
// isn't currently locked due to a sub-object needing the size backfilled)
state.Flush(); // commit any existing data from the buffer
// now just write directly to the underlying stream
// prefer using the array API, even on .NET Core (for now),
// because many implementations won't have overridden the method yet
if (MemoryMarshal.TryGetArray(bytes, out var segment))
{
dest.Write(segment.Array, segment.Offset, segment.Count);
}
else
{
#if PLAT_SPAN_OVERLOADS
dest.Write(bytes.Span);
#else
WriteFallback(bytes.Span, dest);
#endif
}
// since we've flushed offset etc is 0, and remains
// zero since we're writing directly to the stream
}
}
public static ReadOnlyMemory <byte> Decrypt(
ReadOnlyMemory <byte> ciphertext,
ReadOnlyMemory <byte> key,
ReadOnlyMemory <byte> iv
)
{
if (!CalculateLength(ciphertext.Length, out int padSize, out int maxLength))
{
return(ciphertext);
}
using (var rental = CryptoPool.Rent <byte>(maxLength))
{
var aes = CryptoPal.Platform.Aes();
Memory <byte> ciphertextRented;
if (padSize == BlockSize)
{
ciphertextRented = rental.Memory.Slice(0, ciphertext.Length);
ciphertext.CopyTo(ciphertextRented);
}
else
{
var depadded = Depad(ciphertext, padSize);
var decryptedPad = aes.Decrypt(depadded, key, iv);
ciphertextRented = rental.Memory.Slice(0, maxLength);
ciphertext.CopyTo(ciphertextRented);
decryptedPad.Slice(decryptedPad.Length - padSize)
.CopyTo(
ciphertextRented.Slice(ciphertext.Length)
);
}
if (ciphertext.Length >= TwoBlockSizes)
{
SwapLastTwoBlocks(ciphertextRented.Span);
}
return(aes.Decrypt(ciphertextRented, key, iv).Slice(0, ciphertext.Length));
}
}
private static ReadOnlyMemory <byte> Pad(ReadOnlyMemory <byte> data, int length)
{
var copy = new Memory <byte>(new byte[length]);
data.CopyTo(copy.Slice(length - data.Length));
return(copy);
}
internal SpriteData(string path, ReadOnlyMemory <byte> data, SKBitmap image)
{
Path = path;
Reference = GC.AllocateUninitializedArray <byte>((int)data.Length);
data.CopyTo(Reference);
Data = new(Reference);
Image = image;
}
internal ReadOnlyMemory <TableFieldInfo> GetAllFields()
{
var res = new TableFieldInfo[PrimaryKeyFields.Length + Fields.Length];
PrimaryKeyFields.CopyTo(res);
Fields.CopyTo(res.AsMemory(PrimaryKeyFields.Length));
return(res);
}
public override int Read(byte[] buffer, int offset, int count)
{
ReadOnlyMemory <byte> bytes = Read(count, false);
bytes.CopyTo(new Memory <byte>(buffer).Slice(offset, count));
return(bytes.Length);
}
public static void WriteToROM(int Addr, ReadOnlyMemory <byte> val)
{
int f = RomUtils.GetFileIndexForWriting(Addr);
int dest = Addr - RomData.MMFileList[f].Addr;
var memory = new Memory <byte>(RomData.MMFileList[f].Data);
val.CopyTo(memory.Slice(dest));
}
/// <summary>
/// Expand the Received Body Bytes
/// </summary>
/// <param name="bytes">The Received Bytes</param>
protected virtual void ExpandBody(ReadOnlyMemory <byte> bytes)
{
byte[] bodyBytes = new byte[bytes.Length];
bytes.CopyTo(bodyBytes);
_body = bodyBytes;
}
public ReusableTask WriteAsync(ITorrentFileInfo file, long offset, ReadOnlyMemory <byte> buffer)
{
var result = new byte[buffer.Length];
buffer.CopyTo(result.AsMemory());
WrittenData.Add(Tuple.Create(file, offset, result));
return(ReusableTask.CompletedTask);
}
public MemoryOwner(ReadOnlyMemory <byte> memory)
{
// The memory is read-only, and the memory owner expects a mutable area
// of memory. In this case we will create a copy of the data.
// TODO: Can we redesign this to where this isn't necessary?
UnderlyingMemory = MemoryPool <byte> .Shared.Rent(memory.Length);
memory.CopyTo(UnderlyingMemory.Memory);
}
public static async ValueTask WriteAsync(this Stream stream, ReadOnlyMemory <byte> buffer, CancellationToken cancellationToken = default)
{
using (var rentedBuffer = new RentedBuffer <byte>(buffer.Length))
{
buffer.CopyTo(rentedBuffer.Memory);
var segment = rentedBuffer.Segment;
await stream.WriteAsync(segment.Array, segment.Offset, segment.Count, cancellationToken);
}
}
/// <summary>
/// KRB-FX-CF1: Concatenate two strings into a single string.
/// KRB-FX-CF1(UTF-8 string, UTF-8 string) -> (UTF-8 string)
/// KRB-FX-CF1(x, y) := x || y
/// </summary>
/// <param name="x">The first string</param>
/// <param name="y">The second string</param>
/// <returns>Returns the two strings concatenated</returns>
public static ReadOnlyMemory <byte> Cf1(ReadOnlyMemory <byte> x, ReadOnlyMemory <byte> y)
{
Memory <byte> result = new byte[x.Length + y.Length];
x.CopyTo(result);
y.CopyTo(result.Slice(x.Length));
return(result);
}
public static ReadOnlyMemory <byte> FormatKerberosMessageStream(ReadOnlyMemory <byte> message)
{
var kerbMessage = new Memory <byte>(new byte[message.Length + 4]);
BinaryPrimitives.WriteInt32BigEndian(kerbMessage.Span.Slice(0, 4), message.Length);
message.CopyTo(kerbMessage.Slice(4));
return(kerbMessage);
}
public Chip8Platform(ReadOnlyMemory <byte> romImage)
{
this.ram = new Memory <byte>(new byte[0x1000]);
this.font.CopyTo(this.ram);
romImage.CopyTo(this.ram.Slice(0x200));
this.cpu = new Chip8Cpu(this);
this.apu = new Chip8Apu(this);
this.ppu = new Chip8Ppu(this);
}
private static byte[] Reverse(ReadOnlyMemory <byte> data)
{
var copy = new byte[data.Length];
data.CopyTo(copy);
Array.Reverse(copy);
return(copy);
}
