DLL Injection von Memory in anderen Prozess

[snapseep]

Mit Hilfe von BTMemoryModule (Link) lade ich eine DLL in den Speicher meines Programms.

Delphi-Quellcode:

unit Main;

{ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
  * Memory DLL loading code Demo Application                                *
  *- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*
  * Copyright (c) 2005-2010 by Martin Offenwanger / [e-mail]       *
  * http://www.dsplayer.de                                                  *
  *- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*
  * Mozilla Public License Version 1.1:                                     *
  *- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*
  * The contents of this file are used with permission, subject to the      *
  * Mozilla Public License Version 1.1 (the "License"); you may             *
  * not use this file except in compliance with the License. You may        *
  * obtain a copy of the License at                                         *
  * http://www.mozilla.org/MPL/MPL-1.1.html                                 *
  *                                                                         +
  * Software distributed under the License is distributed on an             *
  * "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or          *
  * implied. See the License for the specific language governing            *
  * rights and limitations under the License.                               *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * }
{
  @author(Martin Offenwanger: [e-mail])
  @created(Mar 20, 2005)
  @lastmod(Jul 16, 2010)
  @supported operationg systems(Windows 98 up to Windows 7)
  @tested Delphi compilers(Delphi 7, Delphi 2007 , Delphi 2010)
}

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, BTMemoryModule, StdCtrls, xpman;

type
  TTestCallstdA = procedure(f_Text: PAnsiChar); stdcall;
  TTestCallstdW = procedure(f_Text: PWideChar); stdcall;
  TTestCallcdelA = procedure(f_Text: PAnsiChar); cdecl;
  TTestCallcdelW = procedure(f_Text: PWideChar); cdecl;

  TForm1 = class(TForm)
    BtnMemCall: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure BtnMemCallClick(Sender: TObject);
  private
    m_TestCallstdA: TTestCallstdA;
    m_TestCallstdW: TTestCallstdW;
    m_TestCallcdelA: TTestCallcdelA;
    m_TestCallcdelW: TTestCallcdelW;
    mp_DllData: Pointer;
    m_DllDataSize: Integer;
    mp_MemoryModule: PBTMemoryModule;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;


implementation

{$R *.dfm}
{$R DemoDLL.RES}

procedure TForm1.FormCreate(Sender: TObject);
var
  ResStream: TResourceStream;
begin
  Position := poScreenCenter;
  ResStream := TResourceStream.Create(HInstance, 'DemoDLL', RT_RCDATA);
  ResStream.Position := 0;
  m_DllDataSize := ResStream.Size;
  mp_DllData := GetMemory(m_DllDataSize);
  ResStream.Read(mp_DllData^, m_DllDataSize);
  ResStream.Free;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FreeMemory(mp_DllData);
end;

procedure TForm1.BtnMemCallClick(Sender: TObject);
begin
  mp_MemoryModule := BTMemoryLoadLibary(mp_DllData, m_DllDataSize);
  try
    if mp_MemoryModule = nil then
      Abort;
    @m_TestCallstdA := BTMemoryGetProcAddress(mp_MemoryModule, 'TestCallstdA');
    if @m_TestCallstdA = nil then
      Abort;
    @m_TestCallstdW := BTMemoryGetProcAddress(mp_MemoryModule, 'TestCallstdW');
    if @m_TestCallstdW = nil then
      Abort;
    @m_TestCallcdelA := BTMemoryGetProcAddress(mp_MemoryModule, 'TestCallcdelA');
    if @m_TestCallcdelA = nil then
      Abort;
    @m_TestCallcdelW := BTMemoryGetProcAddress(mp_MemoryModule, 'TestCallcdelW');
    if @m_TestCallcdelW = nil then
      Abort;
    m_TestCallstdA('This is a Dll Memory call loaded from resource!');
    m_TestCallstdW('This is a Dll Memory call loaded from resource!');
    m_TestCallcdelA('This is a Dll Memory call loaded from resource!');
    m_TestCallcdelW('This is a Dll Memory call loaded from resource!');
  except
    Showmessage('An error occoured while loading the dll: ' +
      BTMemoryGetLastError);
  end;
  if mp_MemoryModule <> nil then
    BTMemoryFreeLibrary(mp_MemoryModule);
end;

end.

