Beispiel #1
0
 /// <summary>
 /// Performs application-defined tasks associated with freeing, 
 /// releasing, or resetting unmanaged resources.
 /// </summary>
 public void Dispose()
 {
     if (!_memoryBlock.IsInvalid)
     {
         _memoryBlock.Dispose();
         _memoryBlock = _invalidBlock;
     }
 }
 public void Ctor_NullPointerIsZero()
 {
     //Act
     using (var target = new SafeHGlobalHandle(IntPtr.Zero))
     {
         //Assert
         target.Pointer.Should().BeZero();
         target.IsInvalid.Should().BeTrue();
     };
 }
 public void StringToUnicode_NullStringWorks()
 {
     //Act
     using (var target = SafeHGlobalHandle.StringToUnicode(null))
     {
         //Assert
         target.IsInvalid.Should().BeTrue();
         target.Pointer.Should().BeZero();
     };
 }
Beispiel #4
0
        public void ResizeTest()
        {
            var h = new SafeHGlobalHandle(5);

            Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 5);
            var ptr = (IntPtr)h;

            h.Size = 50;
            Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 50 && (IntPtr)h != ptr);
        }
Beispiel #5
0
 public void FromNativeVariantTest()
 {
     using (var pVar = new SafeHGlobalHandle(100))
     {
         Marshal.GetNativeVariantForObject(0xFFFFFFFF, (IntPtr)pVar);
         var pv = PROPVARIANT.FromNativeVariant((IntPtr)pVar);
         Assert.That(pv.vt, Is.EqualTo(VARTYPE.VT_UI4));
         VariantClear((IntPtr)pVar);
     }
 }
Beispiel #6
0
 public void SetLengthTest()
 {
     using (var m = new SafeHGlobalHandle(1000))
         using (var ms = new NativeMemoryStream((IntPtr)m, m.Size))
         {
             Assert.That(() => ms.SetLength(-1), Throws.TypeOf <ArgumentOutOfRangeException>());
             Assert.That(() => ms.SetLength(1001), Throws.Exception);
             Assert.That(() => ms.SetLength(100), Throws.Nothing);
         }
 }
Beispiel #7
0
 public void SeekTest()
 {
     using SafeHGlobalHandle m = new SafeHGlobalHandle(1000);
     using MarshalingStream ms = new MarshalingStream(m, m.Size);
     Assert.That(ms.Seek(20, SeekOrigin.Begin), Is.EqualTo(20));
     Assert.That(ms.Seek(20, SeekOrigin.Current), Is.EqualTo(40));
     Assert.That(ms.Seek(-100, SeekOrigin.End), Is.EqualTo(900));
     Assert.That(() => ms.Seek(-1, SeekOrigin.Begin), Throws.ArgumentException);
     Assert.That(() => ms.Seek(1, SeekOrigin.End), Throws.ArgumentException);
 }
        static SafeHGlobalHandle CopyOidsToUnmanagedMemory(OidCollection oids)
        {
            SafeHGlobalHandle safeAllocHandle = SafeHGlobalHandle.InvalidHandle;

            if (oids == null || oids.Count == 0)
            {
                return(safeAllocHandle);
            }

            // Copy the oid strings to a local list to prevent a security race condition where
            // the OidCollection or individual oids can be modified by another thread and
            // potentially cause a buffer overflow
            List <string> oidStrs = new List <string>();

            foreach (Oid oid in oids)
            {
                oidStrs.Add(oid.Value);
            }

            IntPtr pOid            = IntPtr.Zero;
            IntPtr pNullTerminator = IntPtr.Zero;

            // Needs to be checked to avoid having large sets of oids overflow the sizes and allow
            // a potential buffer overflow
            checked {
                int ptrSize = oidStrs.Count * Marshal.SizeOf(typeof(IntPtr));
                int oidSize = 0;
                foreach (string oidStr in oidStrs)
                {
                    oidSize += (oidStr.Length + 1);
                }
                safeAllocHandle = SafeHGlobalHandle.AllocHGlobal(ptrSize + oidSize);
                pOid            = new IntPtr((long)safeAllocHandle.DangerousGetHandle() + ptrSize);
            }

            for (int index = 0; index < oidStrs.Count; index++)
            {
                Marshal.WriteIntPtr(new IntPtr((long)safeAllocHandle.DangerousGetHandle() + index * Marshal.SizeOf(typeof(IntPtr))), pOid);
                byte[] ansiOid = Encoding.ASCII.GetBytes(oidStrs[index]);

                if (ansiOid.Length != oidStrs[index].Length)
                {
                    // We assumed single byte characters, fail if this is not the case.  The exception is not ideal.
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CollectionWasModified)));
                }

                Marshal.Copy(ansiOid, 0, pOid, ansiOid.Length);
                pNullTerminator = new IntPtr((long)pOid + ansiOid.Length);
                Marshal.WriteByte(pNullTerminator, 0);

                pOid = new IntPtr((long)pOid + oidStrs[index].Length + 1);
            }
            return(safeAllocHandle);
        }
