Is x86 assembler via .NET possible?

Question

Is there such a thing as an x86 assembler that I can call through C#? I want to be able to pass x86 instructions as a string and get a byte array back. If one doesn't exist, how can I make my own?

To be clear - I don't want to call assembly code from C# - I just want to be able to assemble code from instructions and get the machine code in a byte array. I'll be injecting this code (which will be generated on the fly) to inject into another process altogether.

Answer 1

As part of some early prototyping I did on a personal project, I wrote quite a bit of code to do something like this. It doesn't take strings -- x86 opcodes are methods on an X86Writer class. Its not documented at all, and has nowhere near complete coverage, but if it would be of interest, I would be willing to open-source it under the New BSD license.

UPDATE: Ok, I've created that project -- Managed.X86

Answer 2

See this project:

https://github.com/ZenLulz/MemorySharp

This project wraps the FASM assembler, which is written in assembly and as a compiled as Microsoft coff object, wrapped by a C++ project, and then again wrapped in C#. This can do exactly what you want: given a string of x86/x64 assembly, this will produce the bytes needed.

If you require the opposite, there is a port of the Udis86 disassembler, fully ported to C#, here:

https://github.com/spazzarama/SharpDisasm

This will convert an array of bytes into the instruction strings for x86/x64

Answer 3

Take a look at Phoenix from Microsoft Research.

Answer 4

Cosmos also has some interesting support for generating x86 code:

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

Answer 5

Not directly from C# you can't. However, you could potentially write your own wrapper class that uses an external assembler to compile code. So, you would potentially write the assembly out to a file, use the .NET Framework to spin up a new process that executes the assembler program, and then use System.IO to open up the generated file by the assembler to pull out the byte stream.

However, even if you do all that, I would be highly surprised if you don't then run into security issues. Injecting executable code into a completely different process is becoming less and less possible with each new OS. With Vista, I believe you would definitely get denied. And even in XP, I think you would get an access denied exception when trying to write into memory of another process.

Of course, that raises the question of why you are needing to do this. Surely there's got to be a better way :).

Answer 6

Take a look at this: CodeProject: Using unmanaged code and assembly in C#.

Answer 7

I think you would be best off writing a native Win32 dll. You can then write a function in assembler that is exported from the dll. You can then use C# to dynamically link to the dll.

This is not quite the same as passing in a string and returning a byte array. To do this you would need an x86 assembler component, or a wrapper around masm.exe.

Answer 8

i don't know if this is how it works but you could just shellexecute an external compiler then loading the object generated in your byte array.