Android应用向su申请root权限，以及Superuser进行授权管理的原理浅析

最近研究了好几天su+Superuser的源码，感觉大概梳理通了整个大体的思路框架，mark一下。 

一.su和Suepruser进行root授权的处理流程

对于su命令行程序在对来自Android应用的Root权限请求处理流程大致如下图所示（因为快要找工作了，为了节约时间花了一副丑到哭的图片）：

图中Android应用是申请Root权限的申请者，su命令行程序时Root权限拥有者，因su设置了suid位，因此任何执行它的进程都会获得和它一样的权限，这个好像在之前的文章中提到过，其实细节上并非这么容易，和Superuser用户权限管理apk结合起来使用的话还会有一些仲裁的过程。

描述起来就是：

1.Android应用调用su程序，来申请root权限；

2.su启动LocalSocket服务，LocalSocket的功能和通常我们进程通信的Socket类似，其实是在本地共享一块内存来实现和本地其他进程之间进行通信的Socket服务；

3.su命令行程序通过am命令请求显示Superuser应用的RequestActivity窗口，这个窗口里面显示哪个uid的和user的应用申请权限；

4.Superuser连接到由su进程建立的LocalSocket服务上，至此LocalSocket连接成功，之后进程和Superuser对应的进程可以通过这个LocalSocket来进行信息传递了；

5.LocalSocket的数据通道成功连接库，su程序通过socket传递调用者（申请root权限的Android应用）的一些信息。

6.Superuser将用户的仲裁结果数据返回给su程序，如果用户允许授权则，则 ALLOW root授权，反之DENY。（其中还有用户在一定时间内未作出选择的情况，默认为DENY）

这是从Android应用申请root权限到su和Superuser配合实现用户选择后的仲裁的整个过程。

下面我一步一步分析一下这些过程中的细节

二：从su的main函数开始，分析细节

因为su是一个linux命令行程序，故我们首先在Superuser的源码的jni目录下找到su.c文件，定位到main函数处：

main函数中主要完成了三个主要的工作：

  1.初始化调用者数据和效验
| 1)获取调用者调用su命令的命令行参数-from_init函数
| 2)获取su命令的链接路径-user_init函数
| 3)获取调用者的名称 
  2.通过SQLlite数据库检查申请“Root授权”的Android应用程序是否还需要进一步效验
  3.建立LocalSocket服务，并进行相应的数据通信

由于代码比较长，而且联系紧密因此在源码中我对相应的部分进行了注释，建议下载后面我给出的注释后的源码来对照理解，如果你懒得下，没关系，相关的长长的代码我给你贴上老 ~~

