L'assembleur x86 via .NET est-il possible?

Question

Existe-t-il un assembleur x86 que je puisse appeler via C #? Je veux pouvoir passer des instructions x86 sous forme de chaîne et obtenir un tableau d'octets. S'il n'en existe pas, comment puis-je créer le mien?

Pour être clair - je ne souhaite pas appeler le code d'assemblage à partir de C # - je souhaite simplement pouvoir assembler le code à partir d'instructions et obtenir le code machine dans un tableau d'octets. Je vais injecter ce code (qui sera généré à la volée) pour l’injecter dans un autre processus.

Answer 1

Dans le cadre de certains des premiers prototypes que j’ai réalisés sur un projet personnel, j’ai écrit pas mal de code pour faire quelque chose comme cela. Cela ne prend pas de chaînes - les opcodes x86 sont des méthodes d'une classe X86Writer. Ce n'est pas du tout documenté et sa couverture est loin d'être complète, mais si cela pouvait vous intéresser, je serais prêt à l'ouvrir en source sous la nouvelle licence BSD.

MISE À JOUR: Ok, j'ai créé ce projet - Géré.X86

.

Answer 2

Voir ce projet:

https://github.com/ZenLulz/MemorySharp

Ce projet encapsule l'assembleur FASM, écrit en assembleur et compilé en tant qu'objet Microsoft coff, encapsulé dans un projet C ++, puis à nouveau encapsulé en C #. Cela peut faire exactement ce que vous voulez: une chaîne d’assemblage x86 / x64 produira les octets nécessaires.

Si vous souhaitez l'inverse, il existe un port du désassembleur Udis86, entièrement porté en C #, ici:

https://github.com/spazzarama/SharpDisasm

Ceci convertira un tableau d'octets en chaînes d'instructions pour x86 / x64

Answer 3

Consultez Phoenix de Microsoft Research.

Answer 4

Cosmos dispose également d’un support intéressant pour la génération de code x86:

http://www.gocosmos.org/blog/20080428.en.aspx

Answer 5

Pas directement de C #, vous ne pouvez pas. Cependant, vous pourriez potentiellement écrire votre propre classe d'encapsuleur qui utilise un assembleur externe pour compiler le code. Donc, vous pourriez potentiellement écrire l'assembly dans un fichier, utiliser le .NET Framework pour lancer un nouveau processus exécutant le programme assembleur, puis utiliser System.IO pour ouvrir le fichier généré par l'assembleur afin d'extraire l'octet. courant.

Cependant, même si vous faites tout cela, je serais très surpris que vous ne rencontriez pas de problèmes de sécurité. L'injection de code exécutable dans un processus complètement différent devient de moins en moins possible avec chaque nouveau système d'exploitation. Avec Vista, je pense que vous seriez définitivement refusé. Et même dans XP, je pense que vous obtiendrez une exception d’accès refusé en essayant d’écrire dans la mémoire d’un autre processus.

Bien sûr, cela soulève la question de savoir pourquoi vous devez faire cela. Il doit sûrement y avoir un meilleur moyen:).

Answer 6

Jetez un coup d'œil à ceci: CodeProject: utilisation de code non managé et d'assemblage en C # .

Answer 7

Je pense que vous feriez mieux d'écrire une dll native Win32. Vous pouvez ensuite écrire une fonction dans l'assembleur qui est exportée à partir de la DLL. Vous pouvez ensuite utiliser C # pour créer un lien dynamique vers la dll.

Ce n’est pas tout à fait la même chose que de passer une chaîne et de retourner un tableau d’octets. Pour ce faire, vous aurez besoin d’un composant assembleur x86 ou d’un wrapper autour de masm.exe.

Answer 8

Je ne sais pas si c'est comme cela que cela fonctionne, mais vous pouvez simplement shellexecute un compilateur externe puis charger l'objet généré dans votre tableau d'octets.