root android模拟器的最通用方式

元始天尊

这里介绍的是绝对可行的root方式，对于android模拟器，无论x86 x64 ，无论4.0 5.0 6.0都适用
真机的话5.0和6.0，root成功率比较低，因此不适合在上面做root方面的测试，这时只能考虑虚拟机，因为虚拟机adb有root权限，利用adb root权限便可以提升su权限
网上盛传的方法是http://androidsu.com/superuser https://www.0xaa55.com/forum.php ... tid=1648&extra=
需要superuser.apk，我分析了该网站的su，发现除了传统su的流程(setuid setgid)外，还加入了和superuser.apk通信的这一步
superuser.apk用于单个app权限设置。
遗憾的是该作者并没完成mips架构，和5.0以上的su适配

默认的su，是只允许root权限和shell权限来执行的，因此一般的app并不能使用，因此这也是我们修改的重点，同时还要给su加上必要的环境变量
我这种方式，去除了权限判断部分，因此减少了某些情况下由于这部分带来的root权限未成功获取的bug

这里提供一种方式，可以支持全平台
先构造文件夹：
/jni
/jni/su.cpp
/jni/Android.mk
/jni/Application.mk

1. 
   
2. //su.cpp
   
3. /*
   
4. * Copyright (C) 2008 The Android Open Source Project
   
5. *
   
6. * Licensed under the Apache License, Version 2.0 (the "License");
   
7. * you may not use this file except in compliance with the License.
   
8. * You may obtain a copy of the License at
   
9. *
   
10. *     http://www.apache.org/licenses/LICENSE-2.0
    
11. *
    
12. * Unless required by applicable law or agreed to in writing, software
    
13. * distributed under the License is distributed on an "AS IS" BASIS,
    
14. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    
15. * See the License for the specific language governing permissions and
    
16. * limitations under the License.
    
17. */
    
18. 
    
19. #include <errno.h>
    
20. #include <getopt.h>
    
21. #include <stdio.h>
    
22. #include <stdlib.h>
    
23. #include <string.h>
    
24. #include <unistd.h>
    
25. #include <pwd.h>
    
26. 
    
27. #define AID_ROOT             0  /* traditional unix root user */
    
28. #define AID_SYSTEM        1000  /* system server */
    
29. #define AID_SHELL         2000  /* adb and debug shell user */
    
30. #define AID_NOBODY        9999
    
31. #define AID_APP          10000  /* first app user */
    
32. #define AID_USER        100000  /* offset for uid ranges for each user */
    
33. 
    
34. 
    
35. void pwtoid(const char* tok, uid_t* uid, gid_t* gid) {
    
36.     struct passwd* pw = getpwnam(tok);
    
37.     if (pw)
    
38.     {
    
39.         if (uid) *uid = pw->pw_uid;
    
40.         if (gid) *gid = pw->pw_gid;
    
41.     }
    
42.     else
    
43.     {
    
44.         char* end;
    
45.         errno = 0;
    
46.         uid_t tmpid = strtoul(tok, &end, 10);
    
47.         if (errno != 0 || end == tok)
    
48.                 printf("invalid uid/gid '%s'", tok);
    
49.         if (uid) *uid = tmpid;
    
50.         if (gid) *gid = tmpid;
    
51.     }
    
52. }
    
53. 
    
54. void extract_uidgids(const char* uidgids, uid_t* uid, gid_t* gid, gid_t* gids, int* gids_count) {
    
55.     char *clobberablegids;
    
56.     char *nexttok;
    
57.     char *tok;
    
58.     int gids_found;
    
59. 
    
60.     if (!uidgids || !*uidgids)
    
61.     {
    
62.         *gid = *uid = 0;
    
63.         *gids_count = 0;
    
64.         return;
    
65.     }
    
66. 
    
67.     clobberablegids = strdup(uidgids);
    
68.     strcpy(clobberablegids, uidgids);
    
69.     nexttok = clobberablegids;
    
70.     tok = strsep(&nexttok, ",");
    
71.     pwtoid(tok, uid, gid);
    
72.     tok = strsep(&nexttok, ",");
    
73.     if (!tok)
    
74.     {
    
75.         /* gid is already set above */
    
76.         *gids_count = 0;
    
77.         free(clobberablegids);
    
78.         return;
    
79.     }
    
80.     pwtoid(tok, NULL, gid);
    
81.     gids_found = 0;
    
82.     while ((gids_found < *gids_count) && (tok = strsep(&nexttok, ",")))
    
83.     {
    
84.         pwtoid(tok, NULL, gids);
    
85.         gids_found++;
    
86.         gids++;
    
87.     }
    
88.     if (nexttok && gids_found == *gids_count)
    
89.     {
    
90.         fprintf(stderr, "too many group ids\n");
    
91.     }
    
92.     *gids_count = gids_found;
    
93.     free(clobberablegids);
    
94. }
    
95. 
    
96. int main(int argc, char** argv)
    
