[C++] buffer file execution

[Verwijderd]

Binnen mijn programma heb ik een buffer met daarin een .exe file ingeladen. Nu is het mogenlijk om die buffer naar een file te schrijven en een execute commando te versturen. Maar het lijkt me dat je de buffer ook direct kan executen. Heeft iemand hier een suggestie hoe ik het aanpak?

[CoolGamer]

Een exe uitvoeren direct uit het geheugen is niet mogelijk. Dit heeft een paar redenen, waarvan dit er een is.

Een exe-image bevat een lijst van dll's waar hij van afhankelijk (Dependency Walker is een tooltje waarmee je die dll's kan zien) is. Die dll's moeten worden gelinkt voordat de code kan worden uitgevoerd.

[leuk_he]

http://www.codeguru.com/cpp/w-p/dll/article.php/c105

Is wel net anders als een executable uit een buffer draaien.

[RobIII]

TheCoolGamer schreef op zondag 28 maart 2010 @ 21:31:
Een exe uitvoeren direct uit het geheugen is niet mogelijk. Dit heeft een paar redenen, waarvan dit er een is.

Een exe-image bevat een lijst van dll's waar hij van afhankelijk (Dependency Walker is een tooltje waarmee je die dll's kan zien) is. Die dll's moeten worden gelinkt voordat de code kan worden uitgevoerd.

Een exe hoeft helemaal niet afhankelijk te zijn van dll's (hoewel dat vaak wel zo is). Maar wat jij verstaat onder "dll's moeten worden gelinkt voordat de code kan worden uitgevoerd" is mij een raadsel. Linken is een taak van de linker maar die is al lang en breed aan de beurt geweest (en op een "gewone" PC vaak niet eens aanwezig) toen de .exe gebakken werd. Een linker wordt niet gebruikt om een .exe te starten. Als een .exe "gewoon" wordt gestart zal deze gewoon in het geheugen geladen worden en zullen LoadLibrary etc. er voor zorgen dat dll's geladen worden wanneer nodig. Aleen zal het OS een aantal zaken regelen voordat een .exe aangeschopt wordt; die zaken mis je natuurlijk als je een buffer gaat executen.

De reden waarom dit niet zomaar (of "makkelijk") kan lijkt mij (maar ik ben maar een leek op dat gebied) omdat een buffer gemarkeerd zal zijn als Non-executable geheugen. Maar ik weet niet of een applicatie dan zijn/haar eigen geheugen dan alsnog kan markeren als executable (maar daar lijkt het wel op) en dan alsnog de .exe starten. Daarnaast mist je natuurlijk een zooi zaken die normaliter het OS voor je zal regelen (wat er allemaal nodig is om een PE-executable te starten); het is dus geen kwestie van de program-counter op 't begin van de buffer zetten (jmp ofzo) en je programma loopt.

[ Voor 14% gewijzigd door RobIII op 29-03-2010 02:48 ]

[Soultaker]

Het proces dat TheCoolGamer beschrijft bestaat wel hoor, en dat heet dynamic linking. (Vandaar de afkorting DLL voor dynamically linked library ) Dat proces is enigzins vergelijkbaar met statisch linken, in de zin dat eventuele relocations ook bij het opstarten uitgevoerd kunnen worden.

Ik vermoed dat je onder Windows nooit helemaal statisch kunt linken; je bent altijd afhankelijk van kernel32.dll en dergelijke voor OS functionaliteit. (Dat is anders onder b.v. POSIX systemen waar kernelfunctionaliteit in de C library zit die je meestal ook statisch kunt linken.) Zelfs zonder DLLs zit je met relocations in de executable, hoewel je die in sommige gevallen kunt negereren.

Je kunt (in principe) alles wat de Windows loader doet ook zelf uitvoeren: pages met de juiste permissies in het geheugen mappen, recursief DLLs laden (tenzij ze al in je main executable zitten), relocations uitvoeren voor DLLs en EXEs. Het probleem blijft echter dat je op die manier geen nieuw proces kunt uitvoeren; je kunt wel naar het application entry point jumpen, maar dan wordt je proces half opnieuw geïnitialiseerd. Ik weet niet of dat goed gaat...

Om een lang verhaal kort te maken doe je er waarschijnlijk het verstandigst aan om je EXE naar een tijdelijke locatie te schrijven en gewoon met CreateProcess een nieuw proces te starten. Relatief weinig werk, en een goed ondersteund scenario.