feat: implement machine-id provider for windows

Author: sigilioso

Cargo.lock

@@ -2473,13 +2473,6 @@ Distributed under the following license(s):
 * MIT
 * Apache-2.0
 
-## wasm-bindgen-backend <https://crates.io/crates/wasm-bindgen-backend>
-
-Distributed under the following license(s):
-
-* MIT
-* Apache-2.0
-
 ## wasm-bindgen-futures <https://crates.io/crates/wasm-bindgen-futures>
 
 Distributed under the following license(s):
@@ -2646,6 +2639,12 @@ Distributed under the following license(s):
 
 * MIT
 
+## winreg <https://crates.io/crates/winreg>
+
+Distributed under the following license(s):
+
+* MIT
+
 ## wit-bindgen <https://crates.io/crates/wit-bindgen>
 
 Distributed under the following license(s):

THIRD_PARTY_NOTICES.md

@@ -17,7 +17,10 @@ serde_json = { workspace = true }
 http = { workspace = true }
 fs = { path = "../fs" }
 konst = { workspace = true }
+
+[target.'cfg(windows)'.dependencies]
 windows-link = "0.2.1"
+winreg = "0.55"
 
 [dev-dependencies]
 assert_matches = { workspace = true }

resource-detection/Cargo.toml

@@ -2,7 +2,7 @@
 pub mod detector;
 /// hostname retriever
 pub mod hostname;
-mod identifier_machine_id_unix;
+mod machine_identifier;
 
 /// HOSTNAME_KEY represents the hostname key attribute
 pub const HOSTNAME_KEY: &str = "hostname";

resource-detection/src/system.rs

@@ -1,10 +1,8 @@
 //! System resource detector implementation
-use super::{
-    HOSTNAME_KEY, MACHINE_ID_KEY, identifier_machine_id_unix::IdentifierProviderMachineId,
-};
+use super::{HOSTNAME_KEY, MACHINE_ID_KEY};
 use crate::system::hostname::get_hostname;
+use crate::system::machine_identifier::MachineIdentityProvider;
 use crate::{DetectError, Detector, Key, Resource, Value};
-use fs::LocalFile;
 use tracing::{error, instrument};
 
 /// An enumeration of potential errors related to the system detector.
@@ -19,19 +17,15 @@ pub enum SystemDetectorError {
 }
 
 /// The `SystemDetector` struct encapsulates system detection functionality.
-///
-/// # Fields:
-/// - `hostname_getter`: An instance of the `HostnameGetter` struct for retrieving system hostname.
-/// - `machine_id_provider`: An instance of the `IdentifierProviderMachineId` struct for retrieving machine ID.
 pub struct SystemDetector {
-    machine_id_provider: IdentifierProviderMachineId<LocalFile>,
+    machine_id_provider: MachineIdentityProvider,
 }
 
 /// Default implementation for `SystemDetector` struct.
 impl Default for SystemDetector {
     fn default() -> Self {
         Self {
-            machine_id_provider: IdentifierProviderMachineId::default(),
+            machine_id_provider: MachineIdentityProvider::default(),
         }
     }
 }

resource-detection/src/system/detector.rs

@@ -0,0 +1,9 @@
+#[cfg(unix)]
+mod unix;
+#[cfg(windows)]
+mod windows;
+
+#[cfg(unix)]
+pub(crate) use unix::MachineIdentityProvider;
+#[cfg(windows)]
+pub(crate) use windows::MachineIdentityProvider;

resource-detection/src/system/machine_identifier.rs

@@ -1,11 +1,9 @@
 use std::path::{Path, PathBuf};
 
-use fs::{
-    LocalFile,
-    file_reader::{FileReader, FileReaderError},
-};
+use fs::LocalFile;
+use fs::file_reader::{FileReader, FileReaderError};
 
-use super::detector::SystemDetectorError;
+use crate::system::detector::SystemDetectorError;
 
 const MACHINE_ID_PATH: &str =
     konst::option::unwrap_or!(option_env!("TEST_MACHINE_ID_PATH"), "/etc/machine-id");
@@ -15,29 +13,29 @@ const DBUS_MACHINE_ID_PATH: &str = konst::option::unwrap_or!(
     "/var/lib/dbus/machine-id"
 );
 