97. {
    
98.     uid_t current_uid = getuid();
    
99. 
    
100.     // Handle -h and --help.
     
101.     ++argv;
     
102.     if (*argv && (strcmp(*argv, "--help") == 0 || strcmp(*argv, "-h") == 0))
     
103.     {
     
104.         fprintf(stderr,
     
105.                 "usage: su [UID[,GID[,GID2]...]] [COMMAND [ARG...]]\n"
     
106.                 "\n"
     
107.                 "Switch to WHO (default 'root') and run the given command (default sh).\n"
     
108.                 "\n"
     
109.                 "where WHO is a comma-separated list of user, group,\n"
     
110.                 "and supplementary groups in that order.\n"
     
111.                 "\n");
     
112.         return 0;
     
113.     }
     
114. 
     
115.     uid_t uid = 0;
     
116.     gid_t gid = 0;
     
117. 
     
118.     if (*argv)
     
119.     {
     
120.         gid_t gids[10];
     
121.         int gids_count = sizeof(gids)/sizeof(gids[0]);
     
122.         extract_uidgids(*argv, &uid, &gid, gids, &gids_count);
     
123.         if (gids_count) {
     
124.             if (setgroups(gids_count, gids))
     
125.             {
     
126.                 printf("setgroups failed");
     
127.             }
     
128.         }
     
129.         ++argv;
     
130.     }
     
131. 
     
132.     if (setgid(gid))
     
133.             printf("setgid failed");
     
134.     if (setuid(uid))
     
135.             printf("setuid failed");
     
136. 
     
137.     //设置环境变量
     
138.     setenv("PATH", "/sbin:/vendor/bin:/system/sbin:/system/bin:/system/xbin", 1);
     
139.     setenv("LD_LIBRARY_PATH", "/vendor/lib:/system/lib", 1);
     
140.     setenv("ANDROID_BOOTLOGO", "1", 1);
     
141.     setenv("ANDROID_ROOT", "/system", 1);
     
142.     setenv("ANDROID_DATA", "/data", 1);
     
143.     setenv("ANDROID_ASSETS", "/system/app", 1);
     
144.     setenv("EXTERNAL_STORAGE", "/sdcard", 1);
     
145.     setenv("ASEC_MOUNTPOINT", "/mnt/asec", 1);
     
146.     setenv("LOOP_MOUNTPOINT", "/mnt/obb", 1);
     
147.     char* exec_args[argc + 1];
     
148.     size_t i = 0;
     
149.     for (; *argv != NULL; ++i)
     
150.     {
     
151.       exec_args[i] = *argv++;
     
152.     }
     
153. 
     
154.     if (i == 0) exec_args[i++] = "/system/bin/sh";
     
155.     exec_args[i] = NULL;
     
156. 
     
157.     execvp(exec_args[0], exec_args);
     
158.     printf("failed to exec %s", exec_args[0]);
     
159. }
     
160. 
     
161. //Android.mk
     
162. LOCAL_SRC_FILES := su.cpp
     
163. LOCAL_MODULE := su
     
164. LOCAL_MODULE_FILENAME := su
     
165. LOCAL_LDFLAGS += -fPIE -pie
     
166. LOCAL_CFLAGS += -fPIE
     
167. include $(BUILD_EXECUTABLE)
     
168. 
     
169. //Application.mk   根据自己的需求调整
     
170. APP_ABI := armeabi
     
171. APP_PLATFORM := android-15
     
172. 
     

复制代码

在jni目录下执行ndk-build即可，生成的su文件替换成/system/bin/mysu
模拟器中：
adb remount                                //使/system可写
adb push \??su /system/bin/mysu
adb shell chmod 6777 /system/bin/mysu      //使普通进程可以执行su并获取root权限

我们用简单的代码测试：

1. 
   
2.     public static boolean canRunRootCommands() {
   
3.         boolean retval = false;
   
4.         Process suProcess;
   
5. 
   
6.         try {
   
7.             suProcess = Runtime.getRuntime().exec("mysu");
   
8. 
   
9.             DataOutputStream os = new DataOutputStream(suProcess.getOutputStream());
   
10.             DataInputStream osRes = new DataInputStream(suProcess.getInputStream());
    
11. 
    
12.             if (null != os && null != osRes) {
    
13.                 // Getting the id of the current user to check if this is root
    
14.                 os.writeBytes("id\n");
    
15.                 os.flush();
    
16. 
    
17.                 String currUid = osRes.readLine();
    
18.                 boolean exitSu = false;
    
19.                 if (null == currUid) {
    
20.                     retval = false;
    
21.                     exitSu = false;
    
22.                     Log.d("ROOT", "Can't get root access or denied by user");
    
23.                 } else if (true == currUid.contains("uid=0")) {
    
24.                     retval = true;
    
25.                     exitSu = true;
    
26.                     Log.d("ROOT", "Root access granted");
    
27.                 } else {
    
28.                     retval = false;
    
29.                     exitSu = true;
    
30.                     Log.d("ROOT", "Root access rejected: " + currUid);
    
31.                 }
    
32. 
    
33.                 if (exitSu) {
    
34.                     os.writeBytes("exit\n");
    
35.                     os.flush();
    
36.                 }
    
37.             }
    
38.         } catch (Exception e) {
    
39.             // Can't get root !
    
40.             // Probably broken pipe exception on trying to write to output
    
41.             // stream after su failed, meaning that the device is not rooted
    
42. 
    
43.             retval = false;
    
44.             Log.d("ROOT",
    
45.                     "Root access rejected [" + e.getClass().getName() + "] : " + e.getMessage());
    
46.         }
    
47. 
    
48.         return retval;
    
49.     }
    
50. 
    

复制代码

可以发现是成功的