informis/textfiles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
textfiles/piracy/CRACKING/exact-in.txt
root@procul 278a90f7ce Initial commit
2021-04-15 13:31:59 -05:00

673 lines
34 KiB
Plaintext
Raw Blame History

Introduction To Win95 Cracking
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 Distribution.
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
HexWorkShop
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 (http://www.numega.com). 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
[menu]
menuitem SICE,Load Soft-Ice Debugger Behind Windows
menuitem NORM,Normal Mode
menudefault NORM,5
[SICE]
[NORM]
[common]
DEVICE=C:\WIN96\HIMEM.SYS
DOS=HIGH
DEVICE=C:\cd\drivers\MTMCDAI.SYS /D:MTMIDE01
FILES=40
;--- EOF Config.sys
;--- Autoexec.bat
@ECHO OFF
SET BLASTER=A220 I5 D1 H5 P330 T6
SET MIDI=SYNTH:1 MAP:E
SET PATH=C:\WIN96;C:\WIN96\COMMAND;C:\DOS;D:\NC
SET TEMP=C:\TEMP
SET SOUND=C:\VIBRA16
C:\VIBRA16\DIAGNOSE /S
C:\VIBRA16\MIXERSET /P /Q
PROMPT $p$g
goto %config%
:SICE
C:\Progra~1\SoftIc~1\WINICE.EXE
goto common
:NORM
goto common
: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 | |
+-----------------------------------------------+--------------------------+
| NMI=ON | |
+-----------------------------------------------+--------------------------+
| SIWVIDRANGE=ON | |
+-----------------------------------------------+--------------------------+
| LOWERCASE=OFF | ; Disable lowercase |
| | assembly |
+-----------------------------------------------+--------------------------+
| MOUSE=ON | ; Enable mouse |
+-----------------------------------------------+--------------------------+
| NOLEDS=OFF | ; Disable led switching |
+-----------------------------------------------+--------------------------+
| NOPAGE=OFF | |
+-----------------------------------------------+--------------------------+
| PENTIUM=ON | ; Pentium Op-Codes |
+-----------------------------------------------+--------------------------+
| THREADP=ON | ; Following Thread |
| | Process |
+-----------------------------------------------+--------------------------+
| VERBOSE=ON | |
+-----------------------------------------------+--------------------------+
| PHYSMB=16 | ; Exact Memory Size |
+-----------------------------------------------+--------------------------+
| SYM=256 | ; Memoy allocated to |
| | symbols |
+-----------------------------------------------+--------------------------+
| HST=16 | ; Memory allocated to |
| | history |
+-----------------------------------------------+--------------------------+
| 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 |
| | (Trace) |
+-----------------------------------------------+--------------------------+
| F10="^P;" | ; Step Over functions |
| | (Procedure) |
+-----------------------------------------------+--------------------------+
| F11="^G @SS:ESP;" | ; Step out of function |
+-----------------------------------------------+--------------------------+
| ; Export Symbols | |
+-----------------------------------------------+--------------------------+
| EXP=c:\win96\system\kernel32.dll | |
+-----------------------------------------------+--------------------------+
| EXP=c:\win96\system\user32.dll | |
+-----------------------------------------------+--------------------------+
| EXP=c:\win96\system\gdi32.dll | |
+-----------------------------------------------+--------------------------+
| ;--- 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, GetWindowTextW |
+----------------+----------------------------------+
| GetDlgItemText | GetDlgItemTextA, GetDlgItemTextW |
+----------------+----------------------------------+
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,
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 code...
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 your.
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
.386
.Stack 100h
.Code
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
errorlbl:
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
Reference in New Issue View Git Blame Copy Permalink