Januari 1999 |
"WinU 4.3" ( Algoritma Checking ) |
Win '95 PROGRAM Win Code Reversing |
|
oleh CHuPaCaBRa |
|
|
[eKH] |
|
Program Target WinU 4.3 |
||
Tools Used: SoftICE 3.23 |
||
Rating |
Easy ( X ) Medium ( ) Hard ( ) Pro ( ) |
There is a crack, a crack in everything. That's how the light gets in. |
"WinU 4.3"
( Algoritma Checking )
oleh
CHuPaCaBRa
Intro |
Ada berbagai macam Sistem Proteksi yang ada untuk "mengamankan" program - program Shareware. Pada dasarnya program akan melakukan pengecekan apakah Serial Number yang kita masukan sesuai dengan Serial Number yang berlaku bagi program tersebut.
Kadang - kadang kita akan menemukan program yang dikerjakan oleh programer malas yang tidak ingin susah - susah memikirkan Sistem Proteksinya sehingga ia telah meletakan sebuah Serial Number yang berlaku bagi semua User dan diletakan di dalam badan program. Proteksi seperti ini sangatlah mudah untuk ditembus karena dengan mudah Kraker dapat melihat Serial Number tersebut. Ada lagi Sistem Proteksi yang disebut Memory Echo dimana pada pengecekan Serial Number, program akan menciptakan Serial Number yang valid bagi User ( biasanya berdasarkan Nama User ) dan meletakkannya di memory lalu membandingkannya dengan Serial Number yang dimasukan. Metode seperti ini juga mudah untuk diKrak karena dengan SoftICE, Kraker dapat melihat langsung Serial Number yang valid tersebut.
Dalam tutorialku kali ini, aku akan menunjukkan Sistem Proteksi yang berbeda dengan kedua metode di atas. Program target kita ini tidak menciptakan sebuah Serial Number tertentu, ia hanya menerima Serial Number yang kita masukan lalu memeriksa apakah sesuai dengan Algoritma S/N yang telah ditetapkan oleh programer.
Pengenalan Program |
Penjelasan singkat mengenai WinU :
"WinU is a Windows 95/98 security access control system with time-out and monitoring features, World Wide Web access tracking, three distinct levels of security control, and many flexible configuration options. It’s easy to set up, easy to use ... and virtually impossible to circumvent."
Program ini mempunyai batasan waktu penggunaan selama 30 hari dan menyediakan tempat untuk memasukan S/N apabila User telah membayar Program Shareware tersebut.
Bagi Register User, akan tercipta bagian WinU di dalam Win.ini seperti di bawah ini :
[WinU4]
userdata=6SF\*.;jihja4c7jh9dgjjihgfefdhidPJ5\FU=
Essay |
Kita mulai...... :-)
Masukan S/N apa saja, dan tekan tombol OK dibawahnya. Untuk sementara jangan gunakan SoftICE, kita perhatikan saja dulu apa yang akan terjadi apabila kita memasukan S/N palsu. Ternyata WinU akan menampilkan sebuah Nag Screen yang tidak ada gunanya. Bila kita klik tombol OK maka kita bisa kembali memasukan S/N lain.
Oke...sekarang masukin kembali sembarang S/N, seperti biasa aku masukin angka "123454321". Sebelum menekan tombol OK, masuk ke dalam SoftICE dan siapkan Breakpoint yang penting. Karena tidak tahu apa yang akan digunakan oleh WinU, aku pasang 3 Breakpoint umum yang biasaya untuk menerima inputan yaitu "BPX GetWindowTextA", "BPX.GetDlgItemTextA" dan "BPX GetDlgItemInt".
Kembali ke Windows dan tekan tombol OK....kita akan terlempar ke dalam SoftICE (
ternyata kali ini yang beruntung adalah GetDlgItemTextA ). Tekan F12 untuk keluar dari
fungsi API tersebut dan masuk ke dalam badan program.
:0042A376 FF152C2C4800
Call dword ptr [00482C2C]
:0042A37C 85C0
test eax, eax
==> Kita ada di sini.
:0042A37E 0F8492060000
je 0042AA16
:0042A384 C785ACFEFFFF01000000 mov dword ptr [ebp+FFFFFEAC],
00000001
:0042A38E C785A8FEFFFF00000000 mov dword ptr [ebp+FFFFFEA8],
00000000
:0042A398 833D80E5470000
cmp dword ptr [0047E580], 00000000
:0042A39F 0F8428000000
je 0042A3CD
:0042A3A5 6A0B
push 0000000B
Tekan F10 selama beberapa kali sampai menemukan rutin berikut ini :
:0042A439 0FBE85B0FEFFFF
movsx eax, byte ptr [ebp+FFFFFEB0] ==> Mengambil karakter 1
dari
S/N palsu kita.
:0042A440 50
push eax
:0042A441 E80ACA0200
call 00456E50
:0042A446 83C404
add esp, 00000004
:0042A449 83F841
cmp eax, 00000041
==> Bandingkan dengan 41h ( A )
:0042A44C 0F85CC010000
jne 0042A61E
==> Tidak sama ? Lompat
Karena karakter pertama dari S/N kita adalah "1" maka kita akan melompat menuju Offset 0042A61E.
:0042A61E 0FBE85B0FEFFFF
movsx eax, byte
ptr [ebp+FFFFFEB0] ==> EAX = Karakter 1 S/N kita
:0042A625 50
push eax
:0042A626 E825C80200
call 00456E50
:0042A62B 83C404
add esp, 00000004
:0042A62E 8985A0FEFFFF
mov dword ptr [ebp+FFFFFEA0], eax ==> [ebp+FFFFFEA0]
= "1"
:0042A634 83BDA0FEFFFF4A cmp
dword ptr [ebp+FFFFFEA0], 0000004A ==> Bandingkan dengan 4Ah ( J )
:0042A63B 0F850F000000
jne 0042A650
==> Tidak sama ? Lompat
:0042A641 C7859CFEFFFF00000000 mov dword ptr [ebp+FFFFFE9C], 00000000
:0042A64B E97A000000
jmp 0042A6CA
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A63B(C)
|
:0042A650 83BDA0FEFFFF4C cmp dword
ptr [ebp+FFFFFEA0], 0000004C ==> Bandingkan dengan 4Ch ( L )
:0042A657 0F850F000000
jne 0042A66C
==> Tidak sama ? Lompat.
:0042A65D C7859CFEFFFF02000000 mov dword ptr [ebp+FFFFFE9C], 00000002
:0042A667 E95E000000
jmp 0042A6CA
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A657(C)
|
:0042A66C 83BDA0FEFFFF4D cmp dword ptr
[ebp+FFFFFEA0], 0000004D ==> Bandingakn dengan 4Dh (M)
:0042A673 0F850F000000
jne 0042A688
==> Tidak sama ? Lompat.
:0042A679 C7859CFEFFFF01000000 mov dword ptr [ebp+FFFFFE9C], 00000001
:0042A683 E942000000
jmp 0042A6CA
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A673(C)
|
:0042A688 83BDA0FEFFFF4B cmp dword
ptr [ebp+FFFFFEA0], 0000004B ==> Bandingkan dengan 4Bh ( K )
:0042A68F 0F850F000000
jne 0042A6A4
==> Tidak sama ? Lompat.
:0042A695 C7859CFEFFFF04000000 mov dword ptr [ebp+FFFFFE9C], 00000004
:0042A69F E926000000
jmp 0042A6CA
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A68F(C)
|
:0042A6A4 83BDA0FEFFFF4E cmp dword ptr [ebp+FFFFFEA0],
0000004E ==> Bandingan dengan 4Eh ( N )
:0042A6AB 0F850F000000
jne
0042A6C0
==> Tidak sama ? Lompat.
:0042A6B1 C7859CFEFFFF03000000 mov dword ptr [ebp+FFFFFE9C], 00000003
:0042A6BB E90A000000
jmp 0042A6CA
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A6AB(C)
|
:0042A6C0 C785ACFEFFFF00000000 mov dword ptr [ebp+FFFFFEAC], 00000000 ==>
[ebp+FFFFFEAC] = 0
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0042A64B(U), :0042A667(U), :0042A683(U), :0042A69F(U), :0042A6BB(U)
|
:0042A6CA C785A4FEFFFF01000000 mov dword ptr [ebp+FFFFFEA4], 00000001
:0042A6D4 E906000000
jmp 0042A6DF
Kalau kita terus menekan F10 kita akan tahu bahwa ternyata program akan menentukan bahwa S/N kita salah. Apa yang terjadi ??? Perhatikan kembali listing program di atas, program melakukan pengecekan terhadap karaketer pertama dari S/N kita. Karakter pertama S/N kita dibandingkan dengan "J", "L", "M", "K", "N". Ternyata karakter pertama dari S/N kita harus sama dengan salah satu karakter tersebut. Kalau begitu kita harus merubahnya, kali ini isi S/N dengan 'J123454321'
Setelah menekan tombol OK, kita akan kembali masuk ke dalam baris - baris perintah di atas, telusuri sampai di Offset 0042A634, dimana karakter pertama dari s/n yang kita masukan dibandingkan dengan huruf 'J'. Kali ini sesuai dan kita akan melompat ke 0042A6CA
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0042A64B(U), :0042A667(U), :0042A683(U), :0042A69F(U), :0042A6BB(U)
|
:0042A6CA C785A4FEFFFF01000000 mov dword ptr [ebp+FFFFFEA4], 00000001
:0042A6D4 E906000000
jmp 0042A6DF
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A6D4(U)
|
:0042A6DF 83BDACFEFFFF00
cmp dword
ptr [ebp+FFFFFEAC], 00000000
:0042A6E6 0F8486000000
je 0042A772
:0042A6EC 8B85A4FEFFFF
mov eax, dword ptr [ebp+FFFFFEA4]
:0042A6F2 0FBE8405B0FEFFFF
movsx eax, byte ptr [ebp+eax-00000150] ==> EAX =
Karakter dari s/n
palsu yang kita
masukan.
Pengecekan secara
berurutan
:0042A6FA 85C0
test eax, eax
==> Apakah EAX ada isinya ?
:0042A6FC 0F8470000000
je 0042A772
==> Jika sudah habis, lompat !
:0042A702 833DAC46470001
cmp dword ptr [004746AC], 00000001
:0042A709 0F8E24000000
jle 0042A733
==> Jump ke 0042A733
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A709(C)
|
:0042A733 8B85A4FEFFFF
mov eax, dword ptr [ebp+FFFFFEA4]
:0042A739 0FBE8405B0FEFFFF
movsx eax, byte ptr
[ebp+eax-00000150] ==> EAX = Karakter dalam s/n
palsu kita
* Possible StringData Ref from Data Obj ->" ((((( "
->" H"
|
:0042A741 8B0DA0444700
mov ecx, dword ptr [004744A0]
==> ECX = 004744AA
:0042A747 33D2
xor edx, edx
==> Kosongkan register EDX
:0042A749 668B1441
mov dx, word ptr [ecx+2*eax]
==> DX = ECX + 2 * EAX
:0042A74D 83E204
and edx, 00000004
==> EDX = EDX and 04
:0042A750 899560FDFFFF
mov dword ptr [ebp+FFFFFD60], edx ==>
[ebp+FFFFFD60] = EDX
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A72E(U)
|
:0042A756 83BD60FDFFFF00
cmp dword
ptr [ebp+FFFFFD60], 00000000 ==> Apakah [ebp+FFFFFD60]
sama dengan 0 ???
:0042A75D 0F850A000000
jne 0042A76D
==> Jika tidak, lompat !
:0042A763 C785ACFEFFFF00000000 mov dword ptr [ebp+FFFFFEAC], 00000000
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A75D(C)
|
:0042A76D E967FFFFFF
jmp 0042A6D9
==> Looping....
Apa yang dilakukan oleh baris - baris perintah dari offset
00442A6D9 - 0042A76D ???
Sebenarnya baris - baris perintah di atas berguna untuk mengecek apakah s/n yang dimasukan oleh User berupa huruf atau angka. Ternyata s/n yang dimasukan tidak boleh berupa huruf, kecuali karakter pertama. Aku baru tahu tentang ini setelah aku masukin s/n berupa huruf 'JABCD'. Dengan sukses-nya, s/n tersebut langsung ditolak :-)
Oh iya ada satu hal lagi yang harus diketahui. Kalo kalian telah berusaha mencoba mengKrak s/w ini, kalian mungkin telah menyadari bahwa jika nilai di dalam [ EBP + FFFFFEAC ] ( dalam SoftICE adalah [ EBP - 0154 ] ) adalah 01 maka pengecekan masih dapat terus berlangsung ( So Far So Good ) tapi jika telah bernilai 00 maka s/w langsung melewati semua pengecekan dan langsung menyatakan "Invalid Serial Number"
Setelah selesai dengan pemeriksaan tahap pertama, berikutnya WinU akan memeriksa panjang s/n yang kita masukan. Perhatikan baris - baris perintah di bawah ini....
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0042A6E6(C), :0042A6FC(C)
|
:0042A772 83BDACFEFFFF00 cmp dword ptr
[ebp+FFFFFEAC], 00000000 ==> So Far So Good ???
:0042A779 0F8420000000
je 0042A79F
==> Kalo tidak, lompat !
:0042A77F 8D85B0FEFFFF
lea eax,
dword ptr [ebp+FFFFFEB0]
==> EAX = J123454321
:0042A785 50
push eax
* Reference To: KERNEL32.lstrlenA, Ord:02A1h
|
:0042A786 FF1554294800
Call dword ptr [00482954]
==> Hitung panjang s/n
:0042A78C 83F80B
cmp eax, 0000000B
==> Panjangnya = 0Bh (= 11 ) ?
:0042A78F 0F840A000000
je 0042A79F
==> Jika ya, lompat !
:0042A795 C785ACFEFFFF00000000 mov dword ptr [ebp+FFFFFEAC], 00000000 ==> Beri
tanda kalo s/n sudah
tidak perlu dicek lagi.
Ternyata panjang s/n-nya harus 11 karakter....s/n yang kita masukan tadi hanya 10 karakter panjangnya, karena itu, s/n kita akan langsung ditolak :-(
But it's okay, paling tidak sejauh ini yang sudah kita ketahui adalah :
Masih belon capek khan ? :-D Ulangi lagi dengan memasukan s/n yang sesaui dengan syarat s/n asli, yang sejauh ini sudah kita ketahui. Kali ini masukan 'J1234543211'
Setelah sampai di Offset 0042A78F, kita akan melompat ke Offset 0042A79F
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0042A779(C), :0042A78F(C)
|
:0042A79F 83BDACFEFFFF00
cmp dword ptr
[ebp+FFFFFEAC], 00000000 ==> So Far So Good ???
:0042A7A6 0F841A000000
je 0042A7C6
==>
Jika tidak valid, lompat !
:0042A7AC 0FBE85B1FEFFFF
movsx eax, byte
ptr [ebp+FFFFFEB1]
==>
EAX = Karakter ke 2
dari s/n palsu kita
:0042A7B3 83F836
cmp eax, 00000036
==>
Apakah EAX = 36h (=06)?
:0042A7B6 0F840A000000
je 0042A7C6
==>
Jika sama, lompat !
:0042A7BC C785ACFEFFFF00000000 mov dword ptr [ebp+FFFFFEAC], 00000000
Kita kembali menemukan salah satu syarat s/n asli, karakter kedua ternyata harus sama dengan 06. Kita harus kembali mengisi s/n, isi dengan 'J6123454321'. Setelah melalui langkah - langkah di atas kembali, kita akan "mendarat" di sini :
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0042A7A6(C), :0042A7B6(C)
|
:0042A7C6 83BDACFEFFFF00
cmp dword ptr
[ebp+FFFFFEAC], 00000000 ==> So Far So Good ???
:0042A7CD 0F8420000000
je 0042A7F3
==> Jika tidak valid, lompat !
:0042A7D3 0FBE85B7FEFFFF
movsx
eax, byte ptr [ebp+FFFFFEB7] ==> EAX = Karakter ke 8
:0042A7DA 2B859CFEFFFF
sub eax, dword ptr [ebp+FFFFFE9C] ==> EAX = EAX -
[ebp+FFFFFE9C]
:0042A7E0 83F834
cmp eax, 00000034
==> Apakah EAX = 34h ( = 04 )
:0042A7E3 0F840A000000
je 0042A7F3
:0042A7E9 C785ACFEFFFF00000000 mov dword ptr [ebp+FFFFFEAC], 00000000
Hmm.....syarat lain lagi :-) Kali ini WinU memeriksa karakter ke 8 dari s/n kita, nilai
dari karakter ke 8 itu apabila dikurangkan dengan isi dari [ebp+FFFFFE9C] harus sama
dengan 34h atau 04.
Berapakah nilai [ebp+FFFFFE9C] ???
Lihat kembali ke Offset 0042A641 :
:0042A641 C7859CFEFFFF00000000 mov dword ptr [ebp+FFFFFE9C], 00000000
Apabila karakter pertama dari s/n kita adalah 'J' maka [ebp+FFFFFE9C] di-isi dengan nilai 0, dengan demikian sesuai dengan rumus di atas, perhitungannya menjadi :
Kita beruntung kali ini, kebetulan karakter ke 8 dalam s/n kita adalah 04 sehingga syarat ini dapat dilewati dengan mulus :-)
Tahap berikutnya cukup panjang, secara umum WinU akan mengambil karakter - karakter tertentu dari s/n kita dan menghitungnya. Pada akhir perhitungan, hasil perhitungan itu harus sama dengan angka pada posisi ke 5 dalam s/n kita.
Berikut ini adalah proses penghitungannya ( Ingat S/N yang kita masukan adalah : 'J6123454321': )
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:0042A7CD(C), :0042A7E3(C)
|
:0042A7F3 83BDACFEFFFF00 cmp
dword ptr [ebp+FFFFFEAC], 00000000 ==> So Far So Good ???
:0042A7FA 0F84D0010000
je 0042A9D0
==> Jika tidak valid, lompat !
:0042A800 C78594FEFFFF00000000 mov dword ptr [ebp+FFFFFE94], 00000000
==> [ebp+FFFFFE94] = 00
:0042A80A 0FBE85B2FEFFFF movsx
eax, byte ptr [ebp+FFFFFEB2]
==> EAX = Karakter ke 3
:0042A811 8D0445A0FFFFFF
lea eax, dword ptr
[2*eax+FFFFFFA0]
==>
EAX = [2*eax+FFFFFFA0]
:0042A818 89859CFEFFFF
mov dword ptr [ebp+FFFFFE9C], eax
==>
[ebp+FFFFFE9C] = EAX
:0042A81E 8B859CFEFFFF
mov eax, dword ptr [ebp+FFFFFE9C]
==>
EAX = [ebp+FFFFFE9C]
:0042A824 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax ==>
EAX = EAX + [ebp+FFFFFE94]
:0042A82A 83BD9CFEFFFF0A cmp dword
ptr [ebp+FFFFFE9C], 0000000A ==> [ebp+FFFFFE9C] = 0A ???
:0042A831 0F8C07000000
jl 0042A83E
==> Lebih kecil, lompat !
:0042A837 83AD94FEFFFF09
sub dword ptr
[ebp+FFFFFE94], 00000009 ==> Lebih besar,
[ebp+FFFFFE94] = [ebp+FFFFFE94] - 09
Perhitungan berikutnya sama saja, kecuali karakter yang akan diambil.
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A831(C)
|
:0042A83E 0FBE85B6FEFFFF
movsx eax, byte ptr
[ebp+FFFFFEB6]
==> EAX = Karakter ke 7
:0042A845 8D0445A0FFFFFF
lea eax, dword ptr
[2*eax+FFFFFFA0]
:0042A84C 89859CFEFFFF
mov dword ptr [ebp+FFFFFE9C], eax
:0042A852 8B859CFEFFFF
mov eax, dword ptr [ebp+FFFFFE9C]
:0042A858 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
:0042A85E 83BD9CFEFFFF0A cmp dword
ptr [ebp+FFFFFE9C], 0000000A
:0042A865 0F8C07000000
jl 0042A872
:0042A86B 83AD94FEFFFF09 sub
dword ptr [ebp+FFFFFE94], 00000009
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A865(C)
|
:0042A872 0FBE85B9FEFFFF
movsx eax, byte
ptr [ebp+FFFFFEB9] ==>
EAX = Karakter ke 10
:0042A879 8D0445A0FFFFFF
lea eax, dword
ptr [2*eax+FFFFFFA0]
:0042A880 89859CFEFFFF
mov dword ptr [ebp+FFFFFE9C], eax
:0042A886 8B859CFEFFFF
mov eax, dword ptr [ebp+FFFFFE9C]
:0042A88C 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
:0042A892 83BD9CFEFFFF0A
cmp dword ptr
[ebp+FFFFFE9C], 0000000A
:0042A899 0F8C07000000
jl 0042A8A6
:0042A89F 83AD94FEFFFF09
sub dword ptr
[ebp+FFFFFE94], 00000009
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A899(C)
|
:0042A8A6 0FBE85BAFEFFFF
movsx eax, byte ptr
[ebp+FFFFFEBA] ==>
EAX = Karakter ke 11
:0042A8AD 8D0445A0FFFFFF
lea eax, dword ptr
[2*eax+FFFFFFA0]
:0042A8B4 89859CFEFFFF
mov dword ptr [ebp+FFFFFE9C], eax
:0042A8BA 8B859CFEFFFF
mov eax, dword ptr [ebp+FFFFFE9C]
:0042A8C0 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
:0042A8C6 83BD9CFEFFFF0A cmp
dword ptr [ebp+FFFFFE9C], 0000000A
:0042A8CD 0F8C07000000
jl 0042A8DA
:0042A8D3 83AD94FEFFFF09
sub dword ptr
[ebp+FFFFFE94], 00000009
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A8CD(C)
|
:0042A8DA 0FBE85B1FEFFFF
movsx eax, byte ptr
[ebp+FFFFFEB1] ==>
EAX = Karakter ke 2
:0042A8E1 83E830
sub eax, 00000030
==> EAX = EAX - 30
:0042A8E4 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
==>
[ebp+FFFFFE94] =
[ebp+FFFFFE94] + EAX
:0042A8EA 0FBE85B5FEFFFF
movsx eax, byte
ptr [ebp+FFFFFEB5] ==>
EAX = Karakter ke 6
:0042A8F1 83E830
sub eax, 00000030
:0042A8F4 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
:0042A8FA 0FBE85B7FEFFFF
movsx eax, byte
ptr [ebp+FFFFFEB7] ==.
EAX = Karakter ke 8
:0042A901 83E830
sub eax, 00000030
:0042A904 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
:0042A90A 0FBE85B8FEFFFF
movsx eax, byte
ptr [ebp+FFFFFEB8] ==>
EAX = Karakter ke 9
:0042A911 83E830
sub eax, 00000030
:0042A914 018594FEFFFF
add dword ptr [ebp+FFFFFE94], eax
:0042A91A B90A000000
mov ecx, 0000000A
==>
ECX = 0Ah
:0042A91F 8B8594FEFFFF
mov eax, dword ptr [ebp+FFFFFE94]
==> EAX =
[ebp+FFFFFE94]
:0042A925 99
cdq
:0042A926 F7F9
idiv ecx
==> EAX = EAX idiv ECX
:0042A928 899594FEFFFF
mov
dword ptr [ebp+FFFFFE94], edx
==>
[ebp+FFFFFE94] = EDX
:0042A92E 0FBE85B4FEFFFF
movsx eax,
byte ptr [ebp+FFFFFEB4] ==>
EAX = Karakter ke 5
:0042A935 8B8D94FEFFFF
mov ecx, dword ptr [ebp+FFFFFE94]
==> ECX =
[ebp+FFFFFE94]
:0042A93B 83C130
add ecx, 00000030
==>
ECX = ECX + 30
:0042A93E 3BC1
cmp eax, ecx
==>
Apakah EAX = ECX ???
:0042A940 0F840A000000
je 0042A950
==>
Sama, lompat !
:0042A946 C785ACFEFFFF00000000 mov dword ptr [ebp+FFFFFEAC], 00000000
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:0042A940(C)
|
:0042A950 83BDA0FEFFFF4B
cmp dword ptr
[ebp+FFFFFEA0], 0000004B ==> Apakah karakter 1 = 4Bh
:0042A957 0F8573000000
jne 0042A9D0
==> Tidak sama, lompat !
Dari langkah - langkah di atas, terlihat bahwa karakter ke 5 dari s/n yang kita masukan harus sesuai dengan perhtungan yang telah dilakukan oleh WinU. Dalam contoh s/n di atas, karakter ke 5 harus berupa angka 6 atau 36 dalam hexa.
Kalo begitu, masukan kembali s/n, 'J6126454321'.dan lihat hasilnya ......KRAKED :-)
K r a K |
Nothing..... :-)
A s s e m b l y N o t e s |
- CDQ : Convert Doubleword to Quadword
Perintah ini digunakan untuk merubah nilai 32-bit dalam EAX menjadi sebuah nilai 64-bit yang disimpan di dalam EDX : EAX dengan cara mengosongkan nilai EDX.
- IDIV [Operand] : Signed ( Integer ) Division
Idiv akan membagi nilai di dalam register EDX : EAX dengan Operand, hasilnya akan dimasukan ke dalam EAX sedangkan sisanya disimpan di dalam EDX.
Catatan Singkat |
Sistem Proteksi yang dipakai oleh WinU sebenarnya cukup mudah untuk ditembus, yang mungkin dibutuhkan bagi para newbie dalam mengKrak s/w ini adalah kesabaran karena kita harus berulang kali mencoba memasukan s/n dan melihat efeknya pada s/w tersebut :-)
Berikut adalah ketentuan dalam Algoritma WinU dalam Validasi Serial Number :
Tidak seperti Sistem Proteksi lainnya yang menuntut persamaan yang identik antara S/N yang kita masukin dengan S/N Valid, Sistem Proteksi ini hanya memeriksa apakah S/N yang dimasukan sesuai dengan algoritma S/N yang valid. Coba masukan s/n yang berbeda dengan contoh yang aku kasi' dan perhatikan langkah-langkah dalam Validasi Serial Number-nya.....kalo ada yang ngak kamu mengerti, kamu bisa langsung tanya via mail ke chupacabra@softhome.net
Program dengan Sistem Proteksi sejenis yang bisa kamu coba salah satunya adalah eWords 1.0.
GreetZ |
GreetZ untuk anak - anak [eKH] en other Underground Group :-)
>> Star Krak The Next Generation - To Boldly Krak Where No One Had Krak Before
<<
<*~ MTFBWY ~*>
Copyright 011999 - CHuPaCaBRa [eKH]