int main(int argc, char *argv[]) {
    // Sanitize all secure environment variables (from linker_environ.c in AOSP linker).
    /* The same list than GLibc at this point */
    static const char* const unsec_vars[] = {
        "GCONV_PATH",
        "GETCONF_DIR",
        "HOSTALIASES",
        "LD_AUDIT",
        "LD_DEBUG",
        "LD_DEBUG_OUTPUT",
        "LD_DYNAMIC_WEAK",
        "LD_LIBRARY_PATH",
        "LD_ORIGIN_PATH",
        "LD_PRELOAD",
        "LD_PROFILE",
        "LD_SHOW_AUXV",
        "LD_USE_LOAD_BIAS",
        "LOCALDOMAIN",
        "LOCPATH",
        "MALLOC_TRACE",
        "MALLOC_CHECK_",
        "NIS_PATH",
        "NLSPATH",
        "RESOLV_HOST_CONF",
        "RES_OPTIONS",
        "TMPDIR",
        "TZDIR",
        "LD_AOUT_LIBRARY_PATH",
        "LD_AOUT_PRELOAD",
        // not listed in linker, used due to system() call
        "IFS",
    };
    const char* const* cp   = unsec_vars;
    const char* const* endp = cp + sizeof(unsec_vars)/sizeof(unsec_vars[0]);
    while (cp < endp) {
        unsetenv(*cp);
        cp++;
    }

    /*
     * set LD_LIBRARY_PATH if the linker has wiped out it due to we're suid.
     * This occurs on Android 4.0+
     */
    setenv("LD_LIBRARY_PATH", "/vendor/lib:/system/lib", 0);

    LOGD("su invoked.");
//  第一阶段主要是进行一些初始化和效验
// stx 这个结构体定义了三个成员：from、to和user 表示su调用的上下文
    struct su_context ctx = {
        .from = {
            .pid = -1,
            .uid = 0,
            .bin = "",
            .args = "",
            .name = "",
        },
        .to = {
            .uid = AID_ROOT,
            .login = 0,
            .keepenv = 0,
            .shell = NULL,
            .command = NULL,
            .argv = argv,
            .argc = argc,
            .optind = 0,
            .name = "",
        },
        .user = {
            .android_user_id = 0,
            .multiuser_mode = MULTIUSER_MODE_OWNER_ONLY,
            .database_path = REQUESTOR_DATA_PATH REQUESTOR_DATABASE_PATH,
            .base_path = REQUESTOR_DATA_PATH REQUESTOR
        },
    };
    struct stat st;
    int c, socket_serv_fd, fd;//LocalSocket的句柄
    char buf[64], *result;
    policy_t dballow;
    struct option long_opts[] = {
        { "command",            required_argument,    NULL, 'c' },
        { "help",            no_argument,        NULL, 'h' },
        { "login",            no_argument,        NULL, 'l' },
        { "preserve-environment",    no_argument,        NULL, 'p' },
        { "shell",            required_argument,    NULL, 's' },
        { "version",            no_argument,        NULL, 'v' },
        { NULL, 0, NULL, 0 },
    };

    while ((c = getopt_long(argc, argv, "+c:hlmps:Vvu", long_opts, NULL)) != -1) {
        switch(c) {
        case 'c':
            ctx.to.shell = DEFAULT_SHELL;
            ctx.to.command = optarg;
            break;
        case 'h':
            usage(EXIT_SUCCESS);
            break;
        case 'l':
            ctx.to.login = 1;
            break;
        case 'm':
        case 'p':
            ctx.to.keepenv = 1;
            break;
        case 's':
            ctx.to.shell = optarg;
            break;
        case 'V':
            printf("%d\n", VERSION_CODE);
            exit(EXIT_SUCCESS);
        case 'v':
            printf("%s\n", VERSION);
            exit(EXIT_SUCCESS);
        case 'u':
            switch (get_multiuser_mode()) {
            case MULTIUSER_MODE_USER:
                printf("%s\n", MULTIUSER_VALUE_USER);
                break;
            case MULTIUSER_MODE_OWNER_MANAGED:
                printf("%s\n", MULTIUSER_VALUE_OWNER_MANAGED);
                break;
            case MULTIUSER_MODE_OWNER_ONLY:
                printf("%s\n", MULTIUSER_VALUE_OWNER_ONLY);
                break;
            case MULTIUSER_MODE_NONE:
                printf("%s\n", MULTIUSER_VALUE_NONE);
                break;
            }
            exit(EXIT_SUCCESS);
        default:
            /* Bionic getopt_long doesn't terminate its error output by newline */
            fprintf(stderr, "\n");
            usage(2);
        }
    }
    if (optind < argc && !strcmp(argv[optind], "-")) {
        ctx.to.login = 1;
        optind++;
    }
    /* username or uid */
    if (optind < argc && strcmp(argv[optind], "--")) {
        struct passwd *pw;
        pw = getpwnam(argv[optind]);
        if (!pw) {
            char *endptr;

            /* It seems we shouldn't do this at all */
            errno = 0;
            ctx.to.uid = strtoul(argv[optind], &endptr, 10);
            if (errno || *endptr) {
                LOGE("Unknown id: %s\n", argv[optind]);
                fprintf(stderr, "Unknown id: %s\n", argv[optind]);
                exit(EXIT_FAILURE);
            }
        } else {
            ctx.to.uid = pw->pw_uid;
            if (pw->pw_name)
                strncpy(ctx.to.name, pw->pw_name, sizeof(ctx.to.name));
        }
        optind++;
    }
    if (optind < argc && !strcmp(argv[optind], "--")) {
        optind++;
    }
    ctx.to.optind = optind;

    su_ctx = &ctx;
    
    
    //  初始化from调用者的信息，主要是调用者的用户ID
    if (from_init(&ctx.from) < 0) {
        deny(&ctx);
    }
        
    read_options(&ctx);
    user_init(&ctx);

    // the latter two are necessary for stock ROMs like note 2 which do dumb things with su, or crash otherwise
    if (ctx.from.uid == AID_ROOT) {//如果Android应用已经是root权限，就直接允许其获取root权限
        LOGD("Allowing root/system/radio.");
        allow(&ctx);
    }
    // 校验superuser是否安装。
    // verify superuser is installed
    if (stat(ctx.user.base_path, &st) < 0) {
        // send to market (disabled, because people are and think this is hijacking their su)
        // if (0 == strcmp(JAVA_PACKAGE_NAME, REQUESTOR))
        //     silent_run("am start -d http://www.clockworkmod.com/superuser/install.html -a android.intent.action.VIEW");
        PLOGE("stat %s", ctx.user.base_path);
        deny(&ctx);
    }



    // always allow if this is the superuser uid
    // superuser needs to be able to reenable itself when disabled...
    if (ctx.from.uid == st.st_uid) {//如果调用者就是Superuser，那么直接授予root权限。
        allow(&ctx);
    }

    // check if superuser is disabled completely
    if (access_disabled(&ctx.from)) {
        LOGD("access_disabled");
        deny(&ctx);
    }

    // autogrant shell at this point
    if (ctx.from.uid == AID_SHELL) {
        LOGD("Allowing shell.");
        allow(&ctx);
    }

    // deny if this is a non owner request and owner mode only
    if (ctx.user.multiuser_mode == MULTIUSER_MODE_OWNER_ONLY && ctx.user.android_user_id != 0) {
        deny(&ctx);
    }

    ctx.umask = umask(027);
    // 在/dev目录下创建一个用于LocalSocket缓存的目录，LocalSocket实际通过内存来传递数据
    int ret = mkdir(REQUESTOR_CACHE_PATH, 0770);
    if (chown(REQUESTOR_CACHE_PATH, st.st_uid, st.st_gid)) {
        PLOGE("chown (%s, %ld, %ld)", REQUESTOR_CACHE_PATH, st.st_uid, st.st_gid);
        deny(&ctx);
    }

    if (setgroups(0, NULL)) {
        PLOGE("setgroups");
        deny(&ctx);
    }
    if (setegid(st.st_gid)) {
        PLOGE("setegid (%lu)", st.st_gid);
        deny(&ctx);
    }
    if (seteuid(st.st_uid)) {
        PLOGE("seteuid (%lu)", st.st_uid);
        deny(&ctx);
    }
    //  第二阶段：检查申请“Root授权”的Android应用程序是否还需要进一步效验
    dballow = database_check(&ctx);//核对数据库,如果数据库中已经显示授予Root权限就直接授予，拒绝过就直接拒绝
	//database_check文件是在db.c文件中实现的
    switch (dballow) {
        case INTERACTIVE:
            break;
        case ALLOW:
            LOGD("db allowed");
            allow(&ctx);    /* never returns */
        case DENY:
        default:
            LOGD("db denied");
            deny(&ctx);        /* never returns too */
    }
    //  第三阶段：建立LocalSocket服务，并进行相应的数据通信
    socket_serv_fd = socket_create_temp(ctx.sock_path, sizeof(ctx.sock_path));//根据dev下的路径创建LocalSocket服务
    LOGD(ctx.sock_path);
    if (socket_serv_fd < 0) {//如果LocalSocket创建失败就直接拒绝授权
        deny(&ctx);
    }

    signal(SIGHUP, cleanup_signal);
    signal(SIGPIPE, cleanup_signal);
    signal(SIGTERM, cleanup_signal);
    signal(SIGQUIT, cleanup_signal);
    signal(SIGINT, cleanup_signal);
    signal(SIGABRT, cleanup_signal);

    if (send_request(&ctx) < 0) { //通过am命令向Superuser发送命令，请求显示RequestActivity窗口
        deny(&ctx);
    }

    atexit(cleanup);

    fd = socket_accept(socket_serv_fd);//等待Superuser的连接  
	//一点Superuser已经连接到su命令建立的LocalSocket上，数据传输就不必再使用am命令了，直接通过数据流传输即可
    if (fd < 0) {
        deny(&ctx);
    }
    if (socket_send_request(fd, &ctx)) {//连接成功后，通过已连接的Socket向Superuser发送调用者的信息
        deny(&ctx);
    }
    if (socket_receive_result(fd, buf, sizeof(buf))) {//接收用户在Superuser的选择窗口中进行的授权选择
        deny(&ctx);
    }

    close(fd);
    close(socket_serv_fd);
    socket_cleanup(&ctx);

    result = buf;

#define SOCKET_RESPONSE    "socket:" // socket:ALLOW
    if (strncmp(result, SOCKET_RESPONSE, sizeof(SOCKET_RESPONSE) - 1))
        LOGW("SECURITY RISK: Requestor still receives credentials in intent");
    else
        result += sizeof(SOCKET_RESPONSE) - 1;//让result指针指向“Socket：”后面的数据
    if (!strcmp(result, "DENY")) {
        deny(&ctx);
    } else if (!strcmp(result, "ALLOW")) {
        allow(&ctx);
    } else {
        LOGE("unknown response from Superuser Requestor: %s", result);
        deny(&ctx);
    }
}
/*到现在为止，我们已经了解了su命令和Superuser在授权root权限时，su端的工作原理，
但是su.c文件中的两个函数allow()和deny()的具体实现我们还没有看到,这两个函数才是
最终允许或拒绝root权限授权的关键/*

这里面主要涉及到两个初始化函数from_init和user_init,以及一个描述su调用上下文的结构体su_context。

main函数中首先进行的是调用者信息的初始化工作即from_init函数的功能

static int from_init(struct su_initiator *from) {
    char path[PATH_MAX], exe[PATH_MAX];
    char args[4096], *argv0, *argv_rest;//argv_rest指向真正的su命令行参数的信息
    int fd;
    ssize_t len;
    int i;
    int err;

    from->uid = getuid();//获取实际的用户ID，用于标识Android App（调用者）
    from->pid = getppid();//获取调用进程的父进程ID

    /* Get the command line */
    snprintf(path, sizeof(path), "/proc/%u/cmdline", from->pid);//获得su调用时的命令行参数
    fd = open(path, O_RDONLY);
    if (fd < 0) {
        PLOGE("Opening command line");
        return -1;
    }
    len = read(fd, args, sizeof(args));
    err = errno;
    close(fd);
    if (len < 0 || len == sizeof(args)) {
        PLOGEV("Reading command line", err);
        return -1;
    }
    //  su \0  a  \0  b  \0 c
    //  su \0  a  ' ' b  ' ' c \0   （\0表示字符串结束）
    argv0 = args;   // 指向了第一个命令行参数，也就是su
    argv_rest = NULL;
    for (i = 0; i < len; i++) { //len表示总体的命令行长度
        if (args[i] == '\0') {//从第一个 \0开始，获取命令行参数到argv_rest
            if (!argv_rest) {
                argv_rest = &args[i+1];
            } else {
                args[i] = ' ';
            }
        }
    }
    args[len] = '\0';

    if (argv_rest) {
        strncpy(from->args, argv_rest, sizeof(from->args));//将命令行参数放入调用者信息from->args中
        from->args[sizeof(from->args)-1] = '\0';
    } else {
        from->args[0] = '\0';
    }

    /* If this isn't app_process, use the real path instead of argv[0] */
    snprintf(path, sizeof(path), "/proc/%u/exe", from->pid);
    len = readlink(path, exe, sizeof(exe));
    if (len < 0) {
        PLOGE("Getting exe path");
        return -1;
    }
    exe[len] = '\0';
    if (strcmp(exe, "/system/bin/app_process")) {
        argv0 = exe;
    }

    strncpy(from->bin, argv0, sizeof(from->bin));
    from->bin[sizeof(from->bin)-1] = '\0';

    struct passwd *pw;
    pw = getpwuid(from->uid);
    if (pw && pw->pw_name) {
        strncpy(from->name, pw->pw_name, sizeof(from->name));
    }

    return 0;
}

