wmi: Add INF file parsing for boot-only drivers

Parse driver versions from INF files in the Windows driver store for
drivers that are not loaded at runtime (like AMD DRTM). This allows
detection of boot-only drivers that don't appear via WMI.

Changes:
- Add inf_drivers section to drivers.toml for INF-based detection
- Add find_inf_driver_version() to scan driver store directories
- Add parse_inf_version() with UTF-8 and UTF-16 LE support
- Fix clippy warnings in chromium_ec and esrt modules

Detects: AMD DRTM Driver, Realtek MEP Opt-in Driver

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: JohnAZoidberg

framework_lib/src/chromium_ec/mod.rs

@@ -227,6 +227,7 @@ impl Default for CrosEc {
 /// Find out which drivers are available
 ///
 /// Depending on the availability we choose the first one as default
+#[allow(clippy::vec_init_then_push)]
 fn available_drivers() -> Vec<CrosEcDriverType> {
     let mut drivers = vec![];
 

framework_lib/src/drivers.toml

@@ -69,3 +69,11 @@ GeneStor = "Framework SD Expansion Card"
 # MediaTek WiFi Drivers
 mtkwlex = "RZ616 WiFi Driver"
 mtkwecx = "RZ717 WiFi Driver"
+
+# INF Drivers - detected via driver store INF file parsing
+# These are boot-only drivers not visible via WMI at runtime
+# Format: inf_name (without .inf) = "display_alias"
+
+[inf_drivers]
+amddrtm = "AMD DRTM Driver"
+rtextfw = "Realtek MEP Opt-in Driver"

framework_lib/src/esrt/mod.rs

@@ -438,7 +438,7 @@ pub fn get_esrt() -> Option<Esrt> {
         let short_guid = guid.trim_matches(|c| c == '{' || c == '}');
         let esrt_entry = esrt.open_subkey(&guid).ok()?;
         let esrt = EsrtResourceEntry {
-            fw_class: GUID::parse(&short_guid).ok()?.into(),
+            fw_class: GUID::parse(short_guid).ok()?.into(),
             fw_type: esrt_entry.get_value("Type").ok()?,
             fw_version: esrt_entry.get_value("Version").ok()?,
             lowest_supported_fw_version: esrt_entry.get_value("LowestSupportedVersion").ok()?,

framework_lib/src/wmi.rs

@@ -1,6 +1,8 @@
 use crate::util::Platform;
 use serde::Deserialize;
 use std::collections::HashMap;
+use std::fs;
+use std::path::Path;
 use wmi::*;
 
 /// Driver configuration loaded from TOML
@@ -9,6 +11,8 @@ struct DriversConfig {
     pnp_drivers: HashMap<String, String>,
     products: HashMap<String, String>,
     system_drivers: HashMap<String, String>,
+    #[serde(default)]
+    inf_drivers: HashMap<String, String>,
 }
 
 /// Platform-specific baseline configuration
@@ -47,6 +51,93 @@ fn load_baseline_for_platform(platform: &Platform) -> BaselineConfig {
     toml::from_str(config_str).unwrap_or_default()
 }
 
+const DRIVER_STORE_PATH: &str = r"C:\Windows\System32\DriverStore\FileRepository";
+
+/// Find driver INF file in the driver store and extract version
+fn find_inf_driver_version(inf_name: &str) -> Option<String> {
+    let driver_store = Path::new(DRIVER_STORE_PATH);
+    if !driver_store.exists() {
+        return None;
+    }
+
+    // Look for directories matching the INF name pattern (e.g., amddrtm.inf_amd64_*)
+    let pattern = format!("{}.inf_", inf_name);
+    let mut best_match: Option<(String, std::time::SystemTime)> = None;
+
+    if let Ok(entries) = fs::read_dir(driver_store) {
+        for entry in entries.flatten() {
+            if let Ok(name) = entry.file_name().into_string() {
+                if name.starts_with(&pattern) {
+                    // Only consider directories, not files like .ini
+                    if let Ok(metadata) = entry.metadata() {
+                        if !metadata.is_dir() {
+                            continue;
+                        }
+                        // Get the modification time to find the newest version
+                        if let Ok(modified) = metadata.modified() {
+                            let should_update = match &best_match {
+                                None => true,
+                                Some((_, prev_time)) => modified > *prev_time,
+                            };
+                            if should_update {
+                                best_match =
+                                    Some((entry.path().to_string_lossy().to_string(), modified));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // If we found a matching directory, read the INF file and extract version
+    if let Some((dir_path, _)) = best_match {
+        let inf_file = Path::new(&dir_path).join(format!("{}.inf", inf_name));
+        if inf_file.exists() {
+            return parse_inf_version(&inf_file);
+        }
+    }
+
+    None
+}
+
+/// Parse INF file and extract DriverVer version number
+fn parse_inf_version(inf_path: &Path) -> Option<String> {
+    // Try reading as UTF-8 first, then as UTF-16 LE (common for Windows INF files)
+    let content = match fs::read_to_string(inf_path) {
+        Ok(c) => c,
+        Err(_) => {
+            // Try reading as UTF-16 LE
+            let bytes = fs::read(inf_path).ok()?;
+            // Skip BOM if present and convert UTF-16 LE to String
+            let start = if bytes.len() >= 2 && bytes[0] == 0xFF && bytes[1] == 0xFE {
+                2
+            } else {
+                0
+            };
+            let u16_chars: Vec<u16> = bytes[start..]
+                .chunks_exact(2)
+                .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
+                .collect();
+            String::from_utf16(&u16_chars).ok()?
+        }
+    };
+
+    // Look for DriverVer line, e.g.: DriverVer = 11/11/2024,1.0.18.4
+    for line in content.lines() {
+        let trimmed = line.trim();
+        if trimmed.to_lowercase().starts_with("driverver") {
+            // Extract version after the comma
+            if let Some(comma_pos) = trimmed.find(',') {
+                let version = trimmed[comma_pos + 1..].trim();
+                return Some(version.to_string());
+            }
+        }
+    }
+
+    None
+}
+
 /// Collected driver information for baseline updates
 #[derive(Debug, Default)]
 pub struct DetectedDrivers {
@@ -257,6 +348,14 @@ pub fn print_drivers_with_baseline(platform: Option<&Platform>) {
             print_version_with_baseline(&version, alias, &baseline);
         }
     }
+
+    // INF Drivers (boot-only drivers from driver store)
+    for (inf_name, alias) in &config.inf_drivers {
+        if let Some(version) = find_inf_driver_version(inf_name) {
+            println!("  {}", alias);
+            print_version_with_baseline(&version, alias, &baseline);
+        }
+    }
 }
 
 /// Print version with baseline comparison
@@ -362,5 +461,12 @@ pub fn collect_drivers() -> DetectedDrivers {
         }
     }
 
+    // INF Drivers (boot-only drivers from driver store)
+    for (inf_name, alias) in &config.inf_drivers {
+        if let Some(version) = find_inf_driver_version(inf_name) {
+            detected.drivers.insert(alias.clone(), version);
+        }
+    }
+
     detected
 }