首页
论坛
专栏
课程

[调试逆向] [原创]初学者的静态分析挑战writeup

2019-7-8 11:26 3165

[调试逆向] [原创]初学者的静态分析挑战writeup

2019-7-8 11:26
3165

题目来源至  https://www.malwaretech.com/beginner-malware-reversing-challenges


所有挑战都是在不使用调试器的情况下完成的,你的目标应该是能够在不运行exe的情况下完成每个挑战。


1 隐藏和搜索


exe包含一个或多个未加密的flag,需要找到正确flag。


string1难度等级为1星


strings1.exe包含存储在可执行文件中的未加密flag。运行时,程序将输出flag的MD5哈希值,但不输出原始值。你能得到flag吗?


本地解压后如下:



拖进IDA里,查看下。


很明显,IDA很智能地识别了一些关键的方法,如md5_hash,猜测这就是生成flag的主方法。


call上面为push eax,入栈操作,很智能地显示了eax的类型,这里可以断定eax为md5_hash函数的参数。


mov eax, off_432294


eax的值来自一个地址,跟进此地址中,在IDA中双击此地址,来到了数据区域,发现此地址为FLAG字符串的起始地址。




那 FLAG{CAN-I-MAKE-IT-ANYMORE-OBVIOUS} 到底是不是flag呢?



在网页中进行检查



是真的flag。


string2难度等级为1星


strings2.exe包含存储在可执行文件中的未加密flag。运行时,程序将输出flag的MD5哈希值,但不输出原始值。你能得到flag吗?


本地解压后如下:



拖进IDA里,查看下,此时与string1完全不一样了。



前面是一些IDA为局部变量与参数设置的标识,先不看,来到计算hash的地方。


这里,eax依然作为md5_hash函数的参数,eax的值取自var_28的地址。


从最上面翻到eax赋值这里,发现mov操作为规律赋值,猜测可能是一个字符串或者字符数组。



右键转换为字符,查看下var_28赋值了什么,发现是大写字母F。



