【Android笔记】执行命令行语句

一、Android的root原理

由于不少命令需要root权限，所以先学习一下相关知识

下面文字整理自Kevin大神的回答：http://www.zhihu.com/question/21074979/answer/18176410

Android的内核就是Linux，所以Android获取root其实和Linux获取root权限是一回事儿。

你想在Linux下获取root权限的时候就是执行sudo或者su，接下来系统会提示你输入root用户的密码，密码正确就获得root权限了。Android本身就不想让你获得Root权限，大部分手机出厂的时候根本就没有su这个程序。所以你想获得Android的root权限，第一步就是要把编译好的su文件拷贝到Android手机的/system/bin或者/system/xbin/目录下。我们先假设你可以把su放在xbin下，接下来你可以在Android手机的adb shell或者串口下输入su了。

Linux下su以后输入密码就可以root了，但Android里的su和Linux里的su是不一样的，Android里的su不是靠验证密码的，而是看你原来的权限是什么。意思就是如果你是root，那你可以通过su切换到别的用户，比如说shell,wifi,audio什么的。但如果你是root之外的其他用户，就不能切换回root了，会提示你permission denied。

也就说用root运行su才有用，但我这个时候还没有root怎么办呢？这就涉及到另外个问题。

一般我们在Linux的console下输入 ls -l 会列出所有文件的权限。

比如：-rwxr-xr-x，用过Linux的人都知道r代表该文件可读，w代表可写，x代表可执行，-就代表没有该权限。第一个rwx代表文件所有者的权限，第二个rwx代表和所有者同组人的权限，第三个rwx代表其他用户对该文件的权限。但下面这个文件就比较特殊。



rws，它的执行权限标志位是一个s，s代表当任何一个用户执行该文件的时候都拥有文件所有者的权限，这文件的所有者是root，简单点说就是不管谁执行这个文件，他执行的时候都是以root身份执行的。

也就说即使我不是root也有可能以root身份来执行程序，那么我就把一个所有者是root的su程序权限标志位置成-rwsr-xr-x，那么不管谁执行它，都是root身份执行，su就可以顺利执行成功了，执行成功之后我就是root身份了。

问题都清楚了，就是你需要把一个所有者是root的su拷贝到Android手机上，并且把su的权限标志位置成-rwsr-xr-x。能把这个事情搞定你就成功root了一个手机。

大概意思就是几行代码

<span style="font-family:SimSun;font-size:12px;">cp /data/tmp/su /system/bin/  # copy su 到/system/分区
chown root:root su            # su的所有者置成root
chmod 4775 /system/bin/su     # 把su置成-rwsr-xr-x</span>

熟悉Android的同学都知道，执行上面的每一行代码都需要root权限才能成功。

意思就是说，你只有有root权限的情况下才能执行上面两行代码，而这两行代码就是为了让你获得root权限的，这是一个逻辑闭环，那么如何打破这个逻辑闭环呢？

一个办法就是找一个本身已经有root权限的进程来启动我上面的两行代码，那我这两行代码一启动就是root权限，就可以顺利执行了。但是已经有root权限的进程都是出厂时候就装到手机上的，代码写死了，你没法控制它执行你自己的代码啊。这个时候就需要你找漏洞了，比如用来破解Android2.3 root权限的zergRush漏洞就是利用一个拥有root权限的进程栈溢出漏洞。

（知乎张炬补充）栈溢出的成因是向栈复制数据的时候没有考虑缓冲区的大小，导致缓冲区后面的内存空间被覆盖，这时就形成了一个栈溢出漏洞。

举个栗子，程序申请了一个100字节大小的数组用来存放用户输入的数据，但是用户输入了150个字节的数据，如果没有检查数组长度就向数组中存储，多出来的50个字节就会覆盖这个数组后面的内存空间。倘若后面的内存中存储了一个函数指针，用户就可以精心控制数据长度和内容，用另外一个地址覆盖这个函数指针（指针实际存储的就是一个内存地址）。等到程序使用这个函数指针调用函数时，会跳到用户指定的地址处执行指令（函数就是一段指令序列），用户就劫持了程序的执行流程。root的时候，先在内存里写入提权指令，然后利用上面的方式劫持程序执行它们就可以了。

如果各位有一定基础，能看懂我上面讲的，就基本知道root的原理其实并不难，难点在于找到漏洞。

zergRush的代码在这儿：

revolutionary/zergRush · GitHub

有兴趣的可以看看，网上也有很多分析文章。

另外iphone的越狱其实和Android的root是一回事儿，都是越权操作。所以越狱的方式也都差不多，也是找IOS自带程序的漏洞，只不过IOS安全性强一点，所以也比较难找。如果你发现你的iphone的某个自带程序经过一些特定操作会出现系统崩溃重启的现象，并且是可以复现的，那就很有可能可以用来越狱了。

