Fix DAC verify signature issue (#5470)

Running `clrstack` a second time after a verify DAC failure succeeds.

Runtime.GetDacFilePath wasn't caching the verifySignature parameter so
the DAC wasn't being verified once the dac path was cached.

Verify the DAC path passed to the DBI entry points for the `clrstack -i`
path in RuntimeWrapper.CreateCorDebugProcess.

Display the ISettingsService values in both `runtimes` and `sosstatus`.

Author: Mike McLaughlin

src/Microsoft.Diagnostics.DebugServices.Implementation/Runtime.cs

@@ -25,6 +25,7 @@ public class Runtime : IRuntime, IDisposable
         private Version _runtimeVersion;
         private ClrRuntime _clrRuntime;
         private string _dacFilePath;
+        private bool _verifySignature;      // This only applies to the regular DAC, not the CDAC
         private string _cdacFilePath;
         private string _dbiFilePath;
 
@@ -113,19 +114,22 @@ public string GetCDacFilePath()
 
         public string GetDacFilePath(out bool verifySignature)
         {
-            verifySignature = false;
             if (_settingsService.ForceUseContractReader)
             {
+                // Don't verify signature when using the CDAC and don't change the cached value
+                // because it only applies to the regular DAC in _dacFilePath.
+                verifySignature = false;
                 return GetCDacFilePath();
             }
             if (_dacFilePath is null)
             {
                 _dacFilePath = GetLibraryPath(DebugLibraryKind.Dac);
                 if (_dacFilePath is not null)
                 {
-                    verifySignature = _settingsService.DacSignatureVerificationEnabled;
+                    _verifySignature = _settingsService.DacSignatureVerificationEnabled;
                 }
             }
+            verifySignature = _verifySignature;
             return _dacFilePath;
         }
 
@@ -339,7 +343,8 @@ public override string ToString()
             if (_dacFilePath is not null)
             {
                 sb.AppendLine();
-                sb.Append($"    DAC: {_dacFilePath}");
+                string verify = _verifySignature ? "(verify)" : "(don't verify)";
+                sb.Append($"    DAC: {_dacFilePath} {verify}");
             }
             if (_cdacFilePath is not null)
             {

src/Microsoft.Diagnostics.ExtensionCommands/Host/CommandFormatHelpers.cs

@@ -16,6 +16,15 @@ public static class CommandFormatHelpers
         public const string DebugHeaderExport = "DotNetRuntimeDebugHeader";
         public const string ContractDescriptorExport = "DotNetRuntimeContractDescriptor";
 
+        public static void DisplaySettingService(this CommandBase command)
+        {
+            ISettingsService settingsService = command.Services.GetService<ISettingsService>() ?? throw new DiagnosticsException("Settings service required");
+            command.Console.WriteLine("Settings:");
+            command.Console.WriteLine($"-> Use CDAC contract reader: {settingsService.UseContractReader}");
+            command.Console.WriteLine($"-> Force use CDAC contract reader: {settingsService.ForceUseContractReader}");
+            command.Console.WriteLine($"-> DAC signature verification check enabled: {settingsService.DacSignatureVerificationEnabled}");
+        }
+
         /// <summary>
         /// Displays the special diagnostics info header memory block (.NET Core 8 or later on Linux/MacOS)
         /// </summary>

src/Microsoft.Diagnostics.ExtensionCommands/Host/RuntimesCommand.cs

@@ -128,10 +128,8 @@ public override void Invoke()
                     }
                     this.DisplayResources(runtime.RuntimeModule, all: false, indent: "    ");
                     this.DisplayRuntimeExports(runtime.RuntimeModule, error: true, indent: "    ");
-                    WriteLine($"Use CDAC contract reader: {SettingsService.UseContractReader}");
-                    WriteLine($"Force use CDAC contract reader: {SettingsService.ForceUseContractReader}");
-                    WriteLine($"DAC signature verification check enabled: {SettingsService.DacSignatureVerificationEnabled}");
                 }
+                this.DisplaySettingService();
             }
         }
     }

src/Microsoft.Diagnostics.ExtensionCommands/Host/StatusCommand.cs

@@ -63,6 +63,7 @@ public override void Invoke()
                     }
                 }
                 this.DisplaySpecialInfo();
+                this.DisplaySettingService();
                 Write(SymbolService.ToString());
 
                 List<Assembly> extensions = new(ServiceManager.ExtensionsLoaded);

src/SOS/SOS.Extensions/HostServices.cs

@@ -356,6 +356,10 @@ private int DispatchCommand(
             {
                 return HResult.E_INVALIDARG;
             }
+            if (_commandService is null)
+            {
+                return HResult.E_FAIL;
+            }
             try
             {
                 _commandService.Execute(commandName, commandArguments, string.Equals(commandName, "help", StringComparison.OrdinalIgnoreCase) ?  _contextServiceFromDebuggerServices.Services : _servicesWithManagedOnlyFilter);

src/SOS/SOS.Hosting/RuntimeWrapper.cs

@@ -383,10 +383,9 @@ private IntPtr CreateClrDataProcess(IntPtr dacHandle)
         private IntPtr CreateCorDebugProcess()
         {
             string dbiFilePath = _runtime.GetDbiFilePath();
-            string dacFilePath = _runtime.GetDacFilePath(out bool verifySignature);
-            if (dbiFilePath == null || dacFilePath == null)
+            if (dbiFilePath == null)
             {
-                Trace.TraceError($"Could not find matching DBI {dbiFilePath ?? ""} or DAC {dacFilePath ?? ""} for this runtime: {_runtime.RuntimeModule.FileName}");
+                Trace.TraceError($"Could not find matching DBI {dbiFilePath ?? ""} for this runtime: {_runtime.RuntimeModule.FileName}");
                 return IntPtr.Zero;
             }
             if (_dbiHandle == IntPtr.Zero)
@@ -415,6 +414,16 @@ private IntPtr CreateCorDebugProcess()
             int hresult = 0;
             try
             {
+                // This will verify the DAC signature if needed before DBI is passed the DAC path or handle
+                IntPtr dacHandle = GetDacHandle();
+                if (dacHandle == IntPtr.Zero)
+                {
+                    return IntPtr.Zero;
+                }
+
+                // The DAC was verified in the GetDacHandle call above. Ignore the verifySignature parameter here.
+                string dacFilePath = _runtime.GetDacFilePath(out bool _);
+
                 OpenVirtualProcessImpl2Delegate openVirtualProcessImpl2 = SOSHost.GetDelegateFunction<OpenVirtualProcessImpl2Delegate>(_dbiHandle, "OpenVirtualProcessImpl2");
                 if (openVirtualProcessImpl2 != null)
                 {
@@ -436,12 +445,6 @@ private IntPtr CreateCorDebugProcess()
                     return corDebugProcess;
                 }
 
-                IntPtr dacHandle = GetDacHandle();
-                if (dacHandle == IntPtr.Zero)
-                {
-                    return IntPtr.Zero;
-                }
-
                 // On Linux/MacOS the DAC module handle needs to be re-created using the DAC PAL instance
                 // before being passed to DBI's OpenVirtualProcess* implementation. The DBI and DAC share
                 // the same PAL where dbgshim has it's own.