Windex.cs

// Copyright ©2026 Gatongone
// Author: Gatongone
// Email: gatongone@gmail.com
// Created On: 2026/01/23-11:09:10
// Github: https://github.com/Gatongone

using System.Collections.Concurrent;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO.Compression;
using System.Management;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Encodings.Web;
using System.Text.Json;

/// <summary>
/// Provides helpers to export and locate Windows drivers using WMI, pnputil and SetupDi APIs.
/// Contains interop definitions and utility methods used by the command-line tool.
/// </summary>
internal static class Windex
{
    #region Windows API

    /// <summary>
    /// Retrieves a device information set that contains requested device information elements for a local computer.
    /// </summary>
    /// <param name="classGuid">Reference to a device setup class GUID. Pass <see cref="Guid.Empty"/> to include all classes.</param>
    /// <param name="enumerator">Optional device instance identifier string or null.</param>
    /// <param name="hwndParent">Handle to a top-level window to be used for any user interface that is associated with installing a device instance.</param>
    /// <param name="flags">Flags that specify what types of device information elements to include.</param>
    /// <returns>Handle to the device information set. Returns <see cref="IntPtr.Zero"/> or <c>new IntPtr(-1)</c> on failure.</returns>
    [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
    private static extern IntPtr SetupDiGetClassDevs(
        ref Guid classGuid,
        string enumerator,
        IntPtr hwndParent,
        uint flags);

    /// <summary>
    /// Enumerates the device information elements in a device information set.
    /// </summary>
    /// <param name="deviceInfoSet">Handle to the device information set returned by <see cref="SetupDiGetClassDevs"/>.</param>
    /// <param name="memberIndex">Zero-based index of the member to retrieve.</param>
    /// <param name="deviceInfoData">Receives information about the enumerated device.</param>
    /// <returns><c>true</c> if the function succeeds; otherwise <c>false</c>.</returns>
    [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
    private static extern bool SetupDiEnumDeviceInfo(
        IntPtr deviceInfoSet,
        uint memberIndex,
        ref SP_DEVINFO_DATA deviceInfoData);

    /// <summary>
    /// Retrieves the device instance ID for a device information element.
    /// </summary>
    /// <param name="deviceInfoSet">Handle to the device information set.</param>
    /// <param name="deviceInfoData">Device information element.</param>
    /// <param name="deviceInstanceId">StringBuilder to receive the device instance ID.</param>
    /// <param name="deviceInstanceIdSize">Size of the buffer in characters.</param>
    /// <param name="requiredSize">Receives the number of characters required to hold the full device instance ID.</param>
    /// <returns><c>true</c> if successful; otherwise <c>false</c>.</returns>
    [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
    private static extern bool SetupDiGetDeviceInstanceId(
        IntPtr deviceInfoSet,
        ref SP_DEVINFO_DATA deviceInfoData,
        StringBuilder deviceInstanceId,
        int deviceInstanceIdSize,
        out int requiredSize);

    /// <summary>
    /// Retrieves a specified Plug and Play device property.
    /// </summary>
    /// <param name="deviceInfoSet">Handle to the device information set.</param>
    /// <param name="deviceInfoData">Device information element.</param>
    /// <param name="property">Property identifier (for example <c>SPDRP_DRIVER</c>).</param>
    /// <param name="propertyRegDataType">Receives the registry data type of the property.</param>
    /// <param name="propertyBuffer">Buffer to receive property data.</param>
    /// <param name="propertyBufferSize">Size of the buffer in bytes.</param>
    /// <param name="requiredSize">Receives the number of bytes required to store the property.</param>
    /// <returns><c>true</c> on success; otherwise <c>false</c>.</returns>
    [DllImport("setupapi.dll", CharSet = CharSet.Auto)]
    private static extern bool SetupDiGetDeviceRegistryProperty(
        IntPtr deviceInfoSet,
        ref SP_DEVINFO_DATA deviceInfoData,
        uint property,
        out uint propertyRegDataType,
        byte[] propertyBuffer,
        uint propertyBufferSize,
        out uint requiredSize);

    /// <summary>
    /// Destroys a device information set and frees associated memory.
    /// </summary>
    /// <param name="deviceInfoSet">Handle to the device information set to destroy.</param>
    /// <returns><c>true</c> on success; otherwise <c>false</c>.</returns>
    [DllImport("setupapi.dll")]
    private static extern bool SetupDiDestroyDeviceInfoList(IntPtr deviceInfoSet);

    /// <summary>
    /// Represents the native SP_DEVINFO_DATA structure used by SetupAPI calls.
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    private struct SP_DEVINFO_DATA
    {
        public uint   cbSize;
        public Guid   classGuid;
        public uint   devInst;
        public IntPtr reserved;
    }

    /// <summary>Flag: Return only devices that are present.</summary>
    private const uint DIGCF_PRESENT = 0x00000002;

    /// <summary>Flag: Return devices for all classes.</summary>
    private const uint DIGCF_ALLCLASSES = 0x00000004;

    /// <summary>Property: Driver registry property identifier for SetupAPI.</summary>
    private const uint SPDRP_DRIVER = 0x00000009;

    /// <summary>Property: Hardware ID registry property identifier for SetupAPI.</summary>
    private const uint SPDRP_HARDWAREID = 0x00000001;

    /// <summary>Native error: insufficient buffer.</summary>
    private const uint ERROR_INSUFFICIENT_BUFFER = 122;

    /// <summary>Maximum device id length for buffer allocations.</summary>
    private const int MAX_DEVICE_ID_LEN = 200;

    #endregion

    /// <summary>
    /// Simple container for driver metadata used by export operations.
    /// </summary>
    private class DriverInfo
    {
        /// <summary>Device ID reported by WMI (DeviceID).</summary>
        public string DeviceId { get; set; }

        /// <summary>INF filename associated with the driver.</summary>
        public string InfName { get; set; }

        /// <summary>Driver version string if available.</summary>
        public string DriverVersion { get; set; }

        /// <summary>Driver date string if available.</summary>
        public string DriverDate { get; set; }
    }

    /// <summary>
    /// Exports complete driver files for a specific device by its Device ID.
    /// Tries multiple strategies in order: driver store lookup, pnputil export, then SetupDi enumeration.
    /// </summary>
    /// <param name="deviceId">Device instance ID of the target device.</param>
    /// <param name="outputPath">Directory to copy driver files to. Will be created if missing.</param>
    /// <param name="exportZip">When true, creates a zip archive from the exported folder and removes the folder.</param>
    /// <exception cref="ArgumentException">Thrown when <paramref name="deviceId"/> or <paramref name="outputPath"/> are null or empty.</exception>
    /// <exception cref="Exception">Thrown when all export methods fail or an unexpected error occurs.</exception>
    public static void ExportDriver(string deviceId, string outputPath, bool exportZip = false)
    {
        if (string.IsNullOrEmpty(deviceId))
            throw new ArgumentException("Device ID cannot be null or empty", nameof(deviceId));

        if (string.IsNullOrEmpty(outputPath))
            throw new ArgumentException("Output path cannot be null or empty", nameof(outputPath));

        // Clean up the output path
        outputPath = Path.GetFullPath(outputPath);
        if (!Directory.Exists(outputPath))
        {
            Directory.CreateDirectory(outputPath);
        }

        try
        {
            if (TryExportFromDriverStore(deviceId, outputPath) || // 1. Try to find driver in driver store using WMI
                TryExportWithPnPUtil(deviceId, outputPath) ||     // 2. Try using pnputil (most reliable)
                TryExportWithSetupDi(deviceId, outputPath))       // 3. Try using SetupDi API
            {
                if (exportZip)
                {
                    ZipFile.CreateFromDirectory(outputPath, $"{outputPath}.zip");
                    Directory.Delete(outputPath, true);
                }

                return;
            }

            throw new Exception("All export methods failed");
        }
        catch (Exception ex)
        {
            throw new Exception($"Failed to export driver for device {deviceId}: {ex.Message}", ex);
        }
    }

    /// <summary>
    /// Exports complete driver files for all signed drivers discovered on the system.
    /// Produces a per-device subfolder (and optional zip) and emits a JSON map file referencing exported archives.
    /// </summary>
    /// <param name="outputPath">Root directory where driver exports will be stored.</param>
    /// <param name="remoteUri">Optional base URI prefix used when writing the repository map.</param>
    /// <param name="exportZip">When true, each driver folder will be zipped and the folder removed.</param>
    [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>")]
    public static void ExportAllDriver(string outputPath, string remoteUri = "", bool exportZip = false)
    {
        if (string.IsNullOrEmpty(outputPath))
            throw new ArgumentException("Output path cannot be null or empty", nameof(outputPath));

        outputPath = Path.GetFullPath(outputPath);
        Directory.CreateDirectory(outputPath);

        try
        {
            var allDrivers = GetAllDriverInfos().ToArray();
            Console.WriteLine($"Found {allDrivers.Length} drivers to export");

            var successCount = 0;
            var failCount = 0;
            var map = new ConcurrentDictionary<string, string>();
            if (!string.IsNullOrEmpty(remoteUri) && !remoteUri.EndsWith('/'))
            {
                remoteUri += '/';
            }

            Parallel.For(0L, allDrivers.Length, index =>
            {
                var driver = allDrivers[index];
                try
                {
                    var deviceId = driver.DeviceId;
                    var safeDeviceId = SanitizeFileName(deviceId);
                    var driverOutputPath = Path.Combine(outputPath, safeDeviceId);
                    ExportDriver(deviceId, driverOutputPath, exportZip);
                    map.TryAdd(deviceId, $"{remoteUri}{safeDeviceId}{(exportZip ? ".zip" : "")}");
                    Interlocked.Increment(ref successCount);
                    Console.WriteLine($"Exported: {driverOutputPath}{(exportZip ? ".zip" : "")}");
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine($"Failed to export driver for {driver.DeviceId}: {ex.Message}");
                    Interlocked.Increment(ref failCount);
                }
            });
            var repoConfigs = Path.Combine(outputPath, "driver_repo.json");
            if (File.Exists(repoConfigs))
            {
                File.Create(repoConfigs).Dispose();
            }
            else
            {
                File.Delete(repoConfigs);
                File.Create(repoConfigs).Dispose();
            }

            File.AppendAllText(repoConfigs, JsonSerializer.Serialize(map, new JsonSerializerOptions
            {
                WriteIndented = true,
                Encoder       = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
            }));
            Console.WriteLine($"Remote repo: {repoConfigs}");
            Console.WriteLine($"Export completed: {successCount} successful, {failCount} failed");
        }
        catch (Exception ex)
        {
            throw new Exception($"Failed to export all drivers: {ex.Message}", ex);
        }
    }

    #region Private Helper Methods

    /// <summary>
    /// Returns a file-system safe name by replacing invalid filename characters with underscores.
    /// </summary>
    /// <param name="name">Original file or folder name to sanitize.</param>
    /// <returns>Sanitized string safe for use as a filename.</returns>
    private static string SanitizeFileName(string name) => string.Join("_", name.Split(Path.GetInvalidFileNameChars(), StringSplitOptions.RemoveEmptyEntries));

    /// <summary>
    /// Attempts to locate and copy driver files from the local Driver Store based on the device's INF name reported by WMI.
    /// </summary>
    /// <param name="deviceId">Device instance ID to look up.</param>
    /// <param name="outputPath">Destination folder to copy driver files into.</param>
    /// <returns><c>true</c> if driver files were found and copied; otherwise <c>false</c>.</returns>
    private static bool TryExportFromDriverStore(string deviceId, string outputPath)
    {
        try
        {
            // Get driver INF name from WMI
            var driverInfo = GetDriverInfoFromWmi(deviceId);
            if (driverInfo == null || string.IsNullOrEmpty(driverInfo.InfName))
                return false;

            // Search for driver in Driver Store
            var driverStorePath = FindDriverInDriverStore(driverInfo.InfName);
            if (!string.IsNullOrEmpty(driverStorePath) && Directory.Exists(driverStorePath))
            {
                CopyDirectory(driverStorePath, outputPath, true);
                return true;
            }

            return false;
        }
        catch
        {
            return false;
        }
    }

    private static bool TryExportWithPnPUtil(string deviceId, string outputPath)
    {
        try
        {
            // First, get the INF name
            var driverInfo = GetDriverInfoFromWmi(deviceId);
            if (driverInfo == null || string.IsNullOrEmpty(driverInfo.InfName))
                return false;

            var infName = driverInfo.InfName;

            // Run pnputil to export the driver
            var startInfo = new ProcessStartInfo
            {
                FileName               = "pnputil.exe",
                Arguments              = $"/export-driver \"{infName}\" \"{outputPath}\"",
                UseShellExecute        = false,
                CreateNoWindow         = true,
                RedirectStandardOutput = true,
                RedirectStandardError  = true,
                Verb                   = "runas" // Run as administrator
            };

            using var process = new Process {StartInfo = startInfo};
            process.Start();
            process.StandardOutput.ReadToEnd();
            process.StandardError.ReadToEnd();
            process.WaitForExit(30000); // 30 second timeout

            if (process.ExitCode == 0)
            {
                return true;
            }

            return false;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"PnPUtil method failed: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// Uses pnputil.exe to export driver files by INF name into the specified output folder.
    /// </summary>
    /// <param name="deviceId">Device instance ID to look up INF name via WMI.</param>
    /// <param name="outputPath">Destination folder for exported driver files.</param>
    /// <returns><c>true</c> if pnputil successfully exported the driver; otherwise <c>false</c>.</returns>
    /// <remarks>
    /// This method requires pnputil to be available and will attempt to run it elevated ("runas").
    /// It reads process output and returns success only if pnputil returns exit code 0.
    /// </remarks>
    private static bool TryExportWithSetupDi(string deviceId, string outputPath)
    {
        var deviceInfoSet = IntPtr.Zero;
        try
        {
            var nullGuid = Guid.Empty;
            deviceInfoSet = SetupDiGetClassDevs(ref nullGuid, null, IntPtr.Zero, DIGCF_ALLCLASSES | DIGCF_PRESENT);

            if (deviceInfoSet == IntPtr.Zero || deviceInfoSet == new IntPtr(-1))
                return false;

            var deviceInfoData = new SP_DEVINFO_DATA();
            deviceInfoData.cbSize = (uint) Marshal.SizeOf(typeof(SP_DEVINFO_DATA));

            uint deviceIndex = 0;
            while (SetupDiEnumDeviceInfo(deviceInfoSet, deviceIndex, ref deviceInfoData))
            {
                var instanceIdBuilder = new StringBuilder(MAX_DEVICE_ID_LEN);

                if (SetupDiGetDeviceInstanceId(deviceInfoSet, ref deviceInfoData, instanceIdBuilder,
                    instanceIdBuilder.Capacity, out _))
                {
                    var currentDeviceId = instanceIdBuilder.ToString();

                    if (currentDeviceId.Equals(deviceId, StringComparison.OrdinalIgnoreCase))
                    {
                        // Get driver INF path
                        var propertyBuffer = new byte[1024];

                        if (SetupDiGetDeviceRegistryProperty(deviceInfoSet, ref deviceInfoData,
                            SPDRP_DRIVER, out _, propertyBuffer,
                            (uint) propertyBuffer.Length, out _))
                        {
                            var driverPath = Encoding.Unicode.GetString(propertyBuffer).TrimEnd('\0');
                            if (!string.IsNullOrEmpty(driverPath))
                            {
                                // Extract INF name and find it
                                var infName = Path.GetFileName(driverPath);
                                var driverStorePath = FindDriverInDriverStore(infName);

                                if (!string.IsNullOrEmpty(driverStorePath))
                                {
                                    CopyDirectory(driverStorePath, outputPath, true);
                                    return true;
                                }
                            }
                        }
                    }
                }

                deviceIndex++;
            }

            return false;
        }
        catch
        {
            return false;
        }
        finally
        {
            if (deviceInfoSet != IntPtr.Zero)
                SetupDiDestroyDeviceInfoList(deviceInfoSet);
        }
    }

    /// <summary>
    /// Queries Win32_PnPSignedDriver via WMI and returns driver metadata for the specified device ID.
    /// </summary>
    /// <param name="deviceId">Device instance ID to query.</param>
    /// <returns>A <see cref="DriverInfo"/> object when found; otherwise <c>null</c>.</returns>
    private static DriverInfo? GetDriverInfoFromWmi(string deviceId)
    {
        using var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PnPSignedDriver");
        foreach (var o in searcher.Get())
        {
            var driver = (ManagementObject) o;
            var driverDeviceId = driver["DeviceID"]?.ToString();
            if (driverDeviceId != null &&
                driverDeviceId.Replace("\\", "").Equals(deviceId.Replace("\\", ""), StringComparison.OrdinalIgnoreCase))
            {
                return new DriverInfo
                {
                    DeviceId      = driverDeviceId,
                    InfName       = driver["InfName"]?.ToString(),
                    DriverVersion = driver["DriverVersion"]?.ToString(),
                    DriverDate    = driver["DriverDate"]?.ToString()
                };
            }
        }

        return null;
    }

    /// <summary>
    /// Retrieves a list of unique driver metadata entries for all signed drivers found via WMI.
    /// </summary>
    /// <returns>List of <see cref="DriverInfo"/> objects describing discovered drivers.</returns>
    private static List<DriverInfo> GetAllDriverInfos()
    {
        var drivers = new List<DriverInfo>();

        using var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_PnPSignedDriver");
        foreach (var driver in searcher.Get())
        {
            var deviceId = driver["DeviceID"]?.ToString();
            var infName = driver["InfName"]?.ToString();

            if (string.IsNullOrEmpty(deviceId) || string.IsNullOrEmpty(infName)) continue;
            // Check if we already have this INF (avoid duplicates for same driver)
            if (drivers.Any(d => d.InfName == infName)) continue;
            drivers.Add(new DriverInfo
            {
                DeviceId      = deviceId,
                InfName       = infName,
                DriverVersion = driver["DriverVersion"]?.ToString(),
                DriverDate    = driver["DriverDate"]?.ToString()
            });
        }

        return drivers;
    }

    /// <summary>
    /// Attempts to locate the folder in the local driver store that contains the given INF file.
    /// </summary>
    /// <param name="infName">INF file name (for example <c>oem0.inf</c>) or base name.</param>
    /// <returns>Local folder path when found; otherwise <c>null</c>.</returns>
    private static string? FindDriverInDriverStore(string infName)
    {
        if (string.IsNullOrEmpty(infName))
            return null;

        // Remove .inf extension if present for pattern matching
        var infBaseName = infName;
        if (infBaseName.EndsWith(".inf", StringComparison.OrdinalIgnoreCase))
            infBaseName = infBaseName.Substring(0, infBaseName.Length - 4);

        // Common Driver Store locations
        var driverStorePaths = new[]
        {
            Path.Combine(Environment.SystemDirectory, "DriverStore", "FileRepository"),
            @"C:\Windows\System32\DriverStore\FileRepository",
            @"C:\Windows\INF",
            Environment.SystemDirectory
        };

        foreach (var basePath in driverStorePaths)
        {
            if (!Directory.Exists(basePath))
                continue;

            try
            {
                // Search for folders matching the pattern
                var directories = Directory.GetDirectories(basePath, "*", SearchOption.AllDirectories);

                foreach (var dir in directories)
                {
                    // Check if directory contains the INF file
                    var infFiles = Directory.GetFiles(dir, "*.inf", SearchOption.TopDirectoryOnly);
                    foreach (var infFile in infFiles)
                    {
                        var fileName = Path.GetFileName(infFile);
                        if (fileName.Equals(infName, StringComparison.OrdinalIgnoreCase) ||
                            fileName.StartsWith(infBaseName + ".inf", StringComparison.OrdinalIgnoreCase))
                        {
                            return dir;
                        }
                    }

                    // Also check directory name pattern
                    var dirName = Path.GetFileName(dir);
                    if (dirName.StartsWith(infBaseName + ".inf_", StringComparison.OrdinalIgnoreCase) ||
                        dirName.Contains(infBaseName))
                    {
                        return dir;
                    }
                }
            }
            catch (UnauthorizedAccessException)
            {
                // Skip directories we can't access
            }
        }

        return null;
    }

    /// <summary>
    /// Copies the contents of a directory to a target location, optionally recursing into subdirectories.
    /// Errors copying individual files are reported to console but do not abort the operation.
    /// </summary>
    /// <param name="sourceDir">Source directory path.</param>
    /// <param name="destDir">Destination directory path. Will be created if missing.</param>
    /// <param name="copySubDirs">If <c>true</c> the copy operation will recurse into subdirectories.</param>
    /// <exception cref="DirectoryNotFoundException">Thrown when the <paramref name="sourceDir"/> does not exist.</exception>
    private static void CopyDirectory(string sourceDir, string destDir, bool copySubDirs)
    {
        var dir = new DirectoryInfo(sourceDir);

        if (!dir.Exists)
            throw new DirectoryNotFoundException($"Source directory does not exist: {dir.FullName}");

        var dirs = dir.GetDirectories();

        // Create the destination directory if it doesn't exist
        Directory.CreateDirectory(destDir);

        // Get the files in the directory and copy them
        var files = dir.GetFiles();
        foreach (var file in files)
        {
            var tempPath = Path.Combine(destDir, file.Name);
            try
            {
                file.CopyTo(tempPath, true);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Warning: Could not copy {file.FullName}: {ex.Message}");
            }
        }

        // Copy subdirectories if specified
        if (copySubDirs)
        {
            foreach (var subDir in dirs)
            {
                var tempPath = Path.Combine(destDir, subDir.Name);
                CopyDirectory(subDir.FullName, tempPath, copySubDirs);
            }
        }
    }

    #endregion
}