                    C r
       x C r k' s       a c k i n g   T u t o r   2   
                     H                                
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


Inhaltsverzeichnis:
~~~~~~~~~~~~~~~~~~~

      1. Dank im Voraus & Warme Worte
      
      2. Objekt der Begierde
      
      3. dringend bentigte Tools
      
      4. Vorbereitungen fr den Crack
        4.1. Programmschutz herausfinden
        4.2. Wie fange ich das Programm ab?
        
      5. SoftIce bis zum umkippen

      
      
1. Dank im Voraus & Warme Worte
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Dank: Ja danke fr die vielen netten, und irgendwann
  nervenden EMails den Tutor #1 betreffend. Freut mich
  echt, das er Euch gefallen hat. Ich hoffe das der hier
  genau so gut - ach was - viel besser wird!
  
  Warme Worte: Na ja, eigentlich sollte ich das meiner
  Tastatur und nicht Euch erzhlen: Du kotzt mich an
  du blde Siemens Tastatur! (die macht aus einem 'm'
  schnell mal 2 zwei oder 3, von Alt+Gr ganz zu schweigen).
  Also Entschuldigung fr die ganzen kommenden Recht-
  schreibfehler, da liegt wirklich nur an der Tastatur!
  

2. Objekt der Begierde
~~~~~~~~~~~~~~~~~~~~~~

  WINAMP 2.0
  
  Gestern noch das schnste Freeware Programm welches es
  gab, jetzt endlich Shareware (hat der Cracker lieber!).
  
  Und genau so einfach zu cracken - na ja eigentlich wird
  es ja gar kein Crack, sondern ein Serial Hack - wie zu
  bedienen. (Wer solche Stze jetzt schon nicht versteht,
  sollte ich doch lieber erst mal eine XTC Tablette gnnen,
  oder ne Runde schlafen gehen.)
  
  Warum WinAmp 2.0?
        ~~~~~~~~~~
  (1) ist erst gestern rausgekommen
  
  (2) es gibt schon Keys von Phrozen Crew, aber wer will
      schon seinen WinAmp mit einem PC98 Key fttern?
      Laxity Keys sind doch viel besser!
      
  (3) es gibt auch schon einen Keymaker von TNO, aber
      der hngt ein "(c) by TNO" an jeden Namen, also
      auch nicht gerade das was wir wollen!
      
  (4) es gibt einen Keygen von UCF2000 der fr jeden Namen
      einen Key ausspuckt, also was wollen wir mehr?
      
      ich sage es Euch:
      
      Ihr wollt wissen wie man seinen ganz eigenen Key, ohne
      fremde Hilfe bekommt.
      
      Die Lsung:
      
      Hrt auf zu lesen, und hackt Euch einen!

            
  Gut, das Ziel haben wir gefunden.

  
  
3. dringend bentigte Tools
~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Ich sage Euch schon mal was wir gebrauchen werden!
  
    * SoftIce v3.23
    * Taschenrechner
    * 10min Zeit
    
  Das erste gibts hier:
  
    http://members.tripod.com/~xrmb/lxt_sup/SI95v323.piz
    (einfach nach download in .zip umbenennen)
  
  Ist zwar nur die Win9x Version, aber wer nutzt schon NT?
    

  Das zweite drften die jenigen die schon zu Schule gehen
  in Ihrem Ranzen (ostdeutsches Wort fr Schul-Rucksack)
  finden. Bitte nehmt nicht den M$ Windows Taschenrechner,
  dem traue ich nicht!
  
  Wer noch nicht in die Schule geht: Mama oder Papa fragen.

  Beim SoftIce sollte im Init-String die Register einge-
  schalten werden. Oder spter im SI F1 drcken.
  
  
  
