专栏首页LINUX阅码场解决Linux内核问题实用技巧之-dev/mem的新玩法

解决Linux内核问题实用技巧之-dev/mem的新玩法

/dev/mem里有什么

简单来讲,/dev/mem是系统物理内存的映像文件,这里的 “物理内存” 需要进一步解释。

物理内存是指我们插在内存槽上的内存条吗?当然是,但物理内存不单单指内存条。

物理内存严格来讲应该是指 物理地址空间 ,内存条只是映射到这个地址空间的一部分,其余的还有各种PCI设备,IO端口等。我们可以从/proc/iomem中看到这个映射:

[root@localhost mem]# cat /proc/iomem00000000-00000fff : reserved00001000-0009fbff : System RAM0009fc00-0009ffff : reserved000c0000-000c7fff : Video ROM000e2000-000ef3ff : Adapter ROM000f0000-000fffff : reserved  000f0000-000fffff : System ROM00100000-31ffffff : System RAM  01000000-01649aba : Kernel code  01649abb-01a74b7f : Kernel data  01c13000-01f30fff : Kernel bss32000000-33ffffff : RAM buffer3fff0000-3fffffff : ACPI Tablese0000000-e0ffffff : 0000:00:02.0  e0000000-e0ffffff : vesafbf0000000-f001ffff : 0000:00:03.0  f0000000-f001ffff : e1000......

其中,只有RAM才是指内存条。关于物理地址空间的详细情况,请参考E820相关的资料。

明白了物理内存的构成之后,我们来看看/dev/mem里有什么。事实上,它就是一个活着的Linux系统实时映像,所有的进程taskstruct结构体,sock结构体,skbuff结构体,进程数据等等都在里面的某个位置:

如果能定位它们在/dev/mem里的位置,我们就能得到系统中这些数据结构的实时值,所谓的调试工具所做的也不过如此。其实我们在调试内核转储文件的时候,vmcore也是一个物理内存映像,和/dev/mem不同的是,它是一具尸体。

无论是活体,还是尸体,均五脏俱全,分析它们的手段是一致。和静态分析vmcore不同的是,/dev/mem是一个动态的内存映像,有时候借助它可以做一些正经的事情。

下面通过几个小例子,介绍和展示/dev/mem的一些玩法。

映射系统保留内存

Linux内核的内存管理子系统非常强大,同时也非常复杂。我们受其恩惠的同时,偶尔也会被其折磨得痛苦不堪。

动辄OOM杀掉关键进程,动辄刷脏页导致CPU飙高...

为了避免任意进程任意使用内存,我们引入资源隔离的机制,比如cgroup,但这样事情会变得更加复杂。

能不能保留一部分内存,不受内核的内存管理控制呢?就好像很多数据库不经文件系统直接访问裸盘一样,内核有没有什么机制让我们不经内存管理系统而直接使用内存呢?

当然有!加上mem启动参数即可实现。这里介绍一种关于保留内存的最简单配置,设置mem启动参数如下:

mem=800M

假设我们的系统总共有1G的内存(指内存条的总容量),那么上述启动参数将会保留 1G-800M 的内存不被系统内存管理系统所管理。因此我的保留内存就是200M:

[root@localhost mem]# cat /proc/cmdlineBOOT_IMAGE=/vmlinuz-3.10.0-327.x86_64 root=/dev/mapper/centos-root ro crashkernel=auto rd.lvm.lv=centos/root rd.lvm.lv=centos/swap rhgb quiet LANG=en_US.UTF-8 vga=793 mem=800M[root@localhost mem]# cat /proc/iomem |grep RAM00001000-0009fbff : System RAM00100000-31ffffff : System RAM32000000-33ffffff : RAM buffer[root@localhost mem]#

我们关注一下保留内存的物理地址0x34000000(0x33ffffff+1) 。此时,如果用free命令或者/proc/meminfo,会看到物理内存少了200M,我们保留的200M内存不会记入内核的任何统计。

换句话说, 内核不再管这200M内存,你的程序可以任意涂抹,任意泄漏,任意溢出,任意覆盖它们,也不会对系统产生任何影响。

所谓的系统保留的含义就是 “内核不会为该段内存创建一一映射页表(x86_64位系统可以映射64T的物理内存)”

我们经常使用的crash工具读取内存使用的就是一一映射。

在x86_64平台,每一个非保留的物理内存页面可能会有多个映射,而保留物理内存页面不会有下面第一种映射:

  1. 一一映射到0xffff880000000000开始虚拟地址。【保留页面缺失】
  2. 映射到用户态使用它的进程地址空间。
  3. 临时映射到内核态空间临时touch。
  4. .....