好像是IOS6出来的时候，由于比较难搞，某个越狱团队就号召大家来找茬，发现的漏洞可以报告给他们用来越狱。说明IOS越狱越来越难。直接体现就是现在越狱需要的时间越来越长。

不过如果你发现漏洞也可以报告给苹果，苹果会根据漏洞严重程度给予一定奖励。我记得看新闻说南非一个家伙靠给苹果找漏洞赚25万美元。发家致富的好路子啊，哈哈。

================================================

关于为什么su一定要放到/system/bin/或者/system/xbin/

su不能放在data分区原因是因为data分区在mount时就指定了不能给可执行程序加s位。你在adb shell里执行mount就可以看到，或者看我下面的截图。

关于sudo

android的工程里没有sudo这个东西。sudo是为了给普通用户临时分配root权限的，Android里建立了很多用户，比如wifi,shell等等，这些用户可以访问那个文件，不可以访问那个文件，代码里已经写死了，权限也分配的很分明。它们在运行的过程中不需要临时获得root权限。所以Android不需要sudo这个程序。

补充阅读：

Android应用程序永久获取root权限方法：/article/3843398.html

二、ShellUtils工具类

搬运自Trinea大神的Github：https://github.com/Trinea/android-common/blob/master/src/cn/trinea/android/common/util/ShellUtils.java

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;

/**
* ShellUtils
* <ul>
* <strong>Check root</strong>
* <li>{@link ShellUtils#checkRootPermission()}</li>
* </ul>
* <ul>
* <strong>Execte command</strong>
* <li>{@link ShellUtils#execCommand(String, boolean)}</li>
* <li>{@link ShellUtils#execCommand(String, boolean, boolean)}</li>
* <li>{@link ShellUtils#execCommand(List, boolean)}</li>
* <li>{@link ShellUtils#execCommand(List, boolean, boolean)}</li>
* <li>{@link ShellUtils#execCommand(String[], boolean)}</li>
* <li>{@link ShellUtils#execCommand(String[], boolean, boolean)}</li>
* </ul>
*
* @author <a href="http://www.trinea.cn" target="_blank">Trinea</a> 2013-5-16
*/
public class ShellUtils {

public static final String COMMAND_SU       = "su";
public static final String COMMAND_SH       = "sh";
public static final String COMMAND_EXIT     = "exit\n";
public static final String COMMAND_LINE_END = "\n";

private ShellUtils() {
throw new AssertionError();
}

/**
* check whether has root permission
*
* @return
*/
public static boolean checkRootPermission() {
return execCommand("echo root", true, false).result == 0;
}

/**
* execute shell command, default return result msg
*
* @param command command
* @param isRoot whether need to run with root
* @return
* @see ShellUtils#execCommand(String[], boolean, boolean)
*/
public static CommandResult execCommand(String command, boolean isRoot) {
return execCommand(new String[] {command}, isRoot, true);
}

/**
* execute shell commands, default return result msg
*
* @param commands command list
* @param isRoot whether need to run with root
* @return
* @see ShellUtils#execCommand(String[], boolean, boolean)
*/
public static CommandResult execCommand(List<String> commands, boolean isRoot) {
return execCommand(commands == null ? null : commands.toArray(new String[] {}), isRoot, true);
}

/**
* execute shell commands, default return result msg
*
* @param commands command array
* @param isRoot whether need to run with root
* @return
* @see ShellUtils#execCommand(String[], boolean, boolean)
*/
public static CommandResult execCommand(String[] commands, boolean isRoot) {
return execCommand(commands, isRoot, true);
}

/**
* execute shell command
*
* @param command command
* @param isRoot whether need to run with root
* @param isNeedResultMsg whether need result msg
* @return
* @see ShellUtils#execCommand(String[], boolean, boolean)
*/
public static CommandResult execCommand(String command, boolean isRoot, boolean isNeedResultMsg) {
return execCommand(new String[] {command}, isRoot, isNeedResultMsg);
}

/**
* execute shell commands
*
* @param commands command list
* @param isRoot whether need to run with root
* @param isNeedResultMsg whether need result msg
* @return
* @see ShellUtils#execCommand(String[], boolean, boolean)
*/
public static CommandResult execCommand(List<String> commands, boolean isRoot, boolean isNeedResultMsg) {
return execCommand(commands == null ? null : commands.toArray(new String[] {}), isRoot, isNeedResultMsg);
}

/**
* execute shell commands
*
* @param commands command array
* @param isRoot whether need to run with root
* @param isNeedResultMsg whether need result msg
* @return <ul>
*         <li>if isNeedResultMsg is false, {@link CommandResult#successMsg} is null and
*         {@link CommandResult#errorMsg} is null.</li>
*         <li>if {@link CommandResult#result} is -1, there maybe some excepiton.</li>
*         </ul>
*/
public static CommandResult execCommand(String[] commands, boolean isRoot, boolean isNeedResultMsg) {
int result = -1;
if (commands == null || commands.length == 0) {
return new CommandResult(result, null, null);
}

Process process = null;
BufferedReader successResult = null;
BufferedReader errorResult = null;
StringBuilder successMsg = null;
StringBuilder errorMsg = null;

DataOutputStream os = null;
try {
process = Runtime.getRuntime().exec(isRoot ? COMMAND_SU : COMMAND_SH);
os = new DataOutputStream(process.getOutputStream());
for (String command : commands) {
if (command == null) {
continue;
}

// donnot use os.writeBytes(commmand), avoid chinese charset error
os.write(command.getBytes());
os.writeBytes(COMMAND_LINE_END);
os.flush();
}
os.writeBytes(COMMAND_EXIT);
os.flush();

result = process.waitFor();
// get command result
if (isNeedResultMsg) {
successMsg = new StringBuilder();
errorMsg = new StringBuilder();
successResult = new BufferedReader(new InputStreamReader(process.getInputStream()));
errorResult = new BufferedReader(new InputStreamReader(process.getErrorStream()));
String s;
while ((s = successResult.readLine()) != null) {
successMsg.append(s);
}
while ((s = errorResult.readLine()) != null) {
errorMsg.append(s);
}
}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (os != null) {
os.close();
}
if (successResult != null) {
successResult.close();
}
if (errorResult != null) {
errorResult.close();
}
} catch (IOException e) {
e.printStackTrace();
}

if (process != null) {
process.destroy();
}
}
return new CommandResult(result, successMsg == null ? null : successMsg.toString(), errorMsg == null ? null
: errorMsg.toString());
}

