标签: mprotect

我想写一个信号处理程序来捕获SIGSEGV.我使用保护内存块进行读写

char *buffer;
char *p;
char a;
int pagesize = 4096;

mprotect(buffer,pagesize,PROT_NONE)

这可以保护从缓冲区开始的内存大小字节的内存,防止任何读取或写入.

其次,我尝试读取内存:

p = buffer;
a = *p 

这将生成一个SIGSEGV,我的处理程序将被调用.到现在为止还挺好.我的问题是,一旦调用处理程序,我想通过这样做来改变内存的访问写入

mprotect(buffer,pagesize,PROT_READ);

并继续正常运行我的代码.我不想退出该功能.在将来写入相同内存时,我想再次捕获信号并修改写入权限,然后记录该事件.

这是代码:

#include <signal.h>
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/mman.h>

#define handle_error(msg) \
    do { perror(msg); exit(EXIT_FAILURE); } while (0)

char *buffer;
int flag=0;

static void handler(int sig, siginfo_t *si, void *unused)
{
    printf("Got SIGSEGV at address: 0x%lx\n",(long) si->si_addr);
    printf("Implements the handler only\n");
    flag=1;
    //exit(EXIT_FAILURE);
}

int main(int argc, char *argv[])
{ …

在Linux(或Solaris)上,有一种比手动解析更好的方法/proc/self/maps来确定您是否可以读取,写入或执行存储在内存中一个或多个地址的任何内容？

例如,在Windows中你有VirtualQuery.

在Linux中,我可以mprotect更改这些值,但我无法读回它们.

此外,是否有任何方法可以知道这些权限何时发生变化(例如,当有人使用mmap我背后的文件时),而不是做一些非常具有侵略性的事情并ptrace在进程中的所有线程上使用并拦截任何syscall可能影响内存的尝试地图？

更新:

不幸的是,我在JIT中使用它,它几乎没有关于它正在执行的代码的信息,以获得常量的近似值.是的,我意识到我可以有一个可变数据的常量映射,比如Linux使用的vsyscall页面.我可以放心地假设任何未包含在初始解析中的内容都是可变且危险的,但我对这个选项并不完全满意.

现在我所做的是阅读/proc/self/maps并构建一个结构,我可以通过二进制搜索来获得给定地址的保护.每当我需要了解一些不在我的结构中的页面时,我会重新阅读/ proc/self/maps,假设它已经同时添加,或者我将要进行段错误.

它似乎解析文本以获取此信息,而不知道它何时更改是非常苛刻的.(/dev/inotify几乎不适用于任何事情/proc)

我正在尝试从Linux上的纯Python代码调用内联机器代码.为此,我将代码嵌入到字节文字中

code = b"\x55\x89\xe5\x5d\xc3"

然后调用mprotect()via ctypes以允许执行包含代码的页面.最后,我尝试ctypes用来调用代码.这是我的完整代码:

#!/usr/bin/python3

from ctypes import *

# Initialise ctypes prototype for mprotect().
# According to the manpage:
#     int mprotect(const void *addr, size_t len, int prot);
libc = CDLL("libc.so.6")
mprotect = libc.mprotect
mprotect.restype = c_int
mprotect.argtypes = [c_void_p, c_size_t, c_int]

# PROT_xxxx constants
# Output of gcc -E -dM -x c /usr/include/sys/mman.h | grep PROT_
#     #define PROT_NONE 0x0
#     #define PROT_READ 0x1
#     #define PROT_WRITE 0x2
#     #define PROT_EXEC …

我试图在这里略微调整规则和malloc缓冲区,然后将函数复制到缓冲区.

调用缓冲函数有效,但是当我试图调用其中的另一个函数时,该函数会抛出分段错误.

有什么想法？

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

int foo(int x)
{
    printf("%d\n", x);
}

int bar(int x)
{
}

int main()
{
    int foo_size = bar - foo;

    void* buf_ptr;

    buf_ptr = malloc(1024);

    memcpy(buf_ptr, foo, foo_size);

    mprotect((void*)(((int)buf_ptr) & ~(sysconf(_SC_PAGE_SIZE) - 1)),
             sysconf(_SC_PAGE_SIZE),
             PROT_READ|PROT_WRITE|PROT_EXEC);

    int (*ptr)(int) = buf_ptr;

    printf("%d\n", ptr(3));

    return 0;
}

此代码将抛出一个段错误,除非我将foo函数更改为:

int foo(int x)
{
    //Anything but calling another function.
    x = 4;
    return x;
}

注意:

代码成功复制foo到缓冲区,我知道我做了一些假设,但在我的平台上他们没问题.

我一直试图先使用mprotect反对阅读,然后写作.

这是我的代码

#include <sys/types.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    int pagesize = sysconf(_SC_PAGE_SIZE);
    int *a;
    if (posix_memalign((void**)&a, pagesize, sizeof(int)) != 0)
        perror("memalign");

    *a = 42;
    if (mprotect(a, pagesize, PROT_WRITE) == -1) /* Resp. PROT_READ */
        perror("mprotect");

    printf("a = %d\n", *a);
    *a = 24;
    printf("a = %d\n", *a);
    free (a);
    return 0;
}

在Linux下这里是结果:

以下是输出PROT_WRITE:

$ ./main 
a = 42
a = 24

并为 PROT_READ

$ ./main 
a = 42
Segmentation …

当两个进程共享打开的一段内存shm_open然后对其进行mmap-ed 时，在一个进程中对共享内存的一部分进行操作是否会影响另一个进程在同一部分上mprotect看到的权限？换句话说，如果一个进程将共享内存段的一部分设置为只读，那么它对于另一进程也将变为只读吗？