WMI

https://docs.rs/crate/wmi/latest
Admin
A Rust crate for interacting with WMI (Windows Management Instrumentation) to query system...
Tokens:4,400
Snippets:60
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install WMI Crate

Source: https://docs.rs/crate/wmi/latest

Add the wmi crate to your Cargo.toml file to include WMI functionality in your Rust project.

```toml
[dependencies]

wmi = "0.18"

```

--------------------------------

### Basic WMI Query and Deserialization

Source: https://docs.rs/crate/wmi/latest/source/README.md

Demonstrates how to establish a WMI connection, execute a raw query returning a HashMap, and a structured query deserializing results into a specific struct. Ensure the `wmi` crate is added to your Cargo.toml.

```rust
#![allow(non_camel_case_types)]

#![allow(non_snake_case)]


use serde::Deserialize;
use wmi::{Variant, WMIConnection, WMIDateTime};
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let wmi_con = WMIConnection::new()?;

    let results: Vec<HashMap<String, Variant>> = wmi_con.raw_query("SELECT * FROM Win32_OperatingSystem")?;

    for os in results {
        println!("{:#?}", os);
    }

    #[derive(Deserialize, Debug)]
    struct Win32_OperatingSystem {
        Caption: String,
        Name: String,
        CurrentTimeZone: i16,
        Debug: bool,
        EncryptionLevel: u32,
        ForegroundApplicationBoost: u8,
        LastBootUpTime: WMIDateTime,
    }

    let results: Vec<Win32_OperatingSystem> = wmi_con.query()?;

    for os in results {
        println!("{:#?}", os);
    }

    Ok(())
}
```

--------------------------------

### Query WMI Data with Rust

Source: https://docs.rs/crate/wmi/latest

Demonstrates how to connect to WMI, perform a raw query, and deserialize results into a HashMap or a custom struct. Requires `serde` for deserialization.

```rust
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

use serde::Deserialize;
use wmi::{Variant, WMIConnection, WMIDateTime};
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let wmi_con = WMIConnection::new()?;

    let results: Vec<HashMap<String, Variant>> = wmi_con.raw_query("SELECT * FROM Win32_OperatingSystem")?;

    for os in results {
        println!("{:#?}", os);
    }

    #[derive(Deserialize, Debug)]
    struct Win32_OperatingSystem {
        Caption: String,
        Name: String,
        CurrentTimeZone: i16,
        Debug: bool,
        EncryptionLevel: u32,
        ForegroundApplicationBoost: u8,
        LastBootUpTime: WMIDateTime,
    }

    let results: Vec<Win32_OperatingSystem> = wmi_con.query()?;

    for os in results {
        println!("{:#?}", os);
    }

    Ok(())
}

```

--------------------------------

### Execute Async WMI Query

Source: https://docs.rs/crate/wmi/latest

Demonstrates how to execute an asynchronous WMI query for operating system information and then query for specific OS details using deserialization. Requires the `futures` crate for `block_on`.

```rust
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

use serde::Deserialize;
use wmi::{Variant, WMIConnection, WMIDateTime};
use std::collections::HashMap;
use futures::executor::block_on;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let wmi_con = WMIConnection::new()?;

    block_on(exec_async_query(&wmi_con)?);

    Ok(())
}

async fn exec_async_query(wmi_con: &WMIConnection) -> Result<(), Box<dyn std::error::Error>> {
    let results: Vec<HashMap<String, Variant>> =
        wmi_con.async_raw_query("SELECT * FROM Win32_OperatingSystem").await?;

    for os in results {
        println!("{:#?}", os);
    }

    #[derive(Deserialize, Debug)]
    struct Win32_OperatingSystem {
        Caption: String,
        Name: String,
        CurrentTimeZone: i16,
        Debug: bool,
        EncryptionLevel: u32,
        ForegroundApplicationBoost: u8,
        LastBootUpTime: WMIDateTime,
    }

    let results: Vec<Win32_OperatingSystem> = wmi_con.async_query().await?;

    for os in results {
        println!("{:#?}", os);
    }

    Ok(())
}

```

--------------------------------

### Async WMI Query and Deserialization

Source: https://docs.rs/crate/wmi/latest/source/README.md

Shows how to perform asynchronous WMI queries using `async_raw_query` and `async_query`. This requires the `futures` crate for `block_on`. The results can be deserialized into HashMaps or specific structs.

