

                                        
                 ܲ      
              ܲ۲  ۲  
                 ޲۲   ߲۲ ޲۲  ߲۲
                   ޲۲       ۲  ޲۲ 
                  ޲  ۲   ޲۲  ۲
                    ߲۲  ޲۲  ޲۲ ܲ۲ 
                   ޱ  ߲  ܱ۲  ۲ ۲ 
                 ߰    ߰  ۲ '99
                                       srT  
                                . [ AzzYRiAN ] .


-----------------------------------------------------------------------------
KNACKER ..........................: AzzYRiAN 
PROGRAMM, DASS VERGEWALTIGT WIRD .: TbC KnackMich Nummer 3 programmiert von Viny.
ART DER BRECHUNG .................: Schluesselmacher
-----------------------------------------------------------------------------
WERKZEUGE:
 - Sice
 - Einen C++ Compiler
-----------------------------------------------------------------------------

Dieses Dokument ist fast 100% deutsch. Ich habe mir echt Muehe gegeben :)

[ Vorneweg ] Nur das niemand umfaellt ... Auf diesem Wege macht kein normaler
Mensch einen Keygen, das hat viel mit Aha-Erlebnissen zu tun und geht fuer
dieses KnackMich auch viel schneller. Natuerlich is die Methode die ich hier
zur Erklaerung verwende nicht Falsch. Ausserdem ist ein methodisches vorgehen
immer von Vorteil. Daran werde ich mich nie gewoehnen :) Trotzdem brauchte ich
fuer den Schluesselmacher nur knapp 10 Minuten.

[ SCHRiTT 1 ] Startet das Programm, aha, nur eine Registriernummer wird verlangt,
also geben wir erstmal eine ein: 1122334455. Auf [CHECK iT] klicken und schon
sehen wir eine MessageBoxA, die uns sagt, wie schlecht wir sind. Gut, das ganze
nochmal, allerdings setzen wir vorher einen Haltepunkt auf die Funktion 'hmemcpy'.
Jetz landen wir irgendwo in der Assembler Wueste und druecken so lange f12, bis
wir im eigentlichen Programm angekommen sind.

[ Hauptfunktion des KnackMichs ]
013f:00403d7f  mov     ebx,eax			<- Hier landen wir
013f:00403d81  lea     edi,[ebx+01]
013f:00403d84  mov     eax,edi
013f:00403d86  call    00402464
013f:00403d8b  mov     esi,eax
013f:00403d8d  push    edi
013f:00403d8e  push    esi
013f:00403d8f  mov     eax,[00406508]
013f:00403d94  push    eax
013f:00403d95  call    USER32!GetWindowTextA
013f:00403d9a  cmp     ebx,0b			<- Pruefung 1
013f:00403d9d  jnz     00403e15			<- Laenge der Nummer == 0bh = 11d ?
013f:00403d9f  lea     eax,[ebp-08]
013f:00403da2  mov     edx,esi
013f:00403da4  call    00402e28
013f:00403da9  mov     eax,[ebp-08]
013f:00403dac  lea     edx,[ebp-01]
013f:00403daf  call    00403bb4			<- FUNKTION Kung Fu  ( VN- )
013f:00403db4  cmp     byte ptr [ebp-01],00	<- Pruefung 
013f:00403db8  jz      00403dcc			
013f:00403dba  lea     eax,[ebp-08]
013f:00403dbd  mov     edx,esi
013f:00403dbf  call    00402e28
013f:00403dc4  mov     eax,[ebp-08]
013f:00403dc7  call    00403c54			<- FUNKTION Karate  ( Berechnung )
013f:00403dcc  lea     eax,[ebp-08]
013f:00403dcf  mov     edx,esi
013f:00403dd1  call    00402e28
013f:00403dd6  mov     eax,[ebp-08]
013f:00403dd9  lea     edx,[ebp-01]
013f:00403ddc  call    00403cb4			<- FUNKTION Kung Fu    ( -TbC )
013f:00403de1  cmp     byte ptr [ebp-01],00	<- Pruefung 3
013f:00403de5  jz      00403e15
013f:00403de7  cmp     dword ptr [00406528],0000012c
013f:00403df1  jnz     00403e15			<- Pruefung 4
013f:00403df3  push    00
013f:00403df5  push    00403e50
013f:00403dfa  push    00403e60
013f:00403dff  mov     eax,[00406500]
013f:00403e04  push    eax
013f:00403e05  call    USER32!MessageBoxA	<- Erfolgsmeldung
013f:00403e0a  mov     edx,edi
013f:00403e0c  mov     eax,esi
013f:00403e0e  call    0040247c
013f:00403e13  jmp     00403e2c
013f:00403e15  push    00
013f:00403e17  push    00403e74
013f:00403e1c  push    00403e80
013f:00403e21  mov     eax,[00406500]
013f:00403e26  push    eax
013f:00403e27  call    USER32!MessageBoxA	<- Fehlermeldung
013f:00403e2c  xor     eax,eax
013f:00403e2e  pop     edx
013f:00403e2f  pop     ecx
013f:00403e30  pop     ecx
013f:00403e31  mov     fs:[eax],edx
013f:00403e34  push    00403e49
013f:00403e39  lea     eax,[ebp-08]
013f:00403e3c  call    00402d2c
013f:00403e41  ret