我们试着用crash工具来读取一下保留内存:

crash> rd -p 0x34000000rd: read error: physical address: 34000000  type: "64-bit PHYSADDR"crash>

显然,内核并未对保留页面建立一一映射页表项,所以读取是失败的。

我们知道 /dev/mem 文件是整个物理内存映像,所以用户态进程可以使用mmap系统调用来重建用户态地址空间的页表。方法如下:

#include <stdio.h>#include <unistd.h>#include <sys/mman.h>#include <fcntl.h>
int main(int argc, char **argv){    int fd;    unsigned long *addr;
    fd = open("/dev/mem", O_RDWR);
    // 0x34000000 即/dev/mem的偏移,也就是保留内存在物理地址空间的偏移,我的例子就是0x34000000    addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x34000000);    // ... 随意使用保留内存    close(fd);    munmap(addr, 4096);
    return 1;}

是不是很简单呢?

此时,在我们实施mmap的进程中便可以访问保留内存了:

crash> vtop 0x7f3751c3a000VIRTUAL     PHYSICAL7f3751c3a000  34000000
   PML: 6e477f0 => 2dbf7067   PUD: 2dbf76e8 => c524067   PMD: c524470 => 2c313067   PTE: 2c3131d0 => 8000000034000277  PAGE: 34000000
      PTE         PHYSICAL  FLAGS8000000034000277  34000000  (PRESENT|RW|USER|PCD|ACCESSED|DIRTY|NX)
      VMA           START       END     FLAGS FILEffff88000b7e7af8 7f3751c3a000 7f3751c3b000 50444fb /dev/mem

这个例子中,我们展示了/dev/mem如何用来访问保留内存。接下来我们继续用简单的小例子演示/dev/mem的其它玩法。

进程间交换页面

有这么一种需求:

  • 我们不希望进程A和进程B共享任何页面,这意味着它们不能同时操作同一份数据。
  • 偶尔我们希望进程A和进程B交换数据,却又不想用低效的传统进程间通信机制。

是不是觉得两难了呢?其实我们可以让两个进程的页面进行交换来达到目的。为了让页表项交换尽可能简单,我们依然使用保留内存,解除内核内存管理对操作的约束。

下面给出示例程序代码,先看进程A,master.c:

// gcc master.c -o master#include <stdio.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>#include <fcntl.h>
int main(int argc, char **argv){    int fd;    unsigned long *addr;
    fd = open("/dev/mem", O_RDWR);
    // 映射保留地址的一个页面P1    addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x34000000);    // 写页面P1的内容    *addr = 0x1122334455667788;
    printf("address at: %p   content is: 0x%lx\n", addr, addr[0]);    // 等待交换    getchar();    printf("address at: %p   content is: 0x%lx\n", addr, addr[0]);
    close(fd);    munmap(addr, 4096);
    return 1;}

接下来看希望与之进程页面交换的进程B,slave.c:

// gcc slave.c -o slave#include <stdio.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>#include <fcntl.h>
int main(int argc, char **argv){    int fd;    unsigned long *addr;
    fd = open("/dev/mem", O_RDWR);    // 映射保留地址的页面P2    addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x34004000);    // 写页面P2的内容    *addr = 0x8877665544332211;
    printf("address at: %p   content is: 0x%lx\n", addr, addr[0]);    // 等待交换    getchar();    printf("address at: %p   content is: 0x%lx\n", addr, addr[0]);
    close(fd);    munmap(addr, 4096);
    return 1;}

页面交换的原理非常简单,互换两个进程的两个虚拟地址的页表项即可。实现这件事意味着需要编写内核模块,但是由于我们只是演示,所以我们可以用crash工具轻松达到目标。

小帖士:如若希望crash工具可写/dev/mem,参见上一篇文章,用systemtap HOOK住devmemisallowed,使其恒返回1.

操作演示过程如下:

这个实例非常适用于设计微内核的进程间通信机制。配合以cache一致性协议,会非常高效。

安全篡改程序的内存

所谓的安全篡改程序的内存指的是用一种可靠的方法改程序内存,而不是通过手工hack页表的方式,简单起见,这次我们借助crash工具来完成。

首先我们看一个程序:

#include <stdio.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>
int main(int argc, char **argv){    unsigned char *addr;
    // 匿名映射一段内存    addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_SHARED, -1, 0);    // 为其拷贝数据    strcpy(addr, "浙江温州皮鞋湿");
    // 只是演示,所以我直接将地址打印出,真实场景需要自己hack出来    printf("address at: %p   content is: %s\n", addr, addr);    getchar();    printf("address at: %p   content is: %s\n", addr, addr);
    munmap(addr, 4096);
    return 1;}

