[Android 原创] 几个简单的Android反调试手段

admin

当时写cm里加进去的，期间又搜集资料，各种学习姿势补充了几点调试方式，

具体可参见源代码，220行以下请忽略，

1. https://github.com/Qrilee/crackme

复制代码

https://github.com/Qrilee/crackm ... Debug/antidebug.cpp

1. #include "antidebug.h"
   
2. 
   
3. 
   
4. #define CHECK_TIME 10
   
5. #define MAX 128
   
6. #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, "qtfreet00", __VA_ARGS__)
   
7. #define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "qtfreet00", __VA_ARGS__)
   
8. #define WCHAN_ELSE 0;
   
9. #define WCHAN_RUNNING 1;
   
10. #define WCHAN_TRACING 2;
    
11. int keep_running;
    
12. 
    
13. void signal_handle(int num) {
    
14.     keep_running = 0;
    
15. }
    
16. 
    
17. int getWchanStatus() {
    
18.     char *wchaninfo = new char[128];
    
19.     int result = WCHAN_ELSE;
    
20.     char *cmd = new char[128];
    
21.     pid_t pid = syscall(__NR_getpid);
    
22.     sprintf(cmd, "cat /proc/%d/wchan", pid);
    
23.     //LOGE("cmd= %s", cmd);
    
24.     if (cmd == NULL) {
    
25.         return WCHAN_ELSE;
    
26.     }
    
27.     FILE *ptr;
    
28.     if ((ptr = popen(cmd, "r")) != NULL) {
    
29.         if (fgets(wchaninfo, 128, ptr) != NULL) {
    
30.             LOGE("wchaninfo= %s", wchaninfo);
    
31.         }
    
32.     }
    
33.     if (strncasecmp(wchaninfo, "sys_epoll\0", strlen("sys_epoll\0")) == 0) {
    
34.         result = WCHAN_RUNNING;
    
35.     }
    
36.     else if (strncasecmp(wchaninfo, "ptrace_stop\0", strlen("ptrace_stop\0")) == 0) {
    
37.         result = WCHAN_TRACING;
    
38.     }
    
39.     return result;
    
40. }
    
41. 
    
42. 
    
43. void CalcTime(int res, int des) {
    
44.     int pid = getpid();
    
45.     if (des - res >= 2) {
    
46.         kill(pid, SIGKILL);
    
47.     } else {
    
48.     }
    
49. }
    
50. 
    
51. void checkAndroidServer() {
    
52.     char szLines[1024] = {0};
    
53.     //监听23946端口
    
54.     FILE *fp = fopen("/proc/net/tcp", "r");
    
55.     if (fp != NULL) {
    
56.         while (fgets(szLines, sizeof(szLines), fp)) {
    
57.             //23946端口
    
58.             if (strstr(szLines, "00000000:5D8A")) {
    
59.                 kill(getpid(), SIGKILL);
    
60.                 break;
    
61.             }
    
62.         }
    
63. 
    
64.         fclose(fp);
    
65.     }
    
66. 
    
67.     LOGE("no find android server");
    
68. }
    
69. 
    
70. void readStatus() {
    
71.     FILE *fd;
    
72.     char filename[MAX];
    
73.     char line[MAX];
    
74.     pid_t pid = syscall(__NR_getpid);
    
75.     int ret = getWchanStatus();
    
76.     if (2 == ret) {
    
77.         kill(pid, SIGKILL);
    
78.     }
    
79.     sprintf(filename, "/proc/%d/status", pid);// 读取proc/pid/status中的TracerPid
    
80.     if (fork() == 0) {
    
81.         int pt;
    
82.         pt = ptrace(PTRACE_TRACEME, 0, 0, 0); //子进程反调试
    
83.         if (pt == -1)
    
84.             exit(0);
    
85.         while (1) {
    
86.             checkAndroidServer();
    
87.             fd = fopen(filename, "r");
    
88.             while (fgets(line, MAX, fd)) {
    
89.                 if (strncmp(line, "TracerPid", 9) == 0) {
    
90.                     int statue = atoi(&line[10]);
    
91. //                    LOGE("########## statue = %d,%s", statue, line);
    
92.                     fclose(fd);
    
93.                     syscall(__NR_close, fd);
    
94.                     if (statue != 0) {
    
95.                         // LOGE("########## here");
    
96.                         int ret = kill(pid, SIGKILL);
    
97.                         // LOGE("########## kill = %d", ret);
    
98.                         return;
    
99.                     }
    
100. 
     
101.                     break;
     
102.                 }
     
103.             }
     
104.             sleep(CHECK_TIME);
     
105.         }
     
106.     } else {
     
107. //        LOGE("fork error");
     
108.     }
     
109. }
     
