WinU v4.3

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=

Kita mulai...... :-)

Oke...sekarang masukin 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 :

• Karakter pertama harus 'J', 'L', 'M', 'K' ato 'N'
• Karakter ke 2 sampai selesai harus berupa angka.
• Panjang s/n harus 11 karakter

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 ==> 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 :

• EAX = 04
• EAX = 04 - [ebp+FFFFFE9C] = 04 - 00 = 04

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 ==> EAX = Karakter ke 6
:0042A8F1 83E830 sub eax, 00000030
:0042A8F4 018594FEFFFF add dword ptr [ebp+FFFFFE94], eax
:0042A8FA 0FBE85B7FEFFFF ==.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 :-)

- 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.

Berikut adalah ketentuan dalam Algoritma WinU dalam Validasi Serial Number :

• Karakter pertama harus merupakan huruf dari salah satu huruf yang telah tersedia yaitu 'J', 'L', 'M', K' ato 'N'
  • Jika karakter pertama adalah 'J' maka [EBP+FFFFFE9C]. = 00
  • Jika karakter pertama adalah 'L' maka [EBP+FFFFFE9C]  = 02
  • Jika karakter pertama adalah 'M' maka [EBP+FFFFFE9C]. = 01
  • Jika karakter pertama adalah 'K' maka [EBP+FFFFFE9C]. = 04
  • Jika karakter pertama adalah 'N' maka [EBP+FFFFFE9C]. = 03
• Jumlah karakter dalam Serial Number tersebut harus sama dengan 11 karakter.
• Karakter - karakter berikutnya harus angka.
• Karakter ke-dua harus angka 06
• Karakter ke-delapan harus sama dengan 04 apabila angka pada posisi tersebut dikurangkan dengan [EBP+FFFFFE9C] yang nilainya seperti yang telah tertera di atas.
• Setelah melalui proses perhitungan, angka pada posisi ke-lima harus sama dengan hasil perhitungan tersebut.