Android Shizuku源码分析 第二篇

又是前言

上一篇的 Shizuku 源码分析,我大概从我们开发的应用到 ShizukuService 再到 SystemService 都通了一遍。在文章的结尾我只提到了 moe.shizuku.service 包下的 Starter 这个 Java 类的 main 方法启动了整个 ShizukuService ,所以我们才能愉快地调用 Shizuku 的 API。

我们接下来要更深入分析,去 Navtive 层看看。我想要知道 Starter 的 main 方法又是谁调用的?怎么调用的?

Shizuku 是什么?我就不再多说了。

Github: https://github.com/RikkaApps/Shizuku

(之后会简单涉及到 Android 中的 NDK 开发,和一些 C++ 的内容)

start.sh

当用户使用 ShizukuManager ,通过 ShizukuManager 激活应用时,需要先启动 ShizukuService 。

这里有 adb 和 root 两种启动方式,我们只分析 adb 方式。

1
adb shell sh /sdcard/Android/data/moe.shizuku.privileged.api/files/start.sh

这条 adb 命令想必用过 ShizukuManager 的人都很熟悉吧?只要在 adb 终端输入这条命令,就能激活 ShizukuManager。

这条命令很简单,就是调用 sh 脚本 start.sh 。这个 start.sh 在源码中 manager 模块的 raw 文件夹中:

这个 shell 脚本的内容是什么我们等会再看,我们先要知道 ShizukuManager 这个 APP 在启动时干了什么 ,看看 Manager 的 MainActivity 的 onCreate 方法:

1
2
3
4
5
6
7
8
9
  private static boolean sWriteFilesCalled;

@Override
protected void onCreate(Bundle savedInstanceState) {
if (!sWriteFilesCalled) {
ServerLauncher.writeFiles(this, true);
sWriteFilesCalled = true;
}
}

这里调用了 ServiceLauncher 的 writeFiles 方法,让我们来康康:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public static void writeFiles(Context context, boolean external) {
// 从 MainActivity 传入的 external 是 true
try {
File out;
if (external)
// 执行这里,得到 /sdcard/Android/data/com.example.app/files/
out = context.getExternalFilesDir(null);
else
out = getParent(context);

if (out == null)
return;
int apiVersion = Math.min(ShizukuLegacy.MAX_SDK, Build.VERSION.SDK_INT);
String source = String.format(Locale.ENGLISH, "server-v2-%d.dex", apiVersion);
// 此时 i 为 1
int i = external ? 1 : 0;

// copyDex
DEX_LEGACY_PATH[i] = copyDex(context, source, new File(out, V2_DEX_NAME));
DEX_PATH[i] = copyDex(context, "server.dex", new File(out, V3_DEX_NAME));
// 注意注意这个 writeShellFile 方法
String command = writeShellFile(context, new File(out, "start.sh"), DEX_LEGACY_PATH[i], DEX_PATH[i]);
// external 为 true ,不执行
if (!external) {
COMMAND_ROOT = command;
}
} catch (IOException e) {
e.printStackTrace();
}
}

看到 writeShellFile 这个方法了吗?里面的参数是一个 File 类和一个 “start.sh”,还有两个 dex 文件路径。

继续看 ServiceLauncher#writeShellFile:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private static String writeShellFile(Context context, File out, String dexLegacy, String dex) throws IOException {
if (!out.exists()) {
//noinspection ResultOfMethodCallIgnored
out.createNewFile();
}

BufferedReader is = new BufferedReader(new InputStreamReader(context.getResources().openRawResource(R.raw.start)));
PrintWriter os = new PrintWriter(new FileWriter(out));
String line;
while ((line = is.readLine()) != null) {
// 这里将 start.sh 写出,并把 start.sh 的那些文字替换成路径值。
os.println(line
.replace("%%%STARTER_PATH%%%", getLibPath(context, "libshizuku.so"))
.replace("%%%STARTER_PARAM%%%", getStarterParam(dexLegacy, dex))
.replace("%%%LIBRARY_PATH%%%", getLibPath(context, "libhelper.so"))
);
}
os.flush();
os.close();

return "sh " + out.getAbsolutePath();
}