Beispiel #9
0
 public void PropTest()
 {
     using (var m = new SafeHGlobalHandle(1000))
         using (var ms = new MarshalingStream((IntPtr)m, m.Size))
         {
             Assert.That(ms.Length, Is.EqualTo(1000));
             Assert.That(ms.CanWrite, Is.True);
             Assert.That(ms.CanSeek, Is.True);
             Assert.That(ms.CanRead, Is.True);
         }
 }
        public AsciiCompiledTextSearchNative(
            NativeMethods.SearchAlgorithmKind kind,
            string pattern,
            NativeMethods.SearchOptions searchOptions)
        {
            _patternHandle = new SafeHGlobalHandle(Marshal.StringToHGlobalAnsi(pattern));
            var patternLength = pattern.Length;

            _handle           = CreateSearchHandle(kind, _patternHandle, patternLength, searchOptions);
            _searchBufferSize = NativeMethods.AsciiSearchAlgorithm_GetSearchBufferSize(_handle);
        }
Beispiel #11
0
 public void RECTTest()
 {
     using (var h = SafeHGlobalHandle.CreateFromStructure(new RECT(1, 2, 3, 4)))
     {
         var r = h.ToStructure <RECT>();
         Assert.That(r.left == 1);
         Assert.That(r.top == 2);
         Assert.That(r.right == 3);
         Assert.That(r.bottom == 4);
     }
 }
        public void SecureStringToUnicode_ZeroesMemoryWhenClosed()
        {
            var str    = CreateSecureString("Hello");
            var target = SafeHGlobalHandle.SecureStringToUnicode(str);

            //Act
            target.Close();

            //Assert - All we can do is verify it doesn't blow up
            target.IsClosed.Should().BeTrue();
        }
Beispiel #13
0
 public void GetSetDefaultCommConfigTest()
 {
     using (var mem = new SafeHGlobalHandle(2048))
     {
         var sz = (uint)mem.Size;
         Assert.That(GetDefaultCommConfig(pcCommPort, mem, ref sz), ResultIs.Successful);
         var cc = mem.ToStructure <COMMCONFIG>();
         cc.WriteValues();
         Assert.That(SetDefaultCommConfig(pcCommPort, mem, (uint)mem.Size), ResultIs.Successful);
     }
 }
        public void Dispose_NullPointerWorks()
        {
            //Act
            var target = new SafeHGlobalHandle();

            target.Dispose();

            //Assert - No real way to confirm the memory was released
            target.Pointer.Should().BeZero();
            target.IsInvalid.Should().BeTrue();
        }
Beispiel #15
0
        private void WriteIndexedImage(GLTexture texture, GLTexture palette)
        {
            byte[]    palettesPixels = palette.GetManagedPixelsArray(PixelFormat.Format32bppArgb);
            TexHeader header         = CreateHeader(texture, palette, palettesPixels[3] == 0);

            _output.WriteStruct(header);
            _output.Write(palettesPixels, 0, palettesPixels.Length);
            using (SafeHGlobalHandle pixels = texture.GetUnmanagedPixelsArray(PixelFormat.Format8bppIndexed))
                using (UnmanagedMemoryStream input = pixels.OpenStream(FileAccess.Read))
                    input.CopyTo(_output);
        }
