Please consider a donation to the Higher Intellect project. See or the Donate to Higher Intellect page for more info.

Introduction to Win95 Cracking

From Higher Intellect Vintage Wiki
Jump to navigation Jump to search
Introduction to Win95 Cracking

A few words before beginning

     Giving credits, where credit is due ! So, i'd like to give a really
     BIG thanks to ED!SON of United Cracking Force for his tutorial about
     Windows 95 cracking, without it i won't be here telling you how to
     crack a program under win 95.
     Giving ALL the credits... all i learned about cracking is with the
     help of great tutorials : 5 Minutes 4 a Crack /NeverOne, Amateur
     Crackist Tutorial /Specular Vision, Cracking for Masses /FraVia, Old
     Red Cracker Tutorials /+ORC (A Must), The Ancient Art Of Cracking &
     Cracking 101 /Buckaroo Banzai, The Cracking Manual /Cyborg, The Uncle
     Joe CrackBook /Uncle Joe (heh, what did you expect ?). But also with
     40 Hex Magazines, The Crypt Newsletters, Virus Laboratories And
     Note : a lot of the explaination i'll give you in Introduction parts
     are ripped from some tutorials upper, it's because i wanted to have
     something complete you can start with. Tnx again to those who wrot'em.

     For this tutorial you'll need :
     ACDSee32 V2.0 Beta
     Soft-Ice 3.00

Introduction to Cracking

     You might be wondering what type of programming skills you need to
     become a cracker. Knowing a higher level language such as Basic,
     Pascal, or C++ will help you somewhat in that you will have an
     understanding of what's involved in the process of writing a program
     and how certain aspects of a program function. If you don't have any
     programming skills, you have a long road ahead of you. But even if you
     can program in a high level language, in order to crack you have to
     know assembly... It really doesn't matter what language a program was
     written in in order to crack it, because all programs do the same
     thing. And that is issue commands to the microprocessor. And all
     programs when broken down to their simplest form are nothing more than
     a collection of 80XXX instructions and program specific data. This is
     the level of assembly language. In assembly you have total control of
     the system. This is also the level that the debugger operates at.

     You don't have to become a master at assembly to crack a program, but
     it helps. You do need to learn some rudimentary principles, and you
     absolutely have to become familiar with the registers of the cpu and
     how the 8088 instruction set uses them. There is no way around this.
     How proficient you are at assembly will determine how good of a
     cracker you become. You can get by on learning a few basic
     instructions, how to use a debugger, and one or two simple techniques.
     This will allow you to remove a few shareware nag screens, and maybe
     you'll luck out and remove the copy protection from a game or two, but
     that's it.

     You can then dynamically interact with the program and run it one line
     of code at a time, and see exactly what the program is doing in real
     time as each line of code is executed. You will also be able to
     re-assemble instructions (in memory only), edit the contents of memory
     locations, manipulate the cpu's registers, and see the effects your
     modifications have on the program as it's running. This is also where
     all your system crashes will occur... There is a lot of trial and
     error involved in cracking.

     As you get better, you'll have to write programs that will implement
     your patches if you decide to distribute them. The patches themselves
     don't have to be written in assembly.

     The sources code I included in this manual are extremely simple.
     They're written in assembly because that's the only language I know
     how to program in, but if you are already proficient in a higher level
     language, it should be trivial for you to duplicate it's methods in
     your preferred language.

