Executing assembler code with python

One way you could do this would be to write a (C) extension for Python. You can take a look at this documentation for full details of how to do that.

Another way of developing C-based Python extensions would be to interface directly with an external library using the ctypes module.

In any case, you'd need some C code compiled into either a library or an extension and a way to call it from Python. Clearly for what you want to achieve this is probably not optimal but actually its not that much work to expose a few functions.

You can embed assembly directly inside your Python program:

• https://github.com/Maratyszcza/PeachPy
• https://github.com//pycca/pycca
• http://codeflow.org/entries/2009/jul/31/pyasm-python-x86-assembler/
• https://github.com/AmihaiN/pyAsm

These work by compiling the assembly and loading it into executable memory at runtime. The first three projects implement x86-64 or x86 assemblers in Python, whereas the last calls out to an external compiler.

As a specific example, here is how to call a function which will take an int and return it incremented by one.

To obtain memory with the executable flag set, mmap module is used.

To call the function, ctypes module is used.

To put the machine code into memory, there is hardcoded byte string of x86-64 machine code.

The code will print 43.

In practice, I'd write the code in C shared object library and use inline assembly in C. I'd then use cffi to load and run the library. The advantage of this example is that it is self-contained and only needs the standard Python library.

import ctypes
import mmap

buf = mmap.mmap(-1, mmap.PAGESIZE, prot=mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC)

ftype = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int)
fpointer = ctypes.c_void_p.from_buffer(buf)

f = ftype(ctypes.addressof(fpointer))

buf.write(
    b'\x8b\xc7'  # mov eax, edi
    b'\x83\xc0\x01'  # add eax, 1
    b'\xc3'  # ret
)

r = f(42)
print(r)

del fpointer
buf.close()