Linux内核中添加新功能隐藏进程地址空间内存不被窃取

系统 Linux
首先看怎样能获取其它进程地址空间的内存,答案是ptrace毫无疑问了,其它比如使用crash工具,利用系统漏洞,插入模块等邪门方法不在本篇讨论范围之内。

 [[356458]]

本文转载自微信公众号「相遇Linux」,作者JeffXie 。转载本文请联系相遇Linux公众号。    

首先看怎样能获取其它进程地址空间的内存,答案是ptrace毫无疑问了,其它比如使用crash工具,利用系统漏洞,插入模块等邪门方法不在本篇讨论范围之内。

上例子:test.c

  1.  #define handle_error(msg) \ 
  2.     do { perror(msg); exit(EXIT_FAILURE); } while (0) 
  3.  
  4. int main(void) 
  5.         char *p;  
  6.         char const str[] = "Jeff Xie\n"
  7.  
  8.         p = malloc(sizeof(str)); 
  9.         if (!p) 
  10.                 handle_error("malloc"); 
  11.         printf("p:0x%llx\n", p);  
  12.         memcpy(p, str, sizeof(str)); 
  13.         printf("str:%s\n", p);  
  14.         sleep(10000); 
  15.  
  16.         return 0; 

地址: https://github.com/x-lugoo/hide-memory

上面例子test.c中只是非常单纯的malloc了一块区域(堆区),然后保存了一个字符串.

terminal 1:

  1. #gcc test.c  
  2. #./a.out  
  3. p:0xd3d260 
  4. str:Jeff Xie 

terminal 2:

  1. #ps -C a.out 
  2.   PID TTY          TIME CMD 
  3. 19145 pts/4    00:00:00 a.out 
  4. #cat /proc/19145/maps 
  5. 00400000-00401000 r-xp      /home/jeff/a.out 
  6. 00600000-00601000 r--p      /home/jeff/a.out 
  7. 00601000-00602000 rw-p      /home/jeff/a.out 
  8. 00d3d000-00d5e000 rw-p      [heap] 

可以看到0xd3d260 在heap区域范围内,使用readmem就可以简单粗暴的读出了进程19145(a.out)的0xd3d260 向后十个字节的内容.

terminal 2:

  1. #readmem 19145 0xd3d260 10 
  2. Jeff Xie 

程序readmem使用ptrace功能实现,代码见:

  1. https://github.com/x-lugoo/hide-memory/tree/main/ptrace 

如果进程19145保存的不是一个普通的字符串,而是某位皇帝留下的千年宝藏的地址,或者里面的信息关系到整个公司的命脉,如果被nice值不高的人获取了,后果可想而知。

最近有人(前辈)在linux内核社区提交了一个patch,解决了这个问题,我把整个patch简化了一些。

原始patch:

  1. https://lore.kernel.org/linux-fsdevel/20201203062949.5484-1-rppt@kernel.org/T/#t 

被我简化后:

  1. https://github.com/x-lugoo/hide-memory/blob/main/hidemem/0001-hidemem-Initialization-version.patc 

此patch实现的原理:

新增一个系统调用memfd_hide, 当用户使用这个系统调用时,会返回一个fd, 进而使用mmap(...fd...),map一段内存,此段内存将是安全的,其它人不能通过ptrace获取。

  1. --- a/arch/x86/entry/syscalls/syscall_64.tbl 
  2. +++ b/arch/x86/entry/syscalls/syscall_64.tbl 
  3. @@ -362,6 +362,7 @@ 
  4.  438    common  pidfd_getfd     sys_pidfd_getfd 
  5.  439    common  faccessat2      sys_faccessat2 
  6.  440    common  process_madvise     sys_process_madvise 
  7. +441    common  memfd_hide      sys_memfd_hide 
  8.  
  9. SYSCALL_DEFINE1(memfd_hide, unsigned long, flags) 
  10.         struct file *file; 
  11.         int fd, err; 
  12.         fd = get_unused_fd_flags(flags & O_CLOEXEC); 
  13.         file = hidemem_file_create(flags); 
  14.         fd_install(fd, file); 
  15.         return fd; 

当用户调用441号系统调用时,系统会返回一个fd,例如用户层这样调用:

  1. #define __NR_memfd_hide 441 
  2. static int memfd_secret(unsigned long flags) 
  3.      return syscall(__NR_memfd_hide, flags); 
  4. fd = memfd_secret(0); 