运行它:

[root@localhost mem]# ./a.outaddress at: 0x7fa5990f2000   content is: 浙江温州皮鞋湿

我们想把 “浙江温州皮鞋湿” 这块内存内容改成 “下雨进水不会胖”,如何做呢?

方法很多,这里介绍crash /dev/mem的方法。首先我们找到addr对应的物理页面:

crash> set 1819    PID: 1819    ...crash> vtop 0x7f360c756000VIRTUAL     PHYSICAL7f360c756000  6d3d000
   PML: 2ddec7f0 => 150b6067   PUD: 150b66c0 => 1506b067   PMD: 1506b318 => 2c591067   PTE: 2c591ab0 => 8000000006d3d067  PAGE: 6d3d000
      PTE         PHYSICAL  FLAGS8000000006d3d067   6d3d000  (PRESENT|RW|USER|ACCESSED|DIRTY|NX)
      VMA           START       END     FLAGS FILEffff880015070000 7f360c756000 7f360c757000     fb dev/zero
      PAGE       PHYSICAL      MAPPING       INDEX CNT FLAGSffffea00001b4f40  6d3d000 ffff88002fe24710        0  2 1fffff00080038 uptodate,dirty,lru,swapbacked

我们得到了addr对应的物理地址是 0x6d3d000。

现在让我们写另一个程序,映射/dev/mem,然后修改偏移0x6d3d000处的内存即可:

// gcc hacker.c -o hacker#include <stdio.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>#include <fcntl.h>
int main(int argc, char **argv){    int fd;    unsigned char *addr;    unsigned long off;
    off = strtol(argv[1], NULL, 16);
    fd = open("/dev/mem", O_RDWR);
    addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, off);
    strcpy(addr, "下雨进水不会胖");    close(fd);
    munmap(addr, 4096);
    return 1;}

直接执行:

[root@localhost mem]# ./hacker 0x6d3d000

然后在a.out的运行终端敲入回车:

[root@localhost mem]# ./a.outaddress at: 0x7fa5990f2000   content is: 浙江温州皮鞋湿
address at: 0x7fa5990f2000   content is: 下雨进水不会胖[root@localhost mem]#

这个例子比较简单,显得无趣,OK,下面这个例子稍微有点意思。

通过写/dev/mem修改任意进程的名字

本例我们将放弃crash工具的使用,仅仅依靠hack /dev/mem来修改一个进程的名字。

这对于一些互联网产品的运营是有意义的。\ 特别是在一些托管机器上,为了防止数据泄漏,一般是不允许使用类似crash & gdb工具debug的,当然了,systemtap接口有限制,所以安全,内核模块一般也会禁止。但是有systemtap和/dev/mem就够了!

我们来做这样一个实验:

  • 修改已经在运行的进程的名字。

看看如何完成。先来看一个很简单的程序:

// gcc pixie.c -o pixie#include <stdio.h>
int main(int argc, char **argv){    getchar();}

运行它:

[root@localhost mem]# gcc pixie.c -o pixie[root@localhost mem]# ./pixie

现在我们想办法把进程的名字pixie改成skinshoe。

没有crash工具,没有gdb工具,只有一个可以读写的/dev/mem(假设我们已经HOOK了devmemsiallowed函数)。怎么做到呢?

我们知道,内核所有的数据结构都在/dev/mem中可以找到,因此,我们要找到pixie进程的task_struct结构体的位置,然后更改它的comm字段。问题是/dev/mem是物理地址空间,而操作系统操作的任何内存都基于虚拟地址,如何建立两者之间的关联是关键的。

我们注意到三点事实:

  • x86_64可以直接映射64T的物理内存,足以一一映射当前常见的任意物理内存。
  • Linux内核对所有物理内存建立一一映射。物理地址和虚拟地址之间固定偏移。
  • Linux内核的数据结构是彼此关联的网状结构,因此便可以顺藤摸瓜。

这意味着,只要我们提供一个Linux内核空间数据结构的虚拟地址,我们就能求出它的物理地址,然后顺藤摸瓜就能找到我们的pixie进程的task_struct结构体。

在Linux系统中,很多地方都可以找到内核数据结构的地址:

  • /proc/kallsyms文件。
  • /boot/System.map文件。
  • lsof的结果

最简单的方法,那便是通过在/proc/kallsyms或者System.map里找到init_task的地址,比如在我的环境下:

ffffffff81951440 D init_task

然后在 arch/x86/kernel/vmlinux.lds.S 里找到inittask到物理内存的映射规则,从inittask开始遍历系统的task链表,找到我们的目标pixie进程,改之。