Beispiel #16
0
 public void GetPrivateObjectSecurityTest()
 {
     using (var pSD = GetSD(fn))
     {
         var b = GetPrivateObjectSecurity(pSD, SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION, IntPtr.Zero, 0, out uint rightSize);
         Assert.That(rightSize, Is.GreaterThan(0));
         var sdo = new SafeHGlobalHandle((int)rightSize);
         b = GetPrivateObjectSecurity(pSD, SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION, (IntPtr)sdo, (uint)sdo.Size, out rightSize);
         Assert.That(b);
         Assert.That(!sdo.IsInvalid);
     }
 }
        public void Ctor_ValidPointerIsSet()
        {
            var expected = AllocateMemory(200);

            //Act
            using (var target = new SafeHGlobalHandle(expected))
            {
                //Assert
                target.Pointer.Should().Be(expected);
                target.IsInvalid.Should().BeFalse();
            };
        }
Beispiel #18
0
 public void RegisterEventSourceTest()
 {
     using (var hES = RegisterEventSource(null, "TestSource"))
     {
         Assert.That(hES, ResultIs.ValidHandle);
         using (var mem = SafeHGlobalHandle.CreateFromStructure <EVENTLOG_FULL_INFORMATION>())
         {
             Assert.That(GetEventLogInformation(hES, 0, mem, mem.Size, out var req), ResultIs.Successful);
             mem.ToStructure <EVENTLOG_FULL_INFORMATION>().WriteValues();
         }
     }
 }
        public void StringToUnicode_ValidStringWorks()
        {
            string str = "Hello";

            //Act
            using (var target = SafeHGlobalHandle.StringToUnicode(str))
            {
                //Assert
                target.IsInvalid.Should().BeFalse();
                AssertMemory(target.Pointer, Encoding.Unicode.GetBytes("Hello"));
            };
        }
        public void Attach_NullPointerWorks()
        {
            //Act
            using (var target = new SafeHGlobalHandle())
            {
                target.Attach(IntPtr.Zero);

                //Assert
                target.Pointer.Should().BeZero();
                target.IsInvalid.Should().BeTrue();
            };
        }
        public void SecureStringToAnsi_ValidStringWorks()
        {
            var str = CreateSecureString("Hello");

            //Act
            using (var target = SafeHGlobalHandle.SecureStringToAnsi(str))
            {
                //Assert
                target.IsInvalid.Should().BeFalse();
                AssertMemory(target.Pointer, Encoding.ASCII.GetBytes("Hello"));
            };
        }
        public void ToArrayTest()
        {
            var rs = new[] { 10, 11, 12, 13, 14 };
            var h  = SafeHGlobalHandle.CreateFromList(rs, rs.Length, i);
            var ro = ((IntPtr)h).ToArray <int>(4, i);

            Assert.That(ro.Length, Is.EqualTo(4));
            Assert.That(ro[2], Is.EqualTo(rs[2]));

            Assert.That(((IntPtr)h).ToArray <int>(0, i), Is.Empty);
            Assert.That(IntPtr.Zero.ToArray <int>(3, i), Is.Null);
        }
Beispiel #23
0
        public void FiberTest()
        {
            TestContext.WriteLine($"IsFiber:{IsThreadAFiber()}");
            var id  = FlsAlloc(Callback);
            var mem = new SafeHGlobalHandle(64);

            mem.Fill(1);
            Assert.That(FlsSetValue(id, (IntPtr)mem), Is.True);
            Assert.That(FlsGetValue(id), Is.EqualTo((IntPtr)mem));
            Assert.That(FlsFree(id), Is.True);
            mem.Dispose();
        }
Beispiel #24
0
        public void RtlMoveMemoryTest()
        {
            var strings = new[] { "One", "Two", "Three" };

            using (var src = SafeHGlobalHandle.CreateFromStringList(strings))
                using (var dest = new SafeHGlobalHandle(src.Size))
                {
                    Assert.That(() => RtlZeroMemory(dest, dest.Size), Throws.Nothing);
                    Assert.That(() => RtlMoveMemory(dest, src, src.Size), Throws.Nothing);
                    Assert.That(dest.ToStringEnum(), Is.EquivalentTo(strings));
                }
        }
