052.esgis.1
UPX 0.89 - 3.xx -> Markus & Laszlo ver. [ 0.76 ] <- from file.
A classic viusal C++ programe, compiled at 1998.
长文预警
本文大概有三千个字
先上图；
使用linxue的脱壳机去掉packer,或者使用通用oep大法，upx主要是压缩没有加密，反正也不难。
追踪 引用字符串找到函数结点；
int __thiscall sub_401C20(void *this) {
void *_this;
unsigned int len_plus1;
char *v3;
int v4;
int Ntimes64;
int ii;
int result;
signed int j;
unsigned int *guessPtr;
signed int i;
DWORD Type;
DWORD cbData;
HKEY phkResult;
int guessHex;
char v15;
char v16;
char v17;
int C0_FF_0[2];
int v19;
char userString[500];
BYTE tmp;
CHAR guessString;
_this = this;
memset(userString, 0, sizeof(userString));
memset(&guessString, 0, 0x1F4u);
memset(&tmp, 0, 0x1F4u);
getStrFromTextBox(this + 92, userString, 100);
getStrFromTextBox(_this + 172, &guessString, 100);
strcpy(&tmp, userString);
_strrev(&tmp);
strcat(userString, &tmp);
RegOpenKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", &phkResult);
Type = 1;
cbData = 256;
RegQueryValueExA(phkResult, "ProductID", 0, &Type, &tmp, &cbData);
Type = 1;
strcat(userString, &tmp);
cbData = 256;
RegQueryValueExA(phkResult, "RegisteredOwner", 0, &Type, &tmp, &cbData);
strcat(userString, &tmp);
len_plus1 = strlen(userString) + 1;
setConst_4016E0(C0_FF_0);
memset(&userString[len_plus1 - 1], 0, 76u);
v3 = &userString[len_plus1 + 75];
*v3 = 0;
v3[2] = 0;
v4 = 64 - (len_plus1 & 0x3F);
userString[len_plus1 - 1] = 0x80u;
if ( v4 <= 7 )
v4 += 64;
Ntimes64 = v4 + len_plus1;
ii = 0;
for ( *(&v19 + v4 + len_plus1) = 8 * strlen(userString); ii < Ntimes64; ii += 64 )
MD5like_401700(&userString[ii], C0_FF_0);
C0_FF_0[0] = LOWORD(C0_FF_0[0]);
if ( sscanf(&guessString, "%lx%lx%lx%lx", &guessHex, &v15, &v16, &v17) == 4 ) {
j = 0;
guessPtr = &guessHex;
do {
rolN_401B90(guessPtr, 0xBADC0DE / (j++ + 0x50));
++guessPtr;
} while ( j < 3 );
i = 0;
while ( *(&guessHex + i * 4) == C0_FF_0 ) {
++i;
if ( i >= 4 )
return msgbox_4100A8("... Man, you're good enough to join CORE! ...", "Welcome", 0x40u);
}
result = msgbox_4100A8("... Better luck next time ...", "Failed", 0x30u);
} else {
result = msgbox_4100A8("... Hmmm, you don't even pass the first threshold ...", "Failed", 0x30u);
}
return result;
}
主要函数就在这个block里。
内存地址：0x19ed24
inputtext1.会操作3次得到一个4倍长度的strings1（Win10注册表是空,直接复制3次），inputtext2以%lx的方式读入4个，然后调用sub_401B90循环移位N次得到一个16bytes的字符串，与strings1 的类似MD5摘要结果进行比较。
input1->(like MD5 digest)——┐
cmp---(Y/N)
input2->(ROL+strange+1)___」
MD5 like func
使用PEid的Krypto 插件检查算法会发现有且仅有md5算法，
地址块 ：dword_41B0B0;
所有的常数（F G H I）里面的都是对的，包括UPX0:setConst_4016E0函数 sets initial magic number;
但是，怎么看这个函数都不是正常的标准md5，也没有动力去分析一个修改过的md5;
考虑到在UPX0:00401E56还and了一个0xffff,表明直接爆破md5是不可能的了；
不过可以在内存地址里得到摘要值；
对应于 "0000"的输入，摘要值是
0019ED34 |BB A2 00 00 B8 2E 9A A3 | 42 25 88 E8 70 B8 C4 9D| ........B%..p...
这16bytes数据；
ROL strange array
这个函数是最有意思的函数；开始的时候发现它每次循环修改2 int，
c[0,1],c[1,2],c[2,3],
循环3次刚刚好全部的16bytes
查看反汇编伪代码
char *__cdecl rolN_401B90(unsigned int *ptr, int const1)
{
char *result;
int cnt;
unsigned int Lsi;
unsigned int Hdi;
unsigned __int64 tt0;
int t1;
int t2;
unsigned __int64 tt;
result = ptr;
cnt = const1;
Lsi = *ptr;
Hdi = ptr[1];
if ( const1 )
{
do
{
tt0 = 2 * __PAIR__(Hdi, Lsi);
LODWORD(tt0) = ((2 * Lsi) | (Hdi >> 31)) & 4;
t1 = tt0 | (Hdi >> 31);
t2 = HIDWORD(tt0);
tt = tt0 << 11;
LODWORD(tt) = t1 & 0x2000 ^ tt;
tt <<= 18;
LODWORD(tt) = t1 & 0x80000000 ^ tt;
tt *= 2i64;
Lsi = tt ^ t1;
Hdi = HIDWORD(tt) ^ t2;
--cnt;
}
while ( cnt );
result = ptr;
}
*result = Lsi;
*(result + 1) = Hdi;
return result;
}
不好意思，研究了好久发现，这个代码是错误的，但是只有试过才大概了解到一大堆位运算在干嘛；
在这个地方卡了好久，花时间修改导出的C代码，发现是错误的计算结果;
经过汇编跟踪比较，发现伪代码错误，放弃；
用IDA dump脚本监控前几百次运行是这样的：
ebx, esi, edi,
0,00255F35,00000001,00000002,0000000200000001
1,00255F35,00000002,00000004,0000000400000002
2,00255F34,00000004,00000009,0000000900000004*
3,00255F33,00000008,00000012,0000001200000008
4,00255F32,00000010,00000024,0000002400000010
5,00255F31,00000020,00000048,0000004800000020
6,00255F30,00000040,00000090,0000009000000040
7,00255F2F,00000080,00000120,0000012000000080
8,00255F2E,00000100,00000240,0000024000000100
9,00255F2D,00000200,00000480,0000048000000200
A,00255F2C,00000400,00000900,0000090000000400
B,00255F2B,00000800,00001200,0000120000000800
C,00255F2A,00001000,00002400,0000240000001000
D,00255F29,00002000,00004801,0000480100002000*
E,00255F28,00004000,00009002,0000900200004000
Try Brute force
这里走歪了；
这个函数 接受 4 uint,运行后和md5like 的摘要比较，得到是否正确；
前面说到了，直接用导出的fake C code是不能用的，于是我们想要爆破的话，直接用汇编代码来运行就好了嘛；
这里主要写内联汇编，把rolN_401B90 函数的汇编代码提取出来，在vs2015里改写接口部分，
__declspec(naked)
char* __cdecl rolN_401B90(unsigned int *Cptr, int Cconst1) {
#define ptr 4
#define const1 8
__asm {
mov eax, [esp + ptr]
push ebx
mov ebx, [esp + 4 + const1]
push esi
mov esi, [eax]
push edi
...MORE...
RETZERO:; CODE XREF : __allshl + 3j
xor eax, eax
xor edx, edx
retn
}
#undef ptr
#undef const1
}
运行了一个测试，发现是正确的；
于是写了一个爆破Generator function 来初始化输入值，每10000次打个log；
结果是，原始汇编代码运行1W次时间，4~5minutes，
如果要爆破完16bytes，需要集群了,emm.....
有没有土豪赞助我一车GTX1080和i7 7700K 吗
直接爆破不行，就需要分析这个汇编blocks在干嘛，这里现在看来是最最重要的；
前面调试可以看到全部是位运行，既然是数学，这里使用符号传递来尝试分析；事实证明这个方法是正确的。
; char* __declspec(naked) __cdecl rolN_401B90(unsigned int *ptr, int const1)
rolN_401B90 proc near ; CODE XREF: sub_401C20+284p
;ptr = dword ptr 4
;const1 = dword ptr 8
mov eax, [esp+ptr]
push ebx
mov ebx, [esp+4+const1];cnt;
push esi
mov esi, [eax];c[0]
push edi
mov edi, [eax+4];c[1]
test ebx, ebx
jbe short loc_401C15
push ebp
loop1: ; CODE XREF: rolN_401B90+7Ej
mov ebp, edi
mov ecx, 1 ;ecx=1;
shr ebp, 1Fh
mov [esp+10h+const1], ebp;get c[1].bit31;
mov eax, esi
mov edx, edi
xor ebp, ebp ;ebp=0
call __allshl; edx,eax <<1
;eax=c[0]<<1
;edx=c[1]<<1|c[0]>>31;
mov ecx, [esp+10h+const1];ecx=c[1]>>31
or ebp, edx ; mov ebp,edx;
;ebp=c[1]<<1 | c[0]>>31;
or ecx, eax ;ecx=c[1]>>31|(c[0]<<1);
xor edx, edx ;edx=0;
mov esi, ecx ;esi=c[1]>>31|(c[0]<<1);
mov ecx, 11 ;ecx=11
mov eax, esi ;eax=c[1]>>31|(c[0]<<1);
mov edi, ebp ;edi=c[1]<<1 | c[0]>>31 ;
and eax, 4 ;eax=(c[1]>>31|(c[0]<<1)) & 4;
call __allshl
;eax=((c[1].bit31|(c[0]<<1)) & 4)<<11
;eax=((c[1]>>31 |(c[0]<<1)) & 4)<<11
;eax=((c[0]<<1) & 4)<<11
;eax=( c[0]&2 ) <<12
;edx=0
mov ecx, esi ;ecx=c[1]>>31|(c[0]<<1)
xor ebp, ebp ;ebp=0
and ecx, 2000h ;ecx=(c[1]>>31|(c[0]<<1)) & 0x2000
;ecx=(c[0]<<1) & 0x2000
xor edx, ebp ;NOP ;ebp==0
xor eax, ecx ;eax=(((c[0]<<1) & 4)<<11) ^ (c[0]<<1 & 0x2000)
;eax=( ( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000)
mov ecx, 12h ;ecx=18;
call __allshl
;eax=( (( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000)) << 18
;edx=( (( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000)) >> 14 Always edx==0
;
mov ecx, esi ;ecx=c[1]>>31|(c[0]<<1);
xor edx, ebp ;NOP,ebp==0;
and ecx, 80000000h ;ecx=c[1].bit31|(c[0]<<1) & 0x8000_0000;
;ecx=(c[0]<<1) & 0x8000_0000;
xor eax, ecx
;eax=( ((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000))<<18 )^( (c[0]<<1) & 0x8000_0000 )
mov ecx, 1 ;ecx=1
call __allshl
;eax=(( ((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000))<<18 )^( (c[0]<<1) & 0x8000_0000 ))<<1;
;edx=( ((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000)) >> 14)<<1 |( (((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000))<<18 )^( (c[0]<<1) & 0x8000_0000 ) )>>31
xor esi, eax
;c[0]=(c[1]>>31|(c[0]<<1)) ^( ((((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000))<<18 )^( (c[0]<<1) & 0x8000_0000 ))<<1 )
; ^ ((c[0].bit1<<31 ^ c[0].bit12<<31 ^ c[0].bit30<<31 )<<1)
;c[0]=(c[1]>>31|(c[0]<<1)) ^ 0
;c[0]= c[1]>>31|(c[0]<<1)
xor edi, edx
;c[1]=(c[1]<<1 | c[0]>>31) ^( ( ((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000)) >> 14)<<1 |( (((( c[0]&2 ) <<12) ^ (c[0]<<1 & 0x2000))<<18 )^( (c[0]<<1) & 0x8000_0000 ) )>>31 )
; ( c[0].bit1<<13^ c[0].bit12<<13 )>>14 <<1
;c[1]=(c[1]<<1 | c[0]>>31) ^( 0 |(c[0].bit1<<31 ^ c[0].bit12<<31 ^ c[0].bit30<<31 )>>31)
;c[1]=(c[1]<<1 | c[0]>>31) ^(c[0].bit1 ^ c[0].bit12 ^ c[0].bit30 )
;c[1]=(c[1]<<1 | c[0]>>31) ^(c[0]>>1 ^c[0]>>12 ^c[0]>>30)&1
;c[1]= c[1]<<1 ^ (c[0]>>31 ^c[0]>>1 ^c[0]>>12 ^c[0]>>30)&1
dec ebx
jnz short loop1
mov eax, [esp+10h+ptr]
pop ebp
loc_401C15: ; CODE XREF: rolN_401B90+12j
mov [eax], esi
mov [eax+4], edi
pop edi
pop esi
pop ebx
retn
endp
__allshl proc near ; CODE XREF: rolN_401B90+29p
; rolN_401B90+46p ...
; cmp cl, 40h
; jnb short RETZERO
; cmp cl, 20h
; jnb short MORE32
shld edx, eax, cl
shl eax, cl
retn
; ---------------------------------------------------------------------------
MORE32: ; CODE XREF: __allshl+8j
mov edx, eax
xor eax, eax
and cl, 1Fh
shl edx, cl
retn
; ---------------------------------------------------------------------------
RETZERO: ; CODE XREF: __allshl+3j
xor eax, eax
xor edx, edx
retn
endp
简单来说，
被操作的2个uint 会循环N次，
每次操作
c[1]=(c[1]<<1 | c[0]>>31) ^(c[0]>>1 ^c[0]>>12 ^c[0]>>30)&1
c[0]= c[1]>>31|(c[0]<<1)
差不多就是两个uint32 相互循环移位，附加c[1]一个特殊的最低位XOR，条件是c[0]的c[0].bit1 ^ c[0].bit12 ^ c[0].bit30 的异或 ；
得到这个算法以后写了个C代码测试，验证正确，结果又尝试了爆破，嗯，在编译器O2优化下 2mins/1W 计数；
不行，这个速度太慢了，于是按照逻辑写了个纯汇编的函数，手写的主要循环体优化后只有9行汇编代码，运行速度1mins/1W 计数，还是不够快
柳暗花明又一村
算法已知是迭代的，普通不能爆破，那就只能找算法的特性/漏洞了，比如通项函数什么的。
但是，上面的C表述基本不能看出什么；
于是就画了好几个算法运行的示意图
最后就这个看出端倪了。
可以回代运算（N+1）项得到第N项；
核心是 c[0]的n项的0~30bit在c[0]的n+1项的1~31bit, c[0]n项缺少的 31bit可以从c[0]的n+1项的31，13，2和c[1]的n+1项的最低位这四个东西异或得到；
C代码表述
char* rolN_reverse(uint32_t* ptr, int cnt) {
uint32_t n[2], n_1[2];
n[0] = ptr[0];
n[1] = ptr[1];
printf("[-]Get: %X %X\n", n[0], n[1]);
for (int i = 0; i < cnt; i++) {
n_1[0] = (n[0] >> 1 & 0x7fffffff)|((n[1]&1 ^ n[0]>>31^ n[0]>>13^ n[0]>>2)&1)<<31;
n_1[1] = (n[1] >> 1 &0x7fffffff )|n[0]<<31;
n[0] = n_1[0];
n[1] = n_1[1];
}
printf("[-]Rev: %X %X\n", n[0], n[1]);
ptr[0] = n[0];
ptr[1] = n[1];
return ptr;
}
写了个函数验证，结果正确；
不考虑奇怪的MD5，
最后把注册机（的½）写一下就是
#define V0 0xA2BB
#define V1 0XA39A2EB8
#define V2 0XE8882542
#define V3 0X9DC4B870
#define CV0 0x255f35
#define CV1 0x24e918
#define CV2 0x2475dd
uint32_t knownArray[4] = {V0,V1,V2,V3};
rolN_reverse(knownArray + 2, CV2 );
rolN_reverse(knownArray + 1, CV1);
rolN_reverse(knownArray + 0, CV0);
for (int i = 0; i < 4; i++) {
printf(" 0x%X", knownArray);
}
所以，
成功完成任务；
期间各种奇奇怪怪的bug和错误歧途就不再描述了。。。
Summary
- 内联汇编，x86 asm
- Z3符号引擎 不知道能不能用上帮助分析，手动分析汇编逻辑还是太慢了；
- 不要一条路走到黑，比如爆破什么的。~(￣▽￣)~*
- 笔和草稿纸需常备案头，in case of something;
- ...
[复制链接]
发表于 2017-8-22 07:22
|
发表于 2017-8-22 09:15