fd_install 做了以下操作,把fd和当前进程关联起来.

  1. struct fdtable *fdt; 
  2. struct task_struct { 
  3.           ... 
  4.           struct files_struct             *files; 
  5. fdt = current->files->fdt; 
  6. fdt->fd[fd] = file; 

hidemem_file_create 最终是返回了一个struct file, 但是做的一个很重要的动作是初始化一系列回调函数,让用户调用mmap和memcpy时,在发生page fault时进行合适的动作,比如调用alloc_page(gfp)申请一块内存.

  1. fd = memfd_secret(0); 
  2. p = mmap(NULL, 4096, prot, mode, fd, 0); 
  3. memcpy(p, str, sizeof(str)); 

追随以下绿色标记 可以很好理清函数调用关系:

  1. static struct file *hidemem_file_create(unsigned long flags) 
  2.         struct file *file = ERR_PTR(-ENOMEM); 
  3.         struct inode *inode; 
  4.         inode = alloc_anon_inode(hidemem_mnt->mnt_sb); 
  5.         file = alloc_file_pseudo(inode, hidemem_mnt, "hidemem"
  6.                                  O_RDWR, &hidemem_fops); 
  7.         inode->i_mapping->a_ops = &hidemem_aops; 
  8.  
  9. static const struct file_operations hidemem_fops = { 
  10.         .release        = hidemem_release, 
  11.         .mmap           = hidemem_mmap, 
  12. }; 
  13.  
  14. static int hidemem_mmap(struct file *file, struct vm_area_struct *vma) 
  15.         vma->vm_ops = &hidemem_vm_ops; 
  16.         vma->vm_flags |= VM_LOCKED; 
  17.  
  18. static const struct vm_operations_struct hidemem_vm_ops = { 
  19.         .fault = hidemem_fault, 
  20. }; 
  21.  
  22. static vm_fault_t hidemem_fault(struct vm_fault *vmf) 
  23.         struct address_space *mapping = vmf->vma->vm_file->f_mapping; 
  24.         vm_fault_t ret = 0; 
  25.         struct page *page; 
  26.         int err; 
  27.  
  28.         page = find_get_page(mapping, offset); 
  29.         if (!page) { 
  30.                 page = hidemem_alloc_page(vmf->gfp_mask); 
  31.                 err = add_to_page_cache(page, mapping, offset, vmf->gfp_mask); 
  32.         } 
  33.         vmf->page = page; 
  1. static struct page *hidemem_alloc_page(gfp_t gfp) 
  2.         return alloc_page(gfp); 

回到怎样隐藏进程空间的问题上:

当其它进程使用ptrace功能获取指定进程地址空间内容时,会调用到check_vma_flags(), 此时加上一个条件判断,如果此段vma(/proc/pid/maps中的每一列地址范围属于一个vma)属于hidemem, 直接返回错误.

  1.  static int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags) 
  2.  { 
  3.      vm_flags_t vm_flags = vma->vm_flags; 
  4. @@ -923,6 +925,9 @@ static int check_vma_flags(struct vm_area_struct *vma, unsigned long gup_flags) 
  5.      if (gup_flags & FOLL_ANON && !vma_is_anonymous(vma)) 
  6.          return -EFAULT; 
  7.  
  8. +    if (vma_is_hidemem(vma)) 
  9. +        return -EFAULT; 
  10.      if (write) { 
  11.          if (!(vm_flags & VM_WRITE)) { 
  12.              if (!(gup_flags & FOLL_FORCE)) 
  1. static const struct vm_operations_struct hidemem_vm_ops = { 
  2.         .fault = hidemem_fault, 
  3. }; 
  4.  
  5. bool vma_is_hidemem(struct vm_area_struct *vma) 
  6.         return vma->vm_ops == &hidemem_vm_ops; 

加上vma_is_hidemem(vma)判断之后,此时如果使用readmem利用ptrace获取指定进程内存段的时候,会直接报错,以达到隐藏vma背后page内容的目的。

以上patch和测试代码都在:

  1. https://github.com/x-lugoo/hide-memory 

原始patch:

  1. https://lore.kernel.org/linux-fsdevel/20201203062949.5484-1-rppt@kernel.org/T/#t 

 

 

责任编辑:武晓燕 来源: 相遇Linux
相关推荐

2019-03-28 09:42:15

恶意软件Rootkit攻击

2021-01-08 05:59:39

Linux应用程序Linux系统

2018-05-18 08:43:27

Linux内存空间

2012-05-03 08:27:20

Linux进程

2010-05-13 09:45:26

Linux地址空间

2018-05-18 09:07:43

Linux内核内存

2021-01-04 10:02:54

Facebook凭证攻击

2024-01-08 08:42:43

2021-03-22 11:43:07

Linux运维Linux系统

2022-09-13 11:15:33

加密货币区块链

2011-10-28 15:50:45

C程序

2013-07-01 09:58:58

Windows 8.1

2021-11-09 07:31:08

Robinhood黑客美国

2019-01-29 10:10:09

Linux内存进程堆

2020-08-16 09:25:21

Windows 10Windows操作系统

2022-08-06 16:36:21

漏洞网络攻击

2021-03-28 09:37:35

窃取数据暗网安全

2009-06-09 10:00:56

2020-05-08 11:56:43

微软GitHub账号黑客

2020-10-16 12:11:31

网络攻击网络安全黑客
点赞
收藏

51CTO技术栈公众号