其中包括获得调用者执行su时的命令行参数uid等操作。对照注释看吧。

main函数中第二个主要完成的工作就是：检查申请“Root”授权的Android应用程序是否还需要进一步的效验。然后在本地SQLite数据库中进行查询，如果数据库中显示授予root权限就直接

授予root权限，拒绝过就直接拒绝，如果没有记录就进入到下一阶段，和Superuser进行通信，然后Superuser接收到用户的选择后将选择数据传回到su程序中来决定是否授予新申请root权限的Android应用Roo权限。

main中完成的第三个主要的主要工作就是建立本地LocalSocket服务，等待Superuser的连接，当连接成功后传递调用者信息即初始化后的su_context结构体，Superuser在收到调用者的信息后显示出来让用户仲裁是否授予权限，最后将用户选择回传到su程序，su根据结果来执行deny（）或者allow()函数。

三：允许或拒绝root权限授权的关键allow（）函数和deny（）函数

到现在为止，我们已经了解了su命令和Superuser在授权root权限时，su端的工作原理，但是su.c文件中的两个函数allow()和deny()的具体实现我们还没有看到,这两个函数才是
最终允许或拒绝root权限授权的关键：

static __attribute__ ((noreturn)) void deny(struct su_context *ctx) {
    char *cmd = get_command(&ctx->to);

    int send_to_app = 1;

    // no need to log if called by root
    if (ctx->from.uid == AID_ROOT)
        send_to_app = 0;

    // dumpstate (which logs to logcat/shell) will spam the crap out of the system with su calls
    if (strcmp("/system/bin/dumpstate", ctx->from.bin) == 0)
        send_to_app = 0;

    if (send_to_app)
        send_result(ctx, DENY);

    LOGW("request rejected (%u->%u %s)", ctx->from.uid, ctx->to.uid, cmd);
    fprintf(stderr, "%s\n", strerror(EACCES));
    exit(EXIT_FAILURE);
}