Beispiel #25
0
        private string UnprotectSecretv3(ProtectedSecret data)
        {
            byte[] rawProtectedData = Convert.FromBase64String(data.Data);
            using SafeHGlobalHandle f = new SafeHGlobalHandle(rawProtectedData);

            var result = NCrypt.NCryptUnprotectSecret(out _, NCrypt.UnprotectSecretFlags.NCRYPT_SILENT_FLAG, f.DangerousGetHandle(), f.Size, IntPtr.Zero, IntPtr.Zero, out IntPtr unprotectedData, out uint unprotectedDataSize);

            result.ThrowIfFailed();

            using SafeHGlobalHandle d = new SafeHGlobalHandle(unprotectedData, unprotectedDataSize, true);
            return(Encoding.Unicode.GetString(d.GetBytes(0, (int)unprotectedDataSize)));
        }
Beispiel #26
0
 public void PRECTTest()
 {
     Assert.That(Marshal.SizeOf(typeof(RECT)) == Marshal.SizeOf(typeof(PRECT)));
     using (var h = SafeHGlobalHandle.CreateFromStructure(new PRECT(1, 2, 3, 4)))
     {
         var r = h.ToStructure <RECT>();
         Assert.That(r.left == 1);
         Assert.That(r.top == 2);
         Assert.That(r.right == 3);
         Assert.That(r.bottom == 4);
     }
 }
Beispiel #27
0
 public void SeekTest()
 {
     using (var m = new SafeHGlobalHandle(1000))
         using (var ms = new NativeMemoryStream((IntPtr)m, m.Size))
         {
             Assert.That(ms.Seek(20, SeekOrigin.Begin), Is.EqualTo(20));
             Assert.That(ms.Seek(20, SeekOrigin.Current), Is.EqualTo(40));
             Assert.That(ms.Seek(-100, SeekOrigin.End), Is.EqualTo(900));
             Assert.That(() => ms.Seek(-1, SeekOrigin.Begin), Throws.ArgumentException);
             Assert.That(() => ms.Seek(1, SeekOrigin.End), Throws.ArgumentException);
         }
 }
Beispiel #28
0
        /// <summary>
        /// Ensures that there is sufficient memory allocated.
        /// </summary>
        /// <param name="capacity">
        /// The required capacity of the block, in bytes.
        /// </param>
        /// <exception cref="OutOfMemoryException">
        /// There is insufficient memory to satisfy the request.
        /// </exception>
        public void EnsureCapacity(int capacity)
        {
            int currentSize = _memoryBlock.IsInvalid ? 0 : _memoryBlock.Size;
            if (capacity > currentSize)
            {
                if (0 != currentSize) currentSize <<= 1;
                if (capacity > currentSize) currentSize = capacity;

                if (!_memoryBlock.IsInvalid) _memoryBlock.Dispose();
                _memoryBlock = SafeHGlobalHandle.Allocate(currentSize);
            }
        }