还记得我们之前看的那个 start.sh 的内容吗?这里实际上就是把 raw 内的 start.sh 写出放到 /sdcard/Android/data/moe.shizuku.privileged.api/files。

这就是为什么那条激活用的 adb 命令能够执行:

1
adb shell sh /sdcard/Android/data/moe.shizuku.privileged.api/files/start.sh

看到了吗?如果你安装了 ShizukuManager 并打开了,你可以在 /sdcard/Android/data/moe.shizuku.privileged.api/files 目录里找到这个 start.sh 和两个 dex 文件。

这俩 dex 文件就是通过 ServiceLauncher#writeFiles 用 copyDex 方法把 assets 的 dex 写出到SD目录。

同时 start.sh 中的那开头的三个变量也在写出的时候被 ShizukuManager 替换了:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#!/system/bin/sh

// 这三个变量在 ShizukuManager 写出时被替换了
STARTER_PATH="%%%STARTER_PATH%%%" // 对应 libshizuku.so 文件路径
STARTER_PARAM="%%%STARTER_PARAM%%%" // 对应调用 main 函数的参数,里面包含了那两个 dex 文件的路径和 token
LIBRARY_PATH="%%%LIBRARY_PATH%%%" // 对应 libhelper.so 文件路径

echo "info: start.sh begin"

if [[ -f "$STARTER_PATH" ]]; then
rm -f /data/local/tmp/shizuku_starter
// 将 libshizuku.so 文件移动到
// 实际上 /data/local/tmp/ 下的 shizuku_starter 文件就是 libshizuku.so 文件
cp "$STARTER_PATH" /data/local/tmp/shizuku_starter
// 修改权限
chmod 700 /data/local/tmp/shizuku_starter
chown 2000 /data/local/tmp/shizuku_starter
chgrp 2000 /data/local/tmp/shizuku_starter
// 这似乎是在修改 Selinux 啥的什么东西的啥子命令
chcon u:object_r:shell_data_file:s0 /data/local/tmp/shizuku_starter

// 设置环境变量
export PATH=/data/local/tmp:/system/bin:$PATH
// 调用 shizku_starter so文件(原来是 libshizuku.so)的 main 方法,传入参数
shizuku_starter ${STARTER_PARAM} $1
// 返回上 shizuku_starer 内 main 函数的返回值
result=$?
if [[ ${result} -ne 0 ]]; then
echo "info: shizuku_starter exit with non-zero value $result"
else
echo "info: shizuku_starter exit with 0"
fi
else
echo "Starter file not exist, please open Shizuku Manager and try again."
fi

当我们输入那条用来激活 ShizukuManager 的 adb 命令时候,输出框会噼里啪啦滚出一大堆输出。那些输出是哪里来的?很明显在 start.sh 中没有几条 echo 命令,只能是在 shizuku_starter 的 main 方法里有什么大动作。

这个 libshizuku.so 文件的原身你可以在 ShizukuManager 源码中的 jni 文件夹中找到,文件名是 starter.cpp。

没错,它是一个 C++ 文件,我们看看它的 main 方法(我会适当地跳过一些与主题无关的代码):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#define SERVER_CLASS_PATH_LEGACY "moe.shizuku.server.ShizukuServer"
#define SERVER_CLASS_PATH "moe.shizuku.server.Starter"