/**
* result of command
* <ul>
* <li>{@link CommandResult#result} means result of command, 0 means normal, else means error, same to excute in
* linux shell</li>
* <li>{@link CommandResult#successMsg} means success message of command result</li>
* <li>{@link CommandResult#errorMsg} means error message of command result</li>
* </ul>
*
* @author <a href="http://www.trinea.cn" target="_blank">Trinea</a> 2013-5-16
*/
public static class CommandResult {

/** result of command **/
public int    result;
/** success message of command result **/
public String successMsg;
/** error message of command result **/
public String errorMsg;

public CommandResult(int result) {
this.result = result;
}

public CommandResult(int result, String successMsg, String errorMsg) {
this.result = result;
this.successMsg = successMsg;
this.errorMsg = errorMsg;
}
}
}

三、检测手机是否root

此节参考资料：http://www.kuqin.com/shuoit/20140716/341252.html

方法一：执行su语句

su表示获取root权限，已经root的手机会弹出root请求对话框（我的MIUI 7测试时没有出现），体验不好。上述工具类用的也是此方法。

方法二：检测权限控制文件

一般root手机都会有一些的特殊文件夹，比如/system/bin/su，/system/xbin/su，里面存放有相关的权限控制文件。
但是某些国产手机如小米，未root也有这这些文件夹。此时需要从判断文件的权限入手。

Linux文件权限：



inux文件权限详细可参考《鸟叔的linux私房菜》http://vbird.dic.ksu.edu.tw/linux_basic/0210filepermission.php#filepermission_perm

在判断是否存在上述文件夹的前提下，再另外判断文件拥有者对这个文件是否具有可执行权限(第4个字符的状态)，即可确定手机是否已root。

代码如下：

public class RootUtils {
private final static String TAG = "RootUtils";

public static boolean isRoot() {
String binPath = "/system/bin/su";
String xBinPath = "/system/xbin/su";
if (new File(binPath).exists() && isExecutable(binPath)) {
return true;
}
if (new File(xBinPath).exists() && isExecutable(xBinPath)) {
return true;
}
return false;
}

private static boolean isExecutable(String filePath) {
Process p = null;
try {
p = Runtime.getRuntime().exec("ls -l " + filePath);
BufferedReader in = new BufferedReader(new InputStreamReader(p.getInputStream()));
String str = in.readLine();
Log.i(TAG, str);
if (str != null && str.length() >= 4) {
char flag = str.charAt(3);
if (flag == 's' || flag == 'x')
return true;
}
} catch (IOException e) {
e.printStackTrace();
}finally{
if(p!=null){
p.destroy();
}
}
return false;
}
}