
									      
	                             
	 ۱ ۱  ۱ ۱ ۱  ۱         
	      ۱       ۱       ۱       ۱ ۱  ۱         
	        ۱         ۱         ۱         ۱   ۱    ۱         
	                  ۱         ۱           ۱    ۱         
	                        ۱        ۱    ۱         
	   ۱                  ۱     ۱         ۱         
	   ۱     ۱       ۱   ۱                    
	       ۱    ۱   ۱   ۱       ۱                
	        ۱   ۱  ۱   ۱   ۱         ۱                  
	            ۱                  ۱             
	                                     
									       


				GD^CRAZYs Tutorial
			 > "Wie code ich einen Patcher" <
				  



===[Kontakt]==================

GD^CRAZY
mail: gd_crazy@gmx.net

==============================

   Datum: 5.8.99
   Ŀ 
=== Einleitung         
    

   Moins zusammen! In diesem kurzen Tutorial mchte ich euch zeigen, wie
   man einen kleinen "Patcher" in C/C++ baut ...
   Nun, es werden sich jetzt vielleicht ein paar von euch fragen: "Was um
   Gotteswillen ist ein Patcher und wozu brauche ich das Teil???".
   Ganz einfach: Mit einem "Patcher" ist ein kleines Programm gemeint, das
   von dem meisten Crackern, Hackern oder Scenern in Assembler oder C/C++
   geschrieben wird ...fr den Anfang werden wir uns aber erstmal mit einem
   in C/C++ geschriebenen Patcher befassen. Die Profis coden das ganze
   natrlich in Assembler weil das Teil dann so gut wie keinen (1-2 KB) Platz
   auf der Festplatte einnimmt und viel schneller ist als ein Patcher, der
   in C/C++ geschrieben ist.

   Da das aber ein Tutorials fr Anfnger ist, werde ich (noch) KEINEN
   Assembler hier einsetzen =)


   Ŀ 
=== Und wozu????       
    

   Ein Programm kann/muss aus vielen Grnden gepatcht werden. Zum Beispiel
   um nachtrglich Bugs oder hnliches aus einem Programm zu entfernen. Das
   ganze ist aber nicht immer legal: Die meisten "Patcher", die im Internet
   kursieren dienen dazu um CD-Protections oder Trial-Versionen zu cracken.
   Was ihr mit euerem Patcher dann macht, ist dann eure Sache ;)

   Es gibt mittlerweile eine ganze Serie von sogenannten Patch-Engines im
   Internet, die einem die ganze Code-Arbeit abnehmen. Dazu brauch man nur
   noch die Werte eingeben, die verndert werden sollen ...
   Das ganze hat natrlich auch einen Haken: Die Engines liegen nicht als
   Sourcecode vor, sodas sich jeder seine eigene Engine kompilieren kann,
   nein, alle Groups haben ein fettes "Coded by XYZ^XYZ" in das Proggie ein-
   gebaut! 

   Es geht also nichts ber einen kleinen selbstgecodeten Patcher, den 
   man so gestalten/coden kann wie man selber will ;-))


   Ŀ 
=== Jetzt geht's ab! 
    

   Da ich einfache C/C++ Grundkenntnisse als Vorraussetzung sehe, denke
   ich, wir mssen ber die Befehle/Strukturen nicht sehr lange diskutieren.
   Wenn aber noch Fragen offen sein sollten, dann mailt mir einfach :)

   Ok ...nehmen wir an, wir wollten in einem Spiel namens "T500" (fragt mich
   bitte nicht, wie ich auf so einen genialen Namen gekommen bin!) ein paar
   Bytes verndern um unendliche Leben zu bekommen. Da wir zuflligerweise
   die genaue Adresse dieses Wertes schon kennen, legen wir uns einfach eine
   einfache Tabelle an, die uns zeigt, was wir von diesem Spiel schon wissen.
   (Profis brauchen sowas natrlich NICHT machen!).

   Name:                        T500
   Name der .EXE:               T500.EXE
   Anzahl der Patchtes:         2 Bytes
   
   Offsets der einzelnen Patches
   -----------------------------

   Offset1:             00012321
   Kontrolle1:          75
   ndern in:           74

   Offset2:             00014152
   Kontrolle2:          75
   ndern in:           74

   Als erstes werden wir uns mal die Struktur so eines kleinen Patchers
   ansehen (im Pseudo-Code):

   ----Code Anfang----

   1) Lade Intro-Screen
   2) Schaue ob die Datei, die gepatcht werden soll, vorhanden ist
   3) Wenn ja, dann schaue nach, ob die Bytes, die gendert werden
      sollen, noch nicht verndert (gepatcht) sind.
   4) Wenn alles ok ist, dann beginne mit dem patchen (schreiben/ver-
      ndern der Datei)
   5) Gebe zum Schluss einen Bericht ber die gesamte Aktion aus und
      verziere das ganze mit einem coolen Logo, Spruch oder hnliches
      (letzteres MUSS nicht unbedingt sein *G*)

   -----Code Ende-----


   Ŀ 