Quick Introduction To Soft-Ice 3.0

     Okay, okay, i already heard you : Hey exact, you've ripped the ED!SON
     introduction. Yes, i've taken it ;) Why should i do something if
     someone already did ? So for all of you that didn't have the chance to
     have that intro, i've a little remixed it, and here it is...

     Cracking a Windows program is most often more simple than a program
     running in Dos. In Windows, it's hard to hide anything from anyone who
     really looks for information, as long as Windows own functions are
     used. The first (and often only) tool you need is Soft-Ice, a
     powerfull debugger from NuMega ( Some people
     find it hard to use, but i will tell you how to do efficient debugging
     with it.

     To use Sice, you must load it before windows, to do that, just add the
     "Drive:\Path\WINICE.EXE" at the end of your "AUTOEXEC.BAT". Normally,
     the Sice Setup should have already done it. I advise you to make a
     multi-config in that way, you can load Sice only when you need it.

     Example of multi-config :
     ;--- Config.sys
     menuitem SICE,Load Soft-Ice Debugger Behind Windows
     menuitem NORM,Normal Mode
     menudefault NORM,5
     DEVICE=C:\cd\drivers\MTMCDAI.SYS /D:MTMIDE01
     ;--- EOF Config.sys

     ;--- Autoexec.bat
     @ECHO OFF
     SET BLASTER=A220 I5 D1 H5 P330 T6
     PROMPT $p$g
     goto %config%
     goto common
     goto common
     ;--- EOF Autoexec.bat

     In the config.sys the [menu] indicates that's a multiconfig, it will
     display the two menuitem and wait for the user to select. When
     selected, the part of the config file refering to it is runned and
     followed by the [common] one. In the autoexec.bat there's a %config%
     variable set to the user'selection and is used to select witch part of
     your bat you will execute.

     So, udpate your system files if they need so, and reboot your machine.
     If you don't understand why these config files look like this, refer
     to the MS-DOS Help (Type HELP at the dos prompt).

     Now that Sice is loaded into memory, press "CTRL-D" to to pop it up.
     Here is a little description of the windows you can see on Sice screen

         CPU Registers
            Window        "WR" En/Disable, "R", "Alt-R" Edit.
         FPU Registers
            Window        "WF" En/Disable.
        Locals Windows    "WL" En/Disable, "Alt-L" Focus.
         Watch Window     "WW" En/Disable, "Alt-W" Focus.
          Data Window     "WD" En/Disable, "E", "Alt-D" to Edit.
          Code Window     "WC" En/Disable, "A" Edit, "Alt-C" Focus.
        Command Window    Type Commands and read output here.
           Help Line      Get summary help on what you are typing.

     The register window contains the general purpose and flags registers
     of the cpu. You will notice that the general purpose registers contain
     hexadecimal values. These values are just what happened to be in there
     when you brought up the debugger. You will also notice that some of
     the flags are highlighted while some are not. The highlighted flags
     are the ones that are SET. While the ones that are not highlighted are
     CLEARED. Generally, the register are also highlighted when they change
     value. From this window you will be able to manipulate the contents of
     the cpu's registers. You will change the values of the registers while
     debugging a program in order to change the behavior of the running
     program. Say you come across a JNZ instruction (jump if not zero),
     that instruction makes the decision on whether or not to make the jump
     based on the state of the (Z)ero flag. You can modify the condition of
     the (Z)ero flag in order to alter the flow of the programs code. By
     the same token, you can modify the general purpose registers in the
     same manner. Say the AX register contains 0000, and the program bases
     it's actions on that value, modifying the AX register to contain a new
     value will also have the effect of modifing the flow of the code.
     After you become comfortable with using Sice you'll begin to
     appreciate just how powerful this window is, and you'll aslo discover
     soon enough just how totally it can screw your system if you fuck up.

     The data window will display data as it exists in memory. From this
     window you can usually display, search, edit, fill, and clear entire
     ranges of memory. The two most common commands for this window are
     display and edit. The search command is also useful in cracking. Sice
     offers you 4 data windows, you can toggle from one to another using
     the "data" command. You can also change the type of data this window
     is displaying using the "format" command. You can scroll into the data
     window using ALT and arrows or PgUp/PgDn keys.

     The code window is the window in which you will interact with the
     running program. This is the most complex window, and it is where the
     bulk of debugging occurs. The layout of the window is pretty simple,
     the group of 12 numbers with the colon in the middle of them to the
     far left of the window is the address:offset of that line of code.
     Each line of code in this window is an instruction that the program
     will issue to the microprocessor, and the parameters for that
     instruction. The registers that contain the address for the current
     instruction waiting to be executed are the CS:EIP registers (code
     segment and instruction pointer). This line is highlighted, if you
     havent it in the code window use the "." command to retrieve it. You
     will also notice a group of hex numbers to the right of the addresses,
     this group of numbers is the hexadecimal equivalent of the mnemonic
     instructions. The next group of words and numbers to the right of the
     hex numbers are the mnemonic instructions themselves. You can scroll
     into the code window using ALT and arrows or PgUp/PgDn keys.

     For most examples, we'll only need to have the CPU Registers Window,
     the Data and the code one. Disable others. I'm in 60 lines mode. So if
     all windows are disabled to have the same screen as me do (comment are
     preceded by a semi-colon) :
     :lines 60          ; Set 60 lines mode
     :color f a 4f 1f e ; Set psychedelic colors (Optional)
     :wd 22             ; Enable Data Window 22 lines long
     :wc 25             ; Enable Code Window 25 lines long
     :wr                ; Enable Register Window
     :code on           ; Display instruction bytes

     This can seems you strange to have to type all these commands each
     time you'll start Sice. In fact, all these command can be done in the
     winice.dat file (in your sice directory). Let'see what is in mine :

     ;--- Example of Winice.dat
     ; General Variables

     LOWERCASE=OFF                                   ; Disable lowercase
     MOUSE=ON                                        ; Enable mouse

     NOLEDS=OFF                                      ; Disable led
     PENTIUM=ON                                      ; Pentium Op-Codes

     THREADP=ON                                      ; Following Thread
     PHYSMB=16                                       ; Exact Memory Size

     SYM=256                                         ; Memoy allocated to

     HST=16                                          ; Memory allocated to

     TRA=92                                          ; Memory allocated to
                                                     back trace buffer
     ; Startup sequence
     INIT="lines 60;color f a 4f 1f e;wd 22;wc
     22;wr;code on;x;"
     ; Function Keys
     F5="^G;"                                        ; Run (CTRL-D)

     F8="^T;"                                        ; Step into functions

     F10="^P;"                                       ; Step Over functions
     F11="^G @SS:ESP;"                               ; Step out of function
     ; Export Symbols
     ;--- EOF Winice.dat

     Okay, i think, it speaks by itself. Just a little note for defining
     function keys, all commands preceded by ^ are invisible, and all those
     followed by a ; are executed (the ; indicates an ENTER). Dont forget
     to load the Export Symbols !

Cracking ACDSee 32 V2.0 Beta

Loading ACDSee32.exe into Soft-Ice And Breaking At The Right Point.
     Run the Symbol Loader, do "File/Open Module" or you can also click on
     the first button on the left of the tool bar and browse until you can
     select the file ACDSee32.exe. Now, to start debugging you must to do
     "Module/Loads..." or click the "Load button" (next to the "Open" one).
     Perhaps Sice poped-up, saying Break Due To Load Module, or something
     like that, leave it by pressing "CTRL-D" or typing "X" followed by
     "ENTER". You should disable the "Break At WinMain Option" to dont
     pop-up Sice each time you load a module (the little lamp button).

     OK, let's go. In ACDSee, click on "Tools/Register..." Fill up the
     boxes with what you want. (I've filled them with Name:"Out Rage
     Pirates" and Registration:"112233445566"). Generally programs must
     read the content of the boxes with one of these functions :
     16-bit                  32-bit
     GetWindowText           GetWindowTextA,
     GetDlgItemText          GetDlgItemTextA,

     The last letter of the 32 functions tells if the function uses
     one-byte or double-byte strings. Double-byte code is RARE. So, now we
     gonna enter Sice pressing CTRL-D and set breakpoints on the getting
     content of edit boxes :

     :bpx GetWindowText
     :bpx GetWindowTexta
     :bpx GetWindowTextw
     :bpx GetDlgItemText
     :bpx GetDlgItemTexta
     :bpx GetDlgItemTextw

     Oki, there's no need to set BPs (BreakPointS) 0 and 3 since we know it
     is a 32-bit application, but i've put them here to be exhaustive. If
     you encounter problems settings these breakpoints, make sure that the
     export symbols are loaded in Soft-Ice : edit the file winice.dat and
     check if the semi-colons are removed from the exp= that follows the
     "Example of export symbols that can be included for chicago" near the
     end of file. Generally, you only need to keep kernel32.dll,
     user32.dll, gdi32.dll. If you get an error message "No LDT", make sure
     you dont run any other DOS application in the background,

     It's not sure that Sice will pop-up, and not all program are calling
     these Windows functions.
     Continue the program ("CTRL-D"), and click the OK button. It worked,
     we're back to Sice ! press "CTRL-D" to continue the process, back to
     Sice again ! re-re-press "CTRL-D", no more Sice pop-up. Normal,
     there's only two textboxes... Click OK to get back to the registration
     window. And now, let's throw an eye into Sice, CTRL-D. There's
     comments for the two break points :

     Break due to BPX USER32!GetDlgItemTextA (ET=4.70 seconds)
     Break due to BPX USER32!GetDlgItemTextA (ET=269.77 microseconds)

     It's BP 04 let's delete other BPs :

     :bl                                ; BPs list
     00) BPX USER!GetWindowText
     01) BPX USER32!GetWindowTexta
     02) BPX USER32!CharNextExW
     03) BPX USER!GetDlgItemText
     04) BPX USER32!GetDlgItemTextA
     05) BPX USER32!AppendMenuW
     :bc 0 1 2 3 5                      ; Clear BPs #0, 1, 2, 3 and 5.

     We'll do it again. Press "CTRL-D" to leave Soft-Ice, and click the OK
     button. Magic, we're back in it... Let's do a little focus : where are
     we, and what's the hell now ? We are at the start of the "Get Dialog
     Item Text A" function, and we are going to find where it is called.
     Since we know that when we do a far call to something the next logical
     instruction address is stored on the stack, we gonna set a BP on that
     address and execute the program until we reach it. G command will
     continue the program at the current CS:EIP, and set a temporary BP to
     the address indexed (@) in SS:ESP. There's a function key that
     automatically do it, normally, it's F11.

     :G @SS:ESP

