L'assemblatore x86 tramite .NET è possibile?

Question

Esiste un assemblatore x86 che posso chiamare tramite C #? Voglio essere in grado di passare le istruzioni x86 come stringa e recuperare un array di byte. Se uno non esiste, come posso crearne uno mio?

Per essere chiari - Non voglio chiamare il codice assembly da C # - Voglio solo essere in grado di assemblare il codice dalle istruzioni e ottenere il codice macchina in un array di byte. Inietterò questo codice (che verrà generato al volo) per iniettare in un altro processo del tutto.

Answer 1

Come parte di alcuni primi prototipi che ho fatto su un progetto personale, ho scritto un bel po 'di codice per fare qualcosa del genere. Non richiede stringhe: i codici operativi x86 sono metodi su una classe X86Writer. Non è affatto documentato e non ha alcuna copertura completa, ma se fosse di interesse, sarei disposto ad open-source con la nuova licenza BSD.

UPDATE: Ok, ho creato quel progetto - Managed.X86

Answer 2

Vedi questo progetto:

https://github.com/ZenLulz/MemorySharp

Questo progetto include l'assemblatore FASM, che viene scritto in assembly e compilato come oggetto Microsoft coff, racchiuso in un progetto C ++ e quindi nuovamente racchiuso in C #. Questo può fare esattamente quello che vuoi: data una stringa di assembly x86 / x64, questo produrrà i byte necessari.

Se hai bisogno del contrario, c'è una porta del disassemblatore Udis86, completamente portato su C #, qui:

https://github.com/spazzarama/SharpDisasm

Questo convertirà un array di byte nelle stringhe di istruzioni per x86 / x64

Answer 3

Dai un'occhiata a Phoenix di Microsoft Research.

Answer 4

Cosmos ha anche un supporto interessante per la generazione di codice x86:

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

Answer 5

Non direttamente da C # non puoi. Tuttavia, è possibile potenzialmente scrivere la propria classe wrapper che utilizza un assemblatore esterno per compilare il codice. Quindi, si potrebbe potenzialmente scrivere l'assembly in un file, utilizzare .NET Framework per creare un nuovo processo che esegue il programma assembler e quindi utilizzare System.IO per aprire il file generato dall'assemblatore per estrarre il byte ruscello.

Tuttavia, anche se fai tutto ciò, sarei molto sorpreso se non incappassi in problemi di sicurezza. L'iniezione di codice eseguibile in un processo completamente diverso sta diventando sempre meno possibile con ogni nuovo sistema operativo. Con Vista, credo che ti verrebbero sicuramente negati. E anche in XP, penso che otterresti un'eccezione di accesso negato quando provi a scrivere in memoria di un altro processo.

Ovviamente, ciò solleva la questione del perché tu debba farlo. Sicuramente ci deve essere un modo migliore :).

Answer 6

Dai un'occhiata a questo: CodeProject: utilizzo di codice non gestito e assembly in C # .

Answer 7

Penso che sarebbe meglio scrivere una dll nativa Win32. È quindi possibile scrivere una funzione nell'assemblatore che viene esportata dalla dll. È quindi possibile utilizzare C # per collegarsi dinamicamente alla dll.

Non è esattamente come passare una stringa e restituire un array di byte. Per fare ciò è necessario un componente assembler x86 o un wrapper attorno a masm.exe.

Answer 8

Non so se funziona così, ma potresti semplicemente eseguire un shellexecute di un compilatore esterno e quindi caricare l'oggetto generato nel tuo array di byte.