4. Vorbereitungen fr den Crack
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Das kennen wir ja schon aus Tutor #1. So ein bissl das
  Programm anschauen, und abchecken.
  
  Schauen wir es uns mal fix im HexEdit an, Oih was sehen
  wir das gepackt, du heilige "Hinternpaste". Jetzt knnen
  wir keinen W32DSM nehmen. Kurz in die Cracker Trickkiste
  geschaut, kram, kram. ProcDump... ha klappt Spitze, blo
  laufen tuts nicht (zumindest bei mir).
  
  Aber noch mal zum HexView von der WinAmp.Exe, da steht ja
  dieses tolle Rtsel am Anfang:
  
    if (billg != satan) 
      exit(1); 
    else 
      ShowNiftyWinamp();
      
  billg: das ist eine wahrhaftige Globale Variable, diese
  hat immer den Wert 0 (der Wert berechnet sich irgendwie
  aus der Produktqualitt der Firma)
  
  satan: ist keine globale Variable, sondern eine nur in
  Unterweltfunktionen benutzte. Deren Wert kennen wir nicht!
  Aber er ist ganz einfach zu berechnen. Dafr wird die
  If abfrage einmal nach C++ regeln umgestellt.
  
    if (billg == satan) 
      ShowNiftyWinamp();
    else 
      exit(1); 
  
  Ok, alles beim alten, Bill Gates ist der Satan!
  
  Aber noch etwas lt mir keine Ruhe!
  
  NIFTY:
    Wrterbuch #1:
      nifty, adj. F: flott; (of gadget) raffiniert.
      
    Wrterbuch #2:
      hbsch (umgspr.),
      anziehend (umgspr.);
      belriechend (umgspr.)
      
  ...na was nun?
  
  So, viele werden jetzt aufhren den Tutor zu lesen, weil
  sie denken es ist ein Fake, Dumm-Blubber Mll.
  
  Bitte, wir knnen ja nicht einfache alles so im Raum 
  stehen lassen!
  
  Und liebe Kinder, die noch wenig bzw keine Ahnung vom
  Cracken haben. Diese IF Bedingung hat keine Einflu auf
  die Art und Weise wie der WinAmp gestartet wird!

  
    
4.1. Programmschutz herausfinden
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Dazu installieren wir am besten mal den WinAmp, und 
  starten Ihn. Jetzt klicken wir etwas drinnen rum.
  
  Haaa- da ist eine Box, wo wir Namen und Key eingeben 
  drfen. Und da ist der "Ok" Knopf deaktiviert, der
  wird wahrscheinlich erst aktviert wenn ein richtiger
  Key drinnen steht.
  
  Eins steht fest: zu cracken gehts dank gepackter EXE
  schon mal nicht. Das heit es geht auch der W32DSM
  nicht.
  
  Fr uns bedeutet das SoftIce, und fr mich viel mehr
  Tipparbeit!

  
  