但这种方法无法让人体验在/dev/mem里顺藤摸瓜的快乐的感觉,所以我们最后再来说它,现在我们尝试用一种稍微麻烦的方法来实现修改特定进程名字目标。

我的方法是创建一个tcpdump进程,却不抓任何包,它只是一个提供蛛丝马迹的幌子,我们就从它入手:

[root@localhost ~]# tcpdump -i lo -ntcpdump: verbose output suppressed, use -v or -vv for full protocol decodelistening on lo, link-type EN10MB (Ethernet), capture size 262144 bytes

之所以创建tcpdump进程,是因为tcpdump会创建一个packet套接字,而该套接字的虚拟地址会被展示在procfs中:

[root@localhost mem]# cat /proc/net/packetsk       RefCnt Type Proto  Iface R Rmem   User   Inodeffff88002c201000 3      3    0003   1     1 0      0      22050[root@localhost mem]#

OK,就是这个 0xffff88002c201000 作为我们的突破口。我们从它开始顺藤摸瓜!

我们知道,0xffff88002c201000 是一个struct sock对象的内存地址,我们熟悉sock结构体的详情,知道它的偏移224字节处是一个等待队列waitqueuehead_t对象。

这一点需要你对Linux内核结构体非常熟悉,如果不熟悉,就找到对应源码取手算一下偏移。【 或者借用一下crash工具的struct X.y -o计算偏移也可

而waitqueueheadt对象内部又被一个waitqueuet对象链入,该waitqueueheadt对象被tcpdump始发的pollwqueues结构体所管理,最终它的pollingtask字段指向tcpdump本身,而我们需要的正是tcpdump的task_struct对象本身,因为整个系统的所有task均被链接在一个list中。

整体的关联图示如下:

有了这个结构,我们就可以写代码了。

由于x86_64可以直接一一映射64T的内存,而我只有区区1G的内存,可以保证的是,虚拟地址减去一一映射的基地址(在我的系统它就是 0xffff880000000000)就是物理地址了。

假设packet套接字的地址是0xffff88002c201000,我们就能确认其物理地址在0x2c201000处,编写代码,映射/dev/mem,从0x2c201000开始找起:

#include <stdio.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>#include <fcntl.h>
int main(int argc, char **argv){    int fd;    unsigned long off;    unsigned long *pltmp;    unsigned char *addr, *base;
    fd = open("/dev/mem", O_RDWR);    off = strtol(argv[1], NULL, 16);
    addr = mmap(NULL, 0xffffffff, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);    base = addr;    addr += off;    // 定位sock    addr += 224;    pltmp = addr;
    addr = *pltmp;    addr -= 0xffff880000000000;    addr += (unsigned long)base;    addr += 8;    pltmp  = addr;
    addr = *pltmp;    addr -= 0xffff880000000000;    addr += (unsigned long)base;    addr -= 24;    addr += 8;    pltmp  = addr;
    addr = *pltmp;    addr -= 0xffff880000000000;    addr += (unsigned long)base;    addr += 24;    pltmp  = addr;
    // 找到了tcpdump的task结构体。    addr = *pltmp;    addr -= 0xffff880000000000;    addr += (unsigned long)base;    addr += 1288;    addr += 8;    pltmp = addr;
    // 这里开始应该是一个循环,遍历整个tasks链表,然而本例中我们可以保证pixie进程在tcpdump之前,所以就简化了逻辑,直接找它前面的task即可。    addr = *pltmp;    addr -= 0xffff880000000000;    addr += (unsigned long)base;    addr += 8;    pltmp = addr;
    addr = *pltmp;    addr -= 0xffff880000000000;    addr += (unsigned long)base;    addr -= 1288;    pltmp = addr;
    addr += 1872;    pltmp = addr;    printf("program name is: %s\n", addr);
    strcpy(addr, "skinshoe");
    close(fd);    munmap(addr, 0xffffffff);
    return 1;}

我们用 0xffff88002c201000 的物理地址作为偏移执行程序:

[root@localhost mem]# ./modname 2c201000program name is: pixie

然后,你会发现pixie这个程序的名字被改了:

[root@localhost mem]# cat /proc/3442/commskinshoe

可见,pixie变成skinshoe了。

修改进程名字只是一个例子,既然我们都已经拿到task_struct结构体了,我们就可以学着crash工具的样子去做点类似debug的事情了。下面我们继续。

解析/dev/mem遍历系统所有进程

提到遍历进程,一般能想到的有两个思路:

  1. 遍历procfs文件系统的进程pid目录,解析目录的内容。
  2. 编写模块,调用 for_each_process 宏遍历进程。

还有第一种方法。

