在内存中执行机器代码

Question

我正在尝试弄清楚如何执行存储在内存中的机器代码。

我有以下代码：

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[])
{
    FILE* f = fopen(argv[1], "rb");

    fseek(f, 0, SEEK_END);
    unsigned int len = ftell(f);
    fseek(f, 0, SEEK_SET);

    char* bin = (char*)malloc(len);
    fread(bin, 1, len, f);

    fclose(f);

    return ((int (*)(int, char *)) bin)(argc-1, argv[1]);
}

上面的代码在 GCC 中编译得很好，但是当我尝试像这样从命令行执行程序时：

./my_prog /bin/echo hello

程序段错误。我发现问题出在最后一行，因为注释掉它会停止段错误。

我认为我做的不太对，因为我仍在思考函数指针。

问题是演员阵容错误还是其他原因？

Answer 1

您需要一个具有写入执行权限的页面。如果您在 unix 下，请参阅 mmap(2) 和 mprotect(2)。您不应该使用 malloc 来执行此操作。

另外，请阅读其他人所说的，您只能使用加载程序运行原始机器代码。如果您尝试运行 ELF 标头，它可能会出现相同的段错误。

关于回复和downmods的内容：

1- OP 说他正在尝试运行机器代码，所以我对此进行了回复，而不是执行可执行文件。

2- 了解为什么不混合使用 malloc 和 mman 函数：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/mman.h>

int main()
{
    char *a=malloc(10);
    char *b=malloc(10);
    char *c=malloc(10);
    memset (a,'a',4095);
    memset (b,'b',4095);
    memset (c,'c',4095);
    puts (a);
    memset (c,0xc3,10); /* return */

    /* c is not alligned to page boundary so this is NOOP.
     Many implementations include a header to malloc'ed data so it's always NOOP. */
    mprotect(c,10,PROT_READ|PROT_EXEC);
    b[0]='H'; /* oops it is still writeable. If you provided an alligned
    address it would segfault */
    char *d=mmap(0,4096,PROT_READ|PROT_WRITE|PROT_EXEC,MAP_PRIVATE|MAP_ANON,-1,0);
    memset (d,0xc3,4096);
    ((void(*)(void))d)();
    ((void(*)(void))c)(); /* oops it isn't executable */
    return 0;
}

它在 Linux x86_64 上准确地显示了这种行为，其他丑陋的行为肯定会出现在其他实现上。

Answer 2

使用 malloc 效果很好。

好的，这是我的最终答案，请注意我使用了原始海报的代码。 我正在从磁盘加载此代码的编译版本到堆分配区域“bin”，就像原始代码一样（名称固定不使用 argv，值 0x674 来自；

objdump -F -D foo|grep -i hoho
08048674 <hohoho> (File Offset: 0x674):

这可以在运行时使用 BFD（二进制文件描述符库）或其他东西进行查找，您可以调用其他二进制文件（不仅仅是您自己），只要它们静态链接到同一组库即可。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>

unsigned char *charp;
unsigned char *bin;

void hohoho()
{
   printf("merry mas\n");
   fflush(stdout);
}

int main(int argc, char **argv)
{
   int what;

   charp = malloc(10101);
   memset(charp, 0xc3, 10101);
   mprotect(charp, 10101, PROT_EXEC | PROT_READ | PROT_WRITE);

   __asm__("leal charp, %eax");
   __asm__("call (%eax)" );

   printf("am I alive?\n");

   char *more = strdup("more heap operations");
   printf("%s\n", more);

   FILE* f = fopen("foo", "rb");

   fseek(f, 0, SEEK_END);
   unsigned int len = ftell(f);
   fseek(f, 0, SEEK_SET);

   bin = (char*)malloc(len);
   printf("read in %d\n", fread(bin, 1, len, f));
   printf("%p\n", bin);

   fclose(f);
   mprotect(&bin, 10101, PROT_EXEC | PROT_READ | PROT_WRITE);

   asm volatile ("movl %0, %%eax"::"g"(bin));
   __asm__("addl $0x674, %eax");
   __asm__("call %eax" );
   fflush(stdout);

   return 0;
}