Finding Where The Registation Code Is Checked

     Ok, we are back into Sice at the instruction following the call to
     DlgItemTextA. We gonna take a look on what's happenning before and
     after. Use CTRL-UP and CTRL-DOWN to move into the code window. If you
     dont have the code window on your screen you can make it appears by
     typing WC (WC 20 will set the code windows to be 20 lines long). You
     should see something like following (i've added blank lines and
     comments for clarity and future explainations) :

     ; Get The Name Into Buffer (ESP+8)
      0040367B 8D442418       LEA EAX, [ESP + 18]       ; Buffer(For Name) Address
      0040367F 6A1E           PUSH 0000001E             ; Max String Size
      00403681 8BB42408010000 MOV ESI, [ESP + 00000108]
      00403688 50             PUSH EAX                  ; Buffer Address
      00403689 6A6B           PUSH 0000006B             ; Control ID
      0040368B 8B3D94DA4900   MOV EDI,[USER32!GetDlgItemTextA]
      00403691 56             PUSH ESI                  ; Dialog Handle
      00403692 FFD7           CALL EDI                  ; Call GetDlgItemTextA

     ; Get The Registration Code Into Buffer (ESP+38)
     >00403694 8D442438       LEA  EAX, [ESP + 38]      ; Buffer(Registration) Addy
      00403698 68C8000000     PUSH 000000C8             ; Max String Size
      0040369D 50             PUSH  EAX                 ; Buffer Address
      0040369E 6882000000     PUSH  00000082            ; Control ID
      004036A3 56             PUSH  ESI                 ; Dialog Handle
      004036A4 FFD7           CALL  EDI                 ; Call GetDlgItemTextA

     ; Registration Checking
     >004036A6 8D442438       LEA  EAX, [ESP + 38]      ; Registration Buffer
      004036AA 8D4C2418       LEA  ECX, [ESP + 18]      ; Name Buffer
      004036AE 50             PUSH EAX                  ; Save Datas
      004036AF 51             PUSH ECX
     !004036B0 E80BF9FFFF     CALL 00402FC0             ; Registration Check
      004036B5 83C408         ADD  ESP, 00000008        ; Free Stack
      004036B8 85C0           TEST EAX, EAX
      004036BA 7E6E           JLE  0040372A             ; EAX=0 Means Bad Reg...

     ; Do Something, sure... ;)
      004036BC 8D442438       LEA  EAX, [ESP + 38]
      004036C0 8D4C2418       LEA  ECX, [ESP + 18]
      004036C4 50             PUSH EAX
      004036C5 51             PUSH ECX
      004036C6 E895FAFFFF     CALL 00403160
      004036CB 83C408         ADD  ESP, 00000008
      004036CE 833D44F0480000 CMP  DWORD PTR [0048F044], 00000000
      004036D5 740B           JE   004036E2
      004036D7 A144F04800     MOV  EAX, [0048F044]
      004036DC 8BC8           MOV  ECX, EAX
      004036DE 8B18           MOV  EBX, [EAX]
      004036E0 FF13           CALL DWORD PTR [EBX]
      004036E2 833D40F0480000 CMP  DWORD PTR [0048F040], 00000000
      004036E9 740C           JE   004036F7
      004036EB A140F04800     MOV  EAX, [0048F040]
      004036F0 8BC8           MOV  ECX, EAX
      004036F2 8B18           MOV  EBX, [EAX]
      004036F4 FF5314         CALL [EBX+14]

     ; Close Registration Windows, And pops : "Thanks Registering"
      004036F7 6A01           PUSH 00000001
      004036F9 56             PUSH ESI
      004036FA FF15F4DA4900   CALL [USER32!EndDialog]
      00403700 6A00           PUSH 00000000
      00403702 6820324000     PUSH 00403220
      00403707 56             PUSH ESI
      00403708 FF15F8DA4900   CALL [USER32!GetParent]
      0040370E 50             PUSH EAX
      0040370F 68E4000000     PUSH 000000E4
      00403714 A148F04800     MOV  EAX, [0048F048]
      00403719 50             PUSH EAX
      0040371A FF1544DB4900   CALL [USER32!DialogBoxParamA]
      00403720 B801000000     MOV  EAX, 00000001
      00403725 E92EFFFFFF     JMP  00403658

     ; Pops up a window saying : "Your name and registration code do not match."
      0040372A 6A00           PUSH 00000000
      0040372C A104F34800     MOV EAX, [0048F304]
      00403731 50             PUSH EAX
      00403732 68ACF34800     PUSH 0048F3AC
      00403737 56             PUSH ESI
      00403738 FF15E4DA4900   CALL [USER32!MessageBoxA]
      0040373E 6882000000     PUSH 00000082
      00403743 56             PUSH ESI
      00403744 FF15F0DA4900   CALL [USER32!GetDlgItem]
      0040374A 50             PUSH EAX
      0040374B FF1548DB4900   CALL [USER32!SetFocus]
      00403751 B801000000     MOV  EAX, 00000001
      00403756 E9FDFEFFFF     JMP  00403658

     Let's do a some analysis on what we are seeing. We are at
     0157:00403694 (Your segment address may be different, it depends on
     what you load, update my values with yours). The previous instruction
     is the call to the GetDlgItmeTextA. Again, you can scroll in the code
     windows with "CTRL-UP", "CTRL-PGUP", "CTRL-DOWN" and "CTRL-PGDOWN".
     You can also make the Focus to the code window by pressing "Alt-C" and
     use the UP, DOWN, PGUP, PGDOWN to scroll it.

     In C, the call to the GetDlgItemTextA should look like this :

     int GetWindowText (int windowhandle, char *buffer, int maxlen);

     So the push eax is the buffer address, let's have a look :

     :d esp+18 ; You can also use "db esp+18" for byte display

     We've got it, it's our name ! We saw that in few intructions, there
     will be second call to the GetDlgItemTextA, the CALL EDI at
     0157:004036A4. We dont want Sice to break, so we will disable it :

     :bd 4 ; Disable BP 4

     After that second call, there's another one followed by a test on the
     eax value... humm suspicious, is there any check inside that routine ?
     That's what we gonna determine fastly. We gonna trace the code
     stepping over function calls. Press P (Procedure trace) then ENTER
     (normally it's F10 key). Press it several times.

     After you've reached 0157:004036A6 (the second call) our registration
     code appears in the data window (if it is big enought, else you can
     scroll it down using Alt-DOWN) our predictions were right ;). You are
     now reaching the TEST AX,AX intruction (0157:004036BA), then there's a
     branch to another routine (0157:0040372A), the program will follow it
     and soon you will get a message saying that your registration code is
     wrong... (0157:00403738).

     So now we are sure that the call before the test was done to check the
     data we've enterred, and that the branch choose the direction to the
     Registration Not Match message. What if we change the direction the
     program took?

     Let's go, enable BP 4.

     :be 4 ; Enable BP 4

     Leave Sice (CTRL-D), click on OK to get back to the registration
     window, and click on OK again to pop-up into Sice. Press CTRL-D
     another time to go to the second GetDlgItemTextA call and press F11 to
     go out of that function call. Now step to the branch (F10 until you
     reach 0157:004036BA). And change the zero flag value to disable it:

     :r fl z ; Toggle Zero Register FLag

     Then leave the proggy to himself (CTRL-D). We've done it ! The
     beautifull message appears : thanks for supporting our products, etc,

     Hu Oh, Hey, what's that stupid program ? If i click on the little eye
     (the about button in the toolbar), it's telling me it is not
     registered !!!? Fucking damn thing, we gonna gotcha !

     Oki, let's think two seconds... what's the matter ? Well everything
     seems like if ACDSee checks the name and the registration at every
     times it shows them. So, to avoid this problem, we've got to give him
     the answer he wait each times he call the registration checker.
     First of all, we must verify our affirmations, we must know if the
     routine wich is called by the about button is effectively the piece of
     code into this call. Go into Soft-Ice using the BP we've set on the
     GetDlgItemTexta (go to the registration window and press enter), and
     press F11. Now, we're going to put another BP into the call.

     :bpx 0157:00402FC0 ; Change the address in regard to yours

     Now we gonna try, leave Soft-Ice (it will pop-up two times because BP
     4 is still enabled, we're not interrested into these breaks), close
     the registration window by clicking cancel and finally click on the
     about button... Yep! back in Sice, we were right !!! So everything
     we've got to do now is to send back a satisfying answer to the calling

Patching ACDSee

     Actually in your code window, you should have something like the
     following piece of code. All we've got to do is to leave this routine
     with EAX different from 0...

     ; Check Name Lenght
     >00402FC0 56             PUSH ESI
      00402FC1 8B742408       MOV  ESI, [ESP + 08]
      00402FC5 56             PUSH ESI
      00402FC6 E835000000     CALL 00403000             ; check name length (1st)
      00402FCB 83C404         ADD  ESP, 00000004
     !00402FCE 85C0           TEST EAX, EAX
     !00402FD0 7504           JNE  00402FD6             ; branch is followed
     !00402FD2 33C0           XOR  EAX, EAX             ; Set EAX to 0 (BAD!)
      00402FD4 5E             POP  ESI
      00402FD5 C3             RET                       ; Exit 1

     ; Check Registration Code
     :00402FD6 8B44240C       MOV EAX, [ESP + 0C]
     :00402FDA 50             PUSH EAX
     :00402FDB 56             PUSH ESI
     :00402FDC 6848F34800     PUSH 0048F348             ; "-294378973"
     :00402FE1 E86AE70100     CALL 00421750             ; The key is herein (2nd)
     :00402FE6 83C40C         ADD  ESP, 0000000C
     :00402FE9 83F801         CMP  EAX, 00000001
     :00402FEC 1BC0           SBB  EAX, EAX
     :00402FEE 5E             POP  ESI
     :00402FEF 40             INC  EAX
     :00402FF0 C3             RET                       ; Exit 2

     So what we gonna do is erase the three instructions that works on EAX
     with our own code. Dont forget to change the address in regard to
     Erasing the branch will assure us that only our code will be followed.
     There's thousand of way to modify this code, i choosed the following :

     :a 0157:00402FCE ; Assemble
     0157:00402FCE mov eax,1
     0157:00402FD3 nop
     0157:00402FD3 ; Press escape to stop assembling
     :bc 0  ; Clear BP on 0157:00402FC0

     And now let's check our work ! Press CTRL-D, welldone, the thanks for
     registering message appears... Okay, now click on the about button...
     (suspens) !!!YES!!! we've registered it.

     Oki let's do our work, now we've only got to make the patch...
     What we need to know is where are these instructions in the
     ACDSee32.exe file. I've use HexWorkShop for win95 and found them
     making a search for 85C0750433C0 (the instructions Opcodes, if Sice
     doesnt show the type "CODE ON") the one interesting us are at offset
     23CE. Now we must make a little proggy to replace these bytes with our
     code. Here it is :

     ;--- ORP-A32B.ASM
             Title Patch For ACDSee 32 2.0 Beta
             .Model Huge
             .Stack 100h

             mov     ax,cs
             mov     ds,ax
             mov     es,ax

             mov     ax,3d02h
             mov     dx,offset cs:fname              ; DX=*FileName
             int     21h                             ; DOS/FileOpen
             jc      errorlbl                        ; Jump On Errors

             mov     word ptr [offset cs:fname],ax   ; BX=Handle
             mov     bx,ax

             mov     ax,4200h
             xor     cx,cx                           ; Segment
             mov     dx,23ceh                        ; Offset
             int     21h                             ; DOS/FileSeekSet
             jc      errorlbl                        ; Error !

             mov     ax,4000h
             mov     bx,word ptr [offset fname]      ; BX=Handle
             mov     cx,6                            ; Lenght
             mov     dx,offset patch                 ; Buffer
             int     21h                             ; DOS/WriteFile
             jc      errorlbl

             mov     ax,3e00h
             mov     bx,word ptr [offset fname]      ; BX=Handle
             int     21h                             ; DOS/CloseFile
             jc      errorlbl

             mov     dx,offset cs:text2
             jmp     getout

             mov     dx,offset cs:text1              ; Print
     getout: mov     ah,9
             int     21h

             mov     ah,4ch                          ; Get Out Of Here !
             int     21h

     patch   db 0B8H,001H,000H,000H,000H,090H        ; MOV EAX,00000001 - NOP
     fname   db 'ACDSEE32.EXE',0
     text1   db 0ah,0dh,'Error Handling File'
     text2   db 0ah,0dh,'Patch By Exact /oRP',0ah,0dh,'$'
     end;--- EOF ORP-A32B.ASM

     You can compile it with tasm 3.1 and tlink 5.1 (they can be found on
     my home page) in that manner :

     TASM /m9 /n /q orp-a32b
     TLINK /3 /x orp-a32b

     I think there is not so much comment to add at the source, anyway if
     you have any problems understanding what happening in there, you must
     find a book about programming (you can also try to get Helppc).

Final Note

     Ok, this is the End...
     A really BIG thanks is going to ACP of UCF for sending me W32DASM !

                                                Have Fun With This Stuff !
                                                                eXact /oRP
                                                               aka sice_boy

See Also