Warum ist eine zwittrige EXE möglich?

[BrightAngel]

Hallo liebe DelphiPraxis!
Bin heute beim Surfen auf dieses Problemchen gestoßen.
Und weil ich etwas Zeit hatte und mich das irgendwie nicht in Ruhe gelassen hat, hab ich mich eben hingesetzt und mal selbst was ausprobiert:

Delphi-Quellcode:

program DllTest;

uses
  Windows,
  SysUtils,
  Dialogs,
  Classes;


procedure Testy; export;
begin
  ShowMessage('Success!');
end;

exports Testy;

type
  TProc=Procedure of Object;
var
  Lib:THandle;
  Proc:TProc;
begin
  Lib:=LoadLibrary(PChar(ParamStr(0)));
  if Lib=0 then
    ShowMessage('Nicht geladen!')
  else
  begin
    @Proc:=GetProcAddress(Lib,'Testy');
    Proc;
    FreeLibrary(Lib);
  end;
end.

So. Und jetzt meine Frage: Warum funktioniert denn das? Ist da jetzt irgendwo ein Hacken? Habe ich irgendwelche Einschränkungen (z.B. auf Win7 o.ä.)?

Anmerkungen:
Delphi-Version: 3
TestSystem: Windows XP

P.S. Es geht mir bei diesem Beitrag weniger um den praktischen Nutzen, vielmehr um die Problemstellung an sich. (Im verlinkten Artikel haben die schließlich ein Problem damit. Evtl. habe ich auch den Artikel nicht richtig verstanden?!?)

P.P.S. Bin mir nicht sicher, ob es evtl. nicht unters Offtopic gehört...

Gruß,
Brighty

[Assarbad]

Zitat von BrightAngel:

Hallo liebe DelphiPraxis!
Bin heute beim Surfen auf dieses Problemchen gestoßen.

Was willste denn erreichen?

[BrightAngel]

Achso. Nennen wir es Erweiterung des Grundlagenwissens...
Das wäre zumindest mein Ziel. Ziel des Programms soll sein, dass es sowohl als Dll als auch als Exe lauffähig ist. Eben Zwitter.
Mich würde interessieren, muss ich auf Einschränkungen gefasst sein?
Brighty

[Delphi-Laie]

Zitat von BrightAngel:

Ist da jetzt irgendwo ein Hacken?

Nein, denn der "Hacken" befindet sich am Fuße und nirgendwo sonst.

Exe und DLL zu vereinigen, hat mehr Nach- als Vorteile.

[BUG]

Zitat von BrightAngel:

So. Und jetzt meine Frage: Warum funktioniert denn das?

Ich glaube, dass kann funktionieren, weil DLLs und EXEn beide ein COFF-Format sind, dh. die innere Struktur ist gleich.

[Assarbad]

Zitat von BrightAngel:

Mich würde interessieren, muss ich auf Einschränkungen gefasst sein?

Absolut. Ich bin damals darauf ausgewichen (siehe Funktion putbinresto) die DLLs in die EXE zu packen und zu extrahieren. Die Methode stammt angeblich ursprünglich von OSR und wurde von einem der OSR-Leute an Mark Russinovich verklickert, dessen Programme ich wiederum als Vorbild nahm um die Funktionalität hinzubekommen.

Nicht verwechseln: eine EXE kann logischerweise auch Funktionen exportieren (BCB6 hatte das sehr ausführlich, so ausführlich daß die Größe tierisch beeinflußt wurde). Das macht aus der EXE aber noch keine DLL.

Was du machst ist nur, daß du dein Instanzenhandle benutzt um GetProcAddress anzuweisen eine Funktion in der Exporttabelle der PE-Datei im Speicher auszulesen. Kann man notfalls auch manuell machen. Die PE-Datei ist aber dennoch eine EXE und keine DLL.

Meines Wissens nach dürfte es nahezu unmöglich sein einen echten "Zwitter" hinzubekommen. Mit Schummeln geht vielleicht was, aber dazu müßte die EXE wohl mindestens noch ein weiteres Mal in den Prozeßraum gemappt werden. Einen Vorteil bietet das nicht. Abgesehen davon bezweifele ich, daß diese "DLL" dann auch in andere Prozesse geladen wird, was der eigentliche Sinn der Übung im Rahmen meines Tutorials war.

[BrightAngel]