110. 
     
111. 
     
112. int event_check(int fd) {
     
113.     fd_set rfds;
     
114.     FD_ZERO(&rfds);
     
115.     FD_SET(fd, &rfds);
     
116. 
     
117.     return select(FD_SETSIZE, &rfds, NULL, NULL, NULL);
     
118. }
     
119. 
     
120. int read_event(int fd) {
     
121.     char buffer[16384] = {0};
     
122.     size_t index = 0;
     
123.     struct inotify_event *ptr_event;
     
124. 
     
125.     ssize_t r = read(fd, buffer, 16384);
     
126.     if (r <= 0) {
     
127.         LOGE("read_event");
     
128.         return r;
     
129.     }
     
130. 
     
131.     while (index < r) {
     
132.         ptr_event = (struct inotify_event *) &buffer[index];
     
133. //        LOGD("wd = %d mask = %d cookie = %d len = %d dir = %s\n",
     
134. //             ptr_event->wd, ptr_event->mask, ptr_event->cookie, ptr_event->len,
     
135. //             (ptr_event->mask & IN_ISDIR) ? "yes" : "no");
     
136. //        if (ptr_event->len)
     
137. //            LOGD("name = %s", ptr_event->name);
     
138.         //此处监控事件的读和打开，如果出现则直接结束进程
     
139.         if ((ptr_event->mask & IN_ACCESS) || (ptr_event->mask & IN_OPEN)) {
     
140.             //    LOGD("kill!!!!!\n");
     
141.             //事件出现则杀死父进程
     
142.             LOGE("hhhahahahahahahahahaahah");
     
143.             int ret = kill(getpid(), SIGKILL);
     
144.             //  LOGD("ret = %d", ret);
     
145.             return 0;
     
146.         }
     
147. 
     
148.         index += sizeof(struct inotify_event) + ptr_event->len;
     
149.     }
     
150.     return 0;
     
151. }
     
152. 
     
153. void runInotify() {
     
154.     keep_running = 1;
     
155.     pid_t ppid = syscall(__NR_getpid);
     
156. //    if (signal(SIGINT, signal_handle) == SIG_IGN) {
     
157. //        signal(SIGINT, SIG_IGN);
     
158. //    }
     
159. 
     
160.     int fd;
     
161.     char buf[1024];
     
162.     fd = inotify_init();//初始化
     
163.     if (fd == -1) { //错误处理
     
164.         LOGE("inotify_init error");
     
165.         switch (errno) {
     
166.             case EMFILE:
     
167.                 LOGD("errno: EMFILE");
     
168.                 break;
     
169.             case ENFILE:
     
170.                 LOGD("errno: ENFILE");
     
171.                 break;
     
172.             case ENOMEM:
     
173.                 LOGD("errno: ENOMEM");
     
174.                 break;
     
175.             default:
     
176.                 LOGD("unkonw errno");
     
177.         }
     
178.         return;
     
179.     }
     
180. 
     
181.     int wd;
     
182.     sprintf(buf, "/proc/%d/maps", ppid);
     
183.     wd = inotify_add_watch(fd, buf, IN_ALL_EVENTS); //添加监视
     
184.     if (wd == -1) { //错误处理
     
185.         LOGE("inotify_add_watch");
     
186.         switch (errno) {
     
187.             case EACCES:
     
188.                 LOGE("errno: EACCES");
     
189.                 break;
     
190.             case EBADF:
     
191.                 LOGE("errno: EBADF");
     
192.                 break;
     
193.             case EFAULT:
     
194.                 LOGE("errno: EFAULT");
     
195.                 break;
     
196.             case EINVAL:
     
197.                 LOGE("errno: EINVAL");
     
198.                 break;
     
199.             case ENOMEM:
     
200.                 LOGE("errno: ENOMEM");
     
201.                 break;
     
202.             case ENOSPC:
     
203.                 LOGD("errno: ENOSPC");
     
204.                 break;
     
205.             default:
     
206.                 LOGD("unkonw errno");
     
207.         }
     
208.         return;
     
209.     }
     
210. 
     
211.     while (keep_running) {
     
212.         if (event_check(fd) > 0) {
     
213.             read_event(fd);
     
214.         }
     
215.     }
     
216.     return;
     
217. }
     
218. //以下方法暂不清楚如何利用
     
219. 
     
220. 
     