Beispiel #29
0
        //********************************************************************************************
        // Function: GetPreferredAddress
        //
        // Description: This function sorts a list of Ipv4 & Ipv6 addresses, and returns the "best" address that stack determines
        //
        //********************************************************************************************
        static Win32Error GetPreferredAddress(SOCKADDR_IN6[] pAddrList, out SOCKADDR_STORAGE pPreferredAddr)
        {
            Win32Error dwErr = Win32Error.ERROR_SUCCESS;

            pPreferredAddr = default;

            // Initialize WinSock
            using var wsa = SafeWSA.Initialize();

            // create socket
            var socketIoctl = WSASocket(ADDRESS_FAMILY.AF_INET6, SOCK.SOCK_DGRAM, 0, IntPtr.Zero, 0, WSA_FLAG.WSA_FLAG_OVERLAPPED);

            if (socketIoctl == SOCKET.INVALID_SOCKET)
            {
                dwErr = WSAGetLastError();
                Console.Write("WSASocket failed, (dwErr = {0}).", dwErr);
                return(dwErr);
            }

            var numElement      = pAddrList.Length;
            var pSockAddrList   = Array.ConvertAll(pAddrList, v6 => new SOCKADDR(v6));
            var pSocketAddrList = new SOCKET_ADDRESS_LIST {
                iAddressCount = numElement, Address = Array.ConvertAll(pSockAddrList, sa => new SOCKET_ADDRESS {
                    iSockaddrLength = sa.Size, lpSockaddr = sa.DangerousGetHandle()
                })
            };

            // sort addresses
            using var ppSocketAddrList = SafeHGlobalHandle.CreateFromStructure(pSocketAddrList);
            uint dwSize = 4U + (uint)(Marshal.SizeOf <SOCKET_ADDRESS>() * pSocketAddrList.iAddressCount);

            dwErr           = WSAIoctl(socketIoctl, WinSockIOControlCode.SIO_ADDRESS_LIST_SORT, ppSocketAddrList, dwSize, ppSocketAddrList, dwSize, out var dwBytes);
            pSocketAddrList = ppSocketAddrList.ToStructure <SOCKET_ADDRESS_LIST>();

            if (dwErr == SOCKET_ERROR)
            {
                dwErr = WSAGetLastError();
                Console.Write("WSAIoctl sort address failed, (dwErr = {0}).", dwErr);
                return(dwErr);
            }

            var pBestAddress = new IPAddress(pSocketAddrList.Address[0].lpSockaddr.ToArray <byte>(pSocketAddrList.Address[0].iSockaddrLength));

            pPreferredAddr = (SOCKADDR_STORAGE)(pBestAddress.IsIPv4MappedToIPv6 ? pBestAddress.MapToIPv4() : pBestAddress);

            if (socketIoctl != SOCKET.INVALID_SOCKET)
            {
                closesocket(socketIoctl);
                socketIoctl = SOCKET.INVALID_SOCKET;
            }

            return(dwErr);
        }
Beispiel #30
0
        public void IsBadPtrTest()
        {
            using (var mem = new SafeHGlobalHandle(8))
            {
#pragma warning disable CS0618 // Type or member is obsolete
                Assert.That(IsBadCodePtr(mem), ResultIs.Successful);
                Assert.That(IsBadReadPtr(mem, 8), ResultIs.Successful);
                Assert.That(IsBadStringPtr("string", 4), ResultIs.Successful);
                Assert.That(IsBadWritePtr(mem, 8), ResultIs.Successful);
#pragma warning restore CS0618 // Type or member is obsolete
            }
        }
        public void Detach_NullPointerWorks()
        {
            //Act
            using (var target = new SafeHGlobalHandle())
            {
                var actual = target.Detach();

                //Assert
                actual.Should().BeZero();
                target.Pointer.Should().BeZero();
                target.IsInvalid.Should().BeTrue();
            };
        }
Beispiel #32
0
        public void OpenProcessCloseTraceTest()
        {
            var callbackCount = 0;

            Assert.That(() =>
            {
                var logFile           = new EventLogFile(logfilePath);
                logFile.EventCallback = EvtCallback;
                using (var log = new EventTraceSingleLog(logFile))
                {
                    using (var mem = SafeHGlobalHandle.CreateFromStructure <ETW_TRACE_PARTITION_INFORMATION>())
                    {
                        Assert.That(QueryTraceProcessingHandle(log.Handle, ETW_PROCESS_HANDLE_INFO_TYPE.EtwQueryPartitionInformation, default, 0, mem, mem.Size, out var retLen), ResultIs.Successful);
Beispiel #33
0
 private static extern bool BackupRead(
     SafeFileHandle hFile,
     SafeHGlobalHandle pBuffer,
     int numberOfBytesToRead,
     out int numberOfBytesRead,
     [MarshalAs(UnmanagedType.Bool)] bool abort,
     [MarshalAs(UnmanagedType.Bool)] bool processSecurity,
     ref IntPtr context);