Executing assembler code with python

I want to execute assembly code inside a python script. Is that possible?

In C programming would be like this

static inline getesp(){
        __asm__("mov %esp, %eax");
}

But how to do that with Python? Is it possible?

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.

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.

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()

Sorry for necroposting but I think that you can write your own DLL using asm and call it's functions from within Python.

In theory, you could:

1. Write a simple function in C that calls the assembly
2. Use Cython or Pyrex to call that function from Python

I have to admit that I haven't used either Pyrex or Cython, but they might be able to do what you need without having to go to the trouble of writing a full blown C extension.

Python does not support this type of low level hardware interaction.

It is highly possible I made a small assembler in python, some of the libraries I used may have supported Ctypes, but I used pure Python, Most languages do actually interface at a low level, We are just using the HLL Langage features and not paying appropriate attention to how the code is being processed, I have also written a small POC image editing app in visual basic that used ASM x86 Code I am not actually sure on how to edit this into what I was trying to say. except maybe functions that would read the asm code and work from within the script itself. I do believe my thoughts were pointed out to be wrong. ASM code can be executed through the use of scripted functions that read that area of the code and compile them. almost as if it were a built in on the fly assembler. I try to help not so great a speaker though (or writter in this case as it may be) this page here maybe able to explain better on what I am trying to say http://code.activestate.com/recipes/579037-how-to-execute-x86-64-bit-assembly-code-directly-f/