Jedoch möchte ich die DLL nicht in meinen Speicher laden und verwenden, sondern in einen anderen Prozesss (Notepad).


Leider fehlt mir die Erfahrung bzw. das Know-How, wie dies zu bewerkstelligen ist.

Über jegliche Hilfe wäre ich sehr dankbar.

[Neutral General]

Es ist vllt etwas umständlich (bin mir grad im ersten Moment nicht sicher obs auch einfacher geht):

Du kannst eine DLL erstellen die deine Memory-DLL als Ressource enthält. Diese DLL injizierst du dann "ganz normal" über DLL Injection in Notepad.
Deine ZwischenDLL lädt nun ganz normal wie in deinem Beispielcode unten die Memory-DLL.

Weiß aber nicht ob das für dich so in Ordnung ist.
Du könntest die DLL aus der Resource auch stattdessen als normale Datei abspeichern und diese injizieren.
Wofür soll der ganze Ressourcen-Kram denn gut sein?

[snapseep]

Hallo Michael,

so ähnlich habe ich es momentan auch realisiert.

Erst wird eine Dll in den Zielprozess injectet, die dann wiederrum eine weitere Dll läd ohne sie auf der Festplatte zu speichern.

Optimalerweise wäre es jedoch folgendermaßen:
Programm (exe) läd eine Dll direkt in einen Zielprozess ohne Zwischen-DLL und ohne Zwischen-Speichern auf Festplatte.

[Zacherl]

Zitat von snapseep:

Optimalerweise wäre es jedoch folgendermaßen:
Programm (exe) läd eine Dll direkt in einen Zielprozess ohne Zwischen-DLL und ohne Zwischen-Speichern auf Festplatte.

Warum darf die Dll nicht auf der Festplatte zwischengespeichert werden?

Du kannst die Dll auch direkt aus deiner Resource in den Zielprozess mappen, aber das ist nicht wirklich trivial und erfordert viel Wissen über das PE Format und die Funktionsweise des Windows Loaders. Hatte vor Ewigkeiten mal eine "Manual Mapping" Library geschrieben, die Dlls direkt aus einer Resource laden konnte (nur im eigenen Prozess). Es ist aber auch möglich direkt in einen Zielprozess zu mappen.

Mapping der Sections mit NtCreateSection, NtMapViewOfSection, (evtl. VirtualProtect, wenn du die Section Protections korrekt setzen willst), danach musst du Relocations parsen und anwenden, die IAT auflösen (indem du einen kleinen Loader im Zielprozess ausführst z.b. mit CreateRemoteThread), TLS ausführen, DllMain ausführen, ggfls. noch Exception Tables laden (64 Bit) und noch viele weitere kleine Dinge.

Alles in allem den Aufwand nicht wert denke ich

[brechi]

Genau das macht doch BTMemoryModule,
d.h. man kann das dort doch erweitern (VirtualAllocEx anstatt VirtualAlloc etc.)

uallHook von mir hat eine Funktion InjectMe, da kann die eigene Exe-Datei direkt in einen Zielprozess geladen werden

https://github.com/BenBE/AntiInducA/...n/uallHook.pas

Naja schön ist das zwar nicht, würde das mittlerweilse anders machen aber vill hilfts dir.

[snapseep]

Hallo Zacherl und brechi!

Vielen Dank für euren Input.

Leider bin ich nun etwas verwirrt, da sich eure Antworten dermaßen unterscheiden in Sachen Aufwand und Angehensweise.

Die Vorgehensweise von dir Zacherl ist, wie du ja selbst schreibst "den Aufwand nicht wert", da ich mich wahrscheinlich einige Wochen mit dem Thema beschäftigen müsste um einen Einblick in die Thematik zu bekommen.

Sollte ich jedoch wirklich nur VirtualAlloc durch VirtualAllocEx austauschen müssen, wie von brechi beschrieben, werde ich dies wohl tun.

Danke auch nochmal an brechi für den Link zur uallCollection. Jedoch möchte ich ja eine DLL in den Zielprozess befördern und keine Exe.

Edit:



Wäre diese Vorgehensweise bei VirtualAllocEx korrekt:

1. Mit OpenProcess (PROCESS_VM_OPERATION) Handle im Zielprozess erlangen
2. VirtualAllocEx mit Zielhandle ausführen
3. Durch CreateRemoteThread injectete DLL "starten"

?