冒险解谜游戏中文网 ChinaAVG

标题: 【汉化资料】DASM破解游戏资源入门级简易教程 [打印本页]
作者: shane007    时间: 2008-10-30 20:34
标题: 【汉化资料】DASM破解游戏资源入门级简易教程
众所周知，很多游戏的图片文本影音等资源，都是经过打包、加密或者压缩的，那么为了获取这些资源，只能对算法进行分析，写出相应的破解程序，从而达到资源提取的目的。 ! c1 w8 x- q9 r8 R4 f2 e) M
# _! `, ^* F2 ~9 x8 D; u3 {
但目前来说，使用公开的已知算法来加密或压缩的游戏，毕竟是少数，大多游戏厂商都会对已知算法进行一定的修改或者干脆自己发明一种算法，这时想要破解就没那么容易了。还好为了速度上的考量，这样的算法一般都不会很复杂，我们还是可以通过对程序进行dasm来进行分析破解。
5 L) ~- d$ r6 M0 p+ A) G0 N( O6 ?0 F* N
昨天受朋友之托，让帮忙破解pc版ys2的文本文件"libre.ys2"，花了10来分钟搞定，虽然无论从分析还是算法的角度来说，都属于非常简单的级别，但是对于从未接触过dasm破解的朋友来说，却无疑是一个很好的试刀例子。本文通过描述此次的破解过程，讲述了dasm破解游戏资源的一般思路，希望能达到抛砖引玉的效果。
! |% m: c8 S5 p+ z" w" g
$ s: A. Y2 E! H6 l  A& B; Y. }# \7 s8 g0 J; c. c" {
-------------------------------------------------------------------------------- ) T. l' _9 v8 c  s, A) R9 I
; W% P) J; S8 n4 E, d% f$ N
本人比较懒，既然说是简易教程，就一切从简。。。
5 U2 `6 r* L. Y2 W' M9 \1 F& _6 g( Q) Y/ Q
拿到文件首先分析文件头：
# N$ x: Y- V4 l) X' V9 `% b2 g" \% e' u23 C8 14 00 AE 63 06 00 AC 07 97 3E 02 4F 9C 71 6 T9 h# z* D7 S/ s

3 D) O$ N2 D0 V1 U5 S) x* w  r这是文件前16个字节的内容，很明显，前面8个字节，也就是2个dword马上引起了我们的注意。因为这个文件的大小是0x663B6，而0x000663AE = 0x663B6 - 0x8，那么可以推断，0x000663AE就是数据部分的大小，而前8个字节就是文件头。那么还剩一个0x0014C823是什么呢？因为文件里搜不到明文文本，说明不是被加密就是被压缩过，做过破解的可能都会根据两个数值之间的关系，推断0x0014C832就是解压后的数据大小，看起来也是很合理的，我起初也是这么判断的，目前就先放一边吧。
1 h9 U5 r, I. @2 P! x9 ^7 H* h
8 ?6 d5 U6 {" b+ k7 P: U再让我们看看数据部分，杂乱无章，没有任何已知算法的压缩头，也不像是lz系列的压缩，看来再看下去也是徒劳，只能祭出dasm了。 ; ^& q6 g* e0 p  I; W( i0 y( p
5 Y7 i  T% e2 I& C7 N: W
由于pc上有众多调试器，所以最好的做法是进行动态跟踪来找出算法，不过前面说了我比较懒，抱着侥幸心里先用ida试了试静态分析，看看能不能有所斩获。关于ida的下载安装使用等本文概不提及，有兴趣的朋友可以自行查阅相关教程。 + v! i* p5 }4 Q6 b; p2 Z

