rustilege 0.5.1

Rust library allowing you to recover current privileges under Windows and Linux
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#[cfg(target_os = "windows")]
pub struct Rustilege;

pub enum IntegrityLevel {
    System = 0x00004000,
    Administrator = 0x00003000,
    User = 0x00002000,
    Low = 0x00001000,
    Guest = 0x00000000,
    Error = 0xFFFFFFFF, 
}

#[cfg(target_os = "windows")]
impl Rustilege{

    pub fn get_current_integrity_level() -> IntegrityLevel{

        use windows::Win32::Foundation::{CloseHandle, HANDLE};
        use windows::Win32::Security::{
            GetTokenInformation, TokenIntegrityLevel, TOKEN_MANDATORY_LABEL, TOKEN_QUERY, SID, PSID,
        };
        use windows::Win32::System::Threading::{GetCurrentProcess, OpenProcessToken};

        let mut token_handle: HANDLE = HANDLE::default();
        let current_process = unsafe { GetCurrentProcess() };

        if unsafe { OpenProcessToken(current_process, TOKEN_QUERY, &mut token_handle) }.is_err() {
            return IntegrityLevel::Error;
        }

        let mut token_info_size = 0;
        let _ = unsafe {
            GetTokenInformation(
                token_handle,
                TokenIntegrityLevel,
                None,
                0,
                &mut token_info_size,
            )
        };

        if token_info_size == 0 {
            let _ = unsafe { CloseHandle(token_handle) };
            return IntegrityLevel::Error;
        }

        let mut buffer = vec![0u8; token_info_size as usize];
        let token_info_ptr = buffer.as_mut_ptr() as *mut std::ffi::c_void;

        if unsafe {
            GetTokenInformation(
                token_handle,
                TokenIntegrityLevel,
                Some(token_info_ptr),
                token_info_size,
                &mut token_info_size,
            )
        }.is_err(){
            let _ = unsafe { CloseHandle(token_handle) };
            return IntegrityLevel::Error;
        }

        let token_label = unsafe { &*(token_info_ptr as *const TOKEN_MANDATORY_LABEL) };
        let sid_ptr: PSID = token_label.Label.Sid;

        if sid_ptr.0.is_null() {
            let _ = unsafe { CloseHandle(token_handle) };
            return IntegrityLevel::Error;
        }

        let sid = sid_ptr.0 as *const SID;
        let sub_auth_count = unsafe { (*sid).SubAuthorityCount as usize };

        if sub_auth_count == 0 || sub_auth_count > 15 {
            let _ = unsafe { CloseHandle(token_handle) };
            return IntegrityLevel::Error;
        }

        let integrity_level = unsafe { (*sid).SubAuthority[sub_auth_count - 1] };
        let _ = unsafe { CloseHandle(token_handle) };

        match integrity_level {
            0x00000000 => IntegrityLevel::Guest, 
            0x00001000 => IntegrityLevel::Low,
            0x00002000 => IntegrityLevel::User,
            0x00003000 => IntegrityLevel::Administrator, 
            0x00004000 => IntegrityLevel::System,
            _ => IntegrityLevel::Error,
        }

    }
  

}


#[cfg(target_os = "linux")]
pub struct Rustilege;


#[cfg(target_os = "linux")]
impl Rustilege {
    pub fn get_current_integrity_level() -> IntegrityLevel {

        use std::{fs::Metadata, os::unix::fs::MetadataExt};
        let uid: Option<u32> = std::fs::metadata("/proc/self").map(|m:Metadata|m.uid()).ok();

        if uid == Some(0) {
            IntegrityLevel::Administrator
        } else if uid >= Some(1000) {
            IntegrityLevel::User
        }else{
            IntegrityLevel::Guest
        }

    }
}



// if the code is not under Linux or Windows
#[cfg(not(any(target_os = "windows", target_os = "linux")))]
pub struct Rustilege;

// if the code is not under Linux or Windows
#[cfg(not(any(target_os = "windows", target_os = "linux")))]
impl Rustilege {
    pub fn get_current_integrity_level() -> IntegrityLevel {
        IntegrityLevel::Error // OS not supported
    }
}