int main(int argc, char **argv) {
// argc 是传进来的参数的数量,argv是传入的参数的数组。里面包含了 token, 两个 dec 文件的路径
...
char *token = nullptr;
char *_path = nullptr;
char *_path_legacy = nullptr;
int v2 = 1;
int i;
int use_shell_context = 0;

// for 循环,可以看到这是在取出参数
for (i = 0; i < argc; ++i) {
if (strncmp(argv[i], "--token=", 8) == 0) {
token = strdup(argv[i] + 8);
} else if (strncmp(argv[i], "--path=", 7) == 0) {
_path = strdup(argv[i] + 7);
} else if (strncmp(argv[i], "--path-legacy=", 14) == 0) {
_path_legacy = strdup(argv[i] + 14);
} else if (strncmp(argv[i], "--no-v2", 7) == 0) {
v2 = 0;
} else if (strncmp(argv[i], "--use-shell-context", 19) == 0) {
use_shell_context = 1;
}
}
...

// check_acess 会调用 acess 函数判断路径是否有读写权限
check_access(_path, "source dex path");
if (v2) check_access(_path_legacy, "source legacy dex path");

// 这里我是没看懂的,不知道为什么又建了一个 /data/local/tmp/shizuku 文件夹,将之前 _path 内的文件全部移动到了 path 这个路径里。
mkdir("/data/local/tmp/shizuku", 0707);
chmod("/data/local/tmp/shizuku", 0707);

...

// 一个 char 数组,也就相当于一个 string
char path[PATH_MAX], path_legacy[PATH_MAX];
// 格式化字符,也就是为 path 赋值了
sprintf(path, "/data/local/tmp/shizuku/%s", basename(_path));
sprintf(path_legacy, "/data/local/tmp/shizuku/%s", basename(_path_legacy));

// 开始复制了,将 _path 路径下的两个 dex 移动到 path 路径
copy_if_not_exist(_path, path);
if (v2) copy_if_not_exist(_path_legacy, path_legacy);

check_access(path, "dex path");
if (v2) check_access(path_legacy, "legacy dex path");

printf("info: starter begin\n");
// 强制输出缓冲区的信息,就是为了快速输出上面的 printf 内容啦
fflush(stdout);
...

printf("info: starting server v3...\n");
fflush(stdout);
// 我们重点分析这个 start_service 函数,传入 SERVICE_CLASS_PATH 这个常量,值为 "moe.shizuku.server.Starter",熟悉吗?这就是在应用层的主角啊,用于启动 ShizukuService 的 Java 类。
start_server(path, SERVER_CLASS_PATH, token, SERVER_NAME, use_shell_context);

if (v2) {
printf("info: starting server v2 (legacy)...\n");
fflush(stdout);
start_server(path_legacy, SERVER_CLASS_PATH_LEGACY, token, SERVER_NAME_LEGACY, false);
}

exit_with_logcat(EXIT_SUCCESS);
// starter.cpp 结束
}

注释上已经大概地说了一遍,我们接下来看 start_service 函数,同样 start_service 也是 starter.cpp 中的一个函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
static int start_server(const char *path, const char *main_class, const char *token,
const char *nice_name, int change_context) {
...
/* 省略了很多内容,详细可自己去看看 Shizuku 的源码 */
char buf[128], class_path[PATH_MAX];
sprintf(buf, "--nice-name=%s", nice_name);
setClasspathEnv(path);
snprintf(class_path, PATH_MAX, "-Djava.class.path=%s", path);

char *appProcessArgs[] = {
// app_process 是 Android 里专门用来启动 Java 程序的
const_cast<char *>("/system/bin/app_process"),
class_path,
const_cast<char *>("/system/bin"),
const_cast<char *>(buf),
// main_class 值为 "moe.shizuku.server.Starter"
const_cast<char *>(main_class),
const_cast<char *>(token),
nullptr
};
// 调用 app_process 去运行 main_class
if (execvp(appProcessArgs[0], appProcessArgs)) {
exit_with_logcat(EXIT_FATAL_APP_PROCESS);
}
...
}

到这里我们的分析已经差不多了。

我们再仔细说说 app_process 的内容:

调用 app_process 的话,你需要在参数中提供 dex 文件,同时必须要使 dex 文件有执行权限

1
app_process -Djava.class.path=dex文件名 dex所处的目录路径 你要启动的 Java 类(有类名和包名)

我找来了一个参数列表:

1
2
3
4
5
6
7
8
9
vm-options – VM 选项
cmd-dir –父目录 (/system/bin)
options –运行的参数 :
–zygote
–start-system-server
–application (api>=14)
–nice-name=nice_proc_name (api>=14)
start-class-name –包含main方法的主类 (com.android.commands.am.Am)
main-options –启动时候传递到main方法中的参数

小总结

用户通过输入一条 adb 命令去执行 start.sh 文件,start.sh 文件会执行 ShizukuManager 早已准备好的 so 文件。在 so 文件中经过一大堆操作,会通过 app_process 运行 Starter 类的 main 方法,而 Starter 这个 Java 类的 main 方法会直接 new 一个 ShizukuService 使它跑起来。

看了一上午的代码,翘了一上午的在铛铛的网络课。

尼玛,都延长假期了和上个屎的网络课。

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×