" x% D' T0 E: h4 L- A: i3 [! O" F2 q由于存在数据大小，因此可以判断这个文件是单独使用的，那么首先想到的就是到字符串列表里查找文件名，然后看哪些程序用到了它。
+ W. Y5 a# D( j) |) ^9 r$ q, h0 K$ o# y
# e# l! {0 i2 l* ~; g打开ida，加载"ys2_win.exe"，在strings里搜索"libre.ys2"，果然找到如下字符串：
4 x; A/ e- _/ {9 A# C3 [; b8 q  l_rdata:004B8798 0000000F C DATA\\LIBRE.YS2
& G4 d! U! Y6 K  n3 s. u" ^  t, ?( M1 Y, i) _0 P* u* B' e
双击来到其地址处： ; l1 F! d' |% T3 q, l0 O( `3 i
_rdata:004B8798 aDataLibre_ys2 db 'DATA\LIBRE.YS2',0 ; DATA XREF: sub_0_443030+39o
3 l/ T! D- {2 i3 e2 N4 w/ @/ t: b* g( m) `8 _
可以看到，很幸运，只有一处进行了引用，下面转到sub_0_443030+39处： , }9 q4 n* {/ [" c0 t  D
  i- R% Q- u# Q  x* U8 o! e
C++代码
  t: B, J. D# I; {8 s_unknwn:00443065 push 0    8 E4 L! W1 z5 Y
_unknwn:00443067 push 0   
: j! b8 F8 n* j! o6 c* b2 T% S( a  w_unknwn:00443069 push offset  DataLibre_ys2 ; "DATA\\LIBRE.YS2"   
! B* O9 r' T( U3 r_unknwn:0044306E push  80000000h   
0 j. m( S$ @0 D2 ^1 k& A# g, z_unknwn:00443073 lea ecx, [esp+140h+var_124]   
1 e4 D! B! P2 W$ h1 u_unknwn:00443077 mov [esp+140h+var_4], 0    5 x4 Y8 N9 p( L) S
_unknwn:00443082 call dword ptr [eax+10h]   
) s" `5 q1 Q; C_unknwn:00443085 lea ecx, [esp+140h+var_134]    6 R1 ?6 b/ f& p0 \, P8 S. g* t
_unknwn:00443089 call sub_0_44B780    ( R/ O5 h' [3 D- i
_unknwn:0044308E mov esi, eax    5 g+ Z( @2 N. R2 f( c# T6 _/ h1 g" u( l
_unknwn:00443090 push esi   
3 g8 C5 r! q4 v_unknwn:00443091 call ??2@YAPAXI@Z ; operator new(uint)    ' \2 K& M6 K- v6 @
_unknwn:00443096 add esp, 4   
, u5 T9 A4 q$ b7 M, @) x_unknwn:00443099 push esi ; nNumberOfBytesToRead   
  Z' t/ ~" d# k6 j  |  |% ~_unknwn:0044309A push eax ; lpBuffer   
& c4 u8 P/ J/ C) U, j2 I' t_unknwn:0044309B lea ecx, [esp+148h+var_134]   
: ]" v* u8 J* M+ N6 M_unknwn:0044309F mov dword_0_5FA6B4, eax   
2 \8 V, ^7 v% U% I, J% F  }_unknwn:004430A4 call sub_0_44B6B0    6 H* S! j9 A5 a! V
_unknwn:004430A9 mov eax, dword_0_5FA6B4    . L# r+ O/ F4 g. {& v, ?
_unknwn:004430AE mov edx, [eax+4]   
# [  a6 t+ x$ k" u5 Z) d_unknwn:004430B1 mov ecx, [eax]   
* s% h1 N. D, e. W* f_unknwn:004430B3 lea esi, [eax+8]   
- b0 E% N# K/ n" X# I) i! {5 p_unknwn:004430B6 add edx, esi    , x/ R5 D! w% d7 \. }
_unknwn:004430B8 push edx    2 J# W( Y6 [& L) J
_unknwn:004430B9 mov edx, esi      Y6 u4 A7 t1 n) ?
_unknwn:004430BB call sub_0_492580    ' ]) o; t/ _( ?% e

