Android设备上⾮root的抓包实现⽅法（Tcpdump⽅法）
通常我们在Android应⽤中执⾏某个命令时会使⽤“Runtime().exec("命令路径")”这种⽅式，但是当我们执⾏抓包操作时，使⽤这条命令⽆论如何都不⾏，通过下⾯代码打印结果发现，该命令⼀定要在root权限下才能执⾏。 BufferedReader brW = new BufferedReader(new ErrorStream()));
while((str = adLine()) != null)
Log.d("cwmp", "w:"+str);
但是我们的Android设备（包括机顶盒、⼿机等）通常并没有root过，apk的最⾼权限也只是system权限，这该怎么解决？⾸先我们要知道，⽅法总⽐问题多，在Android设备的/system/bin路径下，我们会看到很多⼆进制⽂件，这些⼆进制⽂件可以获得root权限。因此，我们可以通过C语⾔来实现抓包功能，通过NDK把该C代码交叉编译成⼆进制⽂件置于/system/bin路径下，并赋予其root权限，此时，这个⼆进制⽂件就具备了抓包能⼒了。现在问题⼜来了，我们现在是想通过apk去调⽤这个抓包指定，抓包完成后⼜该怎么通知apk呢？其实，Android可以通过socket使底层与framework层进⾏通信，具体请参考。
接下来我们将贴出关键实现代码。
1、编写socket服务端代码fstiService.cpp，⽣成可执⾏脚本fstiService
#define SOCKET_NAME "fstiService"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, "itv_assistance", __VA_ARGS__)
#include <jni.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <cutils/sockets.h>
改锥头
#include <android/log.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <pthread.h>
pthread_t thread[2];
char s_time[10]; //抓包时间⼦串
s3800char s_command[256]; //抓包指令⼦串
/
/抓包指令：system("/system/bin/tcpdump -v -w /sdcard/te.pcap");
//获取进程tcpdump的进程号
int getPid() {
//for Linux C
//FILE *fp = popen("ps -e | grep \'tcpdump\' | awk \'{print $1}\'", "r");
//for Android(ARM)
口袋领域//FILE *fp = popen("ps | grep \'tcpdump\'", "r");
FILE *fp = popen("ps | grep \'tcpdump\'", "r");
char buff[1024] = { 0 };
while (NULL != fgets(buff, sizeof(buff), fp))
;
/
/取消换⾏符(10)
buff[strlen(buff) - 1] = '\0';
pclose(fp);
char dst[5] = { 0 };
char *p = buff;
char *q = dst;
//每⼀⾏进程信息的第⼆个字符串为进程号
while (*p != ' ')
p++;
while (*p == ' ')
p++;
while (*p != ' ')
*(q++) = *(p++);
*(q++) = '\0';
return atoi(dst);
}
//截取⼦串(抓包时间(秒)：抓包命令)
void substring(char *time, char *command, char *src) {
char *p = src;
char *q = time;
char *s = command;
while (*p != '/')
*(q++) = *(p++);
*(q++) = '\0';
//如果Tcpdump命令已添加环境变量，则添加下⾏代码
//否则删除下⼀⾏代码，client传递的参数格式必须为: num/tcpdump所在路径 p++;
while (*p)
*(s++) = *(p++);
*(s++) = '\0';
}
//抓包线程
void *thread1(void *arg) {
system(s_command);
}
void *thread2(void *arg) {
int i_time = atoi(s_time);
int begin = time((time_t*) NULL);
while (1) {
if (time((time_t*) NULL) - begin < i_time) {
//printf("当前时间(s):%ld\n", time((time_t*)NULL));
continue;
} else {
int n = kill(getPid(), SIGKILL);
LOGD("the kill process result is n=%d", n);
break;
}
}
return 0;
}
//创建⼦线程
void thread_create() {
int temp;
memset(&thread, 0, sizeof(thread));
if ((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0)
LOGD("create tcpdump thread failure");
else
LOGD("create tcpdump thread success");
if ((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0)
LOGD("create count thread failure");
else
LOGD("create count thread success");
}
void thread_wait() {
if (thread[0] != 0) {
pthread_join(thread[0], NULL);
LOGD("tcpdump thread has terminated");
}
if (thread[1] != 0) {
//pthread_join(thread[1], NULL);
printf("counter thread has terminated");
}
}
泥浆比重试验/**
* Native层Socket服务端
*/
int main() {
int connect_number = 6;
int fdListen = -1, new_fd = -1;
int ret;
struct sockaddr_un peeraddr;
socklen_t socklen = sizeof(peeraddr);
int numbytes;
char buff[256];
//这⼀步很关键，就是获取中配置的名为 "fstiService" 的socket
fdListen = android_get_control_socket(SOCKET_NAME);
if (fdListen < 0) {
LOGD("failed to get socket '" SOCKET_NAME "' errno %d", errno);
exit(-1);
}
/**
* ⽅法说明：开始监听（等待参数fdListen的socket连接，参数connect_number指定同时能处理的最⼤连接要求）* 如果连接数⽬达此上限则client端将收到ECONNREFUSED的错误。listen函数并未开始连接，只是设置 * socket为listen模式，真正接收client端连接的是accept()。通常listen()会在socket()
* bind()之后调⽤，接着才调⽤accept().
* 返回值：成功返回0，失败返回-1，错误原因存在errno中
*/
ret = listen(fdListen, connect_number);
LOGD("listen result %d", ret);
if (ret < 0) {
/**
* perror(s)将⼀个函数发⽣错误的原因输出到标准设备（stderr）
* 参数s所指的字符串会先打印出，后⾯再加上错误原因字符串
*/
perror("listen");
exit(-1);
}
/**
* ⽅法说明：accept(int s, struct sockaddr * addr, socklen_t * addrlen)⽤来接受参数s的socket连接。
* socket必须先经bind()、listen()函数处理过，当有socket客户端连接进来时会返回⼀个新的socket处理
* 代码，往后的数据传送与读取就是经由新的socket处理，⽽原来参数s的socket能继续使⽤accept()来接受新的 * 连接请求。连线成功时, 参数addr 所指的结构会被系统填⼊远程主机的地址数据，参数addrlen为sockaddr的
* 结构长度。
* 返回值：成功返回新的socket处理代码，失败返回-1，错误原因存在于errno中。
*/
new_fd = accept(fdListen, (struct sockaddr *) &peeraddr, &socklen);
LOGD("accept_fd %d", new_fd);
if (new_fd < 0) {
LOGD("%d", errno);
perror("accept error");
exit(-1);
}
//循环等待Socket客户端发来消息
while (1) {
/**
* ⽅法说明：recv(int s, void *buf, size_t len, unsigned int flags)⽤来接收
* 客户端socket传来的数据，并把数据存到由参数buf指向的内存空间，参数len为可接收数据的最⼤长度。
* 参数flags⼀般设0
* 返回值：失败返回-1
*/
if ((numbytes = recv(new_fd, buff, sizeof(buff), 0)) == -1) {
LOGD("%d", errno);
perror("recv");
continue;
}
LOGD("the parameter received from socket client is %s", buff);
if(strcmp(buff, "exit") != 0){
substring(s_time, s_command, buff);
thread_create();
thread_wait();
}
char result[10] = "successp";
/**
* ⽅法说明：send(int s, const void *msg, size_t len, unsigned int flags)
* 参数s为已建⽴好连接的socket，参数msg指向欲发送的数据内容，参数len为数据长度，flags⼀般置0.
* 返回值：失败返回-1，错误原因存在errno中
*/
int sendR = send(new_fd, result, strlen(result), 0);
//apk退出后，buff中仍然缓存之前的调⽤命令，此时会额外再执⾏⼀次抓包，固下⾯代⽤重写buff中数据
strcpy(buff, "exit");
if (sendR == -1) {
perror("send");
close(new_fd);
exit(0);
}
}
close(new_fd);
close(fdListen);
return 0;
}
2、配置⽂件，添加如下配置
service fstiService /system/bin/fstiService
socket fstiService stream 777 system system
class main
此处配置了⼀个名为“fstiService”的服务，Android设备开机会⾃动启动并运⾏/system/bin/fstiService这个脚本⽂件。服务端代码完成后，我们需要将其编译成可执⾏脚本fstiService，Android.mk内容如下：
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
#指定该模块在所有版本下都编译
LOCAL_MODULE_TAGS :=optional
LOCAL_MODULE := fstiService
LOCAL_SRC_FILES := fstiService.cpp
LOCAL_LDLIBS := -llog
#编译成动态库
#include $(BUILD_SHARED_LIBRARY)
#编译成可执⾏⽂件
include $(BUILD_EXECUTABLE)
3、Android客户端代码
public class SocketClient {
private final String SOCKET_NAME = "fstiService";
private LocalSocket client = null;
private LocalSocketAddress address = null;
private boolean isConnected = false;
private int connectTime = 1;
public SocketClient(){
client = new LocalSocket();无缝内衣
//A socket in the Android reserved namespace in /dev/socket.
//Only the init process may create a socket here
address = new LocalSocketAddress(SOCKET_NAME, LocalSocketAddress.Namespace.RESERVED); new ConnectSocketThread().start();
}
/**
* 发送消息
* @param msg
* @return 返回Socket服务端消息回执
紫砂电饭锅
*/
public String sendMsg(String msg){
if(!isConnected)
return "Connect failure";
try{
BufferedReader in = new BufferedReader(new InputStream())); PrintWriter out = new OutputStream());
out.println(msg);
out.flush();
adLine();
}catch(IOException e){
e.printStackTrace();
}
return "Nothing Return";
}
/**
* Socket连接线程，若连接失败会尝试重连3次
* @author Administrator
*
*/
private class ConnectSocketThread extends Thread{
@Override
public void run() {
while(!isConnected && connectTime <= 3){
try{
sleep(1000);
Log.d("itv_assistance", "Try to connect socket; ConnectTime: "+connectTime);
isConnected = true;
}catch(Exception e){
connectTime++;
isConnected = false;
Log.d("itv_assistance", "Connect Failure");
}
}
}
}
/**
* 关闭Socket
*/
public void closeSocket(){
try{
client.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
⾄此，基于⾮root的Android设备上的抓包实现⽅法就完成了，接下来就是编译系统进⾏测试了，这步我没有亲⾃去做，⽽是把fstiService脚本及配置⽂件的操作交给合作⼚商来做了，apk是我们⾃⼰做的，经测试⼀切OK。
以上所述是⼩编给⼤家介绍的Android设备上⾮root的抓包实现⽅法(Tcpdump⽅法)，实现⼀个模拟后台数据登⼊的效果，希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。在此也⾮常感谢⼤家对⽹站的⽀持！
