How to remove the CD protection in Mortal Kombat 4
Comment cracker MORTAL KOMBAT 4
Attention, il n’y a pas d’étapes pour ce crack, désolé. Il faut donc bien suivre.
Mortal Kombat 4 doit être cracké d’une manière différence des jeux précédemment car les recherches de "Please Insert the CD" ou les choses comme ça ne marche pas. Alors nous allons appliquer le plan 2 et recherchez "GetDriveTypeA" dans l’appel du KERNEL 32. Pour savoir si cet appel a été utilisé, vérifié en désassemblant le programme et vous devriez voir quelque chose comme ça:
+++++++++++++++++++ IMPORT MODULE DETAILS +++++++++++++++
Import Module 001: KERNEL32.dll
Addr:xxxxxxxx hint(xxxx) Name: ?????????????
--- liste de nombreux appels
Addr:000D3BBE hint(00DF) Name: GetDriveTypeA
--- liste de nombreux appelsAlors si il est utilisé, vous aurais besoin de recherchez la chaîne pour la trouver dans le code désassemblé après la routine de vérification et faire un edit et réalisé que j’ai viré les vidéos, l’intro, et la conclusion mais pas la protection. Ceci est donc vraiment la dernière chose à faire pour cracker comme trouver un appel dans le WINMM comme dans leKERNEL32.DLL ce qui devrait marqué ceci:
Import Module 005: WINMM.dll
Addr:000D410E hint(001A) Name: joyGetDevCapsA
Addr:000D414C hint(0094) Name: timeEndPeriod
Addr:000D413A hint(0093) Name: timeBeginPeriod
Addr:000D412C hint(001E) Name: joyGetPosEx
Addr:000D4120 hint(001D) Name: joyGetPos
Addr:000D40FE hint(0017) Name: auxSetVolume
Addr:000D40EE hint(0014) Name: auxGetNumDevs
Addr:000D40DC hint(0012) Name: auxGetDevCapsA
Addr:000D40CC hint(0015) Name: auxGetVolume
Addr:000D40BE hint(0097) Name: timeGetTime
Addr:000D40AC hint(0032) Name: mciSendCommandAC’est le dernier appel qui nous intéresse ici, car il est utilisé pour les CD de musiques. Donc si un appel revient avec une erreur, ce qu’il n’y a pas de CD dans le lecteur. Ce programme peut vérifié la taille des pistes audios et d’autres choses qui prouveront que le CD est bien un original. Donc nous devons rechercher la chaîne "mciSendCommandA". En faisant ceci, vous allez arriver à ce morceau de code qui est la première séquence de votre recherche:
* Referenced by a CALL at Addresses:
|:004AC333 , :004AC385 , :004AC4B9 , :004AC51C , :004AC58C <-- 9 parties de code à vérifier
|:004AC61F , :004AC73B , :004AC926 , :004C3EFE
|:004AC2B0 A180185400 mov eax, dword ptr [00541880]
:004AC2B5 83EC24 sub esp, 00000024
:004AC2B8 85C0 test eax, eax
:004AC2BA 56 push esi
* Reference To: WINMM.mciSendCommandA, Ord:0032h <-- la chaîne de référence
:004AC2BB 8B353C024D00 mov esi, dword ptr [004D023C]
:004AC2C1 7531 jne 004AC2F4
:004AC2C3 8D442414 lea eax, dword ptr [esp+14]
* Possible StringData Ref from Data Obj ->"cdaudio" <-- Parle du CD audio
:004AC2C7 C744241C84264F00 mov [esp+1C], 004F2684
:004AC2CF 50 push eax
:004AC2D0 6800210000 push 00002100
:004AC2D5 6803080000 push 00000803
:004AC2DA 6A00 push 00000000
:004AC2DC FFD6 call esi
:004AC2DE F7D8 neg eax
:004AC2E0 1BC0 sbb eax, eax
:004AC2E2 40 inc eax
:004AC2E3 A380185400 mov dword ptr [00541880], eax
:004AC2E8 743F je 004AC329
:004AC2EA 8B4C2418 mov ecx, dword ptr [esp+18]
:004AC2EE 890D60185400 mov dword ptr [00541860], ecx
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004AC2C1(C)
|:004AC2F4 A160185400 mov eax, dword ptr [00541860]
:004AC2F9 8D542404 lea edx, dword ptr [esp+04]
:004AC2FD 52 push edx
:004AC2FE 6800010000 push 00000100
:004AC303 6814080000 push 00000814
:004AC308 50 push eax
:004AC309 C744241C05000000 mov [esp+1C], 00000005
:004AC311 FFD6 call esi
:004AC313 85C0 test eax, eax
:004AC315 7512 jne 004AC329
:004AC317 8B442408 mov eax, dword ptr [esp+08]
:004AC31B 85C0 test eax, eax
:004AC31D 740A je 004AC329 <-- Si c’est 0 , alors il y a une erreur
:004AC31F B801000000 mov eax, 00000001 <-- Sinon une autre valeur est sauvé
:004AC324 5E pop esi <-- dans eax pour un bon résultat
:004AC325 83C424 add esp, 00000024
:004AC328 C3 ret
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:004AC2E8(C), :004AC315(C), :004AC31D(C)
:004AC329 33C0 xor eax, eax <-- inutile , mais est sure que EAX=0
:004AC32B 5E pop esi
:004AC32C 83C424 add esp, 00000024
:004AC32F C3 retPour être sûr que cette partie de code est utilisé pour la vérification du CD, j’ai change la valeur de EAX de 00000001 en mov eax,00000000 ce qui provoque une erreur. Alors j’ai lancé le jeu avec le CD dans mon lecteur et regardé le résultat. Et le jeu demanda l’original. Donc nous devons tout d’abord le tromper sur cette valeur et faire totalement sauté la vérif du CD. En vérifiant le premier appel, rien d’intéressant n’en est sorti. Alors j’ai vérifié le second appel et j’ai trouvé cela:
* Referenced by a CALL at Address:
|:004C3F1B <-- d’où il a été appelé
:004AC380 83EC1C sub esp, 0000001C
:004AC383 56 push esi
:004AC384 57 push edi
:004AC385 E826FFFFFF call 004AC2B0
:004AC38A 85C0 test eax, eax
:004AC38C 0F84A3000000 je 004AC435
:004AC392 8B0D60185400 mov ecx, dword ptr [00541860]
:004AC398 8B7C2428 mov edi, dword ptr [esp+28]
* Reference To: WINMM.mciSendCommandA, Ord:0032h <-- un autre appel WINMM
:004AC39C 8B353C024D00 mov esi, dword ptr [004D023C]
:004AC3A2 8D442414 lea eax, dword ptr [esp+14]
:004AC3A6 50 push eax
:004AC3A7 6810010000 push 00000110
:004AC3AC 6814080000 push 00000814
:004AC3B1 51 push ecx
:004AC3B2 C744242C01400000 mov [esp+2C], 00004001
:004AC3BA 897C2430 mov dword ptr [esp+30], edi
:004AC3BE FFD6 call esi
:004AC3C0 85C0 test eax, eax
:004AC3C2 7571 jne 004AC435
:004AC3C4 817C241840040000 cmp dword ptr [esp+18], 00000440
:004AC3CC 7567 jne 004AC435
:004AC3CE A160185400 mov eax, dword ptr [00541860]
:004AC3D3 8D542408 lea edx, dword ptr [esp+08]
:004AC3D7 52 push edx
:004AC3D8 6800040000 push 00000400
:004AC3DD 680D080000 push 0000080D
:004AC3E2 50 push eax
:004AC3E3 C744241C02000000 mov [esp+1C], 00000002
:004AC3EB FFD6 call esi
:004AC3ED 8B1560185400 mov edx, dword ptr [00541860]
:004AC3F3 8D4C2414 lea ecx, dword ptr [esp+14]
:004AC3F7 51 push ecx
:004AC3F8 6810010000 push 00000110
:004AC3FD 6814080000 push 00000814
:004AC402 52 push edx
:004AC403 C744242C01000000 mov [esp+2C], 00000001
:004AC40B 897C2430 mov dword ptr [esp+30], edi
:004AC40F FFD6 call esi
:004AC411 85C0 test eax, eax
:004AC413 7520 jne 004AC435
:004AC415 8B442418 mov eax, dword ptr [esp+18]
:004AC419 33C9 xor ecx, ecx
:004AC41B 8ACC mov cl, ah
:004AC41D 25FF000000 and eax, 000000FF
:004AC422 8D0440 lea eax, dword ptr [eax+2*eax]
:004AC425 8D1480 lea edx, dword ptr [eax+4*eax]
:004AC428 C1E202 shl edx, 02
:004AC42B 03CA add ecx, edx
:004AC42D 8BC1 mov eax, ecx
:004AC42F 5F pop edi
:004AC430 5E pop esi
:004AC431 83C41C add esp, 0000001C
:004AC434 C3 ret
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses:
|:004AC38C(C), :004AC3C2(C), :004AC3CC(C), :004AC413(C)
|:004AC435 5F pop edi
:004AC436 33C0 xor eax, eax
:004AC438 5E pop esi
:004AC439 83C41C add esp, 0000001C
:004AC43C C3 retJ’ai recommencé avec une version non modifié du fichier MK4.EXE et j’ai changé le saut conditionnel en 4AC38C en un saut normal. J’ai relancé MK4 et il me demandé encore le CD. Nous sommes sur la bonne piste. Retraçons cette routine et vérifions le code.
* Referenced by a CALL at Addresses:
|:004B1B78 , :004B8248
|:004C3EA0 83EC3C sub esp, 0000003C
:004C3EA3 56 push esi
:004C3EA4 33C9 xor ecx, ecx <-- ECX est revenu à 0
:004C3EA6 B85C000000 mov eax, 0000005C
:004C3EAB 57 push edi
:004C3EAC 894C2408 mov dword ptr [esp+08], ecx <-- place des variables
:004C3EB0 8944240C mov dword ptr [esp+0C], eax
:004C3EB4 89442410 mov dword ptr [esp+10], eax
:004C3EB8 89442414 mov dword ptr [esp+14], eax
:004C3EBC 89442418 mov dword ptr [esp+18], eax
:004C3EC0 8944241C mov dword ptr [esp+1C], eax
:004C3EC4 89442420 mov dword ptr [esp+20], eax
:004C3EC8 89442424 mov dword ptr [esp+24], eax
:004C3ECC C74424287A000000 mov [esp+28], 0000007A
:004C3ED4 C744242C10000000 mov [esp+2C], 00000010
:004C3EDC C744243038000000 mov [esp+30], 00000038
:004C3EE4 89442434 mov dword ptr [esp+34], eax
:004C3EE8 89442438 mov dword ptr [esp+38], eax
:004C3EEC 8944243C mov dword ptr [esp+3C], eax
:004C3EF0 C74424405A000000 mov [esp+40], 0000005A
:004C3EF8 890DFCDC4F00 mov dword ptr [004FDCFC], ecx <-- met un 0 ici
:004C3EFE E8AD83FEFF call 004AC2B0
:004C3F03 85C0 test eax, eax
:004C3F05 743E je 004C3F45
:004C3F07 E82484FEFF call 004AC330
:004C3F0C 83F80F cmp eax, 0000000F
:004C3F0F 7534 jne 004C3F45
:004C3F11 BE01000000 mov esi, 00000001
:004C3F16 8D7C240C lea edi, dword ptr [esp+0C]
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004C3F39(C)
|:004C3F1A 56 push esi
:004C3F1B E86084FEFF call 004AC380
:004C3F20 8B57FC mov edx, dword ptr [edi-04]
:004C3F23 83C404 add esp, 00000004
:004C3F26 2BC2 sub eax, edx
:004C3F28 99 cdq
:004C3F29 33C2 xor eax, edx
:004C3F2B 2BC2 sub eax, edx
:004C3F2D 83F805 cmp eax, 00000005
:004C3F30 7F13 jg 004C3F45
:004C3F32 46 inc esi
:004C3F33 83C704 add edi, 00000004
:004C3F36 83FE0F cmp esi, 0000000F
:004C3F39 7EDF jle 004C3F1A <-- Compare et saute probablement
:004C3F3B C705FCDC4F0001000000 mov dword ptr [004FDCFC], 00000001 <-- 01 quand s’était initialisé avec 00
* Referenced by a (U)nconditional or (C)onditional Jump at Addresses: <-- pourrait être des flags utilisés plus tard
|:004C3F05(C), :004C3F0F(C), :004C3F30(C)
:004C3F45 5F pop edi
:004C3F46 5E pop esi
:004C3F47 83C43C add esp, 0000003C
:004C3F4A C3 retDans tous mes cracks, j’ai parfois remarqué des choses comme un brouillage d’adresses et que le code qui est dedans est une valeur différente après le saut conditionnel. Plus souvent, ceci met un flag avec un valeur provoquant l’échec, faisant faire un test au CD et si le test passe alors le flag passera à une bonne valeur. Ok, revenons un pas en arrière et regardons ce code :
:004B1B6E E89DE1F6FF call 0041FD10
:004B1B73 E8A82CFBFF call 00464820
:004B1B78 E823230100 call 004C3EA0 <-- appelle la routine pour vérifié le CD
:004B1B7D A1FCDC4F00 mov eax, dword ptr [004FDCFC]<vérif valeur du flag
:004B1B82 85C0 test eax, eax
:004B1B84 750A jne 004B1B90 <-- rien mais 01 passe
:004B1B86 6A07 push 00000007
:004B1B88 E8B33B0000 call 004B5740 <-- Fait le sale bruit et demande le CD
:004B1B8D 83C404 add esp, 00000004
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B1B84(C)
|:004B1B90 C3 retOk, je redémarre avec une copie pas encore modifié de MK4 et je NOPe le saut conditionnel à l’adresse 4B1B84 et relance le jeu avec le CD dans le lecteur. Il redemande le CD en faisant le bruit. Nous savons que la vérification du CD est donc en 4C3EA0 et qu’il est appelé depuis 4B1B78 et 4B8248. Recherchez donc dans le fichier MK4.Exe la chine E8 23 23 01 00 et remplacé la par B8 01 00 00 00 (mov eax,00000001). Recherchez alors l’autre appel pour la vérification du CD (E8 53 BC 00 00) et faites pareil. Vous aurez une version crackée de MK4 et vous pourrez jouer à partir du disque dur.
Mais avec l’arrivée de WIN98 et DIRECT X6, ce crack n’était pas pareil. J’ai donc fait pareil qu’au dessus et j’ai trouvé les 2 vérifs du CD et j’ai refait le même type de patchs
:004B2618 E8F3D6F6FF call 0041FD10
:004B261D E80E22FBFF call 00464830
:004B2622 E8C92B0100 call 004C51F0 <-- fait la vérif du CD
:004B2627 39357CFD4F00 cmp dword ptr [004FFD7C], esi <-- vérifie le flag
:004B262D 750A jne 004B2639 < si ce n’est pas égal saute et demande CD
:004B262F 6A07 push 00000007
:004B2631 E80A3D0000 call 004B6340 <-- le sale son et demande le CD
:004B2636 83C404 add esp, 00000004
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B262D(C)
|:004B2639 893520F97A00 mov dword ptr [007AF920], esi
:004B263F 89351CF97A00 mov dword ptr [007AF91C], esi
:004B2645 E816A4FFFF call 004ACA60<- rappelez vous de cet appel plus tard
:004B264A 85C0 test eax, eax
:004B264C 7430 je 004B267E
* Reference To: WINMM.timeGetTime, Ord:0097h
:004B264E FF1540224D00 Call dword ptr [004D2240]
:004B2654 50 push eax
:004B2655 E8A63E0100 call 004C6500
:004B265A 83C404 add esp, 00000004
:004B265D E8AE3E0100 call 004C6510
:004B2662 A803 test al, 03
:004B2664 7409 je 004B266F
:004B2666 893D20F97A00 mov dword ptr [007AF920], edi
:004B266C 5F pop edi
:004B266D 5E pop esi
:004B266E C3 ret
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B2664(C)
|:004B266F E89C3E0100 call 004C6510
:004B2674 0D81180000 or eax, 00001881
:004B2679 A31CF97A00 mov dword ptr [007AF91C], eax
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B264C(C)
|:004B267E 5F pop edi
:004B267F 5E pop esi
:004B2680 C3 retCa marche à peu prés. Tu ne peux pas bougez à gauche du le long du jeu, même avec ton combattant ou dans le menu de sélection. C’est donc qu’il doit y avoir un deuxième type de protection. J’ai vérifié le désassemblage et j’ai trouvé des octets fantômes (c’est à dire des octets utilisés pour commencer dans la mémoire comme 41FD10 au lieu de 41FD1x où x est compris entre 1 et 9), et dans ce cas les octets fantômes sont remplacés par 90. J’en ai pris un et je l’ai modifié en 91 et, j’ai lancé le jeu. Le jeu commença, ne me demanda pas le CD, ou autre chose, mais je ne pouvais toujours pas bouger à gauche. Donc il y avait une vérif de CRC dans le jeu (ou une autre vérification de ce type). Donc nous devons la tracer dans le programme pour trouver cette vérif. Je pensais que le programme devait lancer cette vérification sur lui-même et donc qu’il devait lire l’exécutable sur le disque dur. Et je savais comment le rb marché (read binary ). Je suis donc allé dans le menu des références et j’ai sélectionné "String data References" et j’ai descendu autour le code et je suis arrivé là-dedans :
* Referenced by a CALL at Address:
|:004ACA92 <-- C’est l’adresse qui l’appelle
:004ACAE0 B810400000 mov eax, 00004010
:004ACAE5 E8E6920100 call 004C5DD0
:004ACAEA 8B842414400000 mov eax, dword ptr [esp+00004014]
:004ACAF1 53 push ebx
:004ACAF2 55 push ebp
:004ACAF3 56 push esi
:004ACAF4 57 push edi
* Possible StringData Ref from Data Obj ->"rb" <- on utilise un appel "read binary"
:004ACAF5 685C504D00 push 004D505C
:004ACAFA 50 push eax
:004ACAFB E8B0920100 call 004C5DB0
:004ACB00 8BD8 mov ebx, eax
:004ACB02 83C408 add esp, 00000008
:004ACB05 85DB test ebx, ebx
:004ACB07 7510 jne 004ACB19
:004ACB09 B8FEFFFFFF mov eax, FFFFFFFE
:004ACB0E 5F pop edi
:004ACB0F 5E pop esi
:004ACB10 5D pop ebp
:004ACB11 5B pop ebx
:004ACB12 81C410400000 add esp, 00004010
:004ACB18 C3 retA partir d’ici, nous devons retourner à l’appel pour voir si cela a à voir avec la protection. Vérifions le code autour de la routine 4ACA92 pour voir ce que c’est :
* Referenced by a CALL at Address:
|:004B2645 <-- c’est appelé d’ici
:004ACA60 81EC00040000 sub esp, 00000400
:004ACA66 8D442400 lea eax, dword ptr [esp]
:004ACA6A 6800040000 push 00000400
:004ACA6F 50 push eax
:004ACA70 6A00 push 00000000
* Reference To: KERNEL32.GetModuleHandleA, Ord:00FEh
:004ACA72 FF152C214D00 Call dword ptr [004D212C]
:004ACA78 50 push eax
* Reference To: KERNEL32.GetModuleFileNameA, Ord:00FCh <-- vérifie le nom de l exe
:004ACA79 FF15A0204D00 Call dword ptr [004D20A0]
:004ACA7F 85C0 test eax, eax
:004ACA81 750A jne 004ACA8D
:004ACA83 83C8FF or eax, FFFFFFFF
:004ACA86 81C400040000 add esp, 00000400
:004ACA8C C3 ret
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004ACA81(C) <-- on arrive ici avec un saut inconditionnel
:004ACA8D 8D4C2400 lea ecx, dword ptr [esp]
:004ACA91 51 push ecx
:004ACA92 E849000000 call 004ACAE0 <-- l’appel à l’appel "rb"
:004ACA97 83C404 add esp, 00000004
:004ACA9A 85C0 test eax, eax
:004ACA9C 752C jne 004ACACA
:004ACA9E 8B1520395400 mov edx, dword ptr [00543920]
:004ACAA4 A198464F00 mov eax, dword ptr [004F4698]
:004ACAA9 3BD0 cmp edx, eax
:004ACAAB 750F jne 004ACABC
:004ACAAD A124395400 mov eax, dword ptr [00543924]
:004ACAB2 8B0D9C464F00 mov ecx, dword ptr [004F469C]
:004ACAB8 3BC1 cmp eax, ecx
:004ACABA 740C je 004ACAC8
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004ACAAB(C)
:004ACABC B8F6FFFFFF mov eax, FFFFFFF6 <- sorties et valeurs de sorties
:004ACAC1 81C400040000 add esp, 00000400
:004ACAC7 C3 ret
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004ACABA(C)
:004ACAC8 33C0 xor eax, eax <-- sorties et valeurs de sorties
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004ACA9C(C)
:004ACACA 81C400040000 add esp, 00000400
:004ACAD0 C3Pour moi, cette partie de code semble bien être la coupable. Elle fait quelques appels à KERNEL32 et utilise le module "nom du fichier". Cela sous-entend que le nom de l’exécutable était lancé ? retournons donc à l’appel 4B2645 et vérifions le
:004B2618 E8F3D6F6FF call 0041FD10
:004B261D E80E22FBFF call 00464830
:004B2622 E8C92B0100 call 004C51F0 <-- vérif du CD
:004B2627 39357CFD4F00 cmp dword ptr [004FFD7C], esi <-- teste le flag
:004B262D 750A jne 004B2639 <-- si ce n’est pas égal , demande le CD
:004B262F 6A07 push 00000007
:004B2631 E80A3D0000 call 004B6340 <-- le sale son et demande le CD
:004B2636 83C404 add esp, 00000004
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B262D(C)
:004B2639 893520F97A00 mov dword ptr [007AF920], esi
:004B263F 89351CF97A00 mov dword ptr [007AF91C], esi
:004B2645 E816A4FFFF call 004ACA60 <-- lit le fichier .exe
:004B264A 85C0 test eax, eax <-- vérifie les valeurs qui sont retournées
:004B264C 7430 je 004B267E <-- on a besoin de prendre ce saut
* Reference To: WINMM.timeGetTime, Ord:0097h
:004B264E FF1540224D00 Call dword ptr [004D2240]
:004B2654 50 push eax
:004B2655 E8A63E0100 call 004C6500
:004B265A 83C404 add esp, 00000004
:004B265D E8AE3E0100 call 004C6510
:004B2662 A803 test al, 03
:004B2664 7409 je 004B266F
:004B2666 893D20F97A00 mov dword ptr [007AF920], edi
:004B266C 5F pop edi
:004B266D 5E pop esi
:004B266E C3 ret
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B2664(C)
:004B266F E89C3E0100 call 004C6510 <-- fait un CRC
:004B2674 0D81180000 or eax, 00001881 <-- ou le résultat avec le CRC actuel
:004B2679 A31CF97A00 mov dword ptr [007AF91C], eax <-- qui est stocké ici
* Referenced by a (U)nconditional or (C)onditional Jump at Address:
|:004B264C(C)
:004B267E 5F pop edi
:004B267F 5E pop esi
:004B2680 C3 retNous avons enfin terminé le code qui fait la vérif. Nous avons aussi trouvé le code faisant le CRC, et si nous essayions de le cracké ?. La seule chose différent avec cette nouvelle version de Mortal Kombat 4.exe provenant du net est ce CRC, donc pour les 2 appels, il faut faire pareil qu’avant (c’est à dire les motifs que l’on a fait avant). Maintenant que vous avez modifié les 2 appels avec mov, eax,0000001, nous devons faire péter ce CRC. J’ai déjà changer le premier appel (call 004ACA60) en xor eax, eax et remplacez le reste avec des NOP’s. Ceci va effectivement forcer le saut en 4B264C à toujours être pris, ce qui va permettre de jouer avec une version non bugle sans le CD. Suivez ce qui suit pour faire un version crackée de MK4 (attention à la version ):
- faire une installation normale du jeu (2 fichiers de copiés )
- Copiez tous les fichiers du répertoire "DATA" du CD MK4 dans le même répertoire que vous avez installé MK4 (excepté mk4.exe)
- Editer Mortal Kombat 4.exe
Cherchez E8 23 23 01 00 à l’adresse 724,856 et remplacez par B8 01 00 00 00
Cherchez E8 53 BC 00 00 à l’adresse 751,176 et remplacez par B8 01 00 00 00 - Editez Mortal Kombat 4.exe from mk4patch1.zip off the net
- Cherchez E8 C9 2B 01 00 à l’adresse 727,586 et remplacez par B8 01 00 00 00
- Cherchez E8 16 A4 FF FF à l’adresse 727,621 et remplacez par 33 C0 90 90 90
- Cherchez E8 83 C3 00 00 à l’adresse 754,280 et remplacez par B8 01 00 00 00
Après avoir copier les fichiers, et fait les changements, vous avez une copie de MK4 qui marche sans le CD
NOTE: le fichier MK4.exe du CD est présent sur votre disque dur sous le nom Mortal Kombat 4.exe. Vous n’en avez donc pas besoin.