正在运行...

co tmp # ./foo
am I alive?
more heap operations
read in 30180
0x804d910
merry mas

您可以使用UPX 来管理文件的加载/修改/执行。

附：抱歉之前断开的链接：|

Answer 3

在我看来，您正在加载 ELF 图像，然后试图直接跳转到 ELF 标头？ http://en.wikipedia.org/wiki/Executable_and_Linkable_Format

如果您尝试执行另一个二进制文件，为什么不为您使用的任何平台使用进程创建功能？

Answer 4

一个典型的可执行文件有：

• 标题
• 在main(int, char **)之前调用的入口代码

第一个意味着您通常不能期望文件的字节 0 是可执行的；相反，标题中的信息描述了如何将文件的其余部分加载到内存中以及从哪里开始执行它。

第二个意思是当你找到入口点时，你不能期望把它当作一个接受参数(int, char **)的C函数。也许，它可以用作不带参数的函数（因此在调用它之前不需要推送任何内容）。但是您确实需要填充环境，然后入口代码将使用该环境来构造传递给 main 的命令行字符串。

在给定的操作系统下手动执行此操作会进入我无法理解的深度；但我确信有一种更好的方式来做你想做的事情。您是否尝试将外部文件作为开关操作执行，或者加载外部二进制文件并将其功能视为程序的一部分？两者都由 Unix 中的 C 库提供。

Answer 5

更有可能是通过函数指针调用跳转到的代码导致了段错误，而不是调用本身。您发布的代码无法确定加载到 bin 中的代码是否有效。最好的办法是使用调试器，切换到汇编器视图，中断 return 语句并进入函数调用，以确定您希望运行的代码确实在运行，并且它是有效的.

还要注意，为了运行所有代码，需要位置独立并完全解析。

此外，如果您的处理器/操作系统启用数据执行预防，那么尝试可能注定要失败。无论如何，这充其量是不明智的，加载代码是操作系统的目的。

Answer 6

您可以 dlopen() 一个文件，查找符号“main”并使用 0、1、2 或 3 个参数（均为 char* 类型）通过强制转换为指向函数返回的整数来调用它-take-0,1,2,or3-char*

Answer 7

使用操作系统加载和执行程序。

在 unix 上，exec 调用可以做到这一点。

问题中的 sn-p 可以重写：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
    return execv(argv[1],argv+2);
}

Answer 8

您正在尝试做的事情类似于口译员所做的事情。除了解释器读取用 Python 等解释语言编写的程序，即时编译该代码，将可执行代码放入内存然后执行。

您可能还想了解更多关于即时编译的信息：

Just in time compilation
Java HotSpot JIT runtime

如果您有兴趣，可以使用 GNU lightning 和 libJIT 等库来生成 JIT 代码。但是，您必须做的不仅仅是从文件中读取并尝试执行代码。一个示例使用场景是：

1. 读取用脚本语言编写的程序（也许 您自己的）。
2. 解析源代码并将其编译为 被理解的中间语言 JIT 库。
3. 使用 JIT 库生成代码 对于这个中间 表示，适用于您的目标平台的 CPU。
4. 执行 JIT 生成的代码。

为了执行代码，您必须使用诸如使用 mmap() 将可执行代码映射到进程的地址空间、标记该页面可执行并跳转到该内存块等技术。它比这更复杂，但它是一个很好的开始，以便了解所有脚本语言（如 Python、Ruby 等）的解释器背后发生的事情。

“Linkers and Loaders”一书的online version 将为您提供有关目标文件格式、执行程序时幕后发生的事情、链接器和加载器的角色等方面的更多信息。这是一本很好的读物。

Answer 9

可执行文件包含的不仅仅是代码。标头、代码、数据、更多数据，这些东西被操作系统及其库分离并加载到不同的内存区域。您不能将程序文件加载到单个内存块中并期望跳转到它的第一个字节。

如果您尝试执行自己的任意代码，则需要查看动态库，因为这正是它们的用途。