8 f. }. |$ P6 o. h3 y对于asm的分析，没有什么捷径可走，只能是耐心+经验+运气。
) D. t7 P4 ]4 T) i. Z0 P  L+ u5 `' d! I% x5 V" I7 T* u3 o/ Y
下面简单分析一下这段程序： . i8 v& @$ m1 x4 ^
: G$ z' u# J0 p& U) J2 ~* i
第3行，对"DATA\\LIBRE.YS2"这个文件名进行了压栈，作为后面函数的参数之一。
& }/ T& O' j! |: ^, [+ p5 O, l! p. Y; v2 l9 p" [
第7行，"call"调用目的函数目前弄不明白，跳过。
0 J% R" f- t3 g9 }/ D% X
5 i6 G5 D6 J! g# M* l* V# k第9行，"call sub_0_44B780"，追到sub_0_44B780里，发现调用了系统API GetFileSize，返回值保存在eax里，所以eax里现在就是文件的大小。
3 A! F$ l# r3 g; g" b* G2 F0 N7 }
2 P( E! X& X+ G: @8 O第10-12行，用"new"进行内存分配，分配空间大小就是刚才获得的文件大小，说明这里是分配一个缓冲，用来加载文件。
$ i! s" m7 B0 e3 c* q6 ?& i$ c3 T  e( X: i6 W# a+ [6 u5 M
第13-18行，压栈一些数据，为函数"sub_0_44B6B0"传递参数，追到这个函数里，发现调用了系统API ReadFile，说明此处是把文件读取到内存的缓冲区中。此处注意，第15行很明确的说明了此时eax就是缓冲区的指针lpBuffer，如果之后要进行解压或者解密，基本上肯定要从这里取得原始数据，因此必需时刻跟踪这个指针。第17行，eax被传到了一个地址上，可以看成是一个临时变量用来暂存lpBuffer。 2 s3 A6 x; x3 C% T& g4 T
1 Q. S0 L- s: }: j$ T! b, T2 U. Y+ y
第19行，把刚才暂存的缓冲区指针lpBuffer传回eax。 # G5 x5 `; {" |$ q- r8 a

  U# j0 t2 h8 c第20行，有意思的来了，想起来了么，[eax+4]就是文件第2个dword，也就是数据部分的大小，传到了edx，看来我们接近目的地了。
! B3 x) W! J+ T+ R) n2 f- C
2 S! Y5 d* Z, C6 T& w第21行，第一个dword传给ecx，之前推测是解压后的大小。
0 n3 V$ ]/ |# j1 U8 L7 }, J6 g4 O/ V% _- i- x
第22行，注意这里lea和前面mov的区别，这里是传地址，esi现在实际上是个指针，指向缓冲区中的实际数据部分。
9 N$ L/ ~( |+ S& [2 P- g! G/ p1 e
! J9 V" _5 v) V6 O, i第23-25行，这里的edx=edx+esi，实际上是得到一个指向数据末尾的指针，猜想是用于循环计数的结束标志，并且将这个指针压栈，作为参数传递给后面的函数sub_0_492580。然后再把lpBuffer送edx。一切准备就绪。 $ H* ^0 w+ t$ E9 K1 i2 d. O1 i
# v, f8 G; z9 a% B+ R8 J: G
现在应该可以判定，sub_0_492580就是用来解压或者解密的函数。不用犹豫，追进去，实在是太熟悉的程序模式了，如下： 5 ]2 S" u, G& \* d. X3 P8 \

; B) Y/ ^' |' ~! |- K0 p& IC++代码 8 y8 h6 n% V3 x2 n! {: o
_unknwn:00492580 sub_0_492580 proc near
- O- k; e9 V: W! A5 N% O( \_unknwn:00492580 9 Z  o$ {6 h- K4 @; p6 @
_unknwn:00492580 6 m0 V0 H2 J0 M$ }
_unknwn:00492580 arg_0 = dword ptr 4 6 n5 H3 }! J: D+ G; L
_unknwn:00492580
2 V4 C0 j; @0 C3 ]; Z_unknwn:00492580 test ecx, ecx ! `& ]& g$ h7 {$ x/ x
_unknwn:00492582 push esi 6 e* O7 E# Y+ Q. D6 W: n
_unknwn:00492583 mov eax, edx 3 m5 X( |# }6 [
_unknwn:00492585 jz short loc_0_4925B3 4 f' G+ T3 W4 T, B) t# l* m
_unknwn:00492587 mov esi, [esp+4+arg_0] . x+ C% ^4 z7 _9 L( l4 A
_unknwn:0049258B cmp eax, esi
) i. S0 p4 J& H3 d_unknwn:0049258D jnb short loc_0_4925B3
# N$ \$ z  j- j  }_unknwn:0049258F push ebx ( s" }) t, p" @3 D. f7 O
_unknwn:00492590
/ d+ I8 M* F- z" w; I' d1 ]_unknwn:00492590 loc_0_492590: ; CODE XREF: sub_0_492580+30j
2 \' L% m: {+ i% w: N_unknwn:00492590 mov bl, [eax] 5 K  L. \& U5 Z5 R- L7 t: T
_unknwn:00492592 lea ecx, [ecx+ecx*4]
8 C& Z" T3 x- D' I/ c_unknwn:00492595 lea ecx, [ecx+ecx*4] 6 i- \9 z$ T5 u0 f$ R6 c! j
_unknwn:00492598 lea ecx, [ecx+ecx*4]
6 d+ f+ c6 y4 H! \/ x, l% q. n_unknwn:0049259B lea ecx, [ecx+ecx*4] * R. m% a# }! `6 }6 I
_unknwn:0049259E lea ecx, [ecx+ecx*4] 0 Z$ X! T% T/ Q" n6 d1 a5 u! g' a
_unknwn:004925A1 lea ecx, [ecx+ecx*4] , ]9 n4 o; {" R9 u& `
_unknwn:004925A4 mov edx, ecx
! x, W" u) V$ S  b  M9 o_unknwn:004925A6 shr edx, 10h
3 t3 Q/ I. R2 ?+ i( }& A3 R_unknwn:004925A9 sub bl, dl 5 }$ E! a8 U" X- F( B
_unknwn:004925AB mov [eax], bl % O" G4 ]. k+ U. Y$ k6 Y
_unknwn:004925AD inc eax
3 _4 q! P' X4 |* q( w5 @. B_unknwn:004925AE cmp eax, esi $ |' t5 M1 V6 c2 E  k
_unknwn:004925B0 jb short loc_0_492590
& q0 F. f) P7 u) V% m_unknwn:004925B2 pop ebx ! ]+ s! \3 g. S! _+ w1 ]
_unknwn:004925B3 / S2 Z& v: T) K; f; G
_unknwn:004925B3 loc_0_4925B3: ; CODE XREF: sub_0_492580+5j , @( k8 X1 x& S* |5 a* q% t
_unknwn:004925B3 sub_0_492580+Dj 8 p& Z1 C, q& G! ]0 T
_unknwn:004925B3 pop esi / d6 e5 X  f% z' B' M" R$ ]
_unknwn:004925B4 retn 4
7 [& E8 r: O& q$ D_unknwn:004925B4 sub_0_492580 endp
3 t5 H0 K1 V3 }& Z& p% O
/ m' k9 Z9 V) c# n4 o; P- N% C这里的"mov bl, [eax] ....... mov [eax], bl"这个程序段实在是太引人注目了，以至于第一眼看到就几乎可以断定这是个解密程序。下面做简要分析：
  t. s  _; H9 A3 R
