É x86 assembler via .NET possível?

Question

Existe tal coisa como um assembler x86 que eu possa chamar através de C #? Eu quero ser capaz de passar x86 instruções como uma string e obter uma volta matriz de bytes. Se não existir, como posso fazer o meu próprio?

Para ser claro - eu não quero Chamada assembly de código de C # - Eu só quero ser capaz de montar o código de instruções e obter o código de máquina em um array de bytes. Eu vou estar a injectar este código (que serão gerados em tempo real) para injetar em outro processo como um todo.

Answer 1

Como parte de alguns protótipos cedo eu fiz em um projeto pessoal, eu escrevi um pouco de código para fazer algo assim. Não é preciso cordas - opcodes x86 são métodos em uma classe X86Writer. A sua não é documentado em tudo, e não tem sequer uma cobertura completa, mas se seria do interesse, eu estaria disposto a fonte a abri-lo sob a licença New BSD.

UPDATE: Ok, eu criei esse projeto - Managed.X86

Answer 2

Veja este projeto:

https://github.com/ZenLulz/MemorySharp

Este projeto envolve o montador FASM, que é escrito em conjunto e como um compilado como objeto Microsoft coff, envolto por um projeto C ++, e em seguida, novamente envolto em C #. Isso pode fazer exatamente o que você quer:. Dada uma série de x86 / x64 montagem, este irá produzir os bytes necessário

Se você precisar o oposto, há uma porta do desmontador Udis86, totalmente portado para C #, aqui:

https://github.com/spazzarama/SharpDisasm

Isto irá converter um array de bytes para as cordas de instrução para x86 / x64

Answer 3

Dê uma olhada Phoenix da Microsoft Research.

Answer 4

Cosmos também tem algum apoio interessante para o código x86 geração:

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

Answer 5

Não diretamente do C # você não pode. No entanto, você poderia escrever sua própria classe wrapper que usa um montador externo ao código de compilação. Então, você poderia potencialmente escrever o conjunto para fora para um arquivo, use o .NET Framework para girar um novo processo que executa o programa assembler, e depois usar System.IO para abrir o arquivo gerado pelo montador para tirar o byte corrente.

No entanto, mesmo se você fizer tudo isso, eu seria muito surpreendido se não, em seguida, correr em questões de segurança. Injetar código executável em um processo completamente diferente está se tornando cada vez menos possível com cada novo OS. Com o Vista, eu acredito que você iria obter negado. E mesmo no XP, eu acho que você iria receber uma exceção acesso negado ao tentar gravar na memória de outro processo.

Claro, isso levanta a questão de por que você está precisando de fazer isso. Certamente não tem que haver uma maneira melhor:).

Answer 6

Dê uma olhada nisso: CodeProject: Usando código não gerenciado e montagem em C # .

Answer 7

Eu acho que você seria melhor fora escrevendo uma DLL Win32 nativo. Você pode então escrever uma função em assembler que é exportado a partir do dll. então você pode usar C # para ligação dinamicamente para a dll.

Este não é exatamente o mesmo que passar em uma string e retornar um array de bytes. Para fazer isso você precisaria de um componente x 86 assembler, ou um invólucro em torno MASM.EXE.

Answer 8

Eu não sei se esta é a forma como ele funciona, mas você poderia apenas shellexecute um compilador externo, em seguida, carregar o objeto gerado na sua matriz de bytes.