当我们知道/dev/mem是整个系统内存映像时,我们就知道整个系统的所有数据结构都在里面可以被找到,当然也包括进程链表。我们现在的任务显然就是在 /dev/mem 里找到它。

在上一小节里,我们已经可以通过一个 tcpdump 制造的packet 套接字找到了我们任意的名叫pixie的进程,并将其名字改成 skinshoe。我们回顾一下通过packet套接字寻找pixie进程的过程:

  1. 通过sock结构体找到固定偏移处的waitqueueheadt字段skwq。
  2. 通过waitqueueheadt找到waitqueuet字段listhead。
  3. 通过listhead对象找到waitqueue_t字段。
  4. 通过waitqueuet对象找到poll_wqueues字段private。
  5. 通过pollwqueues对象找到taskt字段polling_task。

我们可以从polling_task的固定偏移1288字节处定位到一个list,遍历该list就是遍历整个系统进程链表!

我们既然能找到特定的名字为pixie的进程,自然也就能遍历整个链表。

本小节内容我们接着上一个小节继续写,只不过是把 “定位特定进程” 改成了 “遍历整个链表” 。而后者更加简单。

整个过程中,我们要做的只是确定以下两件事情:

  1. 内存一一映射的起始地址是多少? 在我的 3.10.0-327.el7.x86_64 实验系统中该值是 0xffff880000000000. c//arch/x86/include/asm/page_64_types.h:32: #define __PAGE_OFFSET _AC(0xffff880000000000, UL)
  2. 系统初启时init_task映射到哪个虚拟地址? 在我的 3.10.0-327.el7.x86_64 实验系统中该值是 0xffffffff81951440 bash ffffffff81951440 D init_task

我们看下x86_64内存映射整体的模样:

基础知识就说到这里,现在仅仅靠手撸一个/dev/mem文件,到底如何能遍历整个系统的进程?talk is cheap, show you the code:

#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>#include <fcntl.h>
#define    DIRECT_MAPPING_START    0xffff880000000000
// from ./kernel/vmlinux.lds.S// .data : AT(ADDR(.data) - LOAD_OFFSET)// #define LOAD_OFFSET __START_KERNEL_map// #define __START_KERNEL_map 0xffffffff80000000#define    START_MAPPING_START     0xffffffff80000000
int main(int argc, char **argv){    int i = 0;    unsigned int pid0 = 0xffffffff, *pitmp;    int fd;    unsigned long off, map_off = DIRECT_MAPPING_START;    unsigned long *pltmp, *pltmp2;    unsigned char *addr, *taddr, *base, *pctmp;
    fd = open("/dev/mem", O_RDWR);    off = strtoll(argv[1], NULL, 16) - DIRECT_MAPPING_START & 0x0000ffffffffffff;
    addr = mmap(NULL, 0xffffffff, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);    base = addr;    addr += off;    // 定位sock#define    SK_WQ_OFFSET    224 // sock.sk_wq    addr += SK_WQ_OFFSET;    pltmp = (unsigned long *)addr;
    addr = (unsigned char *)*pltmp;    addr -= DIRECT_MAPPING_START;    addr += (unsigned long)base;#define LIST_PREV_OFFSET    8   // list_head.prev    addr += LIST_PREV_OFFSET;    pltmp  = (unsigned long *)addr;
    addr = (unsigned char *)*pltmp;    addr -= DIRECT_MAPPING_START;    addr += (unsigned long)base;#define    WAITQ_TASK_OFFSET   24  // __wait_queue.task_list    addr -= WAITQ_TASK_OFFSET;#define    PRIVATE_OFFSET  8   // __wait_queue.private    addr += PRIVATE_OFFSET;    pltmp  = (unsigned long *)addr;
    addr = (unsigned char *)*pltmp;    addr -= DIRECT_MAPPING_START;    addr += (unsigned long)base;#define POLLING_TASK_OFFSET    24  // poll_wqueues.polling_task    addr += POLLING_TASK_OFFSET;    pltmp  = (unsigned long *)addr;
    addr = (unsigned char *)*pltmp;    addr -= DIRECT_MAPPING_START;    addr += (unsigned long)base;#define PID_OFFSET    1404    // task_struct.pid#define COMM_OFFSET    1872    // task_struct.comm    pitmp = (unsigned int *)(addr + PID_OFFSET);    pid0 = *pitmp;    printf("pid0 is:%d\n", *pitmp);#define    TASKS_OFFSET    1288    // task_struct.tasks    addr += TASKS_OFFSET;    addr += LIST_PREV_OFFSET;    pltmp = (unsigned long *)addr;
    while (1) {
        addr = (unsigned char *)*pltmp; // list        addr -= map_off;        addr += (unsigned long)base;        addr += LIST_PREV_OFFSET ;// prev        pltmp = (unsigned long *)addr;
        taddr = (unsigned char *)*pltmp; // list_entry        if (*pitmp == 1) {            taddr -= START_MAPPING_START;        } else {            taddr -= DIRECT_MAPPING_START;        }        taddr += (unsigned long)base;        taddr -= TASKS_OFFSET;
        pitmp = (unsigned int *)(taddr + PID_OFFSET);        if (*pitmp == pid0) {            break;        }        if (*pitmp == 0) {            map_off = START_MAPPING_START;        } else {            map_off = DIRECT_MAPPING_START;        }        printf("%d\t", *pitmp);
        pctmp = (taddr + COMM_OFFSET);        printf("[%s] \n", pctmp);    }
    close(fd);    munmap(addr, 0xffffffff);
    return 1;}