发现了是FLAG{STA......,猜测这就是flag。


转换完成后,将这段字符串进行检测即可 ,这里不再记录过程。


string3难度等级为2星


strings3.exe包含存储在可执行文件中的未加密flag。运行时,程序将输出flag的MD5哈希值,但不输出原始值。你能得到flag吗?


本地解压后如下:



拖进IDA里,查看下,发现与string1与string2完全不一样。


还是原先的步骤,先找到hash生成函数。


这里发现生成hash的函数使用了类的结构,因为call    ??0MD5@@QAE@XZ  ; MD5::MD5(void) 执行了类对象的构造方法。


重点来到 call  ?digestString@MD5@@QAEPADPAD@Z ; MD5::digestString(char *)


这里是生成hash的主方法,IDA标识了eax为char* 类型,与这个方法的参数类型一致,所以判断push eax为参数入栈。


lea  eax, [ebp+var_4A0]


eax的值为var_4A0变量的地址,var_4A0变量在上面的call    ds:LoadStringA这个API函数中有涉及。


LoadStringA函数


从与指定模块关联的可执行文件中加载字符串资源,并将字符串复制到具有终止空字符的缓冲区中,或者返回指向字符串资源本身的只读指针。


int LoadStringA( HINSTANCE hInstance, UINT uID, LPSTR lpBuffer, int cchBufferMax );


参数

hInstance

类型:HINSTANCE

可执行文件包含字符串资源的模块实例的句柄。要获取应用程序本身的句柄,请使用NULL调用GetModuleHandle函数。


uID

输入:UINT

要加载的字符串的标识符。


lpBuffer

类型:LPTSTR

接收字符串的缓冲区(如果cchBufferMax非零)或者是字符串资源本身的只读指针(如果cchBufferMax为零)。长度必须足以容纳指针(8个字节)。


cchBufferMax

输入:int

缓冲区的大小,以字符为单位。如果字符串长于指定的字符数,则该字符串将被截断并以null结尾。如果此参数为0,则lpBuffer将接收指向字符串资源本身的只读指针。


来源: https://docs.microsoft.com/en-us/windows/desktop/api/winuser/nf-winuser-loadstringa


win32 API函数的调用约定为stdcall,参数从右至左入栈。


所以上面的4个push操作就是参数入栈。


mov     [ebp+var_8], eax
mov     eax, 1
shl     eax, 8
xor     edx, edx
inc     edx
shl     edx, 4
or      eax, edx
mov     [ebp+var_4], eax
push    3FFh
lea     ecx, [ebp+var_4A0]
push    ecx
mov     edx, [ebp+var_4]
push    edx
push    0
call    ds:LoadStringA

cchBufferMax为3FFh,十进制为1023


lpBuffer为ecx


uID为edx


hInstance为0,也就是为NULL


mov     [ebp+var_4A0], 0
lea     ecx, [ebp+var_4A0]

lpBuffer为ecx,ecx为var_4A0变量所在的地址,而往上查,发现var_4A0已经被赋值为0,所以ecx为0。


uID为edx,edx=[ebp+var_4],而[ebp+var_4]=eax。


eax的计算是下面这几条汇编指令:


mov     eax, 1
shl     eax, 8
xor     edx, edx
inc     edx
shl     edx, 4
or      eax, edx

最后算得eax=272。


LoadStringA(0, 272, &var_4A0, 1023);


这里还有个快速的方法,F5反编译。直接使用IDAF5插件反编译功能翻译成伪c代码。



LoadStringA函数是加载字符串资源,所以目前需要使用另一个工具,ResourceHacker。


uID为要加载的字符串的标识符,使用ResourceHacker打开string3,来到字符串资源处。


查找下272标识符里的内容




正确flag


2 shellcode


这些挑战利用与位置无关的代码来解密flag,弄清楚shellcode的作用并自己解密。


shellcode1.exe


包含存储在可执行文件中的flag。运行时,程序将输出flag的MD5哈希值,但不输出原始值,难度等级1星。


本地解压后:



IDA打开,如下:


还是先找一下生成hash的方法,可以确定 call  ?digestString@MD5@@QAEPADPAD@Z ; MD5::digestString(char *) 为生成hash的方法。


找这个函数的参数,发现前面存在一个push操作,为 push  offset Str ; "2b\n:蹥B*bb"


发现Str为一个字符串的地址



可以先将字符串当做flag输入进行检测,经过实践后,发现这里的字符串并不是真正的flag。


说明这个地址保存的字符串在前面的流程中进行了改写,我们继续往上查看汇编代码。


call    [ebp+Dst]


直接调用了一个地址,首先这个地址应该是一个函数的开始地址。那么如何得到这个地址的?


继续往上看


push    10h
push    0
call    ds:GetProcessHeap
push    eax
call    ds:HeapAlloc
mov     [ebp+var_4], eax
mov     eax, [ebp+var_4]
mov     dword ptr [eax], offset Str ; "2b\n:蹥B*bb"
push    offset Str      ; "2b\n:蹥B*bb"
call    strlen
add     esp, 4
mov     ecx, [ebp+var_4]
mov     [ecx+4], eax
push    40h
push    1000h
push    0Dh
push    0
call    ds:VirtualAlloc
mov     [ebp+Dst], eax
push    0Dh             ; MaxCount
push    offset unk_404068 ; Src
mov     edx, [ebp+Dst]
push    edx             ; Dst
call    memcpy
add     esp, 0Ch
mov     esi, [ebp+var_4]
call    [ebp+Dst]

首先往上发现了memcpy方法,属于C库函数。


void *memcpy(void *str1, const void *str2, size_t n) 从存储区 str2 复制 n 个字符到存储区 str1。


edx为str1,unk_404068为str2,0Dh为n


这里发现将unk_404068的内容复制到了Dst地址处,恰巧Dst为下面call调用的地址。


push    40h
push    1000h
push    0Dh
push    0
call    ds:VirtualAlloc
mov     [ebp+Dst], eax

这里使用VirtualAlloc生成了一块虚拟内存,并且设置为可执行,说明[ebp+Dst]处的地址是可执行的,具体可以参考MSDN此函数的用法。


我们跟进unk_404068看看,双击unk_404068进入如下:



目前是以数据显示,猜测这里应该是代码(不然call调用了无法执行)。所以选中unk_404068,Edit 选中Code,生成代码。





可以发现,IDA分析后确实生成了代码。 


call    [ebp+Dst] 这里已经解决了,接着查找这个函数的输入参数。


往上发现了mov  esi, [ebp+var_4],而函数内部也对这个esi寄存器进行了操作,判断这里是寄存器传递参数。


现在的问题变成了(ebp+var_4)地址处的值是什么?


push    10h
push    0
call    ds:GetProcessHeap
push    eax
call    ds:HeapAlloc
mov     [ebp+var_4], eax

首先来到第一次对[ebp+var_4]进行操作的地方,这段汇编的意思是调用HeapAlloc生成了一段堆空间,并将起始地址赋值给了

[ebp+var_4]


mov     eax, [ebp+var_4]
mov     dword ptr [eax], offset Str ; "2b\n:蹥B*bb"
push    offset Str      ; "2b\n:蹥B*bb"
call    strlen
add     esp, 4
mov     ecx, [ebp+var_4]
mov     [ecx+4], eax

接着[ebp+var_4]赋值给了eax,而eax地址处的存储值变成了Str字符串的起始地址。


Str字符串地址入栈,调用了strlen C库函数。将字符串长度eax赋值给了[ecx+4]。


[ecx+4]为[ebp+var_4][1]


现在我们发现


[ebp+var_4][0]=Str[0]

[ebp+var_4][1]=eax=strlen(Str)


进一步,[ebp+var_4]目前的值为Str存储的字符串的地址。


而上面我们发现,esi的值为[ebp+var_4]的值。


所以现在进入 call  [ebp+Dst] 函数里进行分析


               sub_404068      proc near               ; DATA XREF: start+5E↑o
.data:00404068                 mov     edi, [esi]
.data:0040406A                 mov     ecx, [esi+4]
.data:0040406D
.data:0040406D loc_40406D:                             ; CODE XREF: sub_404068+A↓j
.data:0040406D                 rol     byte ptr [edi+ecx-1], 5
.data:00404072                 loop    loc_40406D
.data:00404074                 retn
.data:00404074 sub_404068      endp

mov  esi, [ebp+var_4]

call  [ebp+Dst]


call    strlen

add     esp, 4

mov     ecx, [ebp+var_4]

mov     [ecx+4], eax


esi为Str字符串的起始地址,[esi+4]为eax的值,eax的值是strlen的结果,所以是字符串的长度。


rol  byte ptr [edi+ecx-1], 5


这句汇编的含义是将Str的每个字符串循环左移5位之后再放回原位,所以最后的值是Str字符串。


之后可计算出flag


FLAG{SHELLCODE-ISNT-JUST-FOR-EXPLOITS}


shellcode2.exe


包含存储在可执行文件中的flag。运行时,程序将输出flag的MD5哈希值,但不输出原始值。


按照惯例,使用IDA打开。



发现了涉及hash的函数,接着找输入参数。


push  edx   ; char *   这里是通过edx传入参数


lea   edx, [ebp+str[0]] ;edx保存了一个字符数组的首地址。


因为之前已做过了,这里已经手工对连续排列的参数进行创建数组的处理。


猜测数组保存的应该就是输入的flag,查看上述流程里对该数组做了哪些操作。


call    [ebp+Dst]


依据前面的经验,这里Dst为堆空间地址,之后通过mencpy复制了内容,所以所在的地址为代码,所以现在找到这个地址查看下,


也就是push  offset sub_404040 ; Src  中的sub_404040。


双击进入,如果发现是db ... 等显示,可以按字母c转换为代码格式。



这里已经转换为代码格式,按F5让IDA自动生成伪代码,看看这个函数的作用。



翻到下面,看看具体逻辑。 


这里已经重命名了很多代码,当然主要的知识点就是 LoadLibraryA与GetProcAddress。


通过这个两个API函数,可以调用系统dll里具体的方法。


v78 = LoadLibraryA(&msvcrt.dll);

v27 = LoadLibraryA(&kernel32.dll);


_GetModuleFileNameA = (void (__stdcall *)(_DWORD, char *, signed int))GetProcAddress(v27, &GetModuleFileNameA);

_fopen = (int (__cdecl *)(char *, char *))GetProcAddress(v78, &fopen);

_fseek = (void (__cdecl *)(int, signed int, _DWORD))GetProcAddress(v78, &fseek);

_fread = (void (__cdecl *)(char *, signed int, signed int, int))GetProcAddress(v78, &fread);

_fclose = (int (__cdecl *)(int))GetProcAddress(v78, &fclose);


这里加载了两个dll,之后获取了5个函数的内存实际地址。


  _GetModuleFileNameA(0, &v11, 260);            // v11=当前exe执行的绝对路径

  ptr_file = _fopen(&v11, &rb);

  _fseek(ptr_file, 78, 0);                      // 移动文件指针至离文件开始位置78个字节处

  _fread(v79, 38, 1, ptr_file);                 // 读取38个字节放入v79数组中

                                                // This program cannot be run in DOS mode

  result = _fclose(ptr_file);

  v2_36 = *(_DWORD *)(heap_str + 12);           // 36(十进制)

  v3_str = *(_DWORD *)(heap_str + 8);           // str字符串的地址


获取到当前exe执行程序的绝对路径,之后设置文件指针,移动到离文件开始位置78个字节处,接着读取38个字节的内容

放入v79数组中。实际读取的内容为“This program cannot be run in DOS mode”。


之后关闭文件,取出之前申请的堆空间里的两个数值进行赋值。


  v4_0 = 0;

  do

  {

    LOBYTE(result) = v79[v4_0];

    *(_BYTE *)(v3_str + v4_0++) ^= result;

  }

  while ( v4_0 != v2_36 );

  return result;


这里就是最后的计算逻辑,result等于v79数组的首地址,也就是之前“This program cannot be run in DOS mode”的内容。


v3_str为[ebp+str[0]至[ebp+str[0]+23h]的数组内容,两个数组之间每个索引值进行异或操作赋值给v3_str(具体要看实际汇编指令,翻译成的伪代码不一定正确),循环36次后结束。


 text:0040227F                 call    ??0MD5@@QAE@XZ  ; MD5::MD5(void)

.text:00402284                 mov     [ebp+str[0]], 12h

.text:00402288                 mov     [ebp+str[0]+1], 24h

.text:0040228C                 mov     [ebp+str[0]+2], 28h

.text:00402290                 mov     [ebp+str[0]+3], 34h

.text:00402294                 mov     [ebp+str[0]+4], 5Bh

.text:00402298                 mov     [ebp+str[0]+5], 23h

.text:0040229C                 mov     [ebp+str[0]+6], 26h

.text:004022A0                 mov     [ebp+str[0]+7], 20h

.text:004022A4                 mov     [ebp+str[0]+8], 35h

.text:004022A8                 mov     [ebp+str[0]+9], 37h

.text:004022AC                 mov     [ebp+str[0]+0Ah], 4Ch

.text:004022B0                 mov     [ebp+str[0]+0Bh], 28h

.text:004022B4                 mov     [ebp+str[0]+0Ch], 76h

.text:004022B8                 mov     [ebp+str[0]+0Dh], 26h

.text:004022BC                 mov     [ebp+str[0]+0Eh], 33h

.text:004022C0                 mov     [ebp+str[0]+0Fh], 37h

.text:004022C4                 mov     [ebp+str[0]+10h], 3Ah

.text:004022C8                 mov     [ebp+str[0]+11h], 27h

.text:004022CC                 mov     [ebp+str[0]+12h], 3Dh

.text:004022D0                 mov     [ebp+str[0]+13h], 6Eh

.text:004022D4                 mov     [ebp+str[0]+14h], 25h

.text:004022D8                 mov     [ebp+str[0]+15h], 48h

.text:004022DC                 mov     [ebp+str[0]+16h], 6Fh

.text:004022E0                 mov     [ebp+str[0]+17h], 3Ch

.text:004022E4                 mov     [ebp+str[0]+18h], 58h

.text:004022E8                 mov     [ebp+str[0]+19h], 3Ah

.text:004022EC                 mov     [ebp+str[0]+1Ah], 68h

.text:004022F0                 mov     [ebp+str[0]+1Bh], 2Ch

.text:004022F4                 mov     [ebp+str[0]+1Ch], 43h

.text:004022F8                 mov     [ebp+str[0]+1Dh], 73h

.text:004022FC                 mov     [ebp+str[0]+1Eh], 10h

.text:00402300                 mov     [ebp+str[0]+1Fh], 0Eh

.text:00402304                 mov     [ebp+str[0]+20h], 10h

.text:00402308                 mov     [ebp+str[0]+21h], 6Bh

.text:0040230C                 mov     [ebp+str[0]+22h], 10h

.text:00402310                 mov     [ebp+str[0]+23h], 6Fh


算出flag为FLAG{STORE-EVERYTHING-ON-THE-STACK}


3 vm


第一次逆向虚拟机指令,这次的样本比较简单。


vm1.exe实现了一个简单的8位虚拟机(VM),试图阻止逆向工程师检索flag。VM的RAM包含加密标flag和一些字节码来解密它。你能弄清楚VM是如何工作的吗并解密flag?ram.bin中提供了VM的RAM副本(此数据与执行前恶意软件VM的ram内容相同,并包含自定义程序集代码和加密flag)


解压后如图



IDA打开vm1.exe,找到关键函数。


ecx为输入参数,来源于Dst字符串。


往上溯源查看Dst是什么,通过memcpy函数可知Dst来自于Src字符串内容。



call  sub_4022E0     

; Src的地址赋值给了Dst

; 而sub_4022E0内部对Dst进行了操作,Dst的内容为虚拟机代码与数据,处理完毕后会得到flag。

; 所以也就是对unk_404040地址的内容进行操作


进入sub_4022E0查看,流程有点多,直接F5查看下大致流程。




sub_402270函数对三个字节进行了处理,跟进看看。


现在很清楚了,对Dst字符串数组进行了处理与解码。


选中Dst数据内容,导出后编写Python脚本,得到最终的flag。


# coding:utf-8


vm_chars = [
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0xDE, 0x7E, 0x7D, 0x55, 0x1E, 0x05, 0xE6, 0x9F,
  0xE4, 0xA6, 0x47, 0x50, 0x02, 0x01, 0xC7, 0xFC, 0xCB, 0x60,
  0x09, 0xC6, 0x0E, 0x2E, 0x41, 0x65, 0xA4, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1D, 0xBD, 0x01, 0x05,
  0x53, 0x01, 0x12, 0x48, 0x01, 0x10, 0xE6, 0x01, 0x13, 0x8A,
  0x01, 0x0D, 0x47, 0x01, 0x16, 0x13, 0x01, 0x0A, 0x15, 0x01,
  0x00, 0x98, 0x01, 0x02, 0x3C, 0x01, 0x18, 0xD9, 0x01, 0x1A,
  0x57, 0x01, 0x06, 0xAB, 0x01, 0x1B, 0xC6, 0x01, 0x01, 0x32,
  0x01, 0x17, 0x20, 0x01, 0x15, 0x6F, 0x01, 0x11, 0x2D, 0x01,
  0x08, 0xC9, 0x01, 0x09, 0xE7, 0x01, 0x03, 0x12, 0x01, 0x0C,
  0x2F, 0x01, 0x0E, 0x88, 0x01, 0x19, 0x6C, 0x01, 0x04, 0x65,
  0x01, 0x1E, 0xAE, 0x01, 0x14, 0x59, 0x01, 0x1F, 0x91, 0x01,
  0x1C, 0x5D, 0x01, 0x0F, 0xAE, 0x01, 0x0B, 0x15, 0x01, 0x07,
  0xCC, 0x02, 0x20, 0x00, 0x03, 0x00, 0x00, 0x02, 0x21, 0x00,
  0x03, 0x01, 0x00, 0x02, 0x22, 0x00, 0x03, 0x02, 0x00, 0x02,
  0x23, 0x00, 0x03, 0x03, 0x00, 0x02, 0x24, 0x00, 0x03, 0x04,
  0x00, 0x02, 0x25, 0x00, 0x03, 0x05, 0x00, 0x02, 0x26, 0x00,
  0x03, 0x06, 0x00, 0x02, 0x27, 0x00, 0x03, 0x07, 0x00, 0x02,
  0x28, 0x00, 0x03, 0x08, 0x00, 0x02, 0x29, 0x00, 0x03, 0x09,
  0x00, 0x02, 0x2A, 0x00, 0x03, 0x0A, 0x00, 0x02, 0x2B, 0x00,
  0x03, 0x0B, 0x00, 0x02, 0x2C, 0x00, 0x03, 0x0C, 0x00, 0x02,
  0x2D, 0x00, 0x03, 0x0D, 0x00, 0x02, 0x2E, 0x00, 0x03, 0x0E,
  0x00, 0x02, 0x2F, 0x00, 0x03, 0x0F, 0x00, 0x02, 0x30, 0x00,
  0x03, 0x10, 0x00, 0x02, 0x31, 0x00, 0x03, 0x11, 0x00, 0x02,
  0x32, 0x00, 0x03, 0x12, 0x00, 0x02, 0x33, 0x00, 0x03, 0x13,
  0x00, 0x02, 0x34, 0x00, 0x03, 0x14, 0x00, 0x02, 0x35, 0x00,
  0x03, 0x15, 0x00, 0x02, 0x36, 0x00, 0x03, 0x16, 0x00, 0x02,
  0x37, 0x00, 0x03, 0x17, 0x00, 0x02, 0x38, 0x00, 0x03, 0x18,
  0x00, 0x01, 0x19, 0x00, 0x04, 0x00, 0x00, 0x00
]


vm_code = vm_chars[255:]

result = 1
n = 0

def decode(one, two, three):
    global tmp
    if one == 1:
        vm_chars[two] = three
    elif one == 2:
        tmp = vm_chars[two]
    else:
        if one != 3:
            return 0
        vm_chars[two] = vm_chars[two] ^ tmp
    return 1


while result:
    one = vm_code[n]
    two = vm_code[n + 1]
    three = vm_code[n + 2]
    n += 3
    result = decode(one, two, three)

print(bytearray(vm_chars))


FLAG{VMS-ARE-FOR-MALWARE}

4 ransomware


ransomware1勒索解密,难度等级1星。


题目说是一个脚本小子写的勒索软件,问能否解密flag.txt文件?


仅为静态分析,不需要使用调试器。


下载解压完如图:



文件夹为加密过的文件,exe为加密程序demo。

先分析exe文件,使用IDA打开。


自动识别了start程序,进入看看。



进入sub_401000


之前已分析过,所以已经做了些注释与重命名。


这个函数有两个参数,通过API可知,有打开文件与写入文件的操作,这里应该就是加密的核心了。


查snprintf函数的四个参数,结合已经加密的文件特征可以知道a1为需要加密的原始文件的文件名,这里的作用仅仅是拼接字符串作为加密后的文件名。


接下来的CreateFileA函数是打开已经存在的文件,第二个CreateFileA函数是新建一个文件。


do while循环里第一步先检查读取文件时是否成功,如果成功读取4096个字节则执行for循环。


for循环循环的次数为ReadFile实际读取的字节数v6,如果文件超过4096个字节,则v6第一次读取就为4096。


如果文件小于4096个字节,则v6为实际文件的大小。


for循环里有个参数a2未知,将a2的值加上i与0x20的取模运算后的结果再与当前文件从文件开头的第i个字节的值进行异或,

最后的结果再赋值到源位置里。


循环4096次后,就结束循环。最后关闭文件句柄,退出。


加密的原理是对文件的前4096个字节进行计算后重新赋值,如果文件小于4096就对整个文件内容进行处理再在对应位置赋值。


问题的关键是a2的值是什么?


第一次不使用a2,直接对flag.txt进行处理,发现打开后是乱码,说明解密不成功。


这里的话确实要发挥脑洞了,压缩包里给了两类文件,一类是加密后的图片,一类是存在flag的txt文件。


先看图片文件,发现是英文命名的,后缀都为jpg格式。既然a2的值是固定的,加上jpg格式都是有一定特征的,那么如果这些jpg文件里有部分内容是一样的话,说明就可以通过再进行异或运算得到a2这个key的值。


使用Beyond Compare依次打开这些图片,然后一一比较,发现前22个字节是一致的(这里以为找到了突破口,发现却不是)。



说明图片是突破口,然后弄了半天没有发现如果找到图片开头的特征码,因为每个jpg文件好像除了开头两个字节是特征码之外,其余的字节不一定是一致的,我陷入了无解中。


然后突然觉得这个很难解密了,因为无法知道a2的值到底是什么。


带着怀疑就复制加密后的文件名Chrysanthemum去谷歌搜索下,发现了原来是Win7 自带的壁纸图片,啊啊啊,确实不能放过任何信息。





突然醒悟,或许这就是突破口,马上打开Win7寻找原始的壁纸图片,编辑器打开,与加密后的文件进行对比。 


源壁纸文件如下图:


加密后的壁纸文件如下图:


最后,通过上述两个图片里前4096个字节的每个字节进行异或运算后得到规律发现a2的取值是一个字节数组。


key = [

     0x6E, 0xF7, 0x9B, 0x0E, 0x45, 0x55, 0x5E, 0x95,

     0x96, 0xFE, 0xAB, 0x75, 0x80, 0xB4, 0x0E, 0x40,

     0x3D, 0xF5, 0xA7, 0x1B, 0xED, 0xD5, 0x5B, 0x80,

     0xA9, 0xD3, 0x8D, 0x2C, 0xB8, 0x0A, 0x40, 0x0F

]


并且经过32个字节运算后,会重复这个过程,直到处理的字节数达到4096个。


得到key值后,可以通过之前逆出的加密流程对flag.txt_encrypted进行解密了。


解密脚本如下:


# coding:utf-8
key = [
    0x6E, 0xF7, 0x9B, 0x0E, 0x45, 0x55, 0x5E, 0x95,
    0x96, 0xFE, 0xAB, 0x75, 0x80, 0xB4, 0x0E, 0x40,
    0x3D, 0xF5, 0xA7, 0x1B, 0xED, 0xD5, 0x5B, 0x80,
    0xA9, 0xD3, 0x8D, 0x2C, 0xB8, 0x0A, 0x40, 0x0F
]


decrypted = ''
file_name = "flag.txt_encrypted"


with open(file_name, 'rb') as f:
    encrypted = f.read()


for i in range(len(encrypted)):
    decrypted += chr(encrypted[i] ^ key[i % 0x20])


with open(file_name.replace('_encrypted', ''), 'w') as f:
    f.write(decrypted)
    print(decrypted)




感谢阅读!



[公告]安全服务和外包项目请将项目需求发到看雪企服平台:https://qifu.kanxue.com

最后于 2019-7-15 11:19 被jishuzhain编辑 ,原因: 附件添加
上传的附件:
最新回复 (11)
LM10 2019-7-9 17:32
2
0
最后一题可以的。。。
kanxue 8 2019-7-14 20:21
3
0
附件能否直接上传到论坛本地一份?
jishuzhain 2 2019-7-15 11:15
4
0
kanxue 附件能否直接上传到论坛本地一份?
好的
茉莉fly 2019-7-20 16:32
5
0
shellcode1那个题,str原始值咋看的呀,求大神解答,才开始学
jishuzhain 2 2019-7-20 23:45
6
0
茉莉fly shellcode1那个题,str原始值咋看的呀,求大神解答,才开始学[em_20]
发现前面存在一个push操作,为 push  offset Str ; "2b\n:蹥B*bb",双击Str,IDA会自动跳到数据区,dd xx 等就是数据。
wx_tf 2019-7-23 21:33
7
0
第一题的string样本解压密码不对 ?
wx_tf 2019-7-23 21:35
8
0
wx_tf 第一题的string样本解压密码不对 ?
不好意思,是我多按了个空格,尴尬!
Mr_heiio 1 2019-8-5 11:20
9
0
这篇文章,花费了不少心血
qAq哼唧 2019-8-9 19:51
10
0
大佬还原函数名那里太六了
qAq哼唧 2019-8-9 20:27
11
0
~
最后于 2019-8-9 21:01 被qAq哼唧编辑 ,原因: 上个问题知道了
lliixx 2019-9-11 01:12
12
0
Mark
游客
登录 | 注册 方可回帖
返回