```rust
#![allow(non_camel_case_types)]

#![allow(non_snake_case)]


use serde::Deserialize;
use wmi::{Variant, WMIConnection, WMIDateTime};
use std::collections::HashMap;
use futures::executor::block_on;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let wmi_con = WMIConnection::new()?;

    block_on(exec_async_query(&wmi_con))?;

    Ok(())
}

async fn exec_async_query(wmi_con: &WMIConnection) -> Result<(), Box<dyn std::error::Error>> {
    let results: Vec<HashMap<String, Variant>> = 
        wmi_con.async_raw_query("SELECT * FROM Win32_OperatingSystem").await?;

    for os in results {
        println!("{:#?}", os);
    }

    #[derive(Deserialize, Debug)]
    struct Win32_OperatingSystem {
        Caption: String,
        Name: String,
        CurrentTimeZone: i16,
        Debug: bool,
        EncryptionLevel: u32,
        ForegroundApplicationBoost: u8,
        LastBootUpTime: WMIDateTime,
    }

    let results: Vec<Win32_OperatingSystem> = wmi_con.async_query().await?;

    for os in results {
        println!("{:#?}", os);
    }

    Ok(())
}
```

--------------------------------

### Configure WMI Crate for `time` Crate Usage

Source: https://docs.rs/crate/wmi/latest

To use the `time` crate instead of `chrono` for date/time handling in WMI queries, modify your Cargo.toml and use `WMIOffsetDateTime`.

```toml
[dependencies]

wmi-rs = { version = "*", default-features = false, features = ["time"] }

```

--------------------------------

### Set Custom Authentication Level for WMI

Source: https://docs.rs/crate/wmi/latest/source/README.md

Connect to a WMI namespace requiring specific authentication, such as packet privacy for BitLocker data. Requires administrator privileges.

```rust
use wmi::{AuthLevel, WMIConnection};
use serde::Deserialize;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to BitLocker namespace with packet privacy authentication
    let wmi_con = WMIConnection::with_namespace_path(
        "ROOT\\CIMV2\\Security\\MicrosoftVolumeEncryption"
    )?;
    wmi_con.set_proxy_blanket(AuthLevel::PktPrivacy)?;

    #[derive(Deserialize, Debug)]
    #[serde(rename = "Win32_EncryptableVolume")]
    #[serde(rename_all = "PascalCase")]
    struct EncryptableVolume {
        device_id: String,
        drive_letter: Option<String>,
        protection_status: Option<u32>,  // 0=Unprotected, 1=Protected, 2=Unknown
    }

    let volumes: Vec<EncryptableVolume> = wmi_con.query()?;

    for volume in volumes {
        println!("Drive: {:?}, Protection: {:?}", volume.drive_letter, volume.protection_status);
    }

    Ok(())
}
```

--------------------------------

### Set Custom Authentication Level for WMI

Source: https://docs.rs/crate/wmi/latest

Connects to a specific WMI namespace (BitLocker) and sets the authentication level to Packet Privacy to protect sensitive data. Requires administrator privileges.

```rust
use wmi::{AuthLevel, WMIConnection};
use serde::Deserialize;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to BitLocker namespace with packet privacy authentication
    let wmi_con = WMIConnection::with_namespace_path(
        "ROOT\CIMV2\Security\MicrosoftVolumeEncryption"
    )?;
    wmi_con.set_proxy_blanket(AuthLevel::PktPrivacy)?;

    #[derive(Deserialize, Debug)]
    #[serde(rename = "Win32_EncryptableVolume")]
    #[serde(rename_all = "PascalCase")]
    struct EncryptableVolume {
        device_id: String,
        drive_letter: Option<String>,
        protection_status: Option<u32>,  // 0=Unprotected, 1=Protected, 2=Unknown
    }

    let volumes: Vec<EncryptableVolume> = wmi_con.query()?;

    for volume in volumes {
        println!("Drive: {:?}, Protection: {:?}", volume.drive_letter, volume.protection_status);
    }

    Ok(())
}

```

--------------------------------

### VCS Information JSON

Source: https://docs.rs/crate/wmi/latest/source/.cargo_vcs_info.json

This JSON object contains version control system information, specifically the Git commit SHA and the path of the file within the VCS. It is typically found in .cargo_vcs_info.json.

```json
{
  "git": {
    "sha1": "90dad22895ce91691470d15952f40cef87b4d856"
  },
  "path_in_vcs": ""
}
```

--------------------------------

### Ignore Generated Files in .gitignore

Source: https://docs.rs/crate/wmi/latest/source/.gitignore

This snippet shows common entries for a .gitignore file in a Rust project to exclude generated files and IDE configurations.

```gitignore
# Generated by Cargo
# will have compiled files and executables
/target/


# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
Cargo.lock


# These are backup files generated by rustfmt
**/*.rs.bk

.idea


# vscode ide
.vscode
```
Tokens:
Raw