windows-erg 0.1.0

Ergonomic, idiomatic Rust wrappers for Windows APIs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Security descriptor domain model.

use super::{Dacl, Sid};

/// Resource target represented by a security descriptor.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SecurityTarget {
    /// File or directory path.
    FilePath(String),
    /// Registry key path.
    RegistryPath(String),
    /// In-memory descriptor with no external binding.
    Detached,
}

/// Security descriptor model containing owner/group and DACL.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SecurityDescriptor {
    target: SecurityTarget,
    owner: Option<Sid>,
    group: Option<Sid>,
    dacl: Dacl,
}

impl SecurityDescriptor {
    /// Create a detached descriptor with empty DACL.
    pub fn new() -> Self {
        Self {
            target: SecurityTarget::Detached,
            owner: None,
            group: None,
            dacl: Dacl::new(),
        }
    }

    /// Create descriptor bound to a file path.
    pub fn for_file_path(path: impl Into<String>) -> Self {
        Self {
            target: SecurityTarget::FilePath(path.into()),
            owner: None,
            group: None,
            dacl: Dacl::new(),
        }
    }

    /// Create descriptor bound to a registry path.
    pub fn for_registry_path(path: impl Into<String>) -> Self {
        Self {
            target: SecurityTarget::RegistryPath(path.into()),
            owner: None,
            group: None,
            dacl: Dacl::new(),
        }
    }

    /// Set owner SID.
    pub fn with_owner(mut self, owner: Sid) -> Self {
        self.owner = Some(owner);
        self
    }

    /// Set group SID.
    pub fn with_group(mut self, group: Sid) -> Self {
        self.group = Some(group);
        self
    }

    /// Set DACL.
    pub fn with_dacl(mut self, dacl: Dacl) -> Self {
        self.dacl = dacl;
        self
    }

    /// Returns target information.
    pub fn target(&self) -> &SecurityTarget {
        &self.target
    }

    /// Returns owner SID if present.
    pub fn owner(&self) -> Option<&Sid> {
        self.owner.as_ref()
    }

    /// Returns group SID if present.
    pub fn group(&self) -> Option<&Sid> {
        self.group.as_ref()
    }

    /// Returns descriptor DACL.
    pub fn dacl(&self) -> &Dacl {
        &self.dacl
    }

    /// Returns mutable descriptor DACL.
    pub fn dacl_mut(&mut self) -> &mut Dacl {
        &mut self.dacl
    }
}

impl Default for SecurityDescriptor {
    fn default() -> Self {
        Self::new()
    }
}