221. void AntiDebug() {
     
222.     // LOGE("Call inotify");
     
223.     pid_t ppid = syscall(__NR_getpid);
     
224.     char buf[1024];
     
225.     char readbuf[MAX];
     
226.     int wd, ret, len, i;
     
227.     int fd;
     
228.     fd_set readfds;
     
229.     //防止调试子进程
     
230.     ptrace(PTRACE_TRACEME, 0, 0, 0);
     
231.     fd = inotify_init();
     
232.     sprintf(buf, "/proc/%d/maps", ppid);
     
233. 
     
234.     //wd = inotify_add_watch(fd, "/proc/self/mem", IN_ALL_EVENTS);
     
235.     wd = inotify_add_watch(fd, buf, IN_ALL_EVENTS);
     
236.     if (wd < 0) {
     
237.         // LOGD("can't watch %s", buf);
     
238.         return;
     
239.     }
     
240.     while (1) {
     
241.         i = 0;
     
242.         //注意要对fd_set进行初始化
     
243.         FD_ZERO(&readfds);
     
244.         FD_SET(fd, &readfds);
     
245.         //第一个参数固定要+1，第二个参数是读的fdset，第三个是写的fdset，最后一个是等待的时间
     
246.         //最后一个为NULL则为阻塞
     
247.         ret = select(fd + 1, &readfds, 0, 0, 0);
     
248.         if (ret == -1)
     
249.             break;
     
250.         if (ret) {
     
251.             len = read(fd, readbuf, MAX);
     
252.             LOGE("come in!");
     
253. 
     
254.             while (i < len) {
     
255.                 //   LOGE("comeeeeee i n ...");
     
256.                 //返回的buf中可能存了多个inotify_event
     
257.                 struct inotify_event *event = (struct inotify_event *) &readbuf[i];
     
258.                 //  LOGE("event mask %d\n", (event->mask & IN_ACCESS) || (event->mask & IN_OPEN));
     
259.                 //这里监控读和打开事件
     
260.                 if ((event->mask & IN_ACCESS) || (event->mask & IN_OPEN)) {
     
261.                     //    LOGD("kill!!!!!\n");
     
262.                     //事件出现则杀死父进程
     
263.                     int ret = kill(ppid, SIGKILL);
     
264.                     //  LOGD("ret = %d", ret);
     
265.                     return;
     
266.                 }
     
267.                 i += sizeof(struct inotify_event) + event->len;
     
268.             }
     
269.         }
     
270.         sleep(CHECK_TIME);
     
271.     }
     
272.     inotify_rm_watch(fd, wd);
     
273.     close(fd);
     
274. }
     
275. 
     
276. int gpipe[2];
     
277. 
     
278. void *parent_read_thread(void *param) {
     
279.     LOGD("wait for child process to write decode data");
     
280.     int readPipe = gpipe[0];
     
281.     read(readPipe, 0, 0x10);
     
282.     close(readPipe);
     
283.     return 0;
     
284. }
     
285. 
     
286. void *child_attach_thread(void *param) {
     
287.     int pid = *(int *) param;
     
288.     LOGD("check child status %d", pid);
     
289.     safe_attach(pid);
     
290.     handle_events();
     
291.     LOGE("watch thread exit");
     
292. 
     
293.     kill(getpid(), 9);
     
294. }
     
295. 
     
296. 
     
297. int checkDebugger() {
     
298. // use Multi process to protect itself
     
299.     int forktime = 0;
     
300. 
     
301.     FORKLABEL:
     
302.     forktime++;
     
303.     if (forktime > 5) {
     
304.         return 0;
     
305.     }
     
306. 
     
307.     if (pipe(gpipe)) {
     
308.         return 0;
     
309.     }
     
310.     int pid = fork();
     
311.     prctl(PR_SET_DUMPABLE, 1);
     
312. 
     
313.     if (pid != 0) {
     
314.         // parent
     
315.         close(gpipe[1]);
     
316.         LOGD("start new thread to read decode data");
     
317.         pthread_t ntid;
     
318.         pthread_create(&ntid, NULL, parent_read_thread, &pid);
     
319.         bool flag = false;
     
320.         do {
     
321.             int childstatus;
     
322.             int childpid = waitpid(pid, &childstatus, WNOHANG);
     
323.             bool succ = childpid == 0;
     
324.             if (childpid > 0) {
     
325.                 succ = childstatus == 1;
     
326.                 LOGD("Child process end!");
     
327.             }
     
328.             if (!succ) {
     
329.                 kill(pid, 9);
     
330.                 goto FORKLABEL;
     
331.             }
     
332.             flag = true;
     
333.         } while (!flag);
     
334.     } else {
     
335.         // child
     
336.         // Write key to pipe
     
337.         int cpid = getppid();
     
338.         safe_attach(cpid);
     
339.         LOGD("child process Attach success, try to write data");
     
340. 
     
341.         close(gpipe[0]);
     
342.         int writepipe = gpipe[1];
     
343. 
     
344.         char tflag[0x10 + 1] = {
     
345.                 0x4A, 0x75, 0x73, 0x74, 0x48, 0x61, 0x76, 0x65,
     
346.                 0x41, 0x54, 0x72, 0x79, 0x21, 0x21, 0x21, 0x21
     
347.         };
     
348. 
     
349.         write(writepipe, tflag, 0x10);
     
350.         close(writepipe);
     
351.         handle_events();
     
352.         exit(EXIT_FAILURE);
     
353. 
     
354.     }
     
355.     return 0;
     
356. }
     