以上代码不太难理解,唯一要注意的就是 init_task 的定位。

inittask,也就是Linux系统0号进程,它非常特殊,它并不是fork产生的,它伴随着着系统的初启,也就是说,上电的那一刻,x86进入保护模式的那一刻,就处在0号进程的上下文,然而此时,内存映射规则还没有建立。inittask该在何处?

inittask映射在 *“手写的一个位置”* ,即 *arch/x86/kernel/vmlinux.lds.S*文件里规定的位置。当你通过某种手段找到 inittask 的虚拟地址的时候,减去 LOAD_OFFSET 就是其物理地址:

#define LOAD_OFFSET __START_KERNEL_map#define __START_KERNEL_map 0xffffffff80000000...    /* Data */    .data : AT(ADDR(.data) - LOAD_OFFSET) {        /* Start of data section */        _sdata = .;
        /* init_task */        INIT_TASK_DATA(THREAD_SIZE)

所以我们单独定义了:

#define    START_MAPPING_START     0xffffffff80000000

这就是定位init_task的依据。

言归正传,将上面的C代码编译,演示一下遍历进程。如下:

[root@localhost mem]# cat /proc/net/packetsk       RefCnt Type Proto  Iface R Rmem   User   Inodeffff88002dbb8000 3      3    0003   2     1 0      0      42249[root@localhost mem]# ./listtasks 0x88002dbb8000pid0 is:60205784    [kworker/1:1]5762    [ssh]5760    [kworker/3:2H]5754    [ssh]... // 篇幅所限,省略1    [systemd]0    [swapper/0]6159    [listtasks]... // 篇幅所限,省略[root@localhost mem]#

OK,成功遍历了所有进程!美中不足的是遍历过程未加锁,可能会有同步问题,但无论如何最严重的也只是listtasks进程SEGV。

现在,让我们把上述的代码移植到 3.10.0-862.11.6.el7.x86_64 内核的系统,按照原样执行,出现SEGV。

事实上,每一个运行着的内核的地址链接参数均可能不一致,这也是Linux内核版本间ABI不兼容的原因和结果。不过,要想让 3.10.0-327.el7.x8664 的代码跑在 3.10.0-862.11.6.el7.x8664 系统版本上也不难,按照以下的定义修改宏即可:

#define    DIRECT_MAPPING_START    0xffff8b9d40000000
// from ./kernel/vmlinux.lds.S// .data : AT(ADDR(.data) - LOAD_OFFSET)// #define LOAD_OFFSET __START_KERNEL_map// #define __START_KERNEL_map 0xffffffff80000000#define    START_MAPPING_START     0xffffffffa6a00000#define    SK_WQ_OFFSET    224 // sock.sk_wq#define LIST_PREV_OFFSET    8   // list_head.prev#define    WAITQ_TASK_OFFSET   24  // __wait_queue.task_list#define    PRIVATE_OFFSET  8   // __wait_queue.private#define POLLING_TASK_OFFSET    24  // poll_wqueues.polling_task#define PID_OFFSET    1188    // task_struct.pid#define COMM_OFFSET    1656    // task_struct.comm#define    TASKS_OFFSET    1072    // task_struct.tasks

下面是3.10.0-862.11.6.el7.x86_64内核上的演示:

[root@localhost ~]# cat /proc/net/packetsk       RefCnt Type Proto  Iface R Rmem   User   Inodeffff8b9d7bf89000 3      3    0003   3     1 0      0      16883[root@localhost ~]# ./a.out 8b9d7bf89000pid0 is:959719    [NetworkManager]716    [firewalld]708    [login]703    [crond]698    [systemd-logind]696    [polkitd]......3    [ksoftirqd/0]2    [kthreadd]1    [systemd]0    [swapper/0]2685    [a.out]2171    [pickup]2166    [stapio]1416    [qmgr]1414    [master]1136    [xinetd]1131    [tuned]1129    [rsyslogd]1126    [sshd][root@localhost ~]#