=== Jetzt gibts keine Theorie mehr!! 
    

   Wie die berschrift schon sagt: Jetzt wirds ernst :)
   Der Code des Patchers, den wir coden wollen, wird so aussehen:

   ANMERKUNG: Der gesamte Code ist nochmal komplett in der Dsatei CRAZY.CPP
   enthalten! So msst ihr nicht diesen hier mhsam rausschneiden ;)
   


	#include "stdio.h"
	#include "stdlib.h"

	FILE *Fh;
	char c;
	static long BPos[20];
	static char Ctrl[20];
	static char Trgt[20];

	// Wer war der Patcher?
	char *info_patcher="GD^CRAZY";
	
	// Wie heit das Spiel/die Anwendung?
	char *info_name="T500";
	
	// Wie heit die .EXE-Datei?
	char *info_file="T500.EXE";
	
	// Wieviele Bytes mssen gendert werden?
	int  info_numchanges=2;

	// Hier kommt alles rein, was gendert werden muss!
	void CollectAllChanges ()
	{
		// Die Position in der Datei
		BPos[0]=00012321;
		
		// Welches Byte steht an der Position? (zur Kontrolle!)
		Ctrl[0]=75;
		
		// Mit welchem Byte soll das alte Byte berschrieben werden?
		Trgt[0]=74;

		// Und das ganze nochmal mit dem 2. Teil :)
		BPos[1]=00014152;
		Ctrl[1]=75;
		Trgt[1]=74;
	}

	void RunIntro ()
	{
		// Hier wird das Intro ausgegeben. Kann auch komplett
		// in Mode13, X oder VESA sein ...das ist vllig wurscht.
		
		printf ("\n\nGD^CRAZYs little Patcher v1.0\n");
		printf ("Based on GD^CRAZYs Tutorial in 1999\n");
		printf ("-----------------------------------\n\n");

		printf ("Patched by ..........: %s\n", info_patcher);
		printf ("Name of App/Game ....: %s\n", info_name);
		printf ("File patched ........: %s\n\n", info_file);

		printf ("Patching ...");
	}

	void RunOutro ()
	{
		// Hier kommt das Outro. Wie im Intro ist es vllig
		// egal, was ihr hier hinsetzt!
		
		printf ("\n\nHave a nice day!\n\n");
	}

	void RunPatch ()
	{
		// Das ist das eigentliche "Herz" von dem Patcher.
		// Hier wird in einer Schleife erst geprft, ob das alte
		// Byte tatschlich an der Stelle ist wo es sein sollte.
		// Wenn das der Fall ist, dann berschreibe es mit dem
		// neuen Wert.
		
		if((Fh=fopen(info_file, "r+b"))!=NULL)
		{
			for (int i=0; i<info_numchanges; i++)
			{
				fseek(Fh, BPos[i], SEEK_SET);
				fread(&c, 1, 1, Fh);
				if(c!=Ctrl[i])
				{
					printf("error: file is incompatible or already patched! Patch aborted.");
					fclose(Fh);
					RunOutro ();
					exit(1);
				}
				else
				{
					fseek(Fh, BPos[i], SEEK_SET);
					fwrite(&Trgt[i], 1, 1, Fh);
				}
			}

			fclose (Fh);
			printf ("done. File is patched.");
			RunOutro ();
			exit (0);
		}
		else
		{
			printf ("error: could not open/acces file! Patch aborted.");
			RunOutro ();
			exit (1);
		}
	}

	void main ()
	{
		// Sieht ziemlich klein aus, die main-routine, was? *g*
		
		CollectAllChanges ();
		RunIntro ();
		RunPatch ();        
	}

   
   Ŀ 
=== Nu iss aber gut! 
    

   Ich hoffe ich habe euch einen kleinen Einblick geben knnen wie ein
   Patcher funktioniert. Ich weiss natrlich auch, das der von mir vor-
   gestellte Patcher nicht der beste ist. Er dient ja auch nur zu Lern-
   zwecken. Ausserdem kann man ihn nach Herzenslust noch mit allen
   Finessen ausbauen (z.B Statusbalken, Musik-Routine whrend dem Patchen,
   Grafikeffekte, externe Patch-Archive usw.).
   Sendet mir einfach mal n kurzes Feedback an: gd_crazy@gmx.net

   In diesem Sinne,
			
			GD^CRAZY



   