-pub(super) struct IdentifierProviderMachineId<F> {
+pub struct MachineIdentityProvider<F = LocalFile> {
     machine_id_path: PathBuf,
     dbus_machine_id_path: PathBuf,
     file_reader: F,
 }
 
-impl<F> IdentifierProviderMachineId<F>
+impl<F> MachineIdentityProvider<F>
 where
     F: FileReader,
 {
     fn read_content(&self, file_path: &Path) -> Result<String, FileReaderError> {
         self.file_reader.read(file_path)
     }
 
-    pub(super) fn provide(&self) -> Result<String, SystemDetectorError> {
+    pub fn provide(&self) -> Result<String, SystemDetectorError> {
         self.read_content(self.machine_id_path.as_path())
             .or_else(|_| self.read_content(self.dbus_machine_id_path.as_path()))
             .map(|s: String| s.trim().to_string())
             .map_err(|e| SystemDetectorError::MachineIDError(e.to_string()))
     }
 }
 
-impl Default for IdentifierProviderMachineId<LocalFile> {
+impl Default for MachineIdentityProvider<LocalFile> {
     fn default() -> Self {
         Self {
             machine_id_path: PathBuf::from(MACHINE_ID_PATH),
@@ -56,7 +54,7 @@ mod tests {
     type MachineIDPath = Path;
     type DBusMachineIDPath = Path;
 
-    impl<F> IdentifierProviderMachineId<F>
+    impl<F> MachineIdentityProvider<F>
     where
         F: FileReader,
     {
@@ -82,8 +80,7 @@ mod tests {
 
         file_reader.should_read(path.as_path(), expected_machine_id.clone());
 
-        let provider =
-            IdentifierProviderMachineId::new(path.as_path(), path.as_path(), file_reader);
+        let provider = MachineIdentityProvider::new(path.as_path(), path.as_path(), file_reader);
 
         let machine_id = provider.provide().unwrap();
         assert_eq!(expected_machine_id, machine_id);
@@ -103,7 +100,7 @@ mod tests {
         );
         file_reader.should_read(dbus_machine_id_path.as_path(), expected_machine_id.clone());
 
-        let provider = IdentifierProviderMachineId::new(
+        let provider = MachineIdentityProvider::new(
             machine_id_path.as_path(),
             dbus_machine_id_path.as_path(),
             file_reader,
@@ -124,8 +121,7 @@ mod tests {
         file_reader
             .should_not_read_file_not_found(path.as_path(), String::from("some error message"));
 
-        let provider =
-            IdentifierProviderMachineId::new(path.as_path(), path.as_path(), file_reader);
+        let provider = MachineIdentityProvider::new(path.as_path(), path.as_path(), file_reader);
 
         let result = provider.provide();
         assert!(result.is_err());

…src/system/identifier_machine_id_unix.rs …on/src/system/machine_identifier/unix.rsresource-detection/src/system/identifier_machine_id_unix.rs renamed to resource-detection/src/system/machine_identifier/unix.rs resource-detection/src/system/identifier_machine_id_unix.rs renamed to resource-detection/src/system/machine_identifier/unix.rs

@@ -0,0 +1,39 @@
+use crate::system::detector::SystemDetectorError;
+use winreg::{
+    RegKey,
+    enums::{HKEY_LOCAL_MACHINE, KEY_READ},
+};
+
+const CRYPTOGRAPHY_KEY_PATH: &str = "SOFTWARE\\Microsoft\\Cryptography";
+const MACHINE_GUID_KEY_NAME: &str = "MachineGuid";
+
+#[derive(Default)]
+pub struct MachineIdentityProvider {}
+
+impl MachineIdentityProvider {
+    /// Reads the _MachineGuid_ from the Windows registry using [winreg].
+    pub fn provide(&self) -> Result<String, SystemDetectorError> {
+        let hklm = RegKey::predef(HKEY_LOCAL_MACHINE); // Open the local machine root key.
+        // Open the Cryptography reg key with read permissions
+        let cryptography_key = hklm
+            .open_subkey_with_flags(CRYPTOGRAPHY_KEY_PATH, KEY_READ)
+            .map_err(|err| SystemDetectorError::MachineIDError(err.to_string()))?;
+        // Get the value from the registry
+        cryptography_key
+            .get_value(MACHINE_GUID_KEY_NAME)
+            .map_err(|err| SystemDetectorError::MachineIDError(err.to_string()))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_windows_machine_guid() {
+        let machine_guid = MachineIdentityProvider::default()
+            .provide()
+            .unwrap_or_else(|err| panic!("Unexpected error obtaining Windows MachineGuid: {err}"));
+        assert!(!machine_guid.is_empty())
+    }
+}