Execute computer instructions directly in binary [closed]

Answer 1

This SO question covers the topic perhaps

How to write self-modifying code in x86 assembly

Dont let people slow you down with the "why are you doing this questions"...

You have to know enough about the language or operating system or both and punch through or work within the protection system. Then it is a matter of putting the binary you want to execute (assuming you have done your work to make it positition independent and/or dependent on the addressing given/found/acquired/whatever) in memory and branch to it. In C you can declare a function pointer then assign the address to that function being the address of this binary and then call the function (if you have no other way to branch to an address, I usually prefer to write a few lines of asm and link them that perform the branch to any arbitrary address I pass the asm).

Answer 2

Generating and running code at run-time, within an application, is quite a well understood problem.

You will be able to find lots of information about generating code, and executing it on the fly, by searching the web for "just in time compiler" or "JIT compilation", "dynamic code generation", especially combined with a programming language name, like 'Java'.

Dynamic code generation is one of the hot research topics of the last fifteen years.

The Java run time system (called the Java Virtual Machine or JVM) uses dynamic compilation technology (called HotSpot) to get dramaticly improved (i.e. > 10x faster) performance.

Microsoft use Just-In-Time compilation for .NET languages like C#, but it will likely be harder to find much detailed information.

Ian Piumarta has been developing some very impressive dynamic compilation technology (e.g. Cola) at Viewpoints Research Institute, working with Alan Kay, the 'father' of SmallTalk (SmallTalk is the starting point for modern Windowing Systems and some types of object orientated programming languages). Some of this technology was used to speed up the Cairo rendering engine (used in web browsers, etc.) in a Google Summer of Code project.

Ian Piumarta's work might be the most flexible, and compact, and hence a good place to start. Be warned, Ian is incredibly clever, so be prepared to really think hard if you want to use it.

There are a few JIT's which generate assembler, which may be exactly what you need (but I have never used them):

• asmjit
• jitasm

Other technologies which might be worth a look include:

• StrongTalk
• Google V8 JavaScript Engine
• LLVM
• GNU libjit
• Intel Open Runtime Platform (ORP)

Of those, LLVM's JIT and GNU libjit are probably the best documented for use outside of their normal 'host' environment. LLVM is technology Apple support. LLVM is designed to be assembled from a set of libraries so that it can be used to build other systems. But it is aimed at very sophisticated, high-performance solutions, so there is likely quite a steep learning curve. GNU libjit looks to be smaller, and hopefully easier to understand because of that. I have only just discovered Intel's ORP.

HTH

Answer 3

What you want to do is a bit problematic and is liable to make a lot of people ask "Why are you doing that?"

Assuming you have an operating system WITHOUT memory protection (which is very rare), you can just point a function to array of bytes and call the function. Here's the gist of it:

unsigned char* code_to_execute = "\xB8\x13\x00\xCD\x10";
void (*runCode)();

runCode = code_to_execute;

runCode();

But, there are SO MANY THINGS to worry about when doing something like this. You need to know how your C compiler is setting up function call frames and respect that in your "binary code". It's impossible to create cross-platform code in this manner. Even making it run in multiple C compilers on a single platform would be tricky. And then there's memory protection. Most modern operating systems simply won't let you arbitrarily execute data as code. You need to explicitly mark the memory as executable and many operating systems won't let you do that without special permission. There is no cross-platform way to do this either.

Again, I want to stress that this is really not a good idea. You would be better off using inline assembly language. Or better yet, don't use assembly language at all. Maybe you could explain a little more about your project and why it's important to write "binary code" directly in your C program. It would help us craft an answer or recommendation that could help you considerably.

Answer 4

With the machine code in memory, cast its address to a function pointer. Of course you need to comply with the C calling convention.

On most desktop OSes, you'll need to change memory permissions to mark it executable, e.g. on Windows call VirtualProtect and on Linux mprotect.

Binary machine instructions are not cross-platform. You will need to generate different code for each processor architecture.

No driver is needed as long as the code only requires user-level permissions.