Autom. Header und LIB aus einer DLL erstellen?



  • ganz so einfach ist das nicht 😉 aber
    mit der Dumpbin.exe erstellst du dir die Moduledefinitionsdatei.def
    der korrecte befehl dafür lautet als eingabe in cmd.exe

    dumpbin namederdll.dll /Exports /Out:NamederModuledefinitionsdatei.def

    anstelle von Exports kann natürlich auch Imports stehn.

    Ich gehe jetzt davon aus das sich die cmd.exe & die *.dll im verzeichniss der dumpbin.exe befindet.

    diese *.def datei must du jetzt bearbeiten, entweder liest du sie gleich aus dem Konsolenprog. aus dies setzt aber voraus das du dir ein eigenes programm schreibst was die dumbin- lib- link &o. undname.exe startet. oder aber du läst sie dir erstmal als textdatei mit der endung *.def erstellen. was dabei rauskommt sieht dann ungefähr so aus

    Dump of file NamederDll.dll

    File Type: DLL

    Section contains the following exports for NamederDll.dll

    0 characteristics
    4294DCD9 time date stamp Wed May 25 22:15:21 2005
    0.00 version
    1 ordinal base
    7497 number of functions
    7497 number of names

    ordinal hint RVA name

    1 A 00007063 ??0AAmmunition@@QAE@ABV0@@Z
    2 B 000087F6 ??0AAmmunition@@QAE@XZ
    3 C 00008562 ??0AAntiPortalActor@@IAE@XZ

    diese kauderwelsch ??0AAmmunition@@QAE@ABV0@@Z nennt sich ergänzter Name

    was nun für dich interessant ist zu wissen sind die zahlen die in der spalte ordinal stehen und das was unter name steht. Du must nun die *.def datei die dir dumpbin erstellt hat so umbauen das sie wie unten aufgeführt aussieht. das ist sehr wichtig ansonsten frist sie kein weiterführendes prog. wie Lib- o. Link.exe

    LIBRARY NameDerDll.DLL

    EXPORTS
    ??0AAmmunition@@QAE@ABV0@@Z @ 1
    ??0AAmmunition@@QAE@XZ @ 2
    ??0AAntiPortalActor@@IAE@XZ @ 3
    ...

    jeh nachdem was du oben entpackt hast Exports o. Imports Funktionen muss hier nätürlich auch wieder Exports o. Imports stehn.

    wenn du nun die *.def richtig erstellt hast öffnest du wieder die cmd.exe (achtung ich gehe wieder davon aus das die cmd.exe sich im verzeichniss der lib.exe befindet) und gibst folgendes ein

    lib /def:NamederModuledefinitionsdatei.def /out:NamederLib*.lib

    wenn du alles richtig gemacht hast, erstellt dir die Lib.exe die gewünschte *.lib und die *.exp. Diese kannst du nun in dein Project einbinden.

    Um dir nun daraus ne header zu basteln, wird das ganze noch ein wenig komplizierter, hierfür brauchst du nur die ergänzter Name
    ??0AAmmunition@@QAE@ABV0@@Z und die undname.exe
    den ergänzten namen übergibts du an undname.exe wie unten folgt. (achtung ich gehe wieder davon aus das die cmd.exe im verzeichniss der undname.exe liegt) öffne die cmd.exe und gib dort ein.

    undname -f ??0AAmmunition@@QAE@ABV0@@Z

    und sie gibt dir zurück

    public: __thiscall AAmmunition::AAmmunition(class AAmmunition const &);

    du must das dann noch weiterverarbeiten, denn so kann kein prog damit was anfangen, und zwar in der form

    public gibt dir den zugriffstatus der funktion zurück

    AAmmunition:: gibt dir den classennamen bzw. den headernamen an

    ::AAmmunition(class AAmmunition const &) gibt dir den funktionsnamen an

    so das wars wie man ne header erstellt nur dürfte klar sein das dies über die cmd.exe etwas schwierig zu lösen sein dürfte. und darin liegt nun die kunst. du wirst um dir ne header zu erstellen nicht darum kommen dir ein eigenes programm zu schreiben das dir alle ergänzten namen an die undname.exe übergibt und gleichzeitig das zurückgegeben wieder ausliest und weiterverarbeitet. 😃

    eine andere möglichkeit wäre, an die ergänzten namen zu kommen, das ganze über
    Portable Executable File Format zu erledigen, diesbezüglich bräuchtest du nicht den umweg über die dumbin.exe zu gehn sondern könntest direkt dir die *.def erstellen und alles an undname.exe übergeben.

    Anbei sei noch vermerkt
    es gibt nicht umsonst leute die 250$ und mehr für solche header zahlen. das eröffnet einem nämlich unteranderem unendliche möglichkeiten des cheatens 😉

    LowFly



  • LowFly! Danke für die ausführliche Beschreibung. 👍 😃 Aber so kompliziert habe ich es mir nicht vorgestellt. Gut, aber letztendlich sollte man sich fragen, warum einige OpenSource-Projekte nur eine DLL anbieten, nach dem Motto "Hier haste und kannste benutzen". Wundert mich halt nur...



  • Aber so kompliziert habe ich es mir nicht vorgestellt

    😕

    hmm,
    vor einem jahr hab ich noch zu denen gehört die steif & fest behauptet haben es wäre überhaupt nicht möglich. vor einigen monaten dachte ich noch das man studiert & den doctor title haben muss, um fähig zu sein, header aus ner dll zu erstellen.

    im enddefect ist es aber nur das ausführen von programmen in der richtigen reihenfolge & pissbillige Stringbearbeitung das wars.

    bzw. wenn man sich mal in Portable Executable File Format eingearbeitet hat geht das ganze noch viel einfacher & schneller & es bleibt zum schluß nur noch die Stringbearbeitung.

    klar man muss sich mal etwas intensiver mit dem thema auseinander setzen als es eben mal so aus dem ärmel zu schüteln, jedoch geht es & das sogar recht einfach 😃

    LowFly



  • Zum Header erstellen müsste man auch wissen welche Member die Klassen alle haben, wie gross die Instanzen sind etc.
    Und die Info steht in der DLL nicht drinnen.



  • Mir glaubt mal wieder niemand: Es geht nicht. Es mag für ganz spezielle spezialfälle gehen; abe rnicht in der Regel.



  • nicht alle funktionen haben member, die es zB nicht haben sind konstructor & destructor der klassen. wenn du mal das nachvollzogen hättest dann wüstest du das man alles bekommt was man braucht um sich header zu erstellen.
    da ich auch nicht die addresse der funktion im laufenden process austauchsen will und durch meine ersetzen will interesiert auch die größe der Instanze & ect. nicht 😉

    @ Jochen nein ich kann dir nicht glauben,
    da ich mir son tool geschrieben und komischerweise kann ich ungefähr 5% aller dll's die ich auf der platte hab NICHT entpacken 95% aller dll's kann ich entpacken. die ich nicht entpacken kann sind meistens dll's die mit mfc.. anfangen. Fackt ist das ich die dll's enpacke und diese header in verbindung mit den lib's in ein project einbinde & nutzen kann. ob du es mir nun glaubst oder nicht is mir egal. nur bitte behaupte es nicht das es nicht geht wenn du selbst nicht versucht hast es erfolgreich nachzufollziehn.

    so sieht zB das aus was ich von der undname bekomme. ich nenne es mal die vorläufige header

    public: class UFluidVolumeInterface & __thiscall AFluidVolume::GetInterface(void);
    public: float __thiscall USkeletalMeshInstance::GetKeyAlpha(int,struct MeshAnimChannel const &);
    private: float __thiscall USkeletalMeshInstance::GetKeyAlphaInternal(int,struct MeshAnimChannel const &);
    private: float __thiscall USkeletalMeshInstance::GetKeyAlphaOfHigherBlendsOnChannel(int,struct MeshAnimChannel const &);
    public: double __thiscall UTexture::GetLastUpdateTime(void);
    public: static void __cdecl USkinVertexBuffer::InternalConstructor(void *);
    public: static void __cdecl USound::InternalConstructor(void *);
    public: static void __cdecl USparkEmitter::InternalConstructor(void *);
    public: static void __cdecl USpeechManager::InternalConstructor(void *);
    public: static void __cdecl USpriteEmitter::InternalConstructor(void *);
    public: static void __cdecl UStaticMesh::InternalConstructor(void *);
    public: static void __cdecl UStaticMeshInstance::InternalConstructor(void *);
    public: static void __cdecl UStaticShadow::InternalConstructor(void *);
    public: static void __cdecl UTerrainMaterial::InternalConstructor(void *);
    public: static void __cdecl UTerrainPrimitive::InternalConstructor(void *);
    public: static void __cdecl UTerrainSector::InternalConstructor(void *);
    public: virtual int __thiscall UModifier::IsTransparent(void);
    public: virtual int __thiscall UShader::IsTransparent(void);
    public: virtual int __thiscall UTexture::IsTransparent(void);
    public: int __thiscall UTerrainSector::IsTriangleAll(int,int,int,int,int,unsigned char);
    public: virtual bool __thiscall APawn::IsVisionEnabled(void);
    public: int __thiscall AActor::IsVolumeBrush(void)const ;
    public: virtual int __thiscall ADoor::IsWedged(void);
    public: int __thiscall UViewport::IsWire(void);
    public: bool __thiscall UMassiveAdClient::IsZoneLoaded(void);
    public: virtual int __thiscall UEngine::Key(class UViewport *,enum EInputKey,unsigned short);
    public: unsigned char __thiscall UInput::KeyDown(int);
    public: virtual void __thiscall AEmitter::Kill(void);
    public: int __thiscall USkeletalMesh::LODFootprint(int,int);

    und das lass ich dann das tool daraus machen und erstell mir das als headerdatei auf der platte und binde dies in ein project.

    class AActor
    {

    public:
    AActor(class AActor const &);//
    AActor(void);//
    virtual ~AActor(void);//
    static void * __cdecl operator new(unsigned int,class UObject *,class FName,unsigned long);//
    static void * __cdecl operator new(unsigned int,enum EInternal *);//
    class & operator=(class AActor const &);//
    virtual int AddMyMarker(class AActor *);//
    virtual int AnimGetSpecialChannel(void);//
    virtual class * AssociatedLevelGeometry(void);//
    void AttachProjector(class AProjector *);//
    int AttachToBone(class AActor *,class FName);//
    void BeginTouch(class AActor *);//
    virtual void BoundProjectileVelocity(void);//
    virtual int CanCoverPlaneBillboard(void)const;//
    void execSetTweenMode(struct FFrame &,void * const);//
    void execSimulateSoundOnDedicatedServer(struct FFrame &,void * const);//
    ................
    virtual void initialiseHavokDataObject(void);//
    int moveSmooth(class FVector);//
    virtual void performPhysics(float);//
    virtual void physFalling(float,int);//
    void physProjectile(float,int);//
    void physRootMotion(float);//
    void physTrailer(float);//
    void physicsRotation(float);//
    virtual void processHitWall(class FVector,class AActor *);//
    virtual void processLanded(class FVector,class AActor *,float,int);//
    virtual void setPhysics(unsigned char,class AActor *,class FVector);//
    int setRelativeLocation(class FVector);//
    int setRelativeRotation(class FRotator);//
    virtual void stepDown(class FVector const &,struct FCheckResult &);//
    virtual void stepUp(class FVector,class FVector,class FVector,struct FCheckResult &);//

    protected:

    private:
    static class PrivateStaticClass;//

    /*Müll:

    */

    };



  • Dann musst Du mir noch eines erklären: Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss? Du hast hier keinerlei Member-Variablen drin... woher soll das "new" es dan erahnen?

    Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen, da diese *nur* Namen (oder Ordinal) exportieren und Du weder Aufrufkonventionen noch Parameter kennst.

    Es kann *nur* (ohne Zusatzinfos) gehen, wenn reine C++-Funktionen (also keine Klassen) exportiert werden, da hier in dem dekorierten Namen alles drin steht.



  • Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss.

    indem zb die Dll deren funktion ich manipulieren will schon längst in einem process geladen ist und man eine weitere dll die die manipulierten funktionen enthält dort injeziert und man nur dafür sorge tragen muss das die injezierte dll vom laufenden process anerkannt & ausgeführt wird.

    Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen

    naja dann frag ich mich wieso es bei mir geht 😉

    da diese *nur* Namen (oder Ordinal) exportieren

    falsch falsch falsch aber gleich sowas von falsch. diese ausssage zeigt mir das du anscheinend noch nie eine *.def via Dumpbin erstellt hast. denn dort bekommst du die ordinal zahl & den ergänzten name der Funktion & noch einiges mehr. um dir daraus ne *lib anzufertigen zu lassen must du allerdings die *.def umbauen die dir dumpbin erstellt. und die umgebaute *def übergibst du dann an die lib.exe. Ich hab alles beschrieben wies geht probier es aus, allerdings plauder ich nicht aus dem nähkästchen, mitdenken muss man & setz ich voraus. mehr sag ich nicht mehr dazu.

    der andere weg ist wie gesagt über Portable Executable File Format und dort lass ich mir die ergänzten namen durch eine schleife in einer array plazieren und ihr platz in der Array +1 entspricht auch gleichzeitig ihrer ordinal zahl.

    und Du weder Aufrufkonventionen noch Parameter kennst.

    wie gesagt das zeigt das du es noch nie probiert hast den der aufruf einer classe passiert genau so wie normal auch, wenn du dich im ausführenden process einklingst

    UTerrainSector::IsTriangleAll(int,int,int,int,int,unsigned char);

    UTerrainSector *pUTS = new UTerrainSector();
    pUTS->IsTriangleAll(0,1,2,3,4,_T("Test"));

    na & die Parameternamen auf die du hinauswills interesieren absolut nicht in einer header es reicht der parametertyp und den bekommst ja oder bitte was ist das IsTriangleAll(int,int,int,int,int,unsigned char) in der *.cpp geb ich dir recht dort brauchst du den Parameternamen, nur kann der gänzlich anderst heisen wie in dem orginal.

    kuck dir mal diese beispiele an,
    http://www.codeproject.com/debug/LibView.asp
    insbesondere dieses
    http://www.codeproject.com/dll/Execute_DLL_Function.asp

    ich sag auch nicht das man sich da mal schnell hinsetzt den code runtertippt und man header hat die sofort einsetztbar sind. bei den lib's egal was du sagst funzt es bei mir (man muss die *.def RICHTIG umbaun) und mit den headern rumspielen. dann klapp das auch (mit dem nachbarn 😉 )

    LowFly



  • Ein .lib File zusammenpfuschen ist eine Sache, eine vollständig verwendbare Header Datei eine gänzlich andere.
    Sag was du willst, aber du *kannst* aus einer DLL (mit oder ohne .def File) keine Headers erstellen mit denen man vernünftig arbeiten kann. Es geht nicht. Punkt.

    Ich verstehe genau was du da machst, ist mir alles klar, bloss weiss ich deswegen auch dass das was dabei rauskommt vielleicht reicht mit einer DLL ein wenig blöd rumzuspielen, aber nicht wenn man vernünftig damit arbeiten will.

    Im übrigen wird das was du tust dem OP nixe bringen, er will ja nicht eine "ersatz-dll" schreiben oder irgendwelche Funktionen patchen, sondern eine DLL von der er keine Headers hat selbst verwenden. Und das geht nicht.



  • es ist einfach zu trollig.

    Ein .lib File zusammenpfuschen ist eine Sache, eine vollständig verwendbare Header Datei eine gänzlich andere.
    Sag was du willst, aber du *kannst* aus einer DLL (mit oder ohne .def File) keine Headers erstellen mit denen man vernünftig arbeiten kann. Es geht nicht. Punkt.

    Ich verstehe genau was du da machst, ist mir alles klar, bloss weiss ich deswegen auch dass das was dabei rauskommt vielleicht reicht mit einer DLL ein wenig blöd rumzuspielen, aber nicht wenn man vernünftig damit arbeiten will

    verstehn und es selbst probieren sind zwei paar stiefel die sich gänzlich unterscheiden. und pfuschen tut hier keiner. die aussage zeigt das man(n) sich nicht ernsthaft damit beschäftig, zuwas und wofür gedacht ist die Dumpbin- lib- & link.exe zu nutzen.

    anhand eurer ausssagen sehe ich das ihr es bislang nie ernsthaft versucht habt dies zu bewerkstelligen und spätestens dann aufgehört habt als die ersten stollpersteine kamen o. euch das verständniss dafür fehlt. bzw. nur aus eurem wissen (was ich an dieser stelle keinem streitig machen will) vermutungen anstellt wie etwas zu sein hat. womit ihr beide aber sowas von daneben liegt.

    sondern eine DLL von der er keine Headers hat selbst verwenden. Und das geht nicht

    ich kann mich nur wiederholen es zeigt wieviel ahnung du hast, hättest du nur einmal in das beispiel gekuckt. Es zu verstehen versucht, hättest du dir diese aussage verkniffen da wird zum teil genau das gemacht was du behauptest das es nicht geht.

    aber nochmal langsam zum mitschreiben.

    1; erstelle dir eine *.lib von der dll deren funktion du nutzen willst & binde sie in dein project ein.

    2; wenn nötig erstelle dir eine header aus dem was dir undname.exe anhand der ergänzten namen zurückgibt & binde diese in dein Project.

    die header ist nur notwenig damit der compiler nicht motzt es würden irgendwo nichtaufgelöste externe symbole geben. zu nix anderem ist die header notwendig.

    3; hier gibt es zwei wege zum erfolg
    entweder injeziere die dll die funktionen manipulieren soll in den laufenden process & aktiviere sie
    oder
    lade die gewünschte dll beim start des programms via LoadLibary(...) in deinen Project und du erhälst zugriff auf alle funktionen die in der dll zu finden sind.

    nun kannst du natürlich weiter behaupten das es nicht geht.

    dann frag ich mich aber warum klappt es bei mir egal wie, ob ich nun etwas in einen process injeziere oder die gewünschte dll beim start in mein project lade.

    warscheinlich hab ich nen zauberpc



  • LowFly schrieb:

    Woher weiss der "new" Befehl wieviel Speicher er für die Klasse reservieren muss.

    indem zb die Dll deren funktion ich manipulieren will schon längst in einem process geladen ist und man eine weitere dll die die manipulierten funktionen enthält dort injeziert und man nur dafür sorge tragen muss das die injezierte dll vom laufenden process anerkannt & ausgeführt wird.

    Was hat denn das mit meiner Frage zu tun!? Und wer will hier was manipulieren? Weder ich noch der OP...

    LowFly schrieb:

    Auch kannst Du zu 95% aller Windows-DLLs keine LIB erzeugen

    naja dann frag ich mich wieso es bei mir geht 😉

    da diese *nur* Namen (oder Ordinal) exportieren

    falsch falsch falsch aber gleich sowas von falsch. diese ausssage zeigt mir das du anscheinend noch nie eine *.def via Dumpbin erstellt hast.

    Ich vermute eher mal, dass Du es noch nie mit Windows-DLLs probiert hast!
    Ein Dumpbin von kernel32.dll liefet z.B.:

    Dump of file C:\WINDOWS\SysWOW64\kernel32.dll
    
    File Type: DLL
    
      Section contains the following exports for KERNEL32.dll
    
        00000000 characteristics
        42435E2F time date stamp Fri Mar 25 01:41:19 2005
            0.00 version
               1 ordinal base
             978 number of functions
             978 number of names
    
        ordinal hint RVA      name
    
              1    0 000219F6 ActivateActCtx = _ActivateActCtx@8
              2    1 00023F79 AddAtomA = _AddAtomA@4
              3    2 00043A11 AddAtomW = _AddAtomW@4
              4    3 00081C71 AddConsoleAliasA = _AddConsoleAliasA@12
              5    4 00081C33 AddConsoleAliasW = _AddConsoleAliasW@12
              6    5 00068005 AddLocalAlternateComputerNameA = _AddLocalAlternateComputerNameA@8
              7    6 00067F1E AddLocalAlternateComputerNameW = _AddLocalAlternateComputerNameW@8
    

    So: Und jetzt erklär mir mal bitte, wie Du ohne Infos über die Funktionen eine h-Datei und eine LIB-Datei erzeugen willst!?
    Dir sind weder Parameter/Aufrufkonventionen noch sonstwas bekannt...

    Wie gesagt: Wenn Du die Header irgendwo hast, dann geht es... aber wenn Du *nur* die DLL hast (wie es beim OP geheisen hat), dann ist es IMHO zu 99% unmöglich.



  • ich hab auch nicht behauptet das es einfach ist windows dll zu enpacken
    im falle der kernel stimmt die hab ich noch nicht entpackt warum auch den für die meisten windows *.dll braucht man keine *.libs zu erzeugen den die *.lib's finden sich in ätlichen SDK's 😉 wenn nötig auch die header dazu.

    im fall der kernel zB hat man keine ergänzten namen sondern bekommt gleich den funktionsnamen allerdings OHNE Parameter angabe das ist richtig. aber willst du mir vieleicht erzählen das man für die kernel irgendwelche aufrufkonventionen braucht, ich hoffe nicht.

    und für die Parameter der windows- kernelfunktionen reicht erstens ein rechtsklick auf parametertyp bzw ein blick in die MSDNActivateActCtx

    und für die die windows dll's die keine *.lib's und header in SDK's bereitstellen klappt das beschrieben verfahren. und wenns eben nicht klappt fallen die unter die besagten 5% 😉

    LowFly



  • Man sieht: Es geht nur in Spezialfällen ohne Zusatzinfos. Und das ist, wenn C++-Funktion exportiert werden. In allen anderen Fällen (Klassen, C-Funktionen) geht es nicht.
    Wenn Du mir dies wiederlegen kannst, kannst Du es ja posten. Ich kann Dir auch eine DLL schicken zu der Du mir die h-Datei und die LIB-Datei machen kannst 😉



  • LowFly, du kommst dir wohl sehr schlau vor. Es wurde nach einem Tool gefragt welches aus einer DLL nen .lib file und .h File machen kann. Die Antwort ist ein Tool kann das nicht. Ende & aus.

    Das man mit Hilfe von Tools und ewig rumraten und pfriemeln vielleicht in ein paar sehr sehr einfachen Fällen Erfolg hat - ja, ok, wen interessierts, das geht nämlich sogar ganz ohne Tool. (Ok, .lib File schreib ich nicht mit Hand, aber .def File, und mit dem mach ich dann mein .lib File). Bloss ist das ein gänzlich anderes Thema.

    Wie willst du bitte bei einer C++ DLL sizeof(X) rausbekommen? Wie willst du zu den Klassen kommen die gänzlich inline implementiert sind? Zu den Templates? Wie willst du die Funktionen/Methoden aufrufen deren Parameterliste eine komplett inline implementierte Klasse enthält?

    Du redest hier von spezialfällen, und ignorierst fest das wir anderen das nicht tun.

    BTW: das "MessageBoxA" Beispiel ist wohl komplett lächerlich. Davon abgehesen: das dort vorgestellte Tool erfordert erst recht wieder das man die Parameterliste mit Hand eingigt. Und nun sag mir wie du die Parameterliste von MessageBoxA erraten willst wenn du sie eben nicht weisst, und nicht nachgucken kannst? Hm? Blubb.



  • @jochen
    mal angenommen ich würde darauf eingehn und mir ne dll von dir schicken lassen
    schickste doch eh eine die unter die 5% fällt 😉

    @ hustbaer
    ich habs fast vermutet aber nein ich bin nicht mächtig schlau & auch nicht allwissend oder was dir sonst noch für neckerein einfallen. wenn du diese stufe der komunikation benutzen must bist du geistig noch ärmer als ich vermutet hab.

    All die fragen die du stellst "Wie willst du bitte bei einer C++ DLL sizeof.." hab ich beantwortet,

    wie jetzt schon so oft gesagt du/ihr versucht garnicht es ansatzweise zu verstehn. Es ist immer am leichtesten zu schrein das geht nicht, weil man sich dann nicht die mühe machen muss es zu verstehn oder herauszufinden.

    mir egal ob ihr es nun glauben wollt oder nicht ich bin kein mesias & auch kein prediger der versucht euch zu bekeheren. Ich für meinen teil weis das es geht, ich habs schwarz auf weis vor mir liegen, die leute die es nachvollziehen wollen haben genug material und links durch den thread an der hand um dies erfolgreich nachvollziehen & sich dann selbst ein urteil bilden zu können ob es nun möglich ist oder nicht.

    Da nun leider der thread langsam aus dem ruder läuft (hustbaer 😉 ) und weiterführende diskusionen mit sicherheit im streit enden. gibt der vernünftigere bekanntlich nach. 😉

    Somit,
    ja ihr hab recht, (es ist unmöglich eine header & lib aus einer dll zu machen, es ist kompletter schwachsinn was ich da erzählt hab) & ich meine ruh.

    LowFly



  • LowFly schrieb:

    und für die Parameter der windows- kernelfunktionen reicht erstens ein rechtsklick auf parametertyp bzw ein blick in die MSDNActivateActCtx

    Ja, mit Zusatzinformationen kannst du alles erreichen. Aber was machst du, wenn du NUR diese DLL vorliegen hast (oder eine ähnlich aufgebaute DLL, die irgendein fremder Programmierer (z.B. Jochen) dir in die Hand gedrückt hat)?

    Die ergänzten Namen enthalten nur in Spezialfällen genug Informationen, um daraus den Funktions-Prototyp rekonstruieren zu können. Und afaik gibt es in der DLL auch keine Informationen darüber, welche Member die verwendeten Klassen enthalten (nochmal in verständlichem Deutsch: Woher willst du diese Informationen nehmen?) Und daß es bei dir bislang immer geklappt hat, ist vermutlich auf eine glückliche Auswahl der Test-DLLs zurückzuführen.

    PS: Und die Tatsache, daß auch deine Methode in "5% aller Fälle" versagt, bestätig doch auch die Aussage "es geht nicht generell" 😃



  • Und die Tatsache, daß auch deine Methode in "5% aller Fälle" versagt, bestätig doch auch die Aussage "es geht nicht generell"

    hab ich nie behauptet

    wie schon gesagt ihr habt recht ich meine ruh 😉



  • Doch, hast du:

    LowFly schrieb:

    da ich mir son tool geschrieben und komischerweise kann ich ungefähr 5% aller dll's die ich auf der platte hab NICHT entpacken 95% aller dll's kann ich entpacken.

    (Daß du von diesen 5% zufälligereweise ein paar Zusatzinformationen hast, tut jetzt nichts zur Sache - versuch' doch mal, aus der kernel32.dll einen Header zu erstellen, OHNE die MSDN zu verwenden).



  • ich weis nicht was es soll das du dich zum schluß wo ich gesagt hab ihr hab recht & ich meine ruh noch einklinken, auf alten kamellen rumreiten & versuchen must nen hacken zu finden an dem du dich aufhängen kannst.

    aber nun gut, anscheinend must du das rad jedes mal neu erfinden. ich zähle zu den 95% der dll's die ich enpacken kann nicht die dazu von denen es in SDK's libs & header gibt. warum auch die muß man nicht enpacken.

    aber wie gesagt man kann immer einen hacken finden an dem man sich aufhängt.

    such mal weiter findest bestimmt noch ein paar. 😉



  • Lol.
    LowFly, du hast nich nur keine Ahnung, du bist auch noch ein Mädchen.


Anmelden zum Antworten