Ich krieg die Stub nicht hin -.-

[blackberry]

Erstmal sorry für die späte Antwort... habs nicht gleich entdeckt :O

Was ist ^= für ein Ausdruck?

VariableA ^= VariableB;
Ist lediglich eine Abkürzung für:
VariableA = VariableA ^ VariableB;
(also sowas ähnliches wie: +=, -=, /=, %=, &=, |=, ...)

Muss ich im endeffekt nur die einzelnen Bytes der Codesection mit ^= 0xDE (irgendwas) verändern wenn ich einen XOR erreichen will?

Du kannst auch die längere Form benutzen, oder wie DiZZy_D empfohlen hat eine andere Verschlüsselung benutzen (diese muss aber selbstverständlich eindeutig sein - also wieder entschlüsselbar sein).

Und bei dem decrypter Kapitel blick ich auch nicht ganz durch, was ist die ImageBase? meinste die Standardloadadresse 0x4000000?

Du meinst wohl 0x400000 (eine 0 weniger ).
Im Grunde ist das korrekt, jedoch werden uA. auch andere Adressen benutzt (kernel32.dll wäre ein Beispiel, das mir so spontan einfällt).
Demzufolge habe ich versucht das ganze universell aufzubauen und die Adresse für jedes einzelne Programm individuell einzufügen.

btw: Microsoft bezeichnet diese Adresse auch als ImageBase (siehe die beigelegte .DOCX-Datei). Das ist also keine Eigenerfindung von mir


mfG. BlackBerry

[EBFE]

Naja, bei C/C++ Compilern weiß man wegen der internen Optimierungen eher nie, was an Maschinencode herauskommt (Reihenfolge der Funktionen kann vertauscht werden, nicht erreichbarer Code wird wegoptimiert, es gibt keine globalen Labels usw).
Die Möglichkeiten für Low-Level Coding (Richtung Codeinjections) halte ich daher für relativ begrenzt und i.R sehr Compilerspezifisch (auch wenn mir einige C++ler das Gegenteil weiß machen wollten - aber außer den Sprüchen "du kannst halt kein C++!!!" und "in C++ ist es möglich, denn es kann alles, man muss es nur lernen!!!1" kam nichts )

Jedenfalls zum Thema:
was hast du für eine GCC Version? Sofern es halbwegs aktuell ist (meine ist z.B 4.3.0), funktieren folgende Codes:
Variablenzugriff von Inlnineasm aus, Intelsyntax:

    #include<iostream>
    using namespace std;
    int base=0x402000;
    void outbase()
    {
     cout<<"vor der manipulation: "<<hex<<base<<"\n";
      __asm volatile
     (
     ".intel_syntax noprefix\n"
     "mov ecx,%0\n"
     "add ecx,0x1337\n"
     "mov %0,ecx\n"
     ".att_syntax \n" :"=m"(base)
     );  
      cout<<"nach der manipulation: "<<hex<<base<<"\n";      
    }   
    
    int main()
    { 
      base=0xdeadbeaf;
      outbase();
      cin.get();
      return 0;
    }

%0 ist ein Argument,
"=m" steht für memory und (base) besagt, dass hier die variable Base verwendet werden soll.
Mehr muss man eigentlich für kleinere ASM inliner nicht wissen, aber du kannst gerne http://www.ibiblio.org/gferg/ldp/GCC...bly-HOWTO.html lesen

Selbsmodifizierender code mit g++:

    #include<iostream>
    using namespace std;
    
    int polyMe(void* adress)
    {
      if (adress!=0) goto label_end; //sonst wirds vom gcc auch bei -O0 wegoptimiert
      label_start:
      __asm volatile(
     ".intel_syntax noprefix\n"
     "mov ecx,[ebp-4]\n"
     "inc ecx\n"
     "mov [ebp-4],ecx\n"
     ".att_syntax \n"
     );
      label_end:
      memcpy(adress,&&label_start,(unsigned int)&&label_end-(unsigned int)&&label_start);
      
    }
    
    void polymorpher()
    {
      int i=0;
      
      polyMe(&&label);   //modifiziere den Code
      label:
        __asm 
     (
     ".intel_syntax noprefix\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     "nop\n"
     ".att_syntax \n" 
     ); 
     cout << "i="<<i<<"\n";  //na, wird hier 0 ausgegeben?
    }
    
    int main()
    {
      polymorpher();  
      cin.get();
      return 0;
    }

man sollte allerdings nach der Compilierung mit einem PE-Editor noch die ".text" Section auf "writeable,readable,executable" setzen (geht auch über Linkoptionen, ich habs allerdings nicht hinbekommen).