4.2. Wie fange ich das Programm ab?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  
  Wie abfangen? Also, um in den SoftIce zu gelangen mu
  man Strg+D drcken, und um wieder heraus zukommen auch.
  
  Das Problem: Wenn ich einfach mal so Strg+D drcke lande
  ich im SoftIce garantiert in der Idle Prozedur, weil
  mein supppperschneller Rechner eh nur zu 0,01% aus-
  gelastet ist. Und was will ich wissen was die Idle
  Prozedur macht (die macht einen HLT!).
  
  Also mu ich mir was einfallen lassen wie ich an den
  WinAmp ran bzw reinkomme.
  
  SoftIce bietet uns nun eine Menge Mglichkeiten Break-
  points zu setzen. 
  
  Ein paar Erklrungen fr laien und Anfnger:
  (liebe Profies, ich wei das das sehr oberflchlich
  erklrt wird! bitte sagts mir wenn ich da was falsch 
  erklre!)
  
    * Breakpoint:  einfach bersetzt: Anhaltepunkt

      Anhalte -> Prozess (Programm) stoppen, wenn an einem
      Punkt   -> Speicherstelle zugegriffen wird
      
      kurz gesagt, der Prozessor kennt einen Punkt, eine
      Speicheradresse, und wenn auf diese zugegriffen
      wird springt er in eine Unterroutine (das kann man
      alles selber festlegen: die Adressen und Routinen).
      
      Zugriffe auf eine Speicheradresse knnen unter-
      schiedliche Formen haben:
      
      X:  execution -> an Speicheradresse wo der BP hin-
          zeigt wird ein (ASM)Befehl ausgefhrt.
          
          Bsp: Breakpoint zeigt auf Adresse 015f:00001001
          
          und im Speicher steht dort:
          
          CS   EIP       MEM      ASM
         -------------------------------------------          
          015f:00001000  55       push  ebp
          015f:00001001  8b ec    mov   ebp, esp
          015f:00001003  6a ff    push  0xff
          .
          .
          .
      
          nun passiert folgendes: Der Prozessor schreitet 
          unaufhaltbar mit seinem CS:EIP auf unseren Break-
          point zu. Und wenn er die Stelle, den Befehl an
          015f:00001001 abarbeiten will stellt er fest:
          
          Ah- Breakpoint... da soll ich "anhalten" und 
          springt in eine Breakpointhandling Routine!
          Die ist dann z.b. SoftIce.
          
          (So einfach wie das hier steht ist es nicht!!)
          
          Alles klar?
          
          Also ein Breakpoint der bei Execution auf die
          Stelle 015f:00001001 gesetzt wird erzeugt immer
          dann ein BP-Event wenn der Befehl mov ebp, esp
          an eben genannter Speicherstelle ausgefhrt 
          werden soll.

                
      R:  read -> also bei Lesezugriff auf eine Speicher-
          stelle (Byte, Wort, Doppelwort) kann ein Break-
          point gesetzt werden. Und immer dann, wenn von
          dieser Speicher stelle gelesen wird - wird
          die BP-Handling Routine aufgerufen.
          
          kleines Bsp:
          
          folgendes Datensegment:

          Adresse   Hex-Inhalt                Ascii
         -----------------------------------------------       
          0030:0000 : 31 32 33 34 35 36 37 38   12345678
          0030:0008 : 61 62 63 64 65 66 67 68   abcdefgh
      
      
          und folgender Codesegment-Auszug:
      
          mov   ax, 0x0030
          mov   ds, ax
          mov   bl, [ax]           ; ist dann 0030:0000
          mov   cl, [ax+8]         ; ist dann 0030:0008
          
          und folgender Breakpoint:
          
          an Adresse 0030:0008, bei Lesezugriff
          
          So, jetzt kommt der CS:IP zu
          
          mov   ax, 0x0030
          lesender Speicherzugriff an 0030:0008? Nein...
      
          mov   ds, ax
          lesender Speicherzugriff an 0030:0008? Nein...
          
          mov   bl, [ax]
          lesender Speicherzugriff an 0030:0008? Nein...
          aber an Stellen 0030:0000... knapp vorbei!
          
          mov   cl, [ax+8]
          lesender Speicherzugriff an 0030:0008? Ja...
          
          Was passiert? Die BP-Handling Routine wird
          aufgerufen!
          
          Also ein Breakpoint der bei Lesezugriff auf die
          Stelle 0030:00000008 gesetzt wird erzeugt immer
          dann ein BP-Event wenn von dieser Speicher-
          stelle gelesen wird!


      W:  Write -> im Grunde das gleiche wie bei R, nur
          das eben bei schreibzugriffen der BP anspringt.
                    
          mov   ax, 0x0030
          mov   ds, ax
          mov   bl, [ax]           
          mov   [ax+8], bl  ; hier wird jetzt geschrieben!



      RW: read oder write -> also entweder R oder W
                        

  Das ganze fr SoftIce:
  
    SoftIce bietet die Mglichkeit Breakpoints zu setzen
    und zwar diese:
                             
     BPX ... breakpoint on execution
    
      -> d.h. einen BP auf Speicherstellen, und jedesmal
         wenn der CS:EIP dort hingeht soll SoftIce an-
         hpft kommen
         
         SoftIce bietet einem hier etwas ganz wunderbares:
         Es ermglicht uns BPX's nicht nur auf Speicher-
         adressen zulegen, odern auch auf API Funktionen.
         
         (Jede API Funktion hat eine Adresse, also ist das
         das gleiche, aber ein BPX ShowWindow ist einfacher
         zu machen als ein BPX 1234:004435738)
         

     BPM = BPMB, BPMW, BPMD ... breakpoint on memory access
     
      -> hier kann bestimmte Speicherstellen berwachen,
         berwachen auf Lese-/Schreib-/Exec-zugriffe.
         Und wenn darauf zugegriffen wird kommt natrlich
         SoftIce angesprungen.



  So, jetzt gehen wir wieder zu unserem WinAmp. Wie bereits
  festgestellt ist der Ok Button deaktiviert.
  Jetzt lasse ich mal schnell den VC++ programmierer raus-
  hngen:
  
  Knpfe, oder andere Windowselemente de-/aktivieren?
  
  wie macht man sowas... also ich mache das so:
  
       hwndC = GetDlgItem(hwndDialod, ID_CONTROL);
       EnableWindow(hwndC, boolStatus);


  Na Leute wie wre es wenn wir uns in EnableWindow rein-
  hngen? Klever nicht?
  
  Das ist unser gesuchter Abfangpunkt! Jetzt los - wir
  wollen SoftIcen!


  
