fix: if buffer too small and returnLength is less than buffer length, double buffer length instead of assigning returnLength

Author: BinToss

deadlock-dotnet-sdk/Domain/NativeMethods.cs

@@ -256,7 +256,7 @@ ref returnLength
                 );
         }
 
-        if (status != Code.STATUS_SUCCESS)
+        if (status.Code is not Code.STATUS_SUCCESS)
         {
             // Fall back to using the previous code that we've used since Windows XP (dmex)
             systemInformationLength = 0x10000;
@@ -268,7 +268,7 @@ ref returnLength
                 SystemInformation: pSysInfoBuffer,
                 SystemInformationLength: systemInformationLength,
                 ReturnLength: ref returnLength
-                )) == Code.STATUS_INFO_LENGTH_MISMATCH)
+                )).Code is Code.STATUS_INFO_LENGTH_MISMATCH)
             {
                 Marshal.FreeHGlobal((IntPtr)pSysInfoBuffer);
                 systemInformationLength *= 2;

deadlock-dotnet-sdk/Domain/ProcessInfo.cs

@@ -252,7 +252,9 @@ ref returnLength
 #endif
                     // !WARNING may throw OutOfMemoryException; ReAllocHGlobal received a null pointer, but didn't check the error code
                     // the native call to LocalReAlloc (via Marshal.ReAllocHGlobal) sometimes returns a null pointer. This is a Legacy function. Why does .NET not use malloc/realloc?
-                    bufferCmdLine.Reallocate(numBytes: returnLength);
+                    if (returnLength < bufferCmdLine.ByteLength)
+                        bufferCmdLine.Reallocate(numBytes: (nuint)(bufferCmdLine.ByteLength * 2));
+                    else bufferCmdLine.Reallocate(numBytes: returnLength);
                     // none of these helped debug that internal error...
                     //var pinerr = Marshal.GetLastPInvokeError();
                     //var syserr = Marshal.GetLastSystemError();
@@ -279,7 +281,11 @@ ref returnLength
             if (Env.Is64BitOperatingSystem && !Env.Is64BitProcess && Is32BitEmulatedProcess.v is false) // yes
             {
                 while ((status = NtWow64QueryInformationProcess64(ProcessHandle.v, PROCESSINFOCLASS.ProcessBasicInformation, (void*)bufferPBI.DangerousGetHandle(), (uint)bufferPBI.ByteLength, &returnLength)).Code is Code.STATUS_INFO_LENGTH_MISMATCH or Code.STATUS_BUFFER_TOO_SMALL or Code.STATUS_BUFFER_OVERFLOW)
-                    bufferPBI.Reallocate(numBytes: returnLength);
+                {
+                    if (returnLength < bufferPBI.ByteLength)
+                        bufferPBI.Reallocate(numBytes: (nuint)(bufferPBI.ByteLength * 2));
+                    else bufferPBI.Reallocate(numBytes: returnLength);
+                }
 
                 if (status.Code is not Code.STATUS_SUCCESS)
                     throw new NTStatusException(status, "NtWow64QueryInformationProcess64 failed to query a process's basic information; " + status.Message);
@@ -289,7 +295,11 @@ ref returnLength
             else
             {
                 while ((status = NtQueryInformationProcess(ProcessHandle.v, PROCESSINFOCLASS.ProcessBasicInformation, (void*)bufferPBI.DangerousGetHandle(), (uint)bufferPBI.ByteLength, ref returnLength)).Code is Code.STATUS_INFO_LENGTH_MISMATCH or Code.STATUS_BUFFER_TOO_SMALL or Code.STATUS_BUFFER_OVERFLOW)
-                    bufferPBI.Reallocate(returnLength + (uint)IntPtr.Size);
+                {
+                    if (returnLength < bufferPBI.ByteLength)
+                        bufferPBI.Reallocate((nuint)(bufferPBI.ByteLength * 2));
+                    else bufferPBI.Reallocate((returnLength is 0 ? returnLength = (uint)(Marshal.SizeOf<PROCESS_BASIC_INFORMATION64>() * 2) : returnLength) + (uint)IntPtr.Size);
+                }
 
                 if (status.Code is not Code.STATUS_SUCCESS)
                     throw new NTStatusException(status, "NtQueryInformationProcess failed to query a process's basic information; " + status.Message);

deadlock-dotnet-sdk/Domain/SafeHandleEx.cs

@@ -162,7 +162,9 @@ public unsafe (string? v, Exception? ex) ObjectName
                                                &bufferLength)).Code
                     is Code.STATUS_BUFFER_OVERFLOW or Code.STATUS_INFO_LENGTH_MISMATCH or Code.STATUS_BUFFER_TOO_SMALL)
                 {
-                    buffer.Reallocate(bufferLength);
+                    if (bufferLength < buffer.ByteLength)
+                        buffer.Reallocate((uint)(buffer.ByteLength * 2));
+                    else buffer.Reallocate(bufferLength);
                 }
 
                 OBJECT_NAME_INFORMATION oni = buffer.Read<OBJECT_NAME_INFORMATION>(0);

deadlock-dotnet-sdk/Windows.Win32/SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX.cs

@@ -67,13 +67,13 @@ public unsafe string GetHandleObjectType()
         uint returnLength;
         using var h = new SafeObjectHandle(HandleValue, false);
 
-        status = NtQueryObject(h, OBJECT_INFORMATION_CLASS.ObjectTypeInformation, (void*)buffer.DangerousGetHandle(), (uint)buffer.ByteLength, &returnLength);
-
         // Something's off. Marshal.SizeOf() returns 0x68 (104) but returnLength is 0x78 (120) or sometimes 0x80 (128). Is Win32Metadata's type definition wrong?
-        while (status.Code is STATUS_BUFFER_OVERFLOW or STATUS_INFO_LENGTH_MISMATCH or STATUS_BUFFER_TOO_SMALL)
+        while ((status = NtQueryObject(h, OBJECT_INFORMATION_CLASS.ObjectTypeInformation, (void*)buffer.DangerousGetHandle(), (uint)buffer.ByteLength, &returnLength))
+            .Code is STATUS_BUFFER_OVERFLOW or STATUS_INFO_LENGTH_MISMATCH or STATUS_BUFFER_TOO_SMALL)
         {
-            buffer.Reallocate(returnLength);
-            status = NtQueryObject(h, OBJECT_INFORMATION_CLASS.ObjectTypeInformation, (void*)buffer.DangerousGetHandle(), (uint)buffer.ByteLength, &returnLength);
+            if (returnLength < buffer.ByteLength)
+                buffer.Reallocate((nuint)(2 * buffer.ByteLength));
+            else buffer.Reallocate(returnLength);
         }
 
         return status.IsSuccessful