[ SCHRiTT 2 ] Gut, als erstes einen Haltepunkt setzen ( bpx eip ). Nun tracen wir ein
bischen, aber an der Stelle (Pruefung 1) fliegen wir auch schon raus, da unsere
eingegebene Registriernummer nicht 0bh = 11d Zeichen lang ist. Also, raus, eine
laengere Nummer verwenden, 11223344556 und an unserem neuen Haltepunkt wieder ins
Programm einstegen. Nun kommen wir weiter, bis zu dem Vergleich nach der Funktion, der
ich den Name Kung Fu gab. Hier fliegen wir wieder raus.

[ SCHRITT 3 ] Wieder ins Programm rein, bis Kung Fu tracen, nun mit f8 rein in die
Funktion.
[ Funktion Kung Fu ]
013f:00403cb4  push    ebp
013f:00403cb5  mov     ebp,esp
013f:00403cb7  push    00
013f:00403cb9  push    00
013f:00403cbb  push    00
013f:00403cbd  push    ebx
013f:00403cbe  push    esi
013f:00403cbf  mov     esi,edx
013f:00403cc1  mov     [ebp-04],eax
013f:00403cc4  mov     eax,[ebp-04]
013f:00403cc7  call    00402f40
013f:00403ccc  xor     eax,eax
013f:00403cce  push    ebp
013f:00403ccf  push    00403d3a
013f:00403cd4  push    dword ptr fs:[eax]
013f:00403cd7  mov     fs:[eax],esp
013f:00403cda  lea     eax,[ebp-08]
013f:00403cdd  call    00402d2c
013f:00403ce2  mov     bl,08
013f:00403ce4  lea     eax,[ebp-0c]		<- Start der Schleife
013f:00403ce7  xor     edx,edx
013f:00403ce9  mov     dl,bl
013f:00403ceb  mov     ecx,[ebp-04]
013f:00403cee  mov     dl,[edx+ecx-01]		<- ecx = Nummer
013f:00403cf2  call    00402e18
013f:00403cf7  mov     edx,[ebp-0c]
013f:00403cfa  lea     eax,[ebp-08]
013f:00403cfd  call    00402e58
013f:00403d02  inc     ebx
013f:00403d03  cmp     bl,0c
013f:00403d06  jnz     00403ce4			<- Ende der Schleife
013f:00403d08  mov     eax,[ebp-08]		<- Die ersten 3 Zeichen ( 112 )
013f:00403d0b  mov     edx,00403d50		<- VN-
013f:00403d10  call    00402e9c			<- Vergleich
013f:00403d15  jnz     00403d1c
013f:00403d17  mov     byte ptr [esi],01
013f:00403d1a  jmp     00403d1f
013f:00403d1c  mov     byte ptr [esi],00
013f:00403d1f  xor     eax,eax
013f:00403d21  pop     edx
013f:00403d22  pop     ecx
013f:00403d23  pop     ecx
013f:00403d24  mov     fs:[eax],edx
013f:00403d27  push    00403d41
013f:00403d2c  lea     eax,[ebp-0c]
013f:00403d2f  mov     edx,00000003
013f:00403d34  call    00402d50
013f:00403d39  ret

Gut, hier ein Stueck runtertracen, bis ihr an die Stelle kommt, die ich mit ( Start der
Schleife ) betitelt habe.
Der Programmteil hat die einfache Aufgabe, die ersten 3 Zeichen der eingegebenen Ristrier-
nummer in eine Variable zu schreiben. In unserem Fall 112. diese Zeichenketten werden von
dem Funktionsaufruf etws weiter unten verglichen. So, hier brechen wir ab, und geben eine
neue Registriernummer ein. Und zwar: VN-11223344. Bestens, nun kommen wir auch am Vergleich
(Kung Fu) vorbei. Wir tracen weiter, bis uns der Vergleich nach dem erneuten Aufruf von
(Kung Fu) mit dumme Anfaenger tituliert.

[ SCHRiTT 4 ] Hm, gut gut, wieder VN-11223344 eingeben und bis zum zweiten Aufruf von (Kung Fu)
tracen. Alle Haltepunkte deaktivieren und einen neuen setzen mit bpx eip. So, jetzt mit f8 in
die Funktion rein.