static __attribute__ ((noreturn)) void allow(struct su_context *ctx) {
    char *arg0;
    int argc, err;

    umask(ctx->umask);
    int send_to_app = 1;

    // no need to log if called by root
    if (ctx->from.uid == AID_ROOT)
        send_to_app = 0;

    // dumpstate (which logs to logcat/shell) will spam the crap out of the system with su calls
    if (strcmp("/system/bin/dumpstate", ctx->from.bin) == 0)
        send_to_app = 0;

    if (send_to_app)
        send_result(ctx, ALLOW);//向Superuser回发信息，表明授权成功，这个函数在activity.c中。
		//在socket连接关闭时，是通过am命令传递信息到Superuser的。

    char *binary;
    argc = ctx->to.optind;
    if (ctx->to.command) {
        binary = ctx->to.shell;
        ctx->to.argv[--argc] = ctx->to.command;
        ctx->to.argv[--argc] = "-c";
    }
    else if (ctx->to.shell) {
        binary = ctx->to.shell;
    }
    else {
        if (ctx->to.argv[argc]) {
            binary = ctx->to.argv[argc++];
        }
        else {
            binary = DEFAULT_SHELL;
        }
    }

    arg0 = strrchr (binary, '/');
    arg0 = (arg0) ? arg0 + 1 : binary;
    if (ctx->to.login) {
        int s = strlen(arg0) + 2;
        char *p = malloc(s);

        if (!p)
            exit(EXIT_FAILURE);

        *p = '-';
        strcpy(p + 1, arg0);
        arg0 = p;
    }

    populate_environment(ctx);
    set_identity(ctx->to.uid);

#define PARG(arg)                                    \
    (argc + (arg) < ctx->to.argc) ? " " : "",                    \
    (argc + (arg) < ctx->to.argc) ? ctx->to.argv[argc + (arg)] : ""

    LOGD("%u %s executing %u %s using binary %s : %s%s%s%s%s%s%s%s%s%s%s%s%s%s",
            ctx->from.uid, ctx->from.bin,
            ctx->to.uid, get_command(&ctx->to), binary,
            arg0, PARG(0), PARG(1), PARG(2), PARG(3), PARG(4), PARG(5),
            (ctx->to.optind + 6 < ctx->to.argc) ? " ..." : "");

    ctx->to.argv[--argc] = arg0;
    execvp(binary, ctx->to.argv + argc);
    err = errno;
    PLOGE("exec");
    fprintf(stderr, "Cannot execute %s: %s\n", binary, strerror(err));
    exit(EXIT_FAILURE);
}

其中

execvp(binary, ctx->to.argv + argc);//这一句才是前面各种效验仲裁的允许获得root权限的最终核心的执行代码。

我在这儿就不一行一行的讲解了，其实有的细节部分要结合其他文件中的内容进行理解，大家有兴趣的话可以阅读源码。我有时间进行更深刻的理解的话，会持续更新的。也欢迎大家和我交流。

Superuser源码下载链接：http://download.csdn.net/detail/koozxcv/9487931