Injection de code avec C #

Kevin,
il est possible. Vous pouvez créer une bibliothèque avec crochet de la fenêtre de proc en utilisant le C++. Tout ce que vous devez faire est d'injecter ce crochet dans une application en utilisant la norme WinAPI (SetWindowsHookEx etc.). À l'intérieur de ce crochet, vous pouvez appeler Système::domaine d'application::CurrentDomain->méthode load pour Charger votre assemblée en application cible du domaine d'application. Ensuite, vous pouvez appeler les méthodes définies dans votre assemblée à l'aide de la réflexion. Par exemple, Snoop utilise cette méthode.

EDIT: me semble que j'ai mal compris la question .... J'étais sous l'impression que la question était à propos de l'injection de code dans le processus actuel.

---

Je vais rejoindre la partie un peu tard, mais j'ai juste utilisé exactement de cela il y a quelques semaines:

Un délégué contient les champs privés IntPtr _methodPtr et IntPtr _methodPtrAuxqui représentent le corps de l'adresse de mémoire. En définissant le champ (par réflexion) à des valeurs spécifiques, on peut modifier la mémoire de l'adresse à laquelle le PROGRAMME sera orienté.


À l'aide de cette information, on peut effectuer les opérations suivantes:

1. Créer un tableau avec de l'assemblée octets, qui doivent être exécutées
2. Déplacer le délégué de la méthode pointeur vers les octets en question
3. Appeler le délégué de
4. Profit ???

(Bien sûr, vous pouvez modifier la _methodPtr-de la valeur à n'importe quelle adresse mémoire -- même dans l'espace du noyau, mais c'est peut-être les privilèges d'exécution).

---

J'ai un travail exemple de code ici, si vous voulez:

public static unsafe int? InjectAndRunX86ASM(this Func<int> del, byte[] asm)
{
    if (del != null)
        fixed (byte* ptr = &asm[0])
        {
            FieldInfo _methodPtr = typeof(Delegate).GetField("_methodPtr", BindingFlags.NonPublic | BindingFlags.Instance);
            FieldInfo _methodPtrAux = typeof(Delegate).GetField("_methodPtrAux", BindingFlags.NonPublic | BindingFlags.Instance);

            _methodPtr.SetValue(del, ptr);
            _methodPtrAux.SetValue(del, ptr);

            return del();
        }
    else
        return null;
}

Qui peuvent être utilisés comme suit:

Func<int> del = () => 0;
byte[] asm_bytes = new byte[] { 0xb8, 0x15, 0x03, 0x00, 0x00, 0xbb, 0x42, 0x00, 0x00, 0x00, 0x03, 0xc3 };
//mov eax, 315h
//mov ebx, 42h
//add eax, ebx
//ret

int res = del.InjectAndRunX86ASM(asm_bytes); //should be 789 + 66 = 855

Bien sûr, on pourrait aussi écrire la méthode suivante:

public static unsafe int RunX86ASM(byte[] asm)
{
    Func<int> del = () => 0; //create a delegate variable
    Array.Resize(ref asm, asm.Length + 1);

    //add a return instruction at the end to prevent any memory leaks
    asm[asm.Length - 1] = 0xC3;

    fixed (byte* ptr = &asm[0])
    {
        FieldInfo _methodPtr = typeof(Delegate).GetField("_methodPtr", BindingFlags.NonPublic | BindingFlags.Instance);
        FieldInfo _methodPtrAux = typeof(Delegate).GetField("_methodPtrAux", BindingFlags.NonPublic | BindingFlags.Instance);

        _methodPtr.SetValue(del, ptr);
        _methodPtrAux.SetValue(del, ptr);

        return del();
    }
}

La même chose pourrait être fait pour les méthodes existantes (pas de délégués) par l'intermédiaire de la réflexion:

//UNTESTED //

Action new_method_body = () => { };
MethodInfo nfo = typeof(MyType).GetMethod( ..... );
IntPtr ptr = nfo.MethodHandle.Value; //ptr is a pointer to the method in question

InjectX86ASM(new_method_body, new byte[] { ......., 0xC3 }); //assembly bytes to be injected

int target = new_method_body.Method.MethodHandle.Value.ToInt32();

byte[] redirector = new byte[] {
    0xE8,   //CALL INSTRUCTION + TARGET ADDRESS IN LITTLE ENDIAN
    (byte)(target & 0xff),
    (byte)((target >> 8) & 0xff),
    (byte)((target >> 16) & 0xff),
    (byte)((target >> 24) & 0xff),
    0xC3,   //RETURN INSTRUCTION
};
Marshal.Copy(redirector, 0, ptr, redirector.Length);

---

Utiliser n'importe quel code à vos propres risques. Les exemples de code doit être compilé avec le /dangereux-commutateur de compilateur.