357. 
     
358. bool may_cause_group_stop(int signo) {
     
359.     switch (signo) {
     
360.         case SIGSTOP:
     
361.         case SIGTSTP:
     
362.         case SIGTTIN:
     
363.         case SIGTTOU:
     
364.             return true;
     
365.             break;
     
366.         default:
     
367.             break;
     
368.     }
     
369. 
     
370.     return false;
     
371. }
     
372. 
     
373. void handle_events() {
     
374.     int status = 0;
     
375.     pid_t pid = 0;
     
376. 
     
377.     do {
     
378.         pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, __WALL));
     
379.         if (pid < 0) {
     
380.             perror("waitpid");
     
381.             exit(EXIT_FAILURE);
     
382.         }
     
383. 
     
384.         if (WIFEXITED(status)) {
     
385.             LOGE("%d exited, status=%d\n", pid, WEXITSTATUS(status));
     
386.         }
     
387.         else if (WIFSIGNALED(status)) {
     
388.             LOGE("%d killed by signal %d\n", pid, WTERMSIG(status));
     
389.         }
     
390.         else if (WIFSTOPPED(status)) {
     
391.             int signo = WSTOPSIG(status);
     
392.             LOGE("%d stopped by signal %d\n", pid, signo);
     
393. 
     
394.             if (may_cause_group_stop(signo)) {
     
395.                 signo = 0;
     
396.             }
     
397. 
     
398.             long err = ptrace(PTRACE_CONT, pid, NULL, signo);
     
399.             if (err < 0) {
     
400.                 perror("PTRACE_CONT");
     
401.                 exit(EXIT_FAILURE);
     
402.             }
     
403.         }
     
404. 
     
405.     } while (!WIFEXITED(status) && !WIFSIGNALED(status));
     
406. 
     
407. }
     
408. 
     
409. void safe_attach(pid_t pid) {
     
410.     long err = ptrace(PTRACE_ATTACH, pid, NULL, NULL);
     
411.     if (err < 0) {
     
412.         LOGE("PTRACE_ATTACH");
     
413.         exit(EXIT_FAILURE);
     
414.     }
     
415. 
     
416.     int status = 0;
     
417.     err = TEMP_FAILURE_RETRY(waitpid(pid, &status, __WALL));
     
418.     if (err < 0) {
     
419.         LOGE("waitpid");
     
420.         exit(EXIT_FAILURE);
     
421.     }
     
422. 
     
423.     if (WIFEXITED(status)) {
     
424.         LOGE("%d exited, status=%d\n", pid, WEXITSTATUS(status));
     
425.         exit(EXIT_SUCCESS);
     
426.     }
     
427.     else if (WIFSIGNALED(status)) {
     
428.         LOGE("%d killed by signal %d\n", pid, WTERMSIG(status));
     
429.         exit(EXIT_SUCCESS);
     
430.     }
     
431.     else if (WIFSTOPPED(status)) {
     
432.         int signo = WSTOPSIG(status);
     
433.         LOGE("%d stopped by signal %d\n", pid, signo);
     
434. 
     
435.         if (may_cause_group_stop(signo)) {
     
436.             signo = 0;
     
437.         }
     
438. 
     
439.         err = ptrace(PTRACE_CONT, pid, NULL, signo);
     
440.         if (err < 0) {
     
441.             LOGE("PTRACE_CONT");
     
442.             exit(EXIT_FAILURE);
     
443.         }
     
444.     }
     
445. 
     
446.     LOGD("Debugger: attached to process %d\n", pid);
     
447. }
     

复制代码

代码可以正常运行（cm自身是只支持4.4以下的，把qtfreet.cpp的init函数注释掉可以在5.0+上运行，此处为davilk动态自篡改），

但难免不会有我个人理解的问题，兼容或者没测试出的bug，欢迎大牛提出问题，提出新的检测方式和提交代码，最好顺手给个star，谢谢