Programmet er mange MB stort så jeg regnet ikke med at noen orket å laste det ned og jeg vil ikke på noen måte "skade" de som har laget programmet, derfor er program navnet ukjent og heller ingen vits å vite egentlig.

Denne tutorialen er skrevet til Melk og FHCF :) hei på deg Melk, du vet hvilket program det er snakk om, hysj.... :)
Når vi skal cracke et program finnes det som regel flere måter å gjøre dette på, vi prøver først å få til en keygen, serial, keyfile eller annet, siste utvei er alltid å patche programmet, noe som vi helst vil unngå.
Å patche et program kan være ganske vanskelig hvis programmet har mange disablede funksjoner, nag`s og kanskje andre ting vi kanskje ikke engang viste eksisterte, det er ofte slik at vi glemmer å patche noe eller at vi gjør en feil slik at ting ikke fungere som det skal, noen ganger tar det nesten lengre tid å teste at selve patchen vi har laget fungere som den skal enn å cracke programmet, noe som jeg synes er kjedelig.
Har du noen gang patchet et program slik at det godtar et hvilket som helst serial og at alt ser bra ut helt til du restarter programmet?, da blir det uregistrert igjen :(
Har du også prøvd å cracke et program der du skriver inn serial og du blir bedt om å restarte programmet for å sjekke om serialen er riktig? da hjelper det lite å bruke getwindowtexta, getdlgitemtexta og hmemcpy, et slik program lagrer serialen du skriver inn i registeret eller i en ini fil som den sjekker ved oppstart, for å finne serialen til et slikt program trenger vi en spesiell api som vi snart skal se på.
Disse to problemene ovenfor fikser du hvis du fortsetter å lese, men tutorialen handler egentlig ikke om dette men derimot hvordan patche et program ved å bruke kun et par byte i steden for å måtte "fikse" vær eneste funksjon i programmet.

Dette programmet har name/serial protection men vi finner ikke noe serial så i steden får vi snoke litt rundt, sjekke hva programmet ser etter når det starter opp ved hjelp av RegMon, vi kan jo også disassemble for å se om vi får noe mer informasjon på den måten.
I dag tar vi frem RegMon for å finne ut hva programmet sjekker når den starter, jeg orker ikke forklare hvordan RegMon fungerer da jeg regner med at de aller fleste vet det eller lærer det kjapt.
Etter å ha skrevet inn program navnet i RegMon (maks 8 bokstaver) starter vi programmet som skal crackes og vi ser dette:

44 12:00:06 Jepp QueryValueEx HKCU\SameSoft\Jepp\fullkey6 SUCCESS
190 12:00:06 Jepp QueryValueEx HKCU\SameSoft\Jepp\regname6 NOTFOUND
191 12:00:06 Jepp QueryValueEx HKCU\SameSoft\Jepp\fullkey6 SUCCESS 0x0

Det var selvfølgelig en haug med andre linjer også men de har jeg fjernet.
Her kan vi se at programmet sjekker key`n 'fullkey6' to ganger, første gang sjekker den om key`n eksisterer og at key`n er i riktig format (hex, binary) mens andre gang key`n blir sjekket er det serialen i key`n den sjekker om er riktig (0x0 vil si at key`n = 0 hex)
Man kan også se at key`n 'regname6' ikke eksisterer og det vil vel si at vi ikke har noe username, det kan være en god ide å lage denne key`n selv i regedit ved å høyreklikke og velge "new" - "string value" Etter at key`n er laget renamer du den til 'regname6' og skriver inn et username.
En ting som er viktig å vite er at noen programmer er beskyttet mot RegMon og du vil ikke få den informasjonen du trenger, det kan da være lurt å ha en RegMon som du har patchet bort stringen "RegMon" inne i exe fila og renamet vxd/sys filene til RegMon.
Nå som vi vet at programmet sjekker key`n 'fullkey6' når det starter opp kan vi jo patche slik at den godtar et hvilket som helst serial akkurat slik vi av og til gjør med en vanlig name/serial protection når vi ikke finner serialen.
Breakpointet vi skal bruke er mest sansynlig det lengeste du noen gang kommer til å bruke og det ser slik ut:

bpx RegQueryValueExA if *(ESP->8) == 'Regkey' do "D (ESP->14);"

'Regkey' er navnet på key`n vi er interesert i, for oss vil det i dette tilfellet være 'fullkey6' og når vi skal sette breakpointet i SoftIce vil vi skrive det slik:

bpx RegQueryValueExA if *(ESP->8) == 'full' do "D (ESP->14);"

Du lurer kanskje på hvorfor vi bruker 'full' og ikke 'fullkey6' ? Det er fordi dette er en slags breakpoint macro eller hva det nå heter der key`n maks kan inneholde 4 tegn, siden 'fullkey6' er lengre enn 4 tegn bruker vi bare de 4 første ellers vil ikke breakpointe fungere.
Det er viktig at du skriver riktig med tanke på små og store bokstaver, 'Full' og 'full' er to helt forskjellige key navn å skriver du feil vil ikke SoftIce poppe opp når du trenger den.
Breakpointet ber Softice poppe opp når key`n 'full' blir lest med API`n RegQueryValueExA som er en valig API for å få informasjon fra key`s i windows registeret.
Vi kunne godt ha brukt RegQueryValueExA som breakpoint uten noe macro greier men da ville SoftIce ha poppet opp en haug med ganger der den kun leste key`s som ikke vi hadde noen interesse for å se, ved å bruke macroen sparer vi mye tid og unødvendig tracing:)
La oss fyre opp SoftIce ved å trykke på Ctrl-D for så å sette breakpointet bpx RegQueryValueExA if *(ESP->8) == 'full' do "D (ESP->14);"
vi går så ut av SoftIce i det vi trykker F5.
Nå starter vi programmet vi skal cracke og SoftIce popper opp, vi trykker F5 helt til vi havner i windows igjen, 2 ganger fikk vi trykket F5 før vi havnet i windows, hvorfor 2 egentlig?
Husker du at key`n 'fullkey6' ble sjekket to ganger ved oppstart av programmet? Første gang sjekket den om key`n eksisterer og om key`n var i riktig format mens andre gangen sjekket den selve serialen i key`n, for oss er det programmet sjekker første gang lite interesangt da vi vet at key`n eksisterer og er i riktig format.
Vi starter programmet på nytt og SoftIce popper opp igjen men denne gangen trykker vi F5 1 gang for å slippe å se at programmet sjekker om key`n eksisterer og er i riktig format, vi trykker så F12 for å komme inn i program koden som ser slik ut:

004790AA  E855DBF8FF          CALL      ADVAPI32!RegQueryValueExA         
004790AF  85C0                TEST      EAX,EAX                           
004790B1  742E                JZ        004790E1                 <--- Hopper automatisk          
004790B3  8975F4              MOV       [EBP-0C],ESI                       
004790B6  C645F80B            MOV       BYTE PTR [EBP-08],0B               
004790BA  8D45F4              LEA       EAX,[EBP-0C]                       
004790BD  50                  PUSH      EAX                                
004790BE  6A00                PUSH      00                                 
004790C0  8D55F0              LEA       EDX,[EBP-10]                       
004790C3  A150B25300          MOV       EAX,[0053B250]                     
004790C8  E877C9F8FF          CALL      00405A44          

Hvis vi endrer JZ slik at den ikke hopper vil vi få erroren "Faild to get data for fullkey6" og det sier seg vel selv at vi kanskje bør la JZ være som den er :)
Nå kan vi trace nedover koden helt til vi møter på en RET (479106) da vi har gått over RET`n vil vi havne her:

0047910E  8BC3                MOV       EAX,EBX                            
00479110  5F                  POP       EDI                                
00479111  5E                  POP       ESI                                
00479112  5B                  POP       EBX                                
00479113  8BE5                MOV       ESP,EBP                            
00479115  5D                  POP       EBP                                
00479116  C20800              RET       0008     


Ikke noe interessant her så vi bare tracer til vi møter på RET (479116) etter denne RET`n vil vi havne her:


00478F33  E834010000          CALL      0047906C                          
00478F38  807C240403          CMP       BYTE PTR [ESP+04],03              
00478F3D  7407                JZ        00478F46             <--- Hopper automatisk
00478F3F  8BC3                MOV       EAX,EBX                            
00478F41  E8B2FBFFFF          CALL      00478AF8                           
00478F46  8B0424              MOV       EAX,[ESP]                          
00478F49  59                  POP       ECX                                
00478F4A  5A                  POP       EDX                                
00478F4B  5B                  POP       EBX                                
00478F4C  C3                  RET             
  

Her har vi enda en JZ og hvis vi endrer denne vil programmet avslutte så det er vel også lite vits å endre noe her, vi tracer videre i koden til vi møter på enda en RET (478F4C) og vi ser dette:

0047C975  E8A6C5FFFF          CALL      00478F20                          
0047C97A  8BD8                MOV       EBX,EAX                           
0047C97C  A124E55300          MOV       EAX,[0053E524]                     
0047C981  E89AFEFFFF          CALL      0047C820                           
0047C986  3BD8                CMP       EBX,EAX                            
0047C988  0F9445FF            SETZ      BYTE PTR [EBP-01]                  
0047C98C  33C0                XOR       EAX,EAX                            
0047C98E  5A                  POP       EDX                                
0047C98F  59                  POP       ECX                                
0047C990  59                  POP       ECX                                
0047C991  648910              MOV       FS:[EAX],EDX                       
0047C994  68A9C94700          PUSH      0047C9A9                           
0047C999  8D45F8              LEA       EAX,[EBP-08]                       
0047C99C  E88373F8FF          CALL      00403D24                           
0047C9A1  C3                  RET                                          
0047C9A2  E9B96DF8FF          JMP       00403760                           
0047C9A7  EBF0                JMP       0047C999                           
0047C9A9  8A45FF              MOV       AL,[EBP-01]                        
0047C9AC  5B                  POP       EBX                                
0047C9AD  59                  POP       ECX                                
0047C9AE  59                  POP       ECX                                
0047C9AF  5D                  POP       EBP                                
0047C9B0  C3                  RET           

Ikke kjempe mye spennende her heller, vi får vel tracer til vi møter på en RET (47C9A1) og så til vi møter på enda en RET (47C9B0) og da skal vi vel endelig havne her:

00521763  E8A8B1F5FF          CALL      0047C910                          
00521768  84C0                TEST      AL,AL               <--- AL=0 vil si Uregistrert              
0052176A  753C                JNZ       005217A8            <--- Hopper IKKE automatisk (Uregistrert)               
0052176C  A1E4AA5300          MOV       EAX,[0053AAE4]                     
00521771  C60000              MOV       BYTE PTR [EAX],00                  
00521774  8B4DFC              MOV       ECX,[EBP-04]                       
00521777  B201                MOV       DL,01                              
00521779  A1C4594B00          MOV       EAX,[004B59C4]                     
0052177E  E8F58DF2FF          CALL      0044A578                           
00521783  8B1534B15300        MOV       EDX,[0053B134]                     
00521789  8902                MOV       [EDX],EAX                          
0052178B  A134B15300          MOV       EAX,[0053B134]                     
00521790  8B00                MOV       EAX,[EAX]                          
00521792  8B10                MOV       EDX,[EAX]                          
00521794  FF92CC000000        CALL      [EDX+000000CC]                     
0052179A  A134B15300          MOV       EAX,[0053B134]                     
0052179F  8B00                MOV       EAX,[EAX]                          
005217A1  E87ACDF2FF          CALL      0044E520                           
005217A6  EB08                JMP       005217B0                           
005217A8  A1E4AA5300          MOV       EAX,[0053AAE4]                     
005217AD  C60001              MOV       BYTE PTR [EAX],01                  
005217B0  A1E4AA5300          MOV       EAX,[0053AAE4]                     
005217B5  803800              CMP       BYTE PTR [EAX],00                  
005217B8  7418                JZ        005217D2          
  

Vi endrer JNZ til JMP(S) (753C->EB3C) og programmet blir registrert, det vil si at ALLE disablede funksjoner vil nå fungere som om programmet var registrert, kanskje ikke så rart fordi vi har jo lurt programmet til å tro at det er registrert.
Her har vi patchet kun en byte og fikset alle begrensninger i programmet i steden for å fjerne hver og en av dem som hadde kostet oss mere tid og flere bytes.
Hvis du har laget key`n 'regname6' så vil navnet ditt stå nederst i programmet, hvis du ikke laget noen 'regname6' key så vil det ikke stå noe navn der men programmet vil alikevel være registrert og fungere 100%
Normalt MÅ programmer ha en "name" key for å godta registreringen og det kan være en ide og alltid lage "name" key så lenge du vet hva denne "name" key`n skal hete.

Viste du at AL er en del av EAX?

EAX xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx 32 bit (4 byte)
AX xxxxxxxxxxxxxxxx 16 bit (2 byte)
AH xxxxxxxxyyyyyyyy AL (AH og AL er begge 8 bit, 1 byte)

Øverste del av AX er AH mens nederste del er AL

EAX = 84720193

Verdien 84720193 ligger i EAX (4 Byte, 32 bit)
Verdien 0193 ligger i AX (2 Byte, 16 bit)
Verdien 01 ligger i AH (1 Byte, 8 bit)
Verdien 93 ligger i AL (1 Byte, 8 bit)

Nå burde du vite forskjellen på EAX, AX, AL, AH og slik fungere andre registre også :)