5 U. d0 g8 b7 }  ?0 s第1-9行，一些合法性判断。第8行很重要，edx送到了eax，根据前面的分析，eax此时就是缓冲区中数据部分的起始地址指针！同时也是作为移动游标使用。 $ e( ^. O( s9 O! K% [5 P( Z; l
+ U8 c9 i4 M, h5 A
第10行，获得传入函数的参数，即前面提到的数据末尾指针。送esi。 5 B) o. @, ?3 o4 G$ d  c, s+ G, H8 O
  c0 U. G$ Y& \6 o- Q- }
第11-12行，做了个比较，如果游标大于数据末指针，那么就返回。到这里就很清楚了，eax作为一个游动的指针，指向数据部分的单个字节数据，esi作为一个结束标识，两者结合作为循环结束的判断依据。
  D' t9 y0 K0 m2 _' f5 m* Z7 X8 G! }) Q& \; ^
第16-29行，不用说了，明显是解密。第16行取出一个缓冲区中的数据，第29行则是把解密过的数据放回原缓冲区。中间的就是解密过程了。还记得么，在函数调用之前，ecx的值就是文件第一个dword的值，这里终于弄清楚它的作用，就是作为初始密钥！这里17-22行相当于"ecx = ecx * 5 * 5 * 5 * 5 * 5 * 5"(注意这里是lea)，第23-24行是把得到的结果右移16位，并传入edx。第25行的dl，就是edx的低8位，即"dl = edx & 0xFF"，这里用原始的数据来减dl，然后26行把结果写回缓冲区，这样就完成了一个字节的解密工作。第27-29行则是递增游标，然后判断数据是否解密完，做循环。
7 ^8 d* J3 ]7 x  }& p' E6 N) }$ C
/ U( f1 @* M( w8 F/ {; `( E+ w至此整个解密算法分析结束，如果这样你还写不出解密程序来，我也无话可说了。。。
9 k+ s( C) B  v2 P; H7 z; k: z, g  ^
' R3 \/ X& |$ g7 o' }. U总结起来，dasm破解游戏资源的关键，就是密切跟踪用于加载文件的缓存区，以及对于该缓冲区内数据的读写操作，如果是取出了数据然后经过一系列处理又放回去的，一般就是解密了；如果只是取出数据，经过一系列处理以后，放到了另一个缓冲区的，很可能就是解压。总之，dasm是一件非常需要耐心的工作，asm代码总是枯燥的，要弄清各个寄存器的值也得花一番功夫，但是破解以后的成就感，也只有你亲自动手并完成以后，才能体会得到了。。。0 v& H8 ~) U: D4 \0 G' q
# S) s, O& ]* W7 o+ R
原贴
% N2 n. |& p( Lhttp://www.xinyuonline.net/blog/?action=show&id=37



欢迎光临 冒险解谜游戏中文网 ChinaAVG (https://chinaavg.com/) Powered by Discuz! X3.2