/// <summary> /// Parses encrypted buffer in format MESSAGE_LENGTH|ENCRYPTED_MESSAGE|MESSAGE_TRAILER /// </summary> private static void ParseEncryptedBuffer(byte[] encBuffer, out byte[] encrypted, out byte[] trailer) { GCHandle gcEncBuffer = GCHandle.Alloc(encBuffer, GCHandleType.Pinned); try { IntPtr sizePtr = gcEncBuffer.AddrOfPinnedObject(); int encryptedLen = Marshal.ReadInt32(sizePtr); int trailerLen = encBuffer.Length - 4 - encryptedLen; if (trailerLen < 0) { throw new ArgumentOutOfRangeException("encBuffer.Length"); } IntPtr encryptedPtr = IntPtrHelper.Add(sizePtr, 4); encrypted = new byte[encryptedLen]; Marshal.Copy(encryptedPtr, encrypted, 0, encryptedLen); IntPtr trailerPtr = IntPtrHelper.Add(encryptedPtr, encryptedLen); trailer = new byte[trailerLen]; Marshal.Copy(trailerPtr, trailer, 0, trailerLen); } finally { gcEncBuffer.Free(); } }
/// <summary> /// Returns buffer data /// </summary> public byte[] GetBuffer(int index) { // check object state if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } // parameters validation if ((index < 0) || (index >= BuffersCount)) { throw new ArgumentOutOfRangeException("count"); } // get buffer descriptor IntPtr secBuffer = IntPtrHelper.Add(pvBuffers, index * SSPINative.SecBuffer.Size); // return buffer int size = MarshalHelper.ReadInt32(secBuffer, typeof(SSPINative.SecBuffer), "BufferSize"); if (size > 0) { return(MarshalHelper.ReadBytes(secBuffer, typeof(SSPINative.SecBuffer), "pvBuffer", size)); } else { return(null); } }
// // The overlapped function called (either by the thread pool or the socket) // when IO completes. (only called on Win9x) // private void OverlappedCallback(object stateObject, bool Signaled) { #if DEBUG // GlobalLog.SetThreadSource(ThreadKinds.Worker); Because of change 1077887, need logic to determine thread type here. using (GlobalLog.SetThreadKind(ThreadKinds.System)) { #endif BaseOverlappedAsyncResult asyncResult = (BaseOverlappedAsyncResult)stateObject; GlobalLog.Assert(!asyncResult.InternalPeekCompleted, "AcceptOverlappedAsyncResult#{0}::OverlappedCallback()|asyncResult.IsCompleted", ValidationHelper.HashString(asyncResult)); // // the IO completed asynchronously, see if there was a failure the Internal // field in the Overlapped structure will be non zero. to optimize the non // error case, we look at it without calling WSAGetOverlappedResult(). // uint errorCode = (uint)Marshal.ReadInt32(IntPtrHelper.Add(asyncResult.m_UnmanagedBlob.DangerousGetHandle(), Win32.OverlappedInternalOffset)); uint numBytes = errorCode != 0 ? unchecked ((uint)-1) : (uint)Marshal.ReadInt32(IntPtrHelper.Add(asyncResult.m_UnmanagedBlob.DangerousGetHandle(), Win32.OverlappedInternalHighOffset)); // // this will release the unmanaged pin handles and unmanaged overlapped ptr // asyncResult.ErrorCode = (int)errorCode; object returnObject = asyncResult.PostCompletion((int)numBytes); asyncResult.ReleaseUnmanagedStructures(); asyncResult.InvokeCallback(returnObject); #if DEBUG } #endif }
/// <summary> /// Creates encrypted buffer in format MESSAGE_LENGTH|ENCRYPTED_MESSAGE|MESSAGE_TRAILER /// </summary> private static byte[] CreateEncryptedBuffer(byte[] encrypted, byte[] trailer) { int encryptedLen = encrypted.Length; int trailerLen = trailer.Length; byte[] encBuffer = new byte[4 + encryptedLen + trailerLen]; GCHandle gcEncBuffer = GCHandle.Alloc(encBuffer, GCHandleType.Pinned); try { IntPtr sizePtr = gcEncBuffer.AddrOfPinnedObject(); Marshal.WriteInt32(sizePtr, encryptedLen); IntPtr encryptedPtr = IntPtrHelper.Add(sizePtr, 4); Marshal.Copy(encrypted, 0, encryptedPtr, encryptedLen); IntPtr trailerPtr = IntPtrHelper.Add(encryptedPtr, encryptedLen); Marshal.Copy(trailer, 0, trailerPtr, trailerLen); return(encBuffer); } finally { gcEncBuffer.Free(); } }
private void OverlappedCallback(object stateObject, bool Signaled) { BaseOverlappedAsyncResult result = (BaseOverlappedAsyncResult)stateObject; uint num = (uint)Marshal.ReadInt32(IntPtrHelper.Add(result.m_UnmanagedBlob.DangerousGetHandle(), 0)); uint num2 = (num != 0) ? uint.MaxValue : ((uint)Marshal.ReadInt32(IntPtrHelper.Add(result.m_UnmanagedBlob.DangerousGetHandle(), Win32.OverlappedInternalHighOffset))); result.ErrorCode = (int)num; object obj2 = result.PostCompletion((int)num2); result.ReleaseUnmanagedStructures(); result.InvokeCallback(obj2); }
/// <summary> /// Writes ACE to native buffer /// </summary> internal void UnsafeWrite(IntPtr pAce) { // write ACE properties MarshalHelper.WriteByte(pAce, typeof(SecurityNative.ACE), "AceType", (byte)_aceType); MarshalHelper.WriteByte(pAce, typeof(SecurityNative.ACE), "AceFlags", (byte)_aceFlags); MarshalHelper.WriteInt16(pAce, typeof(SecurityNative.ACE), "AceSize", (short)_size); MarshalHelper.WriteInt32(pAce, typeof(SecurityNative.ACE), "AccessMask", (int)_accessMask); // write SID IntPtr pSid = IntPtrHelper.Add(pAce, Marshal.OffsetOf(typeof(SecurityNative.ACE), "SidStart")); Win32.CopyMemory(pSid, _trustee.Handle, (uint)_trustee.Size); }
internal PingReply(Icmp6EchoReply reply, IntPtr dataPtr, int sendSize) { this.address = new IPAddress(reply.Address.Address, (long)reply.Address.ScopeID); this.ipStatus = (IPStatus)reply.Status; if (this.ipStatus == IPStatus.Success) { this.rtt = reply.RoundTripTime; this.buffer = new byte[sendSize]; Marshal.Copy(IntPtrHelper.Add(dataPtr, 0x24), this.buffer, 0, sendSize); } else { this.buffer = new byte[0]; } }
/// <summary> /// Initializes buffer with data /// </summary> public void SetBuffer(int index, int type, byte[] buffer) { // check object state if (_disposed) { throw new ObjectDisposedException(GetType().FullName); } // parameters validation if ((index < 0) || (index >= BuffersCount)) { throw new ArgumentOutOfRangeException("index"); } if (buffer == null) { throw new ArgumentNullException("buffer"); } if (buffer.Length == 0) { throw new ArgumentOutOfRangeException("buffer.Length"); } // allocate buffer int size = buffer.Length; IntPtr bufferData = Win32.LocalAlloc(Win32.LMEM_ZEROINIT, (uint)size); if (bufferData == IntPtr.Zero) { throw new OutOfMemoryException(); } try { // copy buffer data Marshal.Copy(buffer, 0, bufferData, size); // create buffer descriptor IntPtr secBuffer = IntPtrHelper.Add(pvBuffers, index * SSPINative.SecBuffer.Size); MarshalHelper.WriteInt32(secBuffer, typeof(SSPINative.SecBuffer), "BufferSize", size); MarshalHelper.WriteInt32(secBuffer, typeof(SSPINative.SecBuffer), "BufferType", type); MarshalHelper.WriteIntPtr(secBuffer, typeof(SSPINative.SecBuffer), "pvBuffer", bufferData); } catch { Win32.LocalFree(bufferData); throw; } }
internal void FreeBuffers() { IntPtr secBuffer = pvBuffers; for (int i = 0; i < BuffersCount; ++i) { IntPtr bufferData = MarshalHelper.ReadIntPtr(secBuffer, typeof(SSPINative.SecBuffer), "pvBuffer"); if (bufferData != IntPtr.Zero) { Win32.LocalFree(bufferData); } secBuffer = IntPtrHelper.Add(pvBuffers, SSPINative.SecBuffer.Size); } Win32.RtlZeroMemory(pvBuffers, (uint)(SSPINative.SecBuffer.Size * BuffersCount)); }
// the main constructor for the icmpsendecho apis internal PingReply(Icmp6EchoReply reply, IntPtr dataPtr, int sendSize) { address = new IPAddress(reply.Address.Address, reply.Address.ScopeID); ipStatus = (IPStatus)reply.Status; //the icmpsendecho ip status codes //only copy the data if we succeed w/ the ping operation if (ipStatus == IPStatus.Success) { rtt = (long)reply.RoundTripTime; buffer = new byte[sendSize]; Marshal.Copy(IntPtrHelper.Add(dataPtr, 36), buffer, 0, sendSize); //options = new PingOptions (reply.options); } else { buffer = new byte[0]; } }
internal AccessControlEntry(IntPtr pAce) { // parameters validation if (pAce == IntPtr.Zero) { throw new ArgumentNullException("pAce"); } // read ACE properties _aceType = (AccessControlEntryType)MarshalHelper.ReadByte(pAce, typeof(SecurityNative.ACE), "AceType"); _aceFlags = (AccessControlEntryFlags)MarshalHelper.ReadByte(pAce, typeof(SecurityNative.ACE), "AceFlags"); _accessMask = (AccessMask)MarshalHelper.ReadInt32(pAce, typeof(SecurityNative.ACE), "AccessMask"); // read SID IntPtr pSid = IntPtrHelper.Add(pAce, Marshal.OffsetOf(typeof(SecurityNative.ACE), "SidStart")); Trustee = new SecurityIdentifier(pSid, true); }
internal PingReply(Interop.IpHlpApi.Icmp6EchoReply reply, IntPtr dataPtr, int sendSize) { _address = new IPAddress(reply.Address.Address, reply.Address.ScopeID); // The icmpsendecho IP status codes. _ipStatus = (IPStatus)reply.Status; // Only copy the data if we succeed w/ the ping operation. if (_ipStatus == IPStatus.Success) { _rtt = (long)reply.RoundTripTime; _buffer = new byte[sendSize]; Marshal.Copy(IntPtrHelper.Add(dataPtr, 36), _buffer, 0, sendSize); } else { _buffer = Array.Empty <byte>(); } }
// // The overlapped function called (either by the thread pool or the socket) // when IO completes. (only called on Win9x) // internal void OverlappedCallback(object stateObject, bool Signaled) { OverlappedAsyncResult asyncResult = (OverlappedAsyncResult)stateObject; GlobalLog.Assert(!asyncResult.IsCompleted, "OverlappedAsyncResult#" + ValidationHelper.HashString(asyncResult) + "::OverlappedCallback() asyncResult.IsCompleted", ""); // // the IO completed asynchronously, see if there was a failure the Internal // field in the Overlapped structure will be non zero. to optimize the non // error case, we look at it without calling WSAGetOverlappedResult(). // uint errorCode = (uint)Marshal.ReadInt32(IntPtrHelper.Add(asyncResult.m_UnmanagedBlob, Win32.OverlappedInternalOffset)); uint numBytes = errorCode != 0 ? unchecked ((uint)-1) : (uint)Marshal.ReadInt32(IntPtrHelper.Add(asyncResult.m_UnmanagedBlob, Win32.OverlappedInternalHighOffset)); // // this will release the unmanaged pin handles and unmanaged overlapped ptr // asyncResult.ReleaseUnmanagedStructures(); asyncResult.ErrorCode = (int)errorCode; asyncResult.InvokeCallback(false, (int)numBytes); }
public void IntPtrAddTest() { int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; unsafe { fixed(int *parr = arr) { IntPtr ptr = new IntPtr(parr); // Get the size of an array element. int size = sizeof(int); int index = 0; for (int ctr = 0; ctr < arr.Length; ctr++) { IntPtr newPtr = IntPtrHelper.Add(ptr, ctr * size); Assert.AreEqual(arr[index], Marshal.ReadInt32(newPtr)); index++; } } } }
public void IntPtrSubtractTest() { int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; unsafe { fixed(int *parr = arr) { // Get the size of an array element. const int size = sizeof(int); var ptr = IntPtrHelper.Add(new IntPtr(parr), size * (arr.Length - 1)); var index = arr.Length - 1; for (var ctr = 0; ctr < arr.Length; ctr++) { var newPtr = IntPtrHelper.Subtract(ptr, ctr * size); Assert.AreEqual(arr[index], Marshal.ReadInt32(newPtr)); index--; } } } }
private static PingReply CreatePingReplyFromIcmp6EchoReply(Interop.IpHlpApi.Icmp6EchoReply reply, IntPtr dataPtr, int sendSize) { IPAddress address = new IPAddress(reply.Address.Address, reply.Address.ScopeID); IPStatus ipStatus = (IPStatus)reply.Status; // The icmpsendecho IP status codes. long rtt; byte[] buffer; rtt = reply.RoundTripTime; if (ipStatus == IPStatus.Success) { // Only copy the data if we succeed w/ the ping operation. buffer = new byte[sendSize]; Marshal.Copy(IntPtrHelper.Add(dataPtr, 36), buffer, 0, sendSize); } else { buffer = Array.Empty <byte>(); } return(new PingReply(address, default(PingOptions), ipStatus, rtt, buffer)); }
public static int HackedGetOverlappedResult(IntPtr pOverlapped, out int totalBytes) { // // read IO asynchronous status from Overlapped structure // int status = Marshal.ReadInt32(IntPtrHelper.Add(pOverlapped, Overlapped.InternalLowOffset)); if (status == 0) { // // the Async IO call completed // totalBytes = Marshal.ReadInt32(IntPtrHelper.Add(pOverlapped, Overlapped.InternalHighOffset)); } else { // // the Async IO call failed or still pending // totalBytes = -1; } return(status); }