Pointer in C

[TeraTroll]

Guten Abend Community,

ich nähere mich so langsam dem Thema Pointer in C.
Ich habe da ein kleines Programm geschrieben, in welchem man den Wert einer internen Variable ändern kann.
Ich würde nur gerne fragen, ob es genauso auch beim "memory-manipulating" funktioniert, bzw. während einer Dll-Injektion da es sich ja dann so verhält, dass die Dll zu dem zu manipulierendem Prozess dazugehört, bzw. den selben Prozess bildet.


Die Kommentare sind für mich und die Übersichtlichkeit(gerne auch für die leichtere Verständnis dritter)

 Spoiler

#include <stdio.h>
#include <stdlib.h>

int main(void) {
	int change, temp, value = 10;
	int *pointer = NULL;
	
	printf("Anfangswerte Ausgabe:\n\n");
	printf("Value hat den Startwert: %d\n",value); //Gegebener Wert von 'value' ausgeben
	printf("Value hat die Addresse: %p\n",value); //Addresse von 'value' ausgeben
	printf("Pointer hat die Addresse: %p\n\n",pointer); //Addresse von 'pointer' ausgeben
	
	printf("------------------------------------------\n");
	printf("Initialisierung vom Pointer und zwischenspeichern von Value\n");
	pointer =& value; //Pointer auf die Addresse von 'value' zeigen lassen
	temp = *pointer; //Wer von pointer(value) zwischenspeichern
	printf("------------------------------------------\n\n");
	
	printf("Pointer hat die neue Addresse: %p\n",pointer); //Neue Addresse von 'pointer' ausgeben
	printf("Neuen Wert fuer 'value' bestimmen: ");
	scanf("%d",&change); //Neuen Wert von 'value' einlesen
	
	*pointer = change; //Neuen Wert initialisieren
	printf("------------------------------------------\n\n");
	
	printf("Pointer hat nun den Wert: %d",value); //Neuen Wert ausgeben
	return EXIT_SUCCESS; 
}

MfG Joshi

[snow]

Wenn du dich für das Thema interessierst, solltest du eventuell auch ein paar Bücher über Betriebssyteme lesen, dann dürften einige Zusammenhänge klar werden.

Ja, das Prinzip ist bei einer DLL-Injection das selbe. Die DLL und der Prozess teilen sich den selben Adressraum, weshalb die Adressen, die du in einer DLL referenzierst, gültig sind.

Es gibt dann immer ein paar Besonderheiten zu beachten (Threadsicherheit, Zugriffsschutz, evtl. Überwachung des Adressraums durch ein Anti Cheat), aber sobald man Zeiger verstanden hat, ist es immer das selbe Prinzip.

[TeraTroll]

Ahhh okay, danke. Kannst du mir eines empfehlen?
Bin momentan noch im reinem Lernstadium und habe nur ein bisschen rum gespielt,
dabei habe ich mich gefragt, wenn ich nun eine Dll mit(natürlich muss ich noch einen Handler usw. einfügen) ca. dem selben Inhalt, auf die Adressen abgeglichen, in einen Prozess(Bsp. das Spiel Terraria) Injiziere und somit Werte verändern könnte.
Stimmt dies soweit?

MfG Joshi

[snow]

Ja, das ist korrekt. Intern werden ja irgendwo Strukturen im Speicher angelegt und später wieder ausgelesen, wenn du auch Zugriff auf diese Adressen hast, kannst du da rumpfuschen wie du willst.

Zum Thema Betriebssyteme gibt es einiges, die Theorie wird wohl durch Tanenbaums Buch gut abgedeckt, praktisch (vor allem Windows) soll Windows via C/C++ ganz gut sein, Practical Reverse Engineering bietet auch einen breiten Einstieg in verschiedene Themen, unter anderem wie der Windows Kernel arbeitet (inklusive Kontext-Switching und Addressräume).

[TeraTroll]

Danke sehr für die Empfehlungen, ich denke, ich werde damit Anfangen, wenn ich mein Derzeitiges Buch durch habe. Das Thema Pointer ist meiner Meinung nach schon sehr komplex, von daher hat die System "Theorie" noch Zeit haben.
Erscheint mir auf den ersten Blick ein wenig zu komplex und abstrakt für einen Anfänger.

[_Roman_]

Ich glaube, dass Pointer in dem Sinne komplex sind, wie vielfältig man die einsetzen kann. Die ganzen Anwendungen können einen dann ziemlich verwirren, wie ich finde. Da verliert man leicht den Überblick

[TeraTroll]

Ja das ist genau das "Problem", ich bin ein wenig überwältigt von den Möglichkeiten, es wird in meinem Buch auch gesagt, dass wenn das Thema 'Pointer' kein Problem mehr ist, die Sprache 'C' es auch nicht mehr sein wird.

MfG Joshi

[warfley]

Zeiger sind an sich ziemlich einfach. Betrachte Zeiger nicht als schnieken neuen Datentypen, sondern einfach als 32 bzw. 64 Bit Wort. Du kannst mit Zeigern arbeiten wie mit jedem anderen Wort auch, du kannst es Multiplizieren, Modulieren, Dividieren, Addieren und Subtrahieren, Shiften, And, Or und Not drauf anwenden.
Auf der einen Seite hast du also ein Wort. Auf der anderen Seite Bietet C die Möglichkeit direkt auf den Speicher an einer Bestimmten Adresse zuzugreifen. Um mit Adressen zu Arbeiten muss man diese Irgendwo zwischenspeichern, und Adressen sind nun mal 32 oder 64 Bit Wörter. Also nutzt man Zeiger einfach nur als Variable um Adressen zwischen zu Speichern.

Du könntest auch ein normales Wort nehmen (unsigned long) aber Zeiger bieten durch ihren typen (Char, Integer, Single, etc) noch die Information, wie groß das Feld ist und wie der Typ ausgewertet werden soll (Char als Wort, Integer als Signierte Zahl, Single als IEEE 754).

Ansonsten gilt nur noch: Kellerspeicher wird automatisch zugewiesen und wieder Bereinigt, Haldenspeicher musst du es selbst erledigen mit malloc und free. Speicher wird immer in 8 Bit Blöcken (Registern) bereitgestellt, die Adressen werden pro 8 Bit um 1 erhöht. Greife nie auf umzugewiesenen Speicher zu, und lasse nie Speicher nicht freigegeben.
(Ziemlich einfach erklärt)

Mir hatte das zu Anfang sehr geholfen Zeiger einfach als Wörter zu betrachten, und die Methode auf Speicher über die Adresse zuzugreifen als "eigenständig" und von Pointern unabhängig zu betrachten

[Dr. Coxxy]

Originally Posted by warfley

Zeiger sind an sich ziemlich einfach. Betrachte Zeiger nicht als schnieken neuen Datentypen, sondern einfach als 32 bzw. 64 Bit Wort. Du kannst mit Zeigern arbeiten wie mit jedem anderen Wort auch, du kannst es Multiplizieren, Modulieren, Dividieren, Addieren und Subtrahieren, Shiften, And, Or und Not drauf anwenden.
Auf der einen Seite hast du also ein Wort. Auf der anderen Seite Bietet C die Möglichkeit direkt auf den Speicher an einer Bestimmten Adresse zuzugreifen. Um mit Adressen zu Arbeiten muss man diese Irgendwo zwischenspeichern, und Adressen sind nun mal 32 oder 64 Bit Wörter. Also nutzt man Zeiger einfach nur als Variable um Adressen zwischen zu Speichern.

Du könntest auch ein normales Wort nehmen (unsigned long) aber Zeiger bieten durch ihren typen (Char, Integer, Single, etc) noch die Information, wie groß das Feld ist und wie der Typ ausgewertet werden soll (Char als Wort, Integer als Signierte Zahl, Single als IEEE 754).