Okay, ich denke, dann werde ich mal dein Tutorial durcharbeiten.
Das heißt im Klartext, dass ich sooft ich die EXE als DLL lade, ich sie auch immer neu in den Speicher lade?!?
Ja gut, dann geht der Sinn wirklich verloren.
Irgendwie sind mir die Strukturen der PE-Dateien und die Speicherverwaltung(Zugriffe, was wird wann wie geladen) noch nicht wirklich klar...
Falls jemand von Euch noch hilfreiche Links oder Literaturvorschläge zu diesem Groß-Thema PE-Dateien, DLL, Speicher, COFF, o.ä. hat (also über google hinaus...), bin offen für Alles.

Zudem würde mich interessieren, ob es bereits ein Tool gibt, welches eine EXE nicht DISASSEMBLIERT, sondern vielmehr als Bytefolgen darstellt und vlt. grafisch einfärbt, um zu zeigen, was PE-Header, Resource, Programmstruktur ist.

Das Sahnehäubchen wäre natürlich das Programm zu starten und Live den dem Programm zugeteilten Speicher visuell (in einem Memo o.ä.) mitverfolgen zu können.

Wenn es sowas noch nicht gibt, dann würde mich persönlich der Ansatz zu so etwas reizen (Also was muss ich mir alles in der Anwendung besorgen, dass so etwas möglich ist).

Verbleibe dankend,

Brighty

[Assarbad]

Zitat von BrightAngel:

Das heißt im Klartext, dass ich sooft ich die EXE als DLL lade, ich sie auch immer neu in den Speicher lade?!?

Zumindest wenn sie tatsächlich als DLL geladen werden soll, was eben ein wenig anders abläuft als das Laden einer EXE.

Zitat von BrightAngel:

Irgendwie sind mir die Strukturen der PE-Dateien und die Speicherverwaltung(Zugriffe, was wird wann wie geladen) noch nicht wirklich klar...

Luevelsmeyer PE format

Zitat von BrightAngel:

Zudem würde mich interessieren, ob es bereits ein Tool gibt, welches eine EXE nicht DISASSEMBLIERT, sondern vielmehr als Bytefolgen darstellt und vlt. grafisch einfärbt, um zu zeigen, was PE-Header, Resource, Programmstruktur ist.

PE Explorer und 010 Editor seien dir wärmstens empfohlen.

Zitat von BrightAngel:

Das Sahnehäubchen wäre natürlich das Programm zu starten und Live den dem Programm zugeteilten Speicher visuell (in einem Memo o.ä.) mitverfolgen zu können.

Siehe Sysinternals (bspw. vmmap). Da gibt es einiges dazu, speziell für die neueren Windowsversionen. Wenn dir reicht den Speicher (des geladenen Programms) zu editieren, nochmals 010 Editor.

[BrightAngel]

Vielen Dank!
Tja, es gibt eben nichts über die netten Leute der DP
Ich glaube, jetzt habe ich genug Lesestoff für langweilige Stunden.

Gute Nacht,

Brighty

[Aphton]

Nun eigentlich ist das gar nicht so zwittrig.

Das Einzige, was einen wundern könnte, wäre eben, dass man in einer Exe Funktionen exportieren kann. Dies kann man einfach so erklären - das Portable Executable (PE) Format erlaubt das Exportieren SOWIE was ja eig. klar ist IMPORTIEREN von Funktionen nun einmal für beide Executables (Exe & Dll).

Der Rest:
der LoadLibrary Aufruf >>lädt die Executable (sich selbst) NICHT<<. Er schaut zuerst, ob das zu ladende "Modul" in der Modulliste schon vorhanden ist (Siehe PEB). Falls ja, erhöht es nur den Referenzzähler und liefert das Handle (was eig. mehr die Adresse des gemappten Moduls ist) zurück; mehr nicht! Falls es nicht vorhanden wäre, was ja nicht der Fall ist, da es ausgeführt wird, lädt es die Executable und mappt diese in den Speicherraum des Prozesses.

Interessanter wäre es zu probieren, ne andere Executable per LoadLibrary zu laden!

Ala

Delphi-Quellcode:

program _1;

type
  TProc = procedure(P: Pointer); stdcall;

var
  p: TProc;

begin
  hMod := LoadLibrary( >program _2< );
  p := GetProcAddress( hMod, 'DoBlub' );
  p( NIL );
end.

// ======================================

program _2

procedure DoBlub(P: Pointer); stdcall;
begin
  // ...
  MessageBoxA( 0, 'Ich bin die exportierte Funktion', 'Hoi', 0 );
end;

exports
  DoBlub;

begin
  MessageBoxA( 0, 'Ich wurde geladen', 'Information', 0 );
end.

MfG