5. SoftIce bis zum umkippen
~~~~~~~~~~~~~~~~~~~~~~~~~~~

  Wie gerade beschlossen wollen wir uns in/an die
  EnableWindow hngen. Also SoftIce ranholen, und einen
  BPX enablewindow machen.
  
  F5 im SoftIce damit es weitergeht.
  
  Jetzt gehen wir in den WinAmp und geben einen Key
  ein. Hoppla - eine Taste gedrckt, und schon kommt
  SoftIce. Das ist ja richtig nett.
  Damit fhlen wir uns schon mal in der Annahme be-
  sttigt, das bei jeder nderung von Name oder Key
  getestet wird ob richtig oder nicht.
  Damit wir in Ruhe mal einen Key eingeben knnen
  schalten wir den Breakpoint erst mal wieder aus.
  
  Das geht im SI mit :bd 0 (0...Nummer des BP, und
  da wir nur den einen haben passt's).
  
  Jetzt geben wir Fix unseren Namen ein, na ja wir
  nehmen mal "xCrk'98 [Laxity]" ein. Bei dem Key 
  stellen wir uns gleich von anfang an klever an.
  Da nehmen wir 305419896. He? Wie? Wo ist denn
  logisch oder klever? Leute mitdenken.
  Taschenrechner holen, in HEX umwandeln, ah da
  kommt pltzlich 0x12345678 raus! Und das ist irgend-
  wie klever. Da bei dem Key nur zahlen eingegeben
  werden knnen wird hchst wahrscheinlich irgendwo
  im WinAmp unsere 0x12345678 mit dem richtigen Key
  verglichen werden.
  Also geben wir im WinAmp erstmal 30541989 - die
  6 vergessen wir, die nehmen wir um den BPX auszu-
  lsen. Jetzt den SI aufgerufen, BPX wieder ein-
  schalten (mit :be 0). F5 um SoftIce zu verlassen.
  Und im WinAmp die vergessene 6 eingeben. Kurz danach
  wird auch gleich der BPX ausgelst.
  
  So, jetzt sind wir im SoftIce, der Prozessor steht
  an dem Anfang der EnableWindow Funktion. Das sehen
  wir im Code-Teil bei Softice. Die Funktion selber
  interessiert uns aber nicht. Darum drcken wir F12.
  (F12... SoftIce arbeitet das Programm bis zum 
  nchsten RET ab). Jetzt kommen wir wieder irgendwo
  zum stehen. Und zwar an einem JMP ..., schauen wir
  einen Befehl hher. Aha da steht ja gar kein 
  CALL user32.EnableWindow, also sind wir noch nicht
  richtig aus der EnableWindow Funktion heraus. Das
  heit solange F12 bis der CALL user32.EnableWindow
  ber dem akt. CS:EIP steht. Nach einem weiteren
  F12 haben  wir das dann auch erreicht.
  
  Hier ist mal der entsprechende Codeauszug:
  

:00403733 E8407C0000          call 0040B378
:00403738 83C404              add esp, 00000004
:0040373B 3BC6                cmp eax, esi
:0040373D 7509                jne 00403748
:0040373F 385D80              cmp byte ptr [ebp-80], bl
:00403742 7404                je 00403748
:00403744 6A01                push 00000001
:00403746 EB02                jmp 0040374A
:00403748 6A00                push 00000000
:0040374A 6A01                push 00000001
:0040374C FF7508              push [ebp+08]

* Reference To: USER32.GetDlgItem, Ord:00F3h
|
:0040374F FF151C674400        Call dword ptr [0044671C]
:00403755 50                  push eax

* Reference To: USER32.EnableWindow, Ord:00B2h
|
:00403756 FF15B4664400        Call dword ptr [004466B4]

<------ HIER STEHEN WIR NACH DEM BPX und 2x F12 ------>

:0040375C 33C0                xor eax, eax
:0040375E 5F                  pop edi


  Jetzt kommt einfach wieder das nachobenlesen...
  Fangen wir an:
  
       Call dword ptr [004466B4]
          -> das ist der USER32.EnableWindow Call
       
       push eax
          -> hier wird das hwnd welches die Funktion
             USER32.GetDlgItem liefert fr den
             EnableWindow Call als Parameter gepusht.
             
             Ihr werdet sicher feststellen, das da ein
             Push [etwas] fehlt, weil die Funktion
             EnableWindow ja zwei Parameter hat - keine
             Angst, das wurde bei
             
:00403742 7404                je   00403748
:00403744 6A01                push 00000001 -> Knopf an
:00403746 EB02                jmp  0040374A
:00403748 6A00                push 00000000 -> Knopf aus
             
             schon alles erledigt.
             
  Gehen wir noch etwas hher, noch vor die Status-Push's.
  Da stehen zwei vergleiche, und wie wir festellen, kann
  unsere 1 nur gepusht werden wenn 
  
:0040373B 3BC6                cmp eax, esi
:0040373D 7509                jne 00403748

  und  
  
:0040373F 385D80              cmp byte ptr [ebp-80], bl
:00403742 7404                je 00403748
  
  EAX = ESI und [EBP-80] <> BL.
  
  Sieht ganz vielversprechend aus. Der CMP mit dem BL sieht
  unwichtig aus, aber der CMP EAX, ESI. Und er wird noch
  interessanter wenn wir noch zwei Zeilen hherschauen.
  
:00403733 E8407C0000          call 0040B378
:00403738 83C404              add esp, 00000004
:0040373B 3BC6                cmp eax, esi
  
  Da steht ein CALL, knnte das nicht die immerwieder
  existierende CheckKey Routine, oder hier die GetKey
  Routine sein? (Schon im vorraus... sie ist es).
  
  So, jetzt wieder den SoftIce dahin bringen, das er nach
  dem Call vom EnableWindow auf dem xor eax, eax steht.
  
  Jetzt wechseln wir mit F6 im SI von der "CmdLine" in
  den Code-Teil. Dort scrollen wir nach oben, und
  setzen mit F9 auf den cmp eax, esi einen Breakpoint.
  Jetzt lassen wir mit F5 alles weiterlaufen.
  
  5 Prozessortakte ;-) spter sind wir wieder im SI,
  blo diesmal stehen am cmp eax, esi. Da machen wir
  eine klassische Registerbeobachtung. Aha in EAX steht
  028DDEAA, was knnte das sein - egal, schauen wir
  ESI an, wie was, da steht unsere 12345678 - WOW es
  geschehen noch Zeichen und Wunder! Und jetzt wissen
  wir auch was EAX ist, er richtige Key, den die Funktion
  uns zurckgeliefert hat. WOW das ist ja geil.
  
  Jetzt werden ganz fix alle BP's mit :bd * ausge-
  schalten, der Softice verlassen. Die 028DDEAA mit
  dem Taschenrechner in 42852010 umgewandelt.
  Das ganze im WinAmp eingegeben.
  
  UND: Der Ok Button ist Drckbar!
  
  Wahnsinn, Ihr habt es wieder mal geschafft, ganz ohne
  fremde Hilfe habt Ihr ein gutes (und geschtztes)
  Shareware Programm gekauft!
  
  Gratuliere!
  

    
6. Ich will einen KeyGen!
~~~~~~~~~~~~~~~~~~~~~~~~~

  Na dann machen wir doch schnell noch einen.
  Wie bereits festgestellt ist vor dem cmp eax, esi
  eine Funktion, welche uns den richtigen Key liefert.
  
  Hier ist die komplette "GetKey" Funktion:


  (File: GetKeyFunktion.txt)
  
  So, Leute ich habe keinen Bock drauf. Ich habe
  meinen Key.