Ansonsten gilt nur noch: Kellerspeicher wird automatisch zugewiesen und wieder Bereinigt, Haldenspeicher musst du es selbst erledigen mit malloc und free. Speicher wird immer in 8 Bit Blöcken (Registern) bereitgestellt, die Adressen werden pro 8 Bit um 1 erhöht. Greife nie auf umzugewiesenen Speicher zu, und lasse nie Speicher nicht freigegeben.
(Ziemlich einfach erklärt)

Mir hatte das zu Anfang sehr geholfen Zeiger einfach als Wörter zu betrachten, und die Methode auf Speicher über die Adresse zuzugreifen als "eigenständig" und von Pointern unabhängig zu betrachten

nicht so viel kiffen?
srsly, dafuq?

[TeraTroll]

Wie meinst du das Coxxy?

[snow]

Coxxy möchte damit ausdrücken, dass jemand, der Kellerspeicher und Haldenspeicher in einem Text verwendet, entweder Informatik-Ersti oder bekifft (alternativ auch beides) ist.

Ja das ist genau das "Problem", ich bin ein wenig überwältigt von den Möglichkeiten, es wird in meinem Buch auch gesagt, dass wenn das Thema 'Pointer' kein Problem mehr ist, die Sprache 'C' es auch nicht mehr sein wird.

Ja, das Thema Pointer sieht sehr komplex aus, wenn man es aber mal gerafft hat und versteht, was im Hintergrund passiert und wie alles zusammenhängt, ist es nur ein weiterer Datentyp.

[TeraTroll]

Für mich besteht momentan hauptsächlich das Problem, dass ich mit dem Syntax bzw. den richtigen Zeichen durcheinander komme ('&' und '*') wann ich welches verwende und wann und wie.
Ich denke das ist eine reine Lernsache jedoch trotzdem komplex
Okay die Begriffe sagen mir momentan noch (gar-)nichts.

[Logtetsch]

Originally Posted by TeraTroll

Ahhh okay, danke. Kannst du mir eines empfehlen?

Originally Posted by snow

soll Windows via C/C++ ganz gut sein, Practical Reverse Engineering bietet auch einen breiten Einstieg in verschiedene Themen, unter anderem wie der Windows Kernel arbeitet (inklusive Kontext-Switching und Addressräume).

Ich kann snows Vorschläge nur unterschreiben. Ich setze mich derweil ebenfalls mit beiden Titeln auseinander. Jeffery Richter und Christophe Nasarre haben mit dem Titel "Windows via C/C++" (5th edition - bei mir) ganze Arbeit geleistet. Auch das angesprochene Thema "DLL Injection and API Hooking" sowie "Memory Management" bleiben nicht unbehandelt. Aber auch viele andere Bereiche werden bestens dargestellt und erklärt. Zu letztere kann ich bis dato nur wenig sagen, weil ich erst gerade angefangen habe. €: "Windows Internals 6th edition" - soll auch ganz gut sein.

[warfley]

Coxxy möchte damit ausdrücken, dass jemand, der Kellerspeicher und Haldenspeicher in einem Text verwendet, entweder Informatik-Ersti oder bekifft (alternativ auch beides) ist.

Mein Ziel war es nur mal diese Beiden dinge Anzusprechen, ich wollte da nicht groß drauf eingehen. Bekifft nicht, aber jedesmal wenn ich Kaffee trinke ist das bei mir um Welten schlimmer, ich vertrage einfach kein Koffein :P

[TeraTroll]

Haha damit hast du gerade indirekt zugegeben, dass die THC mehr zusagt :P

B2t:
Danke sehr Logtesch, kannst du mir sagen wie viel "Vorwissen" du hast, bzw. wie viel man benötigt um solch(noch komplexeren) Themen behandeln zu können?