在我们已经掌握了通过特定内存地址的蛛丝马迹顺藤摸瓜在/dev/mem里找到特定结构体这种技巧之后,回过头来再来看相对简单的通过init_task遍历所有进程的方法就很很容易理解了。

下面是通过init_task作为引子遍历所有进程的代码:

#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/mman.h>#include <string.h>#include <fcntl.h>
#define    DIRECT_MAPPING_START    0xffff880000000000#define    DIRECT_MAPPING_END      0xffffc7ffffffffff
// from ./kernel/vmlinux.lds.S// .data : AT(ADDR(.data) - LOAD_OFFSET)// #define LOAD_OFFSET __START_KERNEL_map// #define __START_KERNEL_map 0xffffffff80000000#define    START_MAPPING_START     0xffffffff80000000
int main(int argc, char **argv){    int i = 0 ;    unsigned int pid0 = 0xffffffff, *pitmp;    int fd;    unsigned long off, map_off = DIRECT_MAPPING_START;    unsigned long *pltmp, *pltmp2;    unsigned char *addr, *taddr, *base, *pctmp;
    fd = open("/dev/mem", O_RDWR);    // 参数为我们在/proc/kallsyms里找到的init_task的地址。    off = strtoll(argv[1], NULL, 16) - START_MAPPING_START & 0x0000ffffffffffff;
    addr = mmap(NULL, 0xffffffff, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);    base = addr;    addr += off;#define TASKS_OFFSET    1288    addr += TASKS_OFFSET;    pltmp  = (unsigned long *)addr;
    while (1) {        taddr = (unsigned char *)*pltmp; // list_entry        taddr -= map_off;        taddr += (unsigned long)base;        taddr -= TASKS_OFFSET;
#define PID_OFFSET    1404    // task_struct.pid#define COMM_OFFSET    1872    // task_struct.comm        pitmp = (unsigned int *)(taddr + PID_OFFSET);        printf("%d\t", *pitmp);
        pctmp = (taddr + COMM_OFFSET);        printf("[%s] \n", pctmp);        addr = (unsigned char *)*pltmp; // list        addr -= map_off;        addr += (unsigned long)base;        pltmp = (unsigned long *)addr;        if (*pltmp > DIRECT_MAPPING_END) {            break;        }    }
    close(fd);    munmap(addr, 0xffffffff);
    return 1;}

看起来代码短了不少。演示如下:

[root@10 mem]# ./a.out ffff819514401    [systemd]2    [kthreadd]3    [ksoftirqd/0]7    [migration/0]8    [rcu_bh]9    [rcuob/0]10    [rcuob/1]11    [rcuob/2]12    [rcuob/3]13    [rcu_sched]14    [rcuos/0]15    [rcuos/1]16    [rcuos/2]...

通过写/dev/mem手刃进程

无条件杀掉一个进程的方式不外乎两种:

  1. SIGKILL杀掉它。
  2. 自身出了严重的问题而自毁。

要么从外部着手,要么由内部腐烂,但一个进程的灭亡均需要理由。然而,一个好好的进程整体被掏空意味着什么?可以做到吗?这就好比一个善良且健康的人,突然间遭遇了严重的意外事故那般不幸。

通过写/dev/mem可以轻而易举掏空一个进程,当进程再次准备执行时,发现自己什么都没有了。

我们可以定位到进程在/dev/mem的位置,进而摘除进程的vma,清空stack...有点残忍,我便不再举例细说。

通过写/dev/mem修改函数指令

作为最后一个例子,我想是时候前后呼应一下了,《解决Linux内核问题实用技巧之 - Crash工具结合/dev/mem任意修改内存》中的第一个例子是可以自由快乐玩转后面例子的前提,即修改devmemisallowed函数的指令,使其恒返回1,现在,我们通过写/dev/mem的方式把它还原回去,从而结束本文。

我们从/proc/kallsyms中查到devmemisallowed的地址:

ffffffff8105e630 T devmem_is_allowed

这是它原来的样子:

ja语句被我们改成了两个nop,现在我们要把两个nop还原成ja:

值得注意的是,devmemisallowed函数只会约束/dev/mem的open和mmap调用,一旦mmap成功,访问/dev/mem就像正常的访存操作,不再受到文件读写的限制,所以才可以安全地写/dev/mem,而不必像hook它时那样必须原子写才能成功。

OK,从修改devmemisallowed开始,到恢复devmemisallowed结束,我们玩转了圆满。

为了轻松下车,我们最后再安排一个例子。

合法访问NULL地址

到底NULL地址能不能访问呢?到底是谁不让访问NULL地址呢?

先说结论:

  • NULL地址完全可以访问,只要有页表项映射它到一个物理页面就行。

Linux系统有一个参数控制能不能mmap NULL地址:

[root@10 ~]# cat /proc/sys/vm/mmap_min_addr4096[root@10 ~]# echo  0 >/proc/sys/vm/mmap_min_addr[root@10 ~]# cat /proc/sys/vm/mmap_min_addr0

我们做一个实验,看个究竟,先看代码:

// gcc access0.c -o access0#include <stdio.h>#include <stdlib.h>#include <sys/mman.h>
int main(int argc, char **argv){    int i;    unsigned char *niladdr = NULL;    unsigned char str[] = "Zhejiang Wenzhou pixie shi,xiayu jinshui buhui pang!";
    mmap(0, 4096, PROT_READ|PROT_WRITE, MAP_FIXED|MAP_ANONYMOUS|MAP_SHARED, -1, 0);    perror("a");
    for (i = 0 ; i < sizeof(str); i++) {        niladdr[i] = str[i];    }    printf("using assignment at NULL: %s\n", niladdr);    for (i = 0 ; i < sizeof(str); i++) {        printf ("%c", niladdr[i]);    }    printf ("\n");
    getchar();
    munmap(0, 4096);
    return 0;}

运行它:

[root@10 mem]# ./access0a: Successusing assignment at NULL: (null)Zhejiang Wenzhou pixie shi,xiayu jinshui buhui pang!

此时我们crash工具看看NULL的映射:

看起来并没有不同。

之所以NULL地址不让访问,是为了更好地区分什么是合法地址,所以人为制造了一个特殊地址NULL,MMU层面上,NULL并无不同。

结语

好了,关于crash工具和/dev/mem的话题要结束,结合前面一篇文章,建议亲自做这些实验,方可获得更深刻地认知。

更加重要的是,每个人在亲自动手做这些实验时,会碰到各种各样新的问题,分析以及最终hack掉这些问题,正是快乐感觉的由来,分享这种快乐本身也是一件快乐的事情,这也是我写这两篇文章的动力。

临渊羡鱼,不如退而结网。

本文分享自微信公众号 - Linux阅码场(LinuxDev)

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2019-11-20

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 「前端进阶」从多线程角度来看 Event Loop

    几乎在每一本JS相关的书籍中,都会说JS是 单线程的,JS是通过事件队列 (EventLoop)的方式来实现异步回调的。对很多初学JS的人来说,根本搞不清楚单线...

    桃翁
  • Linux基础之终端、控制台、tty、pty等概念简介

    tty一词源于teletypes,或者teletypewriters,原来指的是电传打字机,是通过串行线用打印机键盘阅读和发送信息的东西,后来这东西被键盘与显示...

    小小科
  • Impala查询卡顿分析案例

    作者简介:黄权隆,Cloudera研发工程师,Apache Impala PMC & Comitter,毕业于北大计算机系网络所数据库实验室,曾就职于Hulu大...

    Fayson
  • Sequelize 系列教程之多对多模型关系

    Sequelize 是一个基于 Promise 的 Node.js ORM,目前支持 Postgres、MySQL、SQLite 和 Microsoft SQL...

    semlinker
  • netdata安装

    Linux性能实时监测工具,以web的可视化方式展示系统及应用程序的实时运行状态(包括cpu、内存、硬盘输入/输出、网络等linux性能的数据)。炫酷的界面来显...

    薛定喵君
  • 每月一生信流程之RNAseq123

    全部bioconductor流程链接在;http://www.bioconductor.org/packages/release/BiocViews.html#...

    生信技能树
  • 谈谈网络通信服务器的结构应该如何设计

    虽然你在线程池的用途上有些混乱,epoll 和 线程池没多大关系,但是这个问题其实蛮不错的,所以详细说一下希望给有需要的读者解决部分疑惑。

    范蠡
  • 你的Redis有类转换异常么

    •该异常不是必现的,偶尔才会出现;•出现该异常后重启应用或者过一会就好了;•序列化协议使用了hessian。

    luoxn28
  • centos yum安装完成桌面环境后无法访问,显示.serverauth.** does not exist解决办法

    centos安装桌面环境serverauth.** does not exist解决办法

    薛定喵君
  • Centos安装MySQL5.7.22文档

    此时发现错误,无法创建lockfile,原因是在/var/lib目录下没有mysql文件夹,错误如下:

    AsiaYe

扫码关注云+社区

领取腾讯云代金券