[ Funktion Kung Fu ]
013f:00403cb4  55                  push    ebp
013f:00403cb5  8bec                mov     ebp,esp
013f:00403cb7  6a00                push    00
013f:00403cb9  6a00                push    00
013f:00403cbb  6a00                push    00
013f:00403cbd  53                  push    ebx
013f:00403cbe  56                  push    esi
013f:00403cbf  8bf2                mov     esi,edx
013f:00403cc1  8945fc              mov     [ebp-04],eax
013f:00403cc4  8b45fc              mov     eax,[ebp-04]
013f:00403cc7  e874f2ffff          call    00402f40
013f:00403ccc  33c0                xor     eax,eax
013f:00403cce  55                  push    ebp
013f:00403ccf  683a3d4000          push    00403d3a
013f:00403cd4  64ff30              push    dword ptr fs:[eax]
013f:00403cd7  648920              mov     fs:[eax],esp
013f:00403cda  8d45f8              lea     eax,[ebp-08]
013f:00403cdd  e84af0ffff          call    00402d2c
013f:00403ce2  b308                mov     bl,08
013f:00403ce4  8d45f4              lea     eax,[ebp-0c]		<- Start der Schleife
013f:00403ce7  33d2                xor     edx,edx
013f:00403ce9  8ad3                mov     dl,bl
013f:00403ceb  8b4dfc              mov     ecx,[ebp-04]
013f:00403cee  8a5411ff            mov     dl,[edx+ecx-01]	<- ecx = Nummer
013f:00403cf2  e821f1ffff          call    00402e18
013f:00403cf7  8b55f4              mov     edx,[ebp-0c]
013f:00403cfa  8d45f8              lea     eax,[ebp-08]
013f:00403cfd  e856f1ffff          call    00402e58
013f:00403d02  43                  inc     ebx
013f:00403d03  80fb0c              cmp     bl,0c
013f:00403d06  75dc                jnz     00403ce4		<- Ende der Schleife
013f:00403d08  8b45f8              mov     eax,[ebp-08]		<- Letzten 4 Zeichen ( 3344  )
013f:00403d0b  ba503d4000          mov     edx,00403d50		<- -TbC
013f:00403d10  e887f1ffff          call    00402e9c		<- Vergleich
013f:00403d15  7505                jnz     00403d1c
013f:00403d17  c60601              mov     byte ptr [esi],01
013f:00403d1a  eb03                jmp     00403d1f
013f:00403d1c  c60600              mov     byte ptr [esi],00
013f:00403d1f  33c0                xor     eax,eax
013f:00403d21  5a                  pop     edx
013f:00403d22  59                  pop     ecx
013f:00403d23  59                  pop     ecx
013f:00403d24  648910              mov     fs:[eax],edx
013f:00403d27  68413d4000          push    00403d41
013f:00403d2c  8d45f4              lea     eax,[ebp-0c]
013f:00403d2f  ba03000000          mov     edx,00000003
013f:00403d34  e817f0ffff          call    00402d50
013f:00403d39  c3                  ret

Die Funktionsweise kennen wir nun, allerdings werden hier die letzten 4 Zeichen unserer
Registriernummer mit -TbC verglichen. Sauber! Also, raus, neue Nummer eingeben VN-1122-TbC
und wir werden von dem Vergleich nach dem zweiten Aufruf von Kung Fu auch vorbeigelassen.

[ Zwischenhalt ] Wir befinden uns nun in der Hauptfunktion des KnackMichs an der Stelle genau
hinter dem Vergleich nach dem zweiten Aufruf von Kung Fu und zwar hier:

013f:00403de7  cmp     dword ptr [00406528],0000012c
013f:00403df1  jnz     00403e15			<- Pruefung 4

Uhm, eine Speicherstelle wird mit 012ch verglichen, tja, in unserem Fall scheint dieser
Vergleich wieder zu versagen ...
Gut, kurze Zwischenanalyse. Der Schluessel muss 12 Zeichen lang sein und folgendes Format
haben: VN-xxxx-TbC

[ SCHRITT 5 ]
An dieser Stelle wuerden die meisten abbrechen, aber wir wollen doch so gerne die Welt
mit einem Schluesselmacher erfreuen.
Wir machen folgendes, wir setzen einen Haltepunkt auf die Speicherstelle die verglichen
wird. bpm 030:00406528 rw
Raus aus dem Programm, wieder unsere falsche Nummer eingeben VN-1122-TbC und nur den neuen
Haltepunkt aktivieren. Auf [CHECK iT] klicken und wir landen an folgender stelle:

013f:00403c54  push    ebp
013f:00403c55  mov     ebp,esp
013f:00403c57  push    ecx
013f:00403c58  mov     [ebp-04],eax
013f:00403c5b  mov     eax,[ebp-04]
013f:00403c5e  call    00402f40
013f:00403c63  xor     eax,eax
013f:00403c65  push    ebp
013f:00403c66  push    00403ca7
013f:00403c6b  push    dword ptr fs:[eax]
013f:00403c6e  mov     fs:[eax],esp
013f:00403c71  xor     eax,eax
013f:00403c73  mov     [00406528],eax
013f:00403c78  mov     al,04			<- DA, HIER!!!!
013f:00403c7a  xor     edx,edx
013f:00403c7c  mov     dl,al
013f:00403c7e  mov     ecx,[ebp-04]		<- Die Zeichen ab 
013f:00403c81  movzx   edx,byte ptr [edx+ecx-01]<- Stelle 4 bis zu
013f:00403c86  add     [00406528],edx		<- Stelle 7 werden
013f:00403c8c  inc     eax			<- addiert
013f:00403c8d  cmp     al,08
013f:00403c8f  jnz     00403c7a
013f:00403c91  xor     eax,eax
013f:00403c93  pop     edx
013f:00403c94  pop     ecx
013f:00403c95  pop     ecx
013f:00403c96  mov     fs:[eax],edx
013f:00403c99  push    00403cae
013f:00403c9e  lea     eax,[ebp-04]
013f:00403ca1  call    00402d2c
013f:00403ca6  ret

Sehr einfach, alle Zeichen von Stelle 4 bis zu Stelle 7 unserer Registriernummer
werden addiert und in der besagten Speicherstelle abgelegt. Fuer unsere Nummer,
ergibt das eine Summe von c6h oder 198d. Gut, gut, wir brauchen aber eine Summe
von 12ch oder 300d. Ja, da spielen wir doch einfache ein bischen unter unserem
guten Softice mit dem ? Kommando rum und kommen zu der Loesung, dass folgende 4
Zeichen eine Quersumme von 12ch haben. AZNC Pruefen mit:  ? 'A'+'Z'+'N'+'C
Gut, eine funktionierende Registriernummer waere demnach: VN-AZNC-TbC
Diese Registriernummer ins KnackMich eintragen und probieren. Hehe, grins, wir
werden dick gelobt :)

[ Der Schluesselmacher ]
/* cODE by AzzYRiAN in 04.07.99 */
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

void main( void )
{
 char
  RegCode[ 5 ],
  Table[ ] = { "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890" };
	// Meine Idee, ich erlaube nur die Zeichen in dem Array, da die immer
	// problemlos dargestellt werden koennen.
 int
   summe = NULL;

 printf( "\nsCHLUESSELMACHER fUER DAS TbC KNACKMiCH 3 - kNACKER: AzzYRiAN / ODDiTY 1999" );
 
 srand( (unsigned)time( NULL ) );	 	
	
 while( summe != 0x12c )		//solange die Summe nicht 12c ist, wiederholen
 {
  summe = NULL;				//Summe auf Null setzen
  RegCode[ 0 ] = 0x0;			//Den Tabellenauszug loeschen
  for( int i = NULL; i < 4; i++ )	//4 Zufallszeichen aus der Tabelle auslesen
  {					
   RegCode[ i ] = Table[ rand() % 62 ];	//addieren der Zeichen
   summe += RegCode[ i ];		
  }
  RegCode[ i ] = 0x0;			//Den Tabellenauszug mit Null( binaer ) abschliessen
 }
 printf( "\nsCHLUESSEL: VN-%s-TbC"	//Ausgeben der Registriernummer
	 "\nDruekce eine Taste zum beenden ...\n", RegCode );
 getch();
}
/* Ende */

[ Allgemein ]
Das Crackme benutzt einen vom Prinzip her sehr starken Algorythmus, der natuerlich
etwas anders implementiert werden muss. Es ist eine de besten Methode, nicht eine
Registrierung auf Basis von Name und Seriennummer zu programmieren, sondern nur
eine Seriennummer abzufragen. Weil, mit der Nummer stellt man mathematische Operationen
an, wie z.B.: Ergeben die letzen beiden stellen wenn sie durch 12 geteilt wurden einen
Restwert von Null und wenn man 7 abzieht, soll die Nummer entweder gexored mit 12 < 20
oder + 20 ^ 13 > 25 sein. Solche Algorythmen sind schwerer zu vestehen und zu
uebersetzen.

[ Gruesse an ] Alle, die hier gegruest werden wollen, sollen mir ein Tutorial schicken,
dass dieses Crackme betrift, allerdings nur mit einem Hexeditor als Werkzeug erstellt
wurde. Gebt euch Muehe.

(c) by AzzYRiAN 16.07.99
 eMail: azzyrian@